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 execute(self, environment):
if not isinstance(self.name,str):
return {'Error': 'El nombre indicado de la base de datos no es una cadena.', 'Fila':self.row, 'Columna': self.column }
result = 3
result = admin.createDatabase(self.name) #<---------------------------
if result == 0:
#Se creo la base de datos correctamente.
environment.createDataBase(self.name)#Guardamos la metadata en el entorno global.
return 'La base de datos ' + self.name + ' ha sido creada con éxito.'
elif result == 1:
#Error al crear
return {'Error':'Ocurrió un error en el storage manager. ' + self.name + ' no pudo ser creada.', 'Fila':self.row, 'Columna':self.column}
elif result == 2:
#Base de datos existente
if self.replace == True:
admin.dropDatabase(self.name)
result = admin.createDatabase(self.name)
environment.deleteDataBase(self.name)
environment.createDataBase(self.name)
switcher = {
0:'La base de datos ' + self.name +' ha sido reemplazada con éxito',
1:{'Error':'Ocurrió un error en el storage manager.' + self.name + ' no pudo ser reemplazada.', 'Fila':self.row, 'Columna':self.column},
2:{'Error':'La Base de datos' + self.name +'no pudo ser reemplazada.', 'Fila':self.row, 'Columna':self.column}
}
return switcher.get(result, {'Error':'Error desconocido al intentar realizar el replace de ' + self.name,'Fila': self.row, 'Columna': self.column})
else:
return {'Error': "La base de datos que se desea crear ya existe.", 'Fila': self.row, 'Columna': self.column}
else:
return {'Error': "Error desconocido en el storage manager.", 'Fila': self.row, 'Columna': self.column}
def EDropDatabase():
cargarMemoria()
#llamar la funcion de EDD
if (len(listaMemoria) > 0):
print("base de datos eliminada:", listaMemoria[0])
EDD.dropDatabase(listaMemoria[0])
listaMemoria.pop(0)
def procesar_dropdb(query,ts):
if store.dropDatabase(query.id) == 0:
print("LA BASE DE DATOS "+str(query.id)+" HA SIDO ELIMINADA")
# ----------------------------------------------------------------------------------------------------------------
elif store.dropDatabase(query.id) == 2:
print("LA BASE DE DATOS "+str(query.id)+" NO EXISTE")
# ----------------------------------------------------------------------------------------------------------------
elif store.dropDatabase(query.id) == 1:
print("ERROR :(")
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):
exito = 0
databases = DBMS.showDatabases()
if self.reemplazo:
if self.nombre in databases: #Eliminamos si existe
DBMS.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)
return exito
def deleteDatabase(self, name: str, line, column):
"""
Method to remove a database in type checker
:param name: The name of the database
:param line: The instruction line
:param column: The instruction column
:return: Returns nothing
"""
dbStatement = jsonMode.dropDatabase(name)
if dbStatement == 0:
database = self.searchDatabase(name)
self._typeCheckerList.remove(database)
self.writeFile()
SymbolTable().delete(database)
print('Database deleted successfully')
elif dbStatement == 1:
desc = f": Can't drop database {name}"
ErrorController().addExecutionError(34, 'Execution', desc, line,
column)
elif dbStatement == 2:
desc = f": Database {name} does not exist"
ErrorController().addExecutionError(35, 'Execution', desc, line,
column)
def procesar_createDatabase(instr,ts,tc) :
if instr.replace == 1:
result = j.dropDatabase(str(instr.nombre.id))
global salida
if result == 1 :
salida = "\nERROR: internal_error \nSQL state: XX000 "
result1 = j.createDatabase(str(instr.nombre.id))
if result1 == 0:
temp1 = TS.Simbolo(instr.nombre.id,'Database',0,"")
ts.agregar(temp1)
salida = "\nCREATE DATABASE"
elif result1 == 1 :
salida = "\nERROR: internal_error \nSQL state: XX000 "
else:
result1 = j.createDatabase(str(instr.nombre.id))
if result1 == 0:
salida = "\nCREATE DATABASE"
temp1 = TS.Simbolo(instr.nombre.id,'Database',0,"")
ts.agregar(temp1)
elif result1 == 1 :
salida = "\nERROR: internal_error \nSQL state: XX000 "
elif result1 == 2 :
salida = "\nERROR: database \"" + str(instr.nombre.id) +"\" already exists \nSQL state: 42P04 "
def deleteDatabase(self, databaseName: str):
dbStatement = jsonMode.dropDatabase(databaseName)
if dbStatement == 0:
database = self.searchDatabase(databaseName)
self._typeCheckerList.remove(database)
self.writeFile()
print('Database deleted successfully')
elif dbStatement == 1:
print(f"Can't drop database '{databaseName}'")
elif dbStatement == 2:
print("Database doesn't exist")
def ejecutar(self, ent):
self.traducir(ent)
if self.orreplace == 'or replace' and self.ifnotexist == 'if not exists':
resultado = DBMS.createDatabase(self.id)
# print("crear base de datos con if not existe y replace ",resultado)
if (resultado == 2):
print("ya existe base de datos pero no da error ")
else:
variables.consola.insert(INSERT, 'La base de datos: (' + self.id + ') ha sido creada con exito\n')
return
elif self.orreplace == 'or replace' and self.ifnotexist == '':
resultado = DBMS.dropDatabase(self.id)
# print("crear base de datos o reemplazarlo",resultado)
if (resultado == 2):
print('')
else:
ent.eliminarDataBase(self.id)
res = DBMS.createDatabase(self.id)
if (res == 2):
print("ya existe base de datos pero debio reemplazarlo :( ")
else:
variables.consola.insert(INSERT, 'La base de datos: (' + self.id + ') ha sido creada con exito\n')
return
elif self.orreplace == 'databases' and self.ifnotexist == 'if not exists':
resultado = DBMS.createDatabase(self.id)
# print("crear base de datos con if not existe",resultado)
if (resultado == 2):
print("ya existe base de datos pero no da error ")
else:
variables.consola.insert(INSERT, 'La base de datos: (' + self.id + ') ha sido creada con exito\n')
return
else:
res = DBMS.createDatabase(self.id)
# print("Crear base de datos sin replace y sin exist",res)
if (res == 2):
variables.consola.insert(INSERT,
'ERROR >> En la instrucción Create Databasem' + self.id + ' , La base de datos YA EXISTE\n')
reporteerrores.append(Lerrores("Error Semantico",
'Instrucción Create Database ' + self.id + ' La base de datos YA EXISTE',
'', ''))
return
else:
variables.consola.insert(INSERT, 'La base de datos: (' + self.id + ' ) ha sido creada con exito\n')
return
def ejecutar(self, ent):
self.traducir(ent)
resultado = DBMS.dropDatabase(self.id)
if (resultado == 2):
variables.consola.insert(INSERT,
'ERROR >> En la instrucción Drop Database ' + self.id + ', La base de datos a eliminar NO EXISTE\n')
reporteerrores.append(
Lerrores("Error Semantico", 'Instrucción Drop Database ' + self.id + ' La base de datos NO EXISTE', '',
''))
return
else:
ent.eliminarDataBase(self.id)
variables.consola.insert(INSERT, 'La base de datos: (' + self.id + ' ) ha sido eliminada con exito\n')
return
def dropDB(self, nodo):
if nodo.valor in self.ts:
result = jsonMode.dropDatabase(nodo.valor)
del self.ts[nodo.valor]
if result == 0:
self.output.append('Base de datos \"' + nodo.valor +
'\" botada exitosamente.')
elif result == 1:
self.errors.append(
Error('XX000', EType.SEMANTICO, 'internal_error',
nodo.linea))
elif result == 2: # Base de datos inexistente
self.errors.append(
Error('-----', EType.SEMANTICO, 'database_non_exist',
nodo.linea))
def execute(self, environment):
if not isinstance(self.name,str):
return {'Error': 'El nombre indicado de la base de datos no es una cadena.', 'Fila':self.row, 'Columna': self.column }
result = 3
result = admin.dropDatabase(self.name) #<---------------------------
if result == 0:
#Se elimino correctamente la base de datos
environment.deleteDataBase(self.name)
return 'Se elimino exitosamente la base de datos: ' + self.name
elif result == 1:
#Error al crear
return {'Error':'Ocurrió un error en el storage manager. No se pudo eliminar la base de datos:' + self.name, 'Fila':self.row, 'Columna':self.column}
elif result == 2:
#Base de datos:oldName no existe
return {'Error':'No existe la base de datos con el nombre: ' + self.name, 'Fila':self.row, 'Columna':self.column}
else:
return {'Error': "Error desconocido en el storage manager.", 'Fila': self.row, 'Columna': self.column}
def dropDatabase(self, database: str, line: int):
# 0 -> operación exitosa
# 1 -> error en la operación
# 2 -> base de datos no existente
query_result = jsonMode.dropDatabase(database)
if query_result == 0:
self.consola.append(
Codigos().successful_completion('DROP DATABASE «' + database +
'»'))
self.type_checker.pop(database)
self.tabla_simbolos.simbolos.pop(database)
if self.actual_database == database:
self.actual_database = ''
self.saveTypeChecker()
elif query_result == 1:
self.addError(Codigos().database_internal_error(database), line)
else:
self.addError(Codigos().database_undefined_object(database), line)
def dropDatabase(self, database: str, line: int):
# 0 -> operación exitosa
# 1 -> error en la operación
# 2 -> base de datos no existente
query_result = jsonMode.dropDatabase(database)
if query_result == 0:
self.consola.append(Codigos().successful_completion('DROP DATABASE'))
self.type_checker.pop(database)
self.tabla_simbolos.simbolos.pop(database)
if self.actual_database == database:
self.actual_database = ''
elif query_result == 1:
error = Codigos().database_internal_error(database)
self.consola.append(error)
self.tabla_errores.agregar(Error('Semántico', error, line))
else:
error = Codigos().database_undefined_object(database)
self.consola.append()
self.tabla_errores.agregar(Error('Semántico', error, line))
def execute(self, environment):
if (self.structure == "TABLE"):
if dbtemp != "":
valor = jsonMode.dropTable(dbtemp, self.name)
if valor == 2:
return "La base de datos no existe"
if valor == 3:
return "La tabla no existe en la base de datos"
if valor == 1:
return "Hubo un problema en la ejecucion de la sentencia"
if valor == 0:
return "Instruccion ejecutada con exito"
return "El nombre de la base de datos no esta especificado operacion no realizada"
else:
valor = jsonMode.dropDatabase(self.name)
if valor == 1:
return "Hubo un problema en la ejecucion de la sentencia"
if valor == 2:
return "La base de datos no existe"
if valor == 0:
return "Instruccion ejecutada con exito"
def procesar_dropDatabase(instr,ts,tc):
global salida
result = j.dropDatabase(str(instr.id.id))
if instr.exists == 0:
global salida
if result == 0:
global salida
salida = "\nDROP DATABASE"
ts.deleteDatabase(instr.id.id)
tc.eliminarDatabase(instr.id.id)
elif result == 1 :
salida = "\nERROR: internal_error \nSQL state: XX000 "
print("ERROR: internal_error \nSQL state: XX000 ")
elif result == 2 :
salida = "\nERROR: database \"" + str(instr.id.id) +"\" does not exist \nSQL state: 3D000"
else:
if result == 0:
salida = "\nDROP DATABASE"
elif result == 1 :
salida = "\nERROR: internal_error \nSQL state: XX000 "
elif result == 2 :
salida = "\nERROR: database \"" + str(instr.id.id) +"\" does not exist, skipping DROP DATABASE"
def dropDatabase(self, database):
if existeBase(database) == 1:
self.tabla.eliminarTS_Base(database)
EDDResp.dropdatabase(condb.dropDatabase(database))
# JSON Mode Test File
# Released under MIT License
# Copyright (c) 2020 TytusDb Team
from storageManager import jsonMode as j
# create db1 and db2, return two 0's and show return list
print(j.createDatabase("db1"))
print(j.createDatabase("db2"))
print(j.showDatabases())
# try create db1 and db2, return error value 2 and show return list
print(j.createDatabase("db1"))
print(j.createDatabase("db2"))
print(j.showDatabases())
# rename db1 to db3, return 0 and show return list
print(j.alterDatabase("db1", "db3"))
print(j.showDatabases())
# rename db2 to db1, return 0 and show return list
print(j.alterDatabase("db2", "db1"))
print(j.showDatabases())
# drop db3 and db1, return two 0's
print(j.dropDatabase("db3"))
print(j.dropDatabase("db1"))
# show empty-list of databases
print(j.showDatabases())
def crearBase(nodo, tablaSimbolos):
val = nodo.id.valor
global consola
if nodo.replace == False and nodo.exists == False:
if nodo.owner == False and nodo.mode == False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, None, None)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
else:
consola += "Error al crear la base de datos \n"
elif nodo.owner == False and nodo.mode != False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, None, nodo.mode)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
else:
consola += "Error al crear la base de datos \n"
elif nodo.owner != False and nodo.mode == False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, nodo.owner, None)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
else:
consola += "Error al crear la base de datos \n"
elif nodo.owner != False and nodo.mode != False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, nodo.owner, nodo.mode)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
else:
consola += "Error al crear la base de datos \n"
elif nodo.replace != False and nodo.exists == False:
jBase.dropDatabase(val)
if nodo.owner == False and nodo.mode == False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, None, None)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
else:
consola += "Error al crear la base de datos \n"
elif nodo.owner == False and nodo.mode != False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, None, nodo.mode)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
else:
consola += "Error al crear la base de datos \n"
elif nodo.owner != False and nodo.mode == False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, nodo.owner, None)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
else:
consola += "Error al crear la base de datos \n"
elif nodo.owner != False and nodo.mode != False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, nodo.owner, nodo.mode)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
else:
consola += "Error al crear la base de datos \n"
elif nodo.replace == False and nodo.exists != False:
if nodo.owner == False and nodo.mode == False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, None, None)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
elif jBase.createDatabase(val) == 2:
consola += "La base de datos " + val + " ya existe. \n"
else:
consola += "Error al crear la base de datos \n"
elif nodo.owner == False and nodo.mode != False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, None, nodo.mode)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
elif jBase.createDatabase(val) == 2:
consola += "La base de datos " + val + " ya existe. \n"
else:
consola += "Error al crear la base de datos \n"
elif nodo.owner != False and nodo.mode == False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, nodo.owner, None)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
elif jBase.createDatabase(val) == 2:
consola += "La base de datos " + val + " ya existe. \n"
else:
consola += "Error al crear la base de datos \n"
elif nodo.owner != False and nodo.mode != False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, nodo.owner, nodo.mode)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
elif jBase.createDatabase(val) == 2:
consola += "La base de datos " + val + " ya existe. \n"
else:
consola += "Error al crear la base de datos \n"
def interpretar_sentencias(arbol, tablaSimbolos):
jBase.dropAll()
global consola
for nodo in arbol:
if isinstance(nodo, SCrearBase):
print("Creando Base-----")
crearBase(nodo, tablaSimbolos)
# aqui va el metodo para ejecutar crear base
elif isinstance(nodo, SShowBase):
print("Mostrando Base-----")
if nodo.like == False:
bases = jBase.showDatabases()
for base in bases:
consola += base + "\n"
else:
bases = jBase.showDatabases()
basn = []
for base in bases:
basn.append(base)
basn2 = []
r = re.compile(".*" + nodo.cadena + ".*")
basn2 = list(filter(r.match, basn))
for bas in basn2:
consola += bas + "\n"
# aqui va el metodo para ejecutar show base
elif isinstance(nodo, SUse):
global useActual
useActual = nodo.id
elif isinstance(nodo, SAlterBase):
print("Alterando Base-----")
AlterDatabase(nodo, tablaSimbolos)
# aqui va el metodo para ejecutar alter base
elif isinstance(nodo, SDropBase):
print("Drop Base-----")
if nodo.exists == False:
db = jBase.dropDatabase(nodo.id.valor)
if db == 2:
listaSemanticos.append(
Error.ErrorS(
"Error Semantico", "Error la base de datos " +
nodo.id.valor + " no existe"))
elif db == 1:
listaSemanticos.append(
Error.ErrorS("Error Semantico",
"Error en la operacion."))
else:
b = tablaSimbolos.eliminar(nodo.id.valor)
if b == True:
consola += "La base de datos " + nodo.id.valor + " se elimino con exito. \n"
else:
db = jBase.dropDatabase(nodo.id.valor)
if db == 1:
listaSemanticos.append(
Error.ErrorS("Error Semantico",
"Error en la operacion."))
elif db == 0:
b = tablaSimbolos.eliminar(nodo.id.valor)
if b == True:
consola += "La base de datos " + nodo.id.valor + " se elimino con exito. \n"
else:
consola += "Error no se pudo elminar la base " + nodo.id.valor + " de la tabla de simbolos \n"
# aqui va el metodo para ejecutar drop base
elif isinstance(nodo, STypeEnum):
print("Enum Type------")
print(nodo.id)
for val in nodo.lista:
print(val.valor)
elif isinstance(nodo, SUpdateBase):
print("Update Table-----------")
print(nodo.id)
for val in nodo.listaSet:
print("columna------")
print(val.columna)
print("------------")
if isinstance(val.valor, SOperacion):
val2 = val.valor
print(val2.opIzq.valor)
print(val2.operador)
print(val2.opDer.valor)
else:
val2 = val.valor
print(val2.valor)
print(nodo.listaWhere)
elif isinstance(nodo, SDeleteBase):
print("Delete Table-------------")
print(nodo.id)
print("Tiene where?")
print(nodo.listaWhere)
elif isinstance(nodo, STruncateBase):
print("Truncate Table------------")
for id in nodo.listaIds:
print(id)
elif isinstance(nodo, SInsertBase):
print("Insert Table-------------")
print("nombre tabla")
print(nodo.id)
print("valores")
for val in nodo.listValores:
if isinstance(val, SExpresion):
print(val.valor)
elif isinstance(nodo, SShowTable):
print("Mostrando tablas----------")
tablas = jBase.showTables(useActual)
for tabla in tablas:
consola += tabla + "\n"
elif isinstance(nodo, SDropTable):
print("Drop table-----------")
bandera = True
for fk in listaFK:
if fk.idtlocal == nodo.id:
bandera = False
if bandera:
b = jBase.dropTable(useActual, nodo.id)
if b == 0:
base = tablaSimbolos.get(useActual)
if base.deleteTable(nodo.id) == True:
consola += "La tabla " + nodo.id + " de la base " + useActual + " se eliminó con éxito. \n"
else:
consola += "Error no se pudo eliminar la tabla " + nodo.id + " de la tabla de simbolos \n"
elif b == 2:
listaSemanticos.append(
Error.ErrorS(
"Error Semantico",
"Error la base de datos " + useActual +
" no existe, No se puede eliminar la tabla " +
nodo.id))
elif b == 3:
listaSemanticos.append(
Error.ErrorS(
"Error Semantico", "Error la tabla " + nodo.id +
" no existe en la base de datos " + useActual))
elif b == 1:
listaSemanticos.append(
Error.ErrorS("Error Semantico",
"Error en la operacion."))
else:
consola += "No se puede eliminar la tabla debido a que esta siendo referenciada por una llave foranea \n"
elif isinstance(nodo, SAlterTableRenameColumn):
print("Cambiando nombre columna---")
AlterRenameColumn(nodo, tablaSimbolos)
elif isinstance(nodo, SAlterRenameTable):
AlterRenameTable(nodo, tablaSimbolos)
elif isinstance(nodo, SAlterTableAddColumn):
print("Agregando Columna-----")
AlterAddColumn(nodo, tablaSimbolos)
elif isinstance(nodo, SAlterTableCheck):
print("Agregando check--------")
AlterTableCheck(nodo, tablaSimbolos)
elif isinstance(nodo, SAlterTableAddUnique):
print("Agregando unique-------")
AlterTableUnique(nodo, tablaSimbolos)
elif isinstance(nodo, SAlterTableAddFK):
print("Agregando llave foranea--------")
AlterTableFK(nodo, tablaSimbolos)
elif isinstance(nodo, SAlterTable_AlterColumn):
print("Alter column--------------")
print(nodo.idtabla)
for col in nodo.columnas:
print(col.idcolumna)
elif isinstance(nodo, SAlterTableDrop):
print("Alter drop----------")
print(nodo.idtabla)
print("Es un constraint?")
print(nodo.idco)
elif isinstance(nodo, SCrearTabla):
crearTabla(nodo, tablaSimbolos)
# FRANCISCO
elif isinstance(nodo, Squeries):
print("Entró a Query")
if nodo.ope == False:
print("Query Simple")
if isinstance(nodo.query1, SQuery):
Qselect = nodo.query1.select
Qffrom = nodo.query1.ffrom
Qwhere = nodo.query1.where
Qgroupby = nodo.query1.groupby
Qhaving = nodo.query1.having
Qorderby = nodo.query1.orderby
Qlimit = nodo.query1.limit
# SELECT
if isinstance(Qselect, SSelectCols):
print("Entro a Select")
# Distinct
if Qselect.distinct != False:
print("Distinct True")
# Cantidad de columnas
if Qselect.cols == "*":
print("Todas las Columnas")
else:
print("Columnas Específicas")
for col in Qselect.cols:
##LISTAS
if isinstance(col.cols, SExpresion):
print("Expre")
print(col.cols.valor)
# print("Tipo")
# print(col.cols.tipo)
elif isinstance(col.cols, SOperacion):
print("Operación")
if isinstance(col.cols.opIzq, SExpresion):
print(col.cols.opIzq.valor)
print(col.cols.operador)
print(col.cols.opDer.valor)
##FUNCIONES DE AGREGACION
elif isinstance(col.cols, SFuncAgregacion):
print("Funcion Agregación:")
print(col.cols.funcion)
if isinstance(col.cols.param, SExpresion):
print("val")
print(col.cols.param.valor)
else:
print("val")
print(col.cols.param)
##FUNCIONES MATH
elif isinstance(col.cols, SFuncMath):
print("Funcion Math:")
print(col.cols.funcion)
if isinstance(col.cols.param, SExpresion):
print("param")
print(col.cols.param.valor)
else:
print("param")
print(col.cols.param)
elif isinstance(col.cols, SFuncMath2):
print("Funcion Math2:")
print(col.cols.funcion)
if isinstance(col.cols.param, SExpresion):
print("params")
print(col.cols.param.valor)
print(col.cols.param2.valor)
else:
print("params")
print(col.cols.param)
print(col.cols.param2)
elif isinstance(col.cols, SFuncMathSimple):
print("Funcion MathSimple:")
print(col.cols.funcion)
##FUNCIONES TRIG
elif isinstance(col.cols, SFuncTrig):
print("Funcion Trig1:")
print(col.cols.funcion)
if isinstance(col.cols.param, SExpresion):
print("param")
print(col.cols.param.valor)
else:
print("param")
print(col.cols.param)
elif isinstance(col.cols, SFuncTrig2):
print("Funcion Trig2:")
print(col.cols.funcion)
if isinstance(col.cols.param, SExpresion):
print("params")
print(col.cols.param.valor)
print(col.cols.param2.valor)
else:
print("params")
print(col.cols.param)
print(col.cols.param2)
##FUNCIONES BINARIAS
elif isinstance(col.cols, SFuncBinary):
print("Funcion Binaria1:")
print(col.cols.funcion)
if isinstance(col.cols.param, SExpresion):
print("param")
print(col.cols.param.valor)
else:
print("param")
print(col.cols.param)
elif isinstance(col.cols, SFuncBinary2):
print("Funcion Binaria2:")
print(col.cols.funcion)
if isinstance(col.cols.param, SExpresion):
print("params")
print(col.cols.param.valor)
print(col.cols.param2.valor)
else:
print("params")
print(col.cols.param)
print(col.cols.param2)
elif isinstance(col.cols, SFuncBinary3):
print("Funcion Binaria3:")
print(col.cols.funcion)
if isinstance(col.cols.param, SExpresion):
print("params")
print(col.cols.param.valor)
print(col.cols.param.det)
print(col.cols.param2.valor)
else:
print("params")
print(col.cols.param)
print(col.cols.det)
print(col.cols.param2)
elif isinstance(col.cols, SFuncBinary4):
print("Funcion Binaria4:")
print(col.cols.funcion)
if isinstance(col.cols.param, SExpresion):
print("params")
print(col.cols.param.valor)
print(col.cols.param2.valor)
print(col.cols.param3.valor)
else:
print("params")
print(col.cols.param)
print(col.cols.param2)
print(col.cols.param3)
# EXTRACT
elif isinstance(col.cols, SExtract):
print("Funcion Extract:")
if isinstance(col.cols.field, STipoDato):
print(col.cols.field.dato)
print(col.cols.field.tipo)
print(col.cols.field.cantidad)
print(col.cols.timestampstr)
elif isinstance(col.cols, SExtract2):
print("Funcion Extract2:")
if isinstance(col.cols.field, STipoDato):
print(col.cols.field.dato)
print(col.cols.dtype.dato)
if isinstance(col.cols.timestampstr,
SExpresion):
print("param")
print(col.cols.timestampstr.valor)
# FUNCIONES DE FECHA
elif isinstance(col.cols, SSelectFunc):
print("Funcion getFecha:")
print(col.cols.id)
elif isinstance(col.cols, SFechaFunc):
print("Funcion Fecha:")
if isinstance(col.cols.param, STipoDato):
print(col.cols.param.valor)
print(col.cols.param2.valor)
else:
print(col.cols.param)
print(col.cols.param2)
elif isinstance(col.cols, SFechaFunc2):
print("Funcion Fecha2:")
print(col.cols.id)
print(col.cols.param)
print(col.cols.tipo)
print(col.cols.param2)
# CASE
elif isinstance(col.cols, SCase):
print("Funcion Case:")
if isinstance(col.cols.casos, SCaseList):
print(col.cols.casos.param)
print(col.cols.casos.param2)
print(col.cols.casos.clist)
elif isinstance(col.cols, SCaseElse):
print("Funcion CaseElse:")
if isinstance(col.cols.casos, SCaseList):
print(col.cols.casos.param)
print(col.cols.casos.param2)
print(col.cols.casos.clist)
print(col.cols.casoelse)
# OTRAS FUNCIONES
elif isinstance(col.cols, SColumnasSubstr):
print("Funcion Substr:")
print(col.cols.st)
print(col.cols.st2)
print(col.cols.st3)
elif isinstance(col, SColumnasGreatest):
print("Funcion Greatest:")
print(col.cols)
elif isinstance(col.cols, SColumnasLeast):
print("Funcion Least:")
print(col.cols)
else:
print("Otro")
print(col.cols)
# ALIAS
if col.id != False:
if isinstance(col.id, SExpresion):
print("Alias")
print(col.id.valor)
# FROM
if isinstance(Qffrom, SFrom):
print("entro al From")
for col in Qffrom.clist:
if isinstance(col, SAlias):
if col.alias == False:
print("id")
print(col.id)
else:
print("id/alias")
print(col.id)
print(col.alias)
elif isinstance(Qffrom, SFrom2):
print("entro al From2")
# Subquerie
print(Qffrom.clist)
print(Qffrom.id)
else:
print("Otro From")
# WHERE
if isinstance(Qwhere, SWhere):
print("entro al Where")
for col in Qwhere.clist:
if isinstance(col, SWhereCond1):
print("Es where1")
print(col.conds)
# print(col.conds.param.opIzq.valor)
# print(col.conds.param.operador)
# print(col.conds.param.opDer.valor)
elif isinstance(col, SWhereCond2):
print("Es where2")
print(col.conds)
print(col.isnotNull)
elif isinstance(col, SWhereCond3):
print("Es where3")
print(col.conds)
print(col.directiva)
elif isinstance(col, SWhereCond4):
print("Es where4")
print(col.conds)
print(col.ffrom)
elif isinstance(col, SWhereCond5):
print("Es where5")
print(col.c1)
print(col.c2)
print(col.c3)
elif isinstance(col, SWhereCond6):
print("Es where6")
print(col.cols)
elif isinstance(col, SWhereCond7):
print("Es where7")
print(col.efunc)
print(col.qcols)
print(col.anyallsome)
print(col.operador)
elif isinstance(col, SWhereCond8):
print("Es where8")
print(col.qcols)
print(col.efunc)
elif isinstance(col, SWhereCond9):
print("Es where9")
print(col.between)
print(col.efunc)
print(col.efunc2)
else:
print("Otro Where")
# GROUP BY
if isinstance(Qgroupby, SGroupBy):
print("entro al Group By")
for col in Qgroupby.slist:
if isinstance(col, SExpresion):
print("Agrupado por")
print(col.valor)
else:
print("Agrupado por")
print(col)
# HAVING
if isinstance(Qhaving, SHaving):
print("entro al Having")
print(Qhaving.efunc)
# ORDER BY
if isinstance(Qorderby, sOrderBy):
print("entro al Order By")
for col in Qorderby.slist:
if isinstance(col, SListOrderBy):
if col.ascdesc == False and col.firstlast == False:
print("OrderBy1")
print(col.listorder)
elif col.ascdesc == False and col.firstlast != False:
print("OrderBy2")
print(col.listorder)
print(col.firstlast)
elif col.ascdesc != False and col.firstlast == False:
print("OrderBy3")
print(col.listorder)
print(col.ascdesc)
elif col.ascdesc != False and col.firstlast != False:
print("OrderBy4")
print(col.listorder)
print(col.ascdesc)
print(col.firstlast)
# LIMIT
if isinstance(Qlimit, SLimit):
print("Entro a Limit")
if isinstance(Qlimit.limit, SExpresion):
print(Qlimit.limit.valor)
else:
print(Qlimit.limit)
if isinstance(Qlimit.offset, SExpresion):
print(Qlimit.offset.valor)
else:
print(Qlimit.offset)
else:
print("Query anidada")
for i in listaSemanticos:
print(i)
return consola
def ejecutar(self, ent):
DBMS.dropDatabase(self.id)
DBMS.showCollection()
def ejecutar(self, ent):
resultado = DBMS.dropDatabase(self.id)
if (resultado == 2):
return "ERROR >> En la instrucción Drop Database " + self.id + ", La base de datos a eliminar NO EXISTE"
else:
return "La base de datos: (" + self.id + ") ha sido eliminada con exito"
# File: JSON Mode Test File for EDD
# License: Released under MIT License
# Notice: Copyright (c) 2020 TytusDB Team
# Developer: Luis Espino
from storageManager import jsonMode as j
# assume no data exist or execute the next optional drop function
j.dropAll()
# test Databases CRUD
print(j.createDatabase('b1')) # 0
print(j.createDatabase('b1')) # 2
print(j.createDatabase('b4')) # 0
print(j.createDatabase('b5')) # 0
print(j.createDatabase(0)) # 1
print(j.alterDatabase('b5', 'b1')) # 3
print(j.alterDatabase('b5', 'b2')) # 0
print(j.dropDatabase('b4')) # 0
print(j.showDatabases()) # ['b1','b2']
