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
