INTRODUCTION TO PYTHON: -

Python is an interpreted, object-oriented, high-level programming language with dynamic

semantics. Its high-level built in data structures, combined with dynamic typing and dynamic
binding; make it very attractive for Rapid Application Development, as well as for use as a
scripting language to connect existing components together. Python's simple and easy to learn
syntax emphasizes readability and therefore reduces the cost of program maintenance. Python
supports modules and packages, which encourages program modularity and code reuse. The
Python interpreter and the extensive standard library are available in source or binary form
without charge for all major platforms and can be freely distributed.

PYTHON'S FEATURES INCLUDE: -

 Easy to code: Python is a high-level programming language, and it is very easy to code.
It is also a developer-friendly language.

 Free and Open Source: Python is freely available. You can download it from the
Python Official Website. Secondly, it is open source. This means that its source code is
available to the public. You can download it, change it, use it, and distribute it.

 Object-Oriented Language: One of the key features of python is Object-Oriented

programming. Python supports object-oriented language and concepts of classes, objects,
modularization etc.

 GUI Programming Support: Graphical User interfaces can be made using a module
such as PyQt5, PyQt4, python, or Tk in python.

 High-Level Language: Python is a high-level language. When we write programs in

python, we do not need to remember the system architecture, nor do we need to manage
the memory.

 Extensible feature: If needed, you can write some of your Python code in other
languages like C++. This makes Python an extensible language, meaning that it can be
extended to other languages.
 Python is Portable language: Python language is also a portable language. For
example, if we have python code for windows and if we want to run this code on other
platforms such as Linux, Unix, and Mac then we do not need to change it, we can run this
code on any platform.

 Python is Integrated language: Python is also an integrated language because we can

easily integrate python with other languages like c, c++, etc.

 Interpreted Language: Python is an Interpreted Language because Python code is

executed line by line at a time. Like other languages C, C++, Java, etc. there is no need to
compile entire python code, this makes it easier to debug the code.

 Large Standard Library: Python has a large standard library which provides a rich set
of modules and functions, so you do not have to write your own code for every single
thing. There are many libraries present in python for such as regular expressions, web
browsers, etc.

 Dynamically Typed Language: Python is dynamically typed. This means that the
type for a value is decided at runtime, not in advance. Therefore, we don't need to specify
the type of data while declaring it.

INTRODUCTION TO MYSQL (RDBMS): -

 A database is a collection of information related to a particular subject or purpose, such

as tracking customer orders or maintaining a product collection. Using any RDBMS
application software like MS SQL Server, MySQL, Oracle, Sybase etc. all information
can be managed from a single database file. Within the file, data can be divided into
separate storage containers called tables. Data can be retrieved using queries.

 A table is a collection of data about a specific topic, such as products or suppliers. Using
a separate table for each topic means you can store that data only once, which makes your
database more efficient and reduces data-entry errors. Table organizes data into columns
(called fields) and rows (called records).

 A Primary key is one or more fields whose value or values uniquely identify each record
in a table. In a relationship, a primary key is used to refer to a specific record in one table
from another table. A foreign key is a column in a relational database table that provides
a link between data in two tables. It acts as a cross-reference between tables because it
references the primary key of another table, thereby establishing a link between them.
 ROLE OF RDBMS APPLICATION PROGRAM:
 A computer database works as an electronic filing system, which has a large number of
ways of cross-referencing, and this allows the user many different ways in which to re-
organize and retrieve data. A database can handle business inventory, accounting and
filing and use the information in its files to prepare summaries, estimates and other
reports. The management of data in a database system is done by means of a general-
purpose software package called a Database Management System (DBMS). Some
commercially available DBMSS are MS SQL Server, MS ACCESS, INGRES, ORACLE,
and Sybase. A database management system, therefore, is a combination of hardware and
software that can be used to set up and monitor a database and can manage the updating
and retrieval of databases that have been stored in it. Most of the database management
systems have the following capabilities:

 Creating of a table, addition, deletion, modification of records.

 Retrieving data collectively or selectively.

 The data stored can be sorted or indexed at the user's discretion and direction.

 Various reports can be produced from the system. These may be either

 standardized report or that may be specifically generated according to specific user

definition.

 Mathematical functions can be performed, and the data stored in the database can be
manipulated with these functions to perform the desired calculations.

 To maintain data integrity and database use.

 The management of data in a database system is done by means of a general- purpose

software package called a Database Management System (DBMS).

 Some commercially available RDBMSS are MS SQL Server, MS ACCESS, INGRES,

ORACLE, and Sybase. MySQL, the most popular Open-Source SQL database
management system, is developed, distributed, and supported by Oracle Corporation.

THE MAIN FEATURES OF MYSQL: -

 MySQL is written in C and C++.

 Easy to use: MySQL is easy to use. We must get only the basic knowledge of SQL. We
can build and interact with MySQL by using only a few simple SQL statements.

 Secure: It consists of a solid data security layer that protects sensitive data from
intruders. Also, passwords are encrypted in MySQL.

 Client/Server Architecture: It follows the working of a client/server architecture.

There is a database server (MySQL) and arbitrarily many clients (application programs),
which communicate with the server; that is, they can query data, save changes, etc.

 Free to download: It is free to use so that we can download it from MySQL official
website without any cost.

 Speed: It is considered to be one of the fastest database languages, backed by a large

number of benchmark tests.

 High Flexibility: It supports a large number of embedded applications,

 which makes it very flexible.

 Compatible with many operating systems: It is compatible to run on many

operating systems, like Novell NetWare, Windows, Linux, many varieties of UNIX etc.

 Allows roll-back: It allows transactions to be rolled back, commit, and crash recovery.

 Memory efficiency: Its efficiency is high because it has a very low memory leakage
problem.

 High Performance: It is faster, more reliable, and cheaper because of its unique
storage engine architecture. It provides very high-performance results in: -

o comparison to other databases without losing an essential functionality of the

software. It has fast loading utilities because of the different cache memory.

o High Productivity: MySQL uses Triggers, Stored procedures, and views that
allow the developer to give higher productivity.

 Platform Independent: It can be downloaded, installed, and executed on most of the

available operating systems.
  Supports large databases: MySQL Server can be used with databases that contain 50
million records. There are users who use MySQL Server with 200,000 tables and about
50,000,000 rows.

MODULES AND DESCRIPTION: -

 The modules used in this software are as follows:

 1. Login: This module has 2 options, and we must select either ADMIN or USER. The
admin has all the rights in the software including updating the status of the site. The
Other fields in login are username and password. If the username and password are
correct, then it is directed accordingly.

 2. New User: This module is for the users who do not have an account. Here the user is
allowed to create an account to login. The account creation is done by filling in the
registration form with user details such as name, phone, email etc.

 Search: This module helps the customer to ease the search based on its budget or
interest. The search can be done on different categories like mobile model name model
number, color, price etc.

SOURCE CODE: -

MYSQL SOURCE CODE: -

 USE tables_backup;

DROP PROCEDURE IF EXISTS SP_DBSCHEMACOMPARE_WITHIN_CLUSTER;

DELIMITER //
CREATE PROCEDURE SP_DBSCHEMACOMPARE_WITHIN_CLUSTER (SOURCEDBNAME VARCHAR(64),
DESTINATIONDBNAME VARCHAR(64))
BEGIN
SET @SOURCEDBNAME = SOURCEDBNAME COLLATE utf8_tolower_ci, @DESTINATIONDBNAME =
DESTINATIONDBNAME COLLATE utf8_tolower_ci;

DROP TABLE IF EXISTS DB_COMPARE;

CREATE TABLE IF NOT EXISTS DB_COMPARE
(
DATABASE_NAME VARCHAR(64) COLLATE utf8_tolower_ci
,TABLE_NAME VARCHAR(64) COLLATE utf8_tolower_ci
,OBJECT_NAME VARCHAR(64) COLLATE utf8_tolower_ci
,OBJECT_TYPE VARCHAR(64) COLLATE utf8_tolower_ci
,MESSAGE VARCHAR(255) COLLATE utf8_tolower_ci
,ISMISSING BIT
,INDEX_COLS VARCHAR(2000) COLLATE utf8_tolower_ci
,INDEX_TYPE VARCHAR(100) COLLATE utf8_tolower_ci
,KEY IX_TYPE (OBJECT_TYPE)
,KEY IX_NAME (DATABASE_NAME, TABLE_NAME)
);

-- Gets the tables exist only in source

INSERT INTO DB_COMPARE
SELECT S.TABLE_SCHEMA, S.TABLE_NAME, NULL, 'Table', CONCAT('Table exists only in source database `',
S.TABLE_SCHEMA, '`.`', S.TABLE_NAME, '`'), 1, NULL, NULL
FROM INFORMATION_SCHEMA.TABLES S
LEFT OUTER JOIN INFORMATION_SCHEMA.TABLES D ON D.TABLE_SCHEMA = @DESTINATIONDBNAME AND
S.TABLE_NAME = D.TABLE_NAME
WHERE S.TABLE_SCHEMA = @SOURCEDBNAME
AND D.TABLE_NAME IS NULL;

-- Gets the table exist only in destination

INSERT INTO DB_COMPARE
SELECT S.TABLE_SCHEMA, S.TABLE_NAME, NULL, 'Table', CONCAT('Table exists only in destination database `',
S.TABLE_SCHEMA, '`.`', S.TABLE_NAME, '`'), 1, NULL, NULL
FROM INFORMATION_SCHEMA.TABLES S
LEFT OUTER JOIN INFORMATION_SCHEMA.TABLES D ON D.TABLE_SCHEMA = @SOURCEDBNAME AND
S.TABLE_NAME = D.TABLE_NAME
WHERE S.TABLE_SCHEMA = @DESTINATIONDBNAME
AND D.TABLE_NAME IS NULL;

-- Gets the columns, which are not part of any missing table, exist in source
INSERT INTO DB_COMPARE
SELECT S.TABLE_SCHEMA, S.TABLE_NAME, S.COLUMN_NAME, 'Column', CONCAT('Column exists only in source
database `', S.TABLE_SCHEMA, '`.`', S.TABLE_NAME, '`'), 1, NULL, NULL
FROM INFORMATION_SCHEMA.COLUMNS S
INNER JOIN INFORMATION_SCHEMA.TABLES T ON S.TABLE_NAME = T.TABLE_NAME AND T.TABLE_SCHEMA
= @DESTINATIONDBNAME
LEFT OUTER JOIN INFORMATION_SCHEMA.COLUMNS D ON D.TABLE_SCHEMA = @DESTINATIONDBNAME
AND S.TABLE_NAME = D.TABLE_NAME AND S.COLUMN_NAME = D.COLUMN_NAME
WHERE S.TABLE_SCHEMA = @SOURCEDBNAME
AND D.COLUMN_NAME IS NULL;

-- Gets the columns, which are not part of any missing table, exist in destination
INSERT INTO DB_COMPARE
SELECT S.TABLE_SCHEMA, S.TABLE_NAME, S.COLUMN_NAME, 'Column', CONCAT('Column exists only in
destination database `', S.TABLE_SCHEMA, '`.`', S.TABLE_NAME, '`'), 1, NULL, NULL
FROM INFORMATION_SCHEMA.COLUMNS S
INNER JOIN INFORMATION_SCHEMA.TABLES T ON S.TABLE_NAME = T.TABLE_NAME AND T.TABLE_SCHEMA
= @SOURCEDBNAME
LEFT OUTER JOIN INFORMATION_SCHEMA.COLUMNS D ON D.TABLE_SCHEMA = @SOURCEDBNAME AND
S.TABLE_NAME = D.TABLE_NAME AND S.COLUMN_NAME = D.COLUMN_NAME
WHERE S.TABLE_SCHEMA = @DESTINATIONDBNAME
AND D.COLUMN_NAME IS NULL;

-- Get entries for change in column

-- The OR conditions shall be replaced by SHA2 HASHING
INSERT INTO DB_COMPARE
SELECT S.TABLE_SCHEMA, S.TABLE_NAME, S.COLUMN_NAME, 'Column', CONCAT('Column property is changed `',
S.TABLE_SCHEMA, '`.`', S.TABLE_NAME, '`'), 0, NULL, NULL
FROM INFORMATION_SCHEMA.COLUMNS S
INNER JOIN INFORMATION_SCHEMA.COLUMNS D ON D.TABLE_SCHEMA = @DESTINATIONDBNAME AND
S.TABLE_NAME = D.TABLE_NAME AND S.COLUMN_NAME = D.COLUMN_NAME
WHERE S.TABLE_SCHEMA = @SOURCEDBNAME
AND
(
COALESCE(S.COLUMN_DEFAULT COLLATE utf8_unicode_ci , '') <> COALESCE(D.COLUMN_DEFAULT COLLATE
utf8_unicode_ci , '')
OR COALESCE(S.IS_NULLABLE COLLATE utf8_unicode_ci , '') <> COALESCE(D.IS_NULLABLE COLLATE
utf8_unicode_ci , '')
/*OR COALESCE(S.DATA_TYPE, '') <> COALESCE(D.DATA_TYPE, '')
OR COALESCE(S.CHARACTER_MAXIMUM_LENGTH, 0) <>
COALESCE(D.CHARACTER_MAXIMUM_LENGTH, 0)
OR COALESCE(S.NUMERIC_PRECISION, 0) <> COALESCE(D.NUMERIC_PRECISION, 0)
OR COALESCE(S.NUMERIC_SCALE, 0) <> COALESCE(D.NUMERIC_SCALE, 0)
OR COALESCE(S.COLUMN_TYPE, '') <> COALESCE(D.COLUMN_TYPE,'')
OR COALESCE(S.DATETIME_PRECISION,0) <> COALESCE(D.DATETIME_PRECISION,0)*/
OR COALESCE(S.CHARACTER_SET_NAME COLLATE utf8_unicode_ci ,'') <>
COALESCE(D.CHARACTER_SET_NAME COLLATE utf8_unicode_ci ,'')
OR COALESCE(S.COLUMN_TYPE COLLATE utf8_unicode_ci, '') <> COALESCE(D.COLUMN_TYPE
COLLATE utf8_unicode_ci,'')
OR COALESCE(S.EXTRA COLLATE utf8_unicode_ci ,'') <> COALESCE(D.EXTRA COLLATE utf8_unicode_ci,'')
OR COALESCE(S.COLUMN_COMMENT COLLATE utf8_unicode_ci ,'') <>
COALESCE(D.COLUMN_COMMENT COLLATE utf8_unicode_ci ,'')
OR COALESCE(S.GENERATION_EXPRESSION COLLATE utf8_unicode_ci,'') <>
COALESCE(D.GENERATION_EXPRESSION COLLATE utf8_unicode_ci ,'')

);
-- AND SHA2(CONCAT(S.COLUMN_DEFAULT, description), 256) = SHA2(CONCAT(name, description), 256);

-- Gets the Indexes, which are not associated with constraints, exist only in destination
INSERT INTO DB_COMPARE
SELECT S.TABLE_SCHEMA, S.TABLE_NAME, S.INDEX_NAME, 'Index', CONCAT('Index exists only in destination
database `', S.TABLE_SCHEMA, '`.`', S.TABLE_NAME, '`'), 1, GROUP_CONCAT( "`", COALESCE(S.COLUMN_NAME
COLLATE utf8_unicode_ci ,S.EXPRESSION COLLATE utf8_unicode_ci ), "`", CASE WHEN S.COLLATION COLLATE
utf8_unicode_ci = 'D' THEN ' DESC ' ELSE '' END, COALESCE(CONCAT(' COMMENT', NULLIF(TRIM(S.COMMENT
COLLATE utf8_unicode_ci),'') ), '') , CASE WHEN S.IS_VISIBLE COLLATE utf8_unicode_ci = 'NO' THEN ' INVISIBLE '
ELSE '' END ORDER BY S.SEQ_IN_INDEX ASC SEPARATOR "," ) INDEX_COLS, S.INDEX_TYPE
FROM INFORMATION_SCHEMA.STATISTICS S
INNER JOIN INFORMATION_SCHEMA.TABLES T ON S.TABLE_NAME = T.TABLE_NAME AND T.TABLE_SCHEMA
= @SOURCEDBNAME
LEFT OUTER JOIN INFORMATION_SCHEMA.STATISTICS D ON D.TABLE_SCHEMA = @SOURCEDBNAME AND
S.TABLE_NAME = D.TABLE_NAME AND S.INDEX_NAME = D.INDEX_NAME
WHERE S.TABLE_SCHEMA = @DESTINATIONDBNAME
-- AND S.NON_UNIQUE = 1
AND D.INDEX_NAME IS NULL
GROUP BY S.TABLE_SCHEMA, S.TABLE_NAME, S.INDEX_NAME, S.INDEX_TYPE;

-- Gets the Indexes, which are not associated with constraints, exist only in source
INSERT INTO DB_COMPARE
SELECT S.TABLE_SCHEMA, S.TABLE_NAME, S.INDEX_NAME, 'Index', CONCAT('Index exists only in source database
`', S.TABLE_SCHEMA, '`.`', S.TABLE_NAME, '`'), 1, GROUP_CONCAT( "`", COALESCE(S.COLUMN_NAME COLLATE
utf8_unicode_ci ,S.EXPRESSION COLLATE utf8_unicode_ci ), "`", CASE WHEN S.COLLATION COLLATE
utf8_unicode_ci = 'D' THEN ' DESC ' ELSE '' END, COALESCE(CONCAT(' COMMENT', NULLIF(TRIM(S.COMMENT
COLLATE utf8_unicode_ci),'') ), '') , CASE WHEN S.IS_VISIBLE COLLATE utf8_unicode_ci = 'NO' THEN ' INVISIBLE '
ELSE '' END ORDER BY S.SEQ_IN_INDEX ASC SEPARATOR "," ) INDEX_COLS, S.INDEX_TYPE
FROM INFORMATION_SCHEMA.STATISTICS S
INNER JOIN INFORMATION_SCHEMA.TABLES T ON S.TABLE_NAME = T.TABLE_NAME AND T.TABLE_SCHEMA
= @DESTINATIONDBNAME
LEFT OUTER JOIN INFORMATION_SCHEMA.STATISTICS D ON D.TABLE_SCHEMA = @DESTINATIONDBNAME
AND S.TABLE_NAME = D.TABLE_NAME AND S.INDEX_NAME = D.INDEX_NAME
WHERE S.TABLE_SCHEMA = @SOURCEDBNAME
-- AND S.NON_UNIQUE = 1
AND D.INDEX_NAME IS NULL
GROUP BY S.TABLE_SCHEMA, S.TABLE_NAME, S.INDEX_NAME, S.INDEX_TYPE;

-- Gets the Indexes, which are not associated with constraints, exist in both databases but with difference in its properties
INSERT INTO DB_COMPARE
SELECT S.*
FROM (
SELECT S.TABLE_SCHEMA, S.TABLE_NAME, S.INDEX_NAME, 'Index', CONCAT('Index with change in properties `',
S.TABLE_SCHEMA, '`.`', S.TABLE_NAME, '`'), 0
, GROUP_CONCAT( "`", COALESCE(S.COLUMN_NAME COLLATE utf8_unicode_ci ,S.EXPRESSION COLLATE
utf8_unicode_ci ), "`", CASE WHEN S.COLLATION COLLATE utf8_unicode_ci = 'D' THEN ' DESC ' ELSE '' END,
COALESCE(CONCAT(' COMMENT', NULLIF(TRIM(S.COMMENT COLLATE utf8_unicode_ci),'') ), '') , CASE WHEN
S.IS_VISIBLE COLLATE utf8_unicode_ci = 'NO' THEN ' INVISIBLE ' ELSE '' END ORDER BY S.SEQ_IN_INDEX ASC
SEPARATOR "," ) INDEX_COLS, S.INDEX_TYPE
FROM INFORMATION_SCHEMA.STATISTICS S
WHERE S.TABLE_SCHEMA = @SOURCEDBNAME
GROUP BY S.TABLE_SCHEMA, S.TABLE_NAME, S.INDEX_NAME, S.INDEX_TYPE
)S
INNER JOIN
(
SELECT S.TABLE_SCHEMA, S.TABLE_NAME, S.INDEX_NAME
,GROUP_CONCAT( "`", COALESCE(S.COLUMN_NAME COLLATE utf8_unicode_ci ,S.EXPRESSION COLLATE
utf8_unicode_ci ), "`", CASE WHEN S.COLLATION COLLATE utf8_unicode_ci = 'D' THEN ' DESC ' ELSE '' END,
COALESCE(CONCAT(' COMMENT', NULLIF(TRIM(S.COMMENT COLLATE utf8_unicode_ci),'') ), '') , CASE WHEN
S.IS_VISIBLE COLLATE utf8_unicode_ci = 'NO' THEN ' INVISIBLE ' ELSE '' END ORDER BY S.SEQ_IN_INDEX ASC
SEPARATOR "," ) INDEX_COLS
FROM INFORMATION_SCHEMA.STATISTICS S
WHERE S.TABLE_SCHEMA = @DESTINATIONDBNAME
GROUP BY S.TABLE_SCHEMA, S.TABLE_NAME, S.INDEX_NAME
) D ON S.TABLE_NAME = D.TABLE_NAME
AND S.INDEX_NAME = D.INDEX_NAME
AND S.INDEX_COLS <> D.INDEX_COLS;

-- Gets missing check constraint from source database

INSERT INTO DB_COMPARE (DATABASE_NAME, TABLE_NAME, OBJECT_NAME, OBJECT_TYPE, MESSAGE,
ISMISSING)
SELECT S.TABLE_SCHEMA, S.TABLE_NAME, S.CONSTRAINT_NAME, S.CONSTRAINT_TYPE, CONCAT(' Missing ',
S.CONSTRAINT_TYPE, '( ', S.CONSTRAINT_NAME, ') in source database'), 1
FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS S
INNER JOIN INFORMATION_SCHEMA.TABLES T ON S.TABLE_NAME = T.TABLE_NAME AND T.TABLE_SCHEMA
= @DESTINATIONDBNAME
LEFT OUTER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS D ON D.TABLE_SCHEMA =
@DESTINATIONDBNAME AND S.TABLE_NAME = D.TABLE_NAME AND S.CONSTRAINT_NAME =
D.CONSTRAINT_NAME AND S.CONSTRAINT_TYPE = D.CONSTRAINT_TYPE
WHERE S.TABLE_SCHEMA = @SOURCEDBNAME
AND D.CONSTRAINT_NAME IS NULL;

-- Gets missing check constraint from destination database

INSERT INTO DB_COMPARE (DATABASE_NAME, TABLE_NAME, OBJECT_NAME, OBJECT_TYPE, MESSAGE,
ISMISSING)
SELECT S.TABLE_SCHEMA, S.TABLE_NAME, S.CONSTRAINT_NAME, S.CONSTRAINT_TYPE, CONCAT(' Missing ',
S.CONSTRAINT_TYPE, '( ', S.CONSTRAINT_NAME, ') in destination database'), 1
FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS S
INNER JOIN INFORMATION_SCHEMA.TABLES T ON S.TABLE_NAME = T.TABLE_NAME AND T.TABLE_SCHEMA
= @SOURCEDBNAME
LEFT OUTER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS D ON D.TABLE_SCHEMA =
@SOURCEDBNAME AND S.TABLE_NAME = D.TABLE_NAME AND S.CONSTRAINT_NAME =
D.CONSTRAINT_NAME AND S.CONSTRAINT_TYPE = D.CONSTRAINT_TYPE
WHERE S.TABLE_SCHEMA = @DESTINATIONDBNAME
AND D.CONSTRAINT_NAME IS NULL;

INSERT INTO DB_COMPARE

SELECT S.TABLE_SCHEMA, S.TABLE_NAME, S.INDEX_NAME, 'Table', 'Missing Table Indexes', 1,
GROUP_CONCAT( "`", COALESCE(S.COLUMN_NAME COLLATE utf8_unicode_ci ,S.EXPRESSION COLLATE
utf8_unicode_ci ), "`", CASE WHEN S.COLLATION COLLATE utf8_unicode_ci = 'D' THEN ' DESC ' ELSE '' END,
COALESCE(CONCAT(' COMMENT', NULLIF(TRIM(S.COMMENT COLLATE utf8_unicode_ci),'') ), '') , CASE WHEN
S.IS_VISIBLE COLLATE utf8_unicode_ci = 'NO' THEN ' INVISIBLE ' ELSE '' END ORDER BY S.SEQ_IN_INDEX ASC
SEPARATOR "," ) INDEX_COLS, S.INDEX_TYPE
FROM INFORMATION_SCHEMA.STATISTICS S
INNER JOIN DB_COMPARE D ON S.TABLE_SCHEMA = D.DATABASE_NAME AND S.TABLE_NAME =
D.TABLE_NAME
WHERE D.OBJECT_TYPE = 'Table'
GROUP BY S.TABLE_SCHEMA, S.TABLE_NAME, S.INDEX_NAME, INDEX_TYPE;

-- Generate Table Schema for the tables exist only in source

SELECT A.*
FROM (
SELECT

CONCAT(' CREATE TABLE IF NOT EXISTS `', @DESTINATIONDBNAME , '`.`',S.TABLE_NAME, '` (',
GROUP_CONCAT( '`', COLUMN_NAME, '` ', COLUMN_TYPE
,CASE WHEN COLLATION_NAME IS NOT NULL THEN CONCAT(' COLLATE ', COLLATION_NAME , ' ') ELSE ' '
END
,CASE WHEN GENERATION_EXPRESSION IS NULL OR LENGTH(TRIM(GENERATION_EXPRESSION)) = 0 THEN
CONCAT( CASE WHEN IS_NULLABLE COLLATE utf8_unicode_ci = 'YES' THEN CONCAT(' NULL', ' DEFAULT ',
COALESCE(COLUMN_DEFAULT, 'NULL')) ELSE CONCAT(' NOT NULL', COALESCE(CONCAT(' DEFAULT ', CASE
WHEN TRIM(COLUMN_DEFAULT) = '' THEN "''" ELSE CASE WHEN SUBSTRING(TRIM(COLUMN_DEFAULT),1,1) =
'(' THEN COLUMN_DEFAULT ELSE CONCAT("'",COLUMN_DEFAULT,"'") END END), '') )END, ' ',
UPPER(LTRIM(COALESCE(REPLACE(EXTRA, 'DEFAULT_GENERATED', ''), ''))) )
ELSE
CONCAT(' GENERATED ALWAYS AS (', GENERATION_EXPRESSION, ') ', CASE EXTRA COLLATE utf8_unicode_ci
WHEN 'STORED GENERATED' THEN ' STORED ' WHEN 'VIRTUAL GENERATED' THEN ' VIRTUAL ' ELSE '' END)
END
ORDER BY C.ORDINAL_POSITION, '
' SEPARATOR ","), COALESCE(CONCAT(', ', MAX(I.INDEX_DEF)),''), COALESCE(CONCAT(', ',
MAX(CHK.CHECK_DEF)), ''), COALESCE(CONCAT(', ', MAX(FKEY.FKEY_DEF)), '') ,') ENGINE=InnoDB DEFAULT
CHARSET=utf8 COLLATE=utf8_unicode_ci;
') TABLE_DEFINITION
FROM DB_COMPARE S
INNER JOIN INFORMATION_SCHEMA.COLUMNS C ON S.DATABASE_NAME = C.TABLE_SCHEMA AND
S.TABLE_NAME = C.TABLE_NAME AND S.OBJECT_NAME IS NULL
LEFT OUTER JOIN
(
SELECT I.DATABASE_NAME TABLE_SCHEMA
,I.TABLE_NAME
,GROUP_CONCAT(CASE CONSTRAINT_TYPE WHEN 'PRIMARY KEY' THEN 'PRIMARY' WHEN 'UNIQUE' THEN
'UNIQUE' ELSE '' END, CASE WHEN INDEX_TYPE = 'BTREE' THEN ' KEY' ELSE CONCAT(' ', INDEX_TYPE, ' KEY ')
END, '`', OBJECT_NAME, '` (', INDEX_COLS, ' )' SEPARATOR "," ) INDEX_DEF
FROM DB_COMPARE I
LEFT JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS TC ON TC.TABLE_SCHEMA = I.DATABASE_NAME
AND TC.TABLE_NAME = I.TABLE_NAME AND TC.CONSTRAINT_NAME = I.OBJECT_NAME
AND CONSTRAINT_TYPE NOT IN ('CHECK','FOREIGN KEY')
WHERE I.OBJECT_TYPE = 'Table' AND I.DATABASE_NAME = @SOURCEDBNAME AND I.ISMISSING = 1 AND
I.OBJECT_NAME IS NOT NULL
GROUP BY I.DATABASE_NAME, I.TABLE_NAME
)I ON I.TABLE_SCHEMA = S.DATABASE_NAME AND I.TABLE_NAME = S.TABLE_NAME
LEFT OUTER JOIN
(
SELECT TABLE_SCHEMA
,TABLE_NAME
,GROUP_CONCAT(CHECK_DEF SEPARATOR ",") CHECK_DEF
FROM (
SELECT TC.TABLE_SCHEMA
,TC.TABLE_NAME
,GROUP_CONCAT(' CONSTRAINT `', TC.CONSTRAINT_NAME, '` CHECK (', CHK.CHECK_CLAUSE, ')' SEPARATOR
"," ) CHECK_DEF
FROM DB_COMPARE I
INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS TC ON TC.TABLE_SCHEMA = I.DATABASE_NAME
AND TC.TABLE_NAME = I.TABLE_NAME AND CONSTRAINT_TYPE = 'CHECK'
INNER JOIN INFORMATION_SCHEMA.CHECK_CONSTRAINTS CHK ON TC.TABLE_SCHEMA =
CHK.CONSTRAINT_SCHEMA AND TC.CONSTRAINT_NAME = CHK.CONSTRAINT_NAME
WHERE OBJECT_TYPE = 'Table' AND I.DATABASE_NAME = @SOURCEDBNAME AND I.ISMISSING = 1 AND
I.OBJECT_NAME IS NULL
GROUP BY TC.TABLE_SCHEMA, TC.TABLE_NAME
)CHK
GROUP BY TABLE_SCHEMA ,TABLE_NAME
)CHK ON CHK.TABLE_SCHEMA = S.DATABASE_NAME AND CHK.TABLE_NAME = S.TABLE_NAME

LEFT OUTER JOIN

(
SELECT TABLE_SCHEMA
,TABLE_NAME
,GROUP_CONCAT(FKEY_DEF SEPARATOR "," ) FKEY_DEF
FROM (
SELECT TC.TABLE_SCHEMA
,TC.TABLE_NAME
,CONCAT(' CONSTRAINT `', FKEY.CONSTRAINT_NAME, '` FOREIGN KEY (', GROUP_CONCAT( '`',
FKEY.COLUMN_NAME , '`' ORDER BY FKEY.ORDINAL_POSITION SEPARATOR ","), ') REFERENCES ', '`',
FKEY.REFERENCED_TABLE_NAME, '`(', GROUP_CONCAT( '`', FKEY.REFERENCED_COLUMN_NAME , '`' ORDER
BY FKEY.ORDINAL_POSITION SEPARATOR ",") , ')'
, CASE WHEN MAX(RC.UPDATE_RULE) = 'NO ACTION' THEN '' ELSE COALESCE(CONCAT(' ON UPDATE ',
MAX(RC.UPDATE_RULE)),'') END
, CASE WHEN MAX(RC.DELETE_RULE) = 'NO ACTION' THEN '' ELSE COALESCE(CONCAT(' ON DELETE ',
MAX(RC.DELETE_RULE)),'') END ) FKEY_DEF
FROM DB_COMPARE I
INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS TC ON TC.TABLE_SCHEMA = I.DATABASE_NAME
AND TC.TABLE_NAME = I.TABLE_NAME AND CONSTRAINT_TYPE = 'FOREIGN KEY'
INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE FKEY ON TC.TABLE_SCHEMA =
FKEY.CONSTRAINT_SCHEMA AND TC.CONSTRAINT_NAME = FKEY.CONSTRAINT_NAME
LEFT OUTER JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS RC ON RC.CONSTRAINT_SCHEMA =
TC.TABLE_SCHEMA AND RC.CONSTRAINT_NAME = TC.CONSTRAINT_NAME
WHERE OBJECT_TYPE = 'Table' AND I.DATABASE_NAME = @SOURCEDBNAME AND I.ISMISSING = 1 AND
I.OBJECT_NAME IS NULL
GROUP BY TC.TABLE_SCHEMA, TC.TABLE_NAME, FKEY.CONSTRAINT_NAME,
FKEY.REFERENCED_TABLE_NAME
) FKEY
GROUP BY TABLE_SCHEMA, TABLE_NAME
)FKEY ON FKEY.TABLE_SCHEMA = S.DATABASE_NAME AND FKEY.TABLE_NAME = S.TABLE_NAME

WHERE OBJECT_TYPE = 'Table' AND S.DATABASE_NAME = @SOURCEDBNAME AND S.ISMISSING = 1

GROUP BY S.DATABASE_NAME, S.TABLE_NAME
)A

UNION ALL

-- select tables that exists only in destination

SELECT CONCAT(' DROP TABLE IF EXISTS `', @DESTINATIONDBNAME , '`.`', S.TABLE_NAME, '`;
')
FROM DB_COMPARE S
WHERE OBJECT_TYPE = 'Table' AND S.DATABASE_NAME = @DESTINATIONDBNAME AND S.ISMISSING = 1

UNION ALL
-- Generate script for missing columns, index and other constraints in Source
SELECT

CONCAT(' ALTER TABLE `', @DESTINATIONDBNAME , '`.`',S.TABLE_NAME, '` ',

SUBSTRING(CONCAT(COALESCE(CONCAT(",",MAX(C.COL_DEF)), ''), COALESCE(CONCAT(', ',
MAX(I.INDEX_DEF)),''), COALESCE(CONCAT(', ', MAX(CHK.CHECK_DEF)), ''), COALESCE(CONCAT(', ',
MAX(FKEY.FKEY_DEF)), '')),2) ,';
') TABLE_DEFINITION
FROM (SELECT DISTINCT S.DATABASE_NAME, S.TABLE_NAME FROM DB_COMPARE S WHERE
S.OBJECT_TYPE <> 'Table' AND S.DATABASE_NAME = @SOURCEDBNAME AND S.ISMISSING = 1) S
LEFT OUTER JOIN (
SELECT GROUP_CONCAT( ' ADD COLUMN `', COLUMN_NAME, '` ', COLUMN_TYPE
,CASE WHEN COLLATION_NAME IS NOT NULL THEN CONCAT(' COLLATE ', COLLATION_NAME , ' ') ELSE ' '
END
,CASE WHEN GENERATION_EXPRESSION IS NULL OR LENGTH(TRIM(GENERATION_EXPRESSION)) = 0 THEN
CONCAT( CASE WHEN IS_NULLABLE COLLATE utf8_unicode_ci = 'YES' THEN CONCAT(' NULL', ' DEFAULT ',
COALESCE(COLUMN_DEFAULT, 'NULL')) ELSE CONCAT(' NOT NULL', COALESCE(CONCAT(' DEFAULT ', CASE
WHEN TRIM(COLUMN_DEFAULT) = '' THEN "''" ELSE CASE WHEN SUBSTRING(TRIM(COLUMN_DEFAULT),1,1) =
'(' THEN COLUMN_DEFAULT ELSE CONCAT("'",COLUMN_DEFAULT,"'") END END), '') )END, ' ',
UPPER(LTRIM(COALESCE(REPLACE(EXTRA, 'DEFAULT_GENERATED', ''), ''))) )
ELSE
CONCAT(' GENERATED ALWAYS AS (', GENERATION_EXPRESSION, ') ', CASE EXTRA COLLATE utf8_unicode_ci
WHEN 'STORED GENERATED' THEN ' STORED ' WHEN 'VIRTUAL GENERATED' THEN ' VIRTUAL ' ELSE '' END)
END
ORDER BY C.ORDINAL_POSITION, '
' SEPARATOR ",") COL_DEF
,S.DATABASE_NAME
,S.TABLE_NAME
FROM DB_COMPARE S
LEFT JOIN INFORMATION_SCHEMA.COLUMNS C ON S.DATABASE_NAME = C.TABLE_SCHEMA AND
S.TABLE_NAME = C.TABLE_NAME AND S.OBJECT_NAME = C.COLUMN_NAME
WHERE S.OBJECT_TYPE = 'Column' AND S.ISMISSING = 1 AND S.DATABASE_NAME =
@SOURCEDBNAME
GROUP BY S.DATABASE_NAME, S.TABLE_NAME
) C ON C.DATABASE_NAME = S.DATABASE_NAME AND C.TABLE_NAME = S.TABLE_NAME
LEFT OUTER JOIN
(
SELECT I.DATABASE_NAME TABLE_SCHEMA
,I.TABLE_NAME
,GROUP_CONCAT(' ADD ', CASE CONSTRAINT_TYPE WHEN 'PRIMARY KEY' THEN 'PRIMARY'
WHEN 'UNIQUE' THEN 'UNIQUE' ELSE '' END, CASE WHEN INDEX_TYPE = 'BTREE' THEN ' KEY' ELSE CONCAT(' ',
INDEX_TYPE, ' KEY ') END, '`', OBJECT_NAME, '` (', INDEX_COLS, ' )' SEPARATOR "," ) INDEX_DEF
 FROM DB_COMPARE I
LEFT OUTER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS TC ON TC.TABLE_SCHEMA =
I.DATABASE_NAME AND TC.TABLE_NAME = I.TABLE_NAME AND TC.CONSTRAINT_NAME = I.OBJECT_NAME
AND CONSTRAINT_TYPE NOT IN ('CHECK','FOREIGN KEY')
WHERE I.OBJECT_TYPE = 'Index' AND I.ISMISSING = 1 AND I.DATABASE_NAME = @SOURCEDBNAME
GROUP BY I.DATABASE_NAME, I.TABLE_NAME
)I ON I.TABLE_SCHEMA = S.DATABASE_NAME AND I.TABLE_NAME = S.TABLE_NAME
LEFT OUTER JOIN
(
SELECT TABLE_SCHEMA
,TABLE_NAME
,GROUP_CONCAT(CHECK_DEF SEPARATOR ",") CHECK_DEF
FROM (
SELECT TC.TABLE_SCHEMA
,TC.TABLE_NAME
,GROUP_CONCAT(' ADD CONSTRAINT `', TC.CONSTRAINT_NAME, '` CHECK (', CHK.CHECK_CLAUSE, ')'
SEPARATOR "," ) CHECK_DEF
FROM DB_COMPARE I
INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS TC ON TC.TABLE_SCHEMA = I.DATABASE_NAME
AND TC.TABLE_NAME = I.TABLE_NAME AND CONSTRAINT_TYPE = 'CHECK'
INNER JOIN INFORMATION_SCHEMA.CHECK_CONSTRAINTS CHK ON TC.TABLE_SCHEMA =
CHK.CONSTRAINT_SCHEMA AND TC.CONSTRAINT_NAME = CHK.CONSTRAINT_NAME
WHERE OBJECT_TYPE = 'CHECK' AND I.DATABASE_NAME = @SOURCEDBNAME AND I.ISMISSING = 1
GROUP BY TC.TABLE_SCHEMA, TC.TABLE_NAME
)CHK
GROUP BY TABLE_SCHEMA, TABLE_NAME
)CHK ON CHK.TABLE_SCHEMA = S.DATABASE_NAME AND CHK.TABLE_NAME = S.TABLE_NAME

LEFT OUTER JOIN

(
SELECT TABLE_SCHEMA
,TABLE_NAME
,GROUP_CONCAT(FKEY_DEF SEPARATOR "," ) FKEY_DEF
FROM (
SELECT TC.TABLE_SCHEMA
,TC.TABLE_NAME
,CONCAT(' ADD CONSTRAINT `', FKEY.CONSTRAINT_NAME, '` FOREIGN KEY (', GROUP_CONCAT( '`',
FKEY.COLUMN_NAME , '`' ORDER BY FKEY.ORDINAL_POSITION SEPARATOR ","), ') REFERENCES ', '`',
FKEY.REFERENCED_TABLE_NAME, '`(', GROUP_CONCAT( '`', FKEY.REFERENCED_COLUMN_NAME , '`' ORDER
BY FKEY.ORDINAL_POSITION SEPARATOR ",") , ')'
, CASE WHEN MAX(RC.UPDATE_RULE) = 'NO ACTION' THEN '' ELSE COALESCE(CONCAT(' ON UPDATE ',
MAX(RC.UPDATE_RULE)),'') END
, CASE WHEN MAX(RC.DELETE_RULE) = 'NO ACTION' THEN '' ELSE
COALESCE(CONCAT(' ON DELETE ', MAX(RC.DELETE_RULE)),'') END ) FKEY_DEF
FROM DB_COMPARE I
INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS TC ON TC.TABLE_SCHEMA = I.DATABASE_NAME
AND TC.TABLE_NAME = I.TABLE_NAME AND CONSTRAINT_TYPE = 'FOREIGN KEY'
INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE FKEY ON TC.TABLE_SCHEMA =
FKEY.CONSTRAINT_SCHEMA AND TC.CONSTRAINT_NAME = FKEY.CONSTRAINT_NAME
LEFT OUTER JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS RC ON
RC.CONSTRAINT_SCHEMA = TC.TABLE_SCHEMA AND RC.CONSTRAINT_NAME = TC.CONSTRAINT_NAME
WHERE OBJECT_TYPE = 'FOREIGN KEY' AND I.DATABASE_NAME = @SOURCEDBNAME AND I.ISMISSING = 1
GROUP BY TC.TABLE_SCHEMA, TC.TABLE_NAME, FKEY.CONSTRAINT_NAME,
FKEY.REFERENCED_TABLE_NAME
) FKEY
GROUP BY TABLE_SCHEMA, TABLE_NAME
)FKEY ON FKEY.TABLE_SCHEMA = S.DATABASE_NAME AND FKEY.TABLE_NAME = S.TABLE_NAME

GROUP BY S.DATABASE_NAME, S.TABLE_NAME

UNION ALL
-- Scripts to alter the existing column, index or constraints
SELECT

CONCAT(' ALTER TABLE `', @DESTINATIONDBNAME , '`.`',S.TABLE_NAME, '` ',

SUBSTRING(CONCAT(COALESCE(CONCAT(",",MAX(C.COL_DEF)),''), COALESCE(CONCAT(', ',
MAX(I.INDEX_DEF)),''), COALESCE(CONCAT(', ', MAX(CHK.CHECK_DEF)), ''), COALESCE(CONCAT(', ',
MAX(FKEY.FKEY_DEF)), '')),2) ,';
') TABLE_DEFINITION
FROM (SELECT DISTINCT S.DATABASE_NAME, S.TABLE_NAME FROM DB_COMPARE S WHERE
S.DATABASE_NAME = @SOURCEDBNAME AND S.ISMISSING = 0) S
LEFT OUTER JOIN (
SELECT GROUP_CONCAT( ' CHANGE COLUMN `', COLUMN_NAME, '` ', '`', COLUMN_NAME, '` ', COLUMN_TYPE
,CASE WHEN COLLATION_NAME IS NOT NULL THEN CONCAT(' COLLATE ', COLLATION_NAME , ' ') ELSE ' '
END
,CASE WHEN GENERATION_EXPRESSION IS NULL OR LENGTH(TRIM(GENERATION_EXPRESSION)) = 0 THEN
CONCAT( CASE WHEN IS_NULLABLE COLLATE utf8_unicode_ci = 'YES' THEN CONCAT(' NULL', ' DEFAULT ',
COALESCE(COLUMN_DEFAULT, 'NULL')) ELSE CONCAT(' NOT NULL', COALESCE(CONCAT(' DEFAULT ', CASE
WHEN TRIM(COLUMN_DEFAULT) = '' THEN "''" ELSE CASE WHEN SUBSTRING(TRIM(COLUMN_DEFAULT),1,1) =
'(' THEN COLUMN_DEFAULT ELSE CONCAT("'",COLUMN_DEFAULT,"'") END END), '') )END, ' ',
UPPER(LTRIM(COALESCE(REPLACE(EXTRA, 'DEFAULT_GENERATED', ''), ''))) )
ELSE
CONCAT(' GENERATED ALWAYS AS (', GENERATION_EXPRESSION, ') ', CASE EXTRA COLLATE utf8_unicode_ci
WHEN 'STORED GENERATED' THEN ' STORED ' WHEN 'VIRTUAL GENERATED' THEN ' VIRTUAL ' ELSE '' END)
END
ORDER BY C.ORDINAL_POSITION, '
' SEPARATOR ",") COL_DEF
,S.DATABASE_NAME
,S.TABLE_NAME
FROM DB_COMPARE S
LEFT JOIN INFORMATION_SCHEMA.COLUMNS C ON S.DATABASE_NAME = C.TABLE_SCHEMA AND
S.TABLE_NAME = C.TABLE_NAME AND S.OBJECT_NAME = C.COLUMN_NAME
WHERE S.OBJECT_TYPE = 'Column' AND S.ISMISSING = 0 AND S.DATABASE_NAME =
@SOURCEDBNAME
GROUP BY S.DATABASE_NAME, S.TABLE_NAME
) C ON C.DATABASE_NAME = S.DATABASE_NAME AND C.TABLE_NAME = S.TABLE_NAME
LEFT OUTER JOIN
(
SELECT I.DATABASE_NAME TABLE_SCHEMA
,I.TABLE_NAME
,GROUP_CONCAT(' DROP ', CASE CONSTRAINT_TYPE WHEN 'PRIMARY KEY' THEN 'PRIMARY
KEY' WHEN 'UNIQUE' THEN 'CONSTRAINT ' ELSE ' KEY ' END, OBJECT_NAME, '`, ',
' ADD ', CASE CONSTRAINT_TYPE WHEN 'PRIMARY KEY' THEN 'PRIMARY' WHEN 'UNIQUE'
THEN 'UNIQUE' ELSE '' END, CASE WHEN INDEX_TYPE = 'BTREE' THEN ' KEY' ELSE CONCAT(' ', INDEX_TYPE, '
KEY ') END, '`', OBJECT_NAME, '` (', INDEX_COLS, ' )' SEPARATOR "," ) INDEX_DEF
FROM DB_COMPARE I
LEFT OUTER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS TC ON TC.TABLE_SCHEMA =
I.DATABASE_NAME AND TC.TABLE_NAME = I.TABLE_NAME AND TC.CONSTRAINT_NAME = I.OBJECT_NAME
AND CONSTRAINT_TYPE NOT IN ('CHECK','FOREIGN KEY')
WHERE I.OBJECT_TYPE = 'Index' AND I.ISMISSING = 0 AND I.DATABASE_NAME = @SOURCEDBNAME
GROUP BY I.DATABASE_NAME, I.TABLE_NAME
)I ON I.TABLE_SCHEMA = S.DATABASE_NAME AND I.TABLE_NAME = S.TABLE_NAME
LEFT OUTER JOIN
(
SELECT TABLE_SCHEMA
,TABLE_NAME
,GROUP_CONCAT(CHECK_DEF SEPARATOR ",") CHECK_DEF
FROM (
SELECT TC.TABLE_SCHEMA
,TC.TABLE_NAME
,GROUP_CONCAT(' DROP CONSTRAINT `', TC.CONSTRAINT_NAME, '`, ',
 ' ADD CONSTRAINT `', TC.CONSTRAINT_NAME, '` CHECK (', CHK.CHECK_CLAUSE, ')'
SEPARATOR "," ) CHECK_DEF
FROM DB_COMPARE I
INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS TC ON TC.TABLE_SCHEMA = I.DATABASE_NAME
AND TC.TABLE_NAME = I.TABLE_NAME AND CONSTRAINT_TYPE = 'CHECK'
INNER JOIN INFORMATION_SCHEMA.CHECK_CONSTRAINTS CHK ON TC.TABLE_SCHEMA =
CHK.CONSTRAINT_SCHEMA AND TC.CONSTRAINT_NAME = CHK.CONSTRAINT_NAME
WHERE OBJECT_TYPE = 'CHECK' AND I.DATABASE_NAME = @SOURCEDBNAME AND I.ISMISSING = 0
GROUP BY TC.TABLE_SCHEMA, TC.TABLE_NAME
)CHK
GROUP BY TABLE_SCHEMA, TABLE_NAME
)CHK ON CHK.TABLE_SCHEMA = S.DATABASE_NAME AND CHK.TABLE_NAME = S.TABLE_NAME

LEFT OUTER JOIN

(
SELECT TABLE_SCHEMA
,TABLE_NAME
,GROUP_CONCAT(FKEY_DEF SEPARATOR "," ) FKEY_DEF
FROM (
SELECT TC.TABLE_SCHEMA
,TC.TABLE_NAME
,CONCAT(' DROP CONSTRAINT `', FKEY.CONSTRAINT_NAME, '`, ',
' ADD CONSTRAINT `', FKEY.CONSTRAINT_NAME, '` FOREIGN KEY (', GROUP_CONCAT( '`',
FKEY.COLUMN_NAME , '`' ORDER BY FKEY.ORDINAL_POSITION SEPARATOR ","), ') REFERENCES ', '`',
FKEY.REFERENCED_TABLE_NAME, '`(', GROUP_CONCAT( '`', FKEY.REFERENCED_COLUMN_NAME , '`' ORDER
BY FKEY.ORDINAL_POSITION SEPARATOR ",") , ')'
, CASE WHEN MAX(RC.UPDATE_RULE) = 'NO ACTION' THEN '' ELSE COALESCE(CONCAT(' ON UPDATE ',
MAX(RC.UPDATE_RULE),'')) END
, CASE WHEN MAX(RC.DELETE_RULE) = 'NO ACTION' THEN '' ELSE
COALESCE(CONCAT(' ON DELETE ', MAX(RC.DELETE_RULE),'')) END ) FKEY_DEF
FROM DB_COMPARE I
INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS TC ON TC.TABLE_SCHEMA = I.DATABASE_NAME
AND TC.TABLE_NAME = I.TABLE_NAME AND CONSTRAINT_TYPE = 'FOREIGN KEY'
INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE FKEY ON TC.TABLE_SCHEMA =
FKEY.CONSTRAINT_SCHEMA AND TC.CONSTRAINT_NAME = FKEY.CONSTRAINT_NAME
LEFT OUTER JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS RC ON
RC.CONSTRAINT_SCHEMA = TC.TABLE_SCHEMA AND RC.CONSTRAINT_NAME = TC.CONSTRAINT_NAME
WHERE OBJECT_TYPE = 'FOREIGN KEY' AND I.DATABASE_NAME = @SOURCEDBNAME AND I.ISMISSING = 0
GROUP BY TC.TABLE_SCHEMA, TC.TABLE_NAME, FKEY.CONSTRAINT_NAME,
FKEY.REFERENCED_TABLE_NAME
) FKEY
GROUP BY TABLE_SCHEMA, TABLE_NAME
)FKEY ON FKEY.TABLE_SCHEMA = S.DATABASE_NAME AND FKEY.TABLE_NAME = S.TABLE_NAME

GROUP BY S.DATABASE_NAME, S.TABLE_NAME

UNION ALL

-- Drop the index, connstraints and columnns which are existing onny in destination
SELECT

CONCAT(' ALTER TABLE `', @DESTINATIONDBNAME , '`.`',S.TABLE_NAME, '` ',

SUBSTRING(CONCAT(COALESCE(CONCAT(",",MAX(C.COL_DEF)),''),
COALESCE(CONCAT(",",MAX(I.INDEX_DEF)),''),COALESCE(CONCAT(",",MAX(CHK.CHECK_DEF)), '')),2) ,';')
TABLE_DEFINITION
FROM (
SELECT DISTINCT S.DATABASE_NAME, S.TABLE_NAME
FROM DB_COMPARE S
WHERE S.DATABASE_NAME = @DESTINATIONDBNAME AND S.ISMISSING = 1 AND OBJECT_TYPE <>
'Table'
AND NOT EXISTS ( SELECT 1 FROM DB_COMPARE D WHERE S.DATABASE_NAME = D.DATABASE_NAME AND
S.TABLE_NAME = D.TABLE_NAME AND D.OBJECT_TYPE = 'Table')
)S
LEFT OUTER JOIN (
SELECT GROUP_CONCAT( 'DROP COLUMN `', OBJECT_NAME, '`' SEPARATOR ",") COL_DEF
,S.DATABASE_NAME
,S.TABLE_NAME
FROM DB_COMPARE S
WHERE S.OBJECT_TYPE = 'Column' AND S.ISMISSING = 1 AND S.DATABASE_NAME =
@DESTINATIONDBNAME
GROUP BY S.DATABASE_NAME, S.TABLE_NAME
) C ON C.DATABASE_NAME = S.DATABASE_NAME AND C.TABLE_NAME = S.TABLE_NAME
LEFT OUTER JOIN
(
SELECT I.DATABASE_NAME TABLE_SCHEMA
,I.TABLE_NAME
,GROUP_CONCAT('DROP ', CASE CONSTRAINT_TYPE WHEN 'PRIMARY KEY' THEN 'PRIMARY
KEY ' WHEN 'UNIQUE' THEN 'CONSTRAINT ' ELSE ' KEY ' END, CASE CONSTRAINT_TYPE WHEN 'PRIMARY
KEY' THEN '' ELSE CONCAT('`',OBJECT_NAME, '`' ) END SEPARATOR "," ) INDEX_DEF
FROM DB_COMPARE I
LEFT OUTER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS TC ON TC.TABLE_SCHEMA =
I.DATABASE_NAME AND TC.TABLE_NAME = I.TABLE_NAME AND TC.CONSTRAINT_NAME = I.OBJECT_NAME
AND CONSTRAINT_TYPE NOT IN ('CHECK','FOREIGN KEY')
WHERE I.OBJECT_TYPE = 'Index' AND I.ISMISSING = 1 AND I.DATABASE_NAME =
@DESTINATIONDBNAME
GROUP BY I.DATABASE_NAME, I.TABLE_NAME
)I ON I.TABLE_SCHEMA = S.DATABASE_NAME AND I.TABLE_NAME = S.TABLE_NAME
LEFT OUTER JOIN
(
SELECT TABLE_SCHEMA
,TABLE_NAME
,GROUP_CONCAT(CHECK_DEF SEPARATOR ",") CHECK_DEF
FROM (
SELECT TC.TABLE_SCHEMA
,TC.TABLE_NAME
,GROUP_CONCAT('DROP CONSTRAINT `', TC.CONSTRAINT_NAME, '`, ' SEPARATOR "," ) CHECK_DEF
FROM DB_COMPARE I
INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS TC ON TC.TABLE_SCHEMA = I.DATABASE_NAME
AND TC.TABLE_NAME = I.TABLE_NAME AND CONSTRAINT_TYPE IN ('CHECK', 'FOREIGN KEY')
WHERE OBJECT_TYPE = 'CHECK' AND I.DATABASE_NAME = @DESTINATIONDBNAME AND I.ISMISSING = 1
GROUP BY TC.TABLE_SCHEMA, TC.TABLE_NAME
)CHK
GROUP BY TABLE_SCHEMA, TABLE_NAME

)CHK ON CHK.TABLE_SCHEMA = S.DATABASE_NAME AND CHK.TABLE_NAME = S.TABLE_NAME

GROUP BY S.DATABASE_NAME, S.TABLE_NAME

;
END //

DELIMITER ;

DROP PROCEDURE IF EXISTS SP_DBSCHEMACOMPARE_CROSS_CLUSTER;

DELIMITER //
CREATE PROCEDURE SP_DBSCHEMACOMPARE_CROSS_CLUSTER (SOURCEDBNAME VARCHAR(64),
DESTINATIONDBNAME VARCHAR(64))
BEGIN
SET @SOURCEDBNAME = SOURCEDBNAME COLLATE utf8_tolower_ci, @DESTINATIONDBNAME =
DESTINATIONDBNAME COLLATE utf8_tolower_ci;

DROP TABLE IF EXISTS DB_COMPARE;

CREATE TABLE IF NOT EXISTS DB_COMPARE
(
DATABASE_NAME VARCHAR(64) COLLATE utf8_tolower_ci
,TABLE_NAME VARCHAR(64) COLLATE utf8_tolower_ci
,OBJECT_NAME VARCHAR(64) COLLATE utf8_tolower_ci
,OBJECT_TYPE VARCHAR(64) COLLATE utf8_tolower_ci
,MESSAGE VARCHAR(255) COLLATE utf8_tolower_ci
,ISMISSING BIT
,INDEX_COLS VARCHAR(2000) COLLATE utf8_tolower_ci
,INDEX_TYPE VARCHAR(100) COLLATE utf8_tolower_ci
,KEY IX_TYPE (OBJECT_TYPE)
,KEY IX_NAME (DATABASE_NAME, TABLE_NAME)
);

-- Gets the tables exist only in source

INSERT INTO DB_COMPARE
SELECT S.TABLE_SCHEMA, S.TABLE_NAME, NULL, 'Table', CONCAT('Table exists only in source database `',
S.TABLE_SCHEMA, '`.`', S.TABLE_NAME, '`'), 1, NULL, NULL
FROM `tables_backup`.information_schema_tables S
LEFT OUTER JOIN `tables_backup`.information_schema_tables D ON D.TABLE_SCHEMA = @DESTINATIONDBNAME
AND S.TABLE_NAME = D.TABLE_NAME
WHERE S.TABLE_SCHEMA = @SOURCEDBNAME
AND D.TABLE_NAME IS NULL;

-- Gets the table exist only in destination

INSERT INTO DB_COMPARE
SELECT S.TABLE_SCHEMA, S.TABLE_NAME, NULL, 'Table', CONCAT('Table exists only in destination database `',
S.TABLE_SCHEMA, '`.`', S.TABLE_NAME, '`'), 1, NULL, NULL
FROM `tables_backup`.information_schema_tables S
LEFT OUTER JOIN `tables_backup`.information_schema_tables D ON D.TABLE_SCHEMA = @SOURCEDBNAME AND
S.TABLE_NAME = D.TABLE_NAME
WHERE S.TABLE_SCHEMA = @DESTINATIONDBNAME
AND D.TABLE_NAME IS NULL;

-- Gets the columns, which are not part of any missing table, exist in source
INSERT INTO DB_COMPARE
SELECT S.TABLE_SCHEMA, S.TABLE_NAME, S.COLUMN_NAME, 'Column', CONCAT('Column exists only in source
database `', S.TABLE_SCHEMA, '`.`', S.TABLE_NAME, '`'), 1, NULL, NULL
FROM `tables_backup`.INFORMATION_SCHEMA_COLUMNS S
INNER JOIN `tables_backup`.information_schema_tables T ON S.TABLE_NAME = T.TABLE_NAME AND
T.TABLE_SCHEMA = @DESTINATIONDBNAME
LEFT OUTER JOIN `tables_backup`.INFORMATION_SCHEMA_COLUMNS D ON D.TABLE_SCHEMA =
@DESTINATIONDBNAME AND S.TABLE_NAME = D.TABLE_NAME AND S.COLUMN_NAME = D.COLUMN_NAME
WHERE S.TABLE_SCHEMA = @SOURCEDBNAME
AND D.COLUMN_NAME IS NULL;

-- Gets the columns, which are not part of any missing table, exist in destination
INSERT INTO DB_COMPARE
SELECT S.TABLE_SCHEMA, S.TABLE_NAME, S.COLUMN_NAME, 'Column', CONCAT('Column exists only in
destination database `', S.TABLE_SCHEMA, '`.`', S.TABLE_NAME, '`'), 1, NULL, NULL
FROM `tables_backup`.INFORMATION_SCHEMA_COLUMNS S
INNER JOIN `tables_backup`.information_schema_tables T ON S.TABLE_NAME = T.TABLE_NAME AND
T.TABLE_SCHEMA = @SOURCEDBNAME
LEFT OUTER JOIN `tables_backup`.INFORMATION_SCHEMA_COLUMNS D ON D.TABLE_SCHEMA =
@SOURCEDBNAME AND S.TABLE_NAME = D.TABLE_NAME AND S.COLUMN_NAME = D.COLUMN_NAME
WHERE S.TABLE_SCHEMA = @DESTINATIONDBNAME
AND D.COLUMN_NAME IS NULL;

-- Get entries for change in column

-- The OR conditions shall be replaced by SHA2 HASHING
INSERT INTO DB_COMPARE
SELECT S.TABLE_SCHEMA, S.TABLE_NAME, S.COLUMN_NAME, 'Column', CONCAT('Column property is changed `',
S.TABLE_SCHEMA, '`.`', S.TABLE_NAME, '`'), 0, NULL, NULL
FROM `tables_backup`.INFORMATION_SCHEMA_COLUMNS S
INNER JOIN `tables_backup`.INFORMATION_SCHEMA_COLUMNS D ON D.TABLE_SCHEMA =
@DESTINATIONDBNAME AND S.TABLE_NAME = D.TABLE_NAME AND S.COLUMN_NAME = D.COLUMN_NAME
WHERE S.TABLE_SCHEMA = @SOURCEDBNAME
AND
(
COALESCE(S.COLUMN_DEFAULT, '') <> COALESCE(D.COLUMN_DEFAULT, '')
OR COALESCE(S.IS_NULLABLE , '') <> COALESCE(D.IS_NULLABLE , '')
OR COALESCE(S.CHARACTER_SET_NAME,'') <> COALESCE(D.CHARACTER_SET_NAME,'')
OR COALESCE(S.COLUMN_TYPE, '') <> COALESCE(D.COLUMN_TYPE,'')
OR COALESCE(S.EXTRA,'') <> COALESCE(D.EXTRA,'')
OR COALESCE(S.COLUMN_COMMENT,'') <> COALESCE(D.COLUMN_COMMENT,'')
OR COALESCE(S.GENERATION_EXPRESSION,'') <> COALESCE(D.GENERATION_EXPRESSION,'')

);
-- AND SHA2(CONCAT(S.COLUMN_DEFAULT, description), 256) = SHA2(CONCAT(name, description), 256);

-- Gets the Indexes, which are not associated with constraints, exist only in destination
INSERT INTO DB_COMPARE
SELECT S.TABLE_SCHEMA, S.TABLE_NAME, S.INDEX_NAME, 'Index', CONCAT('Inded exists only in destination
database `', S.TABLE_SCHEMA, '`.`', S.TABLE_NAME, '`'), 1, GROUP_CONCAT( "`",
COALESCE(S.COLUMN_NAME ,S.EXPRESSION ), "`", CASE WHEN S.COLLATION = 'D' THEN ' DESC ' ELSE '' END,
COALESCE(CONCAT(' COMMENT', NULLIF(TRIM(S.COMMENT),'') ), '') , CASE WHEN S.IS_VISIBLE = 'NO' THEN '
INVISIBLE ' ELSE '' END ORDER BY S.SEQ_IN_INDEX ASC SEPARATOR "," ) INDEX_COLS, S.INDEX_TYPE
FROM `tables_backup`.INFORMATION_SCHEMA_STATISTICS S
INNER JOIN `tables_backup`.information_schema_tables T ON S.TABLE_NAME = T.TABLE_NAME AND
T.TABLE_SCHEMA = @SOURCEDBNAME
LEFT OUTER JOIN `tables_backup`.INFORMATION_SCHEMA_STATISTICS D ON D.TABLE_SCHEMA =
@SOURCEDBNAME AND S.TABLE_NAME = D.TABLE_NAME AND S.INDEX_NAME = D.INDEX_NAME
WHERE S.TABLE_SCHEMA = @DESTINATIONDBNAME
-- AND S.NON_UNIQUE = 1
AND D.INDEX_NAME IS NULL
GROUP BY S.TABLE_SCHEMA, S.TABLE_NAME, S.INDEX_NAME, S.INDEX_TYPE;

-- Gets the Indexes, which are not associated with constraints, exist only in source
INSERT INTO DB_COMPARE
SELECT S.TABLE_SCHEMA, S.TABLE_NAME, S.INDEX_NAME, 'Index', CONCAT('Inded exists only in source database
`', S.TABLE_SCHEMA, '`.`', S.TABLE_NAME, '`'), 1, GROUP_CONCAT( "`",
COALESCE(S.COLUMN_NAME ,S.EXPRESSION ), "`", CASE WHEN S.COLLATION = 'D' THEN ' DESC ' ELSE '' END,
COALESCE(CONCAT(' COMMENT', NULLIF(TRIM(S.COMMENT),'') ), '') , CASE WHEN S.IS_VISIBLE = 'NO' THEN '
INVISIBLE ' ELSE '' END ORDER BY S.SEQ_IN_INDEX ASC SEPARATOR "," ) INDEX_COLS, S.INDEX_TYPE
FROM `tables_backup`.INFORMATION_SCHEMA_STATISTICS S
INNER JOIN `tables_backup`.information_schema_tables T ON S.TABLE_NAME = T.TABLE_NAME AND
T.TABLE_SCHEMA = @DESTINATIONDBNAME
LEFT OUTER JOIN `tables_backup`.INFORMATION_SCHEMA_STATISTICS D ON D.TABLE_SCHEMA =
@DESTINATIONDBNAME AND S.TABLE_NAME = D.TABLE_NAME AND S.INDEX_NAME = D.INDEX_NAME
WHERE S.TABLE_SCHEMA = @SOURCEDBNAME
-- AND S.NON_UNIQUE = 1
AND D.INDEX_NAME IS NULL
GROUP BY S.TABLE_SCHEMA, S.TABLE_NAME, S.INDEX_NAME, S.INDEX_TYPE;

-- Gets the Indexes, which are not associated with constraints, exist in both databases but with difference in its properties
INSERT INTO DB_COMPARE
SELECT S.*
FROM (
SELECT S.TABLE_SCHEMA, S.TABLE_NAME, S.INDEX_NAME, 'Index', CONCAT('Index with change in properties `',
S.TABLE_SCHEMA, '`.`', S.TABLE_NAME, '`'), 0
 , GROUP_CONCAT( "`", COALESCE(S.COLUMN_NAME ,S.EXPRESSION ), "`", CASE WHEN S.COLLATION = 'D'
THEN ' DESC ' ELSE '' END, COALESCE(CONCAT(' COMMENT', NULLIF(TRIM(S.COMMENT),'') ), '') , CASE WHEN
S.IS_VISIBLE = 'NO' THEN ' INVISIBLE ' ELSE '' END ORDER BY S.SEQ_IN_INDEX ASC SEPARATOR "," )
INDEX_COLS, S.INDEX_TYPE
FROM `tables_backup`.INFORMATION_SCHEMA_STATISTICS S
WHERE S.TABLE_SCHEMA = @SOURCEDBNAME
GROUP BY S.TABLE_SCHEMA, S.TABLE_NAME, S.INDEX_NAME, S.INDEX_TYPE
)S
INNER JOIN
(
SELECT S.TABLE_SCHEMA, S.TABLE_NAME, S.INDEX_NAME
,GROUP_CONCAT( "`", COALESCE(S.COLUMN_NAME ,S.EXPRESSION ), "`", CASE WHEN S.COLLATION = 'D'
THEN ' DESC ' ELSE '' END, COALESCE(CONCAT(' COMMENT', NULLIF(TRIM(S.COMMENT COLLATE
utf8_unicode_ci),'') ), '') , CASE WHEN S.IS_VISIBLE = 'NO' THEN ' INVISIBLE ' ELSE '' END ORDER BY
S.SEQ_IN_INDEX ASC SEPARATOR "," ) INDEX_COLS
FROM `tables_backup`.INFORMATION_SCHEMA_STATISTICS S
WHERE S.TABLE_SCHEMA = @DESTINATIONDBNAME
GROUP BY S.TABLE_SCHEMA, S.TABLE_NAME, S.INDEX_NAME
) D ON S.TABLE_NAME = D.TABLE_NAME
AND S.INDEX_NAME = D.INDEX_NAME
AND S.INDEX_COLS <> D.INDEX_COLS;

-- Gets missing check constraint from source database

INSERT INTO DB_COMPARE (DATABASE_NAME, TABLE_NAME, OBJECT_NAME, OBJECT_TYPE, MESSAGE,
ISMISSING)
SELECT S.TABLE_SCHEMA, S.TABLE_NAME, S.CONSTRAINT_NAME, S.CONSTRAINT_TYPE, CONCAT(' Missing ',
S.CONSTRAINT_TYPE, '( ', S.CONSTRAINT_NAME, ') in source database'), 1
FROM `tables_backup`.INFORMATION_SCHEMA_TABLE_CONSTRAINTS S
INNER JOIN `tables_backup`.information_schema_tables T ON S.TABLE_NAME = T.TABLE_NAME AND
T.TABLE_SCHEMA = @DESTINATIONDBNAME
LEFT OUTER JOIN `tables_backup`.INFORMATION_SCHEMA_TABLE_CONSTRAINTS D ON D.TABLE_SCHEMA =
@DESTINATIONDBNAME AND S.TABLE_NAME = D.TABLE_NAME AND S.CONSTRAINT_NAME =
D.CONSTRAINT_NAME AND S.CONSTRAINT_TYPE = D.CONSTRAINT_TYPE
WHERE S.TABLE_SCHEMA = @SOURCEDBNAME
AND D.CONSTRAINT_NAME IS NULL;

-- Gets missing check constraint from destination database

INSERT INTO DB_COMPARE (DATABASE_NAME, TABLE_NAME, OBJECT_NAME, OBJECT_TYPE, MESSAGE,
ISMISSING)
SELECT S.TABLE_SCHEMA, S.TABLE_NAME, S.CONSTRAINT_NAME, S.CONSTRAINT_TYPE, CONCAT(' Missing ',
S.CONSTRAINT_TYPE, '( ', S.CONSTRAINT_NAME, ') in destination database'), 1
FROM `tables_backup`.INFORMATION_SCHEMA_TABLE_CONSTRAINTS S
INNER JOIN `tables_backup`.information_schema_tables T ON S.TABLE_NAME = T.TABLE_NAME AND
T.TABLE_SCHEMA = @SOURCEDBNAME
LEFT OUTER JOIN `tables_backup`.INFORMATION_SCHEMA_TABLE_CONSTRAINTS D ON D.TABLE_SCHEMA =
@SOURCEDBNAME AND S.TABLE_NAME = D.TABLE_NAME AND S.CONSTRAINT_NAME =
D.CONSTRAINT_NAME AND S.CONSTRAINT_TYPE = D.CONSTRAINT_TYPE
WHERE S.TABLE_SCHEMA = @DESTINATIONDBNAME
AND D.CONSTRAINT_NAME IS NULL;

INSERT INTO DB_COMPARE

SELECT S.TABLE_SCHEMA, S.TABLE_NAME, S.INDEX_NAME, 'Table', 'Missing Table Indexes', 1 ,
GROUP_CONCAT( "`", COALESCE(S.COLUMN_NAME ,S.EXPRESSION ), "`", CASE WHEN S.COLLATION = 'D'
THEN ' DESC ' ELSE '' END, COALESCE(CONCAT(' COMMENT', NULLIF(TRIM(S.COMMENT COLLATE
utf8_unicode_ci),'') ), '') , CASE WHEN S.IS_VISIBLE = 'NO' THEN ' INVISIBLE ' ELSE '' END ORDER BY
S.SEQ_IN_INDEX ASC SEPARATOR "," ) INDEX_COLS, S.INDEX_TYPE
FROM `tables_backup`.INFORMATION_SCHEMA_STATISTICS S
INNER JOIN DB_COMPARE D ON S.TABLE_SCHEMA = D.DATABASE_NAME AND S.TABLE_NAME =
D.TABLE_NAME
WHERE D.OBJECT_TYPE = 'Table'
GROUP BY S.TABLE_SCHEMA, S.TABLE_NAME, S.INDEX_NAME, INDEX_TYPE;

-- Generate Table Schema for the tables exist only in source

SELECT A.*
FROM (
SELECT

CONCAT(' CREATE TABLE IF NOT EXISTS `', @DESTINATIONDBNAME , '`.`',S.TABLE_NAME, '` (',
GROUP_CONCAT( '`', COLUMN_NAME, '` ', COLUMN_TYPE
,CASE WHEN COLLATION_NAME IS NOT NULL THEN CONCAT(' COLLATE ', COLLATION_NAME , ' ') ELSE ' '
END
,CASE WHEN GENERATION_EXPRESSION IS NULL OR LENGTH(TRIM(GENERATION_EXPRESSION)) = 0 THEN
CONCAT( CASE WHEN IS_NULLABLE = 'YES' THEN CONCAT(' NULL', ' DEFAULT ',
COALESCE(COLUMN_DEFAULT, 'NULL')) ELSE CONCAT(' NOT NULL', COALESCE(CONCAT(' DEFAULT ', CASE
WHEN TRIM(COLUMN_DEFAULT) = '' THEN "''" ELSE CASE WHEN SUBSTRING(TRIM(COLUMN_DEFAULT),1,1) =
'(' THEN COLUMN_DEFAULT ELSE CONCAT("'",COLUMN_DEFAULT,"'") END END), '') )END, ' ',
UPPER(LTRIM(COALESCE(REPLACE(EXTRA, 'DEFAULT_GENERATED', ''), ''))) )
ELSE
CONCAT(' GENERATED ALWAYS AS (', GENERATION_EXPRESSION, ') ', CASE EXTRA WHEN 'STORED
GENERATED' THEN ' STORED ' WHEN 'VIRTUAL GENERATED' THEN ' VIRTUAL ' ELSE '' END)
END
ORDER BY C.ORDINAL_POSITION, '
' SEPARATOR ","), COALESCE(CONCAT(', ', MAX(I.INDEX_DEF)),''), COALESCE(CONCAT(', ',
MAX(CHK.CHECK_DEF)), ''), COALESCE(CONCAT(', ', MAX(FKEY.FKEY_DEF)), '') ,') ENGINE=InnoDB DEFAULT
CHARSET=utf8 COLLATE=utf8_unicode_ci;
') TABLE_DEFINITION
FROM DB_COMPARE S
INNER JOIN `tables_backup`.INFORMATION_SCHEMA_COLUMNS C ON S.DATABASE_NAME = C.TABLE_SCHEMA
AND S.TABLE_NAME = C.TABLE_NAME AND S.OBJECT_NAME IS NULL
LEFT OUTER JOIN
(
SELECT I.DATABASE_NAME TABLE_SCHEMA
,I.TABLE_NAME
,GROUP_CONCAT(CASE CONSTRAINT_TYPE WHEN 'PRIMARY KEY' THEN 'PRIMARY' WHEN 'UNIQUE' THEN
'UNIQUE' ELSE '' END, CASE WHEN INDEX_TYPE = 'BTREE' THEN ' KEY' ELSE CONCAT(' ', INDEX_TYPE, ' KEY ')
END, '`', OBJECT_NAME, '` (', INDEX_COLS, ' )' SEPARATOR "," ) INDEX_DEF
FROM DB_COMPARE I
LEFT JOIN `tables_backup`.INFORMATION_SCHEMA_TABLE_CONSTRAINTS TC ON TC.TABLE_SCHEMA =
I.DATABASE_NAME AND TC.TABLE_NAME = I.TABLE_NAME AND TC.CONSTRAINT_NAME = I.OBJECT_NAME
AND CONSTRAINT_TYPE NOT IN ('CHECK','FOREIGN KEY')
WHERE I.OBJECT_TYPE = 'Table' AND I.DATABASE_NAME = @SOURCEDBNAME AND I.ISMISSING = 1 AND
I.OBJECT_NAME IS NOT NULL
GROUP BY I.DATABASE_NAME, I.TABLE_NAME
)I ON I.TABLE_SCHEMA = S.DATABASE_NAME AND I.TABLE_NAME = S.TABLE_NAME
LEFT OUTER JOIN
(
SELECT TABLE_SCHEMA
,TABLE_NAME
,GROUP_CONCAT(CHECK_DEF SEPARATOR ",") CHECK_DEF
FROM (
SELECT TC.TABLE_SCHEMA
,TC.TABLE_NAME
,GROUP_CONCAT(' CONSTRAINT `', TC.CONSTRAINT_NAME, '` CHECK (', CHK.CHECK_CLAUSE, ')' SEPARATOR
"," ) CHECK_DEF
FROM DB_COMPARE I
INNER JOIN `tables_backup`.INFORMATION_SCHEMA_TABLE_CONSTRAINTS TC ON TC.TABLE_SCHEMA =
I.DATABASE_NAME AND TC.TABLE_NAME = I.TABLE_NAME AND CONSTRAINT_TYPE = 'CHECK'
INNER JOIN `tables_backup`.INFORMATION_SCHEMA_CHECK_CONSTRAINTS CHK ON TC.TABLE_SCHEMA =
CHK.CONSTRAINT_SCHEMA AND TC.CONSTRAINT_NAME = CHK.CONSTRAINT_NAME
WHERE OBJECT_TYPE = 'Table' AND I.DATABASE_NAME = @SOURCEDBNAME AND I.ISMISSING = 1 AND
I.OBJECT_NAME IS NULL
GROUP BY TC.TABLE_SCHEMA, TC.TABLE_NAME
)CHK
GROUP BY TABLE_SCHEMA ,TABLE_NAME
)CHK ON CHK.TABLE_SCHEMA = S.DATABASE_NAME AND CHK.TABLE_NAME = S.TABLE_NAME

LEFT OUTER JOIN

(
SELECT TABLE_SCHEMA
,TABLE_NAME
,GROUP_CONCAT(FKEY_DEF SEPARATOR "," ) FKEY_DEF
FROM (
SELECT TC.TABLE_SCHEMA
,TC.TABLE_NAME
,CONCAT(' CONSTRAINT `', FKEY.CONSTRAINT_NAME, '` FOREIGN KEY (', GROUP_CONCAT( '`',
FKEY.COLUMN_NAME , '`' ORDER BY FKEY.ORDINAL_POSITION SEPARATOR ","), ') REFERENCES ', '`',
FKEY.REFERENCED_TABLE_NAME, '`(', GROUP_CONCAT( '`', FKEY.REFERENCED_COLUMN_NAME , '`' ORDER
BY FKEY.ORDINAL_POSITION SEPARATOR ",") , ')'
, CASE WHEN MAX(RC.UPDATE_RULE) = 'NO ACTION' THEN '' ELSE COALESCE(CONCAT(' ON UPDATE ',
MAX(RC.UPDATE_RULE)),'') END
, CASE WHEN MAX(RC.DELETE_RULE) = 'NO ACTION' THEN '' ELSE COALESCE(CONCAT(' ON DELETE ',
MAX(RC.DELETE_RULE)),'') END ) FKEY_DEF
FROM DB_COMPARE I
INNER JOIN `tables_backup`.INFORMATION_SCHEMA_TABLE_CONSTRAINTS TC ON TC.TABLE_SCHEMA =
I.DATABASE_NAME AND TC.TABLE_NAME = I.TABLE_NAME AND CONSTRAINT_TYPE = 'FOREIGN KEY'
INNER JOIN `tables_backup`.INFORMATION_SCHEMA_KEY_COLUMN_USAGE FKEY ON TC.TABLE_SCHEMA =
FKEY.CONSTRAINT_SCHEMA AND TC.CONSTRAINT_NAME = FKEY.CONSTRAINT_NAME
LEFT OUTER JOIN `tables_backup`.INFORMATION_SCHEMA_REFERENTIAL_CONSTRAINTS RC ON
RC.CONSTRAINT_SCHEMA = TC.TABLE_SCHEMA AND RC.CONSTRAINT_NAME = TC.CONSTRAINT_NAME
WHERE OBJECT_TYPE = 'Table' AND I.DATABASE_NAME = @SOURCEDBNAME AND I.ISMISSING = 1 AND
I.OBJECT_NAME IS NULL
GROUP BY TC.TABLE_SCHEMA, TC.TABLE_NAME, FKEY.CONSTRAINT_NAME,
FKEY.REFERENCED_TABLE_NAME
) FKEY
GROUP BY TABLE_SCHEMA, TABLE_NAME
)FKEY ON FKEY.TABLE_SCHEMA = S.DATABASE_NAME AND FKEY.TABLE_NAME = S.TABLE_NAME

WHERE OBJECT_TYPE = 'Table' AND S.DATABASE_NAME = @SOURCEDBNAME AND S.ISMISSING = 1

GROUP BY S.DATABASE_NAME, S.TABLE_NAME
)A

UNION ALL

-- select tables that exists only in destination

SELECT CONCAT(' DROP TABLE IF EXISTS `', @DESTINATIONDBNAME , '`.`', S.TABLE_NAME, '`;
')
FROM DB_COMPARE S
WHERE OBJECT_TYPE = 'Table' AND S.DATABASE_NAME = @DESTINATIONDBNAME AND S.ISMISSING = 1

UNION ALL
-- Generate script for missing columns, index and other constraints in Source
SELECT

CONCAT(' ALTER TABLE `', @DESTINATIONDBNAME , '`.`',S.TABLE_NAME, '` ',

SUBSTRING(CONCAT(COALESCE(CONCAT(",",MAX(C.COL_DEF)), ''), COALESCE(CONCAT(', ',
MAX(I.INDEX_DEF)),''), COALESCE(CONCAT(', ', MAX(CHK.CHECK_DEF)), ''), COALESCE(CONCAT(', ',
MAX(FKEY.FKEY_DEF)), '')),2) ,';
') TABLE_DEFINITION
FROM (SELECT DISTINCT S.DATABASE_NAME, S.TABLE_NAME FROM DB_COMPARE S WHERE
S.OBJECT_TYPE <> 'Table' AND S.DATABASE_NAME = @SOURCEDBNAME AND S.ISMISSING = 1) S
LEFT OUTER JOIN (
SELECT GROUP_CONCAT( ' ADD COLUMN `', COLUMN_NAME, '` ', COLUMN_TYPE
,CASE WHEN COLLATION_NAME IS NOT NULL THEN CONCAT(' COLLATE ', COLLATION_NAME , ' ') ELSE ' '
END
,CASE WHEN GENERATION_EXPRESSION IS NULL OR LENGTH(TRIM(GENERATION_EXPRESSION)) = 0 THEN
CONCAT( CASE WHEN IS_NULLABLE = 'YES' THEN CONCAT(' NULL', ' DEFAULT ',
COALESCE(COLUMN_DEFAULT, 'NULL')) ELSE CONCAT(' NOT NULL', COALESCE(CONCAT(' DEFAULT ', CASE
WHEN TRIM(COLUMN_DEFAULT) = '' THEN "''" ELSE CASE WHEN SUBSTRING(TRIM(COLUMN_DEFAULT),1,1) =
'(' THEN COLUMN_DEFAULT ELSE CONCAT("'",COLUMN_DEFAULT,"'") END END), '') )END, ' ',
UPPER(LTRIM(COALESCE(REPLACE(EXTRA, 'DEFAULT_GENERATED', ''), ''))) )
ELSE
CONCAT(' GENERATED ALWAYS AS (', GENERATION_EXPRESSION, ') ', CASE EXTRA WHEN 'STORED
GENERATED' THEN ' STORED ' WHEN 'VIRTUAL GENERATED' THEN ' VIRTUAL ' ELSE '' END)
END
ORDER BY C.ORDINAL_POSITION, '
' SEPARATOR ",") COL_DEF
,S.DATABASE_NAME
,S.TABLE_NAME
FROM DB_COMPARE S
LEFT JOIN `tables_backup`.INFORMATION_SCHEMA_COLUMNS C ON S.DATABASE_NAME = C.TABLE_SCHEMA
AND S.TABLE_NAME = C.TABLE_NAME AND S.OBJECT_NAME = C.COLUMN_NAME
WHERE S.OBJECT_TYPE = 'Column' AND S.ISMISSING = 1 AND S.DATABASE_NAME =
@SOURCEDBNAME
GROUP BY S.DATABASE_NAME, S.TABLE_NAME
) C ON C.DATABASE_NAME = S.DATABASE_NAME AND C.TABLE_NAME = S.TABLE_NAME
LEFT OUTER JOIN
(
SELECT I.DATABASE_NAME TABLE_SCHEMA
,I.TABLE_NAME
,GROUP_CONCAT(' ADD ', CASE CONSTRAINT_TYPE WHEN 'PRIMARY KEY' THEN 'PRIMARY'
WHEN 'UNIQUE' THEN 'UNIQUE' ELSE '' END, CASE WHEN INDEX_TYPE = 'BTREE' THEN ' KEY' ELSE CONCAT(' ',
INDEX_TYPE, ' KEY ') END, '`', OBJECT_NAME, '` (', INDEX_COLS, ' )' SEPARATOR "," ) INDEX_DEF
FROM DB_COMPARE I
LEFT OUTER JOIN `tables_backup`.INFORMATION_SCHEMA_TABLE_CONSTRAINTS TC ON
TC.TABLE_SCHEMA = I.DATABASE_NAME AND TC.TABLE_NAME = I.TABLE_NAME AND
TC.CONSTRAINT_NAME = I.OBJECT_NAME AND CONSTRAINT_TYPE NOT IN ('CHECK','FOREIGN KEY')
WHERE I.OBJECT_TYPE = 'Index' AND I.ISMISSING = 1 AND I.DATABASE_NAME = @SOURCEDBNAME
GROUP BY I.DATABASE_NAME, I.TABLE_NAME
)I ON I.TABLE_SCHEMA = S.DATABASE_NAME AND I.TABLE_NAME = S.TABLE_NAME
LEFT OUTER JOIN
(
SELECT TABLE_SCHEMA
,TABLE_NAME
,GROUP_CONCAT(CHECK_DEF SEPARATOR ",") CHECK_DEF
FROM (
SELECT TC.TABLE_SCHEMA
,TC.TABLE_NAME
,GROUP_CONCAT(' ADD CONSTRAINT `', TC.CONSTRAINT_NAME, '` CHECK (', CHK.CHECK_CLAUSE, ')'
SEPARATOR "," ) CHECK_DEF
FROM DB_COMPARE I
INNER JOIN `tables_backup`.INFORMATION_SCHEMA_TABLE_CONSTRAINTS TC ON TC.TABLE_SCHEMA =
I.DATABASE_NAME AND TC.TABLE_NAME = I.TABLE_NAME AND CONSTRAINT_TYPE = 'CHECK'
INNER JOIN `tables_backup`.INFORMATION_SCHEMA_CHECK_CONSTRAINTS CHK ON TC.TABLE_SCHEMA =
CHK.CONSTRAINT_SCHEMA AND TC.CONSTRAINT_NAME = CHK.CONSTRAINT_NAME
WHERE OBJECT_TYPE = 'CHECK' AND I.DATABASE_NAME = @SOURCEDBNAME AND I.ISMISSING = 1
GROUP BY TC.TABLE_SCHEMA, TC.TABLE_NAME
)CHK
GROUP BY TABLE_SCHEMA, TABLE_NAME
)CHK ON CHK.TABLE_SCHEMA = S.DATABASE_NAME AND CHK.TABLE_NAME = S.TABLE_NAME

LEFT OUTER JOIN

(
SELECT TABLE_SCHEMA
,TABLE_NAME
,GROUP_CONCAT(FKEY_DEF SEPARATOR "," ) FKEY_DEF
FROM (
SELECT TC.TABLE_SCHEMA
,TC.TABLE_NAME
,CONCAT(' ADD CONSTRAINT `', FKEY.CONSTRAINT_NAME, '` FOREIGN KEY (', GROUP_CONCAT( '`',
FKEY.COLUMN_NAME , '`' ORDER BY FKEY.ORDINAL_POSITION SEPARATOR ","), ') REFERENCES ', '`',
FKEY.REFERENCED_TABLE_NAME, '`(', GROUP_CONCAT( '`', FKEY.REFERENCED_COLUMN_NAME , '`' ORDER
BY FKEY.ORDINAL_POSITION SEPARATOR ",") , ')'
, CASE WHEN MAX(RC.UPDATE_RULE) = 'NO ACTION' THEN '' ELSE COALESCE(CONCAT(' ON UPDATE ',
MAX(RC.UPDATE_RULE)),'') END
, CASE WHEN MAX(RC.DELETE_RULE) = 'NO ACTION' THEN '' ELSE
COALESCE(CONCAT(' ON DELETE ', MAX(RC.DELETE_RULE)),'') END ) FKEY_DEF
FROM DB_COMPARE I
INNER JOIN `tables_backup`.INFORMATION_SCHEMA_TABLE_CONSTRAINTS TC ON TC.TABLE_SCHEMA =
I.DATABASE_NAME AND TC.TABLE_NAME = I.TABLE_NAME AND CONSTRAINT_TYPE = 'FOREIGN KEY'
INNER JOIN `tables_backup`.INFORMATION_SCHEMA_KEY_COLUMN_USAGE FKEY ON TC.TABLE_SCHEMA =
FKEY.CONSTRAINT_SCHEMA AND TC.CONSTRAINT_NAME = FKEY.CONSTRAINT_NAME
LEFT OUTER JOIN `tables_backup`.INFORMATION_SCHEMA_REFERENTIAL_CONSTRAINTS RC ON
RC.CONSTRAINT_SCHEMA = TC.TABLE_SCHEMA AND RC.CONSTRAINT_NAME = TC.CONSTRAINT_NAME
WHERE OBJECT_TYPE = 'FOREIGN KEY' AND I.DATABASE_NAME = @SOURCEDBNAME AND I.ISMISSING = 1
GROUP BY TC.TABLE_SCHEMA, TC.TABLE_NAME, FKEY.CONSTRAINT_NAME,
FKEY.REFERENCED_TABLE_NAME
) FKEY
GROUP BY TABLE_SCHEMA, TABLE_NAME
)FKEY ON FKEY.TABLE_SCHEMA = S.DATABASE_NAME AND FKEY.TABLE_NAME = S.TABLE_NAME

GROUP BY S.DATABASE_NAME, S.TABLE_NAME

UNION ALL

-- Scripts to alter the existing column, index or constraints

SELECT

CONCAT(' ALTER TABLE `', @DESTINATIONDBNAME , '`.`',S.TABLE_NAME, '` ',

SUBSTRING(CONCAT(COALESCE(CONCAT(",",MAX(C.COL_DEF)),''), COALESCE(CONCAT(', ',
MAX(I.INDEX_DEF)),''), COALESCE(CONCAT(', ', MAX(CHK.CHECK_DEF)), ''), COALESCE(CONCAT(', ',
MAX(FKEY.FKEY_DEF)), '')),2) ,';
') TABLE_DEFINITION
FROM (SELECT DISTINCT S.DATABASE_NAME, S.TABLE_NAME FROM DB_COMPARE S WHERE
S.DATABASE_NAME = @SOURCEDBNAME AND S.ISMISSING = 0) S
LEFT OUTER JOIN (
SELECT GROUP_CONCAT( ' CHANGE COLUMN `', COLUMN_NAME, '` ', '`', COLUMN_NAME, '` ', COLUMN_TYPE
,CASE WHEN COLLATION_NAME IS NOT NULL THEN CONCAT(' COLLATE ', COLLATION_NAME , ' ') ELSE ' '
END
,CASE WHEN GENERATION_EXPRESSION IS NULL OR LENGTH(TRIM(GENERATION_EXPRESSION)) = 0 THEN
CONCAT( CASE WHEN IS_NULLABLE = 'YES' THEN CONCAT(' NULL', ' DEFAULT ',
COALESCE(COLUMN_DEFAULT, 'NULL')) ELSE CONCAT(' NOT NULL', COALESCE(CONCAT(' DEFAULT ', CASE
WHEN TRIM(COLUMN_DEFAULT) = '' THEN "''" ELSE CASE WHEN SUBSTRING(TRIM(COLUMN_DEFAULT),1,1) =
'(' THEN COLUMN_DEFAULT ELSE CONCAT("'",COLUMN_DEFAULT,"'") END END), '') )END, ' ',
UPPER(LTRIM(COALESCE(REPLACE(EXTRA, 'DEFAULT_GENERATED', ''), ''))) )
ELSE
CONCAT(' GENERATED ALWAYS AS (', GENERATION_EXPRESSION, ') ', CASE EXTRA WHEN 'STORED
GENERATED' THEN ' STORED ' WHEN 'VIRTUAL GENERATED' THEN ' VIRTUAL ' ELSE '' END)
END
ORDER BY C.ORDINAL_POSITION, '
' SEPARATOR ",") COL_DEF
,S.DATABASE_NAME
,S.TABLE_NAME
FROM DB_COMPARE S
LEFT JOIN `tables_backup`.INFORMATION_SCHEMA_COLUMNS C ON S.DATABASE_NAME = C.TABLE_SCHEMA
AND S.TABLE_NAME = C.TABLE_NAME AND S.OBJECT_NAME = C.COLUMN_NAME
WHERE S.OBJECT_TYPE = 'Column' AND S.ISMISSING = 0 AND S.DATABASE_NAME =
@SOURCEDBNAME
GROUP BY S.DATABASE_NAME, S.TABLE_NAME
) C ON C.DATABASE_NAME = S.DATABASE_NAME AND C.TABLE_NAME = S.TABLE_NAME
LEFT OUTER JOIN
(
SELECT I.DATABASE_NAME TABLE_SCHEMA
,I.TABLE_NAME
,GROUP_CONCAT(' DROP ', CASE CONSTRAINT_TYPE WHEN 'PRIMARY KEY' THEN 'PRIMARY
KEY' WHEN 'UNIQUE' THEN 'CONSTRAINT ' ELSE ' KEY ' END, OBJECT_NAME, '`, ',
' ADD ', CASE CONSTRAINT_TYPE WHEN 'PRIMARY KEY' THEN 'PRIMARY' WHEN 'UNIQUE'
THEN 'UNIQUE' ELSE '' END, CASE WHEN INDEX_TYPE = 'BTREE' THEN ' KEY' ELSE CONCAT(' ', INDEX_TYPE, '
KEY ') END, '`', OBJECT_NAME, '` (', INDEX_COLS, ' )' SEPARATOR "," ) INDEX_DEF
FROM DB_COMPARE I
LEFT OUTER JOIN `tables_backup`.INFORMATION_SCHEMA_TABLE_CONSTRAINTS TC ON
TC.TABLE_SCHEMA = I.DATABASE_NAME AND TC.TABLE_NAME = I.TABLE_NAME AND
TC.CONSTRAINT_NAME = I.OBJECT_NAME AND CONSTRAINT_TYPE NOT IN ('CHECK','FOREIGN KEY')
WHERE I.OBJECT_TYPE = 'Index' AND I.ISMISSING = 0 AND I.DATABASE_NAME = @SOURCEDBNAME
GROUP BY I.DATABASE_NAME, I.TABLE_NAME
)I ON I.TABLE_SCHEMA = S.DATABASE_NAME AND I.TABLE_NAME = S.TABLE_NAME
LEFT OUTER JOIN
(
SELECT TABLE_SCHEMA
,TABLE_NAME
,GROUP_CONCAT(CHECK_DEF SEPARATOR ",") CHECK_DEF
FROM (
SELECT TC.TABLE_SCHEMA
,TC.TABLE_NAME
,GROUP_CONCAT(' DROP CONSTRAINT `', TC.CONSTRAINT_NAME, '`, ',
' ADD CONSTRAINT `', TC.CONSTRAINT_NAME, '` CHECK (', CHK.CHECK_CLAUSE, ')'
SEPARATOR "," ) CHECK_DEF
FROM DB_COMPARE I
INNER JOIN `tables_backup`.INFORMATION_SCHEMA_TABLE_CONSTRAINTS TC ON TC.TABLE_SCHEMA =
I.DATABASE_NAME AND TC.TABLE_NAME = I.TABLE_NAME AND CONSTRAINT_TYPE = 'CHECK'
INNER JOIN `tables_backup`.INFORMATION_SCHEMA_CHECK_CONSTRAINTS CHK ON TC.TABLE_SCHEMA =
CHK.CONSTRAINT_SCHEMA AND TC.CONSTRAINT_NAME = CHK.CONSTRAINT_NAME
WHERE OBJECT_TYPE = 'CHECK' AND I.DATABASE_NAME = @SOURCEDBNAME AND I.ISMISSING = 0
GROUP BY TC.TABLE_SCHEMA, TC.TABLE_NAME
)CHK
GROUP BY TABLE_SCHEMA, TABLE_NAME
)CHK ON CHK.TABLE_SCHEMA = S.DATABASE_NAME AND CHK.TABLE_NAME = S.TABLE_NAME

LEFT OUTER JOIN

(
SELECT TABLE_SCHEMA
,TABLE_NAME
,GROUP_CONCAT(FKEY_DEF SEPARATOR "," ) FKEY_DEF
FROM (
SELECT TC.TABLE_SCHEMA
,TC.TABLE_NAME
,CONCAT(' DROP CONSTRAINT `', FKEY.CONSTRAINT_NAME, '`, ',
' ADD CONSTRAINT `', FKEY.CONSTRAINT_NAME, '` FOREIGN KEY (', GROUP_CONCAT( '`',
FKEY.COLUMN_NAME , '`' ORDER BY FKEY.ORDINAL_POSITION SEPARATOR ","), ') REFERENCES ', '`',
FKEY.REFERENCED_TABLE_NAME, '`(', GROUP_CONCAT( '`', FKEY.REFERENCED_COLUMN_NAME , '`' ORDER
BY FKEY.ORDINAL_POSITION SEPARATOR ",") , ')'
, CASE WHEN MAX(RC.UPDATE_RULE) = 'NO ACTION' THEN '' ELSE COALESCE(CONCAT(' ON UPDATE ',
MAX(RC.UPDATE_RULE),'')) END
, CASE WHEN MAX(RC.DELETE_RULE) = 'NO ACTION' THEN '' ELSE
COALESCE(CONCAT(' ON DELETE ', MAX(RC.DELETE_RULE),'')) END ) FKEY_DEF
FROM DB_COMPARE I
INNER JOIN `tables_backup`.INFORMATION_SCHEMA_TABLE_CONSTRAINTS TC ON TC.TABLE_SCHEMA =
I.DATABASE_NAME AND TC.TABLE_NAME = I.TABLE_NAME AND CONSTRAINT_TYPE = 'FOREIGN KEY'
INNER JOIN `tables_backup`.INFORMATION_SCHEMA_KEY_COLUMN_USAGE FKEY ON TC.TABLE_SCHEMA =
FKEY.CONSTRAINT_SCHEMA AND TC.CONSTRAINT_NAME = FKEY.CONSTRAINT_NAME
LEFT OUTER JOIN `tables_backup`.INFORMATION_SCHEMA_REFERENTIAL_CONSTRAINTS RC ON
RC.CONSTRAINT_SCHEMA = TC.TABLE_SCHEMA AND RC.CONSTRAINT_NAME = TC.CONSTRAINT_NAME
WHERE OBJECT_TYPE = 'FOREIGN KEY' AND I.DATABASE_NAME = @SOURCEDBNAME AND I.ISMISSING = 0
GROUP BY TC.TABLE_SCHEMA, TC.TABLE_NAME, FKEY.CONSTRAINT_NAME,
FKEY.REFERENCED_TABLE_NAME
) FKEY
GROUP BY TABLE_SCHEMA, TABLE_NAME
)FKEY ON FKEY.TABLE_SCHEMA = S.DATABASE_NAME AND FKEY.TABLE_NAME = S.TABLE_NAME

GROUP BY S.DATABASE_NAME, S.TABLE_NAME

UNION ALL

-- Drop the index, connstraints and columnns which are existing onny in destination
SELECT

CONCAT(' ALTER TABLE `', @DESTINATIONDBNAME , '`.`',S.TABLE_NAME, '` ',

SUBSTRING(CONCAT(COALESCE(CONCAT(",",MAX(C.COL_DEF)),''),
COALESCE(CONCAT(",",MAX(I.INDEX_DEF)),''),COALESCE(CONCAT(",",MAX(CHK.CHECK_DEF)), '')),2) ,';')
TABLE_DEFINITION
FROM (
SELECT DISTINCT S.DATABASE_NAME, S.TABLE_NAME
FROM DB_COMPARE S
WHERE S.DATABASE_NAME = @DESTINATIONDBNAME AND S.ISMISSING = 1 AND OBJECT_TYPE <>
'Table'
AND NOT EXISTS ( SELECT 1 FROM DB_COMPARE D WHERE S.DATABASE_NAME = D.DATABASE_NAME AND
S.TABLE_NAME = D.TABLE_NAME AND D.OBJECT_TYPE = 'Table')
)S
LEFT OUTER JOIN (
SELECT GROUP_CONCAT( 'DROP COLUMN `', OBJECT_NAME, '`' SEPARATOR ",") COL_DEF
,S.DATABASE_NAME
,S.TABLE_NAME
FROM DB_COMPARE S
WHERE S.OBJECT_TYPE = 'Column' AND S.ISMISSING = 1 AND S.DATABASE_NAME =
@DESTINATIONDBNAME
GROUP BY S.DATABASE_NAME, S.TABLE_NAME
) C ON C.DATABASE_NAME = S.DATABASE_NAME AND C.TABLE_NAME = S.TABLE_NAME
LEFT OUTER JOIN
(
SELECT I.DATABASE_NAME TABLE_SCHEMA
,I.TABLE_NAME
,GROUP_CONCAT('DROP ', CASE CONSTRAINT_TYPE WHEN 'PRIMARY KEY' THEN 'PRIMARY
KEY ' WHEN 'UNIQUE' THEN 'CONSTRAINT ' ELSE ' KEY ' END, CASE CONSTRAINT_TYPE WHEN 'PRIMARY
KEY' THEN '' ELSE CONCAT('`',OBJECT_NAME, '`' ) END SEPARATOR "," ) INDEX_DEF
FROM DB_COMPARE I
LEFT OUTER JOIN `tables_backup`.INFORMATION_SCHEMA_TABLE_CONSTRAINTS TC ON
TC.TABLE_SCHEMA = I.DATABASE_NAME AND TC.TABLE_NAME = I.TABLE_NAME AND
TC.CONSTRAINT_NAME = I.OBJECT_NAME AND CONSTRAINT_TYPE NOT IN ('CHECK','FOREIGN KEY')
WHERE I.OBJECT_TYPE = 'Index' AND I.ISMISSING = 1 AND I.DATABASE_NAME =
@DESTINATIONDBNAME
GROUP BY I.DATABASE_NAME, I.TABLE_NAME
)I ON I.TABLE_SCHEMA = S.DATABASE_NAME AND I.TABLE_NAME = S.TABLE_NAME
LEFT OUTER JOIN
(
SELECT TABLE_SCHEMA
,TABLE_NAME
,GROUP_CONCAT(CHECK_DEF SEPARATOR ",") CHECK_DEF
 FROM (
SELECT TC.TABLE_SCHEMA
,TC.TABLE_NAME
,GROUP_CONCAT('DROP CONSTRAINT `', TC.CONSTRAINT_NAME, '`, ' SEPARATOR "," ) CHECK_DEF
FROM DB_COMPARE I
INNER JOIN `tables_backup`.INFORMATION_SCHEMA_TABLE_CONSTRAINTS TC ON TC.TABLE_SCHEMA =
I.DATABASE_NAME AND TC.TABLE_NAME = I.TABLE_NAME AND CONSTRAINT_TYPE IN ('CHECK', 'FOREIGN
KEY')
WHERE OBJECT_TYPE = 'CHECK' AND I.DATABASE_NAME = @DESTINATIONDBNAME AND I.ISMISSING = 1
GROUP BY TC.TABLE_SCHEMA, TC.TABLE_NAME
)CHK
GROUP BY TABLE_SCHEMA, TABLE_NAME

)CHK ON CHK.TABLE_SCHEMA = S.DATABASE_NAME AND CHK.TABLE_NAME = S.TABLE_NAME

GROUP BY S.DATABASE_NAME, S.TABLE_NAME

;

END //

DELIMITER ;

DROP PROCEDURE IF EXISTS SP_DBSCHEMACOMPARE_COPY_SYSTEM_DATA;

DELIMITER //
CREATE PROCEDURE SP_DBSCHEMACOMPARE_COPY_SYSTEM_DATA (SOURCEDBNAME VARCHAR(64))
BEGIN
SET @SOURCEDBNAME = SOURCEDBNAME COLLATE utf8_tolower_ci;

IF EXISTS ( SELECT 1 FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME =

'information_schema_tables' LIMIT 1) THEN
INSERT INTO `tables_backup`.`information_schema_tables` SELECT * FROM information_schema_tables WHERE
TABLE_SCHEMA = @SOURCEDBNAME;
DELETE FROM `tables_backup`.`information_schema_tables` WHERE TABLE_SCHEMA = @SOURCEDBNAME;

ELSE
CREATE TABLE `tables_backup`.`information_schema_tables` AS SELECT * FROM INFORMATION_SCHEMA.TABLES
WHERE TABLE_SCHEMA = @SOURCEDBNAME;
ALTER TABLE `tables_backup`.`information_schema_tables` ADD KEY `ix_tables` (TABLE_SCHEMA,
TABLE_NAME);
END IF;

IF EXISTS ( SELECT 1 FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME =

'information_schema_columns' LIMIT 1) THEN
DELETE FROM `tables_backup`.`information_schema_columns` WHERE TABLE_SCHEMA = @SOURCEDBNAME;
INSERT INTO `tables_backup`.`information_schema_columns` SELECT * FROM INFORMATION_SCHEMA.COLUMNS
WHERE TABLE_SCHEMA = @SOURCEDBNAME;
ELSE
CREATE TABLE `tables_backup`.`information_schema_columns` AS SELECT * FROM
INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = @SOURCEDBNAME;
ALTER TABLE `tables_backup`.`information_schema_columns` ADD KEY `ix_columns` (TABLE_SCHEMA,
TABLE_NAME, COLUMN_NAME);
END IF;

IF EXISTS ( SELECT 1 FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME =

'information_schema_statistics' LIMIT 1) THEN
DELETE FROM `tables_backup`.`information_schema_statistics` WHERE TABLE_SCHEMA = @SOURCEDBNAME;
INSERT INTO `tables_backup`.`information_schema_statistics` SELECT * FROM INFORMATION_SCHEMA.STATISTICS
WHERE TABLE_SCHEMA = @SOURCEDBNAME;
ELSE
CREATE TABLE `tables_backup`.`information_schema_statistics` AS SELECT * FROM
INFORMATION_SCHEMA.STATISTICS WHERE TABLE_SCHEMA = @SOURCEDBNAME;
ALTER TABLE `tables_backup`.`information_schema_statistics` ADD KEY `ix_statistics` (TABLE_SCHEMA,
TABLE_NAME, INDEX_NAME);
END IF;

IF EXISTS ( SELECT 1 FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME =

'information_schema_table_constraints' LIMIT 1) THEN
DELETE FROM `tables_backup`.`information_schema_table_constraints` WHERE TABLE_SCHEMA =
@SOURCEDBNAME;
INSERT INTO `tables_backup`.`information_schema_table_constraints` SELECT * FROM
INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE TABLE_SCHEMA = @SOURCEDBNAME;
ELSE
CREATE TABLE `tables_backup`.`information_schema_table_constraints` AS SELECT * FROM
INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE TABLE_SCHEMA = @SOURCEDBNAME;
ALTER TABLE `tables_backup`.`information_schema_table_constraints` ADD KEY `ix_constraints` (TABLE_SCHEMA,
TABLE_NAME, CONSTRAINT_NAME);
END IF;

IF EXISTS ( SELECT 1 FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME =

'information_schema_check_constraints' LIMIT 1) THEN
DELETE FROM `tables_backup`.`information_schema_check_constraints` WHERE CONSTRAINT_SCHEMA =
@SOURCEDBNAME;
INSERT INTO `tables_backup`.`information_schema_check_constraints` SELECT * FROM
INFORMATION_SCHEMA.CHECK_CONSTRAINTS WHERE CONSTRAINT_SCHEMA = @SOURCEDBNAME;
ELSE
CREATE TABLE `tables_backup`.`information_schema_check_constraints` AS SELECT * FROM
INFORMATION_SCHEMA.CHECK_CONSTRAINTS WHERE CONSTRAINT_SCHEMA = @SOURCEDBNAME;
ALTER TABLE `tables_backup`.`information_schema_check_constraints` ADD KEY `ix_check_constraints`
(CONSTRAINT_SCHEMA, CONSTRAINT_NAME);
END IF;

IF EXISTS ( SELECT 1 FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME =

'information_schema_key_column_usage' LIMIT 1) THEN
DELETE FROM `tables_backup`.`information_schema_key_column_usage` WHERE TABLE_SCHEMA =
@SOURCEDBNAME;
INSERT INTO `tables_backup`.`information_schema_key_column_usage` SELECT * FROM
INFORMATION_SCHEMA.KEY_COLUMN_USAGE WHERE TABLE_SCHEMA = @SOURCEDBNAME;
ELSE
CREATE TABLE `tables_backup`.`information_schema_key_column_usage` AS SELECT * FROM
INFORMATION_SCHEMA.KEY_COLUMN_USAGE WHERE TABLE_SCHEMA = @SOURCEDBNAME;
ALTER TABLE `tables_backup`.`information_schema_key_column_usage` ADD KEY `ix_key_column_usage`
(TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME);
END IF;

IF EXISTS ( SELECT 1 FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME =

'information_schema_referential_constraints' LIMIT 1) THEN
DELETE FROM `tables_backup`.`information_schema_referential_constraints` WHERE CONSTRAINT_SCHEMA =
@SOURCEDBNAME;
INSERT INTO `tables_backup`.`information_schema_referential_constraints` SELECT * FROM
INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS WHERE CONSTRAINT_SCHEMA = @SOURCEDBNAME;
ELSE
CREATE TABLE `tables_backup`.`information_schema_referential_constraints` AS SELECT * FROM
INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS WHERE CONSTRAINT_SCHEMA = @SOURCEDBNAME;
ALTER TABLE `tables_backup`.`information_schema_referential_constraints` ADD KEY `ix_fkey_constraints`
(CONSTRAINT_SCHEMA, CONSTRAINT_NAME);

END IF;

END //

DELIMITER ;
DROP PROCEDURE IF EXISTS SP_DBSCHEMACOMPARE_INSERT_SYSTEM_DATA;
DELIMITER //
CREATE PROCEDURE SP_DBSCHEMACOMPARE_INSERT_SYSTEM_DATA (SOURCEDBNAME VARCHAR(64))
BEGIN

DELETE FROM `tables_backup`.`information_schema_tables` WHERE TABLE_SCHEMA collate utf8_unicode_ci =

SOURCEDBNAME;
INSERT INTO `tables_backup`.`information_schema_tables` SELECT * FROM INFORMATION_SCHEMA.TABLES
WHERE TABLE_SCHEMA collate utf8_unicode_ci = SOURCEDBNAME;

DELETE FROM `tables_backup`.`information_schema_columns` WHERE TABLE_SCHEMA = SOURCEDBNAME;

INSERT INTO `tables_backup`.`information_schema_columns` SELECT * FROM INFORMATION_SCHEMA.COLUMNS
WHERE TABLE_SCHEMA = SOURCEDBNAME;

DELETE FROM `tables_backup`.`information_schema_statistics` WHERE TABLE_SCHEMA = SOURCEDBNAME;

INSERT INTO `tables_backup`.`information_schema_statistics` SELECT * FROM INFORMATION_SCHEMA.STATISTICS
WHERE TABLE_SCHEMA = SOURCEDBNAME;

DELETE FROM `tables_backup`.`information_schema_constraints` WHERE TABLE_SCHEMA = SOURCEDBNAME;

INSERT INTO `tables_backup`.`information_schema_constraints` SELECT * FROM
INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE TABLE_SCHEMA = SOURCEDBNAME;

DELETE FROM `tables_backup`.`information_schema_check_constraints` WHERE CONSTRAINT_SCHEMA =

SOURCEDBNAME;
INSERT INTO `tables_backup`.`information_schema_check_constraints` SELECT * FROM
INFORMATION_SCHEMA.CHECK_CONSTRAINTS WHERE CONSTRAINT_SCHEMA = SOURCEDBNAME;

DELETE FROM `tables_backup`.`information_schema_key_column_usage` WHERE TABLE_SCHEMA =

SOURCEDBNAME;
INSERT INTO `tables_backup`.`information_schema_key_column_usage` SELECT * FROM
INFORMATION_SCHEMA.KEY_COLUMN_USAGE WHERE TABLE_SCHEMA = SOURCEDBNAME;

DELETE FROM `tables_backup`.`information_schema_referential_constraints` WHERE CONSTRAINT_SCHEMA =

SOURCEDBNAME;
INSERT INTO `tables_backup`.`information_schema_referential_constraints` SELECT * FROM
INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS WHERE CONSTRAINT_SCHEMA = SOURCEDBNAME;

END //

DELIMITER ;

PYTHON SOURCE CODE: -

CREATE CONNECTION .PY

import string
import mysql.connector
from mysql.connector import errorcode
class createConnection:

hostName = ""
DBName = ""
portNumber = ""
userName = ""
password = ""

def __init__(self, hostName, DBName, portNumber, userName, password=""):

self.hostName = hostName
self.DBName = DBName
if len(hostName.strip("")) == 0:
self.portNumber = 3306
else:
self.portNumber = portNumber

self.userName = userName
self.password = password

def checkHostName(self, hostName):

if len(hostName.strip("")) == 0:
print(f"The entered HostName is empty / Invalid")
exit()

def checkDBName(self, DBName):

if len(DBName.strip("")) == 0:
print(f"The entered DBName is empty / Invalid")
exit()

def checkUserName(self, userName):

if len(userName.strip("")) == 0:
print(f"The entered userName is empty / Invalid")
exit()
def createDBConnection(self):
try:
self.checkHostName(self.hostName)
self.checkDBName(self.DBName)
self.checkUserName(self.userName)

DBConnection = mysql.connector.connect( user=self.userName,

password=self.password,
host=self.hostName,
database=self.DBName,
port=self.portNumber
)

except mysql.connector.Error as err:

if err.errno == errorcode.ER_ACCESS_DENIED_ERROR:
print("Authentication related issue raised while making a DB Connection")
elif err.errno == errorcode.ER_BAD_DB_ERROR:
print("Database does not exist")
else:
print("Error while connecting to MySQL", err)
finally:
print("connection created successfully")
return DBConnection

DB SCHEMACOMPARE.PY
import createConnection
import getpass
import os

class DBSchemaCompare:

ConfigFileDict = dict()

def __init__(self, configValues_dict):

self.ConfigFileDict = configValues_dict

'''
def __init__(self, configFilePath):
if len(configFilePath.strip("")) == 0:
print("DB Schema comparison failed as config file does not exist")
exit()
else:
self.configFilePath = configFilePath

def readConfigFile(self):
with open(self.configFilePath) as configFileHandler:
for lines in configFileHandler:
if len(lines.strip().split(":")) == 2:
if len(lines.strip().split(":")[0]) > 0:
self.configValues[lines.strip().split(":")[0]] = lines.strip().split(":")[1]
return self.configValues
'''
def DBSchemaCompare(self):

ConfigFileDict = self.ConfigFileDict

if not ( any(keys in ConfigFileDict for keys in ("source_DBName", "destination_DBName", "sourceUserName",

"destinationUserName"))):
print('One of the mandatory data is missing in the config file')
exit()

if "IsDBSchemaCompare" in ConfigFileDict:
if int(ConfigFileDict.get("IsDBSchemaCompare")) == 1:

# if not (all (keys in ConfigFileDict for keys in ("source_DBName", "destination_DBName", "sourceUserName",

"destinationUserName"))):
# print('One of the mandatory data is missing in the config file')
# exit()

try:

if "source_HostName" in ConfigFileDict:
sourceHostPassword = getpass.getpass(f'Enter the password for the host {ConfigFileDict["source_HostName"]}:
')

if "destination_HostName" in ConfigFileDict:
destHostPassword = getpass.getpass(f'Enter the password for the host
{ConfigFileDict["destination_HostName"]}: ')

except Exception as error:

print('Issues encountered while getting password. The error is:', error)
 # Check the tables_backup database if not create

SourceDBConnection = createConnection.createConnection(ConfigFileDict["source_HostName"],
ConfigFileDict["source_DBName"],
ConfigFileDict["sourcePortNumber"],
ConfigFileDict["sourceUserName"],
sourceHostPassword)
SourceDBConnectionInstance = SourceDBConnection.createDBConnection()
if SourceDBConnectionInstance.is_connected():
cursor = SourceDBConnectionInstance.cursor()
cursor.execute("CREATE DATABASE IF NOT EXISTS tables_backup CHARACTER SET utf8 COLLATE
utf8_tolower_ci; ")
cursor.close()
SourceDBConnectionInstance.close()

DestinationDBConnection = createConnection.createConnection(ConfigFileDict["destination_HostName"],
ConfigFileDict["destination_DBName"],
ConfigFileDict["destinationPortNumber"],
ConfigFileDict["destinationUserName"],
destHostPassword)
DestinationDBConnectionInstance = DestinationDBConnection.createDBConnection()
if DestinationDBConnectionInstance.is_connected():
cursor = DestinationDBConnectionInstance.cursor()
cursor.execute("CREATE DATABASE IF NOT EXISTS tables_backup CHARACTER SET utf8 COLLATE
utf8_tolower_ci; ")
cursor.close()
DestinationDBConnectionInstance.close()

if ConfigFileDict["source_HostName"] == ConfigFileDict["destination_HostName"]:
os_command = f'mysql -h{ConfigFileDict["source_HostName"]} -u{ConfigFileDict["sourceUserName"]} -
p{sourceHostPassword} tables_backup < ./Schema_Compare.sql'
command_output = os.system(os_command)

os_command = f'mysql --raw --force --quick --skip-line-numbers --skip-column-names --silent -

h{ConfigFileDict["source_HostName"]} -u{ConfigFileDict["sourceUserName"]} -p{sourceHostPassword} tables_backup -e"
SET SESSION group_concat_max_len = 10000000; call
SP_DBSCHEMACOMPARE_WITHIN_CLUSTER(\'{ConfigFileDict["source_DBName"]}\', \'{ConfigFileDict["destination_D
BName"]}\'); " > ./Schema_Compare_Result.sql'
command_output = os.system(os_command)

else:
os_command = f'cat ./Schema_Compare.sql | mysql -h{ConfigFileDict["source_HostName"]} tables_backup -
u{ConfigFileDict["sourceUserName"]} -p{sourceHostPassword} '
command_output = os.system(os_command)

DestinationDBConnection = createConnection.createConnection(
ConfigFileDict["destination_HostName"],
"tables_backup",
ConfigFileDict["destinationPortNumber"],
ConfigFileDict["destinationUserName"],
destHostPassword)
DestinationDBConnectionInstance = DestinationDBConnection.createDBConnection()

if DestinationDBConnectionInstance.is_connected():
cursor = DestinationDBConnectionInstance.cursor()
strSQL = "call tables_backup.SP_DBSCHEMACOMPARE_COPY_SYSTEM_DATA('" +
ConfigFileDict["destination_DBName"] + "'); "
 cursor.execute(strSQL)
DestinationDBConnectionInstance.commit()
cursor.close()
DestinationDBConnectionInstance.close()

SourceDBConnection = createConnection.createConnection(
ConfigFileDict["source_HostName"],
"tables_backup",
ConfigFileDict["sourcePortNumber"],
ConfigFileDict["sourceUserName"],
sourceHostPassword)
SourceDBConnectionInstance = SourceDBConnection.createDBConnection()

if SourceDBConnectionInstance.is_connected():
cursor_source = SourceDBConnectionInstance.cursor()
strSQL = "call tables_backup.SP_DBSCHEMACOMPARE_COPY_SYSTEM_DATA('" +
ConfigFileDict["source_DBName"] + "'); "
cursor_source.execute(strSQL)
SourceDBConnectionInstance.commit()
cursor_source.close()
SourceDBConnectionInstance.close()

print("check now")

os_command = f'mysqldump --skip-triggers --no-create-info --skip-add-drop-table --no-create-db -

h{ConfigFileDict["destination_HostName"]} --databases tables_backup -u{ConfigFileDict["destinationUserName"]} -
p{destHostPassword} --tables information_schema_columns information_schema_table_constraints
information_schema_key_column_usage information_schema_statistics information_schema_tables --where
"TABLE_SCHEMA = \'{ConfigFileDict["destination_DBName"]}\' " > ./Schema_Compare_Result_CrossRegion.sql'
#os_command = f'mysqldump --skip-triggers --no-create-info --skip-add-drop-table --no-create-db -
h{ConfigFileDict["destination_HostName"]} --databases tables_backup -u{ConfigFileDict["destinationUserName"]} -
p{destHostPassword} --tables information_schema_columns information_schema_table_constraints
information_schema_key_column_usage information_schema_referential_constraints information_schema_statistics
information_schema_tables > ./Schema_Compare_Result_CrossRegion.sql'
print(command_output)
command_output = os.system(os_command)

os_command = f'mysqldump --skip-triggers --no-create-info --skip-add-drop-table --no-create-db -

h{ConfigFileDict["destination_HostName"]} --databases tables_backup -u{ConfigFileDict["destinationUserName"]} -
p{destHostPassword} --tables information_schema_check_constraints information_schema_referential_constraints --where
"CONSTRAINT_SCHEMA = \'{ConfigFileDict["destination_DBName"]}\' " >> ./Schema_Compare_Result_CrossRegion.sql'
command_output = os.system(os_command)

if not os.path.isfile("Schema_Compare_Result_CrossRegion.sql") :
print("MySQL dump file does not exist")
exit()

os_command = f'cat ./Schema_Compare_Result_CrossRegion.sql | mysql -h{ConfigFileDict["source_HostName"]}

tables_backup -u{ConfigFileDict["sourceUserName"]} -p{sourceHostPassword} '
command_output = os.system(os_command)

os_command = f'mysql --raw --force --quick --skip-line-numbers --skip-column-names --silent -

h{ConfigFileDict["source_HostName"]} -u{ConfigFileDict["sourceUserName"]} -p{sourceHostPassword} tables_backup -e"
SET SESSION group_concat_max_len = 10000000; call
SP_DBSCHEMACOMPARE_WITHIN_CLUSTER(\'{ConfigFileDict["source_DBName"]}\', \'{ConfigFileDict["destination_D
BName"]}\'); " > ./Schema_Compare_Result.sql'
 command_output = os.system(os_command)

MAIN.PY

import createConnection
import DBSchemaCompare
import os
import csv

configFilePath = f"./DBConfig.cnf"
ConfigFileDict = dict()
sourceHostPassword = ""
destHostPassword = ""

# Check config File exists

if not os.path.isfile(configFilePath):
print("Config file does not exist")
exit()

# read the config file

def readConfigFile():
with open(configFilePath) as configFileHandler:
for lines in configFileHandler:
if len(lines.strip().split(":")) == 2:
if len(lines.strip().split(":")[0]) > 0:
ConfigFileDict[lines.strip().split(":")[0]] = lines.strip().split(":")[1]
return ConfigFileDict

# call DB Schema compare

ConfigFileDict = readConfigFile()
DBSchemaCompare = DBSchemaCompare.DBSchemaCompare(ConfigFileDict)
DBSchemaCompare.DBSchemaCompare()

# call DB Data compare

# find mismatched records in Timeline

# Extract records from Timeline to restore on SOR

# DBConnectionInstance.createDBConnection()

# ConfigFileDict = dict.fromkeys(ConfigFileDetail[0], ConfigFileDetail[1] )

SCREENSHOT OF EXECUTION :-
 SYSTEM REQUIREMENTS:-

HARDWARE:-

 Processor :- Pentium III and above

  Printer- to print the required documents of the project.
 Minimum memory – 2GB

SOFTWARE:-

 Windows 7 or higher
 My-SQL server 5.5 or higher (as backend)
 Python idle 3.8 or higher or spyder (as frontend).
 Microsoft Word 2010 or higher for documentation.

BIBILIOGRAPHY

 Computer Science with python – by Sumita Arora

 www.python.org/download
 www.py2exe.org
 www.mysql.org