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 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 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 send_data():
print("Analizando Entrada:")
print("==============================================")
# reporteerrores = []
contenido = Tentrada.get(1.0, 'end')
Tsalida.delete("1.0", "end")
Tsalida.configure(state='normal')
# print(contenido)
jsonMode.dropAll()
jsonMode.createDatabase("DB1")
Principal = Entorno()
Principal.database = "DB1"
instrucciones = g.parse(contenido)
Tsalida.insert(INSERT, "Salida de consultas\n")
for instr in instrucciones:
if instr != None:
res = instr.ejecutar(Principal)
if res != None:
res += '\n'
Tsalida.insert(INSERT, res)
Tsalida.configure(state='disabled')
Principal.mostrarSimbolos()
reporte_lex_sin()
def procesar_createdb(query,ts):
h.textosalida+="TYTUS>> Bases de datos existentes\n"
if store.createDatabase(query.variable) == 0:
print("SE CREO LA BASE DE DATOS "+str(query.variable)+" ")
elif store.createDatabase(query.variable) == 2:
print("LA BASE DE DATOS "+str(query.variable)+" YA EXISTE")
elif store.createDatabase(query.variable) == 1:
print("ERROR :(")
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,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 createDatabase(self, database: str, line, column):
"""
Method to create a database in type checker
:param database: The name of database
:param line: The instruction line
:param column: The instruction column
:return: Returns nothing
"""
dbStatement = jsonMode.createDatabase(database)
if dbStatement == 0:
db = Database(database)
self._typeCheckerList.append(db)
self.writeFile()
SymbolTable().add(db, 'New Database', 'Database', 'Global', None,
line, column)
print('Database created successfully')
# Query returned successfully in # secs # msec.
elif dbStatement == 1:
desc = f": Can't create database {database}"
ErrorController().addExecutionError(34, 'Execution', desc, line,
column)
elif dbStatement == 2:
desc = f": Database {database} already exists"
ErrorController().addExecutionError(30, 'Execution', desc, line,
column)
def createDatabase(self, databaseName: str):
dbStatement = jsonMode.createDatabase(databaseName)
if dbStatement == 0:
self._typeCheckerList.append(Database(databaseName))
self.writeFile()
print('Database created successfully')
elif dbStatement == 1:
print(f"Can't create database '{databaseName}'")
elif dbStatement == 2:
print('Database exists')
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 createDB(self, nodo):
name_db = ''
owner = ''
mode = -1
hijo1 = ''
hijo2 = ''
hijo3 = ''
for hijos in nodo.hijos:
for hijos2 in hijos.hijos:
for hijos3 in hijos2.hijos:
hijo3 = hijos3.valor
hijo2 = hijos2.valor
hijo1 = hijos.valor
if nodo.valor != '':
name_db = nodo.valor
owner = hijo1
mode = hijo2
else:
name_db = hijo1
owner = hijo2
mode = hijo3
query_result = jsonMode.createDatabase(name_db)
if query_result == 0:
jsonMode.createDatabase(name_db)
self.ts[name_db] = Database(owner, mode)
self.output.append('Creación de base de datos \"' + name_db +
'\" exitosa.')
elif query_result == 1:
self.errors.append(
Error('XX000', EType.SEMANTICO, 'internal_error', nodo.linea))
elif query_result == 2:
self.errors.append(
Error('42P04', EType.SEMANTICO, 'duplicate_database',
nodo.linea))
def procesar_createDatabase(instr,ts,tc) :
result = j.createDatabase(str(instr.nombre.id))
if result == 0:
global salida
salida = "\nCREATE DATABASE"
print("CREATE DATABASE")
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.nombre.id) +"\" already exists \nSQL state: 42P04 "
print("ERROR: database \"" + str(instr.nombre.id) +"\" already exists \nSQL state: 42P04 ")
def createDB(database: str):
#*********************** CREATE DB ****************************
resultado = manager.createDatabase(database)
if resultado == 0:
print('Base de datos ' + database + ' creada correctamente')
elif resultado == 2:
print('Error al crear la base de datos ' + database +
'. El nombre ya existe')
elif resultado == 1:
print('Ha ocurrido un error al crear la base de datos ' + database +
'.')
else:
print('Error desconocido')
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])
def createDatabase(self, database: str, line: int, mode: int = 1):
# 0 -> operación exitosa,
# 1 -> error en la operación,
# 2 -> base de datos existente
query_result = jsonMode.createDatabase(database)
if query_result == 0:
self.type_checker[database] = {}
self.tabla_simbolos.agregar(Simbolo(database, 'DATABASE', '',
line))
self.consola.append(
Codigos().database_successful_completion(database))
self.saveTypeChecker()
elif query_result == 1:
self.addError(Codigos().database_internal_error(database), line)
else:
self.addError(Codigos().database_duplicate_database(database),
line)
# 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
def cmd_createdatabase(self, database):
if verificarBasesDuplicada(database) == 1:
self.tabla.agregaraTS('0', database, 'base', 'global', '', '')
EDDResp.createdatabase(condb.createDatabase(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 ejecutar(self, ent):
resultado = DBMS.createDatabase(self.id)
if (resultado == 2):
return "ERROR >> En la instrucción Create Database " + self.id + ", La base de datos a crear ya EXISTE"
else:
return "La base de datos: (" + self.id + ") ha sido creada con exito"
from storageManager import jsonMode as j
import time
j.dropAll() #limpieza de todos los datos
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))
def ejecutar(self, ent):
DBMS.createDatabase(self.id)
DBMS.showCollection()
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"
# 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'])
# 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']
def ECreateDatabase():
cargarMemoria()
if (len(listaMemoria) > 0):
print("base de datos creada:", listaMemoria[0])
EDD.createDatabase(listaMemoria[0])
listaMemoria.pop(0)
