精华内容
下载资源
问答
  • 数据库中数据表是其中最重要、最基本的操作对象,是数据存储的基本单位。 此篇博文列举了一些数据表的常用操作命令。

    在数据库中,数据表是其中最重要、最基本的操作对象,是数据存储的基本单位。
    数据表被定义为列的集合,数据在表中是按照行和列的格式来存储的。每一行代表一条唯一的记录,每一列代表记录中的一个域。

    一、 创建数据表

    ☆ 创建数据表

    在创建数据表之前,我们需要选择一个数据库,在该数据库里面进行创建数据表等相关操作:

    use db_name;  # 选择一个数据库,以便进行后续操作

    创建数据表的语句为:

    create table tb_name(
        字段名1 数据类型 [列的约束条件] [默认值],
        字段名2 数据类型 [列的约束条件] [默认值],
        ...
        [表的约束条件]
    );
    eg: 
    # 创建一个名为 info 的数据表:
    create table info(
        id int(10) ,
        name varchar(30) ,
        salary float ,
        gender int(1) 
    );

    创建完成后,可以查看当前数据库中的数据表:

        >>> show tables;
        +-------------------+
        | Tables_in_test_db |
        +-------------------+
        | info              |
        +-------------------+
        1 row in set (0.00 sec)

    ☆ 使用主键约束

    主键约束,要求主键列的数据唯一,且不允许为空。它能够唯一地标识表中的一条记录,可以结合外键类定义不同表之间的关系,并且可以加快数据库查询的速度。
    主键分为两种类型:单字段主键和多字段联合主键。

    ○ 单字段主键

    单字段主键由一个字段组成,SQL语句的格式分为下面两种情况:
    ① 在定义列的同时指定主键:

    字段名 数据类型 primary key [默认值],
    eg:
    create table info(
        id int(10) primary key ,  # 定义id为主键
        name varchar(30) ,
        salary float ,
        gender int(1) 
    );

    ② 在定义完所有列之后指定主键:

    [constraint <约束名>] primary key (字段名);
    eg:
    create table info(
        id int(10) , 
        name varchar(30) ,
        salary float ,
        gender int(1) ,
        primary key (id)  # 定义id为主键
    );
    ○ 多字段联合主键

    主键由多个字段联合组成:

    primary key (字段1, 字段2, [字段3...])
    eg:
    create table info(
        id int(10) , 
        name varchar(30) ,
        salary float ,
        gender int(1) ,
        primary key (id, name)  # 定义 id、name 为联合主键
    );

    【注意】
    并不是每一个表都需要一个主键,当多个表之间进行连接操作时需要用到主键,所以不需要为每个表建立主键,而且有些情况最好不使用主键。

    ☆ 使用外键约束

    一个表可以有一个或多个外键。外键对应的是参照完整性,一个表的外键可以为空值。
    首先,外键是表中的一个字段,它可以不是本表的主键,但对应的是另外一个表的主键。定义外键后,不允许删除在另一个表中具有关联关系的行。
    外键的作用是保持数据的一致性、完整性。

    对于外键来说,有主表和从表之分:
    主表(父表):对于两个具有关联关系的表而言,相关联字段中主键所在的按个表即使主表。
    从表(子表):对于两个具有关联关系的表而言,相关联字段中外键所在的那个表即是从表。
    创建外键 的语法规则如下:

    [constraint <外键名>] foreign key 字段名1 [, 字段名2, ...] references <主表名> 主键列1 [, 主键列2, ...]
    eg:
    # 创建一个 info 的数据表:
    create table info(
        id int(10) primary key , 
        name varchar(30) not null ,
        salary float ,
        gender int(1) 
    );
    # 创建一个 students 的数据表:
    create table students(
        id int(10) primary key ,
        name varchar(30) not null,
        class int(2) ,
        constraint fk_info foreign key(info) references info(id) 
    );
    # 此时,students 表添加了名称为 fk_info 的外键约束,外键名称为 info , 其依赖于表 info 的主键 id。

    【注意】
    外键约束不能跨引擎使用。也就是说当从表要设置关联主表的外键约束时,主表的存储引擎与子表的必须一致,否则将导致设置外键约束失败。
    所以说,存储引擎的设置并非完全随意。

    ☆ 使用非空约束

    非空约束指字段的值不能为空。

    字段名 数据类型 not null,
    eg:
    # 创建一个 info 的数据表,其中 name 字段的值不能为空:
    create table info(
        id int(10) , 
        name varchar(30) not null ,
        salary float ,
        gender int(1) 
    );

    【注意】
    执行上面的命令后,后续在 name 字段插入值时,该值也不可为空。

    ☆ 使用唯一性约束

    唯一性约束要求该列唯一,允许为空,但只能有一个为空(同样是唯一)。

    ○ 在定义完列之后直接指定唯一约束
    字段名 数据类型 unique,
    eg:
    # 创建一个 info 的数据表,其中 name 字段的值唯一:
    create table info(
        id int(10) , 
        name varchar(30) unique ,
        salary float ,
        gender int(1) 
    );
    ○ 在定义完所有列后指定唯一约束
    [constraint <约束名>] unique (字段名)
    eg:
    # 创建一个 info 的数据表,其中 name 字段的值唯一:
    create table info(
        id int(10) , 
        name varchar(30) ,
        salary float ,
        gender int(1) ,
        constraint uni_que unique(name) 
    );

    【注意】
    unique 和 primary key 的区别:

    一个表中可以有多个字段声明为 unique,但只能有一个 primary key声明,且声明为 primary key 的列不允许有空值,但是声明为 unique 的字段确允许有空值的存在(即使只能有一个为空)。

    ☆ 使用默认约束

    默认约束——指定某列的默认值。

    字段名 数据类型 default 默认值,
    eg:
    # 创建一个 info 的数据表,其中 gender 字段的默认值为 1 (男性):
    create table info(
        id int(10) , 
        name varchar(30) ,
        salary float ,
        gender int(1) default 1 ,
        constraint uni_que unique(name) 
    );

    ☆ 设置表的属性值自动增加

    在MySQL中,默认 auto_increment 的初始值是 1,每新增一条记录,字段值自动加 1。
    一个表只能有一个字段使用 auto_increment 约束,且该字段必须为主键或主键的一部分。

    字段名 数据类型 auto_increment,
    eg:
    # 创建一个 info 的数据表,其中 id 字段的值自动增加:
    create table info(
        id int(10) primary key auto_increment , 
        name varchar(30) ,
        salary float ,
        gender int(1) default 1 
    );

    【注意】
    auto_increment 属性并不是只能从 1 开始自增,当我们定义该属性时,可以指定第一条插入记录的自增字段的初始值,这样后续插入的记录的自增值将从你指定的初始值开始自增。

    二、 查看数据表结构

    使用SQL语句创建好数据表之后,可以查看表结构的定义,以确认表的定义是否正确。

    ☆ 查看表 基本结构 语句: describe / desc

    describe 或 desc 语句可以查看表的字段信息,其中包括:字段名、字段数据类型、是否为主键、是否有默认值等。

    describe 表名;
    或
    desc 表名;
    eg:
    # 创建 info 数据表如下:
    create table info(
        id int(10) ,
        name varchar(30) ,
        salary float ,
        gender int(1) 
    );
    # 查看表结构:
    desc info;
    # 返回的结果:
    +--------+-------------+------+-----+---------+-------+
    | Field  | Type        | Null | Key | Default | Extra |
    +--------+-------------+------+-----+---------+-------+
    | id     | int(10)     | YES  |     | NULL    |       |
    | name   | varchar(30) | YES  |     | NULL    |       |
    | salary | float       | YES  |     | NULL    |       |
    | gender | int(1)      | YES  |     | NULL    |       |
    +--------+-------------+------+-----+---------+-------+
    4 rows in set (0.03 sec)

    ☆ 查看表 详细结构 语句: show create table

    此语句可以显示创建表时的 create table 语句。语法如下:

    show create table tb_name[\G];

    加上 ‘\G’后可以使显示的结果更加直观,易于查看。

    eg:
    # 查看 info 表的详细结构:
    show create table info\G;
    ******** 1. row ********
           Table: info
    Create Table: CREATE TABLE `info` (
      `id` int(10) DEFAULT NULL,
      `name` varchar(30) DEFAULT NULL,
      `salary` float DEFAULT NULL,
      `gender` int(1) DEFAULT NULL
    ) ENGINE=InnoDB DEFAULT CHARSET=latin1
    1 row in set (0.00 sec)

    三、 修改数据表

    修改表指的是修改数据库中已经存在的数据表的 结构。MySQL使用 alter table 语句进行数据表的修改。

    ☆ 修改表名

    alter table tb_name rename [to] <新表名>;
    # to 可以省略也可以写上,没有影响
    eg:
    # 查看数据库中的数据表:
    >>> show tables;
    +-------------------+
    | Tables_in_test_db |
    +-------------------+
    | info              |
    +-------------------+
    1 row in set (0.00 sec)
    # 修改 info 的表名为 students_info :
    >>> alter table info rename to students_info;
    >>> show tables;  # 查看所有的数据表
    +-------------------+
    | Tables_in_test_db |
    +-------------------+
    | students_info     |
    +-------------------+
    1 row in set (0.00 sec)
    # 可以看到,此时 info 的数据表已经更名为 students_info,修改表名成功

    ☆ 修改字段的数据类型

    修改字段的数据类型就是把字段的数据类型转换成另一种数据类型。

    alter table tb_name modify 字段名 新数据类型;
    eg:
    # 查看 info 数据表的结构为:
    >>> desc info;
    +--------+-------------+------+-----+---------+-------+
    | Field  | Type        | Null | Key | Default | Extra |
    +--------+-------------+------+-----+---------+-------+
    | id     | int(10)     | YES  |     | NULL    |       |
    | name   | varchar(30) | YES  |     | NULL    |       |
    | salary | float       | YES  |     | NULL    |       |
    | gender | int(1)      | YES  |     | NULL    |       |
    +--------+-------------+------+-----+---------+-------+
    4 rows in set (0.00 sec)
    # 修改 name 的字段类型为 varchar(50):
    >>> alter table info modify name varchar(50);
    # 查看 info 表的结构:
    >>> desc info;
    +--------+-------------+------+-----+---------+-------+
    | Field  | Type        | Null | Key | Default | Extra |
    +--------+-------------+------+-----+---------+-------+
    | id     | int(10)     | YES  |     | NULL    |       |
    | name   | varchar(50) | YES  |     | NULL    |       |
    | salary | float       | YES  |     | NULL    |       |
    | gender | int(1)      | YES  |     | NULL    |       |
    +--------+-------------+------+-----+---------+-------+
    4 rows in set (0.00 sec)
    # 可以看到, name 字段的数据类型已经变更为 varchar(50)。

    ☆ 修改字段名

    alter table tb_name change <旧字段名> <新字段名> <新数据类型>;

    【注意】
    可以将‘旧字段名’和‘新字段名’设置相同,这样就表示只修改数据类型;可以将‘新数据类型’设置为与原数据类型相同,这样表示只修改字段名,达到和‘modify’一样的效果。

    eg:
    >>> desc info;
    +--------+-------------+------+-----+---------+-------+
    | Field  | Type        | Null | Key | Default | Extra |
    +--------+-------------+------+-----+---------+-------+
    | id     | int(10)     | YES  |     | NULL    |       |
    | name   | varchar(50) | YES  |     | NULL    |       |
    | salary | float       | YES  |     | NULL    |       |
    | gender | int(1)      | YES  |     | NULL    |       |
    +--------+-------------+------+-----+---------+-------+
    4 rows in set (0.00 sec)
    
    # 1. 修改 gender 字段为 sex ,数据类型不变:
    >>> alter table info change gender sex int(1);
    >>> desc info;
    +--------+-------------+------+-----+---------+-------+
    | Field  | Type        | Null | Key | Default | Extra |
    +--------+-------------+------+-----+---------+-------+
    | id     | int(10)     | YES  |     | NULL    |       |
    | name   | varchar(50) | YES  |     | NULL    |       |
    | salary | float       | YES  |     | NULL    |       |
    | sex    | int(1)      | YES  |     | NULL    |       |
    +--------+-------------+------+-----+---------+-------+
    4 rows in set (0.00 sec)
    
    # 2. 修改 gender 字段的数据类型为 varchar(10),保持字段名不变:
    >>> alter table info change gender gender varchar(10);
    >>> desc info;
    +--------+-------------+------+-----+---------+-------+
    | Field  | Type        | Null | Key | Default | Extra |
    +--------+-------------+------+-----+---------+-------+
    | id     | int(10)     | YES  |     | NULL    |       |
    | name   | varchar(50) | YES  |     | NULL    |       |
    | salary | float       | YES  |     | NULL    |       |
    | gender | varchar(10) | YES  |     | NULL    |       |
    +--------+-------------+------+-----+---------+-------+
    4 rows in set (0.00 sec)

    【注意】
    由于不同的数据类型在机器中的存储长度和方式并不相同,所以为避免影响数据,当数据表中已有数据时,不要轻易修改数据类型。

    ☆ 添加字段

    alter table tb_name add <新字段名> <数据类型> [约束条件] [first | after 已存在字段名]

    其中,‘first’会将新添加字段设置为表的第一个字段,’after 已存在字段名’则会将添加的字段置于‘已存在字段名’对应字段的后面。如果没有这两个选填的参数,则默认将新添加的字段置于数据表的最后。

    eg:
    >>> desc info;
    +--------+-------------+------+-----+---------+-------+
    | Field  | Type        | Null | Key | Default | Extra |
    +--------+-------------+------+-----+---------+-------+
    | id     | int(10)     | YES  |     | NULL    |       |
    | name   | varchar(50) | YES  |     | NULL    |       |
    | salary | float       | YES  |     | NULL    |       |
    | sex    | varchar(10) | YES  |     | NULL    |       |
    +--------+-------------+------+-----+---------+-------+
    4 rows in set (0.00 sec)
    
    # 1. 添加无完整性约束条件的字段
    # 添加一个 class 字段,数据类型为 varchar(2):
    >>> alter table info add class varchar(2);
    >>> desc info:
    +--------+-------------+------+-----+---------+-------+
    | Field  | Type        | Null | Key | Default | Extra |
    +--------+-------------+------+-----+---------+-------+
    | id     | int(10)     | YES  |     | NULL    |       |
    | name   | varchar(50) | YES  |     | NULL    |       |
    | salary | float       | YES  |     | NULL    |       |
    | sex    | varchar(10) | YES  |     | NULL    |       |
    | class  | varchar(2)  | YES  |     | NULL    |       |
    +--------+-------------+------+-----+---------+-------+
    5 rows in set (0.00 sec)
    
    # 2. 添加有完整性约束条件的字段
    # 添加一个 grade 字段,数据类型为 varchar(2) 且不能为空:
    >>> alter table info add grade varchar(2) not null;
    >>> desc info;
    +--------+-------------+------+-----+---------+-------+
    | Field  | Type        | Null | Key | Default | Extra |
    +--------+-------------+------+-----+---------+-------+
    | id     | int(10)     | YES  |     | NULL    |       |
    | name   | varchar(50) | YES  |     | NULL    |       |
    | salary | float       | YES  |     | NULL    |       |
    | sex    | varchar(10) | YES  |     | NULL    |       |
    | class  | varchar(2)  | YES  |     | NULL    |       |
    | grade  | varchar(2)  | NO   |     | NULL    |       |
    +--------+-------------+------+-----+---------+-------+
    6 rows in set (0.00 sec)
    
    # 3. 在表的第一列添加一个字段
    # 在第一列添加一个 first_col 字段,数据类型为 int(10):
    >>> alter table info add first_col int(10) first;
    >>> desc info;
    +-----------+-------------+------+-----+---------+-------+
    | Field     | Type        | Null | Key | Default | Extra |
    +-----------+-------------+------+-----+---------+-------+
    | first_col | int(10)     | YES  |     | NULL    |       |
    | id        | int(10)     | YES  |     | NULL    |       |
    | name      | varchar(50) | YES  |     | NULL    |       |
    | salary    | float       | YES  |     | NULL    |       |
    | sex       | varchar(10) | YES  |     | NULL    |       |
    | class     | varchar(2)  | YES  |     | NULL    |       |
    | grade     | varchar(2)  | NO   |     | NULL    |       |
    +-----------+-------------+------+-----+---------+-------+
    7 rows in set (0.00 sec)
    
    # 4. 在表的指定列之后添加一个字段
    # 在表的 id 列之后添加一个 third_col 字段,数据类型为 varchar(10):
    >>> alter table info add third_col varchar(10) after id;
    >>> desc info;
    +-----------+-------------+------+-----+---------+-------+
    | Field     | Type        | Null | Key | Default | Extra |
    +-----------+-------------+------+-----+---------+-------+
    | first_col | int(10)     | YES  |     | NULL    |       |
    | id        | int(10)     | YES  |     | NULL    |       |
    | third_col | varchar(10) | YES  |     | NULL    |       |
    | name      | varchar(50) | YES  |     | NULL    |       |
    | salary    | float       | YES  |     | NULL    |       |
    | sex       | varchar(10) | YES  |     | NULL    |       |
    | class     | varchar(2)  | YES  |     | NULL    |       |
    | grade     | varchar(2)  | NO   |     | NULL    |       |
    +-----------+-------------+------+-----+---------+-------+
    8 rows in set (0.00 sec)

    ☆ 删除字段

    alter table tb_name drop <字段名>;
    eg:
    # 如上列的表结构,删除 third_col 字段:
    >>> alter table info drop third_col;
    >>> desc info;
    +-----------+-------------+------+-----+---------+-------+
    | Field     | Type        | Null | Key | Default | Extra |
    +-----------+-------------+------+-----+---------+-------+
    | first_col | int(10)     | YES  |     | NULL    |       |
    | id        | int(10)     | YES  |     | NULL    |       |
    | name      | varchar(50) | YES  |     | NULL    |       |
    | salary    | float       | YES  |     | NULL    |       |
    | sex       | varchar(10) | YES  |     | NULL    |       |
    | class     | varchar(2)  | YES  |     | NULL    |       |
    | grade     | varchar(2)  | NO   |     | NULL    |       |
    +-----------+-------------+------+-----+---------+-------+
    7 rows in set (0.00 sec)
    
    # 删除其中的 first_col 字段:
    >>> alter table info drop first_col;
    >>> desc info;
    +--------+-------------+------+-----+---------+-------+
    | Field  | Type        | Null | Key | Default | Extra |
    +--------+-------------+------+-----+---------+-------+
    | id     | int(10)     | YES  |     | NULL    |       |
    | name   | varchar(50) | YES  |     | NULL    |       |
    | salary | float       | YES  |     | NULL    |       |
    | sex    | varchar(10) | YES  |     | NULL    |       |
    | class  | varchar(2)  | YES  |     | NULL    |       |
    | grade  | varchar(2)  | NO   |     | NULL    |       |
    +--------+-------------+------+-----+---------+-------+
    6 rows in set (0.00 sec)

    ☆ 修改字段的排列位置

    alter table tb_name modify <字段名1> <数据类型> first | after <字段2>;

    ‘字段1’为要修改位置的字段,‘数据类型’为它的数据类型,参数若选择了 first,则将其修改为列表的第一列,若选择了‘after <字段2>’则表示要将其排列位置修改为‘字段2’列的后面一列。

    eg:
    # 现有表结构如下:
    >>> desc info;
    +--------+-------------+------+-----+---------+-------+
    | Field  | Type        | Null | Key | Default | Extra |
    +--------+-------------+------+-----+---------+-------+
    | id     | int(10)     | YES  |     | NULL    |       |
    | name   | varchar(50) | YES  |     | NULL    |       |
    | salary | float       | YES  |     | NULL    |       |
    | sex    | varchar(10) | YES  |     | NULL    |       |
    | class  | varchar(2)  | YES  |     | NULL    |       |
    | grade  | varchar(2)  | NO   |     | NULL    |       |
    +--------+-------------+------+-----+---------+-------+
    6 rows in set (0.00 sec)
    
    # 1. 将 sex 列修改为表的第一个字段
    >>> alter table info modify sex varchar(10) first;
    >>> desc info;
    +--------+-------------+------+-----+---------+-------+
    | Field  | Type        | Null | Key | Default | Extra |
    +--------+-------------+------+-----+---------+-------+
    | sex    | varchar(10) | YES  |     | NULL    |       |
    | id     | int(10)     | YES  |     | NULL    |       |
    | name   | varchar(50) | YES  |     | NULL    |       |
    | salary | float       | YES  |     | NULL    |       |
    | class  | varchar(2)  | YES  |     | NULL    |       |
    | grade  | varchar(2)  | NO   |     | NULL    |       |
    +--------+-------------+------+-----+---------+-------+
    6 rows in set (0.00 sec)
    
    # 2. 将字段 salary 插入到字段 grade 后面:
    >>> alter table info modify salary float after grade;
    >>> desc info;
    +--------+-------------+------+-----+---------+-------+
    | Field  | Type        | Null | Key | Default | Extra |
    +--------+-------------+------+-----+---------+-------+
    | sex    | varchar(10) | YES  |     | NULL    |       |
    | id     | int(10)     | YES  |     | NULL    |       |
    | name   | varchar(50) | YES  |     | NULL    |       |
    | class  | varchar(2)  | YES  |     | NULL    |       |
    | grade  | varchar(2)  | NO   |     | NULL    |       |
    | salary | float       | YES  |     | NULL    |       |
    +--------+-------------+------+-----+---------+-------+
    6 rows in set (0.01 sec)

    ☆ 更改表的存储引擎

    存储引擎是MySQL数据库中的数据存储在文件或内存中时采用的不同技术实现,我们最多可以为每张表选择不同的存储引擎。
    语法:

    alter table tb_name engine=<更改后的存储引擎名>;
    eg:
    # 1. 在更改数据表的存储引擎之前,需要先查看当前存储引擎:
    >>> show create table info\G;
    ******** 1. row ********
           Table: info
    Create Table: CREATE TABLE `info` (
      `sex` varchar(10) DEFAULT NULL,
      `id` int(10) DEFAULT NULL,
      `name` varchar(50) DEFAULT NULL,
      `class` varchar(2) DEFAULT NULL,
      `grade` varchar(2) NOT NULL,
      `salary` float DEFAULT NULL
    ) ENGINE=InnoDB DEFAULT CHARSET=latin1
    1 row in set (0.00 sec)
    
    # 可以看到当前存储引擎为 InnoDB,现在我们将其修改为MyISAM:
    >>> alter table info engine=MyISAM;
    >>> show create table info\G;
    ******** 1. row ********
           Table: info
    Create Table: CREATE TABLE `info` (
      `sex` varchar(10) DEFAULT NULL,
      `id` int(10) DEFAULT NULL,
      `name` varchar(50) DEFAULT NULL,
      `class` varchar(2) DEFAULT NULL,
      `grade` varchar(2) NOT NULL,
      `salary` float DEFAULT NULL
    ) ENGINE=MyISAM DEFAULT CHARSET=latin1
    1 row in set (0.00 sec)

    ☆ 删除表的外键约束

    alter table tb_name drop foreign key <外键约束名>

    ‘<外键约束名>’指在定义表时 constraint 后面的参数。

    # 查看 info 表的结构如下:
    >>> desc info;
    +--------+-------------+------+-----+---------+-------+
    | Field  | Type        | Null | Key | Default | Extra |
    +--------+-------------+------+-----+---------+-------+
    | sex    | varchar(10) | YES  |     | NULL    |       |
    | id     | int(10)     | NO   | PRI | NULL    |       |
    | name   | varchar(50) | YES  |     | NULL    |       |
    | class  | varchar(2)  | YES  |     | NULL    |       |
    | grade  | varchar(2)  | NO   |     | NULL    |       |
    | salary | float       | YES  |     | NULL    |       |
    +--------+-------------+------+-----+---------+-------+
    6 rows in set (0.00 sec)
    
    # 创建数据表 info_slave 并设置名为 fk_info_id 的外键 info_id 关联 info 表的主键 id:
    >>> create table info_slave(
        id int(10) primary key not null,
        name varchar(50),
        book_name varchar(100),
        info_id int(10),
        constraint fk_info_id foreign key (info_id) references info(id)
    );
    
    # 查看 info_slave 的结构:
    >>> show create table info_slave\G;
    ******** 1. row ********
           Table: info_slave
    Create Table: CREATE TABLE `info_slave` (
      `id` int(10) NOT NULL,
      `name` varchar(50) DEFAULT NULL,
      `book_name` varchar(100) DEFAULT NULL,
      `info_id` int(10) DEFAULT NULL,
      PRIMARY KEY (`id`),
      KEY `fk_info_id` (`info_id`),
      CONSTRAINT `fk_info_id` FOREIGN KEY (`info_id`) REFERENCES `info` (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=latin1
    1 row in set (0.00 sec)
    
    # 可以看到我们成功添加了外键,现在我们将外键约束删除:
    >>> alter table info_slave drop foreign key fk_info _id;
    >>> show create table info_slave\G;
    ******** 1. row ********
           Table: info_slave
    Create Table: CREATE TABLE `info_slave` (
      `id` int(10) NOT NULL,
      `name` varchar(50) DEFAULT NULL,
      `book_name` varchar(100) DEFAULT NULL,
      `info_id` int(10) DEFAULT NULL,
      PRIMARY KEY (`id`),
      KEY `fk_info_id` (`info_id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=latin1
    1 row in set (0.00 sec)
    
    # 可以看到 info_slave 表中已经不存在外键,且原名为 fk_info_id 的外键约束删除成功。

    四、 删除数据表

    删除数据表的同时,表的定义和表中的所有数据均将被删除。所以在进行删除数据表的操作以前,最好将表中的数据做一个备份,以免造成无法挽回的后果。

    ☆ 删除没有被关联的表

    drop table [if exists] 表1 [, 表2, ...];

    如果要删除的数据表不存在,MySQL会报错,当加入 ‘if exists’参数后,会在删除前判断要被删除的表是否存在,如果存在则删除,如果不存在则会跳过该数据表继续向下执行,会报警告,但不会报错。

    eg:
    # 新建表 students :
    >>> create table students(
        id int(10) primary key not null,
        name varchar(50), 
        gender int(1) default 1,
        age int(2) 
        );
    >>> show tables;
    +-------------------+
    | Tables_in_test_db |
    +-------------------+
    | info              |
    | info_slave        |
    | students          |
    +-------------------+
    3 rows in set (0.01 sec)
    
    # 将 students 表删除:
    >>> drop table if exists students;
    >>> show tables;
    +-------------------+
    | Tables_in_test_db |
    +-------------------+
    | info              |
    | info_slave        |
    +-------------------+
    2 rows in set (0.00 sec)

    如果想一次性删除多个数据表,只要将表名写在后面,中间用逗号隔开即可。

    ☆ 删除被其他表关联的主表

    数据表之间存在外键关联的情况下,如果直接删除主表,将会失败,因为这样就破坏了参照完整性。
    如果必须要删除,可以先删除与它关联的子表。但这样又会同时删除了两张表中的数据。如果我们还想保留子表的数据,我们应该怎么办呢?
    想要单独的删除父表,我们就需要先将子表的外键约束条件取消,这样就可以单独将父表删除。

    # 查看 info 表结构如下:
    >>> desc info;
    +--------+-------------+------+-----+---------+-------+
    | Field  | Type        | Null | Key | Default | Extra |
    +--------+-------------+------+-----+---------+-------+
    | sex    | varchar(10) | YES  |     | NULL    |       |
    | id     | int(10)     | NO   | PRI | NULL    |       |
    | name   | varchar(50) | YES  |     | NULL    |       |
    | class  | varchar(2)  | YES  |     | NULL    |       |
    | grade  | varchar(2)  | NO   |     | NULL    |       |
    | salary | float       | YES  |     | NULL    |       |
    +--------+-------------+------+-----+---------+-------+
    6 rows in set (0.00 sec)
    
    # 查看 info_slave 表结构如下:
    >>> desc info_slave;
    +---------+-------------+------+-----+---------+-------+
    | Field   | Type        | Null | Key | Default | Extra |
    +---------+-------------+------+-----+---------+-------+
    | id      | int(10)     | NO   | PRI | NULL    |       |
    | name    | varchar(50) | YES  |     | NULL    |       |
    | info_id | int(10)     | YES  | MUL | NULL    |       |
    +---------+-------------+------+-----+---------+-------+
    3 rows in set (0.00 sec)
    
    # 查看 info_slave 表的外键约束:
    >>> show create table info_slave\G;
    ******** 1. row ********
           Table: info_slave
    Create Table: CREATE TABLE `info_slave` (
      `id` int(10) NOT NULL,
      `name` varchar(50) DEFAULT NULL,
      `info_id` int(10) DEFAULT NULL,
      PRIMARY KEY (`id`),
      KEY `fk_info_id` (`info_id`),
      CONSTRAINT `fk_info_id` FOREIGN KEY (`info_id`) REFERENCES `info` (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=latin1
    1 row in set (0.00 sec)
    
    # 可以看到 info_slave 中的 info_id 字段是外键,关联着 info 表的主键 id。我们先取消 info_slave 表的外键约束:
    >>> alter table info_slave drop foreign key fk_info_id;
    Query OK, 0 rows affected (0.01 sec)
    Records: 0  Duplicates: 0  Warnings: 0
    
    # 表示上面的命令操作成功,现在我们开始删除主表 info :
    # 删除之前我们先查看一下所有的数据表:
    >>> show tables;
    +-------------------+
    | Tables_in_test_db |
    +-------------------+
    | info              |
    | info_slave        |
    +-------------------+
    2 rows in set (0.00 sec)
    
    >>> drop table info;
    Query OK, 0 rows affected (0.01 sec)

    至此,info 数据表被成功删除。

    展开全文
  • 数据表是存储数据的基本单位 数据表按行和列方式存储,每一行代表唯一一条记录,每一列代表记录中的某个字段或者是域 创建数据表 切换至对应数据库指令:USE (NAME) 创建数据表指令:CREATE TABLE table_name ( ...

    第六章 数据表的基本操作

    • 数据表是存储数据的基本单位
    • 数据表按行和列的方式存储,每一行代表唯一一条记录,每一列代表记录中的某个字段或者是域

    创建数据表

    • 切换至对应数据库指令:USE (NAME)
    • 创建数据表指令:
      CREATE TABLE table_name
      (
      字段一 数据类型 列级别约束条件(可选项),
      字段二 数据类型 列级别约束条件(可选项),
      ……
      表级别约束条件
      );
      
    • 注意事项
      • 表的名称不区分大小写
      • 不能使用SQL关键字
      • 存在多列使用逗号分隔
      • 最后一个字段不用逗号分隔

    数据表的结构

    • 查看数据表指令:SHOW TABLES;

    • 查看表的结构指令1(desc全写为describe):DESC table_name;

    • 查看表的结构指令2:show create table student\g;

      • 可以看到所用的引擎
    • 表的结构

      • field:字段名称
      • type:数据类型
      • null:是否为空
      • key:
        • pri(primary):主键
        • uni(unique):唯一
      • default:默认值
      • extra:扩展的值(设置增加属性)

    约束类型

    主键约束

    • 主键:表中的一个列或多个列,可以标识表中某一记录,可结合外键定义不同数据表的关系
    • 主键特点
      • 数据唯一,且不允许为空
      • 使用主键可以加快查询速度
      • 主键和记录一一对应
    • 主键类型
      • 单字段主键:由一个字段组成
        • 设置指令1:PRIMARY KEY,写在列级别约束条件处
        • 设置指令2:PRIMARY KEY(id),写在表级别约束条件处,前一个字段需要逗号隔开
      • 多字段联合主键:由多个字段组成
        • 设置指令:PRIMARY KEY(id,name),写在表级别约束条件处

    外键约束

    • 外键:能够在两个表之间建立数据的连接,外键也是数据表中的某个字段,这个字段可以不是主键

      • 一个表的外键可以是空的,不是空值会分配一个默认值
      • 一个表可以有一个外键或多个外键
      • 定义了一个外键后,就不允许删除另一个表中具有关联关系的记录
      • 作用:保证数据的一致性和完整性
    • 两个表的角色

      • 主表:对于两个表具有关联关系的,且具有主键的表
      • 从表:对于两个表具有关联关系的,且具有外键的表
    • 添加外键语法格式

      CONSTARAINT 外键名 FOREIGN KEY (字段名) REFERENCES 主表名(主键列)
      
      • 写在从表的表级别约束条件处

      • 例如,

        create table student6
        (name varchar(30),id int(11) primary key,age int(2),constraint link foreign key (id) references student4(id));
        

    非空约束

    • 语法格式:NOT NULL
    • 写在列级别约束条件处

    唯一性约束

    • 该列唯一允许为空,但只能出现一个空值
    • 语法格式:UNIQUE
    • 写在列级别约束条件处

    默认约束

    • 设置某列的默认值
    • 语法格式:DEFAULT 数值
    • 写在列级别约束条件处
    • 例如:default 1,则数据的默认值为1

    属性值自动增加

    • 语法格式:AUTO_INCREMENT,写在列级别约束条件处
      • 例如,create table student7 (name varchar(30),id int(11) primary key auto_increment,age int(2));
      • 效果:插入数据,不写主键的值,将自动在原有数据上增加值作为新的数据的主键字段的值
    • 自动增加的字段需为主键
    • 插入数据命令:INSERT INTO table_name (字段名1,字段名2) VALUES('字段名1数据a','字段名2数据a'),('字段名1数据b','字段名2数据b');
      • 例如,insert into student7 (name,id,age) values ('xi','001','10'),('mei','010','19'),('lan','009','08');

    修改数据表

    修改表的名称

    • 修改表名称指令ALTER TABLE 旧的表名称 RENAME TO 新的表名称;

      • 指令中的to可省略
    • 修改字段数据类型指令ALTER TABLE 表的名称 MODIFY 字段 数据类型;

    • 修改字段名称指令ALTER TABLE 表的名称 CHANGE 旧字段名 新字段名 数据类型;

    • 添加字段指令ALTER TABLE 表的名称 ADD 新字段 数据类型;

      • 在第一列添加字段:ALTER TABLE 表的名称 ADD 新字段 数据类型 FIRST;
      • 在指定字段之后添加字段:ALTER TABLE 表的名称 ADD 新字段 数据类型 AFTER 指定字段;
    • 删除字段指令ALTER TABLE 表的名称 DROP 要删除的字段名称;

    • 修改字段排列位置指令ALTER TABLE 表的名称 MODIFY 要移动的字段名称 数据类型 FIRST|AFTER;

      • FIRST是移到最前,AFTER是移到最后
    • 更改存储引擎:ALTER TABLE 表的名称 ENGINE=引擎名称;

    删除数据表

    • 删除表的外键ALTER TABLE 表的名称 DROP FOREIGN KEY 外键约束名;
    • 删除数据表
      • 删除未被关联的表:DROP TABLE IF EXISTS 表的名称;
      • 删除被关联的表:先删除外键,再删除表
    展开全文
  • 表示数据库存储数据的基本单位,由若干个字段组成,主要用来存储数据记录,表的操作是增删改查,这是最基本的操作,也是最重要的操作 创建表 语法create table表名 (字段1类型[(宽度)约束条件], 字段n类型[(宽度)...

    表的操作

    表示数据库存储数据的基本单位,由若干个字段组成,主要用来存储数据记录,表的操作是增删改查,这是最基本的操作,也是最重要的操作

    创建表

    语法create table 表名

    (字段类型[(宽度约束条件],

     字段类型[(宽度约束条件]

    );

    在同一张表中字段名不能相同

    宽度和约束条件是可选的

    字段名和类型是必须的

     

    实例:

    Use school

    Create table student

    (name char(10),

    Sex char(8),

    Age int(3),

    Password varchar(50)

    );

    查看表结构

    Describe 表名;

    Desc 表名;

    Show create table 表名;  //查看表详细结构

    表完整性约束为了保障数据的完整性一致性和准确性

    关键字primkary key 主键, 唯一标识的一个记录

    Foreign key 外键 ,做关联

    No null 非空

    Unique key 唯一约束,这本身就是一个索引

    Default 默认值

    Auto_increment 自增长

     

    实例:

    Use school

    Create table student

    (name char(10) not null,

    Sex enum (male,female), default male not null

    Age int unsigned not null default 18,                    //unsigned修饰值必须为正值

    Hobby set (music,book,disc) default book,disc

    );

     

     

    设置唯一约束实例:unique

    Create table departtment(

    Dept_id int,

    Dept_name varchar(30) unique,

    Comment varchar(50)

     

    );

     

    设置主键约束实例:primary key非常重要,唯一标识符,这本身就是一条索引

    使用单列做主键

    Create table departtment(

    Dept_id int primary key,

    Dept_name varchar(30) ,

    Comment varchar(50)

    );

     

     

    使用多列做主键,也就是复合主键,也就是说这两个共同一起是不能有相同的数据的

    Create table departtment(

    Dept_id int ,

    Dept_name varchar(30),

    Comment varchar(50),

    Constraint pk_id_name primary key (dept_id,dept_name)

    );

     

    设置自增长auto_increment  自增长通常都是配合主键共同使用的,而且这个字段必须是整数类型才行

    Create table student(

    Dept_id int  primary auto_increment,

    Dept_name varchar(30),

    Comment varchar(50)

    );

     

     

    设置外键约束foreign key主要做表的关联,这里就涉及到父子表的概念,外键必须要存储引擎来支撑的,所以必须要确保存储引擎是innodb才行

    实例

    父表

    Create table empolyees(

     

    Name varchar(20) not null,

    Mail varchar (20),

    Primary key (name)

    )engine=innodb;

     

     

     

    子表

    Create table pryroll(

    Id int(5) not null,

    Name varchar(20) not null,

    Payroll float (10,2) no null,

    Primary key (id),

    Constraint fk_name foreign key (name) references employees (name)

    on udate cascade

    on delete cascade           //字表中的nameemployees 表的name字段关联,并且同步删除更新,父表中有那个人,子表中才能够插入,不然是不行的

     

    )engine=innodb;

     

     

    修改表

    修改表名

    Alter table 旧表名  rename 新表名

    实例:

    Alter table stu rename student;  //stu表改名为student

    Alter table student engine=myisam;  //修改student表的存储引擎为myisam

     

    增加字段

    Alter table 表名

     Add字段名 数据类型 [完整性约束条件.....],

    Add字段名 数据类型 [完整性约束条件.....];

    默认情况下新增加的字段是放在所有字段后面的

    实例:

    Alter table student

    Add name varchar(30) not null,

    Add age int not null;

     

    Alter table 表名

    Add字段名 数据类型 [完整性约束条件.....] first;

    实例:

    Add stu_num varchar(30) not null first;

     

     

    Alter table 表名

    Add字段名 数据类型 [完整性约束条件.....] after 字段名;

    实例:

    Add passord  varchar(30) not null after name;

     

     

    删除字段

    Alter table 表名 drop 字段名;

    实例:

    Alter table student drop stu_num;

     

     

     

     

    修改字段

    Alter table 表名 modify 字段名 数据类型 [完整性约束条件......]; //只能针对旧有的字段操作只能改名

     

    Alter table 表名 change 旧字段名 新字段名 旧数据类型 [完整性约束条件......];

    一般用这个

    实例:

    Alter table student change name stu_name varchar(30);

     

     

    Alter table 表名 change 旧字段名 新字段名 新数据类型 [完整性约束条件......];

     

    实例:

    Alter table student change stu_name name varchar(50) not null;

     

     

     

    删除表

    Drop table 表名;

    实例:

    Drop table student

    本文转自    探花无情   51CTO博客,原文链接:http://blog.51cto.com/983865387/1917416


    展开全文
  • 数据表是数据库中的最重要、最基本的操作对象,是数据存储的基本单位数据表被定义为列的集合,数据在表中是按照行和列的格式来存储的。每一行代表一条唯一的记录,每一列代表记录中的一个域。例如一个有关作者信息...

    一.什么是数据库的表?

      在关系数据库中,数据库表是一系列二维数组的集合,用来代表和储存数据对象之间的关系。它由纵向的列和横向的行组成。数据表是数据库中的最重要、最基本的操作对象,是数据存储的基本单位。数据表被定义为列的集合,数据在表中是按照行和列的格式来存储的。每一行代表一条唯一的记录,每一列代表记录中的一个域。例如一个有关作者信息的名为 authors 的表中,每个列包含的是所有作者的某个特定类型的信息,比如“姓氏”,而每行则包含了某个特定作者的所有信息:姓、名、住址等等。

     

    二.创建数据表

    1.创建数据表的MYSQL语句

      在创建数据库表之前,需要选定一个数据库,在选定的数据库中创建数据表,否则创建失败。

      USE 数据库名称;

      CREATE  TABELE  数据表名;

      在创建好数据表之后,使用SQL语句进行查看,创建的数据表是否成功。

      SHOW TABLES;(显示某选定的数据库中的所有的数据表名称)

     

    2.创建数据表的语法

      CREATE  TABLE  表名称 (

      字段1  数据类型  列级别的约束条件  (可以设定默认值),

      字段2  数据类型  列级别的约束条件   (可以设定默认值),

      ......

      )

     

      示例:创建一个员工表 tb_emp,有id,name,deptId,salary等列。

      USE  wangfang;

      mysql> CREATE TABLE tb_emp (

      -> id INT(11),
      -> name VARCHAR(25),
      -> deptId INT(11),
      -> salary FLOAT );
      SHOW  TABLES;

                

     

    三.创建关于数据表的一些约束

    1.主键 (PRIMARY KEY) 约束

     主键又称为主码,是表中一列或者多列的组合。主键约束要求主键列的数据是唯一的,并且不能为空。主键能够唯一的标识表中的一条记录,可以结合外键来定义不同数据表之间的关系,并且可以加快数据库查询的速度。主键和记录之间的关系是一一对应的,就像人和身份证一样。主键分为:单字段主键和多字段联合主键。

    (1)单字段联合主键

      主键是由一个字段组成,定义单字段的方法有两种:一是定义列的同时指定主键,一种是在定义完成后指定主键。

     

      CREATE  TABEL  表名 (

      字段  数据类型  列级别约束条件  (指定默认值)

      id  INT  PRIMARY KEY ,

      ......

      )

     

      CREATE  TABEL  表名 (

      字段  数据类型  列级别约束条件  (指定默认值)

      id  INT ,

      PRIMARY KEY (id);

      ......

      )

     

    (2)多字段联合主键

      CREATE  TABEL  表名 (

      字段  数据类型  列级别约束条件  (指定默认值)

      id  INT  PRIMARY KEY ,

      name  VARCHAR(25) ,

      PRIMARY KEY (id,name);

      ......

      )

     

    2.外键约束

     外键用来在两个表的数据之间建立连接,可以是一列,也可以是多列。一个表可以有一个或者多个外键。外键对应的是参照的完整性,一个表的外键可以为空值,若是不为空值,那么每一个外键值必须等于另一个表中的主键的某个值。外键首先是一个表中的字段,可以不是本表的主键,但是一定要对应另一个表的主键。外键的作用是:保证数据引用的完整性。定义完成后,不能删除有关联性的行。

     注意:建立外键的条件是,两个表的存储引擎要一致。

     

      创建的语法规则:

      CONSTRAINT  外键名称  FOREIGN KEY  外键处的字段名  REFERENCES  主表的主键字段名

      示例:

      

      CREATE  TABEL  wang (

      字段  数据类型  列级别约束条件  (指定默认值)

      id_info  INT  PRIMARY KEY ,

      name  VARCHAR(25) ;

      ......

      )

     

      CREATE  TABEL  haha (

      字段  数据类型  列级别约束条件  (指定默认值)

      id  INT  PRIMARY KEY ,

      name  VARCHAR(25) ,

      CONSTRAINT  waijian  FOREIGN KEY id REFERENCES  wang(id_info) ;

      ......

      )

     

    3.非空 (NOT NULL) 约束

     非空约束指的是:指定的字段不能为空。使用了非空约束的字段,在添加数据的时候,如果没有指定数据的指定值,那么数据库就会报错。

      CREATE  TABEL  表名 (

      字段  数据类型  列级别约束条件  (指定默认值)

      id  INT  PRIMARY KEY  NOT NULL

      ......

      )

     

    4.唯一性 (UNIQUE) 约束

     唯一性约束:要求该列唯一,允许为空,但是只能出现一个空值,唯一约束可以确保一列或者多列不出现重复的值。

      

      CREATE  TABEL  表名 (

      字段  数据类型  列级别约束条件  (指定默认值)

      id  INT  PRIMARY KEY  UNIQUE,

      ......

      )

     

      CREATE  TABEL  表名 (

      字段  数据类型  列级别约束条件  (指定默认值)

      id  INT  PRIMARY KEY ,

      CONSTRAINT  uniq  UNIQUE(id) ;

      ......

      )

      

    5.默认 (DEFAULT) 约束

     默认约束是指:给某一个字段设定默认的值,当用户添加数据的时候,没有给该字段添加相应的数据时,填入默认的值。比如说,一个理工科的学校,一般来说男生比女生要多,那么在存储用户信息的数据库中,可以将性别这一栏设定默认值为:男

     

      CREATE  TABEL  表名 (

      字段  数据类型  列级别约束条件  (指定默认值)

      id  INT  PRIMARY KEY ,

      sex  CHAR(2)  DEFAULT "m" ;

      ......

      )

     

    6.设置表的属性自动增加

     在数据库应用中,经常希望在每次插入新纪录时,系统能够自动的生成字段的主键值。可以通过为表的主键添加 AUTO_INCREMENT 关键字来实现。默认的,在MySQL中AUTO_INCREMENT的初始值为1,每新增加一条记录,字段的值自动加1.一个表只能有一个字段使用 AUTO_INCREMENT关键字,并且该字段必须为主键的一部分。

      

      CREATE  TABEL  表名 (

      字段  数据类型  列级别约束条件  (指定默认值)

      id  INT  PRIMARY KEY  AUTO_INCREMENT,

      name VARCHAR(25) NOT NULL

      ......

      )

     

    四.查看表的结构

     1.DESC(DESCRIBE)数据表的名称  该SQL命令查看的是数据表的基本的结构

      DESC  数据表的名称

          

     

    2.SHOW CREATE TABLE 数据表名称    该SQL命令查看的是表的详细的结构

      SHOW CREATE TABLE 数据表的名称 \G ;   ##如果不添加 \G 参数的话,输出的结果可能会很乱。添加该参数会利于查看

          

          

     

    五.修改数据表

    1.修改表的名称

      语法规则:ALTER  TABLE  表名  RENAME  新表名 ;

          

     

    2.修改表的字段的名称

      语法规则:ALTER  TABEL  表名  CHANGE  旧字段名  新字段名  跟定义的时候的该字段的数据类型 ;

          

     

    3.修改字段的数据类型

      语法规则:ALTER  TABLE  表名  MODIFY  字段名  新的数据类型 ;

        

     

    4.添加字段

    (1)添加新字段,添加的位置不定,默认添加到最后一个

      语法规则:ALTER  TABLE  表名  ADD  字段名  数据类型  列级别的约束条件 ;

           

    (2)添加新的字段到第一个

      语法规则:ALTER  TABLE 表名  ADD  字段名  数据类型  列级别的约束条件  FIRST ;

          

    (3)添加新的字段到指定的字段后面

      语法结构:ALTER  TABLE  表名  ADD  字段名  数据结构  列级别的约束条件  BEFORE  字段名 ;

          

     

    5.修改字段的排列顺序

      语法结构:ALTER  TABLE  表名  MODIFY  字段名  数据类型  FIRST|AFTER  字段名 ;

          

     

    6.更改表的存储引擎

      语法结构:ALTER  TABLE  表名  ENGINE=更改后的存储引擎的名称 ;

      用于查看某表的存储引擎的SQL语句是:SHOW  CREATE  TABLE  表名 ;    ##在后面会有表的相应的存储引擎

          

          

     

    7.删除外键的约束

      语法结构:ALTER TABLE 表名 DROP FOREIGN KEY 外键名称 ;

          

          

          

      以上的操作是在创建外键

          

     

    六.删除数据表

    1.删除没有关联的数据表

      语法结构:DROP TABLE  表名 ;

     

    2.删除有关联的数据表

      如果两个表之间存在外键的连接,那么在删除表的时候,就不可能最先删除主表。

      想要删除的方法是:先删除外键,再删除数据表;先删除子表,再删除父表。

          

          

     

     

     

     

     

     

     

     

     

          

     

          

     

    转载于:https://www.cnblogs.com/wf-aiyouwei/p/10951095.html

    展开全文
  • 在数据库中,数据表是数据库中最重要、最基本的操作对象,是数据存储的基本单位数据表被定义为列的集合,数据在表中是按照行和列的格式来存储的。每一行代表一条唯一的记录,每一列代表记录中的一个域。在这里我们...
  • 当主表的记录被从表参照时,主表的记录将不允许删除,如果要删除数据,需要先删除从表依赖该记录的数据, 然后才可以删除主表的数据。还有一种就是级联删除子表数据。 注意:外键约束的参照列,在主表引用的只能...
  • 数据表是关系数据库中最重要、最基本地数据对象,也是数据存储的基本单位。若没有表,数据库中其他的数据对象则没有意义。 数据表被定义为字段的集合,数据在表中是按照行和列的格式来存储的,每一行代表一条记录,...
  • 数据库中的重要对象

    2014-03-07 12:41:53
    对象时性质相同的数据元素的集合,如超市里的商品一般由食品、家用电器、家具等对象组成 一、表 ...1、表示用来存储数据的最基本单位 2、表的创建sql语句 -- Create table create table DEP...
  • ​ MySQL是一个真正多线程、多用户SQL数据库服务,凭借其高性能、高可靠性和易于使用特性,称为服务器领域中最受欢迎开源数据库系统。下面我们将具体介绍数据库的原理以及怎么编译安装MySQL数据库。 一、...
  • 一:表:表是用来存储数据的最基本单位。表由每一列构成,每一类存储的数据为表中的数据。列中的数据类型和约束决定了数据的合法性和统一性。查看具体表结构:点击查看SQL按钮可以看到具体表结构语句- Create/...
  • 无论是哪一个数据库,如果要对数据库性能进行...在SQLServer数据库中数据页是其存储的最基本单位。系统无论是在保存数据还是在读取数据的时候,都是以页为单位来进行操作。    一、数据基本组成。 ...
  • 例如,企业或事业单位的人事部门常常要把本单位职工的基本情况(职工号、姓名、年龄、性别、籍贯、工资、简历等)存放在表,这张表就可以看成是一个数据库。有了这个"数据仓库"我们就可以根据需要随时查询某职工...
  • 数据的基本操作

    2018-09-19 17:53:14
    在数据库中,数据表是数据库中最重要、最基本的操作对象,是数据储存的基本单位数据表被定义为列的集合,数据在表中是按照行和列的格式来储存的,每一行代表一条唯一的记录,每一列代表记录中的一个域。   1....
  •  字节是计算机信息科技用于计量存储容量的一种计量单位,也表示一些计算机编程语言中的数据类型和语言字符。 1个等于字节是8个bit位每个bit位又0/1两种状态也就是说一个字节可以表示256个状态,计算机里用字节来...
  • 数据库介绍

    2014-02-24 17:23:44
    多个用户可以同时共享数据库中的数据资源,即不同的用户可以同时存取数据库中的同一个数据。数据共享性不仅满足了各用户对信息内容的要求,同时也满足了各用户之间信息通信的要求。 基本结构 数据库的基本结构分...
  • 数据表是数据库中最重要、最基本的操作对象,是数据存储的基本单位数据表被定义为列的集合,数据在表中是按照行和列的格式来存储的。每一行代表一条唯一的记录,每一列代表记录中的一个域。 本模块将介绍数据表的...
  • 在数据库中,数据表是数据库中最重要、最基本的操作对象,是数据存储的基本单位数据表被定义为列的集合,数据在表中是按照行和列的格式来存储的,每一行代表一条唯一的记录,每一列代表记录中的一个域。 一、创建...
  • 在数据库中,数据表是数据库中最重要、最基本的操作对象,是数据存储的基本单位数据表被定义为列的集合,数据在表中是按照行和列的格式来存储的。每一行代表一条唯一的记录,每一列代表记录中的一个域。 一、创建...
  • 第一范式:当关系模式R的所有属性都不能在分解为更基本的数据单位时,称R是满足第一范式的,简记为1NF。 第一范式是最基本的范式。如果数据库的所有字段值都是不可分解的原子值,就说明该数据...
  • 在数据库中,数据表是数据库中最重要、最基本的操作对象,是数据存储的基本单位数据表被定义为列的集合,数据在表中按照行和列的各式来存储的。每一行代表一条唯一的记录,每一列代表记录中的一个域。 一,创建...
  • 数据库学习笔记

    2020-01-30 08:49:22
    数据库中存储数据数据之间关系。正常情况读写文件系统比数据库快一到两个数据级;数据库查询,大量并发时候可能浪费时间是connect和close。数据库优势是体现大量数据的查询、统计以及并发读写,...
  • 数据库中数据表是数据库最重要、最基本的操作对象,是数据存储的基本单位。创建数据表的过程就是规定数据列的属性的过程,同时也是实施数据完整性约束的过程。  创建数据表的语法形式:   CREATE TABLE &...
  • 数据是对一个事物最基本的描述单位,包括但不限于数字,字符,图形,音频和视频等。在早期的计算机系统中数据主要指数值型数据,如整数,浮点数等。随着技术发展,数据的概念越来越广。1.什么是数据库顾名思义,...
  • 在数据库中,数据表是数据库中最基本的操作对象,是数据存储的基本单位数据表被定义为列的集合,数据在表中是按照行和列的格式来存储的。每一行代表一条唯一的记录,每一列代表记录中的一个域。 一、约束 在上一...
  • 学习不是一蹴而就,而是在于日积月累 -- 献给不再年轻的自己 参考文档:oracle 9i 10 g 编程艺术,MSDN 这里只列出sqlserver & oracle 最后两级的数据...为数据库中的数据文件(.mdf 或 .ndf)分配的磁盘空间可以从
  • 数据库范式是指: 为了建立冗余较少,结构合理的数据库,在数据库设计中需要遵循一些规范,在关系型数据库中就称...当关系模式R的所有属性都不能在分解为更基本的数据单位时,称R是满足第一范式的,简记为1NF。 ...
  • 数据库的页构成

    2014-05-20 16:07:42
    SQL Server的页是最基本的数据单位组成,他有8KB,也就是8192个字节(mssql7.0以前是一个页面2KB),而sql server的一个页面,由页头,数据行,和slot table组成(行偏移的位置的记录数组。 页头 页头是一...
  • DBMS用于高效地创建和存储大量的数据,并对数据进行有效的管理、处理和维护,是数据库专家和技术人员数十年研究开发的结果,是当前复杂的系统软件之一。要深入掌握数据库系统的原理和技术,进而从事数据库管理软件...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 426
精华内容 170
关键字:

数据库中最基本的数据单位