def ejecutar(self):
global resultadotxt
global cont
global tabla
global NombreDB
try:
resultado = func.createTable(NombreDB, self.iden,len(self.coltb))
if(resultado == 2):
resultadotxt += "No existe la base de datos: " + NombreDB + "\n"
elif(resultado == 3):
resultadotxt += "La tabla ya existe: " + self.iden + "\n"
else:
resultadotxt += "Se creo la tabla: " + self.iden + " En la base de datos: " + NombreDB + "\n"
buscar = tabla.BuscarNombre(NombreDB)
simbolo = TS.Simbolo(cont,TS.TIPO.TABLE, self.iden, buscar.id)
cont+=1
tabla.agregar(simbolo)
"""SE CREAN LAS COLUMNAS PARA LA TABLA"""
inicio = 1
for columna in self.coltb:
ncolumna = TS.Simbolo(cont,columna.tipo,columna.iden,simbolo.id,inicio)
inicio+=1
cont+=1
tabla.agregar(ncolumna)
except:
"""ERROR SEMANTICO"""
def execute(self, table: SymbolTable, tree):
super().execute(table, tree)
result_name = self.name.execute(table, tree)
result_inherits_from = self.inherits_from.execute(
table, tree) if self.inherits_from else None
result_fields = []
if result_inherits_from:
# get inheritance table, if doesn't exists throws semantic error, else append result
result_fields.append(
table.get_fields_from_table(result_inherits_from))
result = createTable('db_from_st', result_name, len(result_fields))
if result == 1:
raise Error(0, 0, ErrorType.RUNTIME, '5800: system_error')
return False
elif result == 2:
raise Error(0, 0, ErrorType.RUNTIME,
'42P04: database_does_not_exists')
return False
elif result == 3:
raise Error(0, 0, ErrorType.RUNTIME, '42P07: duplicate_table')
return False
else:
table.add(TableSymbol(table.get_current_db().name, result_name))
result_fields = self.fields.execute(
table, tree) # A list of TableField assumed
for field in result_fields:
field.table_name = result_name
table.add(field)
return
def execute(self, table: SymbolTable, tree):
super().execute(table, tree)
#result_name = self.name.execute(table, tree)
result_name = self.name
result_inherits_from = self.inherits_from.execute(table, tree) if self.inherits_from else None
result_fields = self.fields
if result_inherits_from:
# get inheritance table, if doesn't exists throws semantic error, else append result
result_fields.append(table.get_fields_from_table(result_inherits_from))
result = createTable(table.get_current_db().name, result_name, len(result_fields))
if result == 1:
raise Error(0, 0, ErrorType.RUNTIME, '5800: system_error')
return False
elif result == 2:
raise Error(0, 0, ErrorType.RUNTIME, '42P04: database_does_not_exists')
return False
elif result == 3:
raise Error(0, 0, ErrorType.RUNTIME, '42P07: duplicate_table')
return False
else:
#add primary keys, jsonMode needs the number of the column to set it to primarykey
keys = list(
map(
lambda x: result_fields.index(x),
filter(lambda key: key.is_pk == True, result_fields)
)
)
if(len(keys)>0):
result = alterAddPK(table.get_current_db().name, result_name, keys)
table.add(TableSymbol(table.get_current_db().id, result_name, self.check_exp))
##result_fields = self.fields.execute(table, tree) # A list of TableField assumed
field_index = 0
for field in result_fields:
field.table_name = result_name
field.field_index = field_index
field.type = SymbolType.FIELD
field_index += 1
table.add(field)
return "Table: " +str(result_name) +" created."
def execute(self, table: SymbolTable, tree):
super().execute(table, tree)
result_name = self.name
result_inherits_from = self.inherits_from.val if self.inherits_from else None
result_fields = self.fields
if result_inherits_from:
# get inheritance table, if doesn't exists throws semantic error, else append result
result_fields += table.get_fields_from_table(result_inherits_from)
result = createTable(table.get_current_db().name, result_name,
len(result_fields))
if result == 1:
raise Error(self.line, self.column, ErrorType.RUNTIME,
'5800: system_error')
elif result == 2:
raise Error(self.line, self.column, ErrorType.RUNTIME,
'42P04: database_does_not_exists')
elif result == 3:
raise Error(self.line, self.column, ErrorType.RUNTIME,
'42P07: duplicate_table')
else:
# add primary keys, jsonMode needs the number of the column to set it to primarykey
keys = list(
map(lambda x: result_fields.index(x),
filter(lambda key: key.is_pk is True, result_fields)))
if len(keys) > 0:
result = alterAddPK(table.get_current_db().name, result_name,
keys)
table.add(
TableSymbol(table.get_current_db().id, result_name,
self.check_exp))
field_index = 0
for field in result_fields:
nuevo = FieldSymbol(table.get_current_db().name, result_name,
field_index, field.name, field.field_type,
field.length, field.allows_null, field.is_pk,
None, None)
field_index += 1
table.add(nuevo)
return "Table: " + str(result_name) + " created."
def execute(self, table, tree):
super().execute(table, tree)
result_name = self.name.execute(table, tree)
result_inherits_from = self.inherits_from.execute(table, tree) if self.inherits_from else None
result_fields = []
if result_inherits_from:
# get inheritance table, if doesn't exists throws semantic error, else append result
result_fields.append([])
result = createTable('db_from_st', result_name, len(result_fields))
if result == 1:
# log error on operation
return False
elif result == 2:
# log error because db does not exists
return False
elif result == 3:
# log error because table already exists
return False
else:
return True
return True
def ejecutar(self):
global resultadotxt
global cont
global tabla
global NombreDB
try:
resultado = func.createTable(NombreDB, self.iden, 0)
if (resultado == 2):
resultadotxt += "No existe la base de datos: " + NombreDB + "\n"
elif (resultado == 3):
resultadotxt += "La tabla ya existe: " + self.iden + "\n"
else:
buscar = tabla.BuscarNombre(NombreDB)
NuevoSimbolo = TS.Simbolo(cont, self.iden, TS.TIPO.TABLE,
buscar.id, 0)
cont += 1
tabla.agregar(NuevoSimbolo)
"""SE CREAN LAS COLUMNAS PARA LA TABLA"""
inicio = 0
for columna in self.coltb:
try:
if "primary key " in columna.key.lower():
NuevaColumna = TS.Simbolo(
cont, columna.iden, TS.TIPO.COLUMN,
NuevoSimbolo.id, 0, columna.tipo, 1,
columna.references, columna.default, False,
columna.constraint, inicio)
listacol = []
listacol.append(NuevaColumna.numcol)
print(max(listacol))
print(min(listacol))
resultado = func.alterAddPK(
NombreDB, NuevoSimbolo.nombre, listacol)
resultado2 = func.alterAddColumn(
NombreDB, self.iden, columna)
else:
NuevaColumna = TS.Simbolo(
cont, columna.iden, TS.TIPO.COLUMN,
NuevoSimbolo.id, 0, columna.tipo, 0,
columna.references, columna.default, False,
columna.constraint, inicio)
resultado = func.alterAddColumn(
NombreDB, self.iden, columna)
if resultado == 2:
resultadotxt += "No existe la base de datos " + NombreDB + "\n"
elif resultado == 3:
resultadotxt += "No existe la tabla " + self.iden + "\n"
elif resultado == 4:
resultadotxt += "Ya existe una llave primaria en " + self.iden + "\n"
else:
if columna.notnull.lower() == "not null":
NuevaColumna.nullcol = True
else:
NuevaColumna.nullcol = False
cont += 1
inicio += 1
NuevoSimbolo.coltab += 1
tabla.actualizar(NuevoSimbolo)
tabla.agregar(NuevaColumna)
resultadotxt += "Se agrego la columna " + columna.iden + " a la tabla " + self.iden + "\n"
except:
"""ERROR SEMANTICO"""
resultadotxt += "Se creo la tabla: " + self.iden + " En la base de datos: " + NombreDB + "\n"
except:
"""ERROR SEMANTICO"""
def ejecutar(self, tabalSimbolos, listaErrores):
baseDatos = tabalSimbolos.useDataBase
bandera = baseDatos.comprobarNombreTabla(self.identificador)
if bandera == 1:
#Tabla ya existe
errorEnviar = errorReportar.ErrorReportar(self.fila, self.columna,
"Ejecucion",
"Error 42P07")
listaErrores.append(errorEnviar)
return
else:
#Nombre de tabla no existe en base de datos
numColumnas = 0
for columna in self.columnas:
try:
if columna.hijos[0].nombreNodo == "ID":
numColumnas = numColumnas + 1
except:
pass
respuesta = jsonMode.createTable(tabalSimbolos.useDataBase.nombre,
self.identificador, numColumnas)
#Valor de retorno: 0 operación exitosa, 1 error en la operación, 2 base de datos inexistente, 3 tabla existente.
if respuesta == 2:
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error, base de datos inexistente")
listaErrores.append(errorEnviar)
return
elif respuesta == 3:
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion", "Error 42P07")
listaErrores.append(errorEnviar)
return
elif respuesta == 1:
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error en la operacion")
listaErrores.append(errorEnviar)
return
elif respuesta == 0:
#modificar el nombre que se envia de base de datos
tablaGuardar = simboloTabla.SimboloTablas(self.identificador)
try:
if self.herencia[0].hijos[0].nombreNodo == "ID":
comprobar = baseDatos.comprobarNombreTabla(
self.herencia[0].hijos[0].valor)
if comprobar == 1:
tablaHerencia = baseDatos.obtenerTabla(
self.herencia[0].hijos[0].valor)
tablaGuardar.columnas = tablaHerencia.columnas
except:
pass
indice = len(tablaGuardar.columnas)
for columna in self.columnas:
try:
if columna.hijos[0].nombreNodo == "ID":
nuevaColumna = simboloColumna.SimboloColumna(
indice, columna.hijos[0].valor,
columna.hijos[1].valor)
#Es un tipo de dato no primitivo
if nuevaColumna.tipoDato == simboloColumna.TiposDatos.enum:
simboloNuevo = baseDatos.obtenerTipoDatoNoPrimitivo(
columna.hijos[1].valor)
if simboloNuevo != None:
# seteas la instancia de nodo simboloNuevoTipo
nuevaColumna.tipoDatoNOprimitivo = simboloNuevo
else:
#mandas error
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error 42704: Tipo de dato no existe")
listaErrores.append(errorEnviar)
return
pass
self.especificarColumnas(columna.hijos[2],
nuevaColumna, baseDatos,
listaErrores)
tablaGuardar.agregarColumna(nuevaColumna)
elif columna.hijos[0].nombreNodo == "PRIMARY":
encontro = False
for nodoId in columna.hijos[1].hijos:
for columnaEvaluar in tablaGuardar.columnas:
if nodoId.valor.lower(
) == columnaEvaluar.nombre.lower():
encontro = True
columnaEvaluar.crearLlavePrimaria()
print(
"setear llave primaria si existen las columnas: "
+ nodoId.valor.lower())
if encontro == False:
#Id de columna llamado en llave no existe Error 42703
errorEnviar = errorReportar.ErrorReportar(
self.fila, self.columna, "Ejecucion",
"Error 42703")
listaErrores.append(errorEnviar)
print(
"Id de columna llamado en llave no existe: "
+ nodoId.valor.lower())
return
elif encontro == True:
encontro = False
elif columna.hijos[0].nombreNodo == "FOREIGN":
print(
"setear llave foranea si existen las columnas")
elif columna.hijos[0].nombreNodo == "UNIQUE":
print(
"setear llave foranea si existen las columnas")
except:
pass
indice = indice + 1
baseDatos.agregarTabla(tablaGuardar)
return
pass
def execute(self, ts):
#print('----> EJECUTAR CREATE TABLE * '+str(self.id))
mensaje = '\n****CREATE TABLE ' + str(self.id) + '****\n'
self.base = ts.get_dbActual().id
if (isinstance(self.base, E.Errores)):
#no hay base Activa
mensaje = mensaje + '\tERROR - No hay base activa\n'
print(
'***************************error - no hay base activa********************'
)
return mensaje
#creamos la tabla
new_tabla = TS.Simbolo(self.id, TS.tipo_simbolo.TABLE, None, self.base,
None, None, None, None)
#insertamos la tabla a la ts
verificar_tabla = ts.agregar_tabla(str(self.base), new_tabla)
if (isinstance(verificar_tabla, E.Errores)):
#print('***************************error********************')
mensaje = mensaje + '\tError en creación de tabla'
return mensaje
else:
#print('se agrego')
#agregamos las columnas a la tabla
for columna in self.cols:
columna.base = self.base
for const in columna.valor:
if (const.tipo == TS.t_constraint.PRIMARY):
columna.pk = True
columna.valor.remove(const)
elif (const.tipo == TS.t_constraint.FOREIGN):
columna.fk = True
columna.referencia = str(const.id) + ',' + str(
const.valor)
columna.valor.remove(const)
if columna.longitud == None:
columna.longitud = 0
ts.agregar_columna(self.id, self.base, columna)
'''
if self.cont_key != '':
for c in self.cont_key:
ag = ts.get_column(self.base, self.id, c.columna)
if not isinstance(ag, E.Errores):
if const[0].tipo == TS.t_constraint.FOREIGN:
ag.fk = True
ag.referencia = const[0].valor
if const[0].id != None:
ag.valor.append(const[0])
elif const[0].tipo == TS.t_constraint.PRIMARY:
ag.pk = True
if const[0].id != None:
ag.valor.append(const[0])
else:
#print('---->Entró a otros')
ag.valor.append(const[0])
#mensaje = mensaje + '\tSe agregó el constraint correctamente'
#return mensaje
else:
mensaje = mensaje + '\tNo se pudo agregar el constraint'
#return mensaje
'''
mensaje = mensaje + '\tTabla creada correctamente\n'
j.createTable(self.base, self.id, len(self.cols))
return mensaje
