精华内容
下载资源
问答
  • 数据库:码 属性 候选码 主码的关系 定义 码 唯一标识实体的属性集称为码。例如学号是学生实体的码 属性 ...码是唯一确定一条记录的属性或属性集合,因此码其实也就是候选码的简称。 但是码一...

    数据库:码 属性 候选码 主码的关系

    定义


    1. 唯一标识实体的属性集称为码。例如学号是学生实体的码

    2. 属性
      实体所具有的某一特性称为属性

    3. 候选码
      设K为R<U,F>中的属性或属性组合,若K→U,则K为R的候选码

    4. 主码
      若候选码多于一个,则选定其中一个为主码

    区别

    1.码和候选码,属性的区别
    码是唯一确定一条记录的属性或属性集合,因此码其实也就是候选码的简称。
    但是码一般不仅仅包含候选码
    比如身份证,不仅仅包含唯一的身份证号,还有姓名,性别等(姓名,年龄这些就属于属性)
    2. 候选码和主码的区别
    主码一定是候选码,但候选码不一定是主码

    联系

    码>候选码>主码

    展开全文
  • 码/超键:能唯一确定一条记录的属性或属性的集合。 学号、身份证号、(姓名,系别,班级,座位号)、(学号,身份证号)、(学号,姓名)、(学号,系别)。。。 只要能唯一确定一条记录,都被称为码。 候选码/键:能...

    学生信息(学号、身份证号、姓名、系别、班级、座位号,爱好,年龄),假设姓名可以重复,每个系里面的班级都是取值1班、2班、3班。。。

     

    码/超键:能唯一确定一条记录的属性或属性的集合。

                    学号、身份证号、(姓名,系别,班级,座位号)、(学号,身份证号)、(学号,姓名)、(学号,系别)。。。

                    只要能唯一确定一条记录,都被称为码。

     

    候选码/键:能唯一确定一条记录的最小属性集。对码进行了约束。

                          学号、身份证号、(姓名,系别,班级,座位号) //

                           (学号,身份证号)、(学号,姓名)。。。这些不行的原因是它们的单个属性就能确定一条记录,所以不符合最小属性集。

     

    主键/码:从候选码里人为挑出一个作为主键。

                       学号、身份证号、(姓名,系别,班级,座位号) 三选一。

     

    主属性:将候选码的属性集全部拆分为单个属性,这些属性就是主属性。

                      学号、身份证号、(姓名,系别,班级,座位号)

                       ===》学号、身份证号、姓名、系别、班级、座位号

     

    非主属性:主属性除外的属性。

                        爱好、年龄

    展开全文
  • MySQL数据表结构中,一般情况下,都会定义一个具有‘AUTO_INCREMENT’扩展属性的‘ID’字段,以确保数据表一条记录都可以用这个ID唯一确定
  • MySQL修改主键属性

    2016-07-07 14:06:00
    前言:在学习MySQL的过程中,对于主键的属性以及操作理解较模糊,在... 主键约束在数据表中可以定义一个主键值,唯一确定表中的每一条记录。每张表中只能有一个primary key,并且primary key不能为空。如果主键约束...

    前言:在学习MySQL的过程中,对于主键的属性以及操作理解较模糊,在输入多条修改主键属性的语句后经常报错,所以想整理一下这个过程中遇到的问题,作为自己的学习记录,可能都是基础知识,但也希望提高自己对数据库的理解,同时也能帮助到其他人。


      主键约束在数据表中可以定义一个主键值,唯一确定表中的每一条记录。每张表中只能有一个primary key,并且primary key不能为空。如果主键约束定义在不止一列,则一列的值可以重复,但是主键约束定义中的所有列组合必须唯一。

    1. 添加主键约束:

    alter table tbl_name add primary key (index_col_name,…);
    #括号中为字段名,可以为一个或者多个

    2. 在数据表已存在的情况下,且无主键,添加新的字段作为主键,并将该字段移到表格的第一列

    alter table tbl_name add col_name col_definition (data type, null, default...) primary key first current_first_col_name;
    # current_first_col_name表示当前数据表的第一列  

    Notes:关键字first表示位于某一列的前面,如果加入的字段需要位于某一列的后面,可以使用after

     3. 数据表已存在,且有主键,修改主键的定义

    关键字modify

    alter table tbl_name modify col_name col_definition [first|after col_name]
    #在col_definition 声明要修改的属性,如要添加自动编号auto_increment 

    Notes:

    1)  此时不需要重新声明主键属性primary key,如果添加了则会报错:主键重复;

    2)  如果原有属性中存在auto_increment,修改时需要加上auto_increment,否则auto_increment属性被删除

    关键字change

    alter table tbl_name change col_name col_name col_definition [first|after col_name]
    #与modify的区别在于列表需要写两次列名,相当于原列名和新列名,所以change也可以用来修改列名

     

    转载于:https://www.cnblogs.com/suiy-160428/p/5649911.html

    展开全文
  • 数据库中主键能够唯一识别一条记录,它可以是一个字段也可以是多个字段组合。主键主要作用是标识表中的一条... 自然主键是数据表中有逻辑含义字段,比如身份证号来唯一确定一条个人记录。也可以通过学号和...

     数据库中的主键能够唯一识别一条记录,它可以是一个字段也可以是多个字段的组合。主键的主要作用是标识表中的一条记录,还有和其他表中的数据进行关联。数据库中的主键类型必须符合唯一性约束和非空约束。作为附加属性,主键应该尽可能简洁,不要包含过多属性。根据这个原则,主键可以分为自然主键和代理主键。 
        自然主键是数据表中有逻辑含义的字段,比如身份证号来唯一确定一条个人记录。也可以通过学号和课程号来唯一确定成绩。使用自然主键时如果业务发生变化则对数据库调整是极其麻烦的,所以数据库设计使用代理主键是非常好的选择。代理主键是一个和业务无关的流水号,一般采用数据库中自动增长的机制自动生成。例如Oracle数据库使用序列,MySQL和SQL Server有自动增长(auto increment)类型,该字段类型一般为Integer,名称设置为ID或XXID。下面来看看Hibernate中的主键生成策略,实验都以Oracle为主,MySQL为辅来说明。

      第一种是increment策略,Hibernate配置如下: 
    Xml代码
    1. <id name="id" column="ID" type="java.lang.Integer" length="10">  
    2.     <generator class="increment"></generator>  
    3. </id>  
    4.  
    5. 运行结果如下: 
    6. Sql代码 
      1. Hibernate: select max(ID) from USERS   
      2. Hibernate: insert into USERS (NAME, PHONE, DEPARTMENT, CITY, HIRE_TIME, ID) values(?, ?, ?, ?, ?, ?)  

          可以看出,Hibernate是从数据库中先找出已经存在的最大主键数值,然后加1后作为新纪录的主键再执行插入语句。这种策略不适合非独享数据库或者分布式的Hibernate应用,否则就很难保证主键值的唯一了。 
          第二种是identity策略,Hibernate中配置如下: 
      Xml代码 
      1. <id name="id" column="ID" type="java.lang.Integer" length="10">  
      2.     <generator class="identity"></generator>  
      3. </id>  

          这种策略在Oracle中无法使用,因为这种策略是针对数据库中字段自动增长类型。改在MySQL中测试,得到如下结果: 
      Sql代码 
      1. Hibernate: insert into USERS (NAME, PHONE, DEPARTMENT, CITY, HIRE_TIME) values(?, ?, ?, ?, ?)  

          多次运行程序,在数据库中查看,可以看到主键是自动进行递增的。 
          第三种是sequence策略,Hibernate中配置如下: 
      Xml代码 
      1. <generator class="sequence">  
      2.         <param name="sequence">SEQ_HIBERNATE_USERS</param>  
      3.     </generator>  

          使用序列策略是,需要现在数据库中创建一条序列,运行程序,得到如下结果: 
      Sql代码 
      1. Hibernate: select SEQ_HIBERNATE_USERS.nextval from dual   
      2. Hibernate: insert into USERS (NAME, PHONE, DEPARTMENT, CITY, HIRE_TIME, ID) values (?, ?, ?, ?, ?, ?)  

          可以看出Hibernate先从序列中得到下一个数值,然后执行插入操作。 
          第四种是hilo策略,这是Hibernate采用一种称为“高/低位”(hi/lo)的算法产生标识符属性值,该算法采用一个高位值和一个低位值进行运算,结果作为标识符属性的值。使用该策略时,需要在数据库中建立一个表和其中一个字段,名称可以自定。其中的字段值作为高位值的来源。在Hibernate中配置如下: 
      Xml代码 
      1. <generator class="hilo">  
      2.     <param name="table">HIBERNATE_KEY</param>  
      3.     <param name="column">NEXT_HIVALUE</param>  
      4. </generator>  

          可以见名知意,我使用的表名是HIBERNATE_KEY,字段名是NEXT_HIVALUE,然后给该字段设置一个值,作为高位。低位Hibernate有自己的管理机制可不用创建,也可以给出在配置文件中用<param name="max_lo">1</param>的形式给出即可,一般使用情况下使用1更好。该算法是每次按max_lo数值递增。Hibernate的执行结果还是一条语句,如下: 
      Sql代码 
      1. Hibernate: insert into USERS (NAME, PHONE, DEPARTMENT, CITY, HIRE_TIME, ID) values (?, ?, ?, ?, ?, ?)  

          执行后高位自动加1,然后到数据库中就可以查看生成的主键数值。该策略与底层的数据库无关,只要保证高位降低,那么生成的主键值是唯一的,并且可跨数据库使用。 
          第五种是seqhilo策略,基于hilo策略,这种方式的标识符属性生成时指定一个序列作为高位值,那么在Hibernate中的配置如下: 
      Xml代码 
      1.     <generator class="seqhilo">  
      2.         <param name="sequence">SEQ_HIBERNATE_USERS</param>  
      3. </generator>  

          执行插入后,Hibernate首先取出序列的下一个值作为高位值,然后计算一个ID出来进行操作,得到如下结果: 
      Sql代码 
      1. Hibernate: select SEQ_HIBERNATE_USERS.nextval from dual   
      2. Hibernate: insert into USERS (NAME, PHONE, DEPARTMENT, CITY, HIRE_TIME, ID) values (?, ?, ?, ?, ?, ?)  

          第六种是uuid策略,这种策略是使用128位的UUID算法来生成字符串类型标识符属性,这种算法使用IP地址,JVM的启动时间(精确到1/4秒),系统时间和一个计数器(在当前JVM中唯一)这些数值经过计算得到一个标识符属性的值,产生的值是32位长度的字符串,则使用前需要将数据库字段调整到varchar2(32),持久化类的ID属性改为String进行测试。Hibernate中配置如下,注意字段信息的修改: 
      Xml代码 
      1. <id name="id" column="ID" type="java.lang.String" length="32">  
      2.     <generator class="uuid">  
      3.     </generator>  
      4. lt;/id>  

          执行后Hibernate的结果还是一条插入语句,这里不再复制了,我们看看数据库中的结果吧,如下图,就得到了32位的主键值了。 
       
          在做文件下载时,用这种策略生成的主键就可以作为下载链接,而不用在人为去制作链接,是一个不错的选择。 
          第七种是guid策略,Hibernate中配置如下: 
      Xml代码 
      1. <generator class="guid"></generator>  

          这个在Oracle中是用了sys_guid()函数生成的值,而在MySQL中使用uuid()函数生成值,这个值要设置成varchar2/varchar类型,区别在于Oracle中是32位长度,而MySQL原生是36位(有4个-隔开)。运行程序得到如下结果:(Oracle环境下) 
      Sql代码 
      1. Hibernate: select rawtohex(sys_guid()) from dual   
      2. Hibernate: insert into USERS (NAME, PHONE, DEPARTMENT, CITY, HIRE_TIME, ID) values (?, ?, ?, ?, ?, ?)  

      (MySQL环境下) 
      Sql代码 
      1. Hibernate: select uuid()   
      2. Hibernate: insert into USERS (NAME, PHONE, DEPARTMENT, CITY, HIRE_TIME, ID) values (?, ?, ?, ?, ?, ?)  

          第八种是native策略,native字面意思是“本地的”,那么对于数据库,Hibernate该如何选择呢?Hibernate根据所使用的数据库支持能力从identity,sequence或者hilo策略中选择一种,Hibernate中配置很简单: 
      Xml代码 
      1. <generator class="native"></generator>  

          在Oracle下,Oracle先创建一个序列,使用默认名(数据库名_SEQUENCE),然后执行插入操作,而在MySQL下则使用identity策略,使用了自动增长的字段。Oracle中测试结果如下: 
      Sql代码 
      1. Hibernate: select hibernate_sequence.nextval from dual   
      2. Hibernate: insert into USERS (NAME, PHONE, DEPARTMENT, CITY, HIRE_TIME, ID) values (?, ?, ?, ?, ?, ?)  

          第九种是assigned策略,这种方式也是Hibernate中<generator>没有配置标识符属性生成策略时默认使用的方式。但使用这种策略时需要我们自定义标识符属性的值,也就是我们人为设置标识符属性的值,这就需要在程序中显式为标识符属性(ID)赋值。配置方式如下: 
      Xml代码 
      1. <generator class="assigned"></generator>  

          第十种是foreign策略,这种方式是通过关联的持久化对象为当前的持久化对象设置标识符属性,当他们是一对一关联时,一个持久化类的主键值可以参考关联持久化类的标识符属性值。我们做一个完整的实例来看。(使用Hibernate为我们自动创建表) 
      hibernate.cfg.xml 
      Xml代码 
      1. <?xml version='1.0' encoding='UTF-8'?>  
      2. <!DOCTYPE hibernate-configuration PUBLIC   
      3.           "-//Hibernate/Hibernate Configuration DTD 3.0//EN"   
      4.           "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">  
      5. <hibernate-configuration>  
      6.     <session-factory>  
      7.         <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>  
      8.         <property name="connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property>  
      9.         <property name="hibernate.connection.username">hibernate</property>  
      10.         <property name="hibernate.connection.password">hibernate</property>  
      11.         <property name="hibernate.dialect">org.hibernate.dialect.OracleDialect</property>  
      12.         <property name="current_session_context_class">thread</property>  
      13.         <property name="hbm2ddl.auto">create</property>  
      14.         <property name="show_sql">true</property>  
      15.         <property name="format_sql">false</property>  
      16.         <mapping resource="demo/domain/User.hbm.xml" />  
      17.         <mapping resource="demo/domain/Profile.hbm.xml" />  
      18.     </session-factory>  
      19. </hibernate-configuration>  

          User持久化类和映射文件: 
      Java代码 
      1. package demo.domain;   
      2. public class User implements java.io.Serializable {   
      3.     private Integer id;   
      4.     private String name;   
      5.     private String password;   
      6.     private Profile profile;   
      7.     public User() {   
      8.     }   
      9.     // get和set方法   
      10.     public Integer getId() {   
      11.         return id;   
      12.     }   
      13.     public void setId(Integer id) {   
      14.         this.id = id;   
      15.     }   
      16.     public String getName() {   
      17.         return name;   
      18.     }   
      19.     public void setName(String name) {   
      20.         this.name = name;   
      21.     }   
      22.     public String getPassword() {   
      23.         return password;   
      24.     }   
      25.     public void setPassword(String password) {   
      26.         this.password = password;   
      27.     }   
      28.     public Profile getProfile() {   
      29.         return profile;   
      30.     }   
      31.     public void setProfile(Profile profile) {   
      32.         this.profile = profile;   
      33.     }   
      34. }  

      Xml代码 
      1. <?xml version="1.0" encoding="UTF-8"?>  
      2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"   
      3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
      4. <hibernate-mapping>  
      5.     <class name="demo.domain.User" table="USERS">  
      6.         <id name="id" column="ID" type="java.lang.Integer" length="10">  
      7.             <generator class="native">  
      8.             </generator>  
      9.         </id>  
      10.         <property name="name" column="NAME" type="java.lang.String"  
      11.             length="20" not-null="true" />  
      12.         <property name="password" column="PASSWORD" type="java.lang.String"  
      13.             length="32" />  
      14.         <one-to-one name="profile" class="demo.domain.Profile"  
      15.             outer-join="true" cascade="all" />  
      16.     </class>  
      17. </hibernate-mapping>  

          Profile持久化类和映射文件如下: 
      Java代码 
      1. package demo.domain;   
      2.   
      3. public class Profile implements java.io.Serializable {   
      4.     private Integer id;   
      5.     private String info;   
      6.     private User user;   
      7.     public Profile() {   
      8.     }   
      9.     public Integer getId() {   
      10.         return id;   
      11.     }   
      12.     public void setId(Integer id) {   
      13.         this.id = id;   
      14.     }   
      15.     public String getInfo() {   
      16.         return info;   
      17.     }   
      18.     public void setInfo(String info) {   
      19.         this.info = info;   
      20.     }   
      21.     public User getUser() {   
      22.         return user;   
      23.     }   
      24.     public void setUser(User user) {   
      25.         this.user = user;   
      26.     }   
      27. }  

      Xml代码 
      1. <?xml version="1.0" encoding="UTF-8"?>  
      2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"   
      3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
      4. <hibernate-mapping>  
      5.     <class name="demo.domain.Profile" table="PROFILES">  
      6.         <id name="id" column="ID" type="java.lang.Integer" length="10">  
      7.             <generator class="foreign">  
      8.                 <param name="property">user</param>  
      9.             </generator>  
      10.         </id>  
      11.         <property name="info" column="INFO" type="java.lang.String"  
      12.             length="200" not-null="true" />  
      13.         <one-to-one name="user" class="demo.domain.User"  
      14.             constrained="true" />  
      15.     </class>  
      16. </hibernate-mapping>  

          注意二者<one-to-one>配置时的属性是不同的,因为主动的一方是User,被动的一方是Profile,才会要求一个配置cascade,cascade为all表示表示主动一方无论执行任何操作,其关联对象执行同样的操作。一个配置constrained,constrained为true表示约束Profile对象的标识符属性必须与User对象的标识符属性相同。测试类如下: 
      Java代码 
      1. package demo;   
      2. import org.hibernate.*;   
      3. import org.hibernate.cfg.Configuration;   
      4. import demo.domain.*;   
      5. public class Test {   
      6.     public static void main(String[] args) {   
      7.         Configuration config = new Configuration();   
      8.         config.configure();   
      9.         SessionFactory sessionFactory = config.buildSessionFactory();   
      10.         Session session = sessionFactory.getCurrentSession();   
      11.         Transaction tx = session.beginTransaction();   
      12.         User user = new User();   
      13.         user.setName("Tom");   
      14.         user.setPassword("123456");   
      15.         Profile profile = new Profile();   
      16.         profile.setInfo("Information");   
      17.         //双向关联   
      18.         user.setProfile(profile);   
      19.         profile.setUser(user);   
      20.         session.save(user);   
      21.         tx.commit();   
      22.     }   
      23. }  

          执行程序,我们得到如下结果: 
      Sql代码 
      1. Hibernate: select hibernate_sequence.nextval from dual   
      2. Hibernate: insert into USERS (NAMEPASSWORD, ID) values (?, ?, ?)   
      3. Hibernate: insert into PROFILES (INFO, ID) values (?, ?)  

          我们为User对象设置的标识符属性生成策略是native,则在Oracle数据库中使用序列生成。为Profie对象设置的标识符属性生成策略是foreign,它就按照主体对象的标识符属性获取。其实这种一对一关系完全可以合并到一个表中,只是为了说明,分开来演示例子而已。而实际情况就要具体问题具体分析了,主要在业务层面考虑而不是具体的技术实现。 
          最后来说一下标识符属性生成策略的选择方式。应用不需要分布式时,在数据库支持的sequence,identity,hilo,seqhilo和uuid中选择比较好。而分布式数据库应用中uuid是最佳选择。若是改造遗留系统,那么使用assigned是最合适的了。

    转载于:https://www.cnblogs.com/laohuihui/p/5308770.html

    展开全文
  • 数据库中主键能够唯一识别一条记录,它可以是一个字段也可以是多个字段组合。主键主要作用是标识表中... 自然主键是数据表中有逻辑含义字段,比如身份证号来唯一确定一条个人记录。也可以通过学号和课程号来唯
  • 主码 < 候选码 < 码 候选码: 可以唯一标识一个元组最少属性的集合就是候选码 候选码中所有属性都是必须,缺少了任何一个属性,就不能唯一标识一个元组(一条记录)了 超码:
  • mysql全局唯一ID生成方案(二)

    千次阅读 2016-11-10 16:52:40
    MySQL数据表结构中,一般情况下,都会定义一个具有‘AUTO_INCREMENT’扩展属性的‘ID’字段,以确保数据表一条记录都可以用这个ID唯一确定; 随着数据不断扩张,为了提高数据库查询性能,降低查询热点,...
  • MySQL数据表结构中,一般情况下,都会定义一个具有‘AUTO_INCREMENT’扩展属性的‘ID’字段,以确保数据表一条记录都可以用这个ID唯一确定;随着数据不断扩张,为了提高数据库查询性能,降低查询热点,一般...
  • 第二、三范式与BC范式区别

    千次阅读 2019-06-15 21:45:33
    1、码:能唯一确定一条记录的一个/多个属性。码包括主码和候选码。任意一个候选码也能作为主键。其中主码/候选码的任意一个真子集都不能确定一条记录。 2、主属性:构成主码或候选码的属性都叫主属性!千万不要误...
  • 主键:主键是能够确定一条记录的唯一标识,其为一个属性或者一个属性组 外键用于与另一张表的关联(即和另外一张表的主键相关联),是能够确定另外一张表记录的字段,用于保持数据的一致性 主键和外键是把多个表组织成...
  • 主键、外键

    2016-11-06 23:27:53
    什么是主键、外键?...主键是能确定一条记录的唯一标识。 外键用于与另一张表的关联。是能确定另一张表记录的字段,用于保持数据的一致性。    主键  外键  索引 定义 唯一标识一条记
  • 可我不理解多对多关系下建中间表怎么就能体现出唯一性了,不建中间表仅靠联合主键也能唯一确定一条记录。第二范式本质上是要求中间表中除了主键字段外,剩下字段都要由主键(联合主键)一起才能确定,从OO角度来看...
  • 1、索引 MySQL官方对索引的定义...主键 : 某一个属性组能唯一标识一条记录 特点 : 最常见的索引类型 确保数据记录的唯一确定特定数据记录在数据库中的位置 1.3、唯一索引 作用 : 避免同一个表中某数据列中的值重复
  • SQL学习--基础概念

    2019-04-25 15:48:23
    关系型数据库中,每一行数据是一条记录,一张表中有一条或多条记录构成,一...有时候仅一个字段无法唯一确定一条记录,数据库允许多个字段唯一标识记录,即两个或两个以上字段都设为主键,此类主键是联合主键。 外...
  • My SQL 几个概念

    2016-10-22 09:21:30
    1.主键主键是能够标识唯一记录的属性或属性组,比如,一条记录包括身份证号,姓名,年龄。身份证号是唯一确定你这个人的,其他都可能有重复,所以,身份证号是主键。 一个表只能有一个主键,但可以有多个候选索引...
  • 一句话概括:一张表中,可以用于唯一标识一条记录的字段组(或者说是属性组)。给你一个主键的值,你就可以找到一条确定的记录。如: 学生表:学号,姓名,性别,课程。这里学号就是主键。给你一个学号,就可以...
  • 超键 能唯一标示元组的属性集 叫做超键 能唯一标示这一条记录的属性(一个或者多个)或者和其他属性的任意组合 候选键 不包含其他属性的超键 主键 从候选键中选一个。一张表 只能有一个主键 外键 主属性 包含在任一 ...
  • 概述: 基于无线网络和地理位置定位,运用服务器数据区块分割管理法对管、线、缆进行系统编码(指出物品在数据库表中第几条记录)、条形码标识,免查询直接读取数据管理方法。 简单说就是:一条线缆被记录在...
  • 数据库主键和外键

    2021-02-08 16:30:59
    学生表(学号,姓名,...主键是能确定一条记录的唯一标识。 2、外键:用于与另一张表的关联。是能确定另一张表记录的字段,用于保持数据的一致性。比如,A表中的一个字段,是B表的主键,那他就可以是A表的外键。 ...

空空如也

空空如也

1 2 3 4 5 6
收藏数 102
精华内容 40
关键字:

唯一确定一条记录的属性