def execute(self, table: SymbolTable, tree): super().execute(table, tree) # result_name = self.name.execute(table, tree) result_name = self.name result_owner = self.owner.execute( table, tree ) if self.owner else None # Owner seems to be stored only to ST result_mode = self.mode( table, tree ) if self.mode is not None else 6 # Change to 1 when default mode available if self.replace: dropDatabase(result_name) result = 0 if result_mode == 6: # add more ifs when modes from EDD available result = createDatabase(result_name) if result == 1: # log error on operation raise Error(0, 0, ErrorType.RUNTIME, '5800: system_error') return False elif result == 2: # log error because db already exists raise Error(0, 0, ErrorType.RUNTIME, '42P04: duplicate_database') return False else: return table.add( DatabaseSymbol(result_name, result_owner, result_mode))
def execute(self, table: SymbolTable, tree): super().execute(table, tree) #result_name = self.name.execute(table, tree) #result_owner = self.owner.execute(table, tree) if self.owner else None # Owner seems to be stored only to ST #result_mode = self.owner.mode(table, tree) if self.mode else 6 # Change to 1 when default mode from EDD available result_name = self.name.execute(table, tree) result_owner = self.owner result_mode = self.mode result = 0 if self.replace: dropDatabase(result_name) #if result_mode == 6: # add more ifs when modes from EDD available result = createDatabase(result_name) if result == 1: # log error on operation raise Error(0, 0, ErrorType.RUNTIME, '5800: system_error') return False elif result == 2 and self.exists == False: # log error because db already exists raise Error(0, 0, ErrorType.RUNTIME, '42P04: duplicate_database') return False else: #return table.add(DatabaseSymbol(result_name, result_owner, result_mode)) #chaged by loadDatabases table.LoadDataBases() return ['Database \'' + result_name + '\' was created successfully!']
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) 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) header = [] # get all columns and add into header array columns = table.get_fields_from_table(self.table_name) columns.sort(key=lambda x: x.field_index) primary_key = 0 for c in columns: header.append(str(c.field_name)) if c.is_pk: primary_key = c.field_index data = extractTable(table.get_current_db().name, self.table_name) # Apply filter for each row by call the execute function if execute return true we kept the row else remove that if self.where: data = self.where.execute(data, header) # getting only PKs to delete... Added | as a hack to delete keys to_delete = list(map(lambda x: f'{x[primary_key]}|', data)) result = delete(table.get_current_db().name, self.table_name, to_delete) 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, tree): super().execute(table, tree) exp = self.exp.execute(table, tree) try: return math.sqrt(exp) except ValueError: raise(Error(self.line, self.column, ErrorType.SEMANTIC, 'ValueError: only accepts integral positive values')) except: raise(Error(self.line, self.column, ErrorType.SEMANTIC, 'TypeError: must be real number, not '+ str(type(exp))))
def execute(self, table, tree): super().execute(table, tree) exp = self.exp.execute(table, tree) try: return math.log10(exp) except ValueError: raise(Error(self.line, self.column, ErrorType.SEMANTIC, 'ValueError: math domain error')) except : raise(Error(self.line, self.column, ErrorType.SEMANTIC, 'TypeError: must be real number, not '+ str(type(exp))))
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, tree): super().execute(table, tree) exp1 = self.exp1.execute(table, tree) exp2 = self.exp2.execute(table, tree) try: return exp1 // exp2 except ZeroDivisionError: raise(Error(self.line, self.column, ErrorType.SEMANTIC, 'ZeroDivisionError: integer division or modulo by zero')) except: raise(Error(self.line, self.column, ErrorType.SEMANTIC, 'TypeError: Both arguments must be a real number'))
def execute(self, table, tree): super().execute(table, tree) exp = self.exp.execute(table, tree) try: if isinstance(exp, float) or isinstance(exp,int): exp = int(np.sign(exp)) return exp else: raise(Error(self.line, self.column, ErrorType.SEMANTIC, 'ValueError: must be real number')) except : raise(Error(self.line, self.column, ErrorType.SEMANTIC, 'TypeError: must be real number, not '+ str(type(exp))))
def execute(self, table, tree): super().execute(table, tree) exp = self.exp.execute(table, tree) try: return math.degrees(math.asin(exp)) except ValueError: raise (Error(self.line, self.column, ErrorType.SEMANTIC, 'ValueError: Math domain error')) except TypeError: raise (Error(self.line, self.column, ErrorType.SEMANTIC, 'TypeError: must be real number, not ' + str(type(exp)))) except: raise (Error(self.line, self.column, ErrorType.SEMANTIC, 'ASIND() function argument error'))
def execute(self, table, tree): super().execute(table, tree) exp = self.exp.execute(table, tree) try: return 1 / math.tan(math.radians(exp)) except ValueError: raise (Error(self.line, self.column, ErrorType.SEMANTIC, 'ValueError: Math domain error')) except TypeError: raise (Error(self.line, self.column, ErrorType.SEMANTIC, 'TypeError: must be real number, not ' + str(type(exp)))) except: raise (Error(self.line, self.column, ErrorType.SEMANTIC, 'Infinity: cotangent of zero doesn’t exist'))
def execute(self, table, tree): super().execute(table, tree) exp1 = self.exp1.execute(table, tree) exp2 = self.exp2.execute(table, tree) try: return math.degrees(math.atan2(exp1, exp2)) except ValueError: raise (Error(self.line, self.column, ErrorType.SEMANTIC, 'ValueError: Math domain error')) except TypeError: raise (Error(self.line, self.column, ErrorType.SEMANTIC, 'TypeError: Both arguments must be a real number')) except: raise (Error(self.line, self.column, ErrorType.SEMANTIC, 'ATAN2D() function argument error'))
def execute(self, table, tree): super().execute(table, tree) exp = self.exp.execute(table, tree) try: if type(exp) == str: return len(exp) else: raise (Error(self.line, self.column, ErrorType.SEMANTIC, 'LENGTH() function argument error')) except: raise (Error(self.line, self.column, ErrorType.SEMANTIC, 'LENGTH() function argument error'))
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 get_by_id(self, symbol_id): result = next((sym for sym in self.symbols if sym.id == symbol_id), None) if result is None: raise Error(0, 0, ErrorType.RUNTIME, f'[TS]Simbolo id:{symbol_id} no pudo ser encontrado') return result
def execute(self, table, tree): super().execute(table, tree) exp = self.exp.execute(table, tree) try: return random.seed(exp) except: raise(Error(self.line, self.column, ErrorType.SEMANTIC, 'ValueError: Math domain error'))
def execute(self, table, tree): super().execute(table, tree) exp1 = self.exp1.execute(table, tree) exp2 = self.exp2.execute(table, tree) exp3 = self.exp3.execute(table, tree) exp4 = self.exp4.execute(table, tree) try: if exp3 == exp2: return 0 else: return math.ceil( (exp4 * exp1) / (exp3 - exp2) ) except ValueError: raise(Error(self.line, self.column, ErrorType.SEMANTIC, 'ValueError: only accepts integral positive values')) except: raise(Error(self.line, self.column, ErrorType.SEMANTIC, 'TypeError:all arguments must be integers'))
def execute(self, table, tree): self.val = self.val.execute(table, tree) if type(self.val) == int or type(self.val) == float: return self.val * -1 else: raise Error(self.line, self.column, ErrorType.SEMANTIC, 'TypeError: must be number')
def execute(self, table, tree): super().execute(table, tree) exp = self.exp.execute(table, tree) try: return math.factorial() except : raise(Error(self.line, self.column, ErrorType.SEMANTIC, 'TypeError: only accepts integral positive values'))
def execute(self, table, tree): super().execute(table, tree) exp = self.exp.execute(table, tree) try: return np.cbrt(exp) except: raise(Error(self.line, self.column, ErrorType.SEMANTIC, 'TypeError: must be real number, not '+ str(type(exp))))
def add(self, symbol): match = next((sym for sym in self.symbols if sym.name == symbol.name and sym.type == symbol.type), None) if match is None: self.symbols.append(symbol) else: raise Error(0, 0, ErrorType.RUNTIME, f'[TS]{symbol.name} ya ha sido declarado previamente') return True
def execute(self, table: SymbolTable, tree): super().execute(table, tree) result = alterDatabase(self.name, self.new_name) if result == 1: raise Error(0, 0, ErrorType.RUNTIME, '5800: system_error') elif result == 2: raise Error(0, 0, ErrorType.RUNTIME, '42P04: old_database_does_not_exists') elif result == 3: raise Error(0, 0, ErrorType.RUNTIME, '42P04: new_database_already_exists') else: old_symbol = table.get(self.name, SymbolType.DATABASE) old_symbol.name = self.new_name table.update(old_symbol) return "You renamed table " + str(self.name) + " to " + str( self.new_name)
def execute(self, table, tree): super().execute(table, tree) exp1 = self.exp1.execute(table, tree) exp2 = self.exp2.execute(table, tree) try: return math.pow(exp1, exp2) except: raise(Error(self.line, self.column, ErrorType.SEMANTIC, 'TypeError: Both arguments must be a real number'))
def get(self, symbol_name, symbol_type): result = next((sym for sym in self.symbols if sym.type == symbol_type and sym.name == symbol_name), None) if result is None: raise Error(0, 0, ErrorType.RUNTIME, f'[TS]{symbol_name} no pudo ser encontrado') return result
def execute(self, table: SymbolTable, tree): super().execute(table, tree) result_name = self.name.execute(table, tree) result = 0 if self.if_exists: dropDatabase(result_name) return "Database " + str(result_name) + " has been dropped" else: result = dropDatabase(result_name) if result == 0: # successful operation table.drop_data_base(result_name) return "Database " + 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')
def execute(self, table, tree): super().execute(table, tree) exp = self.exp.execute(table, tree) try: return hashlib.md5(exp.encode('utf-8')).hexdigest() except: raise (Error(self.line, self.column, ErrorType.SEMANTIC, 'MD5 error'))
def execute(self, table, tree): super().execute(table, tree) self.val = self.val.execute(table, tree) print(type(self.val)) if(type(self.val) == int or type(self.val) == float): return self.val * 1 else: raise Error(self.line, self.column, ErrorType.SEMANTIC, 'TypeError: must be number')
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 get_current_db(self): result = next( (sym for sym in self.symbols if sym.type == SymbolType.DATABASE and sym.selected is True), None) if result is None: raise Error(0, 0, ErrorType.RUNTIME, 'No se ha seleccionado base de datos') return result