def generate(self, table, tree):
super().generate(table, tree)
if tree:
if self.operator is None: # 'Number' or 'artirmetic function' production for example
return self.exp1.generate(table, tree)
if self.operator == OpArithmetic.PLUS:
return f'{self.exp1.execute(table, tree)} + {self.exp2.execute(table, tree)}'
if self.operator == OpArithmetic.MINUS:
return f'{self.exp1.execute(table, tree)} - {self.exp2.execute(table, tree)}'
if self.operator == OpArithmetic.TIMES:
return f'{self.exp1.execute(table, tree)} * {self.exp2.execute(table, tree)}'
if self.operator == OpArithmetic.DIVIDE:
return f'{self.exp1.execute(table, tree)} / {self.exp2.execute(table, tree)}'
if self.operator == OpArithmetic.MODULE:
return f'{self.exp1.execute(table, tree)} % {self.exp2.execute(table, tree)}'
if self.operator == OpArithmetic.POWER:
return f'{self.exp1.execute(table, tree)} ^ {self.exp2.execute(table, tree)}'
else: #TAC
#Classes who return scalar values NOT expressions: Numeric, Text, BoolAST, ColumnName for ID's, expressions_math.py, expressions_trig.py
arg1 = None
arg2 = None
gen_exp1 = self.exp1.generate(table, tree)
if isinstance(gen_exp1, Quadruple):
arg1 = gen_exp1.res
else:
arg1 = gen_exp1 #if isn´t Cuadrupe must be scallar value such as 1,45,'OLC2 100 pts', False
#same as arg2 but with ternary operator syntax ;)
gen_exp2 = self.exp2.generate(table, tree)
arg2 = gen_exp2.res if isinstance(gen_exp2,
Quadruple) else gen_exp2
this_tac = Quadruple(self.operator, arg1, arg2, generate_tmp(),
OpTAC.ASSIGNMENT)
tree.append(this_tac)
return this_tac
def generate(self, table, tree):
super().generate(table, tree)
if tree is None:
if self.operator == OpRelational.GREATER:
return f'{self.exp1.generate(table, tree)} > {self.exp2.execute(table, tree)}'
if self.operator == OpRelational.LESS:
return f'{self.exp1.generate(table, tree)} < {self.exp2.execute(table, tree)}'
if self.operator == OpRelational.EQUALS:
return f'{self.exp1.generate(table, tree)} = {self.exp2.execute(table, tree)}'
if self.operator == OpRelational.NOT_EQUALS:
return f'{self.exp1.generate(table, tree)} != {self.exp2.execute(table, tree)}'
if self.operator == OpRelational.GREATER_EQUALS:
return f'{self.exp1.generate(table, tree)} >= {self.exp2.execute(table, tree)}'
if self.operator == OpRelational.LESS_EQUALS:
return f'{self.exp1.generate(table, tree)} <= {self.exp2.execute(table, tree)}'
if self.operator == OpRelational.LIKE:
return f'{self.exp1.generate(table, tree)} LIKE {self.exp2.execute(table, tree)}'
if self.operator == OpRelational.NOT_LIKE:
return f'{self.exp1.generate(table, tree)} NOT LIKE {self.exp2.execute(table, tree)}'
else:
arg1 = None
arg2 = None
gen_exp1 = self.exp1.generate(table, tree)
arg1 = gen_exp1.res if isinstance(gen_exp1,
Quadruple) else gen_exp1
gen_exp2 = self.exp2.generate(table, tree)
arg2 = gen_exp2.res if isinstance(gen_exp2,
Quadruple) else gen_exp2
this_tac = Quadruple(self.operator, arg1, arg2, generate_tmp(),
OpTAC.ASSIGNMENT)
tree.append(this_tac)
return this_tac
def generate(self, table, tree):
super().generate(table, tree)
result_name = self.name.generate(table, tree)
quad = Quadruple(None, 'exec_sql', f'DROP TABLE {result_name};',
generate_tmp(), OpTAC.CALL)
tree.append(quad)
return quad
def generate(self, table, tree):
super().generate(table, tree)
col_str = ''
if self.column_list is not None:
for col in self.column_list:
col_str = f'{col_str}{col.val},'
if col_str != '':
col_str = col_str[:-1]
values = ''
if isinstance(self.insert_list, Select):
values = self.insert_list.generate(table, tree)
else:
for value in self.insert_list:
if isinstance(value, Numeric):
values = f'{values}{value.val},'
else:
values = f'{values}\'{value.val}\','
values = f' VALUES({values[:-1]})'
quad = Quadruple(
None, 'exec_sql',
f'"INSERT INTO {self.table_name}{f" ({col_str})" if col_str != "" else ""}{values};"',
generate_tmp(), OpTAC.CALL)
tree.append(quad)
return quad
def generate(self, table, tree):
super().generate(table, tree)
quad = Quadruple(
None, 'exec_sql',
f'ALTER TABLE {self.table_name} RENAME COLUMN {self.old_name} TO {self.new_name};',
generate_tmp(), OpTAC.CALL)
tree.append(quad)
return quad
def generate(self, table, tree):
super().generate(table, tree)
quad = Quadruple(
None, 'exec_sql',
f'ALTER DATABASE {self.name} OWNER TO {self.owner.val};',
generate_tmp(), OpTAC.CALL)
tree.append(quad)
return quad
def generate(self, table, tree):
super().generate(table, tree)
quad = Quadruple(
None, 'exec_sql',
f'ALTER TABLE {self.table_name} ALTER COLUMN {self.field_name} '
f'SET {"NOT NULL" if self.allows_null is False else "NULL"};',
generate_tmp(), OpTAC.CALL)
tree.append(quad)
return quad
def generate(self, table, tree):
super().generate(table, tree)
result_name = self.name.generate(table, tree)
quad = Quadruple(
None, 'exec_sql',
f'DROP DATABASE{" IF EXISTS" if self.if_exists else ""} {result_name};',
generate_tmp(), OpTAC.CALL)
tree.append(quad)
return quad
def generate(self, table, tree):
super().generate(table, tree)
quad = Quadruple(
None, 'exec_sql',
f'ALTER TABLE {self.table_name} ALTER COLUMN {self.field_name} '
f'TYPE {self.field_type.generate(table, tree)};', generate_tmp(),
OpTAC.CALL)
tree.append(quad)
return quad
def generate(self, table, tree):
super().generate(table, tree)
result_field_type = self.field_type.val
quad = Quadruple(
None, 'exec_sql',
f'ALTER TABLE {self.table_name} ADD COLUMN {self.field_name} {result_field_type};',
generate_tmp(), OpTAC.CALL)
tree.append(quad)
return quad
def generate(self, table, tree):
super().generate(table, tree)
all_val = ''
for val in self.value_list:
all_val = f'{all_val}\'{val.generate(table, tree)}\','
quad = Quadruple(None, 'exec_sql',
f'CREATE TYPE {self.name} AS ENUM({all_val[:-1]});',
generate_tmp(), OpTAC.CALL)
tree.append(quad)
return quad
def generate(self, table, tree):
super().generate(table, tree)
result_mode = self.mode.generate(table,
tree) if self.mode is not None else 1
result_name = self.name.generate(table, tree)
quad = Quadruple(
None, 'exec_sql',
f'CREATE DATABASE{" IF NOT EXISTS" if self.exists else ""} {result_name} MODE = {result_mode};',
generate_tmp(), OpTAC.CALL)
tree.append(quad)
return quad
def generate(self, table, tree):
super().generate(table, tree)
exec1 = self.exp1.generate(table, tree)
if tree is None:
if exec1 != 'TRUE' and exec1 != 'FALSE':
raise Exception("The result of operation isn't boolean value")
return 'TRUE' if exec1 == 'FALSE' else 'FALSE'
else:
arg1 = exec1.res if isinstance(exec1, Quadruple) else exec1
this_tac = Quadruple(OpLogic.NOT, arg1, None, generate_tmp(),
OpTAC.ASSIGNMENT)
tree.append(this_tac)
return this_tac
def generate(self, table, tree):
super().generate(table, tree)
result_fields = self.fields
result_inherits_from = self.inherits_from.val if self.inherits_from else None
field_str = ''
for field in result_fields:
field_str = f'{field_str}{field.name} {field.field_type}' \
f'{" IS NOT NULL" if field.allows_null is False else ""}' \
f'{" PRIMARY KEY" if field.is_pk is True else ""},'
quad = Quadruple(
None, 'exec_sql', f'CREATE TABLE {self.name} ({field_str[:-1]})'
f'{f" INHERITS ({result_inherits_from})" if result_inherits_from is not None else ""};',
generate_tmp(), OpTAC.CALL)
tree.append(quad)
return quad
def generate(self, table, tree):
super().generate(table, tree)
col_str = ''
table_str = ''
for col in self.col_names:
col_str = f'{col_str}{col.generate(table, None)},'
if isinstance(self.tables, list):
for table in self.tables:
table_str = f'{table_str}{table.generate(table, tree)},'
ret = f'SELECT{" DISTINCT" if self.is_distinct else ""} {col_str[:-1]}'
if table_str:
ret += f'{f" FROM {table_str[:-1]}" if self.tables is not None else ""}'
if self.where is not None:
ret += f'{self.where.generate(table, None)}'
quad = Quadruple(None, 'exec_sql', f'\'{ret};\'', generate_tmp(),
OpTAC.CALL)
tree.append(quad)
return quad
def generate(self, table, tree):
super().generate(table, tree)
exec1 = self.exp1.generate(table, tree)
exec2 = self.exp2.generate(table, tree)
if tree is None:
if self.operator == OpLogic.AND:
return f'{exec1} AND {exec2}'
if self.operator == OpLogic.OR:
return f'{exec1} OR {exec2}'
else:
arg1 = None
arg2 = None
arg1 = exec1.res if isinstance(exec1, Quadruple) else exec1
arg2 = exec2.res if isinstance(exec2, Quadruple) else exec2
this_tac = Quadruple(self.operator, arg1, arg2, generate_tmp(),
OpTAC.ASSIGNMENT)
tree.append(this_tac)
return this_tac
def generate(self, table, tree):
super().generate(table, tree)
quad = Quadruple(None,'exec_sql', 'SHOW DATABASES;', generate_tmp(), OpTAC.CALL)
tree.append(quad)
return quad
def generate(self, table, tree):
super().generate(table, tree)
quad = Quadruple(None, 'exec_sql', f'USE DATABASE {self.name.generate(table, tree)};', generate_tmp(), OpTAC.CALL)
tree.append(quad)
return quad
def generate(self, table, tree):
super().generate(table, tree)
quad = Quadruple(None, 'exec_sql', f'{self.records_a.generate_pure(table, tree)} INTERSECT {self.records_b.generate_pure(table, tree)};', generate_tmp(), OpTAC.CALL)
tree.append(quad)
return quad