def ejecutar(self,ts):
if TRef.databaseExist(self.nombre):
if not self.existencia:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.duplicate_database), 0)
exito = 0
databases = DBMS.showDatabases()
if self.reemplazo:
if self.nombre in databases: #Eliminamos si existe
DBMS.dropDatabase(self.nombre)
TRef.dropDatabase(self.nombre)
exito = DBMS.createDatabase(self.nombre)
elif self.existencia:
if not self.nombre in databases:
exito = DBMS.createDatabase(self.nombre)
else:
exito = DBMS.createDatabase(self.nombre)
#Si tenemos exito se crea en el type reference
if exito == 1:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.invalid_schema_definition), 0)
elif exito == 2:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.duplicate_database), 0)
TRef.createDatabase(self.nombre, self.modo)
return "Database '" + self.nombre + "' succesful created"
def ejecutar(self, ts):
if self.tipo == ALTER_TABLE_ADD.FOREIGN_KEY:
if not TRef.tableExist(DB_ACTUAL.getName(),self.accion[0]):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_fdw_error.fdw_table_not_found), 0)
if not TRef.columnExist(DB_ACTUAL.getName(), self.accion[0], self.accion[1]):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_fdw_error.fdw_invalid_column_number), 0)
return (self.nombre,self.accion)
elif self.tipo == ALTER_TABLE_ADD.MULTI_FOREIGN_KEY:
if not TRef.tableExist(DB_ACTUAL.getName(),self.accion[0]):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_fdw_error.fdw_table_not_found), 0)
#Comparamos que la misma cantidad de ids propios sea igual a la foranea
if len(self.nombre) != len(self.accion[1]):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_data_exception.data_exception), 0)
for col in self.accion[1]:
if not TRef.columnExist(DB_ACTUAL.getName(), self.accion[0], col):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_fdw_error.fdw_invalid_column_number), 0)
listaSin = list()
for i in range(len(self.nombre)):
listaSin.append( (self.nombre[i], self.accion[0], self.accion[1][i]) )
return listaSin
return (self.nombre, self.accion)
def ejecutar(self, ts):
if DB_ACTUAL.getName() == None:
return ErrorReport('Semantico', 'Not defined database to used', 0)
elif not TRef.databaseExist(DB_ACTUAL.getName()):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_invalid_schema_name.invalid_schema_name), 0)
elif TRef.tableExist(DB_ACTUAL.getName(), self.tabla):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.undefined_table), 0)
DBMS.dropTable(DB_ACTUAL.getName(), self.tabla)
TRef.dropTable(DB_ACTUAL.getName(), self.tabla)
return 'Successful table dropped'
def ejecutar(self, ts):
if not TRef.databaseExist(self.nombre):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_invalid_schema_name.invalid_schema_name), 0)
if self.accion[0] == 'OWNER':
pass
else:
#Comprobamos que no exista una base de datos con ese nombre
if TRef.databaseExist(self.accion[1]):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.duplicate_database), 0)
DBMS.alterDatabase(self.nombre, self.accion[1])
TRef.alterDatabase(self.nombre, self.accion[1])
return 0
def ejecutar(self, ts):
if DB_ACTUAL.getName() == None:
return ErrorReport('Semantico', 'Not defined database to used', 0)
elif not TRef.databaseExist(DB_ACTUAL.getName()):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_invalid_schema_name.invalid_schema_name), 0)
elif not TRef.tableExist(DB_ACTUAL.getName(), self.tabla):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.undefined_table), 0)
if isinstance(self.accion, list):
for subaccion in self.accion:
sint = subaccion.ejecutar(ts)
#Si es un error, solo se retorna
if isinstance(sint, ErrorReport):
return sint
elif isinstance(self.accion, AlterField):
#Comprobamos la existencia del campo
if not TRef.columnExist(DB_ACTUAL.getName(),self.tabla,self.accion.campo):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.undefined_column), 0)
if self.accion.cantidad:
sint = self.accion.ejecutar(ts)
if isinstance(sint, int):
print(TRef.alterField(DB_ACTUAL.getName(), self.tabla, self.accion.campo, 'Type', TYPE_COLUMN.VARCHAR.value))
print(TRef.alterField(DB_ACTUAL.getName(), self.tabla, self.accion.campo, 'Lenght', sint))
elif isinstance(sint, tuple):
print(TRef.alterField(DB_ACTUAL.getName(), self.tabla, self.accion.campo, 'Type', sint[0].value))
print(TRef.alterField(DB_ACTUAL.getName(), self.tabla, self.accion.campo, 'Lenght', sint[1]))
else:
print(TRef.alterField(DB_ACTUAL.getName(), self.tabla, self.accion.campo, 'Type', sint))
print(TRef.alterField(DB_ACTUAL.getName(), self.tabla, self.accion.campo, 'Lenght', None))
else:
print(TRef.alterField(DB_ACTUAL.getName(), self.tabla, self.accion.campo, 'Null', False))
elif isinstance(self.accion, AlterTableDrop):
if self.accion.tipo == ALTER_TABLE_DROP.COLUMN:
sint = self.accion.ejecutar(ts)
#Comprobamos la existencia del campo
if not TRef.columnExist(DB_ACTUAL.getName(),self.tabla,self.accion.campo):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.undefined_column), 0)
dropField = TRef.alterDropColumn(DB_ACTUAL.getName(), self.tabla, sint)
if dropField == 1:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_data_exception.data_exception), 0)
elif dropField == 4:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_integrity_constraint_violation.integrity_constraint_violation), 0)
elif dropField == 6:
return ErrorReport('Semantico', 'Error: A table cannot be empty', 0)
else:
if not TRef.constraintExist(self.accion.nombre):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_integrity_constraint_violation.integrity_constraint_violation), 0)
colPres = TRef.getConstraint(DB_ACTUAL.getName(),self.tabla, self.accion.nombre)
if not isinstance(colPres, tuple):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_data_exception.data_exception), 0)
TRef.alterField(DB_ACTUAL.getName(), self.tabla, colPres[0], colPres[1], None)
return 'Alter table complete'
def ejecutar(self, ts):
if not TRef.databaseExist(DB_ACTUAL.getName()):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_fdw_error.fdw_schema_not_found), 0)
elif not TRef.tableExist(DB_ACTUAL.getName(),self.otraTabla):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_fdw_error.fdw_table_not_found), 0)
#Comparamos que la misma cantidad de ids propios sea igual a la foranea
if len(self.lista) != len(self.listaOtraTabla):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_data_exception.data_exception), 0)
for col in self.listaOtraTabla:
if not TRef.columnExist(DB_ACTUAL.getName(), self.otraTabla, col):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_fdw_error.fdw_invalid_column_number), 0)
listaSin = list()
for i in range(len(self.lista)):
listaSin.append( (self.lista[i], self.otraTabla, self.listaOtraTabla[i]) )
return listaSin
def ejecutar(self, ts):
if not TRef.databaseExist(self.db):
if self.existencia:
return "Drop Database: Database doesn't exist"
else:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_invalid_schema_name.invalid_schema_name), 0)
DBMS.dropDatabase(self.db)
TRef.dropDatabase(self.db)
return 'Successful database dropped'
def ejecutar(self, ts):
# Verificar si existe la columna
if self.cantidad:
if isinstance(self.cantidad, int):
if self.cantidad < 0:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_data_exception.numeric_value_out_of_range),0)
return self.cantidad
elif isinstance(self.cantidad, tuple):
return self.cantidad
else:
return self.cantidad.value
else:
return False
def ejecutar(self, ts):
if TRef.columnExist(DB_ACTUAL.getName(), self.tabla, self.campo):
return {'Table': self.tabla, 'Field': self.campo}
else:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_fdw_error.fdw_column_name_not_found), 0)
def ejecutar(self, ts):
#Guardamos el tipo y largo si es necesario
tipo = None
largo = None
if isinstance(self.tipo, tuple):
tipo = self.tipo[0].value
largo = self.tipo[1]
else:
tipo = self.tipo.value
#Bajo la logica de que puede venir parametros repetidos, tomaremos el ultimo en venir como valido
atributos = dict(
{
"Type": tipo,
"Lenght": largo,
"Default": None,
"Null": True,
"PK": False,
"PKConst": None,
"FK": False,
"References": None,
"FKConst": None,
"Unique": False,
"UniqueConst": None,
"Check": None,
"CheckConst": None
}
)
if self.atributos:
for atr in self.atributos:
if isinstance(atr, ConstraintField):
if atr.tipo == CONSTRAINT_FIELD.PRIMARY_KEY:
atributos['PK'] = True
elif atr.tipo == CONSTRAINT_FIELD.UNIQUE:
atributos['Unique'] = True
atributos['UniqueConst'] = atr.ejecutar(ts)
elif atr.tipo == CONSTRAINT_FIELD.NULL:
atributos['Null'] = atr.ejecutar(ts)
elif isinstance(atr, ForeignKeyField):
fk = atr.ejecutar(ts)
if isinstance(fk, ErrorReport):
return fk
else:
colFK = TRef.getColumns(DB_ACTUAL.getName(), fk['Table'])[fk['Field']]
if colFK['Type'] != tipo:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_fdw_error.fdw_invalid_data_type), 0)
atributos['References'] = fk
atributos['FK'] = True
elif isinstance(atr, DefaultField):
atributos['Default'] = atr.ejecutar(ts)
elif isinstance(atr,CheckField):
#TODO Mejorar implementacion de checks
cheq = atr.ejecutar(ts)
atributos['Check'] = cheq[1]
atributos['CheckConst'] = cheq[0]
else:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.invalid_table_definition), 0)
return atributos
def ejecutar(self, ts):
if DB_ACTUAL.getName() == None:
return ErrorReport('Semantico', 'Not defined database to used', 0)
elif not TRef.databaseExist(DB_ACTUAL.getName()):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_invalid_schema_name.invalid_schema_name), 0)
elif TRef.tableExist(DB_ACTUAL.getName(), self.nombre):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.duplicate_table), 0)
# Aux de comprobacion y almacenamiento
columns = dict()
auxFK = list()
auxPK = list()
auxUnique = list()
auxCheck = list()
# Proceso de las distintas columnas recibidas en la consulta
for col in self.columnas:
if isinstance(col, CreateField): #Columna nueva
#Obtenemos cada columna y corroboramos que tengan nombres distintos
if col.nombre in columns:
return 1
else:
colSint = col.ejecutar(ts)
if isinstance(colSint, ErrorReport):
return colSint
columns[col.nombre] = colSint
elif isinstance(col, ConstraintMultipleFields): #Multiples Constraints
if col.tipo == CONSTRAINT_FIELD.UNIQUE:
auxUnique.extend(col.ejecutar(ts))
else:
auxPK.extend(col.ejecutar(ts))
elif isinstance(col, ForeignKeyMultipleFields): #Multiples Llaves Foraneas
colSint = col.ejecutar(ts)
if isinstance(colSint, ErrorReport):
return colSint
auxFK.extend(colSint)
elif isinstance(col, CheckMultipleFields): #Multiple chequeos
auxCheck.extend(col.ejecutar(ts))
else:
return col
#Modificamos los valores dependiendo de las columnas multiples
# Primary Key
for pk in auxPK:
# Se verifica que cada constraint haga referencia a un campo, de lo contrario será invalido
if not pk in columns:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.invalid_column_reference), 0)
columns[pk]['PK'] = True
# Foreign Key
for fk in auxFK:
# Se verifica que cada constraint haga referencia a un campo, de lo contrario será invalido
if not fk[0] in columns:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.invalid_column_reference), 0)
columns[fk[0]]['FK'] = True
columns[fk[0]]['References'] = {'Table':fk[1],'Field':fk[0]}
for chequeo in auxCheck:
# Se verifica que cada constraint haga referencia a un campo, de lo contrario será invalido
if not chequeo[0] in columns:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.invalid_column_reference), 0)
#TODO Mejorar implementacion de checks
columns[chequeo[0]]['Check'] = chequeo[1]
# Unique
for unico in auxUnique:
# Se verifica que cada constraint haga referencia a un campo, de lo contrario será invalido
if not unico in columns:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.invalid_column_reference), 0)
columns[unico]['Unique'] = True
#--------- Herencia
if self.herencia:
if not TRef.tableExist(DB_ACTUAL.getName(), self.herencia):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_fdw_error.fdw_table_not_found), 0)
else:
colsPadre = TRef.getColumns(DB_ACTUAL.getName(), self.herencia)
for col in colsPadre:
# Verificamos que no existan columnas repetidas con el padre, ya que no existe el polimorfismo de campos
if col in columns:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.duplicate_column), 0)
# De no existir columnas duplicadas, se agregan las columnas a la tabla
columns.update(colsPadre)
# Ahora procedemos a crear
result = DBMS.createTable(DB_ACTUAL.getName(), self.nombre, len(columns))
if result == 0:
TRef.createTable(DB_ACTUAL.getName(), self.nombre, columns, self.herencia)
return result
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.duplicate_table), 0)