def resultupdate(self, result, nomresult, DB, llaves):
if not len(result) > 0:
return (
"En la instrucción Delete no hay registros que cumplan la expresión"
)
else:
if not len(llaves) > 0:
columnas = len(self.encabezado)
DBMS.dropTable(DB, nomresult)
DBMS.createTable(DB, nomresult, columnas)
for x in range(0, len(result)):
DBMS.insert(DB, nomresult, result[x])
self.encabezado.clear()
variables.consola.insert(
INSERT, "La instrucción UPDATE se realizó exitosamente \n")
return "La instrucción UPDATE se realizó exitosamente"
else:
columnas = len(self.encabezado)
DBMS.dropTable(DB, nomresult)
DBMS.createTable(DB, nomresult, columnas)
DBMS.alterAddPK(DB, nomresult, llaves)
for x in range(0, len(result)):
DBMS.insert(DB, nomresult, result[x])
self.encabezado.clear()
variables.consola.insert(
INSERT, "La instrucción UPDATE se realizó exitosamente \n")
return "La instrucción UPDATE se realizó exitosamente"
def ECreateType():
cargarMemoria()
#llamar la funcion de EDD
if (len(listaMemoria) > 0):
crear_type = listaMemoria[0]
EDD.createTable(crear_type[0], crear_type[1], crear_type[2])
EDD.insert(crear_type[0], crear_type[1], crear_type[3])
print("creado type ", crear_type[1], " con valores ", crear_type[3])
listaMemoria.pop(0)
def ECreateTable():
cargarMemoria()
#llamar la funcion de EDD
if (len(listaMemoria) > 0):
crear_tabla = listaMemoria[0]
EDD.createTable(crear_tabla[0], crear_tabla[1], crear_tabla[2])
print("creando Tabla ", crear_tabla[1])
listaMemoria.pop(0)
return True
return False
def createTable(self, database: Database, name: str, columns: int, line,
column):
"""
Method to create a table in database
:param database: Table database
:param name: The name of table
:param columns: Number of columns
:param line: The instruction line
:param column: The instruction column
:return: Returns nothing
"""
dbStatement = jsonMode.createTable(database.name, name, columns)
if dbStatement == 0:
table = Table(name)
database.tables.append(table)
self.writeFile()
print('Table created successfully')
return table
elif dbStatement == 1:
desc = f": Can't create table {name}"
ErrorController().addExecutionError(34, 'Execution', desc, line,
column)
elif dbStatement == 2:
desc = f": Database {database.name} does not exist"
ErrorController().addExecutionError(35, 'Execution', desc, line,
column)
elif dbStatement == 3:
desc = f": Table {name} already exists"
ErrorController().addExecutionError(31, 'Execution', desc, line,
column)
def createTbl(database: str, table: str, numberColumns: int):
resultado = manager.createTable(database, table, numberColumns)
if resultado == 1:
print('Error(42P16): invalid_table_definition.')
elif resultado == 2:
print('Error(???): No existe la base de datos.')
elif resultado == 3:
print('Error(42P07): duplicate_table.')
elif resultado == 0:
print('Tabla ' + table + ' creada correctamente')
def resultdelete(self,result,nomresult,DB):
if not len(result)>0:
return ("En la instrucción Delete no hay registros que cumplan la expresión")
else:
columnas = len(self.encabezados)
print(DBMS.dropTable(DB, nomresult))
print(DBMS.createTable(DB, nomresult, columnas))
for x in range(0,len(result)):
DBMS.insert(DB,nomresult,result[x])
self.encabezados.clear()
return "La instrucción DELETE se realizó exitosamente"
def crearTabla(self, nodo):
tb_name = nodo.valor
columnas = nodo.hijos[0]
col_count = len(columnas.hijos)
if not (self.usingDB in self.ts):
self.errors.append(
Error('-----', EType.SEMANTICO, 'database_non_exist',
nodo.linea))
return
database = self.ts[self.usingDB]
table = {}
result = jsonMode.createTable(self.usingDB, str(tb_name), col_count)
if result == 0: # Operación exitosa
self.output.append('Creación de tabla \"' + tb_name +
'\" exitosa.')
c = 0
for col in columnas.hijos:
if col.etiqueta == 'COLUMN':
new_col = Column(col.valor, c)
new_col.columnType = self.getColType(col.hijos[0])
for atrib in col.hijos[1].hijos:
if atrib.etiqueta == 'NOT NULL':
new_col.isNull = False
elif atrib.etiqueta == 'PRIMARY KEY':
new_col.isPrimaryKey = True
elif atrib.etiqueta == 'CONSTRAINT':
cnst = Constraint(atrib.valor, atrib.hijos[0])
new_col.constraint = cnst
elif atrib.etiqueta == 'CHECK':
new_col.constraint = Constraint('', atrib)
elif atrib.etiqueta == 'UNIQUE':
new_col.isUnique = True
#Se añade a la tabla la nueva columna
new_col.line = col.linea
table[col.valor] = new_col
c += 1
# Se añade a la Base de datos la nueva Tabla
database.tables[tb_name] = table
else:
col_name = col.hijos[0].valor
if col_name in table:
table[col_name].isPrimaryKey = True
elif result == 1: # Error en la operación
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))
elif result == 3: # Tabla existente
self.errors.append(
Error('42P07', EType.SEMANTICO, 'duplicate_table', nodo.linea))
def ejecutar(self, ent):
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)
listaColumnas.append(nuevaColumna)
nuevaTabla.valor = listaColumnas
DBMS.dropAll()
DBMS.createDatabase("prueba")
DBMS.createTable("prueba",self.id,self.numColumnas)
print("---------------------------------------------")
DBMS.showCollection()
print("---------------------------------------------")
def procesar_createTable(instr,ts,tc) :
global pks
columns = []
i = 0
if instr.instrucciones != []:
global salida
for ins in instr.instrucciones:
if isinstance(ins, Definicion_Columnas):
i+=1
columns.append(i)
procesar_Definicion(ins,ts,tc,instr.id)
elif isinstance(ins, LLave_Primaria):
procesar_primaria(ins,ts,tc,instr.id)
elif isinstance(ins, Definicon_Foranea):
procesar_Foranea(ins,ts,tc,instr.id)
elif isinstance(ins, Lista_Parametros):
procesar_listaId(ins,ts,tc,instr.id)
elif isinstance(ins, definicion_constraint):
procesar_constraint(ins,ts,tc,instr.id)
try:
result = j.createTable(str(useCurrentDatabase),str(instr.id),int(len(columns)))
if result == 0:
salida = "\nCREATE TABLE"
temp1 = TS.Simbolo(str(instr.id),'Table',int(len(columns)),str(useCurrentDatabase))
ts.agregar(temp1)
elif result == 1 :
salida = "\nERROR: internal_error \nSQL state: XX000 "
elif result == 2 :
salida = "\nERROR: database \"" + useCurrentDatabase +"\" does not exist \nSQL state: 3D000"
elif result == 3 :
salida = "\nERROR: relation \"" + str(instr.id) +"\" alredy exists\nSQL state: 42P07"
except :
pass
try:
print(pks)
result = j.alterAddPK(str(useCurrentDatabase),str(instr.id),pks)
pks = []
print(pks)
except :
pass
def ejecutar(self, ent:Entorno):
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)
listaColumnas.append(nuevaColumna)
nuevaTabla.valor = listaColumnas
dbActual = ent.getDataBase()
if dbActual != None:
estado = DBMS.createTable(dbActual,self.id, self.numColumnas)
if estado == 0:
nuevaTabla.baseDatos = dbActual
ent.nuevoSimbolo(nuevaTabla)
print("Tabla Creada")
DBMS.showCollection()
def createTable(self, table: str, columns: [], line: int):
# 0 -> operación exitosa
# 1 -> error en la operación
# 2 -> base de datos inexistente
# 3 -> tabla existente
query_result = jsonMode.createTable(self.actual_database, table,
len(columns))
if query_result == 0:
self.consola.append(Codigos().table_successful(table))
self.type_checker[self.actual_database][table] = {}
for columna in columns:
self.type_checker[self.actual_database][table][
columna['nombre']] = columna['col']
self.saveTypeChecker()
elif query_result == 1:
self.addError(Codigos().database_internal_error(table), line)
elif query_result == 2:
self.addError(
Codigos().database_undefined_object(self.actual_database),
line)
else:
self.addError(Codigos().table_duplicate_table(table), line)
def m_carga_de_informacion(self):
# drop all databases if exists
j.dropAll()
# create database
j.createDatabase('BD1')
# create tables
j.createTable('BD1', 'personas', 5)
j.createTable('BD1', 'pais', 4)
j.createTable('BD1', 'idiomas', 4)
# create simple primary keys
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])
# 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
# assume no data exist or execute the next drop function
j.dropAll()
# 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'],
def cmd_createTable(self, database, table, numberColumns):
if verificarTablaDuplicada(table, database) == 1:
self.tabla.agregaraTS('0', table, 'tabla', database, '', '')
EDDResp.createtable(
condb.createTable(database, table, numberColumns))
def ejecutar(self, ts):
if DB_ACTUAL.getName() == None:
return ErrorReport('Semantico', 'Not defined database to used', 0)
elif not TRef.databaseExist(DB_ACTUAL.getName()):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_invalid_schema_name.invalid_schema_name), 0)
elif TRef.tableExist(DB_ACTUAL.getName(), self.nombre):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.duplicate_table), 0)
# Aux de comprobacion y almacenamiento
columns = dict()
auxFK = list()
auxPK = list()
auxUnique = list()
auxCheck = list()
# Proceso de las distintas columnas recibidas en la consulta
for col in self.columnas:
if isinstance(col, CreateField): #Columna nueva
#Obtenemos cada columna y corroboramos que tengan nombres distintos
if col.nombre in columns:
return 1
else:
colSint = col.ejecutar(ts)
if isinstance(colSint, ErrorReport):
return colSint
columns[col.nombre] = colSint
elif isinstance(col, ConstraintMultipleFields): #Multiples Constraints
if col.tipo == CONSTRAINT_FIELD.UNIQUE:
auxUnique.extend(col.ejecutar(ts))
else:
auxPK.extend(col.ejecutar(ts))
elif isinstance(col, ForeignKeyMultipleFields): #Multiples Llaves Foraneas
colSint = col.ejecutar(ts)
if isinstance(colSint, ErrorReport):
return colSint
auxFK.extend(colSint)
elif isinstance(col, CheckMultipleFields): #Multiple chequeos
auxCheck.extend(col.ejecutar(ts))
else:
return col
#Modificamos los valores dependiendo de las columnas multiples
# Primary Key
for pk in auxPK:
# Se verifica que cada constraint haga referencia a un campo, de lo contrario será invalido
if not pk in columns:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.invalid_column_reference), 0)
columns[pk]['PK'] = True
# Foreign Key
for fk in auxFK:
# Se verifica que cada constraint haga referencia a un campo, de lo contrario será invalido
if not fk[0] in columns:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.invalid_column_reference), 0)
columns[fk[0]]['FK'] = True
columns[fk[0]]['References'] = {'Table':fk[1],'Field':fk[0]}
for chequeo in auxCheck:
# Se verifica que cada constraint haga referencia a un campo, de lo contrario será invalido
if not chequeo[0] in columns:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.invalid_column_reference), 0)
#TODO Mejorar implementacion de checks
columns[chequeo[0]]['Check'] = chequeo[1]
# Unique
for unico in auxUnique:
# Se verifica que cada constraint haga referencia a un campo, de lo contrario será invalido
if not unico in columns:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.invalid_column_reference), 0)
columns[unico]['Unique'] = True
#--------- Herencia
if self.herencia:
if not TRef.tableExist(DB_ACTUAL.getName(), self.herencia):
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_fdw_error.fdw_table_not_found), 0)
else:
colsPadre = TRef.getColumns(DB_ACTUAL.getName(), self.herencia)
for col in colsPadre:
# Verificamos que no existan columnas repetidas con el padre, ya que no existe el polimorfismo de campos
if col in columns:
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.duplicate_column), 0)
# De no existir columnas duplicadas, se agregan las columnas a la tabla
columns.update(colsPadre)
# Ahora procedemos a crear
result = DBMS.createTable(DB_ACTUAL.getName(), self.nombre, len(columns))
if result == 0:
TRef.createTable(DB_ACTUAL.getName(), self.nombre, columns, self.herencia)
return result
return ErrorReport('Semantico', sqlErrors.sqlErrorToString(sqlErrors.sql_error_syntax_error_or_access_rule_violation.duplicate_table), 0)
# JSON Mode Test File
# Released under MIT License
# Copyright (c) 2020 TytusDb Team
from storageManager import jsonMode as j
# drop all databases if exists
j.dropAll()
# create database
j.createDatabase('world')
# create tables
j.createTable('world', 'countries', 4)
j.createTable('world', 'cities', 4)
j.createTable('world', 'languages', 4)
# create simple primary keys
j.alterAddPK('world', 'countries', [0])
j.alterAddPK('world', 'cities', [0])
j.alterAddPK('world', 'languages', [0, 1])
# insert data in countries
j.insert('world', 'countries', ['GTM', 'Guatemala', 'Central America', 108889])
j.insert('world', 'countries', ['SLV', 'El Salvado', 'Central America', 21041])
# 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'])
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 execute(self, environment):
if not isinstance(self.table,str):
return {'Error': 'El nombre indicado de la tabla no es una cadena.', 'Fila':self.row, 'Columna': self.column }
columnas = []
restricciones = []
for column in self.fields:
if isinstance(column,Column):
columnas.append(column)
else:
restricciones.append(column)
for i in range(len(columnas)):
if i+1 < len(columnas):
for j in range(i+1, len(columnas)):
if columnas[i].name == columnas[j].name:
return {'Error': 'El nombre de columna ya está siendo utilzado' , 'Fila':self.row, 'Columna': self.column}
name = environment.getActualDataBase()
result = 3
result = admin.createTable(name, self.table, len(columnas))
if result == 0:
#Se creo la tabla en la base de datos correctamente.
#Creo una nueva database en la metadata
database = environment.readDataBase(name)
#Creo una nueva tabla con el nombre solicitado
newTable = Table(self.table,columnas,restricciones)
#Agrego a la tabla las columnas pertenecientes a la misma
primaryKeys = []
ids = []
for const in newTable.constraint:
if const['type'] == "primary":
ids.append(const['value'])
for index in range(len(newTable.columns)):
for id in ids:
if newTable.columns[index].name == id:
primaryKeys.append(index)
#Agrego la nueva tabla a la base de datos.
database.addTable(newTable)
create = admin.alterAddPK(name,self.table,primaryKeys)
if (create == 0):
return('Llave primaria agregada exitosamenta a la tabla' + self.table )
elif (create == 1):
return {'Error':'Tabla ' + self.table + ' creada, pero ocurrio un error al ingresar llaves primarias', 'Fila':self.row, 'Columna':self.column}
elif (create == 2):
return {'Error':'No se encontro la Base de datos, en agregar tabla', 'Fila':self.row, 'Columna':self.column}
elif (create == 3):
return {'Error':'No se pudo agregar llaves pirmarias a '+ self.table + ', Tabla no existente', 'Fila':self.row, 'Columna':self.column}
elif (create == 4):
return {'Error':'Llave Primaria ya existente en Tabla ' + self.table, 'Fila':self.row, 'Columna':self.column}
elif (create == 5):
return {'Error':'Columnas fuera del límites', 'Fila':self.row, 'Columna':self.column}
return 'La Tabla ' + self.table + ' ha sido creada con éxito.'
elif result == 1:
#Error al crear
return {'Error':'Ocurrió un error en el storage manager Tabla' + self.table + ' no pudo ser creada.', 'Fila':self.row, 'Columna':self.column}
elif result == 2:
#Error al crear
return {'Error':'Tabla' + self.table + ' no se encuentra en la base de datos.', 'Fila':self.row, 'Columna':self.column}
elif result == 3:
#Error al crear
return {'Error':'Tabla' + self.table + 'ya existente, no pudo ser creada.', 'Fila':self.row, 'Columna':self.column}
inicio = time.time()
#Area para crear bases de datos
print("Estado BD:", j.createDatabase("BD1")) #Sistema de Asignaciones
print("Estado BD:", j.createDatabase("BD2")) #Sistema de Compras de productos
print("Estado BD:", j.createDatabase(
"BD3")) #Sistema de Accesos de usuario para una base de datos
print("Estado BD:", j.createDatabase(
"BD4")) #Sistema de Peliculas y Series para una pagina web
print("Estado BD:",
j.showDatabases()) #Nos deberia mostrar todas las bases de datos
#Area para crear tablas
'Creamos Tablas Estudiante, Periodo, Año, Asignacion, Curso, Asignacion_Curso'
print("---------Creamos Tabla Estudiante---------")
print("Estado Tabla:", j.createTable("BD1", "Estudiante", 8))
print("Estado PKS:", j.alterAddPK("BD1", "Estudiante", [0]))
print("Estado Inserts", j.loadCSV("./BD1/Estudiantes.csv", "BD1",
"Estudiante"))
print("---------Creamos Tabla Periodo---------")
print("Estado Tabla:", j.createTable("BD1", "Periodo", 2))
print("Estado PKS:", j.alterAddPK("BD1", "Periodo", [0]))
print("Estado Inserts", j.loadCSV("./BD1/Periodo.csv", "BD1", "Periodo"))
print("---------Creamos Tabla Año---------")
print("Estado Tabla:", j.createTable("BD1", "Year", 2))
print("Estado PKS:", j.alterAddPK("BD1", "Year", [0]))
print("Estado Inserts", j.loadCSV("./BD1/Año.csv", "BD1", "Year"))
print("---------Creamos Tabla Curso---------")
def crearTabla(nodo, tablaSimbolos):
val = nodo.id
global consola
if nodo.herencia == False:
contador = 0
nueva = TS.SimboloTabla(val, None)
for col in nodo.columnas:
pk = False
default_ = None
check = None
null = True
unique = False
if isinstance(col, SColumna):
if col.opcionales != None:
for opc in col.opcionales:
if isinstance(opc, SOpcionales):
if opc.tipo == TipoOpcionales.PRIMARYKEY:
pk = True
elif opc.tipo == TipoOpcionales.DEFAULT:
default_ = opc.valor
elif opc.tipo == TipoOpcionales.CHECK:
if opc.id == None:
check = {
"id": col.id + "_check",
"condicion": opc.valor
}
listaConstraint.append(
TS.Constraints(useActual, val,
col.id + "_check",
col.id, "check"))
else:
check = {
"id": opc.id,
"condicion": opc.valor
}
listaConstraint.append(
TS.Constraints(useActual, val, opc.id,
col.id, "check"))
elif opc.tipo == TipoOpcionales.NULL:
null = True
elif opc.tipo == TipoOpcionales.NOTNULL:
null = False
elif opc.tipo == TipoOpcionales.UNIQUE:
if opc.id == None:
unique = col.id + "_unique"
listaConstraint.append(
TS.Constraints(useActual, val,
col.id + "_unique",
col.id, "unique"))
else:
unique = opc.id
listaConstraint.append(
TS.Constraints(useActual, val, opc.id,
col.id, "unique"))
colnueva = TS.SimboloColumna(
col.id, col.tipo, pk, None, unique, default_,
null, check)
nueva.crearColumna(col.id, colnueva)
if colnueva == None:
listaSemanticos.append(
Error.ErrorS(
"Error Semantico",
"Ya existe una columna con el nombre "
+ col.id))
else:
auxc = TS.SimboloColumna(col.id, col.tipo, False, False,
False, False, False, False)
nueva.crearColumna(col.id, auxc)
elif isinstance(col, SColumnaUnique):
for id in col.id:
if nueva.modificarUnique(id.valor, True,
id.valor + "_unique") == None:
listaSemanticos.append(
Error.ErrorS(
"Error Semantico",
"No se encontró la columna con id " +
id.valor))
else:
listaConstraint.append(
TS.Constraints(useActual, val,
id.valor + "_unique", id.valor,
"unique"))
elif isinstance(col, SColumnaCheck):
condicion = col.condicion
opIzq = condicion.opIzq
idcol = opIzq.valor
result = False
if col.id == None:
result = nueva.modificarCheck(idcol, col.condicion,
idcol + "_check")
listaConstraint.append(
TS.Constraints(useActual, val, idcol + "_check", idcol,
"check"))
else:
result = nueva.modificarCheck(idcol, condicion, col.id)
listaConstraint.append(
TS.Constraints(useActual, val, col.id, idcol, "check"))
if result != True:
listaSemanticos.append(
Error.ErrorS(
"Error Semantico",
"No se encontró la columna con id " + idcol))
elif isinstance(col, SColumnaFk):
for i in range(len(col.idlocal)):
idlocal = col.idlocal[i].valor
idfk = col.idfk[i].valor
columnafk = tablaSimbolos.getColumna(
useActual, col.id, idfk)
columnalocal = nueva.getColumna(idlocal)
if columnafk != None and columnalocal != None:
if columnafk.tipo.tipo == columnalocal.tipo.tipo:
nueva.modificarFk(idlocal, col.id, idfk)
listaFK.append(
TS.llaveForanea(useActual, val, col.id,
idlocal, idfk))
else:
listaSemanticos.append(
Error.ErrorS(
"Error Semantico",
"La columna %s y la columna %s no tienen el mismo tipo"
% (idlocal, idfk)))
else:
listaSemanticos.append(
Error.ErrorS("Error Semantico",
"No se encontró la columna"))
elif isinstance(col, SColumnaPk):
for id in col.id:
if nueva.modificarPk(id.valor) == None:
listaSemanticos.append(
Error.ErrorS(
"Error Semantico",
"No se encontró la columna " + id.valor))
contador += 1
base = tablaSimbolos.get(useActual)
base.crearTabla(val, nueva)
tt = jBase.createTable(useActual, nodo.id, contador)
if tt == 0:
consola += "La tabla " + nodo.id + " se creó con éxito. \n"
elif tt == 1:
consola += "Error en la operación al crear la tabla " + nodo.id + "\n"
elif tt == 2:
consola += "La base de datos " + useActual + " no existe. \n"
else:
consola += "La tabla " + nodo.id + " ya existe. \n"
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")
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())
# again create db1 and db2, return two 0's and show return list of databases
print(j.createDatabase("db1"))
print(j.createDatabase("db2"))
print(j.showDatabases())
# create two table in db1 and show return tables list of db1 database
print(j.createTable("db1", "table1", 5))
print(j.createTable("db1", "table2", 8))
print(j.showTables("db1"))
# rename table1 to table 3 and show return tables list of db1 database
print(j.alterTable("db1", "table1","table3"))
print(j.showTables("db1"))
# drop table3 of db1 and show return tables list of db1 database
print(j.dropTable("db1", "table3"))
print(j.showTables("db1"))
# drop db1 with tables, first return 0 and second return None
print(j.dropDatabase("db1"))
print(j.showTables("db1"))
# JSON Mode Test File
# Released under MIT License
# Copyright (c) 2020 TytusDb Team
from storageManager import jsonMode as j
import pandas as pd
from datetime import *
# drop all databases if exists
# create database
j.createDatabase('BD1')
# create tables
j.createTable('BD1', 'personas', 5)
j.createTable('BD1', 'pais', 4)
j.createTable('BD1', 'idiomas', 4)
# create simple primary keys
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'])
