精华内容
下载资源
问答
  • 一、前言研究表与表之间的关系前,先要知道将所有数据存放在一张表中的弊端:1.结构不清晰 ---> 不致命2.浪费空间 ---> 不致命3.可扩展性极差 ---> 不可忽视的弊端就i好比将所有的代码存放在一文件中,强...

    一、前言

    研究表与表之间的关系前,先要知道将所有数据存放在一张表中的弊端:

    1.结构不清晰 ---> 不致命

    2.浪费空间 ---> 不致命

    3.可扩展性极差 ---> 不可忽视的弊端

    就i好比将所有的代码存放在一个文件中,强耦合到了一起,而我们需要做的就是 ----> 解耦合 ----> 拆分表

    拆分表解决以上问题.

    需要给两张表之间,建立一种强有力的关系, 使用 “外键”。

    foreign key(外键): 用来建立两张表之间的关系

    一对多

    多对多

    一对一

    foreign key(外键)语法:

    foreign key(当前表中建立关系的外键字段) references 被关联表名(id)

    二、表与表之间的关系

    (一) 一对多

    一对多(左边表的多条记录对应右边表的唯一一条记录)

    注意:必须先建立被关联表,再建立关联表

    例如:定义一张员工部门表

    id,name,gender,dep_name

    注意: 要确定两张表之间的关系,必须站在两个位置去思考:是否是单向多对一还是双向多对一,还是一一对应的关系。

    站在员工表的位置:多个员工能否对应一个部门?(能)

    员工与部门:多对一(员工表单向 多对一 部门表)

    站在部门表的位置:多个部门能否对应一个员工?(不能)

    总结:凡是单向 多对一的表关系,称之为 一对多 的外键关系,如下图所示

    93e267caf4dbfc7871bc309ac522d0ef.png

    创建两张表:

    #被关联表:

    dep:

    create table dep(

    id int primary key auto_increment,

    dep_name varchar(16),

    dep_desc varchar(255));

    #关联表:

    emp:

    create table emp(

    id int primary key auto_increment,

    name varchar(6),

    age int,

    gender enum('male','female'),

    dep_id int not null,

    foreign key(dep_id) references dep(id));

    #插入数据:必须先插入被关联表(dep)的数据,再插入关联表(emp)的数据。

    #插入dep的数据:

    insert into dep(dep_name,dep_desc) values(

    'nb_外交部', '国际形象大使部门'),

    ('sb_教学部', '造程序员部门!!!!'),

    ('技术部', '技术有限部门');

    #插入emp的数据:

    insert into emp(name, age, gender, dep_id)

    values('tank', 17, 'male', 1),

    ('jason', 70, 'male', 2),

    ('sean', 50, 'male', 2),

    ('egon', 88, 'male', 2),

    ('owen', 95, 'female', 3);

    # 报错

    insert into emp(name, age, gender, dep_id) values(

    'baohan', 18, 'others', 999);

    更新数据:

    update emp set dep_id=100 where id=2; #报错

    update dep set id=100 where id=1; #报错

    # 要先删除已关联的dep_id字段,才能修改dep表中的关联id字段。

    delete from emp where id=1;

    update dep set id=100 where id=1;

    mysql> select * from emp;

    +----+-------+------+--------+--------+

    | id | name | age | gender | dep_id |

    +----+-------+------+--------+--------+

    | 2 | jason | 70 | male | 2 |

    | 3 | sean | 50 | male | 2 |

    | 4 | egon | 88 | male | 2 |

    | 5 | owen | 95 | female | 3 |

    +----+-------+------+--------+--------+

    mysql> select * from dep;

    +-----+--------------+--------------------------+

    | id | dep_name | dep_desc |

    +-----+--------------+--------------------------+

    | 2 | sb_教学部 | 造程序员部门!!!! |

    | 3 | 技术部 | 技术有限部门 |

    | 100 | nb_外交部 | 国际形象大使部门 |

    +-----+--------------+--------------------------+

    删除:先删除关联表中的记录,再删除被关联表中的记录

    #先删除emp表中的dep_id为2的记录

    delete from emp where dep_id=2;

    #再删除dep表中id为2的记录

    delete from dep where id=2;

    mysql> select * from emp;

    +----+------+------+--------+--------+

    | id | name | age | gender | dep_id |

    +----+------+------+--------+--------+

    | 5 | owen | 95 | female | 3 |

    +----+------+------+--------+--------+

    mysql> select * from dep;

    +-----+--------------+--------------------------+

    | id | dep_name | dep_desc |

    +-----+--------------+--------------------------+

    | 3 | 技术部 | 技术有限部门 |

    | 100 | nb_外交部 | 国际形象大使部门 |

    +-----+--------------+--------------------------+

    2035cd0bec18c60e5251ad16d6461970.png

    0a1ded4a503595337bb5e4f84c93a03d.png

    级联更新与级联删除

    on update cascade 级联更新

    on delete cascade 级联删除

    意思是 当更新或删除主键表时,那么外键表也会跟随一起更新或删除

    再以上述例子为例:

    创建两张表:

    #被关联表:

    dep:

    create table dep(

    id int primary key auto_increment,

    dep_name varchar(16),

    dep_desc varchar(255));

    #关联表:

    emp:

    create table emp(

    id int primary key auto_increment,

    name varchar(6),

    age int,

    gender enum('male', 'female'),

    dep_id int not null,

    foreign key(dep_id) references dep(id)

    on update cascade

    on delete cascade

    );

    #插入数据:必须先插入被关联表(dep)的数据,再插入关联表(emp)的数据。

    #插入dep的数据:

    insert into dep(dep_name,dep_desc) values(

    'nb_外交部', '国际形象大使部门'),

    ('sb_教学部', '造程序员部门!!!!'),

    ('技术部', '技术有限部门');

    #插入emp的数据:

    insert into emp(name, age, gender, dep_id)

    values('tank', 17, 'male', 1),

    ('jason', 70, 'male', 2),

    ('sean', 50, 'male', 2),

    ('egon', 88, 'male', 2),

    ('owen', 95, 'female', 3);

    更新数据或删除数据:

    #更新记录:

    update dep set id=200 where id=1;

    mysql> select * from dep;

    +-----+--------------+--------------------------+

    | id | dep_name | dep_desc |

    +-----+--------------+--------------------------+

    | 2 | sb_教学部 | 造程序员部门!!!! |

    | 3 | 技术部 | 技术有限部门 |

    | 200 | nb_外交部 | 国际形象大使部门 |

    +-----+--------------+--------------------------+

    #删除记录

    delete from dep where id=200;

    mysql> select * from dep;

    +----+--------------+------------------------+

    | id | dep_name | dep_desc |

    +----+--------------+------------------------+

    | 2 | sb_教学部 | 造程序员部门!!!! |

    | 3 | 技术部 | 技术有限部门 |

    +----+--------------+------------------------+

    (二) 一对一

    一对一:两张之间的关系 一一对应,将一张数据量比较大的表,拆分成两张表。

    例如:数据量比较大的用户表

    用户表:多个用户 能否 对应 一个用户详情信息? 不能

    用户详情表:多个用户详情信息 能否 对应 一个用户? 不能

    两张表之间都没有多对一的关系,就是“一对一”的外键关系。

    总表:user_info

    id, name, age, gender, hobby, id_card

    分表:user:

    id , name, age, detail_id(外键)

    分表:detail:

    id, gender, hobby, id_card

    注意:1、user与detail表建立了 一对一的外键 关系。

    2、foreign key 应该建在 使用频率较高的一方。

    aaa6efcfdfe72059df7f8869ff1d72ce.png

    创建表:

    #被关联表

    detail

    create table detail(

    id int primary key auto_increment,

    gender enum('male', 'female'),

    hobby varchar(32),

    id_card char(18)

    );

    #关联表

    user

    create table user(

    id int primary key auto_increment,

    name varchar(6),

    age int,

    detail_id int unique,

    foreign key(detail_id) references detail(id)

    on update cascade

    on delete cascade

    );

    #插入数据

    insert into detail(gender, hobby,id_card) values

    ('male','play ball',9527),

    ('female','rap',909),

    ('female','吃鸡',101),

    ('female','被吃鸡',404),

    ('female','HSNM',500

    );

    insert into user(name,age,detail_id) values

    ('tank', 17,3),

    ('egon', 77,5),

    ('jason', 87,1),

    ('sean', 97,2),

    ('owen', 107,4);

    # 报错,一对一,关系必须 一一对应

    insert into user(name,age,detail_id) values ('baohan',19,3);

    mysql> select * from user;

    +----+-------+------+-----------+

    | id | name | age | detail_id |

    +----+-------+------+-----------+

    | 1 | tank | 17 | 3 |

    | 2 | egon | 77 | 5 |

    | 3 | jason | 87 | 1 |

    | 4 | sean | 97 | 2 |

    | 5 | owen | 107 | 4 |

    +----+-------+------+-----------+

    mysql> select * from detail;

    +----+--------+-----------+---------+

    | id | gender | hobby | id_card |

    +----+--------+-----------+---------+

    | 1 | male | play ball | 9527 |

    | 2 | female | rap | 909 |

    | 3 | female | 吃鸡 | 101 |

    | 4 | female | 被吃鸡 | 404 |

    | 5 | female | HSNM | 500 |

    +----+--------+-----------+---------+

    (三) 多对多

    多对多:一个作者可以写多本书,一本书也可以有多个作者,双向的一对多,即 多对多的外键关系

    关联方式:foreign key + 一张新的表

    要把book_id和author_id设置成唯一

    6e01aca6d7206f5100099cf9744e1caf.png

    - 多对多:

    也必须站在两张表的位置去思考;

    - 错误示范:

    - 创建book表

    create table book(

    id int primary key auto_increment,

    title varchar(20),

    price int,

    book_content varchar(255),

    author_id int,

    foreign key(author_id) references author(id)

    on update cascade

    on delete cascade

    );

    - 创建author表

    create table author(

    id int primary key auto_increment,

    name varchar(16),

    age int,

    book_id int,

    foreign key(book_id) references book(id)

    on update cascade

    on delete cascade

    );

    - 问题: 无法知道哪张表是被关联表

    b798c3552ea59661834121a4f498fa05.png

    正确示范:

    - 利用第三张表,为两张表建立“多对多外键关系”。

    book:

    create table book(

    id int primary key auto_increment,

    title varchar(20),

    price int,

    book_content varchar(255));

    author:

    create table author(

    id int primary key auto_increment,

    name varchar(16),

    age int);

    book2author:

    create table book2author(

    id int primary key auto_increment,

    book_id int,

    author_id int,

    foreign key(book_id) references book(id)

    on update cascade

    on delete cascade,

    foreign key(author_id) references author(id)

    on update cascade

    on delete cascade

    );

    #插入数据

    - book

    insert into book(title, price, book_content) values

    ('金瓶mei', 199, '讲述朦胧时光的小故事'),

    ('python从入门到断气', 2000, '学习如何一夜秃头'),

    ('三体', 200, '跟着大佬进入宇宙奇幻世界');

    - author

    insert into author(name, age) values

    ('egon', 68),

    ('jason', 88);

    - book2author:

    insert into book2author(book_id, author_id) values

    (1, 1),

    (1, 2),

    (2, 2),

    (3, 1);

    # 报错, 插入的数据,book_id, author_id必须存在

    insert into book2author(book_id, author_id) values (4, 4);

    # 更新或删除

    # 更新

    - update book set price=6666 where id=1;

    - update book set id=4 where id=1;

    # 删除

    - delete from book where id=4;

    展开全文
  • 而外键是用于在两个表数据之间建立和加强链接一列或多列组合,可控制可在外键表中存储数据。本教程操作环境:windows7系统、mysql5.8版、Dell G3电脑。数据库表与表之间通过主外键来建立联系。主键约束表...

    数据库表与表之间通过主外键来建立联系。如果为表指定了主键约束, 数据库引擎将通过为主键列自动创建唯一索引来强制数据的唯一性;而外键是用于在两个表中的数据之间建立和加强链接的一列或多列的组合,可控制可在外键表中存储的数据。

    324e8a4849177d749aef9ddaf0bd2a62.png

    本教程操作环境:windows7系统、mysql5.8版、Dell G3电脑。

    数据库表与表之间通过主外键来建立联系。

    主键约束

    表通常具有包含唯一标识表中每一行的值的一列或一组列。 这样的一列或多列称为表的主键 (PK),用于强制表的实体完整性。 由于主键约束可保证数据的唯一性,因此经常对标识列定义这种约束。

    如果为表指定了主键约束, 数据库引擎 将通过为主键列自动创建唯一索引来强制数据的唯一性。 当在查询中使用主键时,此索引还允许对数据进行快速访问。 如果对多列定义了主键约束,则一列中的值可能会重复,但来自主键约束定义中所有列的值的任何组合必须唯一。

    如下图所示, Purchasing.ProductVendor 表中的 ProductID 和 VendorID 列构成了针对此表的复合主键约束。 这确保了 ProductVendor 表中的每个行都具有 ProductID 和 VendorID 的一个唯一组合。 这样可以防止插入重复的行。

    ff055ba5295d231f96124dbbf6b63bbc.gif一个表只能包含一个主键约束。

    主键不能超过 16 列且总密钥长度不能超过 900 个字节。

    由主键约束生成的索引不会使表中的索引数超过 999 个非聚集索引和 1 个聚集索引。

    如果没有为主键约束指定聚集或非聚集索引,并且表中没有聚集索引,则使用聚集索引。

    在主键约束中定义的所有列都必须定义为不为 Null。 如果没有指定为 Null 性,则参与主键约束的所有列的为 Null 性都将设置为不为 Null。

    如果在 CLR 用户定义类型的列中定义主键,则该类型的实现必须支持二进制排序。

    外键约束

    外键 (FK) 是用于在两个表中的数据之间建立和加强链接的一列或多列的组合,可控制可在外键表中存储的数据。 在外键引用中,当包含一个表的主键值的一个或多个列被另一个表中的一个或多个列引用时,就在这两个表之间创建了链接。 这个列就成为第二个表的外键。

    例如,因为销售订单和销售人员之间存在一种逻辑关系,所以 Sales.SalesOrderHeader 表含有一个指向 Sales.SalesPerson 表的外键链接。 SalesOrderHeader 表中的 SalesPersonID 列与 SalesPerson 表中的主键列相对应。 SalesOrderHeader 表中的 SalesPersonID 列是指向 SalesPerson 表的外键。 通过创建此外键关系,如果 SalesPerson 表的主键中不存在 SalesPersonID 的值,则 SalesPersonID 的值将无法插入到 SalesOrderHeader 表。

    表最多可以将 253 个其他表和列作为外键引用(传出引用)。 SQL Server 2016 (13.x) 将可在单独的表中引用的其他表和列(传入引用)的数量限制从 253 提高至 10,000。 (兼容性级别至少必须为 130。)数量限制的提高带来了下列约束:只有 DELETE DML 操作才支持超过 253 个外键引用。 不支持 UPDATE 和 MERGE 操作。

    对自身进行外键引用的表仍只能进行 253 个外键引用。

    列存储索引、内存优化表、Stretch Database 或已分区外键表暂不支持进行超过 253 个外键引用。

    外键约束的索引

    与主键约束不同,创建外键约束不会自动创建对应的索引。 但是由于以下原因,对外键手动创建索引通常是有用的:当在查询中组合相关表中的数据时,经常在联接条件中使用外键列,方法是将一个表的外键约束中的一列或多列与另一个表中的主键列或唯一键列匹配。 索引使 数据库引擎 可以在外键表中快速查找相关数据。 但是,创建此索引并不是必需的。 即使没有对两个相关表定义主键或外键约束,也可以对来自这两个表中的数据进行组合,但两个表间的外键关系说明已用其键作为条件对其进行了优化,以便组合到查询中。

    对主键约束的更改可由相关表中的外键约束检查。

    更多编程相关知识,请访问:编程视频!!

    展开全文
  • 我想在两个独立数据库中的两个实体之间建立一个ManyToMany关系.我认为Doctrine不处理这个问题,至少不是以原生方式处理.无论如何要执行它,我在定义上使用schema属性.假设我有这两个实体:/*** @ORM\Table...

    我正在使用

    MySQL和Doctrine 2(使用Symfony 3).

    我想在两个独立的数据库中的两个实体之间建立一个ManyToMany关系.

    我认为Doctrine不处理这个问题,至少不是以原生的方式处理.无论如何要执行它,我在表定义上使用schema属性.

    假设我有这两个实体:

    /**

    * @ORM\Table(schema="bdd2", name="site")

    */

    class Site {}

    /**

    * @ORM\Table(name="user")

    */

    class User {}

    我没有在User实体上使用schema属性,因为我的实体管理器被配置为使用它的数据库,所以它没用.我以这种方式在User 1中建立关系:

    /**

    * @ORM\ManyToMany(targetEntity="[...]")

    */

    private $sites;

    非常简单.在代码方面,它起作用,关系是有效的.

    在数据库方面,它不行,因为doctrine生成的user_site表只有一个外键(对于用户):它不包含第二个数据库的外键.该字段存在,有索引,但不是外键.

    如果我自己添加外键,每次我做一个php bin / console doctrine:schema:update –dump-sql Doctrine想要删除它.

    问题是 :

    如何让学说创建第二个外键?

    或者如果不可能,我怎样才能使学说无视我自己创造的那个?

    最佳答案 这是我建议的解决方案,昨天在我的评论中我无法正确解释.

    >它从映射信息(例如实体注释)生成模式,然后触发postGenerateSchema事件

    >它从当前数据库生成模式(通过反向工程)

    >它比较两个生成的模式,并生成第二个模式与第一个模式相同的SQL代码.

    因此,如果您操纵第一个模式,您可以避免Doctrine做您不喜欢的事情.

    在这个例子中,我有一些实体在db中实际上是VIEWS,而不是TABLES.所以我告诉学说不要生成他们的表和相关表上的所有FKs约束.您可以轻松地从这个工作脚本开始,并适应您的需求.

    最好的祝福.

    这是AppBundle / Utils / IgnoreTablesListener.php

    namespace AppBundle\Utils;

    use Doctrine\ORM\Tools\Event\GenerateSchemaEventArgs;

    class IgnoreTablesListener {

    private $ignoredEntities = null;

    private $ignoredTables = null;

    public function __construct($ignoredEntities) {

    $this->ignoredEntities=$ignoredEntities;

    $this->ignoredTables=array();

    }

    /**

    * Remove ignored entities from Schema

    * This listener is called when the schema as been generated, from entities data mapping (i.e. in doctrine-schema-update or in doctrine:migrations:diff)

    *

    * @param GenerateSchemaEventArgs $args

    */

    public function postGenerateSchema(GenerateSchemaEventArgs $args)

    {

    $schema = $args->getSchema();

    $em = $args->getEntityManager();

    $ignoredTables = $this->ignoredTables;

    foreach ($this->ignoredEntities as $entityName) {

    $ignoredTables[] = strtolower($em->getClassMetadata($entityName)->getTableName());

    }

    foreach ($schema->getTableNames() as $longTableName) {

    $table=$schema->getTable($longTableName);

    $table_name=strtolower($table->getShortestName($table->getNamespaceName()));

    $fks=$table->getForeignKeys();

    foreach ($fks as $fk) {

    $foreign_table_name=strtolower($fk->getForeignTableName());

    if (in_array($foreign_table_name, $ignoredTables)) { //if the fk points to one of the entities i'm ignoring

    $table->removeForeignKey($fk->getName()); //i remove fk constrains from generated schema (NOT FROM MY CURRENT DB!!!)

    // dump('removed FK '.$fk->getName().' from '.$table_name.' pointing to '.$foreign_table_name.'.['.implode(', ', $fk->getForeignColumns()).']');

    }

    }

    if (in_array($table_name, $ignoredTables)) { //if i have to ignore the $table_name table

    $schema->dropTable($longTableName); //remove the table from generated schema -- NOT FROM DB!!

    // dump('removed ignored table/entity '.$longTableName);

    }

    }

    }

    }

    这是服务配置(app / config / services.yml)

    ..

    app.ignoretableslistener:

    class: AppBundle\Utils\IgnoreTablesListener

    arguments: ['AppBundle:MyEntityToBeIgnoredBecauseItIsAView1', 'AppBundle:MyEntityToBeIgnoredBecauseItIsAView2']

    tags:

    - {name: doctrine.event_listener, event: postGenerateSchema }

    ..

    展开全文
  • 1. 表与表之间的关系:一对多;一对一;多对多; 表与表之间怎么建立一对一的关系呢,可以使用外键约束+唯一约束; 有种方式: 1.利用主键,一张表的主键只能有一,所以这张表就可以满足唯一,另一张表跟前面...

     

     

      1. 表与表之间的关系:一对多;一对一;多对多;

    表与表之间怎么建立一对一的关系呢,可以使用外键约束+唯一约束;

    有两种方式:

    1.利用主键,一张表的主键只能有一个,所以这张表就可以满足唯一,另一张表跟前面那张表的主键关联的字段设置为外键,并且该外键字段设置为唯一字段(也就是当两张表关联的两个字段之一是一张表的主键,则另一张表相应字段设置为外键+唯一约束即可);---用户-博客表(假设一个用户只能有一个博客)

    2. 外键与普通字段:普通字段加唯一约束,外键字段设置为外键 加唯一约束,也就是如果是两张表的关联字段都不是主键,则两张表的一张表关联字段设置为唯一约束,另一张表的关联字段设置为外键约束(外键必须是前一张表的主键)+唯一约束----身份证 -人员信息表;

     

    2. 一对多:  (一的表正常创建,多的表关联字段添加外键)

    2.1 场景: 人-汽车表(一个人可以拥有很多部汽车) person表就是一,汽车表就是多, 另外创建一的那张表就正常创建,设置主键就好了;而多那张表需要设置外键约束(跟前面那张表的主键约束);

    首先创建人员信息表:

    create table person(
      id varchar(10) not null PRIMARY key,  # 人员信息表的主键 其实是跟car表关联的字段
      name varchar(20) not null,
      age int not null,
      sex int not null)
    
    alter table person modify sex char(2) not null;
    
    insert into person values("P0001","西西",22,"女");
    insert into person values("P0002","东东",23,"男");
    insert into person values("P0003","楠楠",24,"女");
    
    select * from person;

     

    运行结果:

     

    设计汽车表(多:外键约束)

     

    create table car(
      cid varchar(10) not null primary key, # car表中的主键
      name varchar(20) not null default "大众" ,
      p_id varchar(10) not null,  # car表中跟person表中关联的字段,需要设置为外键约束
      constraint fk_pid foreign key(p_id) references person(id))    # 设置为外键约束(关联另一张表person的主键id)
    
    insert into car values("c0001","大众","P0001"); # 这两个车都是属于同一个人P0001
    insert into car values("c0002","奔驰","P0001"); # 这两个车都是属于同一个人P0001
    insert into car values("c0003","奥迪","P0002"); # c0002车属于P0002这个人
    insert into car values("c0004","奥迪","P0003");
    select * from car;

     

     运行结果:

    这样person表和car表就建立了一对多的关系,person表的id 是该表的主键,也是跟car这张表的关联字段,car这张表也有一个主角,就是car的id,但是car这张表的p-id就是所属人id 代表这个车属于哪个车主,需要设置为外键约束(这样car这种表的p-id  多条数据可以具有相同的p-id 表示多辆车具有相同的车主,一个人拥有多部车)

     

     2.2 场景: 班级-学生表,一个班级可以对应很多学生,就是一对多,所以class 表正常建立,student表需要对关联字段创建外键约束;

    创建班级表(一,需要设置主键,并且这个主键是两张表的关联字段)

     

    create table class(
      id varchar(10) not null primary key,  # 班级id设置为主键,其实也是两张表的关联字段
      c_name varchar(30) not null)
    
    insert into class values("C0001","python课程班级");
    insert into class values("C0002","java课程班级");
    select * from class;

     

    运行结果:

     

    创建学生表(多,需要对关联字段-就是学生表中需要记录该名学生属于哪个班级,添加外键约束)

    create table student(
      id varchar(10) not null primary key,
      name varchar(30) not null,
      age int not null default 22,
      sex char(2) not null default "女",
      c_id varchar(20) not null,   # student表中的外键,关联的是class表中的班级id(主键)所以多student表中添加外键约束即可;
      constraint fk_student_cid foreign key(c_id) references class(id)  # 对student表中的c_id设置外键约束,关联的是class表的班级id
                                                 # 需要注意 student表的外键c-id 必须跟class表的主键id数据类型一样~~
    )
    insert into student values("S0001","西西",22,"女","C0001");  # S0001 S0002属于同一个班级,student表的c-id字段可以重复(也就是多)
    insert into student values("S0002","静静",23,"女","C0001");
    insert into student values("S0003","东东",24,"男","C0002");
    insert into student values("S0004","二狗子",25,"男","C0002");
    
    select * from student;

    运行结果:


    这样两张表就建立了一对多的关系,class的id 是主键唯一,student表的关联字段是c-id 需要设置为外键 这样student表的c-id就可以多条数据具有相同的值,也就是很多个学生可以同属于一个班级(一个班级具有很多学生--一对多)

     

    3. 一对一

    表与表之间一对一的约束关系有两种创建方法:

    1. 普通字段(code)加唯一约束,关联字段(c_id)设置为外键约束加唯一约束(比如人 身份证两张表 需要表示的是一个人有一个身份证号码,但是在card表中id是主键,身份证号是普通字段,所以card表需要设置普通字段code的唯一约束,另外person表需要id就是设置为主键,但是person表需要记录身份证的信息,也就是需要给一个关联字段,关联字段又只能跟别的表的主键关联作为外键,所以person表关联字段需要设置外键+唯一约束

    2. 两张表的一其中一个是主键,另外一张表设置为外键约束和唯一约束(区别就是一是主键的那张表 不需要设置普通字段为唯一约束,因为一本来就是主键,主键本来就唯一)

     

    3.1 场景:每一个人都只拥有一个身份证;

    需要创建两张表 person人员信息表,具有id name age sex p_code (就是人员信息表都得记录每一个人所具有的身份证号的信息----这里是根据身份证card表的id来关联的,card表的id就是主键,然后code有设置为unique 所以一个id就对应一个code编号,所以在person表中查找id也能唯一的找到code) ,另一张表就是身份证信息的表 包含id code (身份证编号)   这两张表就是一对一的关系,也就是person表的c-id需要设置为外键+唯一约束,card表的code普通字段需要添加唯一约束;

     

    创建身份证信息表card表(id 是主键(另一张表person的c-id需要关联的字段),code:普通字段,需添加唯一约束):

    create table card(
      id varchar(10) not null primary key,  # card 表的主键,person表c_id的关联字段(主键和外键数据类型必须一样,其实就是一个东西,只是在两张表中都出现)
      code varchar(20) not null unique    # 需要为普通字段添加唯一约束,因为一对一指的就是card的code普通字段 还有person表的c-id 外键+唯一约束
    )
    
    insert into card values("C0001","129304903940");
    insert into card values("C0002","232392039094");
    insert into card values("C0003","403903403283");  # 三条不同的身份证信息
    select * from card;

    运行结果:

    创建身份证信息表:

    create table person_info(
      id varchar(10) not null primary key,  # person表的主键
      name varchar(20) not null,
      age int not null default 22,
      sex char(2) not null default "女",
      c_id varchar(10) not null unique, # 跟card表的主键id关联的字段,需要添加外键和唯一约束的
      constraint fk_person_cid foreign key(c_id) references card(id))
    
    insert into person_info values("P0001","西西",22,"女","C0003");   # P0001 对应的身份证信息是C0003那条数据;
    insert into person_info values("P0002","楠楠",24,"男","C0001");  
    insert into person_info values("P0003","宝宝",23,"女","C0002");  
    select * from person_info;

    运行结果:

    这样两张表person表和card表就通过person表的c_id外键约束+唯一约束 跟 card表的id 主键关联 与card表的code普通字段(添加唯一约束)建立了一对一的关系;

    3.2  场景:假设一个用户只能有一个博客:

    一张表设置主键(表的一) 另一张表外键约束+唯一约束(另一张表的一)

    (其实我觉得这两张表的建立可以跟身份证信息表建立思路是一样的,就是首先创建 博客表(普通字段添加唯一约束) 然后创建人员信息表,主键id 关联字段就是人员信息表的blog-id 设置为博客表主键id的外键,并且添加唯一约束 我觉得这样也行其实,,,,)

     

    先创建人员信息表:

    create table user(
      id varchar(10) not null primary key,
      name varchar(20) not null)
    
    insert into user values("U0001","西西");
    insert into user values("U0002","东东");
    select * from USER;

    运行结果:

    创建blog表:

    create table blog(
      id varchar(10) not null primary key,
      name varchar(20) not null, 
      user_id varchar(10) not null unique,  -- 两张表的关联字段,设置为外键(关联的是user表的主键id,通过外键user-id就可以唯一找到这个人
      constraint blog_userid foreign key(user_id) references user(id))  -- 需要为外键添加唯一约束(这样两张表就建立一对一的关系)
    insert into blog values("B0001","璇璇是小仙女呀","U0002");  # 这个博客是U0002用户的
    insert into blog values("B0002","小仙女哈哈哈哈","U0001");
    
    select * from blog;

     

    运行结果:

     

    4. 多对多:(如果是两张表之间多对多,一般需要建立三张表,两张独立的实体表,另外一张可以建立两张表关联的关系表)

    4.1 场景: 学生选课,一个学生可以选很多门课,每门课可以提供很多学生选择;

    一般我们需要创建三张表,两张实体表,就是独立的学生表和课程表,另外一个就是关系表,相当于两张多对多是体表的桥梁;

     

    首先创建实体表学生表:

    create table student_info(
      id varchar(10) not null primary key,
      name varchar(20) not null,
      age int not null,
      sex char(2) not null
    )
    
    insert into student_info values("S0001","璇璇",22,"女");
    insert into student_info values("S0002","西西",23,"女");
    insert into student_info values("S0003","东东",24,"男");
    insert into student_info values("S0004","楠楠",25,"男");
    
    
    select * from student_info;

    运行结果:

     

     创建实体表课程表:

    create table course(
      id varchar(10) not null primary key,
      name varchar(10) not null)
    
    insert into course values("C0001","python课程");
    insert into course values("C0002","java课程");
    insert into course values("C0003","c++课程");
    
    select * from course;

    运行结果:

    创建关系表(反映两张实体表多对多关系的关系表):

    create table relation_info(
      s_id varchar(10) not null,
      c_id varchar(10) not null,
      primary key(s_id,c_id),   # 将s_id 与 c_id设置为联合主键 分别指的是student_info表的学生id 以及course表的课程id
      constraint fk_relation_info_sid foreign key(s_id) references student_info(id),  # 为关系表中的两个字段(其实就是另外两张表的主键,添加外键约束)
      constraint fk_relation_info_cid foreign key(c_id) references course(id))
    
    insert into relation_info values("S0001","C0002");  # s00001选了C0002这门课
    insert into relation_info values("S0001","C0003");  
    insert into relation_info values("S0001","C0001");  
    insert into relation_info values("S0003","C0001");
    insert into relation_info values("S0003","C0002");
    insert into relation_info values("S0003","C0003");
    insert into relation_info values("S0002","C0002");
    insert into relation_info values("S0002","C0003");
    
    select * from relation_info;

    运行结果:

     

    转载于:https://www.cnblogs.com/xuanxuanlove/p/9898527.html

    展开全文
  • 表之间的映射关系

    千次阅读 2018-05-22 17:55:20
    经常我们在建立了几个表以后,发现这几个表之间应该是相互关联。比如我有一个SB表,里面记录了各种和SB有关信息。然后我们还有一个ZT表,里面是和ZT相关各种信息。但是,我们现在知道,一个SB对应一个ZT。所以...
  • 1. 表与表之间的关系:一对多;一对一;多对多;表与表之间怎么建立一对一的关系呢,可以使用外键约束+唯一约束;有种方式:1.利用主键,一张表的主键只能有一,所以这张表就可以满足唯一,另一张表跟前面那张表...
  • 1.理解表与表之间建立关系的必要性比如我们建立了一张个人信息表,把所有人信息都存在这张表中这张表中有老师和他们所属部门,并且不同部门工作也是不同所有数据存放在一张表中弊端1.组织结构不清晰2.浪费...
  • 关系数据库的表设计

    2020-03-02 22:22:46
    开发中抽象出来的各个实体之间的关系有:一对一,一对多,多对多 三种,在设计表的时候 先考虑是哪种情况,然后再看看怎么建表。 一对一。通常建表时建立 2 个表(主副表),外键建立在附表中。例如下图,可建立...
  • 【数据库笔记04】(MySQL数据库语句,思维导图记忆)如何联系表多表之间...如图建立两个表,给product的cno添加一个外键约束 //references 执行 alter table product add foreign key(cno) references category (...
  • 数据库怎么设计多对多数据表一、总结1、项目中小组和主题之间是多对多2、可以将常用信息和不常用信息分成两个表来优化数据库2、一对多话:在多里面建立字段,比如母亲(一)和孩子(多),在孩子里面添加...
  • 数据库怎么设计多对多数据

    千次阅读 2018-05-11 00:50:00
    2、可以将常用信息和不常用信息分成两个表来优化数据库  2、一对多话:在多里面建立字段,比如母亲(一)和孩子(多),在孩子里面添加母亲id 3、多对多话:比如老师和学生,建立一个关系表,表id,...
  • 在课堂上,我们都是“学习”数据库...我已经设法创建数据库和表,但现在我如何在两个表之间建立关系?如果我有我两个表这样:CREATE TABLE accounts(account_id INT NOT NULL AUTO_INCREMENT,customer_id INT( 4 )...
  • 不论是生活中,还是抽象出来的软件中,描述生活中的多类型之间的关系,总结如下: 一对一关系 一对多关系、多对一关系 多对多关系 2、多关联关系的实现 可以通过添加外键来实现。 2.1 一对一 主键共享 ...
  • 数据库外键表示了两个关系之间的相关联系。以另一个关系的外键作主关键字的被称为主,具有此外键的被称为主的从。下面我们就为大家介绍一下navicat如何创建外键。1、打开navicat选择要操作的数据库,...
  • 1 简介哈希:又称散列表,是一种根据给定的关键字来计算关键字在中地址的数据结构,即散列表建立了关键字和存储地址之间的一种直接映射关系。哈希函数:又称散列函数,将给定关键字映射为该关键字对应的地址的...
  • 在这里所写索引是要对 有两个表之间有主外键关系而配置 建立是 说 名称已由现有对象使用 这是为什么了
  • Navicat建立外键失败原因总结

    万次阅读 多人点赞 2017-12-28 16:12:45
    用Navicat为mysql数据库的两个表之间建立外键关系,出现“cannot add foreign key constraint”错误,当时真不知道是怎么回事儿,~~~~(>_<)~~~~,不过,说到这儿,先谈谈外键的建立吧。 外键建立:...
  • 因为业务需求,开始日期和结束日期是一值的时间范围,想要将开始日期和结束日期之间的所有日期展开成多行,结果为日期列和值列,最后将日期列与日期表建立关系进行数据分析。 我们先从最简单的内容分析,先看第一...
  • MySQL 外键约束(FOREIGN KEY)用来在两个表的数据之间建立链接,它可以是一列或者多列。一个表可以有一个或多个外键。外键对应是参照完整性,一个表外键可以为空值,若不为空值,则每一个外键值必须等于另一个...
  • NoSQL与关系型数据库全面对比

    千次阅读 2020-09-01 09:56:17
    顾名思义,就是表与表之间关系,平时我们所用到MSSQL Server、Oracle、Mysql等都是关系型数据库,它们是建立关系模型基础上数据库,依靠表、字段等关系模型,结合集合代数等数学方法来处理数据。 关系型...
  • MySQL 外键约束(FOREIGN KEY)用来在两个表的数据之间建立链接,它可以是一列或者多列。一个表可以有一个或多个外键。外键对应是参照完整性,一个表外键可以为空值,若不为空值,则每一个外键值必须等于另一个...
  • 用Navicat为mysql数据库的两个表之间建立外键关系,出现“cannot add foreign key constraint”错误,当时真不知道是怎么回事儿,~~~~(>_ 外键建立: 把表t_stuschoolregisterinfoIDCard字段设成外键,关联表t_...
  • 数据库设计(一对多,多对多)

    万次阅读 多人点赞 2018-09-26 09:21:05
    2、可以将常用信息和不常用信息分成两个表来优化数据库  2、一对多话:在多里面建立字段,比如母亲(一)和孩子(多),在孩子里面添加母亲id 3、多对多话:比如老师和学生,建立一个关系表,表id,...
  • 3.18 需要根据条件把一个复杂表达式赋给两个变量中一个。可以用下面这样代码吗?((condition)?a:b)=complicated_expression; 3.19 我有些代码包含这样表达式。a?b=c:d有些编译器可以接受,有些却不能。为...
  • 多对多关联!...关键是怎么建立数据库中两个表之间的关系??? 这时候需要一个中间表来组织两张表的关系! 创建对应的数据库表! student表 teacher表 middle表 创建对应的实体类 ...

空空如也

空空如也

1 2 3 4 5
收藏数 92
精华内容 36
关键字:

怎么建立两个表之间的关系