精华内容
下载资源
问答
  • 什么是数据库? 数据库(Database)是按照数据结构来组织、存储和管理数据仓库 什么是关系型数据库,主键,外键,索引分别是什么?... 在关系数据库中,索引是一种单独、物理对数据库表中一或多列的

    什么是数据库?

    	数据库(Database)是按照数据结构来组织、存储和管理数据的仓库
    

    什么是关系型数据库,主键,外键,索引分别是什么?

    		关系型数据库是由多张能互相联接的二维行列表格组成的数据库
    		主关键字(primary key)是表中的一个或多个字段,它的值用于唯一地标识表中的某一条记录
    		外键表示了两个关系之间的相关联系。以另一个关系的外键作主关键字的表被称为主表,具有此外键的表被称
    		为主表的从表。外键又称作外关键字
    		在关系数据库中,索引是一种单独的、物理的对数据库表中一列或多列的值进行排序的一种存储结构,它是某
    		个表中一列或若干列值的集合和相应的指向表中物理标识这些值的数据页的逻辑指针清单
    

    主流数据库

    **oralce  数据库**  
        Oracle Database,又名Oracle RDBMS,或简称Oracle。是甲骨文公司的一款关系数据库管理系统。它是在数据库领域一直处于领先地位的产品。可以说Oracle数据库系统是目前世界上流行的关系数据库管理系统,系统可移植性好、使用方便、功能强,适用于各类大、中、小、微机环境。它是一种高效率、可靠性好的 适应高吞吐量的数据库解决方案。
    

    mysql
    MySQL是一个关系型数据库管理系统,由瑞典MySQL AB 公司开发,目前属于 Oracle 旗下产品。MySQL 是最流行的关系型数据库管理系统之一,在 WEB 应用方面,MySQL是最好的 RDBMS (Relational Database Management System,关系数据库管理系统) 应用软件。
    MySQL是一种关系数据库管理系统,关系数据库将数据保存在不同的表中,而不是将所有数据放在一个大仓库内,这样就增加了速度并提高了灵活性。
    MySQL所使用的 SQL 语言是用于访问数据库的最常用标准化语言。MySQL 软件采用了双授权政策,分为社区版和商业版,由于其体积小、速度快、总体拥有成本低,尤其是开放源码这一特点,一般中小型网站的开发都选择 MySQL 作为网站数据库。
    由于其社区版的性能卓越,搭配 PHP 和 Apache 可组成良好的开发环境。

    **DB2** 
       IBM DB2 是美国IBM公司开发的一套关系型数据库管理系统,它主要的运行环境为UNIX(包括IBM自家的AIX)、Linux、IBM i(旧称OS/400)、z/OS,以及Windows服务器版本。
    DB2主要应用于大型应用系统,具有较好的可伸缩性,可支持从大型机到单用户环境,应用于所有常见的服务器操作系统平台下。 DB2提供了高层次的数据利用性、完整性、安全性、可恢复性,以及小规模到大规模应用程序的执行能力,具有与平台无关的基本功能和SQL命令。DB2采用了数据分级技术,能够使大型机数据很方便地下载到LAN数据库服务器,使得客户机/服务器用户和基于LAN的应用程序可以访问大型机数据,并使数据库本地化及远程连接透明化。 DB2以拥有一个非常完备的查询优化器而著称,其外部连接改善了查询性能,并支持多任务并行查询。 DB2具有很好的网络支持能力,每个子系统可以连接十几万个分布式用户,可同时激活上千个活动线程,对大型分布式应用系统尤为适用
    
    
    **SQLserver数据库**
    美国Microsoft公司推出的一种关系型数据库系统。SQL Server是一个可扩展的、高性能的、为分布式客户机/服务器计算所设计的数据库管理系统,实现了与WindowsNT的有机结合,提供了基于事务的企业级信息管理系统方案。
    
    **SQLite**
    是一款轻型的数据库,是遵守ACID的关系型数据库管理系统,它包含在一个相对小的C库中。它是D.RichardHipp建立的公有领域项目。它的设计目标是嵌入式的,而且目前已经在很多嵌入式产品中使用了它,它占用资源非常的低,在嵌入式设备中,可能只需要几百K的内存就够了。它能够支持Windows/Linux/Unix等等主流的操作系统,同时能够跟很多程序语言相结合,比如 Tcl、C#、PHP、Java等,还有ODBC接口,同样比起Mysql、PostgreSQL这两款开源的世界著名数据库管理系统来讲,它的处理速度比他们都快。SQLite第一个Alpha版本诞生于2000年5月。 至2015年已经有15个年头,SQLite也迎来了一个版本 SQLite 3已经发布。
    
    展开全文
  •  答:在我们不知道具体有什么数据时候,也即未知,可以用NULL,我们空,ORACLE,含有空值长度零。ORACLE允许任何一种数据类型字段空,除了以下两种情况:  1、主键字段(primary key), ...

    问:什么是NULL?

      答:在我们不知道具体有什么数据的时候,也即未知,可以用NULL,我们称它为空,ORACLE中,含有空值的表列长度为零。ORACLE允许任何一种数据类型的字段为空,除了以下两种情况:

      1、主键字段(primary key),

      2、定义时已经加了NOT NULL限制条件的字段。

     

    附加说明:

      1、等价于没有任何值、是未知数。

      2、NULL与0、空字符串、空格都不同。

      3、对空值做加、减、乘、除等运算操作,结果仍为空。

      4、NULL的处理使用NVL函数。

      5、比较时使用关键字用“is null”和“is not null”。

      6、空值不能被索引,所以查询时有些符合条件的数据可能查不出来,

      count(*)中,用nvl(列名,0)处理后再查。

      7、排序时比其他数据都大(索引默认是降序排列,小→大),

      所以NULL值总是排在最后。

      使用方法:

     1 SQL> select 1 from dual where null=null;
     2 没有查到记录
     3 SQL> select 1 from dual where null='';
     4 没有查到记录
     5 SQL> select 1 from dual where ''='';
     6 没有查到记录
     7 SQL> select 1 from dual where null is null;
     8         1
     9 ---------
    10         1
    11 SQL> select 1 from dual where nvl(null,0)=nvl(null,0);
    12         1
    13 ---------
    14         1
    15 

    对空值做加、减、乘、除等运算操作,结果仍为空。

    1 SQL> select 1+null from dual;
    2 SQL> select 1-null from dual;
    3 SQL> select 1*null from dual;
    4 SQL> select 1/null from dual;

      查询到一个记录。

      注:这个记录就是SQL语句中的那个null

      设置某些列为空值

      update table1 set 列1=NULL where 列1 is not null;

      现有一个商品销售表sale,表结构为:

      month  char(6)  ——月份

      sellnumber(10,2) ——月销售金额

     1 create table sale (month char(6),sell number);
     2 insert into sale values('200001',1000);
     3 insert into sale values('200002',1100);
     4 insert into sale values('200003',1200);
     5 insert into sale values('200004',1300);
     6 insert into sale values('200005',1400);
     7 insert into sale values('200006',1500);
     8 insert into sale values('200007',1600);
     9 insert into sale values('200101',1100);
    10 insert into sale values('200202',1200);
    11 insert into sale values('200301',1300);
    12 insert into sale values('200008',1000);
    13 insert into sale(monthvalues('200009');
    14          (注意:这条记录的sell值为空)
    15 commit;

    共输入12条记录,此时我们做如下的查询:

    SQL> select * from sale where sell like '%';
    MONTH       SELL
    ------ ---------
    200001      1000
    200002      1100
    200003      1200
    200004      1300
    200005      1400
    200006      1500
    200007      1600
    200101      1100
    200202      1200
    200301      1300
    200008      1000

      查询到11记录。

      结果说明:

      查询结果说明此SQL语句查询不出列值为NULL的字段

      此时需对字段为NULL的情况另外处理。

    SQL> select * from sale where sell like '%' or sell is null;
    SQL
    > select * from sale where nvl(sell,0like '%';
           
    MONTH       SELL
    ------ ---------
    200001      1000
    200002      1100
    200003      1200
    200004      1300
    200005      1400
    200006      1500
    200007      1600
    200101      1100
    200202      1200
    200301      1300
    200008      1000
    200009

      查询到12记录,Oracle的空值就是这么的用法,我们最好熟悉它的约定,以防查出的结果不正确。

        对于NULL而言还有一个特殊的用法:

    select NULL from sale where sell>1500;

        以上语句中并没有什么特殊的含义,它只是想得到是否有符合条件的记录,而不在乎取出什么字段,于是用NULL来代替一下。

      总结:null就是null,和别的类型没有可比性。

    展开全文
  • 你可能听到用户在提到行(row)时为数据库记录(record)。在很大程度上,这两个术语是可以互相替代,但从技术上说,行才是正确术语。 主键 表每一行都应该有可以唯一标识自己(或一组)。一个...

    表中的数据是按行存储的,所保存的每个记录存储在自己的行内。

    如果将表想象为网格,网格中垂直的列为表列,水平行为表行。例如,顾客表可以每行存储一个顾客。表中的行数为记录的总数。

    行(row) 表中的一个记录。是记录还是行? 你可能听到用户在提到行(row)时称其为数据库记录(record)。在很大程度上,这两个术语是可以互相替代的,但从技术上说,行才是正确的术语。

    主键
    表中每一行都应该有可以唯一标识自己的一列(或一组列)。一个顾客表可以使用顾客编号列,而订单表可以使用订单ID,雇员表可以使用雇员ID或雇员社会保险号。
    主键(primary key)

    ①一一列(或一组列),其值能够唯一区分表中每个行。

    唯一标识表中每行的这个列(或这组列)称为主键。主键用来表示一个特定的行。没有主键,更新或删除表中特定行很困难,因为没有安全的方法保证只涉及相关的行。

    应该总是定义主键 虽然并不总是都需要主键,但大多数数据库设计人员都应保证他们创建的每个表具有一个主键,以便于以后的数据操纵和管理。表中的任何列都可以作为主键,只要它满足以下条件:

    1/都不具有相同的主键值;
    2/每个行都必须具有一个主键值(主键列不允许NULL值)。

    主键值规则 这里列出的规则是MySQL本身强制实施的。主键通常定义在表的一列上,但这并不是必需的,也可以一起使用多个列作为主键。在使用多列作为主键时,上述条件必须应用到构成主键的所有列,所有列值的组合必须是唯一的。

    主键的最好习惯 除MySQL强制实施的规则外,应该坚持的几个普遍认可的最好习惯为:
    1/ 不更新主键列中的值;
    2/ 不重用主键列的值;
    3/ 不在主键列中使用可能会更改的值。例如,如果使用一个名字作为主键以标识某个供应商,当该供应商合并和更改其名字时,必须更改这个主键。

    展开全文
  • 数据库学习

    2018-11-27 21:04:00
     在关系数据库中,索引是一种单独的、物理的对数据库表中一或多的值进行排序的一种存储结构;也之为key  索引的作用相当于图书的目录,可以根据目录中的页码快速找到所需的内容。  为什么需要索引  思考...

      今天学习了数据库的索引和面向对象中的元类

      一、索引

        什么是索引

          在关系数据库中,索引是一种单独的、物理的对数据库表中一列或多列的值进行排序的一种存储结构;也称之为key

          索引的作用相当于图书的目录,可以根据目录中的页码快速找到所需的内容。

        为什么需要索引

          思考:一个项目正常运行后,对数据库的操作中,哪些操作是最频繁的?

          对数据库的写操作(增加、删除、修改)频繁吗?

          对数据库的读操作(查询)频繁吗?

          相比较下,对数据的读操作会更加频繁,比例在10:1左右,也就是说对数据库的查询操作是非常频繁的

          随着时间的推移,表中的记录会越来越多,此时如果查询速度太慢的话对用户体验是非常不利的

          索引是提升查询效率最有效的手段

          在数据库中插入数据会引发索引的重建

          简单的说索引就是用来帮我们加快查询速度的

        索引的实现原理

          如何能实现加快查询的效果

            索引最终的目的是要尽可能降低io次数,减少查找的次数,以最少的io找到需要的数据,此时B+树闪亮登场

            光有数据结构还不行,还需要有对应的算法做支持,就是二分查找法

            有了B+数据结构后查找数据的方式就不再是逐个的对比了,而是通过二分查找法来查找

            另外,其实大多数文件系统都是使用B+来完成的!

          应该尽可能的将数据量小的字段作为索引,这样一个叶子节点能存储的数据就更多,从而降低树的高度;

          例如:name和id,应当将id设置为索引而不是name

        聚集索引

          叶子节点保存的就是完成的一行记录,如果设置了主键,主键就作为聚集索引

          如果没有主键,则找第一个NOT NULL 且 QUNIQUE的列作为聚集索引

          如果也没有这样的列,innoDB会在表内自动产生一个聚集索引,它是自增的

        辅助索引

          除了聚集索引之外的索引都称之为辅助索引或第二索引,包括foreign key 与 unique

          辅助索引的特点:

          其叶子节点保存的是索引数据与所在行的主键值,InnoDB用这个 主键值来从聚集索引中搜查找数据

        覆盖索引

          覆盖索引指的是需要的数据仅在辅助索引中就能找到:

          

    # 假设stu表的name字段是一个辅助索引
    select name from stu where name = "jack";

          这样的话则不需要再查找聚集索引数据已经找到

        回表

          如果要查找的数据在辅助索引中不存在,则需要回到聚集索引中查找,这种现象称之为回表

    # name字段是一个辅助索引 而sex字段不是索引
    select sex from stu where name = "jack";

          需要从辅助索引中获取主键的值,再拿着主键值到聚集索引中找到sex的值

          查询速度对比:

          聚集索引 > 覆盖索引 > 非覆盖索引

        正确使用索引

          案例:

          首先准备一张表数据量在百万级别

    create table usr(id int, name char(10),gender char(3),email char(30));
    #准备数据
    delimiter //
    create procedure addData(in num int)
    begin
    declare i int default 0;
    while i < num do
        insert into usr values(i,'jack','m',concat('xxxx',i,'@qq.com'));
    set i = i+1;
    end while;
    end //
    delimiter ;
    #执行查询语句  观察查询时间
    select count(*) from usr where id = 1;
    # 1 row in set (3.85 sec)
    # 时间在秒级别 比较慢
    
    
    1.
    # 添加主键
    alter table usr add primary key(id);
    # 再次查询
    select count(*) from usr where id = 1;
    # 1 row in set(0.00 sec)
    # 基于在毫秒级就能完成 提升非常大
    
    2.
    # 当条件为范围查询时
    select count(*) from usr where id > 1;
    # 速度依然很慢 对于这种查询没有办法可以优化因为需要的数据就是那么多
    # 缩小查询范围  速度立马就快了
    select count(*) from usr where id > 1 and id < 10;
    
    #当查询语句中匹配字段没有索引时 效率测试 
    select count(*) from usr where name = 'jack';
    # 1 row in set (2.85 sec)
    # 速度慢
    
    
    
    3.
    # 为name字段添加索引
    create index name_index on usr(name);
    # 再次查询
    select count(*) from usr where name = 'jack';
    # 1 row in set (3.89 sec)
    # 速度反而降低了 为什么?
    # 由于name字段的区分度非常低 完全无法区分 , 因为值都相同 这样一来B+树会没有任何的子节点,像一根竹竿每一次都匹配 相当于有几条记录就有几次io , 所以要注意 区分度低的字段不应该建立索引,不能加速查询反而降低写入效率,
    # 同理 性别字段也不应该建立索引,email字段更加适合建立索引
    
    # 修改查询语句为
    select count(*) from usr where name = 'aaaaaa';
    # 1 row in set (0.00 sec) 速度非常快因为在树根位置就已经判断出树中没有这个数据 全部跳过了
    # 模糊匹配时
    select count(*) from usr where name like 'xxx'; #
    select count(*) from usr where name like 'XXX%'; #
    select count(*) from usr where name like '%xxx'; #
    # 由于索引是比较大小 会从左边开始匹配 很明显所有字符都能匹配% 所以全都匹配了一遍
    
    4.索引字段不能参加运算
    select count(*) from usr where id * 12 = 120;
    # 速度非常慢原因在于 mysql需要取出所有列的id 进行运算之后才能判断是否成立
    # 解决方案
    select count(*) from usr where id = 120/12;
    # 速度提升了 因为在读取数据时 条件就一定固定了 相当于
    select count(*) from usr where id = 10;
    # 速度自然快了
    
    5.有多个匹配条件时 索引的执行顺序 and和or
    # 先看and
    # 先删除所有的索引
    alter table usr drop primary key;
    drop index name_index on usr;
    
    #测试
    select count(*) from usr where name = 'jack' and gender = 'm' and id = 1 and email = 'xxxx2@qq.com';
    #1 row in set (1.34 sec) 时间在秒级
    
    # 为name字段添加索引
    create index name_index on usr(name);
    # 测试
    select count(*) from usr where name = 'jack' and gender = 'm' and id = 1 and email 'xxxx2@qq.con';
    # 1 row in set (17.82 sec) 反而时间更长了
    
    # 为gender字段添加索引
    create index gender_index on usr(gender);
    # 测试
    select count(*) from usr where name = 'jack' and gender = 'm' and id = 1 and email = 'xxxx2@qq.com';
    # 1 row in set (16.83 sec) gender字段任然不具备区分度
    
    # 为id加上索引
    alter table usr add primary key(id);
    # 测试
    select count(*) from usr where name = 'jack' and gender = 'm' and id = 1 and email = 'xxxx1@qq.com';
    # 1row in set (0.00 sec) id 字段区分度高 速度提升
    # 虽然三个字段都有索引 mysql并不是从左往右傻傻的去查 而是找出一个区分度高的字段优先匹配
    # 改为范围匹配
    select count(*) from usr where name = 'jack' and gender = 'm' and id > 1 and email = 'xxxx1@qq.com';
    # 速度变慢了
    
    # 删除id 索引 为email建立索引
    alter table usr drop primary key;
    create index email_index on usr(email);
    # 测试
    select count(*) from usr where name = 'jack' and gender = 'm' and id  =1 and email = 'xxxx2@qq.com';
    # 1 row in set(0.00 sec) 速度非常快
    # 对于 or条件 都是从左往右匹配
    select count(*)  from usr where name = 'jackxxxx' or email = 'xxxx0@qq.com';
    # 注意 必须or两边都有索引才会使用索引
    
    6.多字段联合索引
    为什么需要联合索引
    案例:
    select count(*) from  usr where name = 'jack' and gender = 'm' and id >3 and email = 'xxxx2@qq.com';
    假设所有字段都是区分度非常高的字段,那么除了id为谁添加索引都能够提升速度,但是如果sql语句中没有出现所有字段,那就无法加速查询,最简单的办法是为每个字段都加上索引,但是索引也是一种数据,会占用内存空间,并且降低写入效率
    此处就可以使用联合索引,
    联合索引最重要的是顺序 按照最左匹配原则 应该将区分度高的放在左边 区分度低的放到右边
    # 删除其他索引
    drop index name_index on usr;
    drop index email_index on usr;
    # 联合索引
    create index mul_index on usr(email,name,gender,id);
    # 查询测试
    select count(*) from usr where name = 'xx' and id = 1 and email = 'xx';
    只要语句中出现了最左侧的索引(email)无论在前在后都能提升效率
    drop index mul_index on usr;

      二、元类

          1.什么是元类

            一切源自于一句话:python中一切皆为对象。既然如此类是不是也是对象呢?

    class Teacher(object):
        school = 'tsinghua'
        def __init__(self,name,age):
            self.name = name
            self.age = age
        def say(self):
            print('%s says welcome to the Beijing' %self.name)
    
    t1 = oldboyTeacher('egon',18)
    print(type(t1))    #查看对象t1的类是<class '__main__.oldboyTeacher'>

        所有的对象都是实例化或者说调用类而得到的(调用类的过程称之为类的实例化),比如对象t1是调用类Teacher得到的

        一切皆对象的话  类也必然是一个对象,验证一下

      

    tcls = Teacher
    li = [Teacher]
    def func(cls):
        print(cls)
    func(Teacher)
    # 完全没问题把他当作对象来使用 和其他对象没有任何区别

        t1是通过Teacher实例化得到的,那Teacher对象是哪个类实例化的呢?

    print(type(Teacher))
    # <class 'type'>

        可以推导出===>产生Teacher的过程一定发生了:Teacher = type(...)

        用于实例化产生类的类称之为元类 就是此时的type类;

        Teacher是通过type实例化得到的,既然如此,是不是可以自己调用type来实例化一个class呢?

        2.创建类的流程分析

          class关键字在帮我们创建类时,必然帮我们调用了元类Teacher = type(...),那调用type时传入的参数是什么呢?必然是类的关键组成部分,一个类有三大组成部分,分别是

          1.类名class_name = 'Teacher'

          2.基类们class_bases = (object,)

          3.类的名称空间class_dic,类的名称空间是执行类体代码而得到的

          调用type时会依次传入以上三个参数

          自己来实例化一个类

        

    class_name = 'Teacher'
    class_body = '''
        def __init__(self,name,age):
            self.name = name
            self.age = age
        def say(self):
            print('%s says welcome to the Beijing' %self.name)      
    '''
    class_dic = exce(class_body)
    bases = (object,)
    Teacher = type(class_name
    ,bases
    ,class_body)

          综上,class关键字帮我们创建一个类应该细分为以下四个过程

          1.获取类名

          2.获取基类

          3.获取名称空间

          4.实例化元类得到类

        补充__call__函数得到执行时机

        该方法会在调用对象时自动触发执行(对象加括号)

    class Foo:
        def _-call__(self,*args,**kwargs):
            print('run')
    f = Foo()
    f()

        自定义元类控制类的创建

          一个类没有声明自己的元类,默认他的元类就是type,除了使用内置元类type,我们也可以通过继承type来自定义元类,然后使用metaclass关键字参数为一个指定元类

    class Mymeta(type):    #只有继承了type类才能称之为一个元类,否则就是一个普通的自定义类
        pass
    class Teacher(object,metaclass = Mymeta):    #Teacher = Mymete('Teacher',(object),{...})
        school = 'tsinghua'
        def __init__(self,name,age):
            self.name = name
            self.age = age
        def say(self):
            print('%s says welcome to the Beijing'%self.name)

        需求

        1.规范类名必须大写

        2.类中必须包含文档注释

    class MyMate(type):
        def __init__(self,name,bases,dic):
            print('run')
            if not dic.get('__doc__')
                raise TypeError('类必须有文档注释!')
            if not name.istitle():
                raise TypeError('类名必须大写开头!')
            super().__init__(name,bases,dic)
    class Foo(object,metaclass = MyMate):
        pass

        自定义元类控制类的调用

          控制类的调用过程 关键在于call函数,类也是对象,调用类必然也会执行call函数

    class MyMate(type):
        def __init__(self,name,bases,dic):
            print('run')
            if not dic.get('__doc__'):
                raise TypeError('类必须有文档注释!')
            if not name.istitle():
                raise TypeError('类名必须大写开头!')
            super().__init__(name,bases,dic)
        def __call__(self,*args,**kwargs):
            #创建空对象
            #调用init
            #返回初始化后的对象
            obj = object.__new__(self)
            self.__init__(obj,*args,**kwargs)
            return obj
    class Foo(object,metaclass = MyMate):
        def __init__(self):
            print('初始化对象')
        pass
    f = Foo()
    print(f)

      元类实现单例

          什么是单例,

          单例指的是单个实例,值一个类只能有一个实例对象

          为什么要用单例

          当一个类的实例中的数据不会变化时使用单例,数据是不变的

          例如开发一个音乐播放器程序,音乐播放器可以封装为一个对象,那你考虑一下,当你切歌的时候,是重新创建一个播放器,还是使用已有的播放器?

          因为播放器中的数据和业务逻辑都是相同的没有必要创建新的,所以最好使用单例模式,以节省资源,

    #使用classmethod 实现单例
    class Player():
        def __init__(self):
            print('创建播放器了')
        __play = None
        @classmethod
        def get_player(cls):
            if not cls.__play:
                cls.__play = Player()
            return cls.__play
    
    p1 = Player.get_player();
    p1 = Player.get_player();
    p1 = Player.get_player();
    p1 = Player.get_player();

        该方法无法避免使用者直接调用类来实例化,这样就不是单例了

        使用元类实现单例模式

    class MyMetaClass(type):
        instance = None
        def __call__(cls,*args,**kwargs):
            if not MyMetaClass.instance:
                MyMetaClass.instance = object.__new__(cls)
              print('创建新的播放器对象')
                MyMetaClass.instance.__init__(*args,**kwargs)
            return MyMetaClass.instance
    
    class CDPlayer(metaclass = MyMetaClass):
        def play(self,music):
            print('切换音乐',music)
        def __init__(self,music_name):
            self.music_name = music_name
    
    p1 = CDPlayer('你发如雪!')
    p1.play('菊花台')
    p1.play('时光机')

     

        

     

     

     

     

     

     

     

     

     

     

     

     

     

     

          

    转载于:https://www.cnblogs.com/xiaocaiyang/p/10029009.html

    展开全文
  • 两者在可空、唯一性、排序等表面特征上并没有什么...比方说,如果想定义外键(或参考约束),那么相关就必须先定义“键”。键在实现上一般都会有自己索引(主键则是有唯一索引),这个索引可能是用户显式定义
  • 数据库范式

    2020-12-09 15:09:10
    关系数据库中的关系必须满足一定的要求,满足不同程度要求的不同范式。 关系数据库有六种范式:第一范式(1NF)、第二范式(2NF)、第三范式(3NF)、巴斯-科德范式(BCNF)、第四范式(4NF)和第五范式(5NF,又...
  • 第二范式:要求一个表中只能存储一种数据,需要确保数据库中的每一都和主键相关3. 第三范式:需要确保数据表中的每一数据都和主键直接相关,而不能间接相关。三、数据库的事务性1. 事务处理2. 事务ACID属性 ...
  • 数据库-索引

    2019-09-30 15:18:13
    在关系数据库中,索引是一种单独的、物理层面的对数据库表中一或多的值进行排序的一种存储结构; 也key 有以下几种: unique key primary key index key 索引的作用相当于图书的目录,可以根据目录中的页码...
  • 主键:数据库对存储数据对象予以唯一和完整标识数据或属性组合,一个数据只能有一个主键,且主键取值不能缺失,既不能空值(null) 外键:一个表存在另一个表主键此表外键 什么是事务?...
  • 数据库的范式和约束

    2019-04-12 17:18:00
     第一范式:当关系模式R的数据表中的每一(每个字段)必须是不可拆分的最小单元,也就是确保每一的原子性,R是满足第一范式的,简记1NF。满足第一范式是关系模式规范化的最低要求,否则,将有很多基本操作...
  • mysql数据库—索引

    2019-09-28 17:02:54
    在关系数据库中,索引是一种单独的、物理层面的对数据库表中一或多的值进行排序的一种存储结构; 也key 有以下几种: unique key primary key index key 索引的作用相当于图书的目录,可以根据目录中的页码...
  • 数据库设计范式

    2019-10-08 00:33:09
    什么是范式:简言之就是,数据库设计对数据...第一范式:数据库每一都是不可分割原子数据项时,R是满足第一范式,简记1NF。 第二范式:要求实体属性完全依赖于主关键字。简而言之,第二范式就是...
  • Mysql数据存储以页方式存储,页大小默认16K,存放数据的称表页,存放索引的称索引页,两者存储角度没有什么区别,但是表页一般相互独立,而索引页之间关系呈树形结构。 根据树层级结构划分:根节点...
  • 索引是由Oracle维护可选结构,数据提供快速访问。准确地判断在什么地方需要使用索引是困难,使用索引有利于调节检索速度。... 1) 索引应该在SQL语句"where"或"and"部分涉及(也谓词...
  • 数据库基础知识

    2019-09-04 13:36:57
    什么是元组,码,候选码,主...码 :码就是能唯一标识实体的属性,对应表中的列。 候选码 :若关系中的某一属性或属性组的值能唯一的标识一个元组,而其任何、子集都不能再标识,则该属性组候选码。 主码 : 主码也...
  • 数据库面试知识点汇总 一、基本概念 1.主键、外键、超键、候选键 超键:在关系中能唯一标识元组属性集称为关系模式超键。一个属性可以为作为一个超键,多个属性...2.为什么用自增作为主键 如果我们定义了...
  •     ...Mysql数据存储以页方式存储,页大小默认16K,存放数据的称表页,存放索引的称索引页,两者存储角度没有什么区别,但是表页一般相互独立,而索引页之间关...
  • MySQL数据库三大范式

    2021-01-30 18:05:04
    建立科学、规范数据库需要满足一些规范,以优化数据存储方式,在关系型数据库中这些规范范式。 第一范式 每一属性都是不可再分属性值,确保每一列的原子性。第一范式是为了排除 重复组 出现,因此...
  • - 常见的数据库对象: 对象 描述 表 基本数据存储集合,由行和组成 视图 从表抽取逻辑上相关数据集合 序列 提供有规律数值 索引 提高查询效率 同义词 给对象起别名 1、Oracle...
  • 数据库三大范式详解

    2020-11-26 11:24:20
    数据库三大范式详解 1. 相关概念 1.1 什么是范式 在数据库的设计过程,要依据一定的规范/规则,这些规范/规则就是范式。这样做的目的是优化数据库的设计和存储。...时,必须拆分不同的列。简而言之
  • 算法岗面试汇总之数据库

    万次阅读 2021-04-02 20:53:20
    一、基本概念 1.主键、外键、超键、候选键 超键:在关系中能唯一标识元组属性集称为关系模式超键。一个属性可以为作为一个超键,多个属性组合在一起也...2.为什么用自增作为主键 如果我们定义了主键(PRIMARY KEY)
  • 一、基本概念 1.主键、外键、超键、候选键 超键:在关系中能唯一标识元组属性集称为关系模式超键。一个属性可以为作为一个超键,多个属性组合在一起也...2.为什么用自增作为主键 如果我们定义了主键(PRIMARY K
  • 外键(foreign key) 外键某个表中的,它包含另一个表 的主键值,定义了两个表之间的关系。 关系数据可以有效地存储和方便地处理。因此,关系数据库 的可伸缩性远比非关系数据库要好。 可伸缩性(scale) 能够...
  • 类型的列时,可以指 定一个不超过的正整数作为字符长度,例如 如果未指定长度,缺省。 确保存储在该列的所有值都具有这一长度。 数据类型的最大长度由数据库页面大 小决定,字符类型最大长度和页面大小的对应关系...
  • 一、基本概念 1.主键、外键、超键、候选键 超键:在关系中能唯一标识元组属性集称为关系模式超键。一个属性可以为作为一个超键,多个属性组合在一起也...2.为什么用自增作为主键 如果我们定义了主键(PRIMAR
  • 1.为什么需要数据库设计? 2.数据库设计3大范式 3.数据库设计步骤 4.E-R图也实体-关系图(Entity Relationship Diagram) 5.实体之间关系 二、数据库优化 1.select 字句避免使用(*) 2.索引失效...
  • 而关系是动态的、随时间不断变化的,因为关系操作在不断地更新着数据库中的数据。 表示方式 关系模式可以表示R(U,F),这里的U是属性集,F是函数依赖。 属性集是什么?一个关系里面,每一列称属性.
  • 数据库MySQL基础(4)

    2021-01-22 20:29:01
    为什么需要多表关联? 解决数据冗余问题,对数据进行拆分。 数据库设计范式 为了建立冗余较小、结构合理数据库,设计数据库时必须遵循一定规律。 在关系型数据库中这种规则就称为范式。范式是符合某一种设计要求...

空空如也

空空如也

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

数据库中的列称为什么