def execute(self, table: SymbolTable, tree): super().execute(table, tree) result_table_name = self.table_name result_field_name = self.field_name result_field_type = self.field_type.val result_field_length = self.field_length result = alterAddColumn(table.get_current_db().name, result_table_name, None) if result == 1: raise Error(0, 0, ErrorType.RUNTIME, '5800: system_error') elif result == 2: raise Error(0, 0, ErrorType.RUNTIME, '42P04: database_does_not_exists') elif result == 3: raise Error(0, 0, ErrorType.RUNTIME, '42P04: table_does_not_exists') else: total_fields = len(table.get_fields_from_table(result_table_name)) column_symbol = FieldSymbol(table.get_current_db().name, result_table_name, total_fields + 1, result_field_name, result_field_type, result_field_length, self.allows_null, False, None, None) table.add(column_symbol) return True
def execute(self, table: SymbolTable, tree): super().execute(table, tree) by_pass = False if isinstance(self.insert_list, Select): self.insert_list = self.insert_list.execute(table, tree)[1] by_pass = True # Table symbol so we can run checks and validations table_symbol = table.get(self.table_name, SymbolType.TABLE) all_fields_declared = table.get_fields_from_table(self.table_name) # Sorting list, so we know order to insert is correct all_fields_declared.sort(key=lambda x: x.field_index) # Mapping values to insert, to actual structure on data structure to_insert = [] if not by_pass: if self.column_list is not None: for field_symbol in all_fields_declared: # looking in column list if declared field appears or None match = next((col for col in self.column_list if col.val == field_symbol.name), None) # Run validations only if result is not None value_related_to_match = self.column_list.index(match) if match is not None: #to ENUM StmENUM = None try: StmENUM = table.get(field_symbol.field_type.upper(), SymbolType.TYPE) except: pass if StmENUM and self.insert_list[value_related_to_match].val not in StmENUM.value_list : raise Error(0, 0, ErrorType.SEMANTIC, f'Field {field_symbol.name} must be a take any of the follow: {str(StmENUM.value_list)}') # TODO ADD HERE TYPE VALIDATIONS PER FIELD, JUST ONE ADDED BY NOW TO GIVE EXAMPLE if field_symbol.field_type.upper() == 'INTEGER' and type(self.insert_list[value_related_to_match].val) != int: raise Error(0, 0, ErrorType.SEMANTIC, f'Field {field_symbol.name} must be an integer type') to_insert.append(self.insert_list[value_related_to_match].val) # TODO ADD HERE CHECK VALIDATION else: to_insert = list(map(lambda x: x.val, self.insert_list)) result = insert(table.get_current_db().name, self.table_name, to_insert) if result == 1: raise Error(0, 0, ErrorType.RUNTIME, '5800: system_error') elif result == 2: raise Error(0, 0, ErrorType.RUNTIME, '42P04: database_does_not_exists') elif result == 3: raise Error(0, 0, ErrorType.RUNTIME, '42P07: table_does_not_exists') elif result == 4: raise Error(0, 0, ErrorType.RUNTIME, '42P10: duplicated_primary_key') else: for insert_reg in self.insert_list: result = insert(table.get_current_db().name, self.table_name, insert_reg) if result == 1: raise Error(0, 0, ErrorType.RUNTIME, '5800: system_error') elif result == 2: raise Error(0, 0, ErrorType.RUNTIME, '42P04: database_does_not_exists') elif result == 3: raise Error(0, 0, ErrorType.RUNTIME, '42P07: table_does_not_exists') elif result == 4: raise Error(0, 0, ErrorType.RUNTIME, '42P10: duplicated_primary_key') return True
def execute(self, table: SymbolTable, tree): super().execute(table, tree) result_name = self.name.execute(table, tree) result_inherits_from = self.inherits_from.execute( table, tree) if self.inherits_from else None result_fields = [] if result_inherits_from: # get inheritance table, if doesn't exists throws semantic error, else append result result_fields.append( table.get_fields_from_table(result_inherits_from)) result = createTable('db_from_st', result_name, len(result_fields)) if result == 1: raise Error(0, 0, ErrorType.RUNTIME, '5800: system_error') return False elif result == 2: raise Error(0, 0, ErrorType.RUNTIME, '42P04: database_does_not_exists') return False elif result == 3: raise Error(0, 0, ErrorType.RUNTIME, '42P07: duplicate_table') return False else: table.add(TableSymbol(table.get_current_db().name, result_name)) result_fields = self.fields.execute( table, tree) # A list of TableField assumed for field in result_fields: field.table_name = result_name table.add(field) return
def execute(self, table: SymbolTable, tree): super().execute(table, tree) result_name = self.name.execute(table, tree) result_field_type = self.field_type.execute(table, tree) result_length = self.length.execute(table, tree) return FieldSymbol(table.get_current_db().name, None, 0, result_name, result_field_type, result_length, self.allows_null, self.is_pk, None, None)
def execute(self, table: SymbolTable, tree): super().execute(table, tree) #result_name = self.name.execute(table, tree) result_name = self.name result_inherits_from = self.inherits_from.execute(table, tree) if self.inherits_from else None result_fields = self.fields if result_inherits_from: # get inheritance table, if doesn't exists throws semantic error, else append result result_fields.append(table.get_fields_from_table(result_inherits_from)) result = createTable(table.get_current_db().name, result_name, len(result_fields)) if result == 1: raise Error(0, 0, ErrorType.RUNTIME, '5800: system_error') return False elif result == 2: raise Error(0, 0, ErrorType.RUNTIME, '42P04: database_does_not_exists') return False elif result == 3: raise Error(0, 0, ErrorType.RUNTIME, '42P07: duplicate_table') return False else: #add primary keys, jsonMode needs the number of the column to set it to primarykey keys = list( map( lambda x: result_fields.index(x), filter(lambda key: key.is_pk == True, result_fields) ) ) if(len(keys)>0): result = alterAddPK(table.get_current_db().name, result_name, keys) table.add(TableSymbol(table.get_current_db().id, result_name, self.check_exp)) ##result_fields = self.fields.execute(table, tree) # A list of TableField assumed field_index = 0 for field in result_fields: field.table_name = result_name field.field_index = field_index field.type = SymbolType.FIELD field_index += 1 table.add(field) return "Table: " +str(result_name) +" created."
def execute(self, table: SymbolTable, tree): super().execute(table, tree) result_name = self.name result_inherits_from = self.inherits_from.val if self.inherits_from else None result_fields = self.fields if result_inherits_from: # get inheritance table, if doesn't exists throws semantic error, else append result result_fields += table.get_fields_from_table(result_inherits_from) result = createTable(table.get_current_db().name, result_name, len(result_fields)) if result == 1: raise Error(self.line, self.column, ErrorType.RUNTIME, '5800: system_error') elif result == 2: raise Error(self.line, self.column, ErrorType.RUNTIME, '42P04: database_does_not_exists') elif result == 3: raise Error(self.line, self.column, ErrorType.RUNTIME, '42P07: duplicate_table') else: # add primary keys, jsonMode needs the number of the column to set it to primarykey keys = list( map(lambda x: result_fields.index(x), filter(lambda key: key.is_pk is True, result_fields))) if len(keys) > 0: result = alterAddPK(table.get_current_db().name, result_name, keys) table.add( TableSymbol(table.get_current_db().id, result_name, self.check_exp)) field_index = 0 for field in result_fields: nuevo = FieldSymbol(table.get_current_db().name, result_name, field_index, field.name, field.field_type, field.length, field.allows_null, field.is_pk, None, None) field_index += 1 table.add(nuevo) return "Table: " + str(result_name) + " created."
def execute(self, table: SymbolTable, tree): super().execute(table, tree) result_name = self.name.execute(table, tree) result = dropTable(table.get_current_db().name, result_name) if result == 0: # successful operation table.drop_table(result_name) return "Table " + str(result_name) + " has been dropped." elif result == 1: # operation error raise Error(0, 0, ErrorType.RUNTIME, '58000: system_error') elif result == 2: # database does not exist. raise Error(0, 0, ErrorType.RUNTIME, '42P04: database_does_not_exists') elif result == 3: # table does not exist raise Error(0, 0, ErrorType.RUNTIME, '42P01: table_does_not_exists')
def execute(self, table: SymbolTable, tree): super().execute(table, tree) result_table_name = self.table_name.execute(table, tree) result_where = self.where.execute( table, tree) # Select is a must, check result from where # This array must be filled with pks to delete result = delete(table.get_current_db().name, result_table_name, ['1']) if result == 1: raise Error(0, 0, ErrorType.RUNTIME, '5800: system_error') elif result == 2: raise Error(0, 0, ErrorType.RUNTIME, '42P04: database_does_not_exists') elif result == 3: raise Error(0, 0, ErrorType.RUNTIME, '42P07: table_does_not_exists') elif result == 4: raise Error(0, 0, ErrorType.RUNTIME, '42P10: PK_does_not_exists') else: return True
def execute(self, table: SymbolTable, tree): super().execute(table, tree) result_table_name = self.table_name.execute(table, tree) result_field_name = self.field_name.execute(table, tree) # Obtaining all fields because are gonna be needed to get correct field and update indexes later all_fields_symbol = table.get_fields_from_table(result_table_name) column_symbol = next((sym for sym in all_fields_symbol if sym.field_name == result_field_name), None) result = alterDropColumn(table.get_current_db(), result_field_name, column_symbol.field_index) if result == 1: raise Error(0, 0, ErrorType.RUNTIME, '5800: system_error') return False elif result == 2: # log error, old database name does not exists raise Error(0, 0, ErrorType.RUNTIME, '42P04: database_does_not_exists') return False elif result == 3: # log error, table does not exists raise Error(0, 0, ErrorType.RUNTIME, '42P04: table_does_not_exists') return False elif result == 4: # log error, PK cannot be deleted or table to be empty raise Error(0, 0, ErrorType.RUNTIME, '2300: integrity_constraint_violation') return False elif result == 4: # log error, column out of index raise Error(0, 0, ErrorType.RUNTIME, '2300: column_out_of_index') return False else: for field in all_fields_symbol: # Update indexes for higher fields if field.field_index > column_symbol: field.field_index -= 1 table.update(field) # TODO just realized it's needed to check for FKs in other tables # finally delete symbol of column removed table.delete(column_symbol.id) return True