Optimizing Knowledge Storage: Exploring Knowledge Varieties and Normalization in SQL – KDnuggets #Imaginations Hub

Optimizing Knowledge Storage: Exploring Knowledge Varieties and Normalization in SQL – KDnuggets #Imaginations Hub
Image source - Pexels.com

Picture by Writer


Within the current century, knowledge is the brand new oil. Optimizing this knowledge storage is at all times crucial for getting a superb efficiency from it. Choosing appropriate knowledge varieties and making use of the right normalization course of is crucial in deciding its efficiency. 

This text will research a very powerful and generally used datatypes and perceive the normalization course of.



There are primarily two knowledge varieties in SQL: String and Numeric. Apart from this, there are further knowledge varieties like Boolean, Date and Time, Array, Interval, XML, and many others.


String Knowledge Varieties


These knowledge varieties are used to retailer character strings. The string is commonly applied as an array knowledge kind and accommodates a sequence of components, usually characters.

  1. CHAR(n): 

It’s a fixed-length string that may include characters, numbers, and particular characters. n denotes the utmost size of the string in characters it will probably maintain.

Its most vary is from 0 to 255 characters, and the issue with this knowledge kind is that it takes the total area specified, even when the precise size of the string is lower than then. The additional string size is padded with additional reminiscence area.

  1. VARCHAR(n):

Varchar is much like Char however can help strings of variable dimension, and there’s no padding. The storage dimension of this knowledge kind is the same as the precise size of the string. 

It could possibly retailer as much as a most of 65535 characters. As a consequence of its variable dimension nature, its efficiency is not so good as the CHAR knowledge kind.

  1. BINARY(n): 

It’s much like the CHAR knowledge kind however solely accepts binary strings or binary knowledge. It may be used to retailer photos, recordsdata, or any serialized objects. There’s one other knowledge kind VARBINARY(n) which has similarities to the VARCHAR knowledge kind but additionally accepts solely binary strings or binary knowledge.

  1. TEXT(n):

This knowledge kind can also be used to retailer the strings however has a most dimension of 65535 bytes.

  1. BLOB(n): Stands for Binary Giant Object and maintain knowledge as much as 65535 bytes.

Apart from these are different knowledge varieties, like LONGTEXT and LONGBLOB, which might retailer much more characters.


Numeric Knowledge Varieties


  1. INT():

It could possibly retailer a numeric integer, which is 4 bytes (32bit). Right here n denotes the show width, which is usually a most of as much as 255. It specifies the minimal variety of characters used to show the integer values.


  1. a)  -2147483648 <= Signed INT <= 2147483647
  2. b)  0 <= Unsigned INT <= 4294967295
  1. BIGINT():

It could possibly retailer a big integer of dimension as much as 64 bits.


  1. a)  -9223372036854775808 <= Signed BIGINT <= 9223372036854775807
  2. b)  0 <= Unsigned BIGINT <= 18446744073709551615
  1. FLOAT():

It could possibly retailer floating level numbers with decimal locations approximated with a sure precision. It has some small rounding errors, so due to this, it’s not appropriate the place precise precision is required.

  1. DOUBLE():

This knowledge kind represents double-precision floating-point numbers. It could possibly retailer decimal values with a better precision as in comparison with the FLOAT knowledge kind.

  1. DECIMAL(n, d):

This knowledge kind represents precise decimal numbers with a hard and fast precision denoted by d. The parameter d specifies the variety of digits after the decimal level, and the parameter n denotes the scale of the quantity. The utmost worth for d is 30, and its default worth is 0.


Another Knowledge Varieties



This knowledge kind shops solely two states that are True or False. It’s used to carry out logical operations.

  1. ENUM:

It stands for Enumeration. It permits you to select one worth from the checklist of predefined choices. It additionally ensures that the saved worth is barely from the required choices.

For instance, contemplate an attribute coloration that may solely be 'Crimson,' 'Inexperienced,' or 'Blue'. Once we put these values in ENUM, then the worth of the coloration can solely be from these specified colours solely.

  1. XML:

XML stands for eXtensible Markup Language. This knowledge kind is used to retailer XML knowledge which is used for structured knowledge illustration.

  1. AutoNumber:

It’s an integer that robotically increments its worth when every file is added. It’s utilized in producing distinctive or sequential numbers. 

  1. Hyperlink:

It could possibly retailer the hyperlinks of recordsdata and net pages.

This completes our dialogue on SQL Knowledge Varieties. There are lots of extra knowledge varieties, however the knowledge varieties that now we have mentioned are essentially the most generally used ones.



Normalization is the method of eradicating redundancies, inconsistencies, and anomalies from the database. Redundancy means the presence of duplicate values of the identical piece of information, whereas inconsistencies within the database characterize the identical knowledge exists in a number of codecs in a number of tables.

Database anomalies might be outlined as any sudden change or discrepancies within the database that aren’t imagined to exist. These modifications might be resulting from varied causes, reminiscent of knowledge corruption, {hardware} failure, software program bugs, and many others. Anomalies can result in extreme penalties, reminiscent of knowledge loss or inconsistency, so detecting and fixing them as quickly as potential is crucial. There are primarily three kinds of anomalies. We are going to briefly focus on every however seek advice from this article if you wish to learn extra.

  1. Insertion Anomaly:

When the newly inserted row creates, inconsistency within the desk results in an insertion anomaly. For instance, we need to add an worker to a corporation, however his division shouldn’t be allotted to him. Then we can not add that worker to the desk, which creates an insertion anomaly.

  1. Deletion Anomaly:

Deletion anomaly happens after we need to delete some rows from the desk, and another knowledge is required to be deleted from the database.

  1. Replace Anomaly:

This anomaly happens after we need to replace some rows and which ends up in inconsistency within the database.

The normalization course of accommodates a sequence of tips that make the design of the database environment friendly, optimized, and free from redundancies and anomalies. There are a number of kinds of regular types like 1NF, 2NF, 3NF, BCNF, and many others.


1. First Regular Kind (1NF)


The primary regular type ensures that the desk accommodates no composite or multi-valued attributes. It signifies that just one worth is current in a single attribute. A relation is in first regular type if each attribute is barely single-valued.

For Ex-


Optimizing Data Storage: Exploring Data Types and Normalization in SQL
Picture by GeeksForGeeks


In Desk 1, the attribute STUD_PHONE accommodates multiple telephone quantity. However in Desk 2, this attribute is decomposed into 1st regular type.


2. Second Regular Kind


The desk have to be within the first regular type, and there should not be any partial dependencies within the relations. Partial dependency signifies that the non-prime attribute (attributes which aren’t a part of the candidate key) is partially dependent or depends upon any correct subset of the candidate key. For the relations to be within the second regular type, the non-prime attributes have to be absolutely useful and depending on the whole candidate key.

For instance, contemplate a desk named Workers having the next attributes.

EmployeeID (Major Key)
ProjectID (Major Key)


Right here the EmployeeID and the ProjectID collectively type the first key. Nevertheless, you possibly can discover a partial dependency between EmployeeName and EmployeeID. It signifies that the EmployeeName relies solely on the a part of the first key (i.e., EmployeeID). For full dependency, the EmployeeName should rely upon each EmployeeID and the ProjectID. So, this violates the precept of the second regular type.

To make this relation within the second regular type, we should cut up the tables into two separate tables. The primary desk accommodates all the worker particulars, and the second accommodates all of the mission particulars.

Subsequently, the Worker desk has the next attributes,

EmployeeID (Major Key)


And the Venture desk has the next attributes,

Venture ID (Major Key)
Venture Identify
Hours Labored


Now you possibly can see that the partial dependency is eliminated by creating two unbiased tables. And the non-prime attributes of each tables rely upon the entire set of the first key.


3. Third Regular Kind


After 2NF, nonetheless, the relations can have replace anomalies. It could occur if we replace just one tuple and never the opposite. That might result in inconsistency within the database.

The situation for the third regular type is that the desk needs to be within the 2NF, and there’s no transitive dependency for the non-prime attributes. Transitive dependency occurs when a non-prime attribute depends upon one other non-prime attribute as a substitute of instantly relying on the first attribute. Prime attributes are the attributes which can be a part of the candidate key.

Contemplate a relation R(A, B, C), the place A is the first key and B & C are the non-prime attributes. Let A→B and B→C be two Useful Dependencies, then A→C would be the transitive dependency. It signifies that attribute C shouldn’t be instantly decided by A. B acts as a intermediary between them.

If a desk consists of a transitive dependency, then we will carry the desk into 3NF by splitting the desk into separate unbiased relations.


4. Boyce-Codd Regular Kind


Though 2NF and 3NF take away many of the redundancies, nonetheless the redundancies should not 100% eliminated. Redundancy can happen if the LHS of the useful dependency shouldn’t be a candidate or tremendous key. A Candidate Key types from the prime attributes, and the Tremendous Key is a superset of the candidate key. To beat this concern, one other kind of useful dependency is out there named Boyce Codd Regular Kind (BCNF).

For a desk to be in BCNF, the left-hand aspect of a useful dependency have to be a candidate key or an excellent key. A. For instance, for a useful dependency X→Y, X have to be a candidate or tremendous key.

Contemplate an Worker Desk that accommodates the next attributes. 

  1. Worker ID (main key)
  2. Worker Identify
  3. Division
  4. Division Head


Optimizing Data Storage: Exploring Data Types and Normalization in SQL


The EmployeeID is the first key that uniquely identifies every row. The Division attribute represents the division of a selected worker, and the Division Head attribute represents the Worker ID of the worker who’s the pinnacle of that particular division.

Now we’ll verify if this desk is within the BCNF. The situation is that the LHS of the useful dependency have to be an excellent key. Under are the 2 useful dependencies of that desk.

Useful Dependency 1: Worker ID → Worker Identify, Division, Division Head

Useful Dependency 2: Division → Division Head

For the FD1, the EmployeeID is the first key, which can also be an excellent key. However for FD2, Division shouldn’t be the tremendous key as a result of a number of workers might be in the identical division.

Subsequently this desk violates the situation of BCNF. To fulfill the property of BCNF, we have to cut up that desk into two separate tables: Workers and Departments. The Workers desk accommodates the EmployeeID, EmployeeName, and Division, and the Division desk could have the Division and the Division Head.


Optimizing Data Storage: Exploring Data Types and Normalization in SQL

Optimizing Data Storage: Exploring Data Types and Normalization in SQL


Now we will see in each tables that every one the useful dependencies are depending on the first keys, i.e., there aren’t any non-trivial dependencies.

We now have coated all of the well-known normalization methods, however aside from these, there are two extra regular types, specifically 4NF and 5NF. If you wish to learn extra about them, seek advice from this article from GeeksForGeeks.



We now have mentioned essentially the most generally used knowledge varieties in SQL and the numerous Normalization methods in database administration techniques. Whereas designing a database system, we purpose to make it scalable, minimizing redundancy and making certain knowledge integrity.

We are able to create a fragile stability between storage, precision, and reminiscence consumption by deciding on applicable knowledge varieties. Additionally, the normalization course of helps eradicate knowledge anomalies and make the schema extra organized.

It’s all for immediately. Till then, maintain studying and continue to learn.
Aryan Garg is a B.Tech. Electrical Engineering scholar, at the moment within the last 12 months of his undergrad. His curiosity lies within the subject of Internet Improvement and Machine Studying. He have pursued this curiosity and am desirous to work extra in these instructions.

Related articles

You may also be interested in