def crearConstraintCheck(self, parent, listaids, columns, checkers):
# Pasos para crear un Check
# Siempre se recibe un nodo OPCIONALES_ATRIBUTO_CHECK
# 1. Recorrer los nodos hijos.
# 2. Si hay un nodo OPCIONAL_CONSTRAINT se encuentra el nombre de la constraint check (opcional)
# 3. Si hay un nodo LISTA_EXP se encontrarán los id's que serán los ids que hay que buscar.
# 4. Dentro de la lista de ID's verificar que todos vengan en la lista de columnas
# 5. Si todas están, insertar.
nombreCheck = ""
for hijo in parent.hijos:
if hijo.nombreNodo == "OPCIONAL_CONSTRAINT":
nombreCheck = hijo.hijos[0].valor.upper()
elif hijo.nombreNodo == "LISTA_EXP":
for exp in hijo.hijos:
nuevaConstraint = Check()
nuevaConstraint.name = nombreCheck.upper()
nuevaConstraint.checkExp = self.construirExpresionJSON(
exp, listaids)
checkers.append(nuevaConstraint)
for ident in listaids:
if not self.buscarColumna(columns, ident):
respError = Error(
3, "No se encuentra la columna " + ident + " en la tabla",
-1)
responseMessage = Response("20000", respError)
return responseMessage
responseMessage = Response("00000",
"Se creo la constraint correctamente")
return responseMessage
def execute(self, parent, enviroment):
# OBTENER TABLAS CAMPOS VALORES
for hijo in parent.hijos:
if "TABLE" == hijo.nombreNodo:
self.name = hijo.valor
elif "ADD" == hijo.nombreNodo:
nuevaCol = Column()
self.addCol = 1
for h in hijo.hijos:
if "COLUMN" == h.nombreNodo:
nuevaCol.name = h.valor
else:
print('none ', h.nombreNodo)
nuevaCol.type = nuevaCol.asignarTipoCol(
h.nombreNodo.upper())
self.columnas.append(nuevaCol)
# INFO DB ACTUAL
with open('src/Config/Config.json') as file:
config = json.load(file)
if config['databaseIndex'] == None:
err_resp = Error(3, "No se ha seleccionado ninguna base de datos.",
-1)
resp = Response("42P12", err_resp)
return resp
listTables = showTables(config['databaseIndex'].upper())
useDB = config['databaseIndex'].upper()
if not (self.name.upper() in listTables):
err_resp = Error(3, "No existe la tabla en la DB.", -1)
resp = Response("42P12", err_resp)
return resp
# INFO A INSERTAR
print('DB ACTUAL', useDB)
print('Tabla', self.name)
# VALIDACIONES
if (self.addCol == 1):
# INSERTAR NUEVA COL
res = alterAddColumn(useDB, self.name.upper(), 1)
res = 0
print('insert col :', res)
if res == 0:
for columna in self.columnas:
tc.CreateColumn(useDB, self.name.upper(), columna)
resp = Response(
"00000",
"Se agrego la columna a la tabla " + self.name.upper())
else:
resp = Response(
"42P12",
"No se agrego la columna a la tabla " + self.name.upper())
self.addCol = 0
return resp
def execute(self, parent, enviroment):
# Siempre se va a recibir un CREATE_TABLE como nodo
# 1. Recorrer y ejecutar cada uno de los nodos.
# 2. Si llegó hasta el final, quiere decir que no hay ningun error
# 3. Verificar que esté seleccionada una base de datos, si lo está crear la tabla.
# 4. Verificar que no exista la tabla en la base de datos seleccionada
for hijo in parent.hijos:
if hijo.nombreNodo == "IDENTIFICADOR":
self.name = hijo.valor.upper()
elif hijo.nombreNodo == "ATRIBUTO_COLUMNA":
nuevaColumna = Column()
resp = nuevaColumna.crearColumna(hijo, self.checkers,
self.listaids)
if resp.code != "00000":
return resp
self.columnas.append(nuevaColumna)
elif hijo.nombreNodo == "ATRIBUTO_PRIMARY_KEY":
nuevaConstraint = Constraint()
resp = nuevaConstraint.crearConstraintPrimary(
hijo, self.columnas)
if resp.code != "00000":
return resp
elif hijo.nombreNodo == "ATRIBUTO_REFERENCES":
nuevaConstraint = Constraint()
resp = nuevaConstraint.crearConstraintReferences(
hijo, self.columnas)
if resp.code != "00000":
return resp
self.listaReferences.append(nuevaConstraint)
elif hijo.nombreNodo == "OPCIONALES_ATRIBUTO_CHECK":
nuevaConstraint = Constraint()
resp = nuevaConstraint.crearConstraintCheck(
hijo, self.listaids, self.columnas, self.checkers)
if resp.code != "00000":
return resp
with open('src/Config/Config.json') as file:
config = json.load(file)
if config['databaseIndex'] == None:
err_resp = Error(3, "No se ha seleccionado ninguna base de datos.",
-1)
resp = Response("42P12", err_resp)
return resp
listTables = showTables(config['databaseIndex'].upper())
if self.name.upper() in listTables:
err_resp = Error(3, "Ya existe la tabla.", -1)
resp = Response("42P12", err_resp)
return resp
createTable(config['databaseIndex'].upper(), self.name.upper(),
len(self.columnas))
tc.createTable(config['databaseIndex'].upper(), self.name.upper(),
self.columnas)
resp = Response("00000", "Se creó la tabla")
return resp
def ejec_atributo_primary(self):
# Verifica que no sea una primary key ya, en caso de que haya una, va a retornar un error
if self.isPrimary == None:
self.isPrimary = True
resp = Response("00000", "Se agrego la PK exitosamente")
return resp
respError = Error(
3, "Ya se declaro esta columna como llave primaria " + self.name,
-1)
responseMessage = Response("20000", respError)
return responseMessage
def ejec_atributo_unique(self, parent):
# Siempre se recibirá un nodo
if self.isUnique != None:
respError = Error(
3, "Ya se declaro esta columna como unique " + self.name, -1)
responseMessage = Response("20000", respError)
return responseMessage
self.isUnique = True
for hijo in parent.hijos:
if hijo.nombreNodo == "OPCIONAL_CONSTRAINT":
self.uniqueName = hijo.valor.upper()
responseMessage = Response("00000", "Se agrego unique correctamente")
return responseMessage
def crearColumna(self, parent, checkers, listaids):
# Pasos para crear una columna.
# Siempre se va a recibir el nodo que contenga el nombre ATRIBUTO_COLUMNA
# 1. Verificar cada uno de los nodos.
# 1.1 El nodo que tenga como nombre IDENTIFICADOR, será el nombre de la columna,
# 1.2 El nodo que tenga como nombre TIPO_DECLARACION, será el tipo de la columna
# 1.3 El nodo que tenga como nombre OPCIONALES_ATRIBUTO_PRIMARY, será el que indique que es una llave primaria
# 1.4 El nodo que tenga como nombre OPCIONALES_ATRIBUTO_UNIQUE, será el que indique que es un campo unique
# 1.5 El nodo que tenga como nombre OPCIONALES_ATRIBUTO_REFERENCES, será el que indique que es una referencia.
# 1.6 El nodo que tenga como nombre OPCIONALES_ATRIBUTO_CHECK, será el que indique que es una check.
# Ejecuta 1.1
self.name = parent.hijos[0].valor.upper()
# Ejecuta 1.2
self.tipo_declaracion(parent.hijos[1])
# Ejecuta 1.3 -> 1.6
for hijo in parent.hijos:
if hijo.nombreNodo == "OPCIONALES_ATRIBUTO_PRIMARY":
response = self.ejec_atributo_primary()
if response.code != "00000":
return response
elif hijo.nombreNodo == "OPCIONALES_ATRIBUTO_UNIQUE":
response = self.ejec_atributo_unique(hijo)
if response.code != "00000":
return response
elif hijo.nombreNodo == "OPCIONALES_ATRIBUTO_REFERENCES":
response = self.ejec_atributo_references(hijo)
if response.code != "00000":
return response
elif hijo.nombreNodo == "OPCIONALES_ATRIBUTO_CHECK":
response = self.ejec_atributo_check(hijo, checkers, listaids)
if response.code != "00000":
return response
resp = Response("00000", "Se creo la columna exitosamente")
return resp
def ejec_atributo_references(self, parent):
# Siempre se va a recibir un nodo con el nombre OPCIONALES_ATRIBUTO_REFERENCES
# Solo tendrá un hijo y es el nombre de la tabla.
# Se debe de buscar que la columna tenga el mismo nombre y se debe de verificar
# que tenga el mismo tipo de dato
if self.buscarColumnaValida(self.name, self.specificType,
parent.hijos[0].nombreNodo):
self.referencesTable = parent.hijos[0].nombreNodo
self.referenceColumn = self.name.upper()
responseMessage = Response(
"00000", "Se agrego la referencia correctamente")
return responseMessage
respError = Error(
3,
"No existe una columna o tabla relacionada para la referencia " +
self.name + " en " + parent.hijos[0].nombreNodo, -1)
responseMessage = Response("20000", respError)
return responseMessage
def crearConstraintPrimary(self, parent, columns):
# Pasos para construir la llave Primaria
# 1. Siempre se va a recibir un nodo ATRIBUTO_PRIMARY_KEY
# 2. Se debe de recorrer cada uno de los nodos de este para asociar cada columna a
# un identificador.
# 3. Se inserta cada uno de los ids en la listaColumnas.
# 4. Se busca cada uno de los id's de listaColumnas en columns para colocar
# las llaves primarias que sean necesarias.
for hijo in parent.hijos:
if hijo.nombreNodo == "IDENTIFICADOR":
self.listaColumnas.append(hijo.valor)
for col in self.listaColumnas:
if not self.buscarColumna(columns, col):
respError = Error(3, "No se encuentra la columna " + col, -1)
responseMessage = Response("20000", respError)
return responseMessage
responseMessage = Response("00000", "Se creo la llave primaria")
return responseMessage
def get_response(self, question):
try:
# Accessa o primeiro dicionario de trainamento
return self.dictionary_1[question]
except:
try:
# Accessa o segundo dicionario de trainamento
return self.dictionary_2[question]
except:
try:
# Accessa o terceiro dicionario de trainamento
return self.dictionary_3[question]
except:
try:
# Accessa o quarto dicionario de trainamento
return self.dictionary_4[question]
except:
try:
# Accessa o quinto dicionario de trainamento
return self.dictionary_5[question]
except:
try:
# Accessa o segundo dicionario de trainamento
return self.dictionary_6[question]
except:
try:
# Accessa o setimo dicionario de trainamento
return self.dictionary_7[question]
except:
try:
# Accessa o oitavo dicionario de trainamento
return self.dictionary_8[question]
except:
try:
# Accessa o nono dicionario de trainamento
return self.dictionary_9[question]
except:
try:
# Accessa o decimo dicionario de trainamento
return self.dictionary_10[
question]
except:
# Quando todos os 10 dicionarios resultarem em KeyError, o chatbot accessa a Class de Resposta
if Str(question).indexOf(
"what"):
if Str(question).indexOf(
"your"):
if Str(question
).indexOf(
"name"):
return self.bot_name
return Response().response(
question)
def procesarIdentificadorTable(self, parent, alias=None):
# Siempre se recibe un nodo Identificador
nuevaTabla = TableResult()
nuevaTabla.nombre = parent.valor
nuevaTabla.alias = parent.valor if alias == None else alias
columnas = self.obtenerColumnasDictionary(parent.valor)
if not columnas:
return Response("22222", "No existe la tabla referenciada")
nuevaTabla.columnas = columnas
self.listaColumnasWhere.append(columnas)
nuevaTabla.data = extractTable(self.dbUse, parent.valor.upper())
nuevaTabla.noFilas = len(nuevaTabla.data)
self.listaTablas.append(nuevaTabla)
def ejec_atributo_check(self, parent, listaChecker, listaids):
# Siempre se recibirá un nodo OPCIONALES_ATRIBUTO_CHECK
# 1. Recorrer cada uno de los hijos buscando el nombre de la constraint.
# 2. Si se encuentra el nodo OPCIONAL_CONSTRAINT tiene un alias en el hijo 0
# 3. Si se encuentra el nodo E, se tiene que construir la expresion JSON.
nuevoCheck = Check()
for hijo in parent.hijos:
if hijo.nombreNodo == "OPCIONAL_CONSTRAINT":
nuevoCheck.name = hijo.hijos[0].valor.upper()
elif hijo.nombreNodo == "E":
nuevoCheck.checkExp = self.construirExpresionJSON(
hijo, listaids)
listaChecker.append(nuevoCheck)
resp = Response("00000", "Se agrego la constraint exitosamente")
return resp
def execute(self, parent, enviroment):
# OBTENER TABLAS CAMPOS VALORES
for hijo in parent.hijos:
if "Tabla" == hijo.nombreNodo:
self.name = hijo.valor
elif "L_COLUMN" == hijo.nombreNodo:
self.traeCols = 1
for h in hijo.hijos:
self.columnas.append(h)
elif "PARAM_INSERT" == hijo.nombreNodo:
for h1 in hijo.hijos:
self.values.append(h1)
# INFO DB ACTUAL
with open('src/Config/Config.json') as file:
config = json.load(file)
useDB = config['databaseIndex'].upper()
if config['databaseIndex'] == None:
err_resp = Error(3, "No se ha seleccionado ninguna base de datos.",
-1)
resp = Response("42P12", err_resp)
return resp
listTables = showTables(config['databaseIndex'].upper())
if not (self.name.upper() in listTables):
err_resp = Error(3, "No existe la tabla en la DB.", -1)
resp = Response("42P12", err_resp)
return resp
# INFO A INSERTAR
columnasI = []
valoresI = []
l_col = tc.return_columnsObject(useDB, self.name.upper())
for h in self.columnas:
columnasI.append(h.valor)
for h in self.values:
valoresI.append(h.valor)
print('DB ACTUAL', useDB)
print('Tabla', self.name)
print('Values', valoresI)
print('Columns', columnasI)
print('L_col', len(l_col))
valores_insertar = []
contador = 0
# VALIDACIONES
if self.traeCols == 1:
# Mismo # de cols y valores
if not (len(self.values) == len(self.columnas)):
print("no tiene la misma cantidad de columnas y valores")
err_resp = Error(
3,
"No tiene la misma cantidad de columnas a insertar y valores a insertar.",
-1)
resp = Response("42P12", err_resp)
return resp
# cols a insertar <= cols existentes
if not (len(l_col) >= len(self.columnas)):
print(
"El numero de columnas a insertar es a mayor a las existentes"
)
err_resp = Error(
3,
"El numero de columnas a insertar es a mayor a las existentes.",
-1)
resp = Response("42P12", err_resp)
return resp
# cols existentes >= valores a insertar
if not (len(l_col) >= len(self.values)):
print(
"El numero de valores a insertar es mayor a la cantidad de columnas existentes"
)
err_resp = Error(
3,
"El numero de valores a insertar es mayor a la cantidad de columnas existentes.",
-1)
resp = Response("42P12", err_resp)
return resp
for h in l_col:
tmp_col_actual = Column()
if len(columnasI) > contador:
tmp_col_insert = columnasI[contador].upper()
tmp_valor = valoresI[contador]
tmp_col_actual = h
# Validar que sea la misma columna
if tmp_col_actual.name == tmp_col_insert:
contador = contador + 1
# Validar tipo de datos
if self.validar_tipo(tmp_col_actual.type, tmp_valor) == 1:
valores_insertar.append(tmp_valor)
else:
print("El tipo de dato no coincide con la variable " +
tmp_valor)
err_resp = Error(
3, "El tipo de dato no coincide con la variable " +
tmp_valor, -1)
resp = Response("42P12", err_resp)
return resp
else:
valores_insertar.append(None)
# Solo vienes valores
else:
for h in l_col:
tmp_col_actual = Column()
tmp_col_actual = h
if not (contador == len(valoresI)):
tmp_valor = valoresI[contador]
# Validar tipo de datos
if self.validar_tipo(
tmp_col_actual.type,
tmp_valor) == 1 and contador < len(valoresI):
contador = contador + 1
valores_insertar.append(tmp_valor)
else:
valores_insertar.append(None)
if not (contador == len(valoresI)):
print("El tipo de dato no coincide con la variable ")
err_resp = Error(
3,
"Los valores a ingresar no coinciden con los valores de la tabla",
-1)
resp = Response("42P12", err_resp)
return resp
# INSERTAR
print('Se va a insertar', valores_insertar)
print('insert code :',
insert(useDB, self.name.upper(), valores_insertar))
resp = Response("00000", "Se inserto el valor en la tabla")
return resp
def execute(self, parent, enviroment=None):
global selectAgregate
selectAgregate.clear()
# Se verifican las variables, si esta seleccionada la base de datos
self.dbUse = self.verificarDBActiva()
if self.dbUse == None:
return Response("22222", "La base de datos no está seleccionada")
# Se recibe como parámetro en nodo SENTENCIA_SELECT
# Se visita al nodo TABLE_EXPRESION
self.procesarTableExpresion(parent.hijos[1])
stringName = ""
for tab in self.listaTablas:
stringName = stringName + tab.alias
if len(parent.hijos) == 3:
listaDataTemp = []
listaColumnasTemp = []
listaTablasTemp = []
for tabla in self.listaTablas:
listaDataTemp.append(tabla.data)
for columna in tabla.columnas:
listaColumnasTemp.append(columna)
listaTablasTemp.append([tabla.nombre, tabla.alias])
#print(listaDataTemp)
#print(listaColumnasTemp)
#print(listaTablasTemp)
#print(self.tableResultData)
nuevoFiltro = Where()
resultado = nuevoFiltro.execute(parent.hijos[2], listaDataTemp,
listaTablasTemp,
self.listaColumnasWhere,
self.tableResultData)
self.ejecutarSelect(parent.hijos[0])
#region Agregacion
dataTemporalAgregacion = []
dataTemporalGlobal = []
#Inicia el pocedimiento de funciones de agregación
hayNoAgregate = False
hayAgregate = False
if len(selectAgregate) >= len(self.encabezadoRetorno):
for i in range(0, len(self.encabezadoRetorno)):
#selectAgregate
if selectAgregate[i] == "AVG":
hayAgregate = True
dataTemporalAgregacion.append(
self.realizarAVG(i, self.tablaRetorno))
elif selectAgregate[i] == "COUNT":
hayAgregate = True
dataTemporalAgregacion.append(
self.realizarCount(i, self.tablaRetorno))
elif selectAgregate[i] == "MAX":
hayAgregate = True
dataTemporalAgregacion.append(
self.realizarMax(i, self.tablaRetorno))
elif selectAgregate[i] == "MIN":
hayAgregate = True
dataTemporalAgregacion.append(
self.realizarMin(i, self.tablaRetorno))
elif selectAgregate[i] == "SUM":
hayAgregate = True
dataTemporalAgregacion.append(
self.realizarSum(i, self.tablaRetorno))
elif selectAgregate[i] == None:
hayNoAgregate = True
if hayAgregate and not hayNoAgregate:
dataTemporalGlobal.append(dataTemporalAgregacion)
else:
dataTemporalGlobal = self.tablaRetorno
#endregion
tablaResultado = TableResult()
tablaResultado.nombre = stringName
tablaResultado.alias = stringName
tablaResultado.columnas = self.encabezadoRetorno
tablaResultado.noColumnas = len(self.encabezadoRetorno)
tablaResultado.data = dataTemporalGlobal
tablaResultado.noFilas = len(dataTemporalGlobal)
tablaResultado.listaEncabezados = self.encabezadoRetorno
return tablaResultado
def crearConstraintReferences(self, parent, columns):
#Pasos para crear una Referencia
# 1. Siempre se va a encontrar un nodo con nombre ATRIBUTO_REFERENCES
# 2. Se debe de recorrer cada uno de los nodos.
# 3. Se crea la lista colOrigen para insertar las columnas de la tabla original ATRIBUTO_FOREIGN_KEY
# 4. Se crea la lista colDestino para insertar las columnas de referencia LISTA_IDS
# 5. Se busca la tabla a la que se hace referencia y se extraen las columnas
# 6. Se buscan las columnas de colOrigen en las columnas ya hechas en la misma tabla
# 7. Se buscan las columnas de colDestino en las columnas de la tabla de referencia
# 8. Si colOrigen y colDestino tienen la misma longitud, se puede realizar
# 9. Si colOrigen es vacío, se puede asignar
# 10. Si no coinciden las longitudes, no se puede realizar la referencia.
# Paso 1 - 4
colOrigen = []
colDestino = []
tablaDestino = ""
for hijo in parent.hijos:
if hijo.nombreNodo == "ATRIBUTO_FOREIGN_KEY":
for col in hijo.hijos[0].hijos:
colOrigen.append(col.valor.upper())
elif hijo.nombreNodo == "IDENTIFICADOR":
tablaDestino = hijo.valor
elif hijo.nombreNodo == "LISTA_IDS":
for col in hijo.hijos:
colDestino.append(col.valor.upper())
# Paso 5
if not self.buscarTablaEnDB(tablaDestino):
respError = Error(3, "No se encuentra la tabla " + tablaDestino,
-1)
responseMessage = Response("20000", respError)
return responseMessage
listaColumnas = self.extraerColumnasDeTabla(tablaDestino)
# Paso 6 Esto es opcional, no siempre va a venir
for col in colOrigen:
if not self.buscarColumna(columns, col):
respError = Error(3,
"No se encuentra la columna referida " + col,
-1)
responseMessage = Response("20000", respError)
return responseMessage
# Paso 7 Esto si es obligatorio.
for col in colDestino:
if not self.buscarColumna(listaColumnas, col):
respError = Error(3,
"No se encuentra la columna referida " + col,
-1)
responseMessage = Response("20000", respError)
return responseMessage
# Paso 8 - 10
if len(colOrigen) == 0:
colOrigen = colDestino
elif len(colOrigen) != len(colDestino):
respError = Error(
3, "El numero de columnas referenciadas no coinciden", -1)
responseMessage = Response("20000", respError)
return responseMessage
for col in columns:
if col.name.upper() in colOrigen:
col.referenceColumn = colOrigen.index(col.name.upper())
col.referenceTable = tablaDestino.upper()
responseMessage = Response("00000", "Se crearon las referencias")
return responseMessage
def execute(self, parent, enviroment):
# OBTENER TABLAS CAMPOS VALORES
for hijo in parent.hijos:
if "TABLE" == hijo.nombreNodo:
self.name = hijo.valor
elif "LISTA_UPDATE" == hijo.nombreNodo:
self.traeCols = 1
for h in hijo.hijos:
for i in h.hijos:
if "COL" == i.nombreNodo:
self.columnas.append(i)
else:
self.values.append(i)
# INFO DB ACTUAL
with open('src/Config/Config.json') as file:
config = json.load(file)
if config['databaseIndex'] == None:
err_resp = Error(3, "No se ha seleccionado ninguna base de datos.",
-1)
resp = Response("42P12", err_resp)
return resp
useDB = config['databaseIndex'].upper()
listTables = showTables(useDB)
if not (self.name.upper() in listTables):
err_resp = Error(3, "No existe la tabla en la DB.", -1)
resp = Response("42P12", err_resp)
return resp
# INFO A INSERTAR
tablename = self.name.upper()
print('DB ACTUAL', useDB)
print('Tabla Update', tablename)
columnasI = []
valoresI = []
val_update = {}
l_col = tc.return_columnsObject(useDB, tablename)
for h in self.columnas:
columnasI.append(h.valor.upper())
for h in self.values:
valoresI.append(h.valor)
contador = 0
contador2 = 0
for h in l_col:
for j in columnasI:
if h.name.upper() == j:
val_update[contador] = valoresI[contador2]
contador2 = contador2 + 1
contador2 = 0
contador = contador + 1
# VALIDACIONES
if len(parent.hijos) < 4:
#Update sin where
res = update(useDB, tablename, val_update, ['0'])
print('update code: ', res)
if res == 0:
resp = Response("00000", "Se actualizo el valor en la tabla")
else:
err_resp = Error(3, "No se logro actualizar el valor", -1)
resp = Response("42P12", err_resp)
return resp
else:
#update con where
parent_node = parent.hijos[3]
raw_matrix = [extractTable(useDB, tablename)]
columnas = self.obtenerColumnasDictionary(useDB, tablename)
tablas = [[tablename, tablename]]
nuevoWhere = Where()
listaResult = nuevoWhere.execute(parent_node, raw_matrix, tablas,
columnas, None)
print('listaREsult ', listaResult)
res = ""
for elemento in listaResult:
if elemento[0] is True:
res = update(useDB, tablename, val_update,
[str(elemento[1])])
print('update code: ', res)
if res == 0:
resp = Response("00000", "Se actualizo el valor en la tabla")
else:
err_resp = Error(3, "No se logro actualizar el valor", -1)
resp = Response("42P12", err_resp)
return resp
