def ejecutar(self, ts): if len(self.fuentes) > 1: encabezados = [] lista = [] columns = [] nuevasFuentes = [] for tabla in self.fuentes: if isinstance(tabla, ITEM_ALIAS): tb = extractTable(DB_ACTUAL.name, tabla.item) lista.append(tb) clm = getColumns(DB_ACTUAL.name, tabla.item) columns.append(clm) for encabezado in clm: encabezados.append(tabla.alias + "." + encabezado) nuevasFuentes.append(tabla.alias) else: tb = extractTable(DB_ACTUAL.name, tabla) lista.append(tb) clm = getColumns(DB_ACTUAL.name, tabla) columns.append(clm) for encabezado in clm: encabezados.append(tabla + "." + encabezado) nuevasFuentes.append(tabla) tabla_fuente = productoCruz(lista) resultado = matriz(encabezados, tabla_fuente, TABLA_TIPO.PRODUCTO_CRUZ, "nueva tabla", nuevasFuentes, columns) return resultado else: if isinstance(self.fuentes[0], ITEM_ALIAS): encabezados = [] tb = extractTable(DB_ACTUAL.name, self.fuentes[0].item) clm = getColumns(DB_ACTUAL.name, self.fuentes[0].item) for encabezado in clm: encabezados.append(self.fuentes[0].alias + "." + encabezado) resultado = matriz(encabezados, tb, TABLA_TIPO.UNICA, self.fuentes[0].alias, [self.fuentes[0].alias], clm) return resultado else: encabezados = [] tb = extractTable(DB_ACTUAL.name, self.fuentes[0]) clm = getColumns(DB_ACTUAL.name, self.fuentes[0]) for encabezado in clm: encabezados.append(self.fuentes[0] + "." + encabezado) resultado = matriz(encabezados, tb, TABLA_TIPO.UNICA, self.fuentes[0], self.fuentes, clm) return resultado
def validarunique(self,entorno,tabla,namecolums,unique): encontrado=0 nocol=-1 if tabla != None: columnas=tabla.valor i=0 param=[] for columna in columnas: nombre = columna.nombre if namecolums == nombre: encontrado+=1 tipo=columna.tipo nocol=i nomtabla=tabla.nombre nomtabla=nomtabla.replace('_'+entorno.getDataBase(),'') continue i=i+1 if encontrado==1 and nocol>-1: datos=DBMS.extractTable(entorno.getDataBase(),nomtabla) if datos!= None: self.nombreres = nomtabla for i in range(0,len(datos)): dato=datos[i][nocol] param.append(dato) for val in param: #print("LIsta-->",val,'------',unique,"-----------") if(val==unique and val!='' ): return True return False
def ejecutar(self,ent:Entorno): tablas = [] result = [] self.encabezados = [] if self.nametable != None: tipo = self.nametable.tipo if tipo.tipo == 'identificador': nombre = self.nametable.getval(ent) self.ntabla = nombre tabla = ent.buscarSimbolo(nombre + "_" + ent.getDataBase()) if tabla != None: tablas.append(tabla) else: return "ERROR >> En la instrucción Delete, la tabla: "+self.ntabla+" NO EXISTE" if len(tablas) > 1: return "ERROR >> En la instrucción Delete, solo puede ingresar el nombre de una tabla" else: 'llenar resultado desde backend' real = tablas[0].nombre.replace('_' + ent.getDataBase(), '') result = DBMS.extractTable(ent.getDataBase(), real) # filtros if self.exps != None: result = self.wheredelete(ent, tablas) else: return "ERROR >> En la instrucción Delete la expresión es incorrecta" return self.resultdelete(result,self.ntabla,ent.getDataBase())
def ejecutar(self, ent: Entorno): dbActual = ent.getDataBase() result = [] if dbActual != None: tabla: Simbolo = ent.buscarSimbolo(self.tabla + "_" + dbActual) if tabla != None: 'obtengo tabla' real = tabla.nombre.replace('_' + ent.getDataBase(), '') result = DBMS.extractTable(ent.getDataBase(), real) columnas = tabla.valor 'lleno encabezado' for col in columnas: self.encabezado.append(col.nombre) for i in range(0, len(result)): resexp = self.resolver(self.where, ent, result, tabla, i) try: if resexp.valor: dic = {} 'busco la columna y le asigno el nuevo valor' for i in range(0, len(self.listaCampos)): nombrecol = self.listaCampos[i].columna expresion = self.listaCampos[i].exp contenido = expresion.getval(ent).valor for nocol in range(0, len(columnas)): if nombrecol == columnas[nocol].nombre: dic.update({nocol: contenido}) 'envio datos par update' llavePrim = [] for column in tabla.valor: prim: Simbolo = ent.buscarSimbolo( column.atributos.get('primary')) llavePrim = prim.valor break r = DBMS.update(dbActual, self.tabla, dic, llavePrim) if r == 0: variables.consola.insert( INSERT, 'Se ha actualizado un registro \n') except: reporteerrores.append( Lerrores( "Error Semantico", 'Error el resultado del where no es booleano', 0, 0)) variables.consola.insert( INSERT, 'Error el resultado del where no es booleano \n') else: variables.consola.insert( INSERT, "La tabla '" + self.tabla + "' que desea actualizar no existe\n") reporteerrores.append( Lerrores( "Error Semántico", "La tabla '" + self.tabla + "' que desea actualizar no existe", "", ""))
def ejecutar(self, ent: Entorno): 'Metodo Abstracto para ejecutar la instruccion' if self.distinct is None and self.froms is None and self.where is None and self.group is None and self.having is None and self.order is None and self.combinig is None: resultados = [] for exp in self.exps: if exp != None: resultados.append(exp.getval(ent)) return resultados elif self.froms != None and self.exps != None: tablas = [] for exp in self.froms: if exp != None: tipo = exp.tipo if tipo.tipo == 'identificador': nombre = exp.getval(ent) tabla = ent.buscarSimbolo(nombre) if tabla != None: tablas.append(tabla) #filtros #acceder a columnas if len(self.exps) == 1: if self.exps[0].getval(ent) == '*': result = [] for tabla in tablas: result.append( DBMS.extractTable(ent.getDataBase(), tabla.nombre)) return result
def ejecutar(self, ent: Entorno): self.encabezado.clear() resultfiltro = [] resultfiltro.clear() llavesprim = [] llavesprim.clear() dbActual = ent.getDataBase() result = [] result.clear() if dbActual != None: tabla: Simbolo = ent.buscarSimbolo(self.tabla + "_" + dbActual) if tabla != None: 'obtengo tabla' real = tabla.nombre.replace('_' + ent.getDataBase(), '') result = DBMS.extractTable(ent.getDataBase(), real) columnas = tabla.valor 'lleno encabezado' for col in columnas: self.encabezado.append(col.nombre) for i in range(0, len(result)): resexp = self.resolver(self.where, ent, result, tabla, i) try: if not resexp.valor: resultfiltro.append(result[i]) 'envio datos para delete' llavePrim = [] for column in tabla.valor: prim: Simbolo = ent.buscarSimbolo( column.atributos.get('primary')) if prim != None: llavePrim = prim.valor break except: reporteerrores.append( Lerrores( "Error Semantico", 'Error el resultado del where no es booleano', 0, 0)) variables.consola.insert( INSERT, 'Error el resultado del where no es booleano \n') llavesprim = llavePrim self.resultdelete(resultfiltro, self.tabla, ent.getDataBase(), llavesprim) else: variables.consola.insert( INSERT, "La tabla '" + self.tabla + "' que desea eliminar no existe\n") reporteerrores.append( Lerrores( "Error Semántico", "La tabla '" + self.tabla + "' que desea eliminar no existe", "", ""))
def cmd_extractTable(self, nombreBase, nombreTabla, where, listaCampos, listaSelect): #if existeTabla(nombreTabla, nombreBase) == 1: ob = pn.DevolverTabla(self.tabla) mc.listadoResp = mc.devolverTabla( ob.ejecutarNumpy(nombreBase, nombreTabla, where, listaCampos, listaSelect)) EDDResp.extractTable(condb.extractTable(nombreBase, nombreTabla))
def ejecutar(self, ent: Entorno): dbActual = ent.getDataBase() result = [] if dbActual != None: tabla: Simbolo = ent.buscarSimbolo(self.tabla + "_" + dbActual) if tabla != None: 'obtengo tabla' real = tabla.nombre.replace('_' + ent.getDataBase(), '') result = DBMS.extractTable(ent.getDataBase(), real) columnas = tabla.valor 'lleno encabezado' for col in columnas: self.encabezado.append(col.nombre) for i in range(0, len(result)): resexp = self.resolver(self.where, ent, result, tabla, i) try: if resexp.valor: 'envio datos par update' llavePrim = [] for column in tabla.valor: prim: Simbolo = ent.buscarSimbolo( column.atributos.get('primary')) llavePrim = prim.valor break #print("PK ----------",llavePrim) r = DBMS.delete(dbActual, self.tabla, llavePrim) #print("DELTEEEE ------------> ",r) if r == 0: variables.consola.insert( INSERT, 'Se ha eliminado un registro \n') except: reporteerrores.append( Lerrores( "Error Semantico", 'Error el resultado del where no es booleano', 0, 0)) variables.consola.insert( INSERT, 'Error el resultado del where no es booleano \n') else: variables.consola.insert( INSERT, "La tabla '" + self.tabla + "' que desea eliminar no existe\n") reporteerrores.append( Lerrores( "Error Semántico", "La tabla '" + self.tabla + "' que desea eliminar no existe", "", ""))
def getTablas(self, instr, tablas): for nodo in instr.hijos: if nodo.etiqueta == 'Tabla': hijos = {} hijos['Tabla'] = nodo.valor if len(nodo.hijos) > 0: hijos['As'] = nodo.hijos[0].valor registros = jsonMode.extractTable(self.usingDB, nodo.valor) if registros == None: self.errors.append( Error('42P01', EType.SEMANTICO, 'No existe la relacion ' + str(nodo.valor), nodo.linea)) return -1 hijos['Tuplas'] = registros tablas.append(hijos) return 1
def execute(self, environment,tableName): if not isinstance(self.columnName,str): return {'Error': 'El nombre indicado de la columna no es una cadena.', 'Fila':self.row, 'Columna': self.column } if not isinstance(tableName,str): return {'Error': 'El nombre indicado de la tabla no es una cadena.', 'Fila':self.row, 'Columna': self.column } db_name = environment.getActualDataBase() database = environment.readDataBase(db_name) table = database.getTable(tableName) repetido = False for item in table.constraint: if item['name'] == self.constraintVal['name']: repetido = True break if repetido == True: return {'Error': 'ya existe una restriccion con el mismo nombre', 'Fila':self.row, 'Columna': self.column } #columna a la que hace referencia menos el check if self.constraintVal['type'] != 'check': reference = False for item in table.column: if item.name == self.constraintVal['value']: reference = True break if reference == False: return {'Error': 'La columna a la que hace referencia la restriccion no existe en la tabla: '+tableName, 'Fila':self.row, 'Columna': self.column } if self.constraintVal['type'] == 'primary': for item in table.constraint: if item['value'] == self.constraintVal['value'] if item['type'] == 'primary': return 'la columna: '+self.columnName +' ya tiene la restriccionde llave primaria' result = admin.extractTable(db_name, tableName) if isinstance(result,list): if len(result) > 0: return {'Error': 'No se puede agregar la llave primaria a la tabla: '+tableName+' porque la tabla ya contiene valores.', 'Fila':self.row, 'Columna': self.column } for item in table.constraint: if item['type'] == 'primary': self.constraintVal = {'type':self.constraintVal['type'],'name':item['name'],'value':self.constraintVal['value']} table.createConstraint(self.constraintVal) return 'la restriccion fue insertada en la tabla: '+tableName+' con exito.'
def ejecutar(self, ent: Entorno): tablas = [] result = [] self.encabezado = [] 'Metodo Abstracto para ejecutar la instruccion' if self.distinct is None and self.froms is None and self.where is None and self.group is None and self.having is None and self.order is None and self.combinig is None: resultados = [] for exp in self.exps: if exp != None: resultados.append(exp.getval(ent)) return resultados elif self.froms != None and self.exps != None: for exp in self.froms: if exp != None: tipo = exp.tipo if tipo.tipo == 'identificador': nombre = exp.getval(ent) tabla = ent.buscarSimbolo(nombre + "_" + ent.getDataBase()) if tabla != None: tablas.append(tabla) if len(tablas) > 1: 'producto cartesiano' else: 'llenar resultado desde backend' real = tablas[0].nombre.replace('_' + ent.getDataBase(), '') result = DBMS.extractTable(ent.getDataBase(), real) #filtros if self.where != None: result = self.execwhere(ent, tablas) #acceder a columnas if len(self.exps) == 1: if self.exps[0].getval(ent) == '*': self.mostarresult(result, 'prueba xd') elif self.exps[0].tipo.tipo == 'identificador': 'obtengo solo columnas pedidas' else: 'pendientes subconsultas y funciones'
def unaTabla(self, nombreBase, nombreTabla, where, listaCampos): tabla_result = [] tabla_result.append(self.devolverCampos(nombreBase, nombreTabla)) resultados = condb.extractTable(nombreBase, nombreTabla) arr = np.array(resultados) if where == -1: # no viene where, guarda todo lo que viene for i in range(0, len(resultados), 1): tabla_result.append(arr[i]) elif listaCampos == -1: for i in range(0, len(resultados), 1): tabla_result.append(arr[i]) else: # si viene where for i in range(0, len(resultados), 1): nuevoWhere = where for j in listaCampos: print(len(listaCampos), "tam de la lista de campos") if nuevoWhere.__contains__(str(j)): posicion = self.devolverPosicionCampos( nombreBase, nombreTabla, j) print("entre al if con ", j, " posicion ", posicion) nuevoWhere = nuevoWhere.replace( str(j), "\"" + arr[i][posicion] + "\"") print("reemplazando ", j, " con ", "\"" + arr[i][posicion] + "\"", "-- resultado ", nuevoWhere) #val = where.replace("col0", "\"" + arr[i][0] + "\"").replace("col2", "\"" + arr[i][2]+ "\"") print(nuevoWhere, "<----") respuesta = eval(nuevoWhere) if (respuesta == True): tabla_result.append(arr[i]) return tabla_result
def FROM(self, db_name, database, tableArray, environment): # recorremos el tableList para ver si todas las tablas pertenecen a la base de datos y las almacenamos en table Array if isinstance(self.tableList, list): for item in self.tableList: table = database.getTable(item['id']) if table == None: if len(self.tableList) > 1: return { 'Error': 'La tabla: ' + item['id'] + ' no existe en la base de datos', 'Linea': self.row, 'Columna': self.column } else: return { 'Error': 'La tabla: ' + item['id'] + ' no existe en la base de datos', 'Linea': self.row, 'Columna': self.column } val = admin.extractTable(db_name, table.name) if val == None: return { 'Error': 'La tabla: ' + item['id'] + ' no existe en la base de datos', 'Linea': self.row, 'Columna': self.column } table.alias = item['as'] valor = {'table': table, 'data': val} tableArray.append(valor) elif isinstance(self.tableList, Select): tableArray.push(self.tableList.execute(environment)) else: return { 'Error': 'Formato no válido en el FROM', 'Fila': self.row, 'Columna': self.column }
def execute(self, environment): if not isinstance(self.tableName, str): return { 'Error': 'El nombre indicado de la tabla no es una cadena.', 'Fila': self.row, 'Columna': self.column } if not isinstance(self.idList, list): db_name = environment.getActualDataBase() database = environment.readDataBase(db_name) if database == None: return { 'Error': 'Error al buscar en la base de datos', 'Fila': self.row, 'Columna': self.column } table = database.getTable(self.tableName) if table == None: return { 'Error': 'La tabla: ' + self.tableName + ' no existe en la base de datos: ' + db_name, 'Fila': self.row, 'Columna': self.column } if len(table.columns) != len(self.valueList): return { 'Error': 'El numero de valores a insertar es diferente que el numero de columnas de la tabla: ' + self.tableName, 'Fila': self.row, 'Columna': self.column } for i in range(len(self.valueList)): columna = table.columns[i] valor = self.valueList[i].execute(environment) res = check(columna.tipo, valor['typ'], valor['value'], columna.lenght) if not isinstance(res, bool): return { 'Error': res, 'Fila': self.row, 'Columna': self.column } for index in range(len(self.valueList)): nombreVariable = table.columns[index].name valorVariable = self.valueList[index].execute(environment) environment.guardarVariableins(nombreVariable, valorVariable['typ'], valorVariable['value'], None) for item in table.constraint: if item['type'] == 'primary': var = environment.buscarVariable(item['value'], None) if var == None: return { 'Error': 'Variable no encontrada', 'Fila': self.row, 'Columna': self.column } if var['tipo'] == Type.NULL: return { 'Error': 'La primary key no puede ser nula', 'Fila': self.row, 'Columna': self.column } elif item['type'] == 'foreign': #no hay validaciones por el momento print('foreign') elif item['type'] == 'not null': var = environment.buscarVariable(item['value'], None) if var == None: return { 'Error': 'Variable no encontrada', 'Fila': self.row, 'Columna': self.column } if var['tipo'] == Type.NULL: return { 'Error': 'El campo: ' + var['name'] + ' no puede ser nulo', 'Fila': self.row, 'Columna': self.column } elif item['type'] == 'check': var = item['value'].execute(environment) if var['typ'] != Type.BOOLEAN: return { 'Error': 'La condicion del check, no es booleana', 'Fila': self.row, 'Columna': self.column } if var['value'] != True: return { 'Error': 'No se cumple con la restriccion: ' + item['name'], 'Fila': self.row, 'Columna': self.column } elif item['type'] == 'unique': val = admin.extractTable(db_name, self.tableName) if val == None: return { 'Error': 'La base de datos o la tabla a la que desea hacer referencia no existe.', 'Fila': self.row, 'Columna': self.column } elif len(val) == 0: #pasa de largo porque no hay registros print('') elif len(val) > 0: aux = -1 for i in range(len(table.columns)): if table.columns[i].name == item['value']: aux = i break if aux == -1: return { 'Error': 'No se encontro la columna: ' + item['value'], 'Fila': self.row, 'Columna': self.column } searched = environment.buscarVariable( item['value'], None) for tupla in val: if tupla[aux] == searched['value']: if isinstance(searched['value'], int): return { 'Error': 'Ya existe un registro con el valor: ' + str(searched['value']) + ' en la columna: ' + item['value'] + ' lo cual viola la restriccion unique', 'Fila': self.row, 'Columna': self.column } else: return { 'Error': 'Ya existe un registro con el valor: ' + searched['value'] + ' en la columna: ' + item['value'] + ' lo cual viola la restriccion unique', 'Fila': self.row, 'Columna': self.column } else: return { 'Error': 'Error desconocido al insertar.', 'Fila': self.row, 'Columna': self.column } #guardando en el storage listaValores = [] for item in self.valueList: valorLista = item.execute(environment) if valorLista['typ'] == Type.DATE or valorLista[ 'typ'] == Type.TIME: listaValores.append(str(valorLista['value'])) else: listaValores.append(valorLista['value']) valorRetorno = admin.insert(db_name, self.tableName, listaValores) print(listaValores) if valorRetorno == 0: return 'Se ha insertado con exito la tupla ' + str( listaValores) + ' en la tabla: ' + self.tableName elif valorRetorno == 1: return { 'Error': 'Error en la operación insertar.', 'Fila': self.row, 'Columna': self.column } elif valorRetorno == 2: return { 'Error': 'La base de datos a la que desea referenciar no existe', 'Fila': self.row, 'Columna': self.column } elif valorRetorno == 3: return { 'Error': 'La tabla en la que desea insertar registros no existe', 'Fila': self.row, 'Columna': self.column } elif valorRetorno == 4: return { 'Error': 'Llave primaria duplicada', 'Fila': self.row, 'Columna': self.column } elif valorRetorno == 5: return { 'Error': 'columna fuera de limites', 'Fila': self.row, 'Columna': self.column } else: return { 'Error': 'Error desconocido al insertar registros', 'Fila': self.row, 'Columna': self.column } else: # aqui es el segundo formato de insert db_name = environment.getActualDataBase() database = environment.readDataBase(db_name) if database == None: return { 'Error': 'Error al buscar en la base de datos', 'Fila': self.row, 'Columna': self.column } table = database.getTable(self.tableName) if table == None: return { 'Error': 'La tabla: ' + self.tableName + ' no existe en la base de datos: ' + db_name, 'Fila': self.row, 'Columna': self.column } if len(table.columns) < len(self.idList): return { 'Error': 'El numero de columnas indicadas es mayor al numero de columnas de la tabla: ' + self.tableName, 'Fila': self.row, 'Columna': self.column } #if len(self.valueList) != len(self.idList): #return {'Error': 'El numero de registros a insertar difiere del numero de columnas indicadas: '+self.tableName, 'Fila':self.row, 'Columna': self.column } #TODO verificar tipos for i in range(len(self.valueList)): columna = table.readColumn(self.idList[i]) if columna == None: return { 'Error': 'La columna: ' + self.idList[i] + ' no existe en la tabla ' + table.name, 'Fila': self.row, 'Columna': self.column } valor = self.valueList[i].execute(environment) res = check(columna.tipo, valor['typ'], valor['value'], columna.lenght) if not isinstance(res, bool): return { 'Error': res, 'Fila': self.row, 'Columna': self.column } # verificar que el id list coincida con los nombres de las columnas for item in self.idList: exist = False for col in table.columns: if col.name == item: exist = True if exist == False: return { 'Error': 'La columna: ' + item + ' no existe en la tabla: ' + self.tableName, 'Fila': self.row, 'Columna': self.column } for index in range(len(self.valueList)): nombreVariable = self.idList[index] valorVariable = self.valueList[index].execute(environment) environment.guardarVariableins(nombreVariable, valorVariable['typ'], valorVariable['value'], None) for item in table.columns: var = environment.buscarVariable(item.name, None) if var == None: if item.default == None: nombreVariable = item.name valorVariable = 'null' tipoVariable = Type.NULL environment.guardarVariableins(nombreVariable, tipoVariable, valorVariable, None) else: nombreVariable = item.name valorVariable = item.default tipoVariable = item.tipo environment.guardarVariableins(nombreVariable, tipoVariable, valorVariable, None) for item in table.constraint: if item['type'] == 'primary': var = environment.buscarVariable(item['value'], None) if var == None: return { 'Error': 'Variable no encontrada', 'Fila': self.row, 'Columna': self.column } if var['tipo'] == Type.NULL: return { 'Error': 'La primary key no puede ser nula', 'Fila': self.row, 'Columna': self.column } elif item['type'] == 'foreign': #no hay validaciones por el momento print('foreign') elif item['type'] == 'not null': var = environment.buscarVariable(item['value'], None) if var == None: return { 'Error': 'Variable no encontrada', 'Fila': self.row, 'Columna': self.column } if var['tipo'] == Type.NULL: return { 'Error': 'El campo: ' + var['name'] + ' no puede ser nulo', 'Fila': self.row, 'Columna': self.column } elif item['type'] == 'check': var = item['value'].execute(environment) if var['typ'] != Type.BOOLEAN: return { 'Error': 'La condicion del check, no es booleana', 'Fila': self.row, 'Columna': self.column } if var['value'] != True: return { 'Error': 'No se cumple con la restriccion: ' + item['name'], 'Fila': self.row, 'Columna': self.column } elif item['type'] == 'unique': val = admin.extractTable(db_name, self.tableName) if val == None: return { 'Error': 'La base de datos o la tabla a la que desea hacer referencia no existe.', 'Fila': self.row, 'Columna': self.column } elif len(val) == 0: #pasa de largo porque no hay registros print('') elif len(val) > 0: aux = -1 for i in range(len(table.columns)): if table.columns[i].name == item['value']: aux = i break if aux == -1: return { 'Error': 'No se encontro la columna: ' + item['value'], 'Fila': self.row, 'Columna': self.column } searched = environment.buscarVariable( item['value'], None) for tupla in val: if tupla[aux] == searched['value']: if isinstance(searched['value'], int): return { 'Error': 'Ya existe un registro con el valor: ' + str(searched['value']) + ' en la columna: ' + item['value'] + ' lo cual viola la restriccion unique', 'Fila': self.row, 'Columna': self.column } else: return { 'Error': 'Ya existe un registro con el valor: ' + searched['value'] + ' en la columna: ' + item['value'] + ' lo cual viola la restriccion unique', 'Fila': self.row, 'Columna': self.column } else: return { 'Error': 'Error desconocido al insertar.', 'Fila': self.row, 'Columna': self.column } #ordenar la lista de valores #guardando en el storage valOrden = [] for item in table.columns: var = environment.buscarVariable(item.name, None) if var == None: return { 'Error': 'Error desconocido al insertar 2.', 'Fila': self.row, 'Columna': self.column } if var['tipo'] == Type.DATE or var['tipo'] == Type.TIME: valOrden.append(str(var['value'])) else: valOrden.append(var['value']) valorRetorno = admin.insert(db_name, self.tableName, valOrden) if valorRetorno == 0: return 'Se ha insertado con exito la tupla ' + str( valOrden) + ' en la tabla: ' + self.tableName elif valorRetorno == 1: return { 'Error': 'Error en la operación insertar.', 'Fila': self.row, 'Columna': self.column } elif valorRetorno == 2: return { 'Error': 'La base de datos a la que desea referenciar no existe', 'Fila': self.row, 'Columna': self.column } elif valorRetorno == 3: return { 'Error': 'La tabla en la que desea insertar registros no existe', 'Fila': self.row, 'Columna': self.column } elif valorRetorno == 4: return { 'Error': 'Llave primaria duplicada', 'Fila': self.row, 'Columna': self.column } elif valorRetorno == 5: return { 'Error': 'columna fuera de limites', 'Fila': self.row, 'Columna': self.column } else: return { 'Error': 'Error desconocido al insertar registros', 'Fila': self.row, 'Columna': self.column }
def ejecutar(self, ent: Entorno,imp=1): #try: tablas = [] result = [] self.encabezado = [] self.aliast=[] if self.distinct is None and self.froms is None and self.where is None and self.group is None and self.having is None and self.order is None and self.combinig is None: resultados = [] newenc=[] for i in range(0,len(self.exps)): exp=self.exps[i] if isinstance(self.exps[i], FuncionesNativas): newenc.append(self.exps[i].identificador+str(i)) elif isinstance(self.exps[i], Alias): newenc.append(self.exps[i].nombre) exp = self.exps[i].expresion elif isinstance(self.exps[i],Identificador): newenc.append(self.exps[i].nombre) else: newenc.append('Exp' + str(len(newenc))) result.append(exp.getval(ent).valor) result=[result] self.encabezado=newenc elif self.froms != None and self.exps != None: for exp in self.froms: if isinstance(exp,Identificador) or isinstance(exp,Terminal): self.aliast.append('') tipo = exp.tipo tablas=self.gettablas(tipo,exp,ent,tablas) elif isinstance(exp,Alias): self.aliast.append(exp.nombre) expre=exp.expresion tipo=expre.tipo tablas=self.gettablas(tipo,expre,ent,tablas) if len(tablas) > 1: 'Obteniendo encabezados de las tablas' for tabla in tablas: cols = tabla.valor for columna in cols: nombre = columna.nombre self.encabezado.append(nombre + "." + tabla.nombre.replace('_' + ent.getDataBase(), '')) 'producto cartesiano' real = tablas[0].nombre.replace('_' + ent.getDataBase(), '') result = DBMS.extractTable(ent.getDataBase(), real) self.nombreres = real for i in range(0, len(tablas) - 1): real2 = tablas[i + 1].nombre.replace('_' + ent.getDataBase(), '') self.nombreres += "_" + real2 tabla2 = DBMS.extractTable(ent.getDataBase(), real2) result = self.producto(result, tabla2) else: 'llenar resultado desde backend' real = tablas[0].nombre.replace('_' + ent.getDataBase(), '') result = DBMS.extractTable(ent.getDataBase(), real) 'encabezados 1 tabla' if (len(self.encabezado) == 0): for tabla in tablas: cols = tabla.valor for columna in cols: nombre = columna.nombre self.encabezado.append(nombre) # add columnas newenc = [] newres = [] for i in range(0, len(self.exps)): if isinstance(self.exps[i], Terminal) or isinstance(self.exps[i], Identificador): 'aqui no agrego las que ya existen' else: exp = self.exps[i] 'aqui agrego las expresiones que se agregaran para filtrar' if isinstance(self.exps[i], FuncionesNativas): newenc.append(self.exps[i].identificador) elif isinstance(self.exps[i], Alias): newenc.append(self.exps[i].nombre) exp = self.exps[i].expresion elif isinstance(self.exps[i], Identificador): newenc.append(self.exps[i].nombre) else: newenc.append('Exp' + str(len(newenc))) for fila in range(0, len(result)): res = self.resolver(exp, ent, result, tablas, fila) if fila == 0: self.tipos.append([newenc[len(newenc) - 1], res.tipo]) if len(newres) != len(result): newres.append([res.valor]) else: newres[fila].append(res.valor) for i in range(0, len(result)): if newres != []: result[i] = result[i] + newres[i] self.encabezado = (self.encabezado + newenc) # filtros if self.where != None: result = self.optwhere(ent,result,tablas) #DEVUELVO SOLO COLUMNAS PEDIDAS newenc = [] newres = [] for i in range(0, len(self.exps)): if isinstance(self.exps[i],Identificador): for j in range(0, len(self.encabezado)): nombrediv = self.encabezado[j].split('.') nombrecol = nombrediv[0] if self.exps[i].nombre == nombrecol: newenc.append(self.encabezado[j]) for x in range(0, len(result)): valcol = result[x][j] if len(newres) != len(result): newres.append([valcol]) else: newres[x].append(valcol) elif isinstance(self.exps[i], Terminal): if self.exps[i].tipo.tipo == 'acceso': expresion=self.exps[i] campos = expresion.getval(ent).valor.split('.') if campos[1] == '*': tablares=self.getasterisco(campos[0], tablas, result, ent,newres,newenc) newenc=tablares[0] newres=tablares[1] #busco el campo pedido si no es * for j in range(0, len(self.encabezado)): nombrediv = self.encabezado[j].split('.') nombrecol = nombrediv[0] nombretabla = nombrediv[1] nombrecol = nombretabla + '.' + nombrecol if expresion.getval(ent).valor == nombrecol: newenc.append(self.encabezado[j]) for x in range(0, len(result)): dato = result[x][j] if len(newres) != len(result): newres.append([dato]) else: newres[x].append(dato) for k in range(0, len(self.aliast)): nombreacc = self.aliast[k] + '.' + nombrediv[0] if expresion.getval(ent).valor == nombreacc and nombrediv[1] == tablas[k].nombre.replace('_' + ent.getDataBase(), ''): newenc.append(self.encabezado[j]) for x in range(0, len(result)): dato = result[x][j] if len(newres) != len(result): newres.append([dato]) else: newres[x].append(dato) elif len(self.exps)==1 and self.exps[0].valor=='*': newres=result[:] newenc=self.encabezado[:] break else: exp = self.exps[i] if isinstance(self.exps[i],FuncionesNativas): newenc.append(self.exps[i].identificador+str(i)) elif isinstance(self.exps[i], Alias): newenc.append(self.exps[i].nombre) exp = self.exps[i].expresion else: newenc.append('Exp'+len(newenc)) for fila in range(0,len(result)): res=self.resolver(exp,ent,result,tablas,fila) '''if isinstance(res,str): if len(newres) != len(result): newres.append(['']) else: newres[fila].append('') continue''' if len(newres) != len(result) : newres.append([res.valor]) else: newres[fila].append(res.valor) result = newres[:] self.encabezado = newenc[:] # combining(union,intersect,except) if self.combinig != None: datos2 = self.combinig.select.ejecutar(ent, 0) enc2 = datos2[0] res2 = datos2[1] result = self.m_combining(self.combinig, self.encabezado, result, enc2, res2) aber = result # limitar resultados if self.limit != None: a = self.limit result = self.m_limit(result, a.limit, a.off) #distinct if self.distinct!=None: newres=[] 'elimino duplicados' for i in range(0,len(result)): encontrado=False fila=result[i] for j in range(0,len(result)): if j!= i: if fila==result[j]: encontrado=True if encontrado==False: newres.append(fila) result=newres #imprimir resultado solo si no se llamo de un subquery,union,intersect,except if self.agregacion==1: result=[result[0]] if imp == 1: self.mostarresult(result, self.encabezado, self.nombreres) return [self.encabezado, result]
def execute(self, environment): #NOMBRE DE LA BD dbname = environment.getActualDataBase() db = environment.readDataBase(dbname) if (db == None): return { 'Error': 'No se encuentra una base de datos en uso', 'Fila': self.row, 'Columna': self.column } #NOMBRE DE LA TABLA tbname = self.idTable #LISTA CON LOS INDEX DE LAS COLUMNAS QUE SON LLAVES PRIMARIAS table = db.getTable(self.idTable) #Diccionario con las clave el nombre de la tabla y valor el indice indColumnas = {} for c in range(len(table.columns)): indColumnas[table.columns[c].name] = c #--Busco los nombres de los campos que son primary key pkNames = [] for con in table.constraint: if con['type'] == 'primary': pkNames.append(con['value']) #--Busco los indices de los campos correspondientes pkIndexes = [] for i in range(len(table.columns)): for item in pkNames: if table.columns[i].name == item: pkIndexes.append(i) #LISTA DE LLAVE VALOR tuplas = admin.extractTable(dbname, tbname) if len(tuplas) == 0: return { 'Error': 'La tabla no contiene registros a actualizar.', 'Fila': self.row, 'Columna': self.column } if tuplas == None: return { 'Error': 'La tabla no ha podido encontrarse, error en el Storage.', 'Fila': self.row, 'Columna': self.column } #POR CADA TUPLA QUE HAYA for tindex in range(len(tuplas)): #POR CADA CAMPO EN LA TUPLA CREO EN LA TABLA DE SIMBOLOS LA VARIABLE DE CADA CAMPO for index in range(len(tuplas[tindex])): #TIPOS, PROBABLEMENTE SE DEBA CAMBIAR tipo = Type.STRING if isinstance(tuplas[tindex][index], int): tipo = Type.DECIMAL #GUARDAR EN EL ENTORNO UNA VARIALBE CON EL NOMBRE DE LA COLUMNA environment.guardarVariable(table.columns[index].name, tipo, tuplas[tindex][index]) #CREO EL DICCIONARIO CON LOS VALORES A MODIFICAR tuplaModificada = {} for asign in self.assignList: clave = indColumnas[asign['id']] valor = asign['value'].execute(environment)['value'] tuplaModificada[clave] = valor #CREO UN ARREGLO CON LA LLAVE PRIMARIA DE ESE REGISTRO primaryKey = [] for val in pkIndexes: primaryKey.append(tuplas[tindex][val]) #VERIFICO LA CONDICIÓN DEL WHERE where = True if not isinstance(self.condition, bool): where = self.condition.execute(environment)['value'] if where == True: res = admin.update(dbname, tbname, tuplaModificada, primaryKey) switcher = { 0: 'Se ha realizado el update en el registro con la FK: ' + str(primaryKey), 1: { 'Error:': 'Error en la operación update.', 'Fila': self.row, 'Columna': self.column }, 2: { 'Error:': 'La base de datos buscada no existe.', 'Fila': self.row, 'Columna': self.column }, 3: { 'Error:': 'La tabla ' + self.idTable + ' no existe.', 'Fila': self.row, 'Columna': self.column }, 4: { 'Error:': 'No existe el registro buscado: ' + str(primaryKey), 'Fila': self.row, 'Columna': self.column }, } return switcher.get( res, 'Error en la respuesta del update en el StorageManager.')
def execute(self, environment): dbname = environment.getActualDataBase() db = environment.readDataBase(dbname) if (db == None): return {'Error': 'No se encuentra una base de datos referenciada.'} tbname = self.idTable table = db.getTable(self.idTable) indColumnas = {} for c in range(len(table.columns)): indColumnas[table.columns[c].name] = c pkNames = [] for con in table.constraint: if con['type'] == 'primary': pkNames.append(con['value']) pkIndexes = [] for i in range(len(table.columns)): for item in pkNames: if table.columns[i].name == item: pkIndexes.append(i) #LISTA DE LLAVE VALOR tuplas = admin.extractTable(dbname, tbname) if len(tuplas) == 0: return { 'Error': 'La tabla no contiene registros a actualizar.', 'Fila': self.row, 'Columna': self.column } if tuplas == None: return { 'Error': 'La tabla no ha podido encontrarse, error en el Storage.', 'Fila': self.row, 'Columna': self.column } #POR CADA TUPLA QUE HAYA for tindex in range(len(tuplas)): #POR CADA CAMPO EN LA TUPLA CREO EN LA TABLA DE SIMBOLOS LA VARIABLE DE CADA CAMPO for index in range(len(tuplas[tindex])): #TIPOS, PROBABLEMENTE SE DEBA CAMBIAR tipo = Type.STRING if isinstance(tuplas[tindex][index], int): tipo = Type.DECIMAL #GUARDAR EN EL ENTORNO UNA VARIALBE CON EL NOMBRE DE LA COLUMNA environment.guardarVariable(table.columns[index].name, tipo, tuplas[tindex][index], None) #CREO UN ARREGLO CON LA LLAVE PRIMARIA DE ESE REGISTRO primaryKey = [] for val in pkIndexes: primaryKey.append(tuplas[tindex][val]) #VERIFICO LA CONDICIÓN DEL WHERE where = True if not isinstance(self.condition, bool): where = self.condition.execute(environment)['value'] if where == True: res = admin.delete(dbname, tbname, primaryKey) switcher = { 0: 'Se ha realizado el delete en el registro con la FK: ' + str(primaryKey), 1: { 'Error:': 'Error en la operación delete.', 'Fila': self.row, 'Columna': self.column }, 2: { 'Error:': 'La base de datos' + dbname + 'no existe.', 'Fila': self.row, 'Columna': self.column }, 3: { 'Error:': 'La tabla ' + self.idTable + ' no existe.', 'Fila': self.row, 'Columna': self.column }, 4: { 'Error:': 'No existe el registro buscado: ' + str(primaryKey), 'Fila': self.row, 'Columna': self.column }, } return switcher.get( res, 'Error en la respuesta del update en el StorageManager.')
def ejecutar(self, ent: Entorno): dbActual = ent.getDataBase() if dbActual != None: tam = len(self.listaDef) nuevaTabla = Simbolo(TipoSimbolo.TABLA, (self.id + "_" + dbActual)) listaColumnas = [] listaAtrCol = [] hayPrimaria = False hayForanea = False primariaAdd: Primaria = None foraneaAdd: Foranea = None inicioHerencia = 0 if self.herencia != None: r: Simbolo = ent.buscarSimbolo(self.herencia + "_" + dbActual) if r != None: for colPadre in r.valor: listaColumnas.append(colPadre) if colPadre.atributos.get('primary') != None: coPrimary: Simbolo = ent.buscarSimbolo( colPadre.atributos.get('primary')) if coPrimary != None: self.listPK = coPrimary.valor inicioHerencia = len(r.valor) else: variables.consola.insert( INSERT, "La tabla padre '" + self.herencia + "' no existe") reporteerrores.append( Lerrores( "Error Semántico", "La tabla padre '" + self.herencia + "' no existe", "", "")) for x in range(0, tam, 1): tt = self.listaDef[x] if tt.tipo == AtributosColumna.COLUMNA_SIMPLE: nuevaColumna = Simbolo(tt.tipoDato, tt.identificador) if tt.lista != None: #aca se mete si viene por ejemplo: columna1 integer references tabla2 tamano = len(tt.lista) for y in range(tamano): hayAtr = False nuevoSym = Simbolo("tipo", "nombre") nuevoSym.baseDatos = dbActual nuevoSym.tabla = self.id atrColumna: Atributo = tt.lista[y] if atrColumna.tipo == AtributosColumna.UNICO: hayAtr = True nuevoSym.tipo = TipoSimbolo.CONSTRAINT_UNIQUE if atrColumna.valor != None: #forma de: constraint id UNIQUE #formato de nombre: U_database_tabla_nombreColumna_idConstraint nuevoSym.nombre = str("U_" + dbActual + "_" + self.id + "_" + tt.identificador + "_" + atrColumna.valor) nuevaColumna.atributos.update({ 'unique': str("U_" + dbActual + "_" + self.id + "_" + tt.identificador + "_" + atrColumna.valor) }) else: #forma de: nombreColumna tipo UNIQUE #formato: U_database_tabla_nombreColumna nuevoSym.nombre = str("U_" + dbActual + "_" + self.id + "_" + tt.identificador) nuevaColumna.atributos.update({ 'unique': str("U_" + dbActual + "_" + self.id + "_" + tt.identificador) }) nuevoSym.valor = tt.identificador elif atrColumna.tipo == AtributosColumna.CHECK: hayAtr = True nuevoSym.tipo = TipoSimbolo.CONSTRAINT_CHECK nuevoSym.valor = atrColumna.exp if atrColumna.valor != None: #forma de: constraint id check cond < cond #formato: C_database_tabla_nombreColumna_idConstraint nuevoSym.nombre = str("C_" + dbActual + "_" + self.id + "_" + tt.identificador + "_" + atrColumna.valor) nuevaColumna.atributos.update({ 'check': str("C_" + dbActual + "_" + self.id + "_" + tt.identificador + "_" + atrColumna.valor) }) else: #cuando viene: nombreColumna tipo CHECK cond < cond #formato: C_database_tabla_nombreColumna nuevoSym.nombre = str("C_" + dbActual + "_" + self.id + "_" + tt.identificador) nuevaColumna.atributos.update({ 'check': str("C_" + dbActual + "_" + self.id + "_" + tt.identificador) }) elif atrColumna.tipo == AtributosColumna.DEFAULT: nuevaColumna.atributos.update( {'default': atrColumna.valor}) elif atrColumna.tipo == AtributosColumna.NO_NULO: nuevaColumna.atributos.update( {'not null': True}) elif atrColumna.tipo == AtributosColumna.NULO: nuevaColumna.atributos.update({'null': True}) elif atrColumna.tipo == AtributosColumna.PRIMARY: hayPrimaria = True nuevaColumna.atributos.update({ 'primary': str("PK_" + dbActual + "_" + self.id) }) # PK_database_tabla elif atrColumna.tipo == AtributosColumna.REFERENCES: rr = DBMS.extractTable(dbActual, atrColumna.valor) if rr == None: return str( "La tabla \'" + atrColumna.valor + "\' a la que está referenciando, no existe" ) else: tablaReferencia: Simbolo = ent.buscarSimbolo( atrColumna.valor + "_" + dbActual) colRef = tablaReferencia.valor for col in colRef: nomConstraintPK = col.atributos.get( 'primary') if nomConstraintPK != None: consPK: Simbolo = ent.buscarSimbolo( nomConstraintPK) arrPk = consPK.valor if len(arrPk) == 1: if tablaReferencia.valor[arrPk[ 0]].tipo.tipo == nuevaColumna.tipo.tipo: hayForanea = True hayAtr = True nuevoSym.tipo = TipoSimbolo.CONSTRAINT_FOREIGN # FK_database_tabla_tablaReferencia nuevoSym.nombre = str( "FK_" + dbActual + "_" + self.id + "_" + atrColumna.valor) nuevaColumna.atributos.update( { 'foreign': str("FK_" + dbActual + "_" + self.id + "_" + atrColumna. valor) }) break if not hayForanea: variables.consola.insert( INSERT, "No se puede establecer llave foranea entre tabla '" + self.id + "' y '" + atrColumna.valor + "'\n") reporteerrores.append( Lerrores( "Error Semántico", "No se puede establecer llave foranea entre tabla '" + self.id + "' y '" + atrColumna.valor + "'", "", "")) if hayAtr: listaAtrCol.append(nuevoSym) listaColumnas.append(nuevaColumna) if tt.tipo == AtributosColumna.PRIMARY: if hayPrimaria: variables.consola.insert( INSERT, str("La tabla \'" + self.id + "\' ya contiene llave primaria declarada\n")) reporteerrores.append( Lerrores( "Error Semántico", "La tabla \'" + self.id + "\' ya contiene llave primaria declarada", "", "")) else: primariaAdd: Primaria = tt if tt.tipo == AtributosColumna.REFERENCES: if hayForanea: variables.consola.insert( INSERT, str("La tabla \'" + self.id + "\' ya contiene llave foranea declarada\n")) reporteerrores.append( Lerrores( "Error Semántico", "La tabla \'" + self.id + "\' ya contiene llave foranea declarada", "", "")) else: foraneaAdd: Foranea == tt rr = DBMS.extractTable(dbActual, foraneaAdd.tabla) if tt.tipo == AtributosColumna.CONSTRAINT: if tt.contenido.tipo == AtributosColumna.PRIMARY: if hayPrimaria: variables.consola.insert( INSERT, str("La tabla \'" + self.id + "\' ya contiene llave primaria declarada\n" )) reporteerrores.append( Lerrores( "Error Semántico", "La tabla \'" + self.id + "\' ya contiene llave primaria declarada", "", "")) else: primariaAdd: Primaria = tt.contenido primariaAdd.idConstraint = tt.id elif tt.contenido.tipo == AtributosColumna.REFERENCES: if hayForanea: variables.consola.insert( INSERT, str("La tabla \'" + self.id + "\' ya contiene llave foranea declarada\n") ) reporteerrores.append( Lerrores( "Error Semántico", "La tabla \'" + self.id + "\' ya contiene llave foranea declarada", "", "")) else: foraneaAdd: Foranea == tt rr = DBMS.extractTable(dbActual, foraneaAdd.tabla) elif tt.contenido.tipo == AtributosColumna.UNICO: listUnicas = tt.contenido.unicos for x in listUnicas: for col in listaColumnas: if col.nombre == x.valor: #formato: U_database_tabla_nombreColumna_idConstraint col.atributos.update({ 'unique': str("U_" + dbActual + "_" + self.id + "_" + col.nombre + "_" + tt.id) }) sym = Simbolo( TipoSimbolo.CONSTRAINT_UNIQUE, str("U_" + dbActual + "_" + self.id + "_" + col.nombre + "_" + tt.id)) ent.nuevoSimbolo(sym) elif tt.contenido.tipo == AtributosColumna.CHECK: #formato: C_database_tabla_nombreColumna_idConstraint nombreColCheck = str( tt.contenido.condiciones.exp1.valor) for x in listaColumnas: if x.nombre == nombreColCheck: x.atributos.update({ 'check': str("C_" + dbActual + "_" + self.id + "_" + x.nombre + "_" + tt.id) }) sym = Simbolo( TipoSimbolo.CONSTRAINT_CHECK, str("C_" + dbActual + "_" + self.id + "_" + x.nombre + "_" + tt.id)) sym.tabla = self.id sym.baseDatos = dbActual sym.valor = tt.contenido.condiciones listaAtrCol.append(sym) break nuevaTabla.valor = listaColumnas estado = DBMS.createTable(dbActual, self.id, len(listaColumnas)) if estado == 0: nuevaTabla.baseDatos = dbActual r = ent.nuevoSimbolo(nuevaTabla) if r == "ok": for x in listaAtrCol: ent.nuevoSimbolo(x) alreadyPrimary = False for x in range(inicioHerencia, len(listaColumnas), 1): if not alreadyPrimary: pk = listaColumnas[x].atributos.get('primary') if pk != None: self.listPK.append(x) rrr = DBMS.alterAddPK(dbActual, self.id, self.listPK) if rrr != 0: variables.consola.insert( INSERT, "No se ha podido agregar PK en tabla \'" + self.id + "\'\n") reporteerrores.append( Lerrores( "Error Semántico", "No se ha podido agregar PK en tabla \'" + self.id + "'", "", "")) else: alreadyPrimary = True sym1 = Simbolo( TipoSimbolo.CONSTRAINT_PRIMARY, str("PK_" + dbActual + "_" + self.id)) sym1.valor = self.listPK sym1.tabla = self.id sym1.baseDatos = dbActual ent.nuevoSimbolo(sym1) if not alreadyPrimary: tablaB: Simbolo = ent.buscarSimbolo(nuevaTabla.nombre) if tablaB != None: if primariaAdd != None: listaPrim = primariaAdd.primarias for p in listaPrim: for col in range(len(tablaB.valor)): if p.valor == tablaB.valor[col].nombre: self.listPK.append(col) #print(p.valor) #print(col.nombre) if len(self.listPK) > 0: n = DBMS.alterAddPK( dbActual, self.id, self.listPK) if n != 0: variables.consola.insert( INSERT, "No se ha podido agregar PK en tabla \'" + self.id + "\'\n") reporteerrores.append( Lerrores( "Error Semántico", "No se ha podido agregar PK en tabla \'" + self.id + "'", "", "")) else: idPk = "" alreadyPrimary = True sym: Simbolo = None if primariaAdd.idConstraint != "": idPk = str( "PK_" + dbActual + "_" + self.id + "_" + primariaAdd.idConstraint) sym = Simbolo( TipoSimbolo.CONSTRAINT_PRIMARY, idPk) else: idPk = str("PK_" + dbActual + "_" + self.id) sym = Simbolo( TipoSimbolo.CONSTRAINT_PRIMARY, idPk) for y in self.listPK: tablaB.valor[y].atributos.update( {'primary': idPk}) sym.valor = self.listPK sym.tabla = self.id sym.baseDatos = dbActual ent.nuevoSimbolo(sym) DBMS.showCollection() variables.consola.insert( INSERT, str("Tabla " + self.id + " creada exitosamente\n")) return return r
def ejecutar(self, ent: Entorno): self.encabezado.clear() dbActual = ent.getDataBase() result = [] result.clear() llavesprim = [] llavesprim.clear() if dbActual != None: tabla: Simbolo = ent.buscarSimbolo(self.tabla + "_" + dbActual) if tabla != None: 'obtengo tabla' real = tabla.nombre.replace('_' + ent.getDataBase(), '') result = DBMS.extractTable(ent.getDataBase(), real) columnas = tabla.valor 'lleno encabezado' for col in columnas: self.encabezado.append(col.nombre) colsupdate = [] poscolsupdate = [] newvals = [] colsupdate.clear() poscolsupdate.clear() newvals.clear() for i in range(0, len(self.listaCampos)): nombrecol = self.listaCampos[i].columna expresion = self.listaCampos[i].exp contenido = expresion.getval(ent).valor colsupdate.append(nombrecol) newvals.append(contenido) for x in range(0, len(colsupdate)): for y in range(0, len(self.encabezado)): print("comparando" + colsupdate[x]) print("con+" + self.encabezado[y]) if (colsupdate[x] == self.encabezado[y]): poscolsupdate.append(y) print(poscolsupdate) for i in range(0, len(result)): resexp = self.resolver(self.where, ent, result, tabla, i) try: if resexp.valor: cont = 0 for a in poscolsupdate: result[i][a] = newvals[cont] cont += 1 llavePrim = [] for column in tabla.valor: prim: Simbolo = ent.buscarSimbolo( column.atributos.get('primary')) llavePrim = prim.valor break except: reporteerrores.append( Lerrores( "Error Semantico", 'Error el resultado del where no es booleano', 0, 0)) variables.consola.insert( INSERT, 'Error el resultado del where no es booleano \n') llavesprim = llavePrim self.resultupdate(result, self.tabla, ent.getDataBase(), llavesprim) else: variables.consola.insert( INSERT, "La tabla '" + self.tabla + "' que desea actualizar no existe\n") reporteerrores.append( Lerrores( "Error Semántico", "La tabla '" + self.tabla + "' que desea actualizar no existe", "", ""))
def wheredelete(self,entorno,tablas): filtrado=[] exp1:Expresion exp2:Expresion colres=[] tipo='' isid=False posid=-1 if isinstance(self.exps, Relacional) or isinstance(self.exps,Logica): encontrado=0 nocol=-1 nomtabla='' 'realizar operacion' exp1=self.exps.exp1 exp2=self.exps.exp2 op=self.exps.operador if (op==">"): op="<" elif (op=="<"): op=">" elif (op=="!="): op="=" elif (op=="="): op="!=" elif (op==">="): op="<=" elif (op=="<="): op=">=" else: print("") val='' if (exp1.tipo.tipo=='identificador'): val = exp1.getval(entorno) posid = 1 else: return ("ERROR >> En la instrucción Delete hay problema con la expresión, debe ingresar un identificador antes del operador") for tabla in tablas: columnas=tabla.valor i=0 for columna in columnas: nombre = columna.nombre self.encabezados.append(nombre) if val == nombre: encontrado+=1 tipo=columna.tipo nocol=i nomtabla=tabla.nombre nomtabla=nomtabla.replace('_'+entorno.getDataBase(),'') continue i=i+1 if encontrado==1 and nocol>-1: datos=DBMS.extractTable(entorno.getDataBase(),nomtabla) if datos!= None: self.nombreres = nomtabla for i in range(0,len(datos)): dato=datos[i][nocol] expi = Terminal(tipo, dato) expd = exp2 if op in ('>','<','>=','<=','='): nuevaop = Relacional(expi,expd,op); if nuevaop.getval(entorno): 'Agrego la fila al resultado' filtrado.append(datos[i]) elif op in ('or','and','not'): nuevaop = Logica(expi,expd,op); if nuevaop.getval(entorno): 'Agrego la fila al resultado' filtrado.append(datos[i]) else: return ('ERROR >> En la instrucción Delete, el resultado del where no es booleano') return filtrado else: return ("ERROR >> En la instrucción Delete, el nombre de las columnas es ambiguo") else: return ("ERROR >> En la instrucción Delete, no ingreso una expresión relacional")
def ejecutar(self, ent:Entorno): dbActual = ent.getDataBase() tam = len(self.listaDef) print (tam) nuevaTabla = Simbolo(TipoSimbolo.TABLA,self.id) listaColumnas = [] for x in range(0,tam,1): tt = self.listaDef[x] if tt.tipo == AtributosColumna.COLUMNA_SIMPLE: self.numColumnas += 1 nuevaColumna = Simbolo(tt.tipoDato,tt.identificador) if tt.lista != None: #aca se mete si viene por ejemplo: columna1 integer references tabla2 tamano = len(tt.lista) for y in range(tamano): atrColumna = tt.lista[y] if atrColumna.tipo == AtributosColumna.UNICO: nuevoUnico = Simbolo(TipoSimbolo.CONSTRAINT_UNIQUE,atrColumna.valor) nuevoUnico.baseDatos = dbActual nuevoUnico.tabla = self.id ent.nuevoSimbolo(nuevoUnico) nuevaColumna.atributos.update({'unique':atrColumna.valor}) elif atrColumna.tipo == AtributosColumna.CHECK: nuevoCheck = Simbolo(TipoSimbolo.CONSTRAINT_CHECK,atrColumna.valor) nuevoCheck.baseDatos = dbActual nuevoCheck.tabla = self.id ent.nuevoSimbolo(nuevoCheck) nuevaColumna.atributos.update({'check':atrColumna.valor}) elif atrColumna.tipo == AtributosColumna.DEFAULT: nuevaColumna.atributos.update({'default':atrColumna.valor}) elif atrColumna.tipo == AtributosColumna.NO_NULO: nuevaColumna.atributos.update({'not null':True}) elif atrColumna.tipo == AtributosColumna.NULO: nuevaColumna.atributos.update({'null':True}) elif atrColumna.tipo == AtributosColumna.PRIMARY: nuevaPrimaria = Simbolo(TipoSimbolo.CONSTRAINT_PRIMARY,str("PK_" + self.id)) nuevaPrimaria.baseDatos = dbActual nuevaPrimaria.tabla = self.id ent.nuevoSimbolo(nuevaPrimaria) nuevaColumna.atributos.update({'primary':str("PK_" + self.id)}) elif atrColumna.tipo == AtributosColumna.REFERENCES: rr = DBMS.extractTable(dbActual,atrColumna.valor) if rr == []: return str("La tabla \'" + atrColumna.valor + "\' a la que está referenciando, no existe") else: nuevaForanea = Simbolo(TipoSimbolo.CONSTRAINT_FOREIGN,str("FK_" + self.id)) nuevaForanea.baseDatos = dbActual nuevaForanea.tabla = self.id ent.nuevoSimbolo(nuevaForanea) nuevaColumna.atributos.update({'foreign':str("FK_" + self.id)}) listaColumnas.append(nuevaColumna) #considerar la situacion de cuando no se haya creado la tabla pero ya se hayan #agregado los constraint a la tabla de simbolos nuevaTabla.valor = listaColumnas if dbActual != None: estado = DBMS.createTable(dbActual,self.id, self.numColumnas) if estado == 0: nuevaTabla.baseDatos = dbActual ent.nuevoSimbolo(nuevaTabla) DBMS.showCollection() return str("Tabla " + nuevaTabla.nombre + " creada exitosamente")
def ejecutar(self, ent: Entorno, imp=1): try: tablas = [] result = [] self.encabezado = [] aliast = [] 'Metodo Abstracto para ejecutar la instruccion' if self.distinct is None and self.froms is None and self.where is None and self.group is None and self.having is None and self.order is None and self.combinig is None: resultados = [] for exp in self.exps: if exp != None: res = exp.getval(ent) resultados.append(res.valor) variables.consola.insert(INSERT, str(res.valor)) variables.consola.insert(INSERT, '\n') return resultados elif self.froms != None and self.exps != None: for exp in self.froms: if isinstance(exp, Terminal): aliast.append('') tipo = exp.tipo tablas = self.gettablas(tipo, exp, ent, tablas) elif isinstance(exp, Alias): aliast.append(exp.nombre) expre = exp.expresion tipo = exp.tipo tablas = self.gettablas(tipo, expre, ent, tablas) if len(tablas) > 1: 'Obteniendo encabezados de las tablas' for tabla in tablas: cols = tabla.valor for columna in cols: nombre = columna.nombre self.encabezado.append( nombre + "." + tabla.nombre.replace('_' + ent.getDataBase(), '')) 'producto cartesiano' real = tablas[0].nombre.replace('_' + ent.getDataBase(), '') result = DBMS.extractTable(ent.getDataBase(), real) self.nombreres = real for i in range(0, len(tablas) - 1): real2 = tablas[i + 1].nombre.replace( '_' + ent.getDataBase(), '') self.nombreres += "_" + tabla.nombre.replace( '_' + ent.getDataBase(), '') tabla2 = DBMS.extractTable(ent.getDataBase(), real2) result = self.producto(result, tabla2) else: 'llenar resultado desde backend' real = tablas[0].nombre.replace('_' + ent.getDataBase(), '') result = DBMS.extractTable(ent.getDataBase(), real) 'encabezados 1 tabla' if (len(self.encabezado) == 0): for tabla in tablas: cols = tabla.valor for columna in cols: nombre = columna.nombre self.encabezado.append(nombre) #lleno arreglo de alias for exp in self.exps: self.aliast.append('') for x in range(0, len(self.exps)): if isinstance(self.exps[x], Alias): self.aliast[i] = self.exps[i].nombre # filtros if self.where != None: result = self.optwhere(ent, result, tablas) # combining(union,intersect,except) if self.combinig != None: datos2 = self.combinig.select.ejecutar(ent, 0) enc2 = datos2[0] res2 = datos2[1] result = self.m_combining(self.combinig, self.encabezado, result, enc2, res2) aber = result # limitar resultados if self.limit != None: a = self.limit result = self.m_limit(result, a.limit, a.off) # acceder a columnas if len(self.exps) == 1: if self.exps[0].tipo.tipo == 'identificador': newenc = [] 'obtengo solo columnas pedidas' for i in range(0, len(self.encabezado)): nombrediv = self.encabezado[i].split('.') nombrecol = nombrediv[0] if self.exps[0].getval(ent).valor == nombrecol: for x in range(0, len(result)): valcol = result[x][i] result[x] = [valcol] if (len(newenc) == 0): newenc.append(self.encabezado[i]) self.encabezado = newenc else: '' else: newenc = [] newres = [] for i in range(0, len(self.exps)): if isinstance(self.exps[i], Terminal): if self.exps[i].tipo.tipo == 'identificador': for j in range(0, len(self.encabezado)): nombrediv = self.encabezado[j].split('.') nombrecol = nombrediv[0] if self.exps[i].getval( ent).valor == nombrecol: newenc.append(self.encabezado[j]) for x in range(0, len(result)): valcol = result[x][j] if len(newres) != len(result): newres.append([valcol]) else: newres[x].append(valcol) else: if isinstance(self.exps[i], FuncionesNativas): newenc.append(self.exps[i].identificador) else: newenc.append('Exp' + len(newenc)) for fila in range(0, len(result)): exp = self.exps[i] res = self.resolver(exp, ent, result, tablas, fila) if len(newres) != len(result): newres.append([res.valor]) else: newres[fila].append(res.valor) result = newres self.encabezado = newenc #distinct if self.distinct != None: newres = [] 'elimino duplicados' for i in range(0, len(result)): encontrado = False fila = result[i] for j in range(0, len(result)): if j != i: if fila == result[j]: encontrado = True if encontrado == False: newres.append(fila) result = newres if imp == 1: self.mostarresult(result, self.encabezado, self.nombreres) return [self.encabezado, result] except Exception as inst: print(inst) return
def where2id(self,entorno,tablas): filtrado=[] exp1:Expresion exp2:Expresion colres=[] tipo1='' tipo2= '' encontrado1=0 encontrado2= 0 nocol1 = -1 nocol2 = -1 nomtabla1 = '' nomtabla2 = '' 'realizar operacion' exp1=self.where.exp1 exp2=self.where.exp2 val1=exp1.getval(entorno) val2=exp2.getval(entorno) op=self.where.operador for tabla in tablas: columnas=tabla.valor i=0 for columna in columnas: nombre = columna.nombre self.encabezado.append(nombre) if val1 == nombre: encontrado1+=1 tipo1=columna.tipo nocol1=i nomtabla1=tabla.nombre nomtabla1=nomtabla1.replace('_'+entorno.getDataBase(),'') i=i+1 continue if val2 == nombre: encontrado2+=1 tipo2=columna.tipo nocol2 = i nomtabla2=tabla.nombre nomtabla2=nomtabla2.replace('_'+entorno.getDataBase(),'') i=i+1 continue i=i+1 if encontrado1 == 1 and encontrado2 == 1: datos1 = DBMS.extractTable(entorno.getDataBase(),nomtabla1) datos2 = DBMS.extractTable(entorno.getDataBase(), nomtabla2) if datos1 == datos2: self.nombreres=nomtabla1 for i in range(0,len(datos1)): dato1=datos1[i][nocol1] dato2=datos1[i][nocol2] expi = Terminal(tipo1, dato1) expd = Terminal(tipo2, dato2) if op in ('>','<','>=','<=','='): nuevaop = Relacional(expi,expd,op); if nuevaop.getval(entorno): 'Agrego la fila al resultado' filtrado.append(datos1[i]) elif op in ('or','and','not'): nuevaop = Logica(expi,expd,op); if nuevaop.getval(entorno): 'Agrego la fila al resultado' filtrado.append(datos1[i]) else: variables.consola.insert('Error el resultado del where no es booleano \n') return filtrado else: variables.consola.insert('Error el nombre de las columnas es ambiguo \n')
def execwhere(self,entorno,tablas): filtrado=[] exp1:Expresion exp2:Expresion colres=[] tipo='' isid=False posid=-1 if isinstance(self.where, Relacional) or isinstance(self.where,Logica): encontrado=0 nocol=-1 nomtabla='' 'realizar operacion' exp1=self.where.exp1 exp2=self.where.exp2 op=self.where.operador val='' if(exp1.tipo.tipo=='identificador') and exp2.tipo.tipo=='identificador': return self.where2id(entorno,tablas) elif (exp1.tipo.tipo=='identificador'): val = exp1.getval(entorno) posid = 1 else: val = exp2.getval(entorno) posid=2 for tabla in tablas: columnas=tabla.valor i=0 for columna in columnas: nombre = columna.nombre self.encabezado.append(nombre) if val == nombre: encontrado+=1 tipo=columna.tipo nocol=i nomtabla=tabla.nombre nomtabla=nomtabla.replace('_'+entorno.getDataBase(),'') continue i=i+1 if encontrado==1 and nocol>-1: datos=DBMS.extractTable(entorno.getDataBase(),nomtabla) if datos!= None: self.nombreres = nomtabla for i in range(0,len(datos)): dato=datos[i][nocol] expi = None expd = None if posid == 1: expi = Terminal(tipo, dato) expd = exp2 else: expi = exp1 expd = Terminal(tipo, dato) if op in ('>','<','>=','<=','='): nuevaop = Relacional(expi,expd,op); if nuevaop.getval(entorno): 'Agrego la fila al resultado' filtrado.append(datos[i]) elif op in ('or','and','not'): nuevaop = Logica(expi,expd,op); if nuevaop.getval(entorno): 'Agrego la fila al resultado' filtrado.append(datos[i]) else: variables.consola.insert('Error el resultado del where no es booleano \n') return filtrado else: variables.consola.insert('Error el nombre de las columnas es ambiguo \n') elif isinstance(self.where,Unaria): 'busco columna y resulvo unaria' else: 'ya veremos dijo el ciego'
def ejecutar(self,ent:Entorno): tablas = [] result = [] self.encabezado = [] 'Metodo Abstracto para ejecutar la instruccion' if self.distinct is None and self.froms is None and self.where is None and self.group is None and self.having is None and self.order is None and self.combinig is None: resultados = []; for exp in self.exps: if exp != None: resultados.append(exp.getval(ent)) return resultados elif self.froms != None and self.exps!= None: for exp in self.froms: if exp != None: tipo =exp.tipo; if tipo.tipo=='identificador': nombre=exp.getval(ent) self.nombreres = nombre tabla=ent.buscarSimbolo(nombre+"_"+ent.getDataBase()) if tabla!=None: tablas.append(tabla) else: return ("ERROR >> En la instrucción Select, la tabla: "+nombre+" NO EXISTE") else: return ("ERROR >> En la instrucción Select, ingreso un nombre de tabla incorrecto") else: return ("Algo paso") if len(tablas)>1: 'producto cartesiano' 'Obteniendo encabezados de las tablas' postab = 1 for tabla in tablas: cols = tabla.valor for columna in cols: nombre = columna.nombre self.encabezados.append(nombre+"_T"+str(postab)) postab = postab +1 'producto cartesiano' real = tablas[0].nombre.replace('_' + ent.getDataBase(), '') result = DBMS.extractTable(ent.getDataBase(), real) self.nombreres = real+"(T1)" for i in range(0, len(tablas)-1): real2 = tablas[i+1].nombre.replace('_' + ent.getDataBase(), '') self.nombreres += '_' + real2 + "(T"+str(i+2)+")" tabla2 = DBMS.extractTable(ent.getDataBase(), real2) result = self.producto(result, tabla2) else: 'llenar resultado desde backend' real=tablas[0].nombre.replace('_'+ent.getDataBase(),'') result=DBMS.extractTable(ent.getDataBase(),real) #filtros if self.where != None: result=self.execwhere(ent,tablas) else: if (len(self.encabezados)==0): for tabla in tablas: cols = tabla.valor for columna in cols: nombre = columna.nombre self.encabezados.append(nombre) #acceder a columnas if len(self.exps) == 1: if self.exps[0].getval(ent) == '*': self.mostarresult(result, self.nombreres) elif self.exps[0].tipo.tipo=='identificador': 'obtengo solo columnas pedidas' else: 'pendientes subconsultas y funciones'
j.alterAddPK('BD1', 'personas', [0]) j.alterAddPK('BD1', 'pais', [0]) j.alterAddPK('BD1', 'idiomas', [0]) # insert data in countries j.insert('BD1', 'pais', ['GTM', 'Guatemala', 'Central America', 108889]) j.insert('BD1', 'pais', ['MX', 'Mexico', 'Norte America', 21041]) j.insert('BD1', 'pais', ['EEUU', 'Estados Unidos', 'Norte America', 21041]) # insert data in cities j.insert('BD1', 'personas', [1, 'Jossie', 'Castrillo','27', 'GTM']) j.insert('BD1', 'personas', [2, 'Juanpi', 'Garcia','27', 'GTM']) j.insert('BD1', 'personas', [3, 'Byron', 'Cermeno','27', 'GTM']) j.insert('BD1', 'personas', [4, 'Hayrton', 'Ixpata','27', 'GTM']) j.insert('BD1', 'personas', [5, 'Dulce', 'DeLeon','25', 'MX']) j.insert('BD1', 'personas', [6, 'Miguel', 'Basir','26', 'GTM']) j.insert('BD1', 'personas', [7, 'Nose', 'Algo','30', 'EEUU']) # inser data in languages j.insert('BD1', 'idiomas', ['GTM', 'Espanol', 'official', 64.7]) j.insert('BD1', 'idiomas', ['EEUU', 'Espanol', 'official', 100.0]) j.insert('BD1', 'idiomas', ['MX', 'Espanol', 'official', 100.0]) # show all data #j.showCollection() a=j.extractTable("BD1", "personas") horaActual= datetime.now().strftime("%H:%M:%S") print(horaActual)
# JSON Mode Test File # Released under MIT License # Copyright (c) 2020 TytusDb Team from storageManager import jsonMode as j print(j.extractTable('compiladores2', 'USUARIO')) # create database j.createDatabase('world') j.createTable('world', 'cities', 4) # create simple primary keys j.alterAddPK('world', 'cities', [0]) # insert data in cities j.insert('world', 'cities', [1, 'Guatemala', 'Guatemala', 'GTM']) j.insert('world', 'cities', [2, 'Cuilapa', 'Santa Rosa', 'GTM']) j.insert('world', 'cities', [3, 'San Salvador', 'San Salvador', 'SLV']) j.insert('world', 'cities', [4, 'San Miguel', 'San Miguel', 'SLV']) # show all datap print(j.extractTable('world', 'cities')) #SELECT print(j.update('world', 'cities', { 1: 'Mexico', 3: 'MX' }, [1])) print(j.extractTable('world', 'cities')) #SELECT
# test Databases CRUD print(j.createDatabase('db1')) # 0 print(j.createDatabase('db1')) # 2 print(j.createDatabase('db4')) # 0 print(j.createDatabase('db5')) # 0 print(j.createDatabase(0)) # 1 print(j.alterDatabase('db5', 'db1')) # 3 print(j.alterDatabase('db5', 'db2')) # 0 print(j.dropDatabase('db4')) # 0 print(j.showDatabases()) # ['db1','db2'] # test Tables CRUD print(j.createTable('db1', 'tb4', 3)) # 0 print(j.createTable('db1', 'tb4', 3)) # 3 print(j.createTable('db1', 'tb1', 3)) # 0 print(j.createTable('db1', 'tb2', 3)) # 0 print(j.alterTable('db1', 'tb4', 'tb3')) # 0 print(j.dropTable('db1', 'tb3')) # 0 print(j.alterAddPK('db1', 'tb1', 0)) # 1 print(j.alterAddPK('db1', 'tb1', [0])) # 0 print(j.showTables('db1')) # ['tb1', 'tb2'] # test Registers CRUD print(j.insert('db1', 'tb1', [1, 1])) # 5 print(j.insert('db1', 'tb1', ['1', 'line', 'one'])) # 0 print(j.loadCSV('tb1.csv', 'db1', 'tb1')) # [0, 0, 0, 0, 0] print(j.extractTable('db1', 'tb1')) # [['1', 'line', 'one'], ['2', 'line', 'two'], # ['3', 'line', 'three'], ['4', 'line', 'four'], # ['5', 'line', 'five'], ['6', 'line', 'six']]