manage on delete/on update for foreign keys, change the foreign key name

only if there are duplicates within the same schema
the4thdoctor · Feb 13, 2022 · 308affa · 308affa
1 parent 56ca548
commit 308affa
Show file tree

Hide file tree

Showing 2 changed files with 62 additions and 24 deletions.
diff --git a/pg_chameleon/lib/mysql_lib.py b/pg_chameleon/lib/mysql_lib.py
@@ -374,25 +374,51 @@ def get_foreign_keys_metadata(self):
         self.logger.info("retrieving foreign keys metadata for schemas %s" % schema_replica)
         sql_fkeys = """
             SELECT
-                table_name as table_name,
-                table_schema as table_schema,
-                constraint_name as constraint_name,
-                referenced_table_name as referenced_table_name,
-                referenced_table_schema as referenced_table_schema,
-                GROUP_CONCAT(concat('"',column_name,'"') ORDER BY POSITION_IN_UNIQUE_CONSTRAINT) as fk_cols,
-                GROUP_CONCAT(concat('"',REFERENCED_COLUMN_NAME,'"') ORDER BY POSITION_IN_UNIQUE_CONSTRAINT) as ref_columns
+                kc.table_name as table_name,
+                kc.table_schema as table_schema,
+                CASE WHEN (
+                                SELECT
+                                    count(1)
+                                FROM
+                                    information_schema.referential_constraints r
+                                WHERE
+                                        rc.constraint_name=r.constraint_name
+                                    AND  rc.constraint_schema=r.constraint_schema
+                            )>1
+                THEN
+                    concat(substring(kc.constraint_name,1,59),'_',SUBSTRING(md5(uuid()),1,4))
+                ELSE
+                    kc.constraint_name
+                END as constraint_name,
+                kc.referenced_table_name as referenced_table_name,
+                kc.referenced_table_schema as referenced_table_schema,
+                group_concat(concat('"',kc.column_name,'"') ORDER BY POSITION_IN_UNIQUE_CONSTRAINT) as fk_cols,
+                group_concat(concat('"',kc.referenced_column_name,'"') ORDER BY POSITION_IN_UNIQUE_CONSTRAINT) as ref_columns,
+                concat('ON DELETE ',rc.delete_rule) AS on_delete,
+                concat('ON UPDATE ',rc.update_rule) AS on_update
             FROM
-                information_schema.key_column_usage
+                information_schema.key_column_usage kc
+                INNER JOIN information_schema.referential_constraints rc
+                ON
+                        rc.table_name=kc.table_name
+                    AND rc.constraint_schema=kc.table_schema
+                    AND rc.constraint_name=kc.constraint_name
             WHERE
-                    table_schema in (%s)
-                AND referenced_table_name IS NOT NULL
-                AND referenced_table_schema in (%s)
+                    kc.table_schema in (%s)
+                AND kc.referenced_table_name IS NOT NULL
+                AND kc.referenced_table_schema in (%s)
             GROUP BY
-                table_name,
-                constraint_name,
-                referenced_table_name
+                kc.table_name,
+                kc.constraint_name,
+                kc.referenced_table_name,
+                kc.table_schema,
+                kc.referenced_table_schema,
+                rc.delete_rule,
+                rc.update_rule,
+                rc.constraint_name,
+                rc.constraint_schema
             ORDER BY
-                table_name
+                kc.table_name
             ;
 
         """ % (schema_replica, schema_replica)
@@ -729,14 +755,22 @@ def __create_indices(self, schema, table):
         self.connect_db_buffered()
         self.logger.debug("Creating indices on table %s.%s " % (schema, table))
         sql_index = """
-            
+
             SELECT
             CASE WHEN index_name='PRIMARY'
-            THEN 
+            THEN
                 index_name
-            WHEN (SELECT count(1) FROM information_schema.statistics s WHERE s.index_name=t.index_name)>1
+            WHEN (
+                    SELECT
+                        count(1)
+                    FROM
+                        information_schema.statistics s
+                    WHERE
+                             s.index_name=t.index_name
+                        AND  s.table_schema=t.table_schema
+                )>1
             THEN
-                concat(substring(index_name,1,length(index_name)-5),'_',SUBSTRING(md5(uuid()),1,4))
+                concat(substring(index_name,1,59),'_',SUBSTRING(md5(uuid()),1,4))
             ELSE
                 index_name
             END AS index_name,
@@ -754,7 +788,7 @@ def __create_indices(self, schema, table):
                 index_name
             ;
         """
-        
+
         self.cursor_buffered.execute(sql_index, (schema, table))
         index_data = self.cursor_buffered.fetchall()
         table_pkey = self.pg_engine.create_indices(loading_schema, table, index_data)
@@ -792,7 +826,7 @@ def __copy_tables(self):
                             master_status = self.copy_data(schema, table)
                         else:
                             master_status = self.get_master_coordinates()
-                        
+
                         table_pkey = self.__create_indices(schema, table)
                     self.pg_engine.store_table(destination_schema, table, table_pkey, master_status)
                     if self.keep_existing_schema:

diff --git a/pg_chameleon/lib/pg_lib.py b/pg_chameleon/lib/pg_lib.py
@@ -782,21 +782,25 @@ def create_foreign_keys(self):
         for foreign_key in self.fk_metadata:
             table_name = foreign_key["table_name"]
             table_schema = schema_mappings[foreign_key["table_schema"]]
-            fk_name = ("%s_%s") % (foreign_key["constraint_name"][0:20] ,  str(fk_counter))
+            fk_name = foreign_key["constraint_name"]
             fk_cols = foreign_key["fk_cols"]
             referenced_table_name = foreign_key["referenced_table_name"]
             referenced_table_schema = schema_mappings[foreign_key["referenced_table_schema"]]
             ref_columns = foreign_key["ref_columns"]
+            on_update = foreign_key["on_update"]
+            on_delete = foreign_key["on_delete"]
             fk_list.append({'fkey_name':fk_name, 'table_name':table_name, 'table_schema':table_schema})
-            sql_fkey = ("""ALTER TABLE "%s"."%s" ADD CONSTRAINT "%s" FOREIGN KEY (%s) REFERENCES "%s"."%s" (%s) NOT VALID;""" %
+            sql_fkey = ("""ALTER TABLE "%s"."%s" ADD CONSTRAINT "%s" FOREIGN KEY (%s) REFERENCES "%s"."%s" (%s) %s %s  NOT VALID;""" %
                     (
                         table_schema,
                         table_name,
                         fk_name,
                         fk_cols,
                         referenced_table_schema,
                         referenced_table_name,
-                        ref_columns
+                        ref_columns,
+                        on_update,
+                        on_delete
                     )
                 )
             fk_counter+=1