Simplify

Author: bakwc

mysql_ch_replicator/converter.py

@@ -748,18 +748,6 @@ def parse_create_table_query(self, mysql_query) -> tuple[TableStructure, TableSt
                 new_table_name = match.group(1).strip('`"')
                 source_table_name = match.group(2).strip('`"')
 
-                # Create a basic fallback structure in case we can't get the source
-                basic_structure = TableStructure()
-                basic_structure.table_name = new_table_name
-                basic_structure.primary_keys = ['id']
-                basic_structure.fields.append(TableField(
-                    name='id',
-                    field_type='int',
-                    parameters='NOT NULL AUTO_INCREMENT',
-                    additional_data=None,
-                ))
-                basic_structure.preprocess()
-                
                 # Try to get the actual structure from the existing table structures first
                 if (hasattr(self, 'db_replicator') and 
                     self.db_replicator is not None and 
@@ -782,13 +770,12 @@ def parse_create_table_query(self, mysql_query) -> tuple[TableStructure, TableSt
                         return new_mysql_structure, new_ch_structure
 
                 # If we couldn't get it from state, try with MySQL API
-                try:
-                    # If we have a db_replicator with a valid mysql_api
-                    if (hasattr(self, 'db_replicator') and 
-                        self.db_replicator is not None and 
-                        hasattr(self.db_replicator, 'mysql_api') and 
-                        self.db_replicator.mysql_api is not None):
-                        
+                if (hasattr(self, 'db_replicator') and 
+                    self.db_replicator is not None and 
+                    hasattr(self.db_replicator, 'mysql_api') and 
+                    self.db_replicator.mysql_api is not None):
+                    
+                    try:
                         # Get the CREATE statement for the source table
                         source_create_statement = self.db_replicator.mysql_api.get_table_create_statement(source_table_name)
 
@@ -803,14 +790,15 @@ def parse_create_table_query(self, mysql_query) -> tuple[TableStructure, TableSt
                         ch_table_structure = self.convert_table_structure(mysql_table_structure)
 
                         return mysql_table_structure, ch_table_structure
-                except Exception as e:
-                    print(f"Warning: Could not get source table structure for LIKE statement: {str(e)}")
+                    except Exception as e:
+                        error_msg = f"Could not get source table structure for LIKE statement: {str(e)}"
+                        print(f"Error: {error_msg}")
+                        raise Exception(error_msg, mysql_query)
 
-                # If we got here, use the fallback structure
-                ch_basic_structure = self.convert_table_structure(basic_structure)
-                return basic_structure, ch_basic_structure
+                # If we got here, we couldn't determine the structure
+                raise Exception(f"Could not determine structure for source table '{source_table_name}' in LIKE statement", mysql_query)
 
-        # Regular parsing for non-LIKE statements or if LIKE handling failed
+        # Regular parsing for non-LIKE statements
         mysql_table_structure = self.parse_mysql_table_structure(mysql_query)
         ch_table_structure = self.convert_table_structure(mysql_table_structure)
         return mysql_table_structure, ch_table_structure
@@ -861,44 +849,31 @@ def parse_mysql_table_structure(self, create_statement, required_table_name=None
                 raise Exception('wrong create statement', create_statement)
 
             source_table_name = strip_sql_name(tokens[4].get_real_name())
+            target_table_name = strip_sql_name(tokens[2].get_real_name())
 
-            # Create a basic structure with the target table name
-            structure.table_name = strip_sql_name(tokens[2].get_real_name())
-            
-            # During initial parsing in the test, we'll create a skeleton structure
-            # Later during replication, the actual structure will be used
-            structure.primary_keys = ['id']  # Assuming 'id' is the primary key
-            structure.fields.append(TableField(
-                name='id',
-                field_type='int',
-                parameters='NOT NULL AUTO_INCREMENT',
-                additional_data=None,
-            ))
-            structure.preprocess()
-            
-            # Try to get the actual structure if possible
-            try:
-                # If we have a db_replicator with a valid mysql_api
-                if (hasattr(self, 'db_replicator') and 
+            # Try to get the actual structure - we need a valid MySQL API
+            if not (hasattr(self, 'db_replicator') and 
                     self.db_replicator is not None and 
                     hasattr(self.db_replicator, 'mysql_api') and 
                     self.db_replicator.mysql_api is not None):
-                    
-                    # Try to get the CREATE statement from the current database
-                    mysql_api = self.db_replicator.mysql_api
-                    source_create_statement = mysql_api.get_table_create_statement(source_table_name)
-                    
-                    # Parse the source table structure
-                    source_structure = self.parse_mysql_table_structure(source_create_statement)
-                    
-                    # Copy the structure but keep the new table name
-                    structure = copy.deepcopy(source_structure)
-                    structure.table_name = strip_sql_name(tokens[2].get_real_name())
+                raise Exception(f"Cannot parse LIKE statement - no MySQL API available to get source table structure", create_statement)
+                
+            try:
+                # Try to get the CREATE statement from the current database
+                mysql_api = self.db_replicator.mysql_api
+                source_create_statement = mysql_api.get_table_create_statement(source_table_name)
+                
+                # Parse the source table structure
+                source_structure = self.parse_mysql_table_structure(source_create_statement)
+                
+                # Copy the structure but keep the new table name
+                structure = copy.deepcopy(source_structure)
+                structure.table_name = target_table_name
+                return structure
             except Exception as e:
-                # Log the error but still return the basic structure
-                print(f"Warning: Could not get source table structure: {str(e)}")
-            
-            return structure
+                error_msg = f"Could not get source table structure: {str(e)}"
+                print(f"Error: {error_msg}")
+                raise Exception(error_msg, create_statement)
 
         if not isinstance(tokens[3], sqlparse.sql.Parenthesis):
             raise Exception('wrong create statement', create_statement)