精华内容
下载资源
问答
  • 数据库 组合主键 外键

    千次阅读 2020-05-02 10:49:56
    ='000'),/*正则*/ courseNo char(3) not null, /*非空*/ bookNo char(6) not null check(bookNo like 'CN[0-9][0-9][0-9][0-9]'),/*正则*/ primary key(courseNo,bookNo), /*组合主键*/ foreign key(courseNo) ...
    create table SBook(
    	schoolYear TINYINT not null check(schoolYear in ('1','2','3','4','5','6','7','8')),/*取值范围*/
    	Number Smallint check(Number like '[0-9][0-9][0-9]' and Number!='000'),/*正则*/
    	courseNo char(3) not null, /*非空*/
    	bookNo char(6) not null check(bookNo like 'CN[0-9][0-9][0-9][0-9]'),/*正则*/
    	primary key(courseNo,bookNo), /*组合主键*/
    	foreign key(courseNo) references Course(courseNo) /*参照 references 不可少*/
    )
    
    展开全文
  • sqlServer组合主键

    千次阅读 2019-10-06 04:07:40
    sqlServer 组合主键 创建表时: create table Person ( Name1 nvarchar(10) not null ,Name2 nvarchar(10) not null primary key(Name1,Name2) ,Age int not null ,Sex char(2) ) go View Code ...

    sqlServer   组合主键

    创建表时:

    create table Person
    (
    Name1 nvarchar(10) not null
    ,Name2 nvarchar(10) not null
    primary key(Name1,Name2)
    ,Age int not null
    ,Sex char(2)
    )
    go
    View Code

    效果如下图:

    表创建后:

     

    转载于:https://www.cnblogs.com/zlp520/p/3599305.html

    展开全文
  • 组合主键及JPA映射

    千次阅读 2016-08-24 09:59:50
    主键最常见的是单字段主键,组合主键使用两个及以上的字段作为主键,常用于多个字段能唯一标示一条记录的表。比如,股票数据表,股票代码、日期和收盘价作为主键。每支股票,在一个特定日期,只能有一个收盘价。 ...

    组合主键

    主键最常见的是单字段主键,组合主键使用两个及以上的字段作为主键,常用于多个字段能唯一标示一条记录的表。比如,股票数据表,股票代码、日期和收盘价作为主键。每支股票,在一个特定日期,只能有一个收盘价。
    数据库管理系统使用MySQL,创建一个具有组合主键的表Person。
    CREATE TABLE PERSON (
    	name VARCHAR(255) NOT NULL,
        age BIGINT UNSIGNED NOT NULL,
        adress VARCHAR(255) ,
    	PRIMARY KEY (name, age)
    ) ENGINE = InnoDB;

    JPA映射之@IdClass

    定义工具类

    package com.gxz.entities;
    
    import java.io.Serializable;
    
    public class PersonCompositeId implements Serializable {
    	private String name;
        private long age;
        
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public long getAge() {
    		return age;
    	}
    	public void setAge(long age) {
    		this.age = age;
    	}
    }
    
    该工具类的属性必须和实体类的@Id属性完全匹配。包括数量、名字,不能有额外的属性。

    定义实体类

    package com.gxz.entities;
    
    import javax.persistence.Entity;
    import javax.persistence.Id;
    import javax.persistence.IdClass;
    import javax.persistence.Table;
    
    @Entity
    @Table
    @IdClass(PersonCompositeId.class)
    public class Person {
    	private String name;
        private long age;
        private String adress;
        
        @Id
    	public String getName() {
    		return name;
    	}
    	
    	public void setName(String name) {
    		this.name = name;
    	}
    	
    	@Id
    	public long getAge() {
    		return age;
    	}
    	
    	public void setAge(long age) {
    		this.age = age;
    	}
    	
    	public String getAdress() {
    		return adress;
    	}
    	public void setAdress(String adress) {
    		this.adress = adress;
    	}
    }
    
    该实体类有两个属性标示为@Id,表示主键为组合主键,主键属性为name、age。相应地,工具类PersonCompositeId必须有两个属性,分别为name、age。注意,此处指的是工具类必须有getName、setName、getAge、setAge,而不是指必须有字段name、age,注意区分属性和字段的区别。@IdClass(PersonCompositeId.class):表示使用工具类PersonCompositeId定义组合主键。另外,工具类PersonCompositeId必须实现序列化Serializable,否则,报出如下异常。
    [PersistenceUnit: EntityMappings] Unable to build Hibernate SessionFactory
    Composite-id class must implement Serializable: com.gxz.entities.PersonCompositeId
    Composite-id class must implement Serializable: com.gxz.entities.PersonCompositeId

    持久化

     Person person = new Person();
                person.setName("李四");
                person.setAge(40);
                person.setAdress("广州市");
                manager.persist(person);

    根据id查找实体

     PersonCompositeId personCompositeId = new PersonCompositeId();
                personCompositeId.setName("张三");
                personCompositeId.setAge(50);
                Person person = manager.find(Person.class, personCompositeId);
                if (person != null) {
                	System.out.println("name:" + person.getName() + " age:" + person.getAge());
    			}

    JPA映射之@EmbeddedId

    定义工具类

    package com.gxz.entities;
    
    import java.io.Serializable;
    
    import javax.persistence.Embeddable;
    
    @Embeddable
    public class PersonCompositeId implements Serializable {
    	private String name;
        private long age;
        
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public long getAge() {
    		return age;
    	}
    	public void setAge(long age) {
    		this.age = age;
    	}
    }

    @Embeddable:表示该工具类用于组合主键,属性就是组合主键的属性。

    定义实体类

    package com.gxz.entities;
    
    import javax.persistence.EmbeddedId;
    import javax.persistence.Entity;
    import javax.persistence.Table;
    
    @Entity
    @Table
    public class Person {
    	private PersonCompositeId personCompositeId;
    	
    	@EmbeddedId
        public PersonCompositeId getPersonCompositeId() {
    		return personCompositeId;
    	}
    	public void setPersonCompositeId(PersonCompositeId personCompositeId) {
    		this.personCompositeId = personCompositeId;
    	}
    	private String adress;
        
    	
    	public String getAdress() {
    		return adress;
    	}
    	public void setAdress(String adress) {
    		this.adress = adress;
    	}
    }
    @EmbeddedId:表示该属性是组合主键,类型是组合主键工具类。

    持久化

    PersonCompositeId personCompositeId = new PersonCompositeId();
                personCompositeId.setName("搜噶");
                personCompositeId.setAge(100);
                person.setPersonCompositeId(personCompositeId);
                
                person.setAdress("广州市");
                manager.persist(person);
    
                transaction.commit();

    两种映射方式的比较

    第一种方式,工具类和实体类有一模一样的属性,属于冗余,第二种方式则没有没有冗余,显得更加科学。因此,实际工作中,第二种方式更加常用。


    展开全文
  • 组合主键的使用(1)

    2015-08-28 11:41:16
    但是,如果是组合主键所生成的代码中诸多功能是不工作的,包括: index中点击热点,自动调用show,显示当前记录; edit功能, delete功能。。 等等。   之所以不能工作,原因就是使用了复合主键——原来的ID...

    Grails中定义域类后,就可以通过脚手架自动生成各种CRUD操作代码。但是,如果是组合主键所生成的代码中诸多功能是不工作的,包括:

    index中点击热点,自动调用show,显示当前记录;

    edit功能,

    delete功能。。

    等等。

     

    之所以不能工作,原因就是使用了复合主键——原来的ID不起作用了,或者说没有了。

     

    所以,必须对域类、控制器、GSP文件都进行相应的修改,才行。

     

    首先是域类的说明:

    package cn.edu.cup.unit
    
    import grails.gorm.DetachedCriteria
    import groovy.transform.ToString
    import org.apache.commons.lang.builder.HashCodeBuilder
    
    @ToString(cache=true, includeNames=true, includePackage=false)
    class QuantityStandardUnit implements Serializable {
    
        private static final long serialVersionUID = 1
    
        PhysicalQuantity physicalQuantity
        QuantityUnit quantityUnit
    
        QuantityStandardUnit(PhysicalQuantity p, QuantityUnit q) {
            this()
            physicalQuantity = p
            quantityUnit = q
        }
    
        @Override
        boolean equals(other) {
            if (!(other instanceof QuantityStandardUnit)) {
                return false
            }
    
            other.physicalQuantity?.id == 
            physicalQuantity?.id && 
            other.quantityUnit?.id == quantityUnit?.id
        }
    
        @Override
        int hashCode() {
            def builder = new HashCodeBuilder()
            if (physicalQuantity) builder.append(physicalQuantity.id)
            if (quantityUnit) builder.append(quantityUnit.id)
            builder.toHashCode()
        }
    
        static QuantityStandardUnit get(long physicalQuantityId, long quantityUnitId) {
            criteriaFor(physicalQuantityId, quantityUnitId).get()
        }
    
        static boolean exists(long physicalQuantityId, long quantityUnitId) {
            criteriaFor(physicalQuantityId, quantityUnitId).count()
        }
    
        private static DetachedCriteria criteriaFor(long physicalQuantityId, long quantityUnitId) {
            QuantityStandardUnit.where {
                physicalQuantity == PhysicalQuantity.load(physicalQuantityId) &&
                quantityUnit == QuantityUnit.load(quantityUnitId)
            }
        }
    
        static QuantityStandardUnit create(PhysicalQuantity physicalQuantity, QuantityUnit quantityUnit, boolean flush = false) {
            def instance = new QuantityStandardUnit(physicalQuantity, quantityUnit)
            instance.save(flush: flush, insert: true)
            instance
        }
    
        static boolean remove(PhysicalQuantity u, QuantityUnit r, boolean flush = false) {
            if (u == null || r == null) return false
    
            int rowCount = QuantityStandardUnit.where { physicalQuantity == u && quantityUnit == r }.deleteAll()
    
            if (flush) { QuantityStandardUnit.withSession { it.flush() } }
    
            rowCount
        }
    
        static void removeAll(PhysicalQuantity u, boolean flush = false) {
            if (u == null) return
    
            QuantityStandardUnit.where { physicalQuantity == u }.deleteAll()
    
            if (flush) { QuantityStandardUnit.withSession { it.flush() } }
        }
    
        static void removeAll(QuantityUnit r, boolean flush = false) {
            if (r == null) return
    
            QuantityStandardUnit.where { quantityUnit == r }.deleteAll()
    
            if (flush) { QuantityStandardUnit.withSession { it.flush() } }
        }
    
        static constraints = {
            quantityUnit validator: { QuantityUnit r, QuantityStandardUnit ur ->
                if (ur.physicalQuantity == null || ur.physicalQuantity.id == null) return
                boolean existing = false
                QuantityStandardUnit.withNewSession {
                    existing = QuantityStandardUnit.exists(ur.physicalQuantity.id, r.id)
                }
                if (existing) {
                    return 'quantityStandardUnit.exists'
                }
            }
        }
    
        static mapping = {
            id composite: ['physicalQuantity', 'quantityUnit']
            version false
        }
    }
    

     

     

    展开全文
  • 1.在开发中有时一个主键是不能确定该数据,通过组合主键,hibernate也考虑到了; 看代码:
  • 组合主键映射

    2017-08-01 08:53:02
    组合主键映射是指主键是多列的组合,因为考虑到数据库的优化,现在在设计数据库时很少使用。 组合主键映射需要在映射配置文件中使用标签,该标签是指将一个类指定为相应的组合主键,它的name属性需要指定类文件中...
  • 【Hibernate教程】组合主键映射

    万次阅读 2016-12-26 22:43:27
    1、编写组合主键的类,该类必须实现Serializable接口 生成对应的get/set方法;最好实现equals和hashCode方法 2、在主类中引用对应组件 3、映射文件的编写 4、测试代码 5.数据库中Score表
  • Hibernate复合主键

    2018-06-03 21:05:34
    一个简单的复合主键的做关联类的例子
  • sql server创建复合主键的2种方法,需要的朋友可以参考一下
  • 主要介绍了mybatis-plus实体类主键策略有3种(小结),文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • JPA_5_联合主键

    2016-05-30 22:22:17
    针对JPA资料进行整理,根据传智播客的教学视频,边看边写,文档包含了jpa的基本概念,相关注解解释,及一些增删改查的demo。本文档方便了对jpa的学习与复习,快速掌握基本操作。
  • 组合主键resultMap解决方案

    千次阅读 2019-05-08 23:02:06
    Mybatis ResultMap Collection 复合主键 <id property="name" column="colname"/> <collection property="list" javaType="ArrayList" column="{id = colid,name=colname}" select="getSubXXX"/&g...
  • 在我们开发的过程中,总感觉一张表就一个主键。但是事情往往没有我们想象的那么简单,一张表其实也是可以有多个主键。 如上图所示,其实说多个主键也不对,可以说是复合主键。意思为 这2个字段都不是唯一的,2个...
  • 为什么不能有其他的组合呢?两个表的主键放在一起不可以吗?不也是唯一确定吗?而且既然可以选City列,那么LanguageName不也是一个没有重复值得列吗? ![图片说明]...
  •    将所有的主键集合为单独一个类,作为一个组件。将组件注解为@Embeddedable,并将组件的属性注解为@Id。将组件的属性注解为@EmbeddedId。将表类注解为@IdClass(主键类.Class),并将该实体中所有属于...
  • hibernate+jpa中的组合主键与系统表的实体映射 关于hibernate中的组合主键,相信很多人都已经很清楚了。 建立对应的ID实体并实现Serializable接口,在目标实体中加入ID对象并注解Id或EmbeddedId(具体可自行查阅)...
  • 当表中一个主键不能唯一标识一条记录的时候,就需要使用联合主键了,下面是使用JPA注解实现联合主键的代码1 首先需要建立一个复合主键类,用来存放需要生产联合主键的属性,该类需要实现序列化。package ...
  • mysql 主键索引,组合索引,单列索引使用场景 CREATE TABLE button ( id bigint(20) NOT NULL AUTO_INCREMENT, --主键索引 button_name varchar(45) NOT NULL COMMENT ‘功能名称’, app_id bigint(20) NOT NULL, ...
  • 添加组合主键

    2010-06-22 15:49:00
    create table xlfkzz_cs ( xlfkzz01 varchar(20), xlfkzz02 varchar(20) not null, xlfkzz03 datetime not null, xlfkzz04 varchar(20) ...add constraint pk_xlfkzz_...
  • 如果数据库中用多个字段而不仅仅是一个字段作为主键,也就是联合主键,这个时候就可以使用hibernate提供的联合主键生成策略。 具体如下: 可以使用一个组件作为一个实体类的标识符。你的组件类必须满足以下要求: ...
  • postgreSQL复合主键

    2013-02-27 09:31:37
    关于postgreSQL复合主键的一些用法,希望对大家有用。
  • sql 复合主键 联合主键 If you’ve already worked with databases, then you could hardly miss the term – Primary Key (PK). And if you’re reading this series and use it to learn about databases, well,...
  • 但是可以有两个字段组合成一个主键,这就是为什么有时候表里为什么会有两个字段都有主键的标志,那是因为他们组合成了一个主键了。 我们可以先删除了原来的主键再用TSQL建alter table tablename add constraint pk_...
  • 测试组合主键取值------需要实现Serializable接口 b.第二种方式-----把组合主键类提取出来,优于第一种方式 c.第三种方式 测试-----注意Student对象和Subject对象是从数据库中取出来的已有数据 ...
  • MySQL如何创建主键,外键和复合主键

    千次阅读 2019-10-28 14:36:13
    1.主键语法 ①创建时:create table sc ( studentnoint, courseidint, scoreint, primary key (studentno) ); ②修改时:ALTER TABLE table_name ADD CONSTRAINT pk_name PRIMARY KEY(列名); 前提是原先没有...
  • JPA复合主键配置方式

    2021-02-02 10:15:35
    spring boot项目中如果需要使用符合主键,单纯的使用@Id是无法达到的,只使用@Id只能定义单一主键。需要使用@IdClass类注解来标明复合主键。 @Target({TYPE}) @Retention(RUNTIME) public @interface IdClass { /...
  • sql-创建复合主键

    2021-05-20 08:10:31
    2、所谓的一张表多个主键,我们称之为复合主键(联合主键)。 注:联合主键:就是用多个字段一起作为一张表的主键。 二、创建复合主键(联合主键)有两种方法: 法1:创建表是 创建复合主键 Create Table ...
  • 一个表中不能有多个独立的主键,但是一个表中可以有联合主键(即多个字段组合)。 一、查看主键 SELECT * FROM USER_CONSTRAINTS WHERE CONSTRAINT_TYPE='P' AND TABLE_NAME='你要查看的表名' AND OWNER=USER; ...
  • 主键约束----复合主键

    2020-01-12 18:33:29
    主键约束 (一)概述 1、关键字 :primary key 2、特点:增加主键约束的列(字段)的值必须是非空 + 唯一的,一个表只有一个主键约束 3、作用:保证表中不会出现两条无法区分的记录 4、要求:每一张表都必须有主键...
  • InnoDB和主键

    2019-10-31 20:56:31
    InnoDB和主键 MySQL是被广泛应用的数据库,InnoDB又是用得最广的存储引擎,主键又是对InnoDB性能影响最大的因素之一,主键选择对,可以极大提升性能。 InnoDB建表时,可不可以不声明主键? 可以不声明主键,但必须...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 104,293
精华内容 41,717
关键字:

组合主键