Creating Table in SQL


Creating a table in SQL involves using the CREATE TABLE command to define the columns and data types of the table. Once the table is defined, data can be inserted and manipulated using other SQL commands. When creating a table in SQL, you must specify the name of the table, the names and data types of the columns within the table, and any primary and foreign key constraints. Once the table is created, it can store data and manipulate it with other SQL commands.

Steps for Creating Tables in SQL

  1. Identify the data that will be stored in the table.
  2. Choose a name for the table.
  3. Define the columns and their data types.
  4. Set primary keys and foreign keys.
  5. Define any constraints or rules that should be applied to the data.
  6. Create the table in the database using the CREATE TABLE statement.
  7. Insert data into the table using the INSERT INTO statement.

Guidelines for Naming Tables in SQL

  1. Use descriptive names: Choose names that accurately reflect the data that is stored in the table. Avoid using generic names like “Table1” or “Table2”.
  2. Use singular nouns: Use singular nouns, such as “Product” instead of “Products”.
  3. Use underscores and capital letters: Use underscores and capital letters to separate words in the table name. For example, “Product_Order” instead of “ProductOrder”.
  4. Avoid special characters: Don’t use special characters, such as hyphens or spaces, in table names.
  5. Make it descriptive: Ensure the table name provides enough information about the stored data. For example, a table called “Customer” is more descriptive than one called “Data”.
  6. Avoid abbreviations: Avoid using abbreviations in table names, as they can be confusing.
  7. Keep it consistent: Use the same naming convention across all tables in the database. This will help keep the database organized and easy to maintain.

Benefits of Using SQL Tables

  1. Improved data organization: SQL tables can provide a more organized and efficient way to store data. They can also help structure data in a way that is easier to comprehend and query.
  2. Increased data security: SQL tables are more secure than plain text files. They are less vulnerable to malicious intruders, as they require authentication and authorization to access any data within the table.
  3. Increased data integrity and accuracy: SQL tables provide a consistent format for data, which helps ensure data integrity and accuracy.
  4. Improved scalability: SQL tables can easily scale up or down depending on the needs of the organization.
  5. Easier data retrieval: SQL tables can simplify the process of querying data, making it easier to search and retrieve the necessary information.

Understanding Table Constraints in SQL

  • Table constraints are rules that specify what kind of data is accepted by a database table.
  • These rules help ensure that the data stored in the table is valid and reliable.
  • Constraints can be used to enforce the integrity of the data, maintain data consistency, or ensure that certain operations are performed correctly.
  • There are several types of table constraints, including primary key constraints, foreign key constraints, unique constraints, and check constraints which we will see in the further lessons.

Using Data Types in SQL Table Creation

When creating an SQL table, it is important to use the appropriate data types for each column. This ensures that data is stored in the correct format and that errors are minimized. For example, if a column is meant to store whole numbers, it should be declared as an integer data type. Similarly, if a column should store decimal numbers, it should be declared as a decimal data type. By using the appropriate data types, it is possible to ensure that the data stored in a table is accurate, consistent, and valid.

CREATE TABLE student_grades (
    student_id integer primary key,
    student_name varchar(50) not null,
    grade_level smallint not null,
    math_grade decimal(2,1) not null,
    science_grade decimal(2,1) not null,
    history_grade decimal(2,1) not null);

This code creates a table called student_grades with six columns:

  • student_id (an integer that serves as the primary key)
  • student_name (a string up to 50 characters long that cannot be empty)
  • grade_level (a small integer that cannot be empty)
  • math_grade (a decimal with two digits and one decimal place that cannot be empty)
  • science_grade (a decimal with two digits and one decimal place that cannot be empty)
  • history_grade (a decimal with two digits and one decimal place that cannot be empty)

Techniques for Modifying Tables in SQL

  1. ALTER TABLE: This command is used to add, delete, or modify columns in an existing table.
  2. CREATE TABLE: This command is used to create a new table in a database.
  3. DROP TABLE: This command is used to delete an existing table in a database.
  4. TRUNCATE TABLE: This command is used to delete all records from an existing table.
  5. RENAME TABLE: This command is used to rename an existing table.
  6. UPDATE: This command is used to modify existing records in a table.

Strategies for Optimizing SQL Table Creation

  1. Choose Appropriate Data Types: Choose the right data type for each column. This will help ensure the data is stored efficiently and will take up less space.
  2. Create Indexes: Create indexes on columns that will be searched often. This will help speed up query performance.
  3. Use Primary Keys: A Primary Key is a unique identifier for each row in the table. It is important to define a Primary Key for all tables to ensure data integrity.
  4. Normalize the Data: Normalize the data to reduce redundancy and ensure the data integrity.
  5. Use Partitioning: Partitioning can improve query performance by splitting the data into multiple tables.
  6. Use Temporary Tables: If you need to perform complex queries on large datasets, consider using temporary tables to improve performance.
  7. Use Constraints: Constraints are a great way to ensure data integrity. Using them will help prevent invalid data from being entered into the database.
  8. Minimize Table Joins: Table joins can be expensive. Try to minimize them by creating views or using query optimization techniques.

Troubleshooting Tips for Creating SQL Tables

  1. Ensure that the table name is valid: A valid table name must begin with a letter and not contain any spaces or special characters.
  2. Check your column data types: Make sure the data types you choose for your columns match the type of data that will be stored in them.
  3. Define Primary and Foreign Keys: Make sure that any columns that should be designated as primary or foreign keys are defined as such.
  4. Set Default Values: If any columns should have default values set, make sure they are set correctly.
  5. Set the Table’s Character Set and Collation: Make sure that the table’s character set and collation is set to match the intended language or region.
  6. Validate the SQL Syntax: Run the SQL statement to create the table through a syntax validator to make sure the syntax is correct.
  7. Test the Table: Make sure the table is working as expected by inserting some test data and querying the table.

Examples of Table Creation in SQL

    ProductID int NOT NULL,
    Name varchar(50),
    Price money,
    Primary Key (ProductID)

It creates a Product table with four columns, ProductID, Name, Price, and a primary key. The ProductID is marked as not null, meaning it cannot be blank when entering data. The Name field is limited to a maximum of 50 characters and the The price field is a money data type.

CREATE TABLE Customers (
    CustomerID int NOT NULL,
    Name varchar(50),
    Address varchar(50),
    City varchar(50),
    State varchar(2),
    ZipCode int,
    Primary Key (CustomerID)

It creates a table called Customers with seven columns, CustomerID, Name, Address, City, State, ZipCode, and a primary key. The CustomerID is marked as not null, meaning it cannot be blank when entering data. The Name, Address, City and State fields are limited to a maximum of 50 characters, and the ZipCode field is an integer data type.

Accessing data from Excel file in PostgreSQL

To access data from an Excel sheet in PostgreSQL, you can follow these general steps:

  1. Save the Excel sheet as a CSV (comma-separated values) file.
  2. Open pgAdmin or any other PostgreSQL client tool.
  3. Create a new table in PostgreSQL with the same column names and data types as in the Excel sheet.
  4. Use the COPY command to load the data from the CSV file into the new PostgreSQL table.

Here's an example of how you could do this using pgAdmin:

  1. Save the Excel sheet as a CSV file.
  2. In pgAdmin, right-click on the database to which you want to load the data and select "Query Tool".
  3. Run the following SQL command to create a new table with the same column names and data types as in the Excel sheet:
CREATE TABLE table_name (
   column1 data_type,
   column2 data_type,

Replace table_name, column1, column2, etc., with the actual names of your table and columns, and replace data_type with the appropriate data type for each column (e.g. text, numeric, date, etc.).

  1. Run the following SQL command to load the data from the CSV file into the new table:
COPY table_name FROM 'path/to/csv/file.csv' DELIMITER ',' CSV HEADER;

Replace table_name with the actual name of your table, and replace path/csv/file.csv with the actual path to your CSV file.

This will copy the data from the CSV file into the new PostgreSQL table. You should now be able to query the data using SQL commands.


This lesson provides an overview of creating tables in SQL, including identifying the data to be stored, naming conventions, and data types. It also covers table constraints, modifying tables, optimizing table creation, and troubleshooting tips. Additionally, it includes examples of table creation in SQL and accessing data from an Excel sheet in PostgreSQL.

Key takeaways

  1. Use CREATE TABLE statement to create a new table in a database.
  2. Specify the table name, column names, and their data types in the CREATE TABLE statement.
  3. Use the primary key to identify each row in the table and the foreign key to establish relationships between tables.
  4. Use the NOT NULL constraint to ensure that the columns are not empty.
  5. Use the CHECK constraint to validate the data entered into the columns.
  6. Use the DEFAULT constraint to set default values for the columns.
  7. Use the UNIQUE constraint to prevent duplicate values in columns.
  8. Use INDEX to increase the query performance.


1. What command is used to create a table in SQL? 



2. What statement is used to add a column to an existing table in SQL? 


Answer: b. ADD COLUMN

3. What is the syntax for adding a column to a table in SQL? 

  1. ADD TABLE column_name datatype 
  2. CREATE TABLE column_name datatype 
  3. ALTER TABLE ADD column_name datatype 
  4. UPDATE TABLE column_name datatype

Answer: c. ALTER TABLE ADD column_name datatype

4. What is the syntax for creating a table in SQL? 

  1. CREATE TABLE table_name (column_name datatype) 
  2.  ALTER TABLE table_name (column_name datatype)
  3.  DROP TABLE table_name (column_name datatype) 
  4. SELECT TABLE table_name (column_name datatype)

Answer: a. CREATE TABLE table_name (column_name datatype)

Module 3: DDL Commands Creating Table in SQL

Top Tutorials

Related Articles

Made with heartin Bengaluru, India
  • Official Address
  • 4th floor, 133/2, Janardhan Towers, Residency Road, Bengaluru, Karnataka, 560025
  • Communication Address
  • 4th floor, 315 Work Avenue, Siddhivinayak Tower, 152, 1st Cross Rd., 1st Block, Koramangala, Bengaluru, Karnataka, 560034
  • Follow Us
  • facebookinstagramlinkedintwitteryoutubetelegram

© 2024 AlmaBetter