MySQL填写剩余余额！
MySQL填写剩余余额！
我正在尝试计算剩余余额并将其存储在我的表中的记录中。这很复杂，因为我需要存储它的地方在表格本身。这是一个解释：
Accounts_Table
╔═════════╦═══════╗
║ Account ║ Total ║
╠═════════╬═══════╣
║ A ║ $1000 ║
╠═════════╬═══════╣
║ B ║ $800 ║
╠═════════╬═══════╣
║ C ║ $1200 ║
╚═════════╩═══════╝
Detail_Table
╔═════════╦══════╦══════╦═════════╗
║ Account ║ Line ║ Type ║ Amount ║
╠═════════╬══════╬══════╬═════════╣
║ A ║ 001 ║ E ║ $200.00 ║
╠═════════╬══════╬══════╬═════════╣
║ A ║ 002 ║ E ║ $300.00 ║
╠═════════╬══════╬══════╬═════════╣
║ A ║ 003 ║ E ║ $100.00 ║
╠═════════╬══════╬══════╬═════════╣
║ A ║ 004 ║ R ║ ║
╠═════════╬══════╬══════╬═════════╣
║ B ║ 001 ║ E ║ $300.00 ║
╠═════════╬══════╬══════╬═════════╣
║ B ║ 002 ║ R ║ ║
╠═════════╬══════╬══════╬═════════╣
║ C ║ 001 ║ R ║ ║
╚═════════╩══════╩══════╩═════════╝
我想要做的是将与每个账户匹配的所有金额相加，找出该金额与账户总金额之间的差额，然后在金额列中记录剩余余额，其中类型列= R.
因此，例如，帐户A的类型R行将填充400.00美元，即（$ 1000.00 - （$ 300.00 + $ 200.00 + $ 100.00））。
所以我的结果看起来像：
╔═════════╦══════╦══════╦══════════╗
║ Account ║ Line ║ Type ║ Amount ║
╠═════════╬══════╬══════╬══════════╣
║ A ║ 001 ║ E ║ $200.00 ║
╠═════════╬══════╬══════╬══════════╣
║ A ║ 002 ║ E ║ $300.00 ║
╠═════════╬══════╬══════╬══════════╣
║ A ║ 003 ║ E ║ $100.00 ║
╠═════════╬══════╬══════╬══════════╣
║ A ║ 004 ║ R ║ $400.00 ║
╠═════════╬══════╬══════╬══════════╣
║ B ║ 001 ║ E ║ $300.00 ║
╠═════════╬══════╬══════╬══════════╣
║ B ║ 002 ║ R ║ $500.00 ║
╠═════════╬══════╬══════╬══════════╣
║ C ║ 001 ║ R ║ $1200.00 ║
╚═════════╩══════╩══════╩══════════╝
这就是我现在所处的位置。这不起作用，并且引发了一个关于更新我正在阅读的同一个表的错误，更不用说我甚至不确定我是否正确地接近了这个问题：
UPDATE Detail_Table
INNER JOIN Accounts_Table
ON Detail_Table.Account = Accounts_Table.Account
SET
Detail_Table.Amount = Accounts_Table.Total - (SELECT SUM(Amount) FROM Detail_Table AS TempTable WHERE TempTable.Account = Accounts_Table.Account)
WHERE
Detail_Table.Type = 'R'
AND
Detail_Table.Amount IS NULL;
MySQL填写剩余余额
1 个回答
用户回答回答于 2018-08-30
执行计算的查询是：
select a.account, ( a.total - coalesce(sum(d.amount), 0) ) as balance
from accounts_table a join
detail_table d
on a.account = d.account and d.type = 'E'
group by a.account, a.total;
有了这个，只需加入：
update detail_table d join
(select a.account, ( a.total - coalesce(sum(d.amount), 0) ) as balance
from accounts_table a join
detail_table d
on a.account = d.account and d.type = 'E'
group by a.account, a.total
) b
on d.account = b.account
set d.amount = b.balance
where d.type = 'R';
以上就是今天要分享的技巧，你学会了吗？若有什么问题，欢迎在下方留言。
一、基础
1. 变量
1.1 val：value给了初始值不能改变（通常情况下，先用这个）(像vue中的const)（java需要在变量前声明 final )
1.2 var：variable值可以改变
val var
tips: kotlin 有类型推导机制，会自动推断类型 （变量延迟赋值就需要显示声明）
1.3 类型（kotlin是对象数据类型，java是基本数据类型）
Int: 整型
Long: 长整型
Short: 短整型
Float: 单精度浮点型
Double: 双精度浮点型
Boolean: 布尔型
Char: 字符型
Byte: 字节型 （例如：0101）
2. 函数 function（一个行为，里面放了代码块） Method
// fun:定义 customFun:函数名 ():接受参数 (num):接受参数名 (:Int):接受参数类型 :Int:函数返回类型
fun customFun(num1:Int,num2:Int):Int{
val result=num1+num2
println("num1+num2=$result")
return result
}
function
3. 逻辑控制
3.1 顺序语句
3.2 条件语句
3.2.1 选择
3.2.1.1 if 语句
if else
3.2.1.2 when 语句
val score =60
val score1 =when(score){
in 0..59 -> {
"未及格"
}
in 60..100-> {
"及格了"
}
else-> {
"这是啥"
}
}
when
3.3.循环语句
3.3.1 双端闭区间 [ ]
for (i in 1..10) { print(i) }
3.3.2 单端闭区间 until [ )
for (i in 1 until 10) { print(i) }
3.3.3 跳跃 step
for (i in 1 ..10 step 3) { print(i) }
3.3.4 降序 downTo [10,1]
for (i in 10 downTo 1) { print(i) }
4. 面向对象
4.1 类与对象
4.1.1 类：包括属性和函数
类
4.2 继承
4.2.1 被继承的类需要在开头添加 open ，然后子类构造函数去调用父类构造函数，继承多个用逗号隔开就行
4.3 构造函数
类实例化的工具，出厂就有一些设置 ，有两种，主构造函数和次构造函数(几乎很少用，被替代性很高 )
4.3.1 主构造函数(没有函数体)
如果想在主构造函数里写逻辑，可以使用 init 对象
4.3.2 次构造函
4.4 接口和多态
4.4.1 接口：我们在接口中定义一系列抽象的方法，然后在具体的子类中去实现
4.4.2 多态：面向接口编程（接收接口的所有）
4.5 修饰符
public: 所有类可见
pravate: 当前类可见
protected: 当前类、子类可见
default: java的kotlin没有
internal: 同意模块中的类可见（java没有这个）
4.6 数据类
关键字：data （kolin 中的数据类 equal hashcode toString 全整好了，短短一行）
data class Dog(val name:String,val color: Color)
4.7 单例类
关键字：object （永远只有一个实例对象）
object Account{
fun accountInfo(){
println("这是一个实例类的方法")
}
}
5. Lambda
（目前感觉像是一个对象，备注给自己看的哈）
5.1 集合
集合的函数式 API 是入门 Lambda 编程的绝佳示例。
5.1.1 list/set 类
5.1.2 map类 键值对
5.2 集合的函数式 API
5.2.1 定义：一小段可以作为参数传递的代码
5.2.2 语法结构：{ 参数名：参数类型，参数名：参数类型 -> 函数体}
5.2.3 参数：外面传递进来
6. 空指针检查
6.1 什么是 NPE ？
NullPointerException 是Bug,系统崩溃率最高
原因：因为空指针是一种不受编程语言检查的运行时异常，只能由程序员主动通过逻辑判断来避免，但即使是最出色的程序员，也不可能将所有潜在的控制正异常全部考虑到。
6.2 kotlin默认所有参数和变量都不可为空，将空指针异常的检查 提前到了编译期
6.3 判空辅助工具
6.3.1 ?. -> 当对象不为空时正常调用相应的方法，当对象为空时则什么都不做
study?.readBooks()
6.3.2 ?: -> 如果左边表达式不为空就返回左边表达式的结果，否则就返回右边表达式的结果
val c =a?:b
6.3.3 !! -> 函数外做了非空处理，函数内部需要用它来强制执行
7. let 函数
（kotlin标准函数）既可以配合辅助判空问号，又可以解决全局变量问题，是可以处理全局变量的判空问题的，而if判断语句则无法做到这一点。
8. 字符串内嵌表达式/函数的参数默认值
8.1 字符串内嵌表达式
println("see ${a+b} see$b")
8.2 函数的参数默认值
用函数穿惨随意 -> 代替次构造函数
val JJJ = Boy(height = 100)
data class Boy(val name:String ="" ,val age:Int =0 ,val height:Int)
二、进阶
1. 标准函数
1.1 with：对同一个对象有很多操作时使用。
whit 函数接收两个参数：第一个参数可以时一个任意类型的对象，第二个参数时一个Lambda表达式。with 函数会在Lambda中提供一个参数对象的上下文，并使用Lambda表达式中的最后一行代码作为返回值返回。
val resultWith =with(StringBuilder()){
// obj上下文
append("startWith:\n")
for (s in list) {
append(s).append("\n")
}
append("over!")
toString() //whit 函数的返回值
}
1.2 run：对同一个对象有很多操作时使用。
在某个对象的基础上调用；run函数值接收一个Lambda参数，并且会在Lambda表达式中提供调用的上下文，并使用Lambda表达式中的最后一行代码作为返回值返回。
val resultRun = StringBuilder("startRun:\n").run{
// obj上下文
for (s in list) {
append(s).append("\n")
}
append("over!")
toString() //run 函数的返回值
}
1.3 apply：对同一个对象有很多操作时使用。
在某个对象的基础上调用；applt 函数值接收一个Lambda参数，并且会在Lambda表达式中提供调用的上下文，返回值是调用对象本身。
val resultApply = StringBuilder("startApply:\n").apply{
// obj上下文
for (s in list) {
append(s).append("\n")
}
append("over!")
toString() //apply 函数的返回值
}
with_run_apply函数
2. 静态函数
2.1 单例类：整个类中的所有方法全部变成类似于静态方法的调用方式。（Kotlin 用单例类代替了静态属性）
2.2 companion object：类中的某一个方法变成类似于静态方法调用方式。（companion object 实际上实在类中创建一个伴生类，companion object 包裹的方法就是定义在这个伴生类里面的实例方法）
2.3 注解 @JvmStatic：只能加载单例类或 companion object 中的方法上，如果你尝试加载一个普通方法上，会直接提示语法错误。
2.4 顶层方法：没有定义在任何类中的方法，直接创建一个Kotlin 的文件，然后在这个文件中直接写的都是顶层方法。这个在Kotlin中随便在哪，都可以直接调用顶层方法。
tip: 注解和顶层方法是真正的静态方法。
作者：A前A程
链接：https://www.jianshu.com/p/8826f46f0819
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
共有 0 条评论