09SQLDDL

SQL - Data Definition Statements

Outline

CREATE TABLE statement
DROP TABLE statement
ALTER TABLE statement

CREATE TABLE statement, creates a new relational table with a given name, given attribute names and types and with given logical consistency

A step of logical design transforms a class of objects into a relational schema, it means, a header of a relational table. A name of a class of objects, becomes a name of a relational schema and later a name of a relational table.

The names of attributes (properties) describing a class of objects, become the names of columns in a relational table. One of the identifiers becomes a primary key, while the other identifiers become the candidate keys. A set of attributes, that implements an association becomes a foreign key.

To create a relational table, we have to provide a table name, the column names, a primary key, the candidate keys if any, the foreign keys if any and the domain constraints.

We also have to provide information, about the mandatory and optional values in the columns, in a form of null (not null) constraints.

CREATE TABLE statement

CREATE TABLE statement creates a new relational table with a given name, given attribute names and types and with the given logical consistency constraints

CREATE TABLE

After a set of logical design when we know the names of relational schemes, attributes in the relational schemas, primary, candidate, and foreign keys we determine the types of columns, domain constraints, and mandatory/optional (NOT NULL/NULL) constraints. Types and NULL/NOT NULL constraints must be determined before creating CREATE TABLE statement.

Assume that, we would like to create a relational table: DEPARTMENT, to store information about the university departments.

The relational table: DEPARTMENT, consists of six columns: department name (name), department code (code), total staff number, chairperson (chair ), and budget.

A column: name, is a primary key and the values in a column: name, are the variable size strings, no longer than 50 characters, A column: name, is a primary key and because of that all values in the column are mandatory (NOT NULL).

A column: code, is a candidate key and all it’s values are fixed size strings 5 characters long. If the codes are shorter than 5 characters, then such values are padded with a sequence of blanks, up to 5 characters long. The values in a column code are mandatory (NOT NULL).

The values in a column: total staff, are integer values, in a range from one to fifty. The values in a column: total staff, are mandatory (NOT NULL).

A column: chair, contains the variable size strings, no more than 50 characters long, and all its values are optional (NULL)

A column: budget, contains the real numbers, no more than 9 digits long, with at most one position after a decimal dot. The values in a column budget are mandatory (NOT NULL).

CREATE TABLE statement

Example:
- name: primary key, variable size string, no more than 50 characters, mandatory
- code: candidate key, fixed size string, precisely 5 characters
- total staff: total staff number, integer, range 1..50, mandatory
- chair: chaiperson, variable size string, no more than 50 characters, optional
- budget: real number, no more than 9 digits, one position after decimal dot, mandatory

We use, CREATE TABLE statement to create a table: DEPARTMENT.

The columns are described by the rows, in a format, one column per row. A description of a single column, consists of column name, column type and NULL/NOT NULL constraint.

The types of columns like VARCHAR, CHAR, DECIMAL will be more thoroughly explained in one of the next slides.

For a while we can say that, VARCHAR(50), means a variable size string, no longer than 50 characters CHAR(5), means a fixed size string, 5 character long, DECIMAL(2), means an integer number, in a range from -99 to 99, maximum 2 digits long, and

DECIMAL(9,1) means a floating point number, 9 positions long, including 1 position after decimal dot.

A very common mistake in interpretation of DECIMAL(x,y) format is to consider the first number as the maximum length of an integer part of a floating point number, and the second number as the maximum length of a fraction part of a floating number. The first number: x, in a format decimal x comma y, is the maximum number of digits of an entire number, and the second number: y, is the maximum number of digits after decimal dot.

A primary key constraint determines a primary key.

A unique constraint determines a candidate key.

A check constraint determines a domain constraint, in the present case, the total number of staff members must be at least one and no more than 50.

CREATE TABLE statement

Example:

CREATE TABLE DEPARTMENT(

name               VARCHAR(50)  NOT NULL,

code               CHAR(5)      NOT NULL,

total_staff_number DECIMAL(2)   NOT NULL,

chair              VARCHAR(50)      NULL,

budget             DECIMAL(9,1) NOT NULL,

CONSTRAINT dept_pkey PRIMARY KEY(name),

CONSTRAINT dept_ckey1 UNIQUE(code),

CONSTRAINT dept_ckey2 UNIQUE(chair),

CONSTRAINT dept_check1
CHECK (total_staff_number BETWEEN 1 AND 50) );

CREATE TABLE statement

Table name

Attribute names

 
name               VARCHAR(50)        NOT NULL,
code               CHAR(5)            NOT NULL,
total_staff_number DECIMAL(2)         NOT NULL,
chair              VARCHAR(50)            NULL,
budget             DECIMAL(9,1)       NOT NULL,

Attribute types


name               VARCHAR(50)        NOT NULL,
code               CHAR(5)            NOT NULL,
total_staff_number DECIMAL(2)         NOT NULL,
chair              VARCHAR(50)            NULL,
budget             DECIMAL(9,1)       NOT NULL,

CREATE TABLE statement

NULL/NOT NULL constraints

name               VARCHAR(50)        NOT NULL,
code               CHAR(5)            NOT NULL,
total_staff_number DECIMAL(2)         NOT NULL,
chair              VARCHAR(50)            NULL,
budget             DECIMAL(9,1)       NOT NULL,

Primary key constraint

Candidate key constraints

CONSTRAINT dept_ckey1 UNIQUE(code),
CONSTRAINT dept_ckey2 UNIQUE(chair),

Domain constraint


CONSTRAINT dept_check1 CHECK (total_staff_number BETWEEN 1 AND 50) );

CREATE TABLE statement

"Bird's eye view"

	      
CREATE TABLE DEPARTMENT(
 name               VARCHAR(50)        NOT NULL,
 code               CHAR(5)            NOT NULL,
 total_staff_number DECIMAL(2)         NOT NULL,
 chair              VARCHAR(50)            NULL,
 budget             DECIMAL(9,1)       NOT NULL,
  CONSTRAINT dept_pkey PRIMARY KEY(name),
  CONSTRAINT dept_ckey1 UNIQUE(code),
  CONSTRAINT dept_ckey2 UNIQUE(chair),
  CONSTRAINT dept_check1 CHECK (total_staff_number BETWEEN 1 AND 50) );

In another example, we would like to create a relational table: COURSE, to store information about the university courses. The relational table: COURSE, consists of four columns: course number (cnum), course title (title), total number of credits (credits), and a name of a department that offers a course (offeredby).

A column: cnum, is a primary key, and the values in a column: cnum, are the fixed size strings, 7 characters long.

A column: title, is a candidate key, and its values are the variable size strings, no longer than 200 characters. The values in both columns: cnum and title, are mandatory.

If the values in a column cnum are shorter than 7 characters, then such values are padded with blanks, up to 7 characters long.

The values in a column: credits, are integer values equal to either 6 or 12. The values in a column: credits, are mandatory.

A column: offered by, contains the variable size strings, no longer than 50 characters and all its values are optional. it means that, it is possible that a course is not offered by any department.

CREATE TABLE statement

Another example
- cnum: primary key, fixed size string, 7 characters
- title: candidate key, variable size string no longer than 100 characters, is mandatory
- credits: integer, either 6 or 12, is mandatory
- offered_by: foreign key, references department name, variable size string, no longer than 50 characters, is optional

A CREATE TABLE statement is used to create a table: COURSE.

Like before, the columns are described one by one, a description of a single column consists of: column name, column type and NULL/NOT NULL constraint. More information about the types of columns will be provided in one of the coming slides.

For a while we can that:

- CHAR(7) means a fixed size string, 7 characters long,

- VARCHAR(200) means a variable size string, up to 200 characters long,

- DECIMAL(2) means an integer number, in a range from -99 to 99, maximum 2 digits long,

- VARCHAR(50) means a variable size string, up to 50 characters long.

A primary key constraint named as: COURSE_PKEY, makes an attribute: cmum, a primary key.

A unique constraint named as: COURSE_CKEY, determines a candidate key: title.

A check constraint determines a domain constraint, in the present case any value in a column: credits, can be either 6 or 12.

A foreign key constraint named as: COURSE_FKEY1, determines a referential integrity constraint, where a column: offered_by, references a column: name, in a relational table: DEPARTMENT.

It means that any name of department in a column: offered_by, must be earlier inserted into a relational table: DEPARTMENT.

A clause: ON DELETE CASCADE, means that if a row from a relational table: DEPARTMENT, is deleted, then all rows in a relational table: COURSE, referencing the row to be deleted must be automatically deleted. It practically means, that if a department is deleted, then all courses offered by the department, must be deleted as well.

CREATE TABLE statement

Another example

CREATE TABLE COURSE(

cnum        CHAR(7)      NOT NULL,

title       VARCHAR(200) NOT NULL,

credits     DECIMAL(2)   NOT NULL,

offered_by  VARCHAR(50)      NULL,

CONSTRAINT course_pkey PRIMARY KEY(cnum),

CONSTRAINT course_check1 CHECK (credits IN (6, 12)),

CONSTRAINT course_fkey1 FOREIGN KEY(offered_by)
                        REFERENCES DEPARTMENT(name)ON DELETE CASCADE );

CREATE TABLE statement

Table name

Attribute names

cnum               CHAR(7)           NOT NULL,
title              VARCHAR(200)      NOT NULL,
credits            DECIMAL(2)        NOT NULL,
offered_by         VARCHAR(50)           NULL,

Attribute types

cnum               CHAR(7)           NOT NULL,
title              VARCHAR(200)      NOT NULL,
credits            DECIMAL(2)        NOT NULL,
offered_by         VARCHAR(50)           NULL,

CREATE TABLE statement

NULL/NOT NULL constraints

cnum               CHAR(7)           NOT NULL,
title              VARCHAR(200)      NOT NULL,
credits            DECIMAL(2)        NOT NULL,
offered_by         VARCHAR(50)           NULL,

Primary key constraint

CONSTRAINT course_pkey PRIMARY KEY(cnum),

Domain constraint

CONSTRAINT course_check1 CHECK (credits IN (6, 12)),

Foreign key constraint

	      
CONSTRAINT course_fkey1 FOREIGN KEY(offered_by)
                        REFERENCES DEPARTMENT(name) ON DELETE CASCADE );

A bird's eye view on a complete CREATE TABLE statement, that can be used to create a relational table: COURSE, is presented in the current slide.

Please note formatting of CREATE TABLE statement. The names, types, and null not null constraints applied to the columns are listed in the separate lines with vertical adjustment of the columns types, and null not null constraints.

We avoid inline constraints, it means the constraints attached to the lines with the specifications of the columns.

All other constraints, are listed at the end of the specification of the columns.

All constraints, except NULL/NOT NULL constraints, must have the names indicating a relational table applied to and a type of a constraint.

A clause: ON DELETE CASCADE, means that if a row with a value of primary key referenced by a row with a value of foreign key in another or the same relational table is deleted, then a row with a foreign key in another or the same relational table is automatically deleted.

CREATE TABLE statement

"Bird's eye view"

CREATE TABLE COURSE(
 cnum               CHAR(7)           NOT NULL,
 title              VARCHAR(200)      NOT NULL,
 credits            DECIMAL(2)        NOT NULL,
 offered_by         VARCHAR(50)           NULL,
  CONSTRAINT course_pkey PRIMARY KEY(cnum),
  CONSTRAINT course_check1 CHECK (credits IN (6, 12)),
  CONSTRAINT course_fkey1 FOREIGN KEY(offered_by)
                          REFERENCES DEPARTMENT(name) ON DELETE CASCADE );

A clause ON DELETE CASCADE means that if a row with a value of primary key referenced by a row with a value of foreign key in another or the same relational table is deleted ...
... then a row with a foreign key in another or the same relational table is automatically deleted

Some of the commonly used column types are the following.

VARCHAR type is used to say, that a value is a variable length string not longer than a given size. The largest value of: VARCHAR size is 65535 bytes.

CHAR type is used to say, that a value is a fixed size string of a given size. If an inserted string is shorter then a given size, then it is padded with the blanks on its right hand side.

INTEGER type is used to say, that a value is an integer number in a range from -2147483648 to 2147483647.

REAL type is used to say, that a value is a real number with total M digits and D digits after a decimal point.

A DECIMAL type is used to say, that a value is an integer number with total M digits stored with an exact precision. A DECIMAL type can also be used to say, that a value is a real number with the total M digits and D digits after decimal point stored with an exact precision.

A DATE type is used to say, that a value is a date with a precision up to a single day. A default data entry entry format is YYYY-MM-D D.

A TIME type is used to say, that a value is a moment in time determined with a precision up to a single second.

A DATETIME type is used to say, that a value is a date and time.

A default entry format is YYYY-MM-DD HH:MI:SS.

CREATE TABLE statement

Some of the attribute types:
- VARCHAR(size) Variable length string, maximum size 65535 bytes
- CHAR(size) Fixed length string, maximum size 255 bytes
- INTEGER Integer numbers in a range [-2147483648, 2147483647]
- REAL(M,D) Real numbers with total M digits and D digits after decimal point
- DECIMAL(M) Integer numbers with total M digits stored with exact precision
- DECIMAL(M,D) Real numbers with total M digits and D digits after decimal point stored with exact precision
- DATE dates, default entry format 'YYYY-MM-DD'
- TIME times, default entry format 'HH:MI:SS;
- DATETIME dates and times, default entry format 'YYYY-MM-DD HH:MI:SS'

SQL - Data Definition Statements

DROP TABLE statement

Functionality:
- DROP TABLE statement permanently deletes the contents of relational table and removes its definition from a database
- A relational table that has been dropped can be recreated as an empty table by the execution of CREATE TABLE statement

CREATE TABLE

Assume, that we used CREATE TABLE statements listed in the current slide, to create the relational tables: DEPARTMENT and COURSE.

A relational table DEPARTMENT contains information about the departments of a hypothetical education-oriented institution. A name of department is nominated as primary key and code of department and chair of department are the candidate keys. CREATE TABLE statement enforces a domain constraint on a column total_staff_number restricting the values in the columns to a range 1..50.

A relational table COURSE contains informations about the courses offered by the departments. An attribute course number (cnum) is a primary kley. CREATE TABLE statement enforces a domain constraint restricting the values of credits to either 6 or 12. An attribute offered_by is a foreign key reference a primary key in a relational table DEPARTMENT (attribute dname). A foreign key implements an association between the classes DEPARTMENT and COURSE in a conceptual schema.

The relational tables, that have been created are very similar to the relational tables created in the previous presentation.

DROP TABLE statement

Examples:

CREATE TABLE DEPARTMENT(
 name               VARCHAR(50)        NOT NULL,
 code               CHAR(5)            NOT NULL,
 total_staff_number DECIMAL(2)         NOT NULL,
 chair              VARCHAR(50)            NULL,
 budget             DECIMAL(9,1)       NOT NULL,
  CONSTRAINT dept_pkey PRIMARY KEY(name),
  CONSTRAINT dept_ckey1 UNIQUE(code),
  CONSTRAINT dept_ckey2 UNIQUE(chair),
  CONSTRAINT dept_check1 CHECK (total_staff_number BETWEEN 1 AND 50) );

CREATE TABLE COURSE(
 cnum               CHAR(7)           NOT NULL,
 title              VARCHAR(200)      NOT NULL,
 credits            DECIMAL(2)        NOT NULL,
 offered_by         VARCHAR(50)           NULL,
  CONSTRAINT course_pkey PRIMARY KEY(cnum),
  CONSTRAINT course_check1 CHECK (credits IN (6, 12)),
  CONSTRAINT course_fkey1 FOREIGN KEY(offered_by)
                        REFERENCES DEPARTMENT(name) ON DELETE CASCADE )

To drop a relational table: COURSE, we use DROP TABLE statement in a way presented at the top of the current slide.

Now, assume, that we try to drop a relational table: DEPARTMENT, before dropping a nonempty relational table: COURSE. Then, such attempt ends up with an error message:

Cannot delete or update a parent row: a foreign key.

If a relational table: COURSE, is not empty, then we cannot drop a relational table: DEPARTMENT, because a table: COURSE, has a foreign key that references the values of a primary key in a relational table: COURSE. If a relational table: COURSE, is not empty, then dropping a relational table: DEPARTMENT, would violate a referential integrity constraint.

Therefore, we have to drop a relational table: COURSE, first, or we have to suspend or drop a referential integrity constraint first.

One more solution, is to replace the values in a column: offered by, in a relational table: COURSE, with nulls, such that no value in a column: offered by, references a value in column: name in a relational table DEPARTMENT.

An important conclusion from this experiment means, that an order in which the relational tables are dropped is very important !

DROP TABLE statement

Examples:

DROP TABLE COURSE;

DROP TABLE DEPARTMENT;

BEWARE !!!

DROP TABLE DEPARTMENT;

--------------
DROP TABLE DEPARTMENT
--------------

ERROR 1217 (23000): Cannot delete or update a parent row: a foreign key 
constraint fails

An order in which the relational tables are dropped is important !!!

SQL - Data Definition Statements

Outline

CREATE TABLE statement
DROP TABLE statement
ALTER TABLE statement

ALTER TABLE statement

Functionality
- ALTER TABLE statement permanently changes a definition of relational table
- ALTER TABLE statement can be used to:
  - add or drop a column,
  - modify a type of column,
  - add or drop a consistency constraint,
  - rename a relational table

ALTER TABLE

Assume, that we used CREATE TABLE statement given at the top of the current slide, to create a relational table: DEPARTMENT.

To add a column to a relational table we use the ALTER TABLE statement with a clause: ADD COLUMN. A specification of a new column mut provide a column name and type and optional NUL/NOT NULL constraint. If NULL/NOT NULL constraint is not provide then a default state of such constraint is NULL.

For example, to add a column: category, of type: VARCHAR(20), to a relational table: DEPARTMENT, we use the ALTER TABLE statement listed just below CREATE TABLE statement.

For example, to add an attribute: vision statement (vision_stmt), of type: VARCHAR(5000), to a relational table: DEPARTMENT, we use ALTER TABLE statement listed at the bottom of the current slide.

ALTER TABLE statement

Adding the attributes


CREATE TABLE DEPARTMENT(
 name               VARCHAR(50)        NOT NULL,
 code               CHAR(5)            NOT NULL,
 total_staff_number DECIMAL(2)         NOT NULL,
 chair              VARCHAR(50)            NULL,
 budget             DECIMAL(9,1)       NOT NULL,
  CONSTRAINT dept_pkey PRIMARY KEY(name),
  CONSTRAINT dept_ckey1 UNIQUE(code),
  CONSTRAINT dept_ckey2 UNIQUE(chair),
  CONSTRAINT dept_check1 CHECK (total_staff_number BETWEEN 1 AND 50) );


ALTER TABLE DEPARTMENT ADD COLUMN category VARCHAR(20);


ALTER TABLE DEPARTMENT ADD COLUMN vision_stmt VARCHAR(5000);

ALTER TABLE statement

Dropping an attribute


CREATE TABLE DEPARTMENT(
 name               VARCHAR(50)        NOT NULL,
 code               CHAR(5)            NOT NULL,
 total_staff_number DECIMAL(2)         NOT NULL,
 chair              VARCHAR(50)            NULL,
 budget             DECIMAL(9,1)       NOT NULL,
  CONSTRAINT dept_pkey PRIMARY KEY(name),
  CONSTRAINT dept_ckey1 UNIQUE(code),
  CONSTRAINT dept_ckey2 UNIQUE(chair),
  CONSTRAINT dept_check1 CHECK (total_staff_number BETWEEN 1 AND 50) );


ALTER TABLE DEPARTMENT DROP COLUMN budget;

We use the same relational table: DEPARTMENT, as in the previous slide.

To change a type of a column in a relational table, we use the ALTER TABLE statement with a clause: MODIFY a name of column and with NULL/NOT NULL null constraint. A column to be modified is identified by its name. The names of columns in a relational tables must be unique. The present definition, i.e. type and NUL/NOT NULL constraint is replaced with a new definition provide in ALTER TABLE statement.

For example, to change a type of an attribute: code, from: CHAR(5), to: CHAR(6), in a relational table: DEPARTMENT, we use the ALTER TABLE statement listed just below the CREATE TABLE statement.

For example, to change a type of an attribute: chair, from: VARCHAR(50), to: VARCHAR(80), and to change NULL/NOT NULL constraint to NOT NULL in a relational table: DEPARTMENT, we use the ALTER TABLE statement listed at the bottom of the current slide.

ALTER TABLE statement

Changing a type of attribute


CREATE TABLE DEPARTMENT(
 name               VARCHAR(50)        NOT NULL,
 code               CHAR(5)            NOT NULL,
 total_staff_number DECIMAL(2)         NOT NULL,
 chair              VARCHAR(50)            NULL,
 budget             DECIMAL(9,1)       NOT NULL,
  CONSTRAINT dept_pkey PRIMARY KEY(name),
  CONSTRAINT dept_ckey1 UNIQUE(code),
  CONSTRAINT dept_ckey2 UNIQUE(chair),
  CONSTRAINT dept_check1 CHECK (total_staff_number BETWEEN 1 AND 50) );


ALTER TABLE DEPARTMENT MODIFY code CHAR(6) NOT NULL;


ALTER TABLE DEPARTMENT MODIFY chair VARCHAR(80) NOT NULL;

ALTER TABLE statement

Adding a constraint


CREATE TABLE DEPARTMENT(
 name               VARCHAR(50)        NOT NULL,
 code               CHAR(5)            NOT NULL,
 total_staff_number DECIMAL(2)         NOT NULL,
 chair              VARCHAR(50)            NULL,
 budget             DECIMAL(9,1)       NOT NULL,
  CONSTRAINT dept_pkey PRIMARY KEY(name),
  CONSTRAINT dept_ckey1 UNIQUE(code),
  CONSTRAINT dept_ckey2 UNIQUE(chair),
  CONSTRAINT dept_check1 CHECK (total_staff_number BETWEEN 1 AND 50) );


ALTER TABLE DEPARTMENT ADD CONSTRAINT dept_check2
                       CHECK (code = UPPER(code));

To demonstrate how to drop a constraint, we use a relational table: COURSE.

To delete a consistency constraint from a relational table, we use the ALTER TABLE statement with a clause: DROP and a constraint type (PRIMARY KEY, FOREIGN KEY, CHECK, where a constraint type is either: PRIMARY KEY, UNIQUE, FOREIGN KEY, CHECK and constraint name (except PRIMARY KEY constraint).

For example, to remove a foreign key constraint: COURSE_FKEY1, from a relational table COURSE, we use the ALTER TBLE statement listed just below CREATE TABLE statement.

To identify a constraint to be dropped we must provide a name of a constraint (except when dropping PRIMARY KEY constraint). Now, it is very clear, that we benefit a lot from the correct naming of consistency constraints. Just imagine, that we would like to remove a constraint, while we do not know its name. It would require some time wasted on an extra search in a data dictionary to find a correct name.

We do not need to use a name of a constraint when removing a primary key, please see a line, the second from bottom in the current slide.

The ALTER TABLE statement given at the bottom of the current slide, drops a CHECK (domain) constraint: COURSE_CHECK1.

ALTER TABLE statement

Dropping a constraint

CREATE TABLE COURSE(
 cnum               CHAR(7)           NOT NULL,
 title              VARCHAR(200)      NOT NULL,
 credits            DECIMAL(2)        NOT NULL,
 offered_by         VARCHAR(50)           NULL,
  CONSTRAINT course_pkey PRIMARY KEY(cnum),
  CONSTRAINT course_check1 CHECK (credits IN (6, 12)),
  CONSTRAINT course_fkey1 FOREIGN KEY(offered_by)
                        REFERENCES DEPARTMENT(name) ON DELETE CASCADE );


ALTER TABLE COURSE DROP FOREIGN KEY course_fkey1;


ALTER TABLE DEPARTMENT DROP PRIMARY KEY;


ALTER TABLE COURSE DROP CHECK COURSE_CHECK1;

ALTER TABLE statement

Renaming a relational table


CREATE TABLE DEPARTMENT(
 name               VARCHAR(50)        NOT NULL,
 code               CHAR(5)            NOT NULL,
 total_staff_number DECIMAL(2)         NOT NULL,
 chair              VARCHAR(50)            NULL,
 budget             DECIMAL(9,1)       NOT NULL,
  CONSTRAINT dept_pkey PRIMARY KEY(name),
  CONSTRAINT dept_ckey1 UNIQUE(code),
  CONSTRAINT dept_ckey2 UNIQUE(chair),
  CONSTRAINT dept_check1 CHECK (total_staff_number BETWEEN 1 AND 50) );


ALTER TABLE DEPARTMENT RENAME TO NEWDEPARTMENT;

References

C. Coronel, S. Morris, A. Basta, M. Zgola, Data Management and Security, Chapter 5 Introduction to Structured Query Language, Cengage Compose eBook, 2018, eBook: Data Management and Security, 1st Edition
T. Connoly, C. Begg, Database Systems, A Practical Approach to Design, Implementation, and Management, Chapters 7.1, 7.2, 7.3 (except 7.3.5, 7.3.6) SQL: Data Definition, Pearson Education Ltd, 2015
D. Darmawikarta, SQL for MySQL A Beginner’s Tutorial, Chapter 1, pages 5-8, Brainy Software Inc. First Edition: June 2014
How to ... ? Cookbook, How to use data definition and basic data manipulation statements of SQL ? Recipe 4.1 How to create and how to alter the relational tables ?