数据库关联
最简单的关联关系： 一对多。
例如: 王妈妈， 有两个孩子：小明 和 小亮。
可以说： 王妈妈， 有多个孩子。
也可以说:
小明，有一个妈妈。 小王，有一个妈妈。
用数据库结构来表示
如果不考虑表间关系的话, 有两个表 妈妈 (mothers) 和 儿子 (sons):
mothers 表:
id name
1 王妈妈
sons 表:
id name
100 小王
101 小明
那么， 如何在数据库中， 设计表间关系呢？
为某个相关的表，增加列。 （数据库么，就是保存数据的。 关系也是一种数据 )
所以， 一对多关系， 要在 "多" 的一端， 增加一列.
增加了外键的 sons 表:
id name mother_id
100 小王 1
101 小明 1
上面的 mother_id 列， 就是外键。(foreign key)
表示： 该行， 对应 mother 表中的某个记录
唯一作用就是： 记录了 表间关系。
外键的值，其实是另一个表的 id 的值。
用 SQL 来表示。
select * from mothers
join sons
on sons.mother_id = mothers.id
where sons.id = 1
用持久层 (ruby 代码) 来表示
一个妈妈可以有多个孩子:
class Mother
has_many :sons
end
一个儿子属于一个妈妈:
class Son
belongs_to :mother
end
然后，我就可以在 Rails Console 中：
> xiao_wang = Son.first
就会生成 SQL：
select * from sons where id = 1;
我们还可以轻易的从 xiao_wang 找到他的妈妈:
mama = xiao_wang.mother
这个 .mother 方法就是由 class Son 的 belongs_to :mother 这句话生成的。
上面的代码会被转换成下面的 SQL 语句, 然后被执行.
select * from mothers
join sons
on sons.mother_id = mothers.id
where sons.id = 1
如何 根据 配置，来自动生成上面的复杂的 SQL 语句的？
最初的配置：
belongs_to :mother
等同于下面的：
belongs_to :mother, :class => 'Mother', :foreign_key => 'mother_id'
可以看出，这个就是 Rails 最典型的 根据 惯例来编程。
- belongs_to :mother, rails 就能判断出： mothers 表，是一的那一端。 而当前 class 是： “class Son”, 那么 rails 就知道了 两个表的对应关系。
- :class => 'Mother', 表示， 一的那一端， 对应的 model class 是 Mother. 根据 rails 的惯例， Mother model 对应的是 数据库中的 mothers 表。
- :foreign_key => 'mother_id', rails 就知道了， 外键是 'mother_id'. 而一对多关系中， 外键是保存在 多的那一端（也就是 sons)
所以， 这个复杂的 SQL 条件就齐备了， 可以生成了。
上面的 ruby 代码，配置好之后， 就可以这样调用：
Son.first.mother # .mother方法， 作用在 son 上。 是由 class Son 中的 belongs_to 产生的。
Mother.first.sons # .sons 方法， 作用在 mother上， 是由 class Mother 中的 hash_many 产生的。
一对一： 一对多的特例。
一对多： has_many/belongs_to
一对一： has_one/belongs_to
老婆和老公的例子:
一个老婆： 有一个老公
class Mother
belongs_to :father
end
一个老公： 有一个老婆。
class Father
has_one :mother
end
mothers 表
id name
1 王妈妈
fathers 表
id name
200 李爸爸
那么，外键， 放在哪个表都可以。 (我们可以在 mothers 表，增加一个列， 叫 father_id, 也可以在 fathers 表，增加一个列， 叫 mother_id)
多对多：
一个学生， 有多个老师 （ 学习了多门课程） 一个老师，可以教多个孩子 （教一门课程，但是有好多学生来听这个课程）
表结构
students , 学生表
id name
1 小王
2 小明
3 小红
teachers, 老师表
id name
100 王老师
200 李老师
目前看来， 把外键，放在任何一个表中都不满足需求。 所以，需要中间表。
lessons 中间表
id name student_id teacher_id
1000 物理课 1(小王id) 100(王老师）
2000 物理课 2(小明id) 100(王老师）
3000 物理课 3(小红id) 100(王老师）
4000 化学课 1(小王id) 200(李老师）
5000 化学课 3(小红id) 200(李老师）
从上表中，可以看出，
王老师， 上的是物理课， 教了 3 个孩子： 小王，小明和小红
李老师， 上的是化学课， 教了 2 个孩子： 小王和小红。
传统的 SQL 语句, 其实很麻烦的.
小王都有哪些老师？ ( 一个 SQL 例子）
select teachers.*, students.*, lessons.*
from lessons //因为找的是老师，我们就要 from teachers ,
join teachers
on lessons.teacher_id = teachers.id // 通过中间表，把老师 join 弄过来
join students
on lessons.student_id = students.id // 通过中间表，把学生 join 弄过来
where students.name = '小王'
这个 复杂的 SQL 会生成下面的表：
teachers. id teachers. name students. id students. name lessons. id lessons. name lessons. student_id lessons. teacher_id
100 王老师 1 小王 1000 物理成绩 1 100
100 王老师 2 小明 2000 物理成绩 2 100
100 王老师 3 小红 3000 物理成绩 3 100
200 李老师 1 小王 4000 化学成绩 1 200
200 李老师 3 小王 5000 化学成绩 3 200
跟下面的表是严格相对的：
id name student_id teacher_id
1000 物理成绩 1(小王id) 100(王老师）
2000 物理成绩 2(小明id) 100(王老师）
3000 物理成绩 3(小红id) 100(王老师）
4000 化学成绩 1(小王id) 200(李老师）
5000 化学成绩 3(小红id) 200(李老师）
用代码来表示
class Student
has_many :lessons
has_many :teachers, :through => :lessons
# 上面的简写， 相当于：
has_many :teachers, :class => 'Teacher', :foreign_key => 'teacher_id', :throught => :lessons
end
```ruby
class Teachers
has_many :lessons
has_many :students, :through => :lessons
end
上面的代码定义完之后，就可以实现这个了：
小王都有哪些老师？ ( 同 SQL 例子）
Student.find_by_name('小王').teachers
(如果你不需要 查询： 王老师，有哪些学生？， 就不需要定义 class Teacher 里的 has_many :students) 所以说，rails 中的定义，非常灵活。 但是， 实战中， 建议都老老实实的加上。 这样 当你的同事， 如果之前哪怕不知道有 student 这个 model, 但是，看到了 teacher 这个 model, 也就直到了 teacher 与 student 的关系了。
另外，从实现模式的角度讲， 也要两端都加上这个 has_many 的声明。
- 什么是实现模式呢？ 我们连接数据库：有
connection.start就要有connection.close - 对于一些回调函数, 有
before, 就要有after对于一些回调函数, 有success, 就要有error/fail
不建议
- 表名不明确。 不要使用 a_bs 这样的表名。对应 model 比较难写。 (app/models/a_b.rb 吗？)
- 任何一个中间表，都是有意义的。 90% 的时候，中间表， 是有正常的列的。与其后期通过 migration 加上这个列， 不如 一开始，就不要使用 has_many_and_belongs_to 这样的方式来声明（声明之后， model 的名字就定下来了。难改）
多对多的关联时，对中间表的命名。
- 确定两个对象是多对多的关系
- 就肯定有个中间表
- 再给中间表起个名字。
中间表，一定要有名字。 不能叫： 中间表 1， 中间表 2.
如果 A ： B = N ： N
有个不太好用，但是也将就能用的模式： A_Bs , 例如： student_teachers. 但是它不如： lessons 好用。
好的名字:
- 商品 与 顾客 的中间表是 订单
- 学生 与 老师 的中间表是 课程 (或成绩)
has_many 与 belongs_to 会自动生成一系列的方法
例如：
mother has_many :sons.
Mother 自动获得了 16 个方法： 把下面的 collection 换成 sons 就行了。）
wangmama = Mother.first
会生成下列方法 :
API 原文 对于我们上面的例子
collection(force_reload = false) wangmama.sons
collection<<(object, ...) wangmama.sons << Son.create({... })
collection.delete(object, ...) wangmama.sons.delete
collection.destroy(object, ...) wangmama.sons.destroy
collection=objects wangmama.sons=
collection_singular_ids wangmama.son_id
collection.create(attributes = {}) wangmama.sons.create(...)
总共16个. 其他的略.
不过, 这些方法中, 常用的只有一两个. 大家可以参考文档.
destroy 与 delete 区别？
destroy: 会删掉 关联表的 数据（通过调用关联表的方法）
delete : 不会。 只会删掉当前对象对应的表。
例子：
老王去世了。 老王有 20 张银行卡。
如果： 我们是上帝。 我们就可以这样写：
laowang.destroy (老王的银行卡也会被删掉）
laowang.delete （只删掉老王， 保留银行卡）
级联删除
级联删除, 就是我们把一对多中, “一 "的那一端删掉, 那么" 多 " 的那一端的所有关联数据, 也要一起删掉.
在 Rails 中, 我们使用 dependency => :destroy 来实现.
例如: 某个人去世后, 他的银行卡应该都被注销掉. 那么就可以这样写:
class Person
has_many :cards
end
```ruby
class Card
# 下面这句，表示： person一旦被删除， 该card也会自动被删除。
belongs_to :person, :dependency => :destroy
end
实战中，不要用级联删除。（不要一条命令，删掉多个表的数据）
- 好处： 删的比较干净。 很清爽。
- 缺点： 大项目， 公司内的项目， 一般都不允许删除。 很多项目，用“禁用” 来代替删除。
例子：
论坛 有用户。 用户会发好多帖子。 假如某天， 用户老王不在了。 他还会发好多帖子。 这些帖子， 有好多人回帖。 问题： 如果删了老王，和老王的帖子。 其他人的回帖怎么办？ 所以： 不要删帖，不要删用户。 在用户管理中，把老王 “禁用”(disabled)
(在大公司中， 删东西，特别慎重。 宁可不删， 宁可占用空间， 也不作删除。)
我们对关联的表进行删除操作的时候， 两种写法：
- 级联删除特点： 代码少。
# cards 也跟着删掉。 cards 的关联对象也会被删掉.
Person.first.destroy
- 手动删除特点：删掉哪个，一目了然。
laowang = Person.first
laowang.cards.delete
laowang.delete
一般项目中， 表跟表，关联关系，都是比较复杂的。 往往是一环套一环
A : B = 1 : n
B : C = 1 : n
C : D = 1:n
我删掉一个 A, 你确定， b, c, d 都要跟着删吗？ 那时候，class 一多，你是记不住： 哪个 has_many/belongs_to 中，包含了 dependency => :destroy
评论区