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 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 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):
unario = self.exp.ejecutar(ts)
if isinstance(unario, ErrorReport):
return unario # si ya viene un error solo lo retorna
if not (isinstance(unario, ExpresionNumero)):
return ErrorReport('semantico', 'Error , Tipe Invalido UNARIO "+"',
self.linea)
try:
return ExpresionNumero(unario.val, unario.tipo, self.linea)
except:
return ErrorReport('semantico', 'Error , Tipe Invalido UNARIO "+"',
self.linea)
def ejecutar(self, ts):
if self.parametro2 != None and self.parametro3 != None: # 3 PARAMETROS
res1 = self.parametro1.ejecutar(ts)
res2 = self.parametro2.ejecutar(ts)
res3 = self.parametro3.ejecutar(ts)
if isinstance(res1 , ErrorReport):
return res1
if isinstance(res2 , ErrorReport):
return res2
if isinstance(res3 , ErrorReport):
return res3
if self.funcion == "SUBSTRING" or self.funcion == "SUBSTR":
if isinstance(res1 , ExpresionID) or isinstance(res1 , ExpresionCadena):
if isinstance(res2 , ExpresionNumero) or isinstance(res3 , ExpresionNumero):
if res2.tipo == TIPO_DE_DATO.ENTERO and res3.tipo == TIPO_DE_DATO.ENTERO:
print("RETORNA: "+ str(res1)[int(res2.val) : int(res3.val)])
return ExpresionCadena(str(res1)[int(res2.val) : int(res3.val)], TIPO_DE_DATO.CADENA , self.linea)
# si no entra hasta el ultimo if llega aca
return ErrorReport('semantico', 'error de tipo en el parametro 2 o parametro 3' ,self.linea)
else:
return ErrorReport('semantico', 'error de tipo en el parametro 1' ,self.linea)
elif self.parametro2 != None: # 2 PARAMETROS
print("2 parametros")
elif self.parametro1 != None: # 1 PARAMETRO
nodoSimplificado = self.parametro1.ejecutar(ts)
if isinstance(nodoSimplificado , ErrorReport):
return nodoSimplificado # SOLO SE SUBE EL ERROR
if self.funcion == "LENGTH":
if isinstance(nodoSimplificado , ExpresionCadena) or isinstance(nodoSimplificado , ExpresionID):
print("RETORNA: "+ str(len(nodoSimplificado.val)))
return ExpresionNumero(len(nodoSimplificado.val), TIPO_DE_DATO.ENTERO , self.linea)
else:
return ErrorReport('semantico', 'error de tipo' ,self.linea)
elif self.funcion == "TRIM":
if isinstance(nodoSimplificado , ExpresionCadena) or isinstance(nodoSimplificado , ExpresionID):
print("RETORNA: "+ str((nodoSimplificado.val)).strip())
return ExpresionCadena(str((nodoSimplificado.val)).strip(), TIPO_DE_DATO.CADENA , self.linea)
else:
return ErrorReport('semantico', 'error de tipo' ,self.linea)
elif self.funcion == "MD5":
if isinstance(nodoSimplificado , ExpresionCadena) or isinstance(nodoSimplificado , ExpresionID):
return ExpresionCadena(hashlib.md5(nodoSimplificado.val.encode()).hexdigest(), TIPO_DE_DATO.CADENA , self.linea)
else:
return ErrorReport('semantico', 'error de tipo' ,self.linea)
elif self.funcion == "SHA256":
if isinstance(nodoSimplificado , ExpresionCadena) or isinstance(nodoSimplificado , ExpresionID):
return ExpresionCadena(hashlib.sha256(nodoSimplificado.val.encode()).hexdigest(), TIPO_DE_DATO.CADENA , self.linea)
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):
izq = self.exp1.ejecutar(ts)
der = self.exp2.ejecutar(ts)
if isinstance(izq, ErrorReport):
return izq
if isinstance(der, ErrorReport):
return der
# como expresionNumero abarca tanto decimales como enteros
if isinstance(izq, ExpresionNumero) and isinstance(
izq, ExpresionNumero):
if self.operador == OPERACION_RELACIONAL.DESIGUAL:
return ExpresionBooleano(izq.val != der.val, self.linea)
elif self.operador == OPERACION_RELACIONAL.IGUAL:
return ExpresionBooleano(izq.val == der.val, self.linea)
elif self.operador == OPERACION_RELACIONAL.MAYOR:
return ExpresionBooleano(izq.val > der.val, self.linea)
elif self.operador == OPERACION_RELACIONAL.MAYORIGUAL:
return ExpresionBooleano(izq.val >= der.val, self.linea)
elif self.operador == OPERACION_RELACIONAL.MENOR:
return ExpresionBooleano(izq.val < der.val, self.linea)
elif self.operador == OPERACION_RELACIONAL.MENORIGUAL:
return ExpresionBooleano(izq.val <= der.val, self.linea)
elif isinstance(izq, ExpresionCadena) and isinstance(
izq, ExpresionCadena):
if self.operador == OPERACION_RELACIONAL.DESIGUAL:
return ExpresionBooleano(izq.val != der.val, self.linea)
elif self.operador == OPERACION_RELACIONAL.IGUAL:
return ExpresionBooleano(izq.val == der.val, self.linea)
else:
return ErrorReport('semantico',
'Error de tipos , en Operacion Relacional',
self.linea)
def ejecutar(self, ts):
lista = list()
for item in self.lista:
if not item.val in lista:
lista.append(item.val)
if not TEnum.insertEnum(self.nombre, lista):
return ErrorReport('Semantico', 'Invalid Enum Declaration', self.lista[0].linea)
return 'Enum \'' + self.nombre + '\' succesful created'
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 metodo_width_bucket(self, lista_numeros):
if len(lista_numeros) == 4:
# EXPRESION , MIN_VALLUE , MAX_VALUE , N_BLOQUES
pass
else:
return ErrorReport(
'sintactico',
'error en width_bucket se esperaba solo 4 parametros',
self.linea)
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):
izq = self.exp1.ejecutar(ts)
der = self.exp2.ejecutar(ts)
# como expresionNumero abarca tanto decimales como enteros
if (isinstance(izq,ExpresionNumero) and isinstance(izq,ExpresionNumero)) or (isinstance(izq,ExpresionCadena) and isinstance(izq,ExpresionCadena)):
if self.operador == OPERACION_BINARIA_IS.IS_NOT_DISTINCT_FROM:
return ExpresionBooleano(izq.val == der.val, self.linea)
elif self.operador == OPERACION_BINARIA_IS.IS_DISTINCT_FROM:
return ExpresionBooleano(izq.val != der.val, self.linea)
else:
return ErrorReport('semantico', 'Error de tipos , en Operacion Relacional' ,self.linea)
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):
columnas = []
filas = []
for actual in self.campos:
if isinstance(actual, ITEM_ALIAS):
if isinstance(actual.item, ExpresionID):
print("Error semántico, solo se aceptan expresiones.")
sqlTypeError = sqlErrors.sql_error_data_exception.invalid_parameter_value
return ErrorReport(
'Semántico', "ERROR " + sqlTypeError.value + ": " +
str(sqlTypeError.name), self.linea)
elif isinstance(actual.item, Expresion):
filas.append(actual.item.ejecutar(ts).val)
columnas.append(actual.alias)
else:
print("Error semántico, solo se aceptan expresiones.")
sqlTypeError = sqlErrors.sql_error_data_exception.invalid_parameter_value
return ErrorReport(
'Semántico', "ERROR " + sqlTypeError.value + ": " +
str(sqlTypeError.name), self.linea)
elif isinstance(actual, ExpresionID):
print("Error semántico, solo se aceptan expresiones.")
sqlTypeError = sqlErrors.sql_error_data_exception.invalid_parameter_value
return ErrorReport(
'Semántico', "ERROR " + sqlTypeError.value + ": " +
str(sqlTypeError.name), self.linea)
elif isinstance(actual, Expresion):
filas.append(actual.ejecutar(ts).val)
columnas.append('???')
print("Error semántico, solo se aceptan expresiones.")
sqlTypeError = sqlErrors.sql_error_data_exception.invalid_parameter_value
return ErrorReport(
'Semántico', "ERROR " + sqlTypeError.value + ": " +
str(sqlTypeError.name), self.linea)
salida = matriz(columnas, [filas], TABLA_TIPO.SELECT_SIMPLE,
"nueva tabla", None, None)
return salida.ejecutar(ts)
def ejecutar(self, ts):
unario = self.exp.ejecutar(ts)
if isinstance(unario , ErrorReport):
return unario # si ya viene un error solo lo retorna
if not (isinstance(unario , ExpresionNumero)):
return ErrorReport('semantico', f'Error , Tipe Invalido UNARIO {self.operador}' ,self.linea)
try:# CASOS DE EJECUCION
if self.operador == "~":
if GET_TIPO(unario.val) == TIPO_DE_DATO.ENTERO:
return ExpresionNumero(~ unario.val, GET_TIPO(unario.val), self.linea)
else:
return ErrorReport('semantico', 'error operador Unario ~ solo recibe ENTEROS' ,self.linea)
elif self.operador =="|": # SACA LA RAIZ CUADRADA
if (unario.val) < 0:
return ErrorReport('semantico', 'error operador Unario | solo recibe numeros POSITIVOS' ,self.linea)
valor = unario.val**(1/2)
return ExpresionNumero(valor,GET_TIPO(valor),self.linea)
elif self.operador =="||": # SACA LA RAIZ CUBICA
valor = raizCubica(unario.val)
return ExpresionNumero(valor,GET_TIPO(valor),self.linea)
except:
return ErrorReport('semantico', f'Error: Tipe Invalido UNARIO {self.operador}' ,self.linea)
def ejecutar(self, ts):
izq = self.exp1.ejecutar(ts)
der = self.exp2.ejecutar(ts)
# por si se quiere operar un error con una expresion buena , retorna de una el error
if isinstance(izq , ErrorReport):
return izq
if isinstance(der , ErrorReport):
return der
if izq.tipo == TIPO_DE_DATO.BOOLEANO and der.tipo == TIPO_DE_DATO.BOOLEANO:
if self.operador == OPERACION_LOGICA.AND:
return ExpresionBooleano(izq.val and der.val,self.linea)
elif self.operador == OPERACION_LOGICA.OR:
return ExpresionBooleano(izq.val or der.val, self.linea)
else:
return ErrorReport('semantico', 'Error , se esta operando con valores No booleanos' ,self.linea)
def metodo_width_bucket(self , lista_numeros , ts):
if len(lista_numeros) == 4:
#EXPRESION , MIN_VALLUE , MAX_VALUE , N_BLOQUES
valorPrueba = lista_numeros[0].ejecutar(ts)
if isinstance(valorPrueba , ErrorReport):
return valorPrueba
rangoInicial = lista_numeros[1].ejecutar(ts)
if isinstance(rangoInicial , ErrorReport):
return rangoInicial
rangoMax = lista_numeros[2].ejecutar(ts)
if isinstance(rangoMax , ErrorReport):
return rangoMax
nBloques = lista_numeros[3].ejecutar(ts)
if isinstance(nBloques , ErrorReport):
return nBloques
# validacion de tipo numerico ,
if not isinstance(valorPrueba , ExpresionNumero):
return ErrorReport('sintactico', 'Error solo se acepta un tipo numero' ,self.linea)
if not isinstance(rangoInicial, ExpresionNumero):
return ErrorReport('sintactico', 'Error solo se acepta un tipo numero' ,self.linea)
if not isinstance(rangoMax, ExpresionNumero):
return ErrorReport('sintactico', 'Error solo se acepta un tipo numero' ,self.linea)
if not isinstance(nBloques, ExpresionNumero):
return ErrorReport('sintactico', 'Error solo se acepta un tipo numero' ,self.linea)
if not self.getTipo(nBloques.val) == TIPO_DE_DATO.ENTERO:
return ErrorReport('sintactico', 'Error solo se acepta un ENTERO en el ultimo parametro' ,self.linea)
# dando los meros valores
valorPrueba = valorPrueba.val
rangoInicial = rangoInicial.val
rangoMax = rangoMax.val
nBloques = nBloques.val
if valorPrueba >= rangoMax:
return ExpresionNumero(1 + nBloques,TIPO_DE_DATO.ENTERO,self.linea)
elif valorPrueba < rangoInicial:
return ExpresionNumero( (1-1)*0 , TIPO_DE_DATO.ENTERO,self.linea)
else:
diferencia = rangoMax-rangoInicial
subIntervalos = diferencia/nBloques # _ , _ , _ , _
auxUbicacion = 1
aux = rangoInicial + subIntervalos
while(not valorPrueba < aux):
#print(str(aux - subIntervalos) +' , ' + str(aux))
aux += subIntervalos
auxUbicacion +=1
return ExpresionNumero(auxUbicacion, TIPO_DE_DATO.ENTERO,self.linea)
else:
return ErrorReport('sintactico', 'error en width_bucket se esperaba solo 4 parametros' ,self.linea)
def ejecutar(self, ts):
ev = self.evaluado.ejecutar(ts)
inf = self.limiteInferior.ejecutar(ts)
sup = self.limiteSuperior.ejecutar(ts)
if isinstance(ev, ExpresionNumero) and isinstance(
inf, ExpresionNumero) and isinstance(sup, ExpresionNumero):
if self.tipo == BETWEEN.BETWEEN:
return ExpresionBooleano(inf.val <= ev.val <= sup.val,
self.linea)
elif self.tipo == BETWEEN.NOT_BETWEEN:
return ExpresionBooleano(not inf.val <= ev.val <= sup.val,
self.linea)
elif self.tipo == BETWEEN.BETWEEN_SYMMETRIC:
return ExpresionBooleano(
(inf.val <= ev.val <= sup.val) ^
(ev.val <= inf.val or sup.val <= ev.val), self.linea)
elif self.tipo == BETWEEN.NOT_BETWEEN_SYMMETRIC:
return ExpresionBooleano(
not ((inf.val <= ev.val <= sup.val) ^
(ev.val <= inf.val or sup.val <= ev.val)), self.linea)
else:
return ErrorReport('semantico',
'Error de tipos , en Operacion Relacional',
self.linea)
def t_error(t):
print(f'Error lexico: {t.value[0]}')
error = ErrorReport('lexico', f'error lexico con {t.value[0]}', t.lineno)
listaErrores.addError(error)
t.lexer.skip(1)
def ejecutar(self, ts = None):
if self.parametro2 != None: # 2 PARAMETROS
nodoSyn1 = self.parametro1.ejecutar(ts)
if isinstance(nodoSyn1 , ErrorReport):
return nodoSyn1
nodoSyn2 = self.parametro2.ejecutar(ts)
if isinstance(nodoSyn2 , ErrorReport):
return nodoSyn2
if isinstance(nodoSyn1 , ExpresionNumero) and isinstance(nodoSyn2 , ExpresionNumero):
if self.funcion == "ATAN2":
rads = math.atan2(nodoSyn1.val,nodoSyn2.val)
return ExpresionNumero(rads,self.getTipo(rads),self.linea)
if self.funcion == "ATAN2D":
rads = math.atan2(nodoSyn1.val,nodoSyn2.val)
grados = (rads * 180/math.pi)
return ExpresionNumero(grados,self.getTipo(grados),self.linea)
if self.funcion == "DIV":
izq = nodoSyn1.val
der = nodoSyn2.val
if der == 0:
return ErrorReport('semantico', 'error DIVISION entre 0' ,self.linea)
valor = izq/der
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
if self.funcion =="GCD":
valor = math.gcd(nodoSyn1.val , nodoSyn2.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
if self.funcion =="MOD":
try:
valor = (nodoSyn1.val % nodoSyn2.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
except:
return ErrorReport('semantico', 'error en MODULO' ,self.linea)
if self.funcion =="POWER":
try:
valor = (nodoSyn1.val ** nodoSyn2.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
except:
return ErrorReport('semantico', 'error en MODULO' ,self.linea)
if self.funcion =="ROUND":
valor = round(nodoSyn1.val , nodoSyn2.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
if self.funcion == "TRUNC":
if self.getTipo(nodoSyn2.val) != TIPO_DE_DATO.ENTERO:
return ErrorReport('semantico', 'error en Metodo TRUNC el segundo parametro tiene que ser un entero' ,self.linea)
cadenaInt = str(nodoSyn1.val)
numero_truncado = ''
indice = 0
decimalesAdjuntados = 0
for i in range(len(cadenaInt)):
if cadenaInt[i] == '.':
numero_truncado += cadenaInt[i]
indice = i
break
else:
numero_truncado += cadenaInt[i]
indice+=1
while(decimalesAdjuntados < nodoSyn2.val):
if indice < len(cadenaInt):
numero_truncado += cadenaInt[indice]
else:
numero_truncado += '0'
indice+=1
decimalesAdjuntados+=1
valor = float(numero_truncado)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
else:
return ErrorReport('semantico', 'error de tipo, se esperaba un ENTERO O DECIMAL' ,self.linea)
elif self.parametro1 != None: # 1 PARAMETRO
if isinstance(self.parametro1,list):
if self.funcion =="WIDTH_BUCKET":
return self.metodo_width_bucket(self.parametro1,ts)
nodoSyn1 = self.parametro1.ejecutar(ts)
if isinstance(nodoSyn1 , ErrorReport):
return nodoSyn1
if isinstance(nodoSyn1 , ExpresionNumero): # decimales y eneteros
if self.funcion == "ACOS": # RADIANEES
if nodoSyn1.val > 1 or nodoSyn1.val < 1:
return ErrorReport('semantico', 'Error en ACOS ,el parametro debe estar entre -1 y 1' ,self.linea)
return ExpresionNumero(math.acos(nodoSyn1.val),self.getTipo(nodoSyn1.val),self.linea)
if self.funcion == "ACOSD": # GRADOS
if nodoSyn1.val > 1 or nodoSyn1.val < 1:
return ErrorReport('semantico', 'Error en ACOSD , el parametro debe estar entre -1 y 1' ,self.linea)
rads = math.acos(nodoSyn1.val)
grados = (rads * 180/math.pi)
return ExpresionNumero(grados,self.getTipo(grados),self.linea)
if self.funcion == "ASIN":
if nodoSyn1.val > 1 or nodoSyn1.val < 1:
return ErrorReport('semantico', 'Error en ASIN ,el parametro debe estar entre -1 y 1' ,self.linea)
valor = math.asin(nodoSyn1.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
if self.funcion == "ASIND":
if nodoSyn1.val > 1 or nodoSyn1.val < 1:
return ErrorReport('semantico', 'Error en ASIND ,el parametro debe estar entre -1 y 1' ,self.linea)
rads = math.asin(nodoSyn1.val)
grados = (rads * 180/math.pi)
return ExpresionNumero(grados,self.getTipo(grados),self.linea)
if self.funcion == "ATAN":
try:
rads = math.atan(nodoSyn1.val)
return ExpresionNumero(rads,self.getTipo(rads),self.linea)
except:
return ErrorReport('semantico', 'Error en ATAN por el valor del parametro ' ,self.linea)
if self.funcion == "ATAND":
try:
rads = math.atan(nodoSyn1.val)
grados = (rads * 180/math.pi)
return ExpresionNumero(grados,self.getTipo(grados),self.linea)
except:
return ErrorReport('semantico', 'Error en ATAND por el valor del parametro ' ,self.linea)
if self.funcion == "COS":
valor = math.cos(nodoSyn1.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
if self.funcion == "COSD":
rads = math.cos(nodoSyn1.val)
grados = (rads * 180/math.pi)
return ExpresionNumero(grados,self.getTipo(grados),self.linea)
if self.funcion == "COT":
tangente=math.tan(nodoSyn1.val)
if tangente == 0:
return ErrorReport('semantico', 'Error en COT por el valor del parametro ' ,self.linea)
cot = 1 / tangente
return ExpresionNumero(cot,self.getTipo(cot),self.linea)
if self.funcion == "COTD":
tangente=math.tan(nodoSyn1.val)
if tangente == 0:
return ErrorReport('semantico', 'Error en COTD por el valor del parametro ' ,self.linea)
cot =math.degrees(1 / tangente)
return ExpresionNumero(cot,self.getTipo(cot),self.linea)
if self.funcion == "SIN":
radianes=math.sin(nodoSyn1.val)
return ExpresionNumero(radianes,self.getTipo(radianes),self.linea)
if self.funcion == "SIND":
grados=math.degrees(math.sin(nodoSyn1.val))
return ExpresionNumero(grados,self.getTipo(grados),self.linea)
if self.funcion == "TAN":
try:
radianes=math.tan(nodoSyn1.val)
return ExpresionNumero(radianes,self.getTipo(radianes),self.linea)
except:
return ErrorReport('semantico', 'Error en TAN por el valor del parametro ' ,self.linea)
if self.funcion == "TAND":
try:
grados=math.degrees(math.tan(nodoSyn1.val))
return ExpresionNumero(grados,self.getTipo(grados),self.linea)
except:
return ErrorReport('semantico', 'Error en TAND por el valor del parametro ' ,self.linea)
if self.funcion == "COSH":
try:
valor=math.cosh(nodoSyn1.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
except:
return ErrorReport('semantico', 'Error en COSH por el valor del parametro ' ,self.linea)
if self.funcion == "SINH":
try:
valor=math.sinh(nodoSyn1.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
except:
return ErrorReport('semantico', 'Error en SINH por el valor del parametro ' ,self.linea)
if self.funcion == "TANH":
try:
valor=math.tanh(nodoSyn1.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
except:
return ErrorReport('semantico', 'Error en TANH por el valor del parametro ' ,self.linea)
if self.funcion == "ACOSH":
if nodoSyn1.val < 1:
return ErrorReport('semantico', 'Error en ACOSH, el parametro debe de ser mayor o igual a 1 ' ,self.linea)
valor=math.acosh(nodoSyn1.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
if self.funcion == "ASINH":
valor=math.asinh(nodoSyn1.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
if self.funcion == "ATANH":
if nodoSyn1.val > 0.99 or nodoSyn1.val < -0.99:
return ErrorReport('semantico', 'Error en ATANH, el parametro debe estar entre 0.99 y -0.99 ' ,self.linea)
valor=math.atanh(nodoSyn1.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
#_________________________________ fin de trigonometricas
if self.funcion == "ABS":
valor=math.fabs(nodoSyn1.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
if self.funcion == "CBRT": #RAIZ CUBICA SOLO PARA ENTREROS
if (nodoSyn1.val % 1) == 0:
valor = raizCubica(nodoSyn1.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
else:
return ErrorReport('semantico', 'error CBRT solo recibe enteros, NO decimales' ,self.linea)
if self.funcion =="CEIL" or self.funcion == "CEILING":
valor = math.ceil(nodoSyn1.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
if self.funcion =="DEGREES":
valor = math.degrees(nodoSyn1.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
if self.funcion =="FACTORIAL":
valor = math.factorial(nodoSyn1.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
if self.funcion =="FLOOR":# POR SI VIENE EN UN INSERT
valor = math.floor(nodoSyn1.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
if self.funcion =="LN":
try:
valor = math.log(nodoSyn1.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
except :
return ErrorReport('semantico', 'error en el paramtro de LN' ,self.linea)
if self.funcion =="LOG":
try:
valor = math.log10(nodoSyn1.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
except :
return ErrorReport('semantico', 'error en el paramtro de LOG' ,self.linea)
if self.funcion =="EXP":
try:
valor = math.exp(nodoSyn1.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
except :
return ErrorReport('semantico', 'error en el paramtro de EXP' ,self.linea)
if self.funcion =="RADIANS":
valor = math.radians(nodoSyn1.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
if self.funcion =="ROUND":
valor = round(nodoSyn1.val)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
if self.funcion =="SIGN":
if nodoSyn1.val > 0:
valor = 1
return ExpresionNumero(valor,TIPO_DE_DATO.ENTERO,self.linea)
if nodoSyn1.val < 0:
valor = -1
return ExpresionNumero(valor,TIPO_DE_DATO.ENTERO,self.linea)
else:
return ErrorReport('semantico', 'error en funcion SING , EL 0 no tiene signo ' ,self.linea)
if self.funcion == "SQRT":
if (nodoSyn1.val) < 0 :
return ErrorReport('semantico', 'error SQRT solo recibe enteros POSITIVOS' ,self.linea)
if (nodoSyn1.val % 1) == 0:
valor = nodoSyn1.val**(1/2)
return ExpresionNumero(valor,self.getTipo(valor),self.linea)
else:
return ErrorReport('semantico', 'error SQRT solo recibe enteros, NO decimales' ,self.linea)
if self.funcion == "TRUNC":
valor = math.trunc(nodoSyn1.val)
return ExpresionNumero(valor,TIPO_DE_DATO.ENTERO,self.linea)
else:
return ErrorReport('semantico', 'error de tipo, se esperaba un ENTERO O DECIMAL' ,self.linea)
else:# SIN PARAMETROS
if self.funcion == 'PI':
return ExpresionNumero(math.pi,TIPO_DE_DATO.DECIMAL,self.linea)
elif self.funcion == "RANDOM":
valor = random.choice((1,0))
return ExpresionNumero(valor,TIPO_DE_DATO.ENTERO,self.linea)
def ejecutar(self, ts):#los que pueden venir en el select
if self.parametro1 != None and self.parametro2 != None:
if self.funcion == "EXTRACT":
self.parametro2 = str(self.parametro2).strip()
# AHORA REVISANDO SI TIENE COHERENCIA
try:# EL PARAMETRO 2 ES MI CADENA DATE , PARAMETRO 2 ESPERADO yyyy-mm-dd hh:mm:dd
objetodate = datetime.strptime(self.parametro2, '%Y-%m-%d %H:%M:%S')
except:
return ErrorReport('semantico', 'error Incoherencia con la cadena date' ,self.linea)
if self.parametro1 == "YEAR":
anio = str(objetodate.year)
return ExpresionNumero(int(anio), TIPO_DE_DATO.ENTERO,self.linea)
elif self.parametro1 == "MONTH":
mes = str(objetodate.month)
return ExpresionNumero(int(mes), TIPO_DE_DATO.ENTERO,self.linea)
elif self.parametro1 == "DAY":
dia = str(objetodate.day)
return ExpresionNumero(int(dia), TIPO_DE_DATO.ENTERO,self.linea)
elif self.parametro1 == "HOUR":
hora = str(objetodate.hour)
return ExpresionNumero(int(hora), TIPO_DE_DATO.ENTERO,self.linea)
elif self.parametro1 == "MINUTE":
minuto = str(objetodate.minute)
return ExpresionNumero(int(minuto), TIPO_DE_DATO.ENTERO,self.linea)
elif self.parametro1 == "SECOND":
seg = str(objetodate.second)
return ExpresionNumero(int(seg), TIPO_DE_DATO.ENTERO,self.linea)
elif self.funcion == "DATE_PART":
self.parametro2 = self.parametro2.lower().strip()
valores = {}
lexema = self.parametro2[0]
x = 1
while(x < len(self.parametro2)):
lexema += self.parametro2[x]
if self.parametro2[x] == "s" and self.parametro2[x-1] != " " :
lexema = lexema.strip()
key = ''
val = ''
posIniKey = 0
for i in range( len(lexema)):
if lexema[i] == ' ':
break
else:
val += lexema[i]
posIniKey = i
posIniKey +=1
while(posIniKey < len(lexema)):
key += lexema[posIniKey]
posIniKey+=1
lexema = ""
key = key.strip()
validacion = valores.get(key , 'ok')
if validacion == 'ok':
valores[key] = val
else:
return ErrorReport('sintactico', 'ERROR: la sintaxis de entrada no es válida para tipo interval' ,self.linea)
x+=1
if self.parametro1 == "HOUR" or self.parametro1 == "HOURS":
valor = valores.get('hours','NO_ESTA')
if valor == 'NO_ESTA':
return ErrorReport('semantico', 'solicitud de horas en Interaval y no fue especificado en la cadena' ,self.linea)
else:
return ExpresionNumero(int(valor), TIPO_DE_DATO.ENTERO,self.linea)
elif self.parametro1 == "MINUTE" or self.parametro1 == "MINUTE":
valor = valores.get('minutes','NO_ESTA')
if valor == 'NO_ESTA':
return ErrorReport('semantico', 'solicitud de minutos en Interaval y no fue especificado en la cadena' ,self.linea)
else:
return ExpresionNumero(int(valor), TIPO_DE_DATO.ENTERO,self.linea)
elif self.parametro1 == "SECOND" or self.parametro1 == "SECONDS":
valor = valores.get('seconds','NO_ESTA')
if valor == 'NO_ESTA':
return ErrorReport('semantico', 'solicitud de segundos en Interaval y no fue especificado en la cadena' ,self.linea)
else:
return ExpresionNumero(int(valor), TIPO_DE_DATO.ENTERO,self.linea)
else:
print("funcion desconocida")
elif self.parametro1 != None:
if self.funcion == 'TIMESTAMP':
hora_fecha_actual = str(datetime.now())[0:19]
return ExpresionCadena(hora_fecha_actual,TIPO_DE_DATO.CADENA,self.linea)
else:
print("funcion desconocida")
else:
if self.funcion == "NOW":
hora_fecha_actual = str(datetime.now())[0:19]
return ExpresionCadena(hora_fecha_actual,TIPO_DE_DATO.CADENA,self.linea)
elif self.funcion == "CURRENT_DATE":
fecha_actual = str(datetime.now())[0:10]
return ExpresionCadena(fecha_actual,TIPO_DE_DATO.CADENA,self.linea)
elif self.funcion == "CURRENT_TIME":
hora_actual = str(datetime.now())[11:19]
return ExpresionCadena(hora_actual,TIPO_DE_DATO.CADENA,self.linea)
elif self.funcion == "CURRENT_TIMESTAMP":
hora_fecha_actual = str(datetime.now())[0:19]
return ExpresionCadena(hora_fecha_actual,TIPO_DE_DATO.CADENA,self.linea)
def ejecutar(self, ts):
expizq = self.exp1.ejecutar(ts)
expder = self.exp2.ejecutar(ts)
# por si se quiere operar un error con una expresion buena , retorna de una el error
if isinstance(expizq , ErrorReport):
return expizq
if isinstance(expder , ErrorReport):
return expder
# la UNICA EXPRESION QUE DEBE DE OPERAR ES UN ID-tipo-entero o un tipoentero de la expresion sumerica
if not (isinstance(expizq , ExpresionNumero) or isinstance(expizq , ExpresionID)):
return ErrorReport('semantico', 'Error de tipo con el operando izquierdo' , self.linea )
if not (isinstance(expder , ExpresionNumero) or isinstance(expizq , ExpresionID)):
return ErrorReport('semantico', 'Error de tipo con el operando Derecho' , self.linea )
if self.operador == ">>" :
if expizq.tipo == TIPO_DE_DATO.ENTERO and expder.tipo == TIPO_DE_DATO.ENTERO:
return ExpresionNumero(expizq.val >> expder.val, TIPO_DE_DATO.ENTERO,self.linea)
elif expizq.tipo == TIPO_DE_DATO.DECIMAL:
return ErrorReport('semantico', 'Error de tipo con el operando izquierdo en OPERADOR >>' , self.linea )
elif expder.tipo == TIPO_DE_DATO.DECIMAL:
return ErrorReport('semantico', 'Error de tipo con el operando derecho en OPERADOR >>' , self.linea )
elif self.operador == "<<":
if expizq.tipo == TIPO_DE_DATO.ENTERO and expder.tipo == TIPO_DE_DATO.ENTERO:
return ExpresionNumero(expizq.val << expder.val, TIPO_DE_DATO.ENTERO,self.linea)
elif expizq.tipo == TIPO_DE_DATO.DECIMAL:
return ErrorReport('semantico', 'Error de tipo con el operando izquierdo en OPERADOR <<' , self.linea )
elif expder.tipo == TIPO_DE_DATO.DECIMAL:
return ErrorReport('semantico', 'Error de tipo con el operando derecho en OPERADOR <<' , self.linea )
elif self.operador == "#":
if expizq.tipo == TIPO_DE_DATO.ENTERO and expder.tipo == TIPO_DE_DATO.ENTERO:
try:
valor = expizq.val ^ expder.val
return ExpresionNumero(valor, TIPO_DE_DATO.ENTERO , self.linea)
except:
return ErrorReport('semantico', 'Error de Ejecucion con el OPERADOR | ', self.linea )
elif expizq.tipo == TIPO_DE_DATO.DECIMAL:
return ErrorReport('semantico', 'Error de tipo con el operando izquierdo en OPERADOR #' , self.linea )
elif expder.tipo == TIPO_DE_DATO.DECIMAL:
return ErrorReport('semantico', 'Error de tipo con el operando derecho en OPERADOR #' , self.linea )
else:
return 0
elif self.operador == "|":
if expizq.tipo == TIPO_DE_DATO.ENTERO and expder.tipo == TIPO_DE_DATO.ENTERO:
try:
valor = expizq.val | expder.val
return ExpresionNumero(valor, TIPO_DE_DATO.ENTERO , self.linea)
except:
return ErrorReport('semantico', 'Error de Ejecucion con el OPERADOR | ', self.linea )
elif expizq.tipo == TIPO_DE_DATO.DECIMAL:
return ErrorReport('semantico', 'Error de tipo con el operando izquierdo en OPERADOR |' , self.linea )
elif expder.tipo == TIPO_DE_DATO.DECIMAL:
return ErrorReport('semantico', 'Error de tipo con el operando derecho en OPERADOR |' , self.linea )
else:
return 0
elif self.operador == "&":
if expizq.tipo == TIPO_DE_DATO.ENTERO and expder.tipo == TIPO_DE_DATO.ENTERO:
try:
valor = expizq.val & expder.val
return ExpresionNumero(valor, TIPO_DE_DATO.ENTERO , self.linea)
except:
return ErrorReport('semantico', 'Error de Ejecucion con el OPERADOR | ', self.linea )
elif expizq.tipo == TIPO_DE_DATO.DECIMAL:
return ErrorReport('semantico', 'Error de tipo con el operando izquierdo en OPERADOR #' , self.linea )
elif expder.tipo == TIPO_DE_DATO.DECIMAL:
return ErrorReport('semantico', 'Error de tipo con el operando derecho en OPERADOR #' , self.linea )
else:
return ErrorReport('semantico', 'Error Operador desconocido' , self.linea )
def ejecutar(self, ts):
expizq = self.exp1.ejecutar(ts)
expder = self.exp2.ejecutar(ts)
# por si se quiere operar un error con una expresion buena , retorna de una el error
if isinstance(expizq, ErrorReport):
return expizq
if isinstance(expder, ErrorReport):
return expder
if self.operador == OPERACION_ARITMETICA.MAS:
if expizq.tipo == TIPO_DE_DATO.ENTERO and expder.tipo == TIPO_DE_DATO.ENTERO:
return ExpresionNumero(expizq.val + expder.val,
TIPO_DE_DATO.ENTERO, self.linea)
elif expizq.tipo == TIPO_DE_DATO.ENTERO and expder.tipo == TIPO_DE_DATO.DECIMAL:
return ExpresionNumero(expizq.val + expder.val,
TIPO_DE_DATO.DECIMAL, self.linea)
elif expizq.tipo == TIPO_DE_DATO.DECIMAL and expder.tipo == TIPO_DE_DATO.ENTERO:
return ExpresionNumero(expizq.val + expder.val,
TIPO_DE_DATO.DECIMAL, self.linea)
elif expizq.tipo == TIPO_DE_DATO.DECIMAL and expder.tipo == TIPO_DE_DATO.DECIMAL:
return ExpresionNumero(expizq.val + expder.val,
TIPO_DE_DATO.DECIMAL, self.linea)
else:
return 0
elif self.operador == OPERACION_ARITMETICA.MENOS:
if expizq.tipo == TIPO_DE_DATO.ENTERO and expder.tipo == TIPO_DE_DATO.ENTERO:
return ExpresionNumero(expizq.val - expder.val,
TIPO_DE_DATO.ENTERO, self.linea)
elif expizq.tipo == TIPO_DE_DATO.ENTERO and expder.tipo == TIPO_DE_DATO.DECIMAL:
return ExpresionNumero(expizq.val - expder.val,
TIPO_DE_DATO.DECIMAL, self.linea)
elif expizq.tipo == TIPO_DE_DATO.DECIMAL and expder.tipo == TIPO_DE_DATO.ENTERO:
return ExpresionNumero(expizq.val - expder.val,
TIPO_DE_DATO.DECIMAL, self.linea)
elif expizq.tipo == TIPO_DE_DATO.DECIMAL and expder.tipo == TIPO_DE_DATO.DECIMAL:
return ExpresionNumero(expizq.val - expder.val,
TIPO_DE_DATO.DECIMAL, self.linea)
else:
return 0
elif self.operador == OPERACION_ARITMETICA.POR:
if expizq.tipo == TIPO_DE_DATO.ENTERO and expder.tipo == TIPO_DE_DATO.ENTERO:
return ExpresionNumero(expizq.val * expder.val,
TIPO_DE_DATO.ENTERO, self.linea)
elif expizq.tipo == TIPO_DE_DATO.ENTERO and expder.tipo == TIPO_DE_DATO.DECIMAL:
return ExpresionNumero(expizq.val * expder.val,
TIPO_DE_DATO.DECIMAL, self.linea)
elif expizq.tipo == TIPO_DE_DATO.DECIMAL and expder.tipo == TIPO_DE_DATO.ENTERO:
return ExpresionNumero(expizq.val * expder.val,
TIPO_DE_DATO.DECIMAL, self.linea)
elif expizq.tipo == TIPO_DE_DATO.DECIMAL and expder.tipo == TIPO_DE_DATO.DECIMAL:
return ExpresionNumero(expizq.val * expder.val,
TIPO_DE_DATO.DECIMAL, self.linea)
else:
return 0
elif self.operador == OPERACION_ARITMETICA.DIVIDO:
if expder.val != 0:
if expizq.tipo == TIPO_DE_DATO.ENTERO and expder.tipo == TIPO_DE_DATO.ENTERO:
return ExpresionNumero(expizq.val / expder.val,
TIPO_DE_DATO.ENTERO, self.linea)
elif expizq.tipo == TIPO_DE_DATO.ENTERO and expder.tipo == TIPO_DE_DATO.DECIMAL:
return ExpresionNumero(expizq.val / expder.val,
TIPO_DE_DATO.DECIMAL, self.linea)
elif expizq.tipo == TIPO_DE_DATO.DECIMAL and expder.tipo == TIPO_DE_DATO.ENTERO:
return ExpresionNumero(expizq.val / expder.val,
TIPO_DE_DATO.DECIMAL, self.linea)
elif expizq.tipo == TIPO_DE_DATO.DECIMAL and expder.tipo == TIPO_DE_DATO.DECIMAL:
return ExpresionNumero(expizq.val / expder.val,
TIPO_DE_DATO.DECIMAL, self.linea)
else:
return 0
else:
return ErrorReport('semantico', 'No se puede dividir entre 0',
self.linea)
elif self.operador == OPERACION_ARITMETICA.MODULO:
if expizq.tipo == TIPO_DE_DATO.ENTERO and expder.tipo == TIPO_DE_DATO.ENTERO:
return ExpresionNumero(expizq.val % expder.val,
TIPO_DE_DATO.ENTERO, self.linea)
elif expizq.tipo == TIPO_DE_DATO.ENTERO and expder.tipo == TIPO_DE_DATO.DECIMAL:
return ExpresionNumero(expizq.val % expder.val,
TIPO_DE_DATO.DECIMAL, self.linea)
elif expizq.tipo == TIPO_DE_DATO.DECIMAL and expder.tipo == TIPO_DE_DATO.ENTERO:
return ExpresionNumero(expizq.val % expder.val,
TIPO_DE_DATO.DECIMAL, self.linea)
elif expizq.tipo == TIPO_DE_DATO.DECIMAL and expder.tipo == TIPO_DE_DATO.DECIMAL:
return ExpresionNumero(expizq.val % expder.val,
TIPO_DE_DATO.DECIMAL, self.linea)
else:
return 0
elif self.operador == OPERACION_ARITMETICA.EXPONENTE:
if expizq.tipo == TIPO_DE_DATO.ENTERO and expder.tipo == TIPO_DE_DATO.ENTERO:
return ExpresionNumero(expizq.val**expder.val,
TIPO_DE_DATO.ENTERO, self.linea)
elif expizq.tipo == TIPO_DE_DATO.ENTERO and expder.tipo == TIPO_DE_DATO.DECIMAL:
return ExpresionNumero(expizq.val**expder.val,
TIPO_DE_DATO.DECIMAL, self.linea)
elif expizq.tipo == TIPO_DE_DATO.DECIMAL and expder.tipo == TIPO_DE_DATO.ENTERO:
return ExpresionNumero(
int(expizq.val)**expder.val, TIPO_DE_DATO.ENTERO,
self.linea)
elif expizq.tipo == TIPO_DE_DATO.DECIMAL and expder.tipo == TIPO_DE_DATO.DECIMAL:
return ExpresionNumero(expizq.val**expder.val,
TIPO_DE_DATO.DECIMAL, self.linea)
else:
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 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)
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 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):
salida = None
if len(self.resultado.fuentes) > 1:
seleccion_columnas = []
for actual in self.columnas:
if isinstance(actual, ITEM_ALIAS):
if isinstance(actual.item, ExpresionID):
actual.item = actual.item.val
if actual.item.count('.') == 1:
seleccion_columnas.append(actual)
elif esAmbiguo(actual.item, self.resultado.columnas,
self.resultado.fuentes):
print("Error semántico, el identificador \"",
actual, "\" es ambiguo")
sqlTypeError = sqlErrors.sql_error_syntax_error_or_access_rule_violation.ambiguous_column
return ErrorReport(
'Semántico', "ERROR " + sqlTypeError.value +
": " + str(sqlTypeError.name), self.linea)
else:
actual = aclarar(actual.item,
self.resultado.columnas,
self.resultado.fuentes)
seleccion_columnas.append(actual)
elif isinstance(actual.item, Expresion):
seleccion_columnas.append(actual)
elif actual.item.count('.') == 1:
seleccion_columnas.append(actual)
elif actual.item == "*":
print(
"Error semántico, el operador \"*\" no es aplicable con alias."
)
sqlTypeError = sqlErrors.sql_error_syntax_error_or_access_rule_violation.datatype_mismatch
return ErrorReport(
'Semántico', "ERROR " + sqlTypeError.value + ": " +
str(sqlTypeError.name), self.linea)
else:
if esAmbiguo(actual, self.resultado.columnas,
self.resultado.fuentes):
print("Error semántico, el identificador \"",
actual, "\" es ambiguo")
sqlTypeError = sqlErrors.sql_error_syntax_error_or_access_rule_violation.ambiguous_column
return ErrorReport(
'Semántico', "ERROR " + sqlTypeError.value +
": " + str(sqlTypeError.name), self.linea)
else:
actual = aclarar(actual, self.resultado.columnas,
self.fuentes)
seleccion_columnas.append(actual)
elif isinstance(actual, Expresion):
seleccion_columnas.append(actual)
elif actual.count('.') == 1:
seleccion_columnas.append(actual)
elif actual == "*":
seleccion_columnas.append(actual)
else:
if esAmbiguo(actual, self.resultado.columnas,
self.resultado.fuentes):
print("Error semántico, el identificador \"", actual,
"\" es ambiguo")
sqlTypeError = sqlErrors.sql_error_syntax_error_or_access_rule_violation.ambiguous_column
return ErrorReport(
'Semántico', "ERROR " + sqlTypeError.value + ": " +
str(sqlTypeError.name), self.linea)
else:
actual = aclarar(actual, self.resultado.columnas,
self.fuentes)
seleccion_columnas.append(actual)
salida = self.resultado.obtenerColumnas(seleccion_columnas)
if salida == None:
print("Algo salió mal")
return salida
else:
seleccion_columnas = []
for actual in self.columnas:
if isinstance(actual, ITEM_ALIAS):
if isinstance(actual.item, ExpresionID):
actual.item = actual.item.val
seleccion_columnas.append(actual)
else:
seleccion_columnas.append(actual)
salida = self.resultado.obtenerColumnas(self.columnas)
return salida
def ejecutar(self, ts):
izquierdo = self.izq.ejecutar(ts)
derecho = self.der.ejecutar(ts)
if len(izquierdo.filas) == len(derecho.filas) and len(
izquierdo.columnas) == len(derecho.columnas):
if self.operador == COMBINE_QUERYS.UNION:
set1 = set(tuple(x) for x in izquierdo.filas)
set2 = set(tuple(x) for x in derecho.filas)
union = set1 | set2
lista_intermedia = list(union)
lista_final = []
for actual in lista_intermedia:
lista_final.append(list(actual))
nuevas_columnas = []
for actual in lista_final[0]:
nuevas_columnas.append("Union")
nuevas_fuentes = []
for actual in izquierdo.fuentes:
nuevas_fuentes.append(actual)
for actual in derecho.fuentes:
nuevas_fuentes.append(actual)
nuevo_clm = []
for actual in izquierdo.clm:
nuevo_clm.append(actual)
for actual in derecho.clm:
nuevo_clm.append(actual)
salida = matriz(nuevas_columnas, lista_final,
TABLA_TIPO.TABLAUNION, 'nueva tabla',
nuevas_fuentes, nuevo_clm)
salida.imprimirMatriz()
return salida
elif self.operador == COMBINE_QUERYS.INTERSECT:
set1 = set(tuple(x) for x in izquierdo.filas)
set2 = set(tuple(x) for x in derecho.filas)
union = set1 & set2
lista_intermedia = list(union)
lista_final = []
for actual in lista_intermedia:
lista_final.append(list(actual))
nuevas_columnas = []
if len(lista_final) > 0:
for actual in lista_final[0]:
nuevas_columnas.append("Intersect")
nuevas_fuentes = []
for actual in izquierdo.fuentes:
nuevas_fuentes.append(actual)
for actual in derecho.fuentes:
nuevas_fuentes.append(actual)
nuevo_clm = []
for actual in izquierdo.clm:
nuevo_clm.append(actual)
for actual in derecho.clm:
nuevo_clm.append(actual)
salida = matriz(nuevas_columnas, lista_final,
TABLA_TIPO.TABLAINTERSECCION, 'nueva tabla',
nuevas_fuentes, nuevo_clm)
salida.imprimirMatriz()
return salida
elif self.operador == COMBINE_QUERYS.EXCEPT:
set1 = set(tuple(x) for x in izquierdo.filas)
set2 = set(tuple(x) for x in derecho.filas)
union = set1 - set2
lista_intermedia = list(union)
lista_final = []
for actual in lista_intermedia:
lista_final.append(list(actual))
nuevas_columnas = []
for actual in lista_final[0]:
nuevas_columnas.append("Except")
nuevas_fuentes = []
for actual in izquierdo.fuentes:
nuevas_fuentes.append(actual)
for actual in derecho.fuentes:
nuevas_fuentes.append(actual)
nuevo_clm = []
for actual in izquierdo.clm:
nuevo_clm.append(actual)
for actual in derecho.clm:
nuevo_clm.append(actual)
salida = matriz(nuevas_columnas, lista_final,
TABLA_TIPO.TABLAEXCEPT, 'nueva tabla',
nuevas_fuentes, nuevo_clm)
salida.imprimirMatriz()
return salida
else:
print(
"Error semántico, el número de filas de los operandos es diferente."
)
sqlTypeError = sqlErrors.sql_error_data_exception.invalid_parameter_value
return ErrorReport(
'Semántico',
"ERROR " + sqlTypeError.value + ": " + str(sqlTypeError.name),
self.linea)
def obtenerColumnas(self, ids: list):
error = False
resultante = []
flag = True
columnas_resultantes = []
for actual in ids:
if isinstance(actual, ITEM_ALIAS):
if isinstance(actual.item, Expresion):
ColumnaCompleta = []
MinitablaSimbolos = []
filas = self.filas
columnas = self.columnas
i = 0
while (i < len(filas)):
indiceColumna = 0
while (indiceColumna < len(columnas)):
if len(self.fuentes) == 1:
MinitablaSimbolos.append({
'id':
columnas[indiceColumna],
'val':
filas[i][indiceColumna],
'tipo':
self.clm[quitarRef(
columnas[indiceColumna])]['Type']
})
else:
MinitablaSimbolos.append({
'id':
columnas[indiceColumna],
'val':
filas[i][indiceColumna],
'tipo':
self.clm[obtenerIndice(
self.fuentes,
obtenerRef(columnas[indiceColumna]))]
[quitarRef(
columnas[indiceColumna])]['Type']
})
indiceColumna += 1
tupla = TuplaCompleta(MinitablaSimbolos)
casillaResultante = actual.item.ejecutar(tupla)
if isinstance(casillaResultante, ErrorReport):
print(casillaResultante.description)
ColumnaCompleta.append(casillaResultante.val)
MinitablaSimbolos.clear()
i += 1
if flag:
for k in ColumnaCompleta:
nuevaColumna = []
nuevaColumna.append(k)
resultante.append(nuevaColumna)
flag = False
columnas_resultantes.append(actual.alias)
else:
h = 0
for j in resultante:
resultante[h].append(ColumnaCompleta[h])
h += 1
flag = False
columnas_resultantes.append(actual.alias)
elif self.columnas.__contains__(
self.nombre + "." +
actual.item) and self.tipo == TABLA_TIPO.UNICA:
i = 0
for columna in self.columnas:
if columna == self.nombre + "." + actual.item:
break
else:
i += 1
j = 0
for fila in self.filas:
if flag:
nuevaColumna = []
nuevaColumna.append(fila[i])
resultante.append(nuevaColumna)
else:
resultante[j].append(fila[i])
j += 1
flag = False
columnas_resultantes.append(actual.alias)
else:
i = 0
bandera = False
for columna in self.columnas:
if columna == actual.item:
bandera = True
break
else:
i += 1
if bandera:
j = 0
for fila in self.filas:
if flag:
nuevaColumna = []
nuevaColumna.append(fila[i])
resultante.append(nuevaColumna)
else:
resultante[j].append(fila[i])
j += 1
flag = False
columnas_resultantes.append(actual.alias)
else:
print(
"Error semántico, la columna: \" ", actual.item,
" \" no se encuentra o su referencia es ambigua.")
error = True
sqlTypeError = sqlErrors.sql_error_fdw_error.fdw_column_name_not_found
return ErrorReport(
'Semántico', "ERROR " + sqlTypeError.value + ": " +
str(sqlTypeError.name), self.linea)
else:
if isinstance(actual, Expresion):
ColumnaCompleta = []
MinitablaSimbolos = []
filas = self.filas
columnas = self.columnas
i = 0
while (i < len(filas)):
indiceColumna = 0
while (indiceColumna < len(columnas)):
if len(self.fuentes) == 1:
MinitablaSimbolos.append({
'id':
columnas[indiceColumna],
'val':
filas[i][indiceColumna],
'tipo':
self.clm[quitarRef(
columnas[indiceColumna])]['Type']
})
else:
MinitablaSimbolos.append({
'id':
columnas[indiceColumna],
'val':
filas[i][indiceColumna],
'tipo':
self.clm[obtenerIndice(
self.fuentes,
obtenerRef(columnas[indiceColumna]))]
[quitarRef(
columnas[indiceColumna])]['Type']
})
indiceColumna += 1
tupla = TuplaCompleta(MinitablaSimbolos)
casillaResultante = actual.ejecutar(tupla)
if isinstance(casillaResultante, ErrorReport):
print(casillaResultante.description)
ColumnaCompleta.append(casillaResultante.val)
MinitablaSimbolos.clear()
i += 1
if flag:
for k in ColumnaCompleta:
nuevaColumna = []
nuevaColumna.append(k)
resultante.append(nuevaColumna)
flag = False
columnas_resultantes.append('exp')
else:
h = 0
for j in resultante:
resultante[h].append(ColumnaCompleta[h])
h += 1
flag = False
columnas_resultantes.append('exp')
elif actual == "*":
j = 0
for fila in self.filas:
if flag:
nuevaColumna = []
for k in fila:
nuevaColumna.append(k)
resultante.append(nuevaColumna)
else:
for k in fila:
resultante[j].append(k)
j += 1
for c in self.columnas:
columnas_resultantes.append(c)
flag = False
elif self.columnas.__contains__(
self.nombre + "." +
actual) and self.tipo == TABLA_TIPO.UNICA:
i = 0
for columna in self.columnas:
if columna == self.nombre + "." + actual:
break
else:
i += 1
j = 0
for fila in self.filas:
if flag:
nuevaColumna = []
nuevaColumna.append(fila[i])
resultante.append(nuevaColumna)
else:
resultante[j].append(fila[i])
j += 1
flag = False
columnas_resultantes.append(actual)
else:
i = 0
bandera = False
for columna in self.columnas:
if columna == actual:
bandera = True
break
else:
i += 1
if bandera:
j = 0
for fila in self.filas:
if flag:
nuevaColumna = []
nuevaColumna.append(fila[i])
resultante.append(nuevaColumna)
else:
resultante[j].append(fila[i])
j += 1
flag = False
columnas_resultantes.append(actual)
else:
print(
"Error semántico, la columna: \" ", actual,
" \" no se encuentra o su referencia es ambigua.")
error = True
sqlTypeError = sqlErrors.sql_error_fdw_error.fdw_column_name_not_found
return ErrorReport(
'Semántico', "ERROR " + sqlTypeError.value + ": " +
str(sqlTypeError.name), self.linea)
if not error:
salida = matriz(columnas_resultantes, resultante,
TABLA_TIPO.SELECCIONADA, "nueva tabla",
self.fuentes, self.clm)
else:
salida = None
return salida