def checkNotNull(cls, tableName, listcolumn, listvalues,
headColumns) -> bool:
'''
:param tableName:
:param listcolumn: Nombre de columnas A evaluar
:param headColumns: encabezado de la tabla
:return: False-> si no encuentra todas las columnas con restriccion not null
:return: True-> si estan todas las columnas con restriccion not null
'''
notnullColumns: list = Meta.getNameColumnsNotNull(headColumns)
for i in range(len(notnullColumns)):
notnullColumn = notnullColumns[i]
if Meta.contains(notnullColumn, listcolumn) == False:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
borra el print de abajo o comentalo xd
Descripcion:'la columna: '+namecolumn+'Ya se ha ingresado.'
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX5: La columna: " + notnullColumn +
", es obligatoria para la tabla: " + tableName, 0, 0,
'Use database')
Meta.arbol.ErroresSemanticos.append(Error)
print('La columna: "' + notnullColumn +
', es obligatoria para la tabla: ' + tableName)
return False
listFields = Meta.toListFields(listcolumn, listvalues)
for i in range(len(listFields)):
field: Field = listFields[i]
if Meta.isNotNullByName(field.name) == True:
if field.value == '':
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
borra el print de abajo o comentalo xd
Descripcion:'la columna: '+namecolumn+'Ya se ha ingresado.'
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX5: El campo: " + field.name + ", de la tabla: " +
tableName + " no puede venir con ' ", 0, 0,
'Use database')
Meta.arbol.ErroresSemanticos.append(Error)
print('El campo: ' + field.name + ', de la tabla: ' +
tableName + ' no puede venir con \'\' ')
return False
return True
def execute(self, entorno: Tabla_de_simbolos, arbol: Arbol):
# Se ejecuta el metodo para la eliminar la base de datos
result = dbms.dropDatabase(self.database_name)
# Si la operacion fue exitosa
if result == 0:
# Si la base de datos actual es la que se va a eliminar
if entorno.getBD() == self.database_name:
# Se coloca en nulo ls base de datos actual
entorno.setBD("")
cadena = 'tytus> Base de datos \'' + self.database_name + '\' fue eliminada exitosamente'
print('tytus> Base de datos \'' + self.database_name +
'\' fue eliminada exitosamente')
arbol.console.append(cadena)
return
# Si hubo un error en la operacion
elif result == 1:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
Descripcion: XX000 internal_error (yo creo que seria ese)
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX01: internal_error", self.linea, self.columna,
'Drop Database')
arbol.ErroresSemanticos.append(Error)
print('XX00: internal_error')
return
# Si la base de datos no existe
elif result == 2:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
Descripcion: La base de datos no existe
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX01: internal_error la db no existe", self.linea,
self.columna, 'Drop Database')
arbol.ErroresSemanticos.append(Error)
print('La base de datos no existe')
return
def searchColumn(cls, tableName: str, columnName: str,
headColumns: list) -> bool:
'''
:param columnName: Nombre de la columna a buscar
:param headColumns: Columnas que existen en la tabla
:return: TRUE -> si lo encuentra , False -> si no lo encuentra
'''
for headName in headColumns:
if headName == columnName:
return True
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
borra el print de abajo o comentalo xd
Descripcion:'La columna'+columnName+' no existe en la tabla ->'+tableName
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX5: La columna" + columnName + " no existe en la tabla ->" +
tableName, 0, 0, 'Use database')
Meta.arbol.ErroresSemanticos.append(Error)
print('La columna' + columnName + ' no existe en la tabla ->' +
tableName)
return False
def execute(self, entorno: Tabla_de_simbolos, arbol: Arbol):
# Se verifica que se este trabajando sobre una base de datos
if entorno.BDisNull() is True:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
Descripcion: No se ha seleccionado una base de datos para trabajar.
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX00: no se a seleccionado base de datos", self.linea,
self.columna, 'Update')
arbol.ErroresSemanticos.append(Error)
print('No se ha seleccionado una base de datos para trabajar')
return
# Se verifica que exista la tabla a actualizar
else:
# Si la tabla existe
if Meta.existTable(entorno.getBD(), self.table_name) is True:
# Se obtiene los encabezados de la tabla, las columnas y sus valores a actualizar
header = dbms.extractTable(entorno.getBD(), self.table_name)[0]
columns, values = [], []
self.getdata(columns, values, entorno, arbol)
# Si no hay condicional where
if self.where is None:
pass
# Si hay condicional where
else:
self.whithwhere(columns, header, values, entorno, arbol)
def TypesCompare(self, headColumns, listValues, entorno, arbol) -> bool:
result: bool = True
typeColumns = Meta.getTypeHeadColumns(headColumns)
typeValues = Meta.getTypes(listValues, entorno, arbol)
nameColumns = Meta.getNameColumns(headColumns)
for i in range(len(typeColumns)):
nameColumn: str = nameColumns[i]
typeColumn: int = typeColumns[i]
typeValue: int = typeValues[i]
if typeColumn != typeValue:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
borra el print de abajo o comentalo xd
Descripcion: la columna: %nameColumn% No acepta el %value.tipo%
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX45: la columna " + nameColumn + " no acepta el valor ",
self.linea, self.columna, 'Drop Database')
arbol.ErroresSemanticos.append(Error)
print(' la columna: ' + nameColumn + ' No acepta el ' +
str(typeValue))
result = False
return result
def existColumn(cls, tableName, listcolumn, headColumns) -> bool:
namesColumns = Meta.getNameColumns(headColumns)
aux = []
for namecolumn in listcolumn:
existColumn: bool = Meta.searchColumn(tableName, namecolumn,
namesColumns)
if existColumn == True:
if not Meta.contains(namecolumn, aux):
aux.append(namecolumn)
else:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
borra el print de abajo o comentalo xd
Descripcion:'la columna: '+namecolumn+'Ya se ha ingresado.'
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX5: la columna: " + namecolumn +
" ya se ha ingresado.", 0, 0, 'Use database')
Meta.arbol.ErroresSemanticos.append(Error)
print('la columna: "' + namecolumn +
'" ya se ha ingresado.')
return False
else:
return False
return True
def execute(self, entorno: Tabla_de_simbolos, arbol:Arbol):
# Se ejecuta el metodo que devuelve lista de bases de datos
result = dbms.showDatabases()
# Si no hay bases de datos o hay un error
if not result:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
Descripcion: No hay bases de datos
'''
Error: ErroresSemanticos = ErroresSemanticos("XX00: no hay base de datos", self.linea,
self.columna,
'show database')
arbol.ErroresSemanticos.append(Error)
print('No hay bases de datos')
return
# Si la operacion fue exitosa
else:
cad = ""
for db in result:
cad += " | " + db
cad += " |"
print("tytus> Las bases de datos en el sistema son: " + cad)
arbol.console.append("tytus> Las bases de datos en el sistema son: " + cad)
def TypesCompare(cls, headColumns, listValues, entorno, arbol) -> bool:
result: bool = True
typeColumns = Meta.getTypeHeadColumns(headColumns)
typeValues = Meta.getTypes(listValues, entorno, arbol)
nameColumns = Meta.getNameColumns(headColumns)
for i in range(len(typeColumns)):
nameColumn = nameColumns[i]
typeValue = typeValues[i]
typeColumn = typeColumns[i]
# Validacion Type
if Meta.isNumber(typeColumn) == False:
objectType = typeColumns[i]
value = Meta.getValue(listValues[i], entorno, arbol)
if Meta.contains(value, objectType) == False:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
borra el print de abajo o comentalo xd
Descripcion: la columna: %nameColumn% No acepta el %value.tipo%
'''
#tipo:str = Meta.getTypeByHead(headColumns[i])
#Error: ErroresSemanticos = ErroresSemanticos(
# "XX5:la columna: \'" + nameColumn + "\' Solo acepta valoes del tipo "+tipo, 0,
# 0,
# 'Use database')
#Meta.arbol.ErroresSemanticos.append(Error)
#print(' la columna: \'' + nameColumn + '\' Solo acepta valores del tipo: ',tipo)
result = True
else:
if typeColumn != typeValue:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
borra el print de abajo o comentalo xd
Descripcion: la columna: %nameColumn% No acepta el %value.tipo%
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX5:la columna: " + nameColumn +
" No acepta el tipo ingresado", 0, 0, 'Use database')
Meta.arbol.ErroresSemanticos.append(Error)
print(' la columna: \'' + nameColumn +
'\' No acepta el tipo ingresado')
result = False
return result
def execute(self, entorno: Tabla_de_simbolos, arbol: Arbol):
databaseName = entorno.getBD()
Meta.tableName = self.tableName
Meta.databaseName = databaseName
Meta.arbol = arbol
self.arbol = arbol
Meta.entorno = entorno
if entorno.BDisNull():
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
borra el print de abajo o comentalo xd
Descripcion: BD %databaseName% no existe ("BD " + databaseName + " no existe")
'''
Error: ErroresSemanticos = ErroresSemanticos("XX00: internal_error db is not exist",
self.linea,
self.columna,
'Insert')
arbol.ErroresSemanticos.append(Error)
print('BD' + databaseName + 'no existe')
return
if not self.listColumn:
self.insertNormal(databaseName, entorno, arbol)
else:
self.insertWithListId(databaseName, entorno, arbol)
def checkLen(self, columns: list, values: list) -> bool:
lengthColumn = len(columns)
lengthValues = len(values)
if lengthValues > lengthColumn:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
borra el print de abajo o comentalo xd
Descripcion: Insert Demasiados Parametros
'''
Error: ErroresSemanticos = ErroresSemanticos("XX00: internal_error hay mas parametros en el insert", self.linea,
self.columna,
'Insert')
self.arbol.ErroresSemanticos.append(Error)
print('Hay Mas valores de los permitidos')
return False
elif lengthValues < lengthColumn:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
borra el print de abajo o comentalo xd
Descripcion: Faltan parametros en el insert
'''
Error: ErroresSemanticos = ErroresSemanticos("XX00: internal_error Faltan parametros en el insert", self.linea,
self.columna,
'Insert')
self.arbol.ErroresSemanticos.append(Error)
print('Faltan valores para ingresar')
return False
# si no es mayor ni tampoco menor entonces es igual
else:
return True
def existTable(cls, database: str, table: str) -> bool:
tables_: list = dbms.showTables(database)
# La Base de datos existe
if tables_ != None:
for table_ in tables_:
if table_ == table:
return True
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
borra el print de abajo o comentalo xd
Descripcion: La %table% no existe en %database%
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX5: la tabla " + table + "no existe en la base de datos " +
database, 0, 0, 'Meta')
Meta.arbol.ErroresSemanticos.append(Error)
#print('La tabla no existe en ' + database)
return False
else:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
borra el print de abajo o comentalo xd
Descripcion: La %database% no existe
'''
print('La ' + database + ' de datos no existe')
Error: ErroresSemanticos = ErroresSemanticos(
"XX5: no existe la base de datos " + database, 0, 0, 'Meta')
Meta.arbol.ErroresSemanticos.append(Error)
return False
def execute(self, entorno: Tabla_de_simbolos, arbol: Arbol):
izquierdo: Valor = self.izq.execute(entorno, arbol)
derecho: Valor = self.der.execute(entorno, arbol)
if derecho == 0:
Error: ErroresSemanticos = ErroresSemanticos(
"Error semantico no se puede dividir entre 0", self.linea,
self.columna, "DIVISION")
arbol.ErroresSemanticos.append(Error)
else:
tipoRes = COMPROBADOR_deTipos(izquierdo.tipo, derecho.tipo, "/")
if tipoRes == 0:
newValor: Valor = Valor(tipoRes, izquierdo.data / derecho.data)
return newValor
def checkUnique(cls, listColumn, listValues, headColumns) -> bool:
'''
Verifica que no se repita un campo que tenga con restrccion unique
:param listColumn: lista de columnas a evaluar
:param listValues: lista de valores de esas columnas
:param headColumns: encabezado de la tabla
:return: False-> si se repite algun campo con restriccion unique
:return: True-> si ningun campo se repite
'''
columnsUnique = Meta.getNameColumnsUnique(headColumns)
fields = Meta.toListFields(listColumn, listValues)
for i in range(len(columnsUnique)):
columnUnique = columnsUnique[i]
for j in range(len(fields)):
field: Field = fields[j]
if columnUnique == field.name:
valuesColumn = Meta.getColumnsValues(columnUnique)
if Meta.contains(field.value, valuesColumn) == True:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
borra el print de abajo o comentalo xd
Descripcion:'la columna: '+namecolumn+'Ya se ha ingresado.'
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX5: El campo: " + field.name +
" No adminite valores repetidos, El valor: " +
str(field.value) + " Ya se ha ingresado", 0, 0,
'Use database')
Meta.arbol.ErroresSemanticos.append(Error)
print(
'El campo: \'' + field.name +
'\' No adminite valores repetidos, El valor: \'' +
str(field.value) + '\' Ya se ha ingresado')
return False
return True
pass
def execute(self, entorno: Tabla_de_simbolos, arbol: Arbol):
if self.exist(self.id) is True:
entorno.setBD(self.id)
arbol.console.append('tytus> Trabajando en: \'' + self.id + '\'')
print('tytus> Trabajando en: \'' + self.id + '\'')
else:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
Descripcion: BD %databaseName% no existe ("BD " + databaseName + " no existe")
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX00: la base de datos no existe", self.linea, self.columna,
'Use database')
arbol.ErroresSemanticos.append(Error)
print("error no existe la bd")
return
def execute(self, entorno: Tabla_de_simbolos, arbol: Arbol):
izquierdo: indexador_auxiliar = self.izq
derecho: Valor = self.der.execute(entorno, arbol)
if self.tipoOperaRelacional == "=":
if entorno.varibaleExiste("TablaResult"):
TablaResult: Valor = entorno.obtener_varibale("TablaResult")
TablaResult.inicializarPrettybabe()
TablaResult.filtrarWhere("=", izquierdo.referencia,
derecho.data)
simbol: Simbolo = Simbolo("TablaResult", 0, TablaResult)
entorno.insertar_variable(simbol)
retorno: bool = not (TablaResult.matriResult_isEmpty())
arbol.console.append("\n" +
TablaResult.inicializarPrettybabe() +
"\n")
print(str(retorno) + " <--------------")
return Valor(3, retorno)
else:
# Codigo de Pablo
# Se crea una lista que contendra o no las llaves primarias que cumplan la condicion
registers = []
'''
Se obtiene la tabla, el indice de la columna que especifica el lado izquierdo de la operacion
relacional y las llaves primarias
'''
table = entorno.gettable()
pks = Meta.getPksIndex(table[0])
column = Meta.getNumberColumnByName(izquierdo.get_origen(),
table[0])
# Si la columna existe
if column != -1:
# Se recorre cada uno de los registros de la tabla
for row in range(len(table)):
# Si el registro coincide con el valor
if table[row][column] == derecho.data:
# Si no hay llaves primarias en la tabla
if not pks:
registers.append(str([row]))
# Si hay llaves primarias en la tabla
else:
inner = []
for pk in pks:
inner.append(str(table[row][pk]) + '|')
registers.append(inner)
# Se devuelven los valores de las llaves primarias de las filas que cumplen la condicion o es vacia
return registers
# Si la columna no existe
else:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
Descripcion: La columna especificada izquierdo.get_origen() no existe.
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX01: La columna especificada izquierdo.get_origen() no existe",
self.linea, self.columna, 'Operaciones Relacionales')
arbol.ErroresSemanticos.append(Error)
print(
'La columna especificada izquierdo.get_origen() no existe'
)
return None
elif self.tipoOperaRelacional == "u:=":
return {izquierdo: self.der}
def execute(self, entorno: Tabla_de_simbolos, arbol: Arbol):
if self.replace is True and self.ifnotexists is True or self.replace is False and self.ifnotexists is False:
resultado = dbms.createDatabase(self.id)
if resultado == 0: # OPERACION EXITOSA
arbol.console.append('tytus> Base de datos \'' + self.id +
'\' creada exitosamente')
print('tytus> Base de datos \'' + self.id +
'\' creada exitosamente')
elif resultado == 1: # ERROR EN LA OPERACION
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
Descripcion: error en la operacion
'''
Error: ErroresSemanticos = ErroresSemanticos(
"0LP01 invalid_grant_operation", self.linea, self.columna,
'create database')
arbol.ErroresSemanticos.append(Error)
print("error en la operacion")
else: # LA BASE DE DATOS YA EXISTE
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
Descripcion: la BD ya existe ("BD " + databaseName + " ya existe")
'''
Error: ErroresSemanticos = ErroresSemanticos(
"42P04 duplicate_database", self.linea, self.columna,
'create database')
arbol.ErroresSemanticos.append(Error)
print("ya existe la base de datos")
elif self.replace is True and self.ifnotexists is False:
if self.existe(self.id) is True:
dbms.dropDatabase(self.id)
arbol.console.append('tytus> Base de datos \'' + self.id +
'\' eliminada exitosamente')
print('tytus> Base de datos \'' + self.id +
'\' eliminada exitosamente')
dbms.createDatabase(self.id)
arbol.console.append('tytus> Base de datos \'' + self.id +
'\' creada exitosamente')
print('tytus> Base de datos \'' + self.id +
'\' creada exitosamente')
else:
if self.existe(self.id) is False:
dbms.createDatabase(self.id)
arbol.console.append('tytus> Base de datos \'' + self.id +
'\' creada exitosamente')
print('tytus> Base de datos \'' + self.id +
'\' creada exitosamente')
else:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
Descripcion: la BD ya existe ("BD " + databaseName + " ya existe")
'''
Error: ErroresSemanticos = ErroresSemanticos(
"42P04 duplicate_database", self.linea, self.columna,
'create database')
arbol.ErroresSemanticos.append(Error)
print("ya existe la base de datos")
def execute(self, entorno: Tabla_de_simbolos, arbol: Arbol):
# Se obtiene la base de datos actual, la tabla a crear y el numero de colúmnas
bdactual = entorno.getBD()
self.bd_actual = bdactual
nuevatabla = self.id
nocolumnas = len(self.columnas)
if self.herencia is not None:
self.inh = self.definir_inherits(self.herencia.tabla)
if self.inh is not None:
self.ifinh = True
nocolumnas = nocolumnas + len(self.inh)
else:
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
Descripcion: ocurrio un error o no existe la base de datos
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX00: internal_error db is not exist", self.linea,
self.columna, 'Create Table')
arbol.ErroresSemanticos.append(Error)
print("error")
#return
# Se utiliza el paquete de almacenamiento para enviar a crear una nueva tabla y se obtiene un retorno
retorno = dbms.createTable(bdactual, nuevatabla, nocolumnas)
if retorno == 0: # Si la operacion exitosa
primarykeys = self.crear_pks(
) # Se verifican si existen llaves primarias
if len(primarykeys) != 0:
pks = self.obtenerindice(primarykeys)
dbms.alterAddPK(bdactual, nuevatabla,
pks) # Se crean las llaves primarias
cadena = "tytus> La tabla '" + self.id + "' fue creada exitosamente"
print("tytus> La tabla '" + self.id +
"' fue creada exitosamente")
arbol.console.append(cadena)
else:
pks = self.obtenerindice(primarykeys)
if len(pks) != 0:
dbms.alterAddPK(bdactual, nuevatabla,
pks) # Se crean las llaves primarias
self.crear_encabezados(
bdactual, entorno,
arbol) # Se crean los encabezados de las columnas
elif retorno == 1: # Error en la operacion
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
Descripcion: error en la operacion
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX00: internal_error error en la operacion", self.linea,
self.columna, 'Create Table')
arbol.ErroresSemanticos.append(Error)
print("Nel error")
elif retorno == 2: # La base de datos no existe
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
Descripcion: no existe la base de datos
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX00: internal_error db is not exist", self.linea,
self.columna, 'Create Table')
arbol.ErroresSemanticos.append(Error)
print("Nel no existe la bd")
elif retorno == 3: # La tabla ya existe
'''
______ _____ _____ ____ _____
| ____| __ \| __ \ / __ \| __ \
| |__ | |__) | |__) | | | | |__) |
| __| | _ /| _ /| | | | _ /
| |____| | \ \| | \ \| |__| | | \ \
|______|_| \_\_| \_\\____/|_| \_\
Descripcion: la tabla 'self.id' ya existe
'''
Error: ErroresSemanticos = ErroresSemanticos(
"XX01: internal_error id ya existe", self.linea, self.columna,
'Create Table')
arbol.ErroresSemanticos.append(Error)
print("Nel ya existe la tabla")