When we are working with different versions of database, database professionals are comparing the objects between databases of SQL Server.
They must make sure about that all databases are in sync.

Using this T-SQL Script, you can compare two databases and find a list of unmatched objects like: Constraints, Tables, Views, Stored Procedure, Triggers.

Sample demonstration:
First, Create two sample databases:

CREATE DATABASE ABC
GO
CREATE DATABASE XYZ
GO

Create few sample tables in both the databases:

CREATE TABLE ABC.dbo.tbl_Test
(
	ID INT
	,MyDate DATE
)
GO

CREATE TABLE ABC.dbo.tbl_MyTest
(
	ID INT
	,Name VARCHAR(50)
)
GO

CREATE TABLE XYZ.dbo.tbl_Test
(
	ID INT
	,MyDate DATE
)
GO

CREATE TABLE XYZ.dbo.tbl_MyFinal
(
	ID INT
	,Name VARCHAR(50)
)
GO

T-SQL Script to compare objects between two databases:
According to your databases, You can change the name of @SourceDatabase and @DestinationDatabase.

DECLARE @SourceDatabase VARCHAR(50) 
DECLARE @DestinationDatabase VARCHAR(50) 
DECLARE @SQL VARCHAR(MAX) 
     
SELECT @SourceDatabase = 'ABC' 
SELECT @DestinationDatabase = 'XYZ'
     
SELECT @SQL = 
'
	SELECT 
		ISNULL(S.name,D.name) ObjectName
		,CASE  
			WHEN S.object_id IS NULL 
				THEN D.type_desc + '' is missing in the Source Database: '	+ @SourceDatabase + ''' 
			WHEN D.object_id IS NULL 
				THEN S.type_desc +  '' is missing in the Destination Database: ' + @DestinationDatabase + ''' 
		END ''Status'' 
	FROM 
	(
		SELECT * FROM ' + @SourceDatabase + '.SYS.objects  
		WHERE Type_desc not in (''INTERNAL_TABLE'',''SYSTEM_TABLE'',''SERVICE_QUEUE'')
	) AS S  
	FULL OUTER JOIN 
	(
		SELECT * FROM ' + @DestinationDatabase + '.SYS.objects  
		WHERE Type_desc not in (''INTERNAL_TABLE'',''SYSTEM_TABLE'',''SERVICE_QUEUE'')
	) AS D 
	ON S.name = D.name 
		AND S.type = D.type 
	ORDER BY isnull(S.type,D.type)
'  
EXEC (@Sql)

The Result:

ObjectName                         Status
------------------  -------------------------------------------------------
tbl_Test              NULL
tbl_MyFinal           USER_TABLE is missing in the Source Database: ABC
tbl_MyTest            USER_TABLE is missing in the Destination Database: XYZ

I already shared an article on how to enable or disable the foreign keys in the SQL Server.

Enable and Disable Foreign key and Check constraint in SQL Server

Why we require this? To make faster data migration by disabling the foreign key constraint.

For example, Now foreign key constraint disabled, and you load/migrate the data. Next, you enable the foreign key constraint with NOCHECK option.

That means if your key data do not reference of your primary key then also it allows the foreign key constraint that is called untrusted or invalid foreign key constraint because data is invalid.

You must find out untrusted or invalid foreign keys from your SQL Server so that you can take appropriate action on invalid referenced data.

Use below script to find untrusted or invalid foregin keys:

SELECT '[' + s.name + '].[' + o.name + '].[' + f.name + ']' AS ForeignKeyName
FROM    sys.foreign_keys f
INNER JOIN sys.objects o 
	ON f.parent_object_id = o.object_id
INNER JOIN sys.schemas s 
	ON o.schema_id = s.schema_id
WHERE   f.is_not_trusted = 1
	AND f.is_not_for_replication = 0
	AND f.is_disabled = 0

If you don’t know about the Hekaton engine of SQL Server 2014, please visit below an article.

SQL Server 2014: What is Hekaton?

I am very surprised with the feature list of SQL Server 2016 because it came with lots of features and improvements. Whenever I explored SQL Server 2016, I got something new.
SQL Server 2016 already enhanced In-Memory OLTP by introducing the list of features. Let me share one of the features here.

In the previous version, you cannot create a FOREIGN KEY in memory optimized table. Now, SQL Server 2016 introduced a feature to store the reference of a table in memory so you can create a FOREIGN KEY in memory optimized tables.

You can create a reference between memory optimized tables; you cannot give reference of a Non-memory optimized table to a memory optimized table.

Below is a full demonstration on this.

If you do not configure Memory optimized file group and data file, use below script to configure it.

Add Memory optimized file group:

ALTER DATABASE Database_Name
ADD Filegroup OLTP_InMemory CONTAINS MEMORY_OPTIMIZED_DATA

Add data file into created Memory optimized file group:

ALTER DATABASE Database_Name
ADD FILE (NAME = OLTP_InMemory, FILENAME = N'C:\SQLBackup\Hekaton')
TO FILEGROUP OLTP_InMemory

Create a sample In-Memory table:

CREATE TABLE tbl_Departments
(
	DeptID INT PRIMARY KEY NONCLUSTERED
	,DeptName VARCHAR(20)	
)WITH ( MEMORY_OPTIMIZED = ON, DURABILITY = SCHEMA_AND_DATA)
GO

Create a another In-Memory child table:

CREATE TABLE tbl_Employee
(
	EmpID INT PRIMARY KEY NONCLUSTERED
	,EmpName VARCHAR(20)
	,DeptID INT
	,CONSTRAINT fk_tbl_Employee_EmpID FOREIGN KEY (DeptID) REFERENCES tbl_Departments(DeptID)
) WITH ( MEMORY_OPTIMIZED = ON, DURABILITY = SCHEMA_AND_DATA);
GO

Try to give reference of Non-Memory optimized table to Memory optimized table:

CREATE TABLE tbl_EmpSalary
(
	EmpSalaryID INT PRIMARY KEY 
	,EmpID INT
	,EmpSalary INT
	,EmpSalaryMonth INT
	,CONSTRAINT fk_tbl_EmpSalary_EmpID FOREIGN KEY (EmpID) REFERENCES tbl_Employee(EmpID)
)
GO

You will get below errors:

Msg 10778, Level 16, State 0, Line 1
Foreign key relationships between memory optimized tables and non-memory optimized tables are not supported.
Msg 1750, Level 16, State 1, Line 1
Could not create constraint or index. See previous errors.

In this post, I am going to share one of the important script for SQL Serve DBA to find a list of tables which have disable foreign keys.

In any RDBMS system, the rule of data integrity is mandatory because it ensures the quality of data.

In our organization, database developers sometime disable the foreign key constraint because they required to insert test data or required to import non-related data.
After this testing, there are 90% chance of forgetting to enable foreign key constraint again to maintain further data integrity.

Using below script,the DBA can find a list of tables which have disable foreign key constraints.

SELECT 
	[s].[name] + '.' + [t].[name] AS TableName
FROM [sys].[tables] AS t
INNER JOIN [sys].[schemas] AS s
	ON [t].[schema_id] = [s].[schema_id]
WHERE EXISTS
(
	SELECT 1 FROM [sys].[foreign_keys] AS fk
	WHERE [fk].[parent_object_id] = [t].[object_id]
		AND [fk].[is_disabled] = 1
);

What are the different main type of normalization?

In database design, we start with one single table, with all possible columns. A lot of redundant data would be present since it’s a single table. The process of removing the redundant data, by splitting up the table in a well defined fashion is called normalization.

First Normal Form (1NF):A relation is said to be in first normal form if and only if all underlying domains contain atomic values only. After 1NF, we can still have redundant data.

Second Normal Form (2NF):A relation is said to be in 2NF if and only if it is in 1NF and every non key attribute is fully dependent on the primary key. After 2NF, we can still have redundant data.

Third Normal Form (3NF):A relation is said to be in 3NF, if and only if it is in 2NF and every non key attribute is non-transitively dependent on the primary key.

What is the Primary key?

A primary key is a one or more fields that uniquely identifies a row in a table. The primary key cannot be null (blank). The primary key is indexed.

A primary key is a value that can be used to identify a unique row in a table.

What should be your best practice with Primary Key?

Best practice for Primary Key in Database Management System

How to find all the Tables without having a Primary Key?

SQL Server: Script to find all the Tables without having a Primary Key

What is the Unique key?

Unique key also ensures data uniqueness like primary key.

A column with unique key defined allows null value. By default, it creates non-clustered index.

What is the Super key?

A superkey is defined in the relational model as a set of attributes of a relation variable (relvar) for which it holds that in all relations assigned to that variable there are no two distinct tuples (rows) that have the same values for the attributes in this set. Equivalently a superkey can also be defined as a set of attributes of a relvar upon which all attributes of the relvar are functionally dependent.

What is the Foreign key?

 A foreign key is a relationship between columns in two database tables (one of which is indexed) designed to insure consistency of data.

Usually a foreign key in one table refers to the primary key (PK) of another table. This way references can be made to link information together and it is an essential part of database normalization.

How to Find Foreign key References in SQL Server?

How to Find Foreign key References in SQL Server

How you can find source and destination information of all foreign keys?

PostgreSQL: Script to find Source and Destination of All Foreign Key Constraint

What is the Composite key?

A composite key consists of more than one field to uniquely identify a record. This differs from a compound key in that one or more of the attributes, which make up the key, are not simple keys in their own right. Taking the example from compound key, imagine we identified a student by their firstName + lastName.

In our table representing students on modules our primary key would now be firstName + lastName + moduleCode. Because firstName + lastName represent a unique reference to a student, they are not each simple keys, they have to be combined in order to uniquely identify the student. Therefore the key for this table is a composite key.

What is the Natural key?

A composite primary key which is composed of attributes (fields) which already exist in the real world e.g. First Name, Last Name, Social Security Number.

What is the Surrogate key?

A primary key which is internally generated (typically auto-incremental integer value) that does not exist in the real world i.e. ID=1 for Customer A and ID=2 for Customer B serves to uniquely identify the record but has no bearing the customer themselves and is an attribute they will never (need to) be aware of.

What is the Candidate key?

A candidate key is a column or group of columns that can uniquely identify a row in the table without referring to any other source.

What is the Compound key?

 A composite key consisting of two or more fields that uniquely describe a row in a table. The difference between compound and candidate is that all of the fields in the compound key are foreign keys; in the candidate key one or more of the fields may be foreign keys.

Can a foreign key reference a non-primary key?

Yes, a foreign key can actually reference a key that is not the primary key of a table. But, a foreign key must reference a unique key.

Can a foreign key contain null values?

Yes, a foreign key can hold NULL values. Because foreign keys can reference unique, non-primary keys – which can hold NULL values – this means that foreign keys can themselves hold NULL values as well.

What are the type of data integrity?

• Domain Integrity: data type, check constraints
• Entity Integrity: primary key, unique constraint
• Referential Integrity: foreign key constraint

MySQL Error code: 1005 Can’t create table (errno 150).

This error message is a pretty frustrating because it is not properly well-defined error message.

I have got this message while creating a table with foreign key constraint. I checked syntax and other things which were also correct.

This error looks like an OS file permission issue because it is not able to create a .frm file.

After some time, I found that my reference column data type is BIGINT and foreign key data type is INT.
Actually, this was a problem of data type mismatching and misleading of the error message.

There are some other reasons:

The two key fields data type and/or size doesn’t match exactly.
For example, one is INT and another is BIGINT.

One of the key fields that you are trying to reference does not have an index and/or is not a primary key. If one of the fields in the relationship is not a primary key, you must create an index for that field.

The foreign key name is a duplicate of an already existing key.

One or both of your tables is a MyISAM table. In order to use foreign keys, the tables must both be InnoDB.

You have specified a cascade ON DELETE SET NULL, but the relevant key field is set to NOT NULL.

Make sure that the Charset and Collate options are the same both at the table level as well as an individual field level for the key columns.

The name of your foreign key exceeds the max length of 64 chars.

In this post, I am sharing a script on how to enable and disable Foreign Key constraint in MySQL.

During data migration and testing purpose, Database Developer requires disabling Foreign key constraint.

Once you disable the constraint, later you might require enabling again, but during this exercise make sure that all your data changes are correct, and as per the constraint rule otherwise, you cannot enable those constraints. It violates data integrity rules.

You can perform disable/enable for both global and session levels of MySQL.

At Session level:

To Disable:

SET FOREIGN_KEY_CHECKS=0;

To Enable:

SET FOREIGN_KEY_CHECKS=1;

At Global level:

To Disable:

SET GLOBAL FOREIGN_KEY_CHECKS=0;

To Enable:

SET GLOBAL FOREIGN_KEY_CHECKS=1;

In this post, I am sharing a script to find the list of Foreign Keys with the source and destination table information of a MySQL Database.

Using below script you can easily find all foreign keys of a MySQL Database and its very useful for Database Architect for finding different references of foreign keys.

I am finding all Foreign Key references using INFORMATION_SCHEMA.KEY_COLUMN_USAGE.

Below is a script:

SELECT
  referenced_table_name AS ParentTable
  ,table_name AS ChildTable
  ,constraint_name AS ConstraintName
FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
WHERE referenced_table_name IS NOT NULL
ORDER BY referenced_table_name;

Find Table Dependency in MySQL

PostgreSQL: Script to find Source and Destination of All Foreign Key Constraint

How to Find Foreign key References in SQL Server

In this post, I am sharing the script to enable and disable foreign key and check constraint in SQL Server.

During data migration and testing purpose, Database Developer requires to disable Foreign key constraint or Check constraint.

Once you disable constraint, then later you might need enabling again, but during this exercise make sure that all your data changes are correct, and as per the constraint rule otherwise, you should not enable those constraints.

You can disable/enable action only on Foreign Key and Check Constraint.
You cannot perform disable/enable on Primary Key and Unique Key.

Disable All Foreign keys and Check Constraints:

EXEC sp_msforeachtable "ALTER TABLE ? NOCHECK CONSTRAINT ALL"

Enable All Foreign keys and Check Constraints:

EXEC sp_msforeachtable @command1="print '?'", 
@command2="ALTER TABLE ? WITH CHECK CHECK CONSTRAINT ALL"

Disable all the table constraints:

ALTER TABLE table_name NOCHECK CONSTRAINT ALL

Enable all the table constraints:

ALTER TABLE table_name CHECK CONSTRAINT ALL

Disable a single constraint:

ALTER TABLE table_name NOCHECK CONSTRAINT constraint_name

Enable a single constraint:

ALTER TABLE table_name CHECK CONSTRAINT constraint_name

In this post, I am sharing a script to find the all foreign key sources and destination references of the SQL Server.

Whenever we need to check all table references, we can use this script.

Below is a script:

SELECT 
	ccu.table_name AS SourceTable
	,ccu.constraint_name AS SourceConstraint
	,ccu.column_name AS SourceColumn
	,kcu.table_name AS TargetTable
	,kcu.column_name AS TargetColumn
FROM INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE ccu
	INNER JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc
		ON ccu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME 
	INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu 
		ON kcu.CONSTRAINT_NAME = rc.UNIQUE_CONSTRAINT_NAME  
ORDER BY ccu.table_name