精华内容
下载资源
问答
  • 中已有字段设置 外键 似乎不能设置为主键即使定义时没有定义主键也会报错 如 Multiple primary key defined 1。添加新字段 alter table 表名 add 字段名 字段描述; alter table student add phone varchar(20);...

    将表中已有字段设置 外键
    似乎不能设置为主键即使定义时没有定义主键也会报错 如
    Multiple primary key defined

    1。添加新字段
    alter table 表名 add 字段名 字段描述;

    alter table student add phone varchar(20);
    

    2。设置外键
    alter table 表名 add constraint 键名 foreign key(外键名) references 主表名(主表主键名)

    alter table grade add constraint g_id foreign key(g_id) references school(id)
    

    8.一对多关系
    1.设计表
    1.班级表
    create table classes(classid int primary key auto_increment,classname varchar(20));

    2.学生表
    create table student2(studentid int primary key auto_increment,studentname varchar(20) not null,classid int,foreign key(classid) references classes(classid))
    外键格式: foreign key(外键字段名) references 表名(关联字段名)

       classid班级id是外键,需要关联classes班级表的classid主健,  
    

    2.插入数据
    1.班级表
    insert into classes values(0,“py01”),(0,“py02”),(0,“py03”),(0,“java01”),(0,“h501”),(0,“ui01”),(0,“java02”),(0,“h502”),(0,“ui02”);
    2.学生表
    insert into student2 values(0,“张三”,4);
    insert into student2 values(0,“李四”,1);
    insert into student2 values(0,“王五”,1);
    insert into student2 values(0,“赵六”,2);
    insert into student2 values(0,“田七”,1);

    注意:如果关联的外键,而外键的值在关联的表中不存在,则无法成功插入
    error: insert into student2 values(0,“胖八”,11);

    3.多表查询数据
    1.需求: 查看所有的学生姓名及其所在的班级 ?
    例:
    select student2.studentname,classes.classname from student2,classes where student2.classid = classes.classid;
    注: 1.表名.字段名 可以指定到对应表中的某个字段,在多表联合查询的时候使用
    2.在多表联合查询的时候,from后面可以跟多个表
    2.需求2: 展示py01班所有的学生?
    select student2.studentname,classes.classname from student2,classes where student2.classid = classes.classid and classes.classid=1;
    3.需求3: 展示所有学生的所有信息?
    select student2.,classes. from student2,classes where student2.classid = classes.classid;
    4.连接关系查询
    1.内连接 inner join
    1.查询所有学生及姓名 ?
    select student2.studentname,classes.classname from student2 inner join classes on student2.classid = classes.classid;
    2.左外连接 left join
    select student2.studentname,classes.classname from classes left join student2 on student2.classid = classes.classid;
    3.右外连接 right join

    4.格式:  select .... from 表1 inner/left/right join 表2  on  条件;
    

    9.多对多
    1.设计表
    1.学生表
    create table student3(studentid int primary key auto_increment,studentname varchar(20) not null);
    2.课程表
    create table courses(coursesid int primary key auto_increment,coursesname varchar(20));
    3. 学生 —课程 表即选修课表
    create table elective(studentid int,coursesid int,primary key(studentid,coursesid),foreign key(studentid) references student3(studentid),foreign key(coursesid) references courses(coursesid));

    选修课

    2.插入数据
    插入学生:
    insert into student3 values(0,“张三”);
    insert into student3 values(0,“李四”);
    insert into student3 values(0,“王五”);
    insert into student3 values(0,“赵六”);
    insert into student3 values(0,“田七”);

    插入课程:

    insert into courses values(0,“python”);
    insert into courses values(0,“java”);
    insert into courses values(0,“h5”);
    insert into courses values(0,“ui”);

    插入选修课数据:
    insert into elective values(1,1);

    insert into elective values(1,2);
    insert into elective values(1,4);
    insert into elective values(3,1);
    insert into elective values(3,4);

    insert into elective values(1,1);
    注意:如果关联了外键,而外键的值在关联的表中不存在,则无法成功插入,

    3.查询数据
    查询学生的选修课
    select student3.*,courses.* from student3,courses,elective where student3.studentid = elective.studentid and courses.coursesid = elective.coursesid;

    mysql数据库。
    多表查询时
    select … from 表1 inner/left/right join 表2 on 条件;
    假设有班级表 学生表
    inner join 内联。查询数据为两表重合部分。即学生表外键关联了班级表的部分。 而学生表外键为空部分 班级表未被关联部分 不做为查询库
    left out join/left join 左外连接 即使表1 中没有外键关联 或者 被关联 也作为查询库。
    right out join/right join 右外连接 表2 中的数据作为查询库。同左外连接。

    展开全文
  • SQLAlchemy创建,crud,聚合函数,过滤条件,外键约束,relationship 1.sqlalchemy的创建创建引擎create_engine,再创建基类Base: from sqlalchemy.ext.declarative import declarative_base,Column from ...

    SQLAlchemy创建,crud,聚合函数,过滤条件,外键约束,relationship


    1.sqlalchemy的创建

    先创建引擎create_engine,再创建基类Base:
    from sqlalchemy.ext.declarative import declarative_base,Column
    from sqlalchemy import create_engine
    
    DB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
    engine = create_engine(DB_URI)
    Base = declarative_base(engine)
    
    class Person(Base):
            __tablename__ = 'person'
            # 2. 在这个ORM模型中创建一些属性,来跟表中的字段进行一一映射。这些属性必须是sqlalchemy给我们提供好的数据类型。
            id = Column(Integer,primary_key=True,autoincrement=True)
            name = Column(String(50))
            age = Column(Integer)
    

    使用Base.metadata.create_all()来将模型映射到数据库中。

    **注意:**一旦使用Base.metadata.create_all()将模型映射到数据库中后,即使改变了模型的字段,也不会重新映射了。

    2.crud

    用session做数据的增删改查操作:

    构建session对象:所有和数据库的ORM操作都必须通过一个叫做session的会话对象来实现,通过以下代码来获取会话对象:

    *add_data:
    ```python
    from sqlalchemy.orm import sessionmaker
    engine = create_engine(DB_URI)
    session = sessionmaker(engine)()
    添加对象:
    * 创建对象,也即创建一条数据:
    
        p = Person(name='zhiliao',age=18,country='china')
       
    * 将这个对象添加到`session`会话对象中:
        
        session.add(p)
       
    * 将session中的对象做commit操作(提交):
     
        session.commit()
       
    * 一次性添加多条数据:
        
        p1 = Person(name='zhiliao1',age=19,country='china')
        p2 = Person(name='zhiliao2',age=20,country='china')
        session.add_all([p1,p2])
        session.commit()
      
    ```
    
    *seach_data:
     	# 查找某个模型对应的那个表中所有的数据:
        all_person = session.query(Person).all()
        # 使用filter_by来做条件查询
        all_person = session.query(Person).filter_by(name='zhiliao').all()
        # 使用filter来做条件查询
        all_person = session.query(Person).filter(Person.name=='zhiliao').all()
        # 使用get方法查找数据,get方法是根据id来查找的,只会返回一条数据或者None
        person = session.query(Person).get(primary_key)
        # 使用first方法获取结果集中的第一条数据
        person = session.query(Person).first()
    
    *update_data:
    	#修改对象:首先从数据库中查找对象,然后将这条数据修改为你想要的数据,最后做commit操作就可以修改数据了
        person = session.query(Person).first()
        person.name = 'ketang'
        session.commit()
    
    *delete_data:
         #删除对象:将需要删除的数据从数据库中查找出来,然后使用`session.delete`方法将这条数据从session中删除,最后做commit操作就可以了
        person = session.query(Person).first()
        session.delete(person)
        session.commit()
    
    SQLAlchemy常用数据类型:
    1. Integer:整形,映射到数据库中是int类型。

    2. Float:浮点类型,映射到数据库中是float类型。他占据的32位。

    3. Double:双精度浮点类型,映射到数据库中是double类型,占据64位。

    4. String:可变字符类型,映射到数据库中是varchar类型.

    5. Boolean:布尔类型,映射到数据库中的是tinyint类型。

    6. DECIMAL:定点类型。是专门为了解决浮点类型精度丢失的问题的。在存储钱相关的字段的时候建议大家都使用这个数据类型。并且这个类型使用的时候需要传递两个参数,第一个参数是用来标记这个字段总能能存储多少个数字,第二个参数表示小数点后有多少位。

    7. Enum:枚举类型。指定某个字段只能是枚举中指定的几个值,不能为其他值。在ORM模型中,使用Enum来作为枚举,示例代码如下:

      ```python
      class Article(Base):
          __tablename__ = 'article'
          id = Column(Integer,primary_key=True,autoincrement=True)
          tag = Column(Enum("python",'flask','django'))
      ```
      

      ​ 在Python3中,已经内置了enum这个枚举的模块,我们也可以使用这个模块去定义相关的字段。示例代码如下:

      ```python
      class TagEnum(enum.Enum):
          python = "python"
          flask = "flask"
          django = "django"
      ```
      
      class Article(Base):
          __tablename__ = 'article'
          id = Column(Integer,primary_key=True,autoincrement=True)
          tag = Column(Enum(TagEnum))
      
      article = Article(tag=TagEnum.flask)
      
      
      1. Date:存储时间,只能存储年月日。映射到数据库中是date类型。在Python代码中,可以使用datetime.date来指定。示例代码如下:

        class Article(Base):
            __tablename__ = 'article'
            id = Column(Integer,primary_key=True,autoincrement=True)
            create_time = Column(Date)
        
        article = Article(create_time=date(2017,10,10))
        
      2. DateTime:存储时间,可以存储年月日时分秒毫秒等。映射到数据库中也是datetime类型。在Python代码中,可以使用datetime.datetime来指定。示例代码如下:

        class Article(Base):
            __tablename__ = 'article'
            id = Column(Integer,primary_key=True,autoincrement=True)
            create_time = Column(DateTime)
        
        article = Article(create_time=datetime(2011,11,11,11,11,11))
        
      3. Time:存储时间,可以存储时分秒。映射到数据库中也是time类型。在Python代码中,可以使用datetime.time来至此那个。示例代码如下:

        class Article(Base):
            __tablename__ = 'article'
            id = Column(Integer,primary_key=True,autoincrement=True)
            create_time = Column(Time)
        
        article = Article(create_time=time(hour=11,minute=11,second=11))
        
      4. Text:存储长字符串。一般可以存储6W多个字符。如果超出了这个范围,可以使用LONGTEXT类型。映射到数据库中就是text类型。

      5. LONGTEXT:长文本类型,映射到数据库中是longtext类型。

    Column常用参数:

    1. primary_key:设置某个字段为主键。

    2. autoincrement:设置这个字段为自动增长的。

    3. default:设置某个字段的默认值。在发表时间这些字段上面经常用。

    4. nullable:指定某个字段是否为空。默认值是True,就是可以为空。

    5. unique:指定某个字段的值是否唯一。默认是False。

    6. onupdate:在数据更新的时候会调用这个参数指定的值或者函数。在第一次插入这条数据的时候,不会用onupdate的值,只会使用default的值。常用的就是update_time(每次更新数据的时候都要更新的值)。

    7. name:指定ORM模型中某个属性映射到表中的字段名。如果不指定,那么会使用这个属性的名字来作为字段名。如果指定了,就会使用指定的这个值作为参数。这个参数也可以当作位置参数,在第1个参数来指定。

      title = Column(String(50),name='title',nullable=False)
      title = Column('my_title',String(50),nullable=False)
      

    3.聚合函数

    query可用参数:
    1. 模型对象。指定查找这个模型中所有的对象。
    2. 模型中的属性。可以指定只查找某个模型的其中几个属性。
    3. 聚合函数。
      • func.count:统计行的数量。
      • func.avg:求平均值。
      • func.max:求最大值。
      • func.min:求最小值。
      • func.sum:求和。
        func上,其实没有任何聚合函数。但是因为他底层做了一些魔术,只要mysql中有的聚合函数,都可以通过func调用。
    4.过滤条件
    filter过滤条件:

    过滤是数据提取的一个很重要的功能,以下对一些常用的过滤条件进行解释,并且这些过滤条件都是只能通过filter方法实现的:

    1. equals:

      article = session.query(Article).filter(Article.title == "title0").first()
      print(article)
      
    2. not equals:

      query.filter(User.name != 'ed')
      
    3. like:

      query.filter(User.name.like('%ed%'))
      
    4. in:

      query.filter(User.name.in_(['ed','wendy','jack']))
      # 同时,in也可以作用于一个Query
      query.filter(User.name.in_(session.query(User.name).filter(User.name.like('%ed%'))))
      
    5. not in:

      query.filter(~User.name.in_(['ed','wendy','jack']))
      
    6. is null:

      query.filter(User.name==None)
      # 或者是
      query.filter(User.name.is_(None))
      
    7. is not null:

      query.filter(User.name != None)
      # 或者是
      query.filter(User.name.isnot(None))
      
    8. and:

      from sqlalchemy import and_
      query.filter(and_(User.name=='ed',User.fullname=='Ed Jones'))
      # 或者是传递多个参数
      query.filter(User.name=='ed',User.fullname=='Ed Jones')
      # 或者是通过多次filter操作
      query.filter(User.name=='ed').filter(User.fullname=='Ed Jones')
      
    9. or:

      from sqlalchemy import or_  query.filter(or_(User.name=='ed',User.name=='wendy'))
      

    如果想要查看orm底层转换的sql语句,可以在filter方法后面不要再执行任何方法直接打印就可以看到了。比如:

    ```python
        articles = session.query(Article).filter(or_(Article.title=='abc',Article.content=='abc'))
        print(articles)
    ```
    

    5.外键约束

    外键:

    使用SQLAlchemy创建外键非常简单。在从表中增加一个字段,指定这个字段外键的是哪个表的哪个字段就可以了。从表中外键的字段,必须和父表的主键字段类型保持一致。
    示例代码如下:

    class User(Base):
        __tablename__ = 'user'
        id = Column(Integer,primary_key=True,autoincrement=True)
        username = Column(String(50),nullable=False)
    
    class Article(Base):
        __tablename__ = 'article'
        id = Column(Integer,primary_key=True,autoincrement=True)
        title = Column(String(50),nullable=False)
        content = Column(Text,nullable=False)
    
        uid = Column(Integer,ForeignKey("user.id"))
    
    外键约束有以下几项: 
    1. RESTRICT:父表数据被删除,会阻止删除。默认就是这一项。 
    2. NO ACTION:在MySQL中,同RESTRICT。 
    3. CASCADE:级联删除。 
    4. SET NULL:父表数据被删除,子表数据会设置为NULL。
    
    第一种:RESTRICT(默认就是这种。当父表数据被删除,从表会拒绝删除)
    语法:uid = Column(Integer , ForeignKey("user.id" ,ondelete="RESTRICT")) 
    
    第二种:NO ACTIION(同RESTRICT 一样)
    语法: uid = Column(Integer , ForeignKey("user.id" ,ondelete="NO ACTION")) 
    
    第三种:CASCADE (父表数据删除、从表数据也会跟着删除)
    语法:uid = Column(Integer , ForeignKey("user.id" ,ondelete="CASCADE"))
    
    第四种: SET NULL (父表数据删除,从表外键字段设为NULL)
    语法:uid = Column(Integer , ForeignKey("user.id" ,ondelete="SET NULL"))
    
    注意: 如果uid字段设置了 nullable=False , 再设置 ondelete = "SET NULL",pycharm运行程序则会报错
    

    6.relationship

    ORM关系以及一对多:

    mysql级别的外键,还不够ORM,必须拿到一个表的外键,然后通过这个外键再去另外一张表中查找,这样太麻烦了。SQLAlchemy提供了一个relationship,这个类可以定义属性,以后在访问相关联的表的时候就直接可以通过属性访问的方式就可以访问得到了。示例代码:

    class User(Base):
        __tablename__ = 'user'
        id = Column(Integer,primary_key=True,autoincrement=True)
        username = Column(String(50),nullable=False)
    
        # articles = relationship("Article")
    
        def __repr__(self):
            return "<User(username:%s)>" % self.username
    
    class Article(Base):
        __tablename__ = 'article'
        id = Column(Integer,primary_key=True,autoincrement=True)
        title = Column(String(50),nullable=False)
        content = Column(Text,nullable=False)
        uid = Column(Integer,ForeignKey("user.id"))
    
        author = relationship("User",backref="articles")
    

    另外,可以通过backref来指定反向访问的属性名称。articles是有多个。他们之间的关系是一个一对多的关系

    一对一的关系:

    在sqlalchemy中,如果想要将两个模型映射成一对一的关系,那么应该在父模型中,指定引用的时候,要传递一个uselist=False这个参数进去。就是告诉父模型,以后引用这个从模型的时候,不再是一个列表了,而是一个对象了。示例代码如下:

    class User(Base):
        __tablename__ = 'user'
        id = Column(Integer,primary_key=True,autoincrement=True)
        username = Column(String(50),nullable=False)
    
        extend = relationship("UserExtend",uselist=False)
    
        def __repr__(self):
            return "<User(username:%s)>" % self.username
    
    class UserExtend(Base):
        __tablename__ = 'user_extend'
        id = Column(Integer, primary_key=True, autoincrement=True)
        school = Column(String(50))
        uid = Column(Integer,ForeignKey("user.id"))
    
        user = relationship("User",backref="extend")
    

    当然,也可以借助sqlalchemy.orm.backref来简化代码:

    class User(Base):
        __tablename__ = 'user'
        id = Column(Integer,primary_key=True,autoincrement=True)
        username = Column(String(50),nullable=False)
    
        # extend = relationship("UserExtend",uselist=False)
    
        def __repr__(self):
            return "<User(username:%s)>" % self.username
    
    class UserExtend(Base):
        __tablename__ = 'user_extend'
        id = Column(Integer, primary_key=True, autoincrement=True)
        school = Column(String(50))
        uid = Column(Integer,ForeignKey("user.id"))
    
        user = relationship("User",backref=backref("extend",uselist=False))
    
    多对多的关系:
    1. 多对多的关系需要通过一张中间表来绑定他们之间的关系。
    2. 先把两个需要做多对多的模型定义出来
    3. 使用Table定义一个中间表,中间表一般就是包含两个模型的外键字段就可以了,并且让他们两个来作为一个“复合主键”。
    4. 在两个需要做多对多的模型中随便选择一个模型,定义一个relationship属性,来绑定三者之间的关系,在使用relationship的时候,需要传入一个secondary=中间表。
    展开全文
  • 要求:请安装Kingbase数据库软件,在数据库软件中创建一个自己名字的模式,在该模式下创建学生关系数据、课程、选课表。 插入一些数据,尝试查询、更新、删除 二、相关原理与知识 (完成实验所用到的相关原理...

    一、实验题目
    已有条件:Kingbase数据库软件包。
    要求:请安装Kingbase数据库软件,在数据库软件中创建一个自己名字的模式,在该模式下创建学生关系数据表、课程表、选课表。
    插入一些数据,尝试查询、更新、删除
    二、相关原理与知识
    (完成实验所用到的相关原理与知识)
    1.定义模式
    在SQL语句中模式定义语句如下:

    CREATE SCHEMA <模式名>AUTHORIZATION<用户名>;
    

    2.定义基本表

    CREATE TABLE<表名>  (<列名><数据类型> [列级完整性约束条件]
    [,<列名><数据类型> [列级完整性约束条件]]
    …
    [,<表级完整性约束条件>]);
    

    3.数据类型:
    在这里插入图片描述
    4.查询语法:

    SELECT [ALL | DISTINCT] <目标列表达式> [,<目标列表达式>] …
    FROM <表名或视图名>[, <表名或视图名> ] …
    [ WHERE <条件表达式> ]
    [ GROUP BY <列名1> [ HAVING <条件表达式> ] ]
    [ ORDER BY <列名2> [ ASC | DESC ] ] ;
    

    注:
    SELECT子句:指定要显示的属性列;
    FROM子句:指定查询对象(基本表或视图);
    WHERE子句:指定查询条件;
    GROUP BY子句:对查询结果按指定列的值分组,该属性列值相等的元组为一个组。通常会在每组中使用集函数;
    HAVING短语:筛选出只有满足指定条件的组;
    ORDER BY子句:对查询结果按指定列值升序或降序排序。
    5.插入数据
    插入单个元组--新元组插入指定表中。
    语句格式:

        INSERT
    	INTO <表名> [(<属性列1>[,<属性列2 >…)]
    	VALUES (<常量1> [,<常量2>]    … ) ;
    

    注:
    INTO子句
    指定要插入数据的表名及属性列
    属性列的顺序可与表定义中的顺序不一致
    没有指定属性列:表示要插入的是一条完整的元组,且属性列属性与表定义中的顺序一致
    指定部分属性列:插入的元组在其余属性列上取空值
    VALUES子句
    提供的值的个数和值的类型必须与INTO子句匹配
    6.修改数据:
    语句格式:

     UPDATE  <表名>
       SET  <列名>=<表达式>[, <列名>=<表达式>]…
       [WHERE  <条件>];
    

    功能:
    修改指定表中满足WHERE子句条件的元组。
    注:
    SET子句--指定修改方式,要修改的列和修改后取值
    WHERE子句
    指定要修改的元组
    缺省表示要修改表中的所有元组
    7.删除数据
    语句格式:

    DELETE
    FROM   <表名>
    [WHERE   <条件>] ;
    

    功能:
    删除指定表中满足WHERE子句条件的元组
    注:
    WHERE子句
    指定要删除的元组
    缺省表示要修改表中的所有元组
    7.设置搜索模式路径
    SET search_path TO “S-T”;
    SET search_path TO PUBLIC;
    SET search_path TO “S-T”,PUBLIC;
    三、实验过程
    (清晰展示实际操作过程,相关截图及解释)
    1.建立以@@@命名模式;
    2.建立如下三个表:
    学生表:Student(Sno,Sname,Ssex,Sage,Sdept),用来存放学号、学生姓名、性别、年龄和所在院系,其中Sno为主码;
    课程表:Course(Cno,Cname,Cpno,Ccredit),存放课程编号、课程名称、先修课程和学分,其中Cno为主码;
    学生选课表:SC(Sno,Cno,Grade),存放学号、课程号和该名学生在此课程得分,其中主码由两个属性(Sno和Cno)组成,必须作为表级完整性进行定义,另外,注意Sno和Cno为外码,参照表分别为STUDENT和COURSE。
    建立模式和表后可以得到如下目录:
    在这里插入图片描述
    3.数据插入:
    然后向STUDENT表、COURSE表和SC表中添加学生信息。
    发挥想象,插入数据后的表如下:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    4.数据查询:
    接下来查询STUDENT表中的姓名与性别。
    使用SELECT语句对STUDENT表进行查询姓名与性别。
    在这里插入图片描述
    5.数据修改:
    修改COURSE 表中的数据,将课程号为05的信安数基的学分改为3。运行代码后,打开COURSE表,此时CCREDIT已修改为3,如图所示。
    在这里插入图片描述
    6.数据删除:
    将SC表中学号为201803006的同学,且课程代码为02,得分为92的这条数据删除。
    打开表SC可以发现,此时201803006同学在02课程中得分为92的数据已经删除。(左图为原来的SC表,右图为运行删除代码后的SC表)
    在这里插入图片描述
    在这里插入图片描述
    四、实验结果与分析
    用SQL语句建成了简单的学生选课信息系统,由三个表组成,分别为STUDENT表(用来存放学生信息,包括学号、姓名、性别、年龄、所在系),COURSE表(用来存放课程信息,内含课程号、课程名、先修课程、学分),以及SC表(由学号、课程号以及成绩组成),值得注意的是,SC表中的学号和课程号为外码,与STUDENT表和COURSE表相关。
    有了表的框架之后,发挥想象,向表中插入数据。运用书中INSERT相关内容,逐个向表中插入数据。然后对表尝试查询、更新和删除操作。查询操作后,数据库会直接给出查询所得的内容。修改操作后,系统提示语句运行正确或错误,若成功,刷新表后,即可发现数据信息修改完毕,否则依据错误提示进行修改。删除操作与修改操作相似。
    五、问题总结
    (记录所遇到的问题及解决方法)
    1.
    遇到问题:在建立表的时候找不到我所定义的名为@@@的SHAME
    解决方法:在定义表之前,加上一句SET search_path TO @@@;
    2.
    遇到问题:SQL语句中所有的标点符号均为英文字符,在写的过程中混入了中文字符,因无法识别导致运行失败。
    解决方法:将中文字符改为英文字符。
    六、源代码
    (源程序)
    建立模式:

    CREATE SCHEMA @@@
    

    建立STUDENT表:

     SET search_ path TO @@@;
    	CREATE TABLE  Student
            ( Sno     CHAR(9)  PRIMARY  KEY ,
             Sname   CHAR(20)  UNIQUE ,
             Ssex     CHAR(2) ,
             Sage     SMALLINT ,
             Sdept    CHAR(20)
    	    ) ;
    

    建立COURSE表:

        SET search_ path TO @@@;
    CREATE TABLE  Course
               (Cno     CHAR(4) PRIMARY KEY,
            	 Cname   CHAR(40) NOT NULL,            
             	 Cpno    CHAR(4),               	                      
               Ccredit   SMALLINT,
              ); 
    

    建立SC表:

     SET search_ path TO @@@;
     	CREATE TABLE  SC
               (Sno  CHAR(9), 
               Cno  CHAR(4),  
               Grade  SMALLINT,
               PRIMARY KEY (Sno,Cno),  
                          /* 主码由两个属性构成,必须作为表级完整性进行定义*/
               FOREIGN KEY (Sno) REFERENCES Student(Sno),
                         /* 表级完整性约束条件,Sno是外码,被参照表是Student */
               FOREIGN KEY (Cno) REFERENCES Course(Cno)
                         /* 表级完整性约束条件, Cno是外码,被参照表是Course*/
            ); 
    

    插入数据(部分代码):

    INSERT INTO "@@@"."SC"
             ("201801001","04","94" )
     VALUES 
             ('CHAR (9)','CHAR (4)','SMALLINT' );
    

    查询STUDENT表中的姓名与性别:

    SELECT "SNAME","SSEX"
    FROM "@@@"."STUDENT";
    

    更新COURSE表中的数据:

    UPDATE "@@@"."COURSE"
    SET "CCREDIT"='3'
    WHERE "CNO"='05';
    

    删除SC中的数据:

    DELETE "@@@."SC"
    WHERE Sno='201803006' AND Cno='02' AND Grade='92' ;
    
    展开全文
  • 数据库表创建注意事项

    千次阅读 2016-08-07 00:04:38
    1、 剔除关系不密切的字段 2、 字段命名要有规则及相对应的含义(不要一部分英文,一部分拼音,还有类似a.b.c这样不明含义的字段) 3、 字段命名尽量不要使用缩写(大多数缩写都不能明确字段含义) 4、 字段不要...

    一、      字段名及字段配制合理性

    1、        剔除关系不密切的字段

    2、        字段命名要有规则及相对应的含义(不要一部分英文,一部分拼音,还有类似a.b.c这样不明含义的字段)

    3、        字段命名尽量不要使用缩写(大多数缩写都不能明确字段含义)

    4、        字段不要大小写混用(想要具有可读性,多个英文单词可使用下划线形式连接)

    5、        字段名不要使用保留字或者关键字

    6、        保持字段名和类型的一致性

    7、        慎重选择数字类型

    8、        给文本字段留足余量

    二、      系统特殊字段处理及建成后建议

    1、        添加删除标记(例如操作人、删除时间)

    2、        建立版本机制

    三、      表结构合理性配置

    1、        多型字段的处理

    就是表中是否存在字段能够分解成更小独立的几部分(例如:人可以分为男人和女人)

    2、        多值字段的处理

    可以将表分为三张表

    这样使得检索和排序更加有调理,且保证数据的完整性!

    四、      其它建议

    1、        对于大数据字段,独立表进行存储,以便影响性能(例如:简介字段)

    2、        使用varchar类型代替char,因为varchar会动态分配长度,char指定长度是固定的。

    3、        给表创建主键,对于没有主键的表,在查询和索引定义上有一定的影响。

    4、        避免表字段运行为null,建议设置默认值(例如:int类型设置默认值为0)在索引查询上,效率立显!

    5、        建立索引,最好建立在唯一和非空的字段上,建立太多的索引对后期插入、更新都存在一定的影响(考虑实际情况来创建)。

    展开全文
  • Access创建表/新建

    千次阅读 2019-02-14 20:36:22
    这里我们不会去讲太深,像的结构,什么E-R图啊,关系啊,吧啦吧啦之类的,这里我们只讲创建表,相信很多接触Access的人都不是专业的开发人员,讲的太专业,大家看起来也累。这里我直接用Access2016的截...
  • 知识点:数据库的相关概念、创建数据库的方法、设计数据库、向数据库中插入数据、建立不同数据库之间的关系、删除数据库。 1、数据相关的一些概念 1.1 数据库里的数据是如何保存的? 数据库...
  • 建立数据库关系注意点:--清楚的查看之间的引用关系--建立引用关系,可以在新建的数据库关系图的页面中直接按鼠标左键拖拽:从主的主键向子的引用键拖动--在设计状态下建立主外键关系是从子主键关系--...
  • Oracle数据库之创建表结构

    千次阅读 2015-06-10 13:24:15
    Oracle数据库之创建表结构主键与外键主键:关系型数据库中的一条记录中有若干个属性,若其中的某一个属性组(可以是一个属性,也可以是多个)能唯一标识一条记录,那么该属性组就是主键。外键:关系型数据库中的一...
  • DDL语句--创建表

    万次阅读 2016-03-31 11:13:01
    的操作包含创建,修改,删除。这些操作都是数据库管理中最基本,也是最重要的操作。 具体而言,关于的相关操作如下: 1,创建表的方法 2,的完整性约束条件 3,查看结构的方法 4,修改的方法...
  • 操作数据库的第一步当然是创建表了,传统创建表的方法相信大多数人都知道,那么今天我除了会展示传统的建表方法之外,还会讲解LitePal这个框架的基本用法,并使用它来完成同样的建表操作,让大家体会到使用框架来...
  • Oracle创建表空间和

    千次阅读 2018-12-24 13:28:44
    创建表空间和 ORACLE物理上是由磁盘上的以下几种文件:数据文件和控制文件和LOGFILE构成的 oracle中的就是一张存储数据的空间是逻辑上的划分。方便管理的。 数据空间 (Tablespace) 存放数据总是需要空间...
  • 简单的创建数据库的 SQL语句: use master go if exists(select * from sysdatabases where name='Test') begin select '该数据库已存在' drop database Test --如果该数据库已经存在,那么就删除它 end else ...
  • mysql系列(三)创建表和删除

    千次阅读 2018-05-23 15:27:03
    2.创建表 2.1表创建基础 2.2使用NULL值 2.3 主键 2.4 使用AUTO_INCREMENT 2.5指定默认值 2.6 引擎类型 3.更新 4.重命名 5.删除 6.小结 前言 之前对mysql数据库做了一个简要的讲解,也讲了怎么...
  • neo4j创建节点之间的关系

    千次阅读 2019-04-18 10:38:35
    但是节点的关系创建有点复杂,因为需要考虑如何匹配到有关系的两个节点,以及关系本身的属性如何设置。这里我简单学一下如何建立节点之间的关系。 选择的顺序是由易到难,而不是场景的使用频率。 1,新节点+新关系+...
  • oracle创建表空间深入学习

    千次阅读 2018-07-20 15:04:59
    Oracle创建表空间和 创建表空间和 ORACLE物理上是由磁盘上的以下几种文件:数据文件和控制文件和LOGFILE构成的 oracle中的就是一张存储数据的空间是逻辑上的划分。方便管理的。 数据空间 (Tablespace...
  • 第6章 创建、修改和删除 是数据库存储数据的基本单位。 一个包含若干字段或记录。 的操作包括创建、修改和删除。 本章将讲解如何在数据库中操作,包括: 创建表的方法; 的完整性约束条件...
  • Oracle安装完后,其中有一个缺省的数据库,除了这个缺省的数据库外,我们还可以创建自己的数据库。  对于初学者来说,为了避免麻烦,可以用'Database ...关系:一个大的数据中分为几个空间,创建几个用户然后指定
  • ·数据库创建及查询 文章目录学习笔记任务过程第一步:分析需求第二步:新建数据库第三步:新建1.Grade2.Student3.subject第三步:插入数据1.Grade2.Student3.subject第四步:查询测试1.查询学号...
  • 2 创建表空间TBS 打开空间菜单,鼠标右键单击,选择“新建空间”菜单: 进入新建空间的对话框中,输入空间名称:TBS,并添加两个空间数据文件,设定相关的存储路径/大小等参数。 3 建立用户TEST 在...
  • 怎么用hibernate自动创建数据库

    万次阅读 2018-05-15 09:43:08
    跪请各路大神帮忙指点首先使用hibernate自动创建数据库肯定是要先创建一个java项目啦,老生常谈直接上图强调一下我这里用的是hibernate5.0.1,为什么强调他呢肯定是有原因的,因为新版本自动创建数据库的方式...
  • MS SQLServer 创建数据库关系

    千次阅读 2019-03-06 11:30:36
    我们会用到一些的数据库关系图,利用SQLserver本身的创建数据库关系图的功能就可以很好的画出来。 新建数据库关系图的时候常常会碰到下图的提示: 解决一: 新建查询页面当中输入该SQL语句 exec sp_...
  • MySQL-创建、修改和删除

    千次阅读 2017-06-25 18:26:04
    的操作包括创建、修改和删除,这些操作都是数据库管理中最基本、也是最重要的操作。 创建表 创建表是在已存在的数据库中建立新创建表的语法格式 MySql中,创建表是通过SQL语句create table 实现...
  • 1.显示数据库信息:通过show database命令。...4.创建表。数据库是的容器,,必须输入某个数据库。因而在创建表之前要指定数据库。1.可以通过语法指明所属的数据库。库.表语法。如果任何的标识符出现了特...
  • Neo4j-创建节点之间的关系

    万次阅读 2018-12-14 11:22:40
    但是节点的关系创建有点复杂,因为需要考虑如何匹配到有关系的两个节点,以及关系本身的属性如何设置。这里我简单学一下如何建立节点之间的关系。 选择的顺序是由易到难,而不是场景的使用频率。 1,新节点+新关系+...
  • Django创建数据

    万次阅读 2017-08-08 21:50:42
    Django创建数据 Django中,我们使用models来定义,并且尽量不要跳过Django手动操作数据。 在旧版本中用sqlall来查看Django会执行的SQL语句,新版本中sqlmigrate是最接近sqlall功能的,但并不等价。
  • PowerDesigner表关系

    千次阅读 2009-01-06 14:46:00
    1、Relationship Cardinalities Dominant role : 统制关系 A--》B 说明 B为A的从,而A为B的主 Mandatory : 强制关系 A--》B 说明:1对N或1对O,说明只有A存在 ,才能在B中插入A的主键 Dependent : 依赖关系...
  • MySQL创建关联的方法

    千次阅读 2016-11-28 12:05:32
    MySQL创建关联可以理解为是两个之间有个外键关系,但这两个必须满足三个条件 1.两个必须是InnoDB数据引擎 2.使用在外键关系的域必须为索引型(Index) 3.使用在外键关系的域必须与数据类型相似 下面分别建...
  • 哈希创建

    万次阅读 多人点赞 2015-10-06 22:28:56
    在记录的存储位置和它的关键字之间建立一个确定的对应关系f,使每个关键字和中唯一的存储位置相对应,称这个对应关系f为哈希(散列)函数,根据这个思想建立的为哈希。  若key1≠key2, 而f(key1)=f(key2), 则...
  • ER图和关系模型到MySQL数据库

    千次阅读 2020-03-02 21:01:12
    本篇主要介绍了MySQL数据库从ER图到关系模型,再到数据库创建过程及其结构的修改。通过本篇的学习,可以掌握以下内容: ● 应用ER图和关系模型创建数据库 ● 数据库结构的修改 1、mooc数据库的ER...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,005,227
精华内容 402,090
关键字:

创建表间关系应注意什么