def ejecutar(self, TS, Errores): #No se toca el owner para esta fase
if self.if_not_exist:
if self.nombre_DB in TypeChecker.showDataBases():
Errores.insertar(
err.Nodo_Error('42P04', 'duplicated database', self.fila,
self.columna))
return '42P04: duplicated database\n'
if self.or_replace:
respuesta = TypeChecker.dropDataBase(self.nombre_DB)
if respuesta == 1:
Errores.insertar(
err.Nodo_Error('XX000', 'internal_error', self.fila,
self.columna))
return 'XX000: internal_error\n'
if self.mode > 5 or self.mode < 1:
Errores.insertar(
err.Nodo_Error('Semantico', 'El modo debe estar entre 1 y 5',
self.fila, self.columna))
return 'Error semantico: El modo debe estar entre 1 y 5\n'
respuesta = TypeChecker.createDataBase(self.nombre_DB, self.mode,
self.owner)
if respuesta == 2:
Errores.insertar(
err.Nodo_Error('42P04', 'duplicated database', self.fila,
self.columna))
return '42P04: duplicated database\n'
if respuesta == 1:
Errores.insertar(
err.Nodo_Error('P0000', 'plpgsql_error', self.fila,
self.columna))
return 'P0000: plpgsql_error\n'
return 'BASE DE DATOS %s CREADA\n' % self.nombre_DB
def ejecutar(self, TS, Errores):
nombre_DB = os.environ['DB']
if nombre_DB is None:
Errores.insertar(
err.Nodo_Error(
'P0002',
'no data found, no hay una base de datos seleccionada',
self.fila, self.columna))
return 'P0002: no data found, no hay una base de datos seleccionada\n'
respuesta = TypeChecker.dropTable(nombre_DB, self.nombre_tabla)
if respuesta != 0:
if respuesta == 1:
Errores.insertar(
err.Nodo_Error('XX000', 'internal_error', self.fila,
self.columna))
return 'XX000: internal_error\n'
elif respuesta == 2:
Errores.insertar(
err.Nodo_Error(
'3D000', 'No existe base de datos <<%s>>' % nombre_DB,
self.fila, self.columna))
return '3D000: No existe base de datos <<%s>>\n' % nombre_DB
else:
Errores.insertar(
err.Nodo_Error(
'42P01',
'No existe la tabla <<%s>>' % self.nombre_tabla,
self.fila, self.columna))
return '42P01: No existe la tabla <<%s>>\n' % self.nombre_tabla
return 'Tabla <<%s>> eliminada\n' % self.nombre_tabla
def ejecutar(self, TS, Errores):
if self.nuevo_nombre_DB is not None:
respuesta = TypeChecker.alterDataBase(self.nombre_DB,
self.nuevo_nombre_DB)
if respuesta == 1:
Errores.insertar(
err.Nodo_Error('XX000', 'internal_error', self.fila,
self.columna))
return 'XX000: internal_error\n'
elif respuesta == 2:
Errores.insertar(
err.Nodo_Error(
'3D000',
'No existe base de datos <<%s>>' % self.nombre_DB,
self.fila, self.columna))
return '3D000: No existe base de datos <<%s>>' % self.nombre_DB
elif respuesta == 3:
Errores.insertar(
err.Nodo_Error('42P04', 'duplicated database', self.fila,
self.columna))
return '42P04: duplicated database\n'
return 'Base de datos %s, renombrada a: %s' % (
self.nombre_DB, self.nuevo_nombre_DB)
else:
if self.current_user:
return 'No hay implementacion para esto porque no se maneja usuario\n'
elif self.session_user:
return 'No hay implementacion para esto porque no se maneja usuario\n'
else:
respuesta = TypeChecker.alterDataBaseOwner(
self.nombre_DB, self.owner)
if respuesta == 1:
Errores.insertar(
err.Nodo_Error('XX000', 'internal_error', self.fila,
self.columna))
return 'XX000: internal_error\n'
elif respuesta == 2:
Errores.insertar(
err.Nodo_Error(
'3D000',
'No existe base de datos <<%s>>' % self.nombre_DB,
self.fila, self.columna))
return '3D000: No existe base de datos <<%s>>' % self.nombre_DB
return 'Owner de base de datos <<%s>>, cambiado a <<%s>>' % (
self.nombre_DB, self.owner)
def ejecutar(self, TS, Errores):
respuesta = TypeChecker.registarEnum(self.nombre_type, self.lista_enum)
if respuesta != 0:
Errores.insertar(
err.Nodo_Error(
'42710', 'duplicate_object, ya existe un tipo <<%s>>' %
self.nombre_type, self.fila, self.columna))
return '42710: duplicate_object, ya existe un tipo <<%s>>\n' % self.nombre_type
return 'Type <<%s>> creado satisfactoriamente\n' % self.nombre_type
def ejecutar(self, TS, Errores):
databases = TypeChecker.showDataBases()
if self.like_str is not None:
databases_con_filtro = []
for nombre_db in databases:
if self.like_str in nombre_db:
databases_con_filtro.append(nombre_db)
databases = databases_con_filtro
respuesta = PrettyTable()
respuesta.field_names = ["DBName"]
for nombre_db in databases:
respuesta.add_row([nombre_db])
return respuesta.get_string() + '\n'
def ejecutar(self, TS, Errores):
respuesta = TypeChecker.dropDataBase(self.nombre_DB)
if respuesta == 2: #Base de datos no existente
if self.if_exists:
return 'NOTICIA: BASE DE DATOS %s, NO EXISTENTE\n' % self.nombre_DB
Errores.insertar(
err.Nodo_Error(
'3D000', 'No existe base de datos <<%s>>' % self.nombre_DB,
self.fila, self.columna))
return '3D000: No existe base de datos <<%s>>\n' % self.nombre_DB
if respuesta == 1: #Error interno
Errores.insertar(
err.Nodo_Error('P0000', 'plpgsql_error', self.fila,
self.columna))
return 'P0000: plpgsql_error\n'
return 'BASE DE DATOS %s ELIMINADA\n' % self.nombre_DB
def ejecutar(self, TS, Errores):
bd = os.environ['DB']
infoTB = tp.showColumns(bd, self.id) #datos de tabla
nombreCol = list(infoTB.keys())
TiposCol = list(infoTB.values())
if self.condicion != '':
col = self.condicion.exp1.id
op = self.condicion.op
valor = self.condicion.exp2.val
if col in nombreCol:
noColumna = nombreCol.index(col) #indice col
npPK = tp.showPrimaryKeys(bd, self.id) #retorna nombre
indicePK = nombreCol.index(npPK[0]) #indice pk
try:
res = wh.evaluar(bd, self.id, col, op, valor, noColumna,
indicePK, 'delete')
respuesta = jm.delete(bd, self.id, res)
if respuesta == 2: # noexisteDB
Errores.insertar(
Nodo_Error('08003', 'connection_does_not_exist',
self.fila, self.columna))
return '08003: connection_does_not_exist\n'
elif respuesta == 3: # noexisteTB
Errores.insertar(
Nodo_Error('HV00R', 'fdw_table_not_found',
self.fila, self.columna))
return 'HV00R: fdw_table_not_found \n'
elif respuesta == 4: # noexistePk
Errores.insertar(
Nodo_Error('P0002', 'no_data_found ', self.fila,
self.columna))
return 'P0002: no_data_found \n'
elif respuesta == 1: # error
Errores.insertar(
Nodo_Error('XX000', 'internal_error', self.fila,
self.columna))
return 'XX000: internal_error \n'
else:
return 'Se eliminaron los registros de la tabla \n'
except:
Errores.insertar(
Nodo_Error('XX000', 'internal_error', self.fila,
self.columna))
return 'XX000: internal_error \n'
else:
Errores.insertar(
Nodo_Error('42P10', 'invalid_column_reference ', self.fila,
self.columna))
return '42P10 : invalid_column_reference \n'
else: #elimina todos los registros
respuesta = jm.truncate(bd, self.id)
if respuesta == 2: # noexisteDB
Errores.insertar(
Nodo_Error('08003', 'connection_does_not_exist', self.fila,
self.columna))
return '08003: ' + str(bd) + ' connection_does_not_exist\n'
elif respuesta == 3: # noexisteTB
Errores.insertar(
Nodo_Error('42P01', 'undefined_table', self.fila,
self.columna))
return '42P01: ' + str(self.id) + 'undefined_table \n'
elif respuesta == 1: # error
Errores.insertar(
Nodo_Error('XX000', 'internal_error', self.fila,
self.columna))
return 'XX000: internal_error \n'
else:
return 'Se eliminaron los registros de la tabla ' + str(
self.id)
def ejecutar(self, TS, Errores):
columnas = []
col_dict = {}
tuplas = []
tuplas_aux = []
ordencol = []
db = os.environ['DB']
result = 'Query from tables: '
contador = 0
tablasError = []
tableState = True
#---------------------FROM
if len(self.tables) != 0:
for tabla in self.tables:
while jm.extractTable(db, tabla) is not None:
tuplas += jm.extractTable(db, tabla)
col_dict += tp.showColumns(db, tabla)
tablasError.append(tabla)
tableState = False
if tableState:
#--------------------WHERE
if isinstance(self.conditions, Where):
self.conditions.ejecutar(TS, Errores)
# ---------------------ORDER BY
if self.ord is not None:
for ord in self.ord:
ord.ejecutar(TS, Errores)
ord_dict = {
'columna': ord.columna,
'orden': ord.orden,
'nulls': ord.nulls
}
ordencol.append(ord_dict)
if self.arguments is not None:
for columna in self.arguments:
columna.ejecutar(TS, Errores)
if columna.op_type == 'as':
if columna.val.op_type == 'valor' or \
columna.val.op_type == 'Aritmetica' or \
columna.val.op_type == 'Relacional' or \
columna.val.op_type == 'Logica' or \
columna.val.op_type == 'unario':
tuplas_aux.append(columna.val.val)
columnas.append(columna.asid)
elif columna.op_type == 'valor':
columnas.append('Columna ' + str(contador))
tuplas_aux.append(columna.val)
contador = contador + 1
elif columna.op_type == 'iden':
columnas.append(columna.id)
else:
tuplas.append(columna.val)
columnas.append('Columna ' + str(contador))
contador = contador + 1
else:
columnas = list(col_dict.keys())
if len(columnas) != 0:
self.result_query.field_names = columnas
cont = 0
if len(tuplas_aux) > 0:
tuplas += [tuplas_aux]
if len(tuplas) != 0:
if ordencol is not None:
for dic in ordencol:
while dic['columna'] != columnas[cont]:
cont = cont + 1
for item in ordencol:
if item['orden'] == 'asc':
tuplas = sorted(tuplas, key=itemgetter(cont))
else:
tuplas = sorted(tuplas,
key=itemgetter(cont),
reverse=True)
if isinstance(self.conditions, Where):
new_tuplas = []
for tupla in tuplas:
if self.conditions.dictionary['val'] in tupla:
new_tuplas.append(tupla)
tuplas = new_tuplas
if len(tuplas[0]) == len(columnas):
for tupla in tuplas:
self.result_query.add_row(tupla)
else:
new_tuplas2 = []
indices = []
index = 0
for col in col_dict.keys():
if col == columnas[index]:
indices.append(index)
index = index + 1
for ind in indices:
new_tuplas2 = list(map(itemgetter(ind), tuplas))
print(new_tuplas2)
else:
tabless = ''
for tabla in tablasError:
Errores.insertar(
Nodo_Error('42P01', 'undefined_table', self.line,
self.column))
tabless += str(tabla) + ' '
result = '42P01: <<' + str(tabless) + '>> UNDEFINED TABLE(S)'
return result
if self.tables is not []:
for obj in self.tables:
result += str(obj) + ' '
result += '\n' + self.result_query.get_string()
return result
def ejecutar(self, TS, Errores):
bd = os.environ['DB']
infoTB = tp.showColumns(bd, self.table_id) # datos de tabla
noCol = len(infoTB)
nombreCol = list(infoTB.keys())
TiposCol = list(infoTB.values())
tipos = []
val = [] # valores
noValores = len(self.values) # noValues
for columna in self.values:
columna.ejecutar(TS, Errores)
val.append(columna.val)
tipos.append(columna.type)
if self.col != None:
noc = len(self.col)
if noc == noCol:
for nn, ss in enumerate(self.col):
if ss == nombreCol[nn]:
pass
else:
Errores.insertar(
Nodo_Error('42P10', 'invalid_column_reference',
self.fila, self.columna))
return '42P10 : invalid_column_reference'
for n, s in enumerate(TiposCol):
k = list(s.values())
if (k[0] == 'integer' or k[0] == 'smallint'
or k[0] == 'bigint' or k[0] == 'decimal'
or k[0] == 'numeric' or k[0] == 'double'
or k[0] == 'money'):
if (tipos[n] == 'INT' or tipos[n] == 'DOUBLE'
or tipos[n] == 'FLOAT'):
if len(str(val[n])) <= k[1]:
pass
else:
Errores.insertar(
Nodo_Error('22023',
'invalid_parameter_value',
self.fila, self.columna))
return '22023 : invalid_parameter_value'
else:
Errores.insertar(
Nodo_Error('22023', 'invalid_parameter_value',
self.fila, self.columna))
return '22023 : invalid_parameter_value'
elif (k[0] == 'character varying' or k[0] == 'character'
or k[0] == 'varchar' or k[0] == 'char'
or k[0] == 'text'):
if (tipos[n] == 'CHAR' or tipos[n] == 'STR'):
if len(str(val[n])) <= k[1]:
pass
else:
Errores.insertar(
Nodo_Error('22023',
'invalid_parameter_value',
self.fila, self.columna))
return '22023 : invalid_parameter_value'
else:
Errores.insertar(
Nodo_Error('22023', 'invalid_parameter_value',
self.fila, self.columna))
return '22023 : invalid_parameter_value'
elif (k[0] == 'boolean'):
if (tipos[n] == 'BOOLEAN'):
pass
else:
Errores.insertar(
Nodo_Error('22023', 'invalid_parameter_value',
self.fila, self.columna))
return '22023 : invalid_parameter_value'
elif (k[0] == 'date'):
if (tipos[n] == 'DATE'):
if len(str(val[n])) <= k[1]:
pass
else:
Errores.insertar(
Nodo_Error('22023',
'invalid_parameter_value',
self.fila, self.columna))
return '22023 : invalid_parameter_value'
else:
Errores.insertar(
Nodo_Error('22023', 'invalid_parameter_value',
self.fila, self.columna))
return '22023 : invalid_parameter_value'
else:
res1 = tp.obtenerTiposEnum(k[0])
if val[n] in res1:
pass
else:
Errores.insertar(
Nodo_Error('22023', 'invalid_parameter_value',
self.fila, self.columna))
return '22023 : invalid_parameter_value'
respuesta = jm.insert(bd, self.table_id, val)
if respuesta == 2: # noexisteDB
Errores.insertar(
Nodo_Error('08003', 'connection_does_not_exist',
self.fila, self.columna))
return '08003: ' + str(bd) + ' connection_does_not_exist\n'
elif respuesta == 3: # noexisteTB
Errores.insertar(
Nodo_Error('42P01', 'undefined_table', self.fila,
self.columna))
return '42P01: ' + str(
self.table_id) + ' undefined_table \n'
elif respuesta == 5: # noColDiferente
Errores.insertar(
Nodo_Error('HV008', 'fdw_invalid_column_number',
self.fila, self.columna))
return 'HV008: fdw_invalid_column_number \n'
elif respuesta == 4: # Pk_duplicada
Errores.insertar(
Nodo_Error('42710', 'duplicate_object', self.fila,
self.columna))
return '42710: duplicate_object \n'
elif respuesta == 1: # error
Errores.insertar(
Nodo_Error('XX000', 'internal_error', self.fila,
self.columna))
return 'XX000: internal_error \n'
else:
for n, s in enumerate(TiposCol):
k = list(s.values())
r = nombreCol[n] #nombrecol
a = k[0] #tipo dato
b = k[1] #size
#tts.TabladeSimbolos.insertar(r,a,b,self.table_id,self.fila,self.columna,'Insert')
return 'Se ingresaron los registros exitosamente \n'
else:
Errores.insertar(
Nodo_Error('HV008', 'fdw_invalid_column_number', self.fila,
self.columna))
return 'HV008: fdw_invalid_column_number \n'
else:
if noValores == noCol:
for n, s in enumerate(TiposCol):
k = list(s.values())
if (k[0] == 'integer' or k[0] == 'smallint'
or k[0] == 'bigint' or k[0] == 'decimal'
or k[0] == 'numeric' or k[0] == 'double'
or k[0] == 'money'):
if (tipos[n] == 'INT' or tipos[n] == 'DOUBLE'
or tipos[n] == 'FLOAT'):
if len(str(val[n])) <= k[1]:
pass
else:
Errores.insertar(
Nodo_Error('22023',
'invalid_parameter_value',
self.fila, self.columna))
return '22023 : invalid_parameter_value'
else:
Errores.insertar(
Nodo_Error('22023', 'invalid_parameter_value',
self.fila, self.columna))
return '22023 : invalid_parameter_value'
elif (k[0] == 'character varying' or k[0] == 'character'
or k[0] == 'varchar' or k[0] == 'char'
or k[0] == 'text'):
if (tipos[n] == 'CHAR' or tipos[n] == 'STR'):
if len(str(val[n])) <= k[1]:
pass
else:
Errores.insertar(
Nodo_Error('22023',
'invalid_parameter_value',
self.fila, self.columna))
return '22023 : invalid_parameter_value'
else:
Errores.insertar(
Nodo_Error('22023', 'invalid_parameter_value',
self.fila, self.columna))
return '22023 : invalid_parameter_value'
elif (k[0] == 'boolean'):
if (tipos[n] == 'BOOLEAN'):
pass
else:
Errores.insertar(
Nodo_Error('22023', 'invalid_parameter_value',
self.fila, self.columna))
return '22023 : invalid_parameter_value'
elif (k[0] == 'date'):
if (tipos[n] == 'DATE'):
if len(str(val[n])) <= k[1]:
pass
else:
Errores.insertar(
Nodo_Error('22023',
'invalid_parameter_value',
self.fila, self.columna))
return '22023 : invalid_parameter_value'
else:
Errores.insertar(
Nodo_Error('22023', 'invalid_parameter_value',
self.fila, self.columna))
return '22023 : invalid_parameter_value'
else:
res1 = tp.obtenerTiposEnum(k[0])
if val[n] in res1:
pass
else:
Errores.insertar(
Nodo_Error('22023', 'invalid_parameter_value',
self.fila, self.columna))
return '22023 : invalid_parameter_value'
respuesta = jm.insert(bd, self.table_id, val)
if respuesta == 2: # noexisteDB
Errores.insertar(
Nodo_Error('08003', 'connection_does_not_exist',
self.fila, self.columna))
return '08003: ' + str(bd) + ' connection_does_not_exist\n'
elif respuesta == 3: # noexisteTB
Errores.insertar(
Nodo_Error('42P01', 'undefined_table', self.fila,
self.columna))
return '42P01: ' + str(
self.table_id) + ' undefined_table \n'
elif respuesta == 5: # noColDiferente
Errores.insertar(
Nodo_Error('HV008', 'fdw_invalid_column_number',
self.fila, self.columna))
return 'HV008: fdw_invalid_column_number \n'
elif respuesta == 4: # Pk_duplicada
Errores.insertar(
Nodo_Error('42710', 'duplicate_object', self.fila,
self.columna))
return '42710: duplicate_object \n'
elif respuesta == 1: # error
Errores.insertar(
Nodo_Error('XX000', 'internal_error', self.fila,
self.columna))
return 'XX000: internal_error \n'
else:
for n, s in enumerate(TiposCol):
k = list(s.values())
r = nombreCol[n] #nombrecol
a = k[0] #tipo dato
b = k[1] #size
#tts.TabladeSimbolos.insertar(r,a,b,self.table_id,self.fila,self.columna,'Insert')
return 'Se ingresaron los registros exitosamente \n'
else:
Errores.insertar(
Nodo_Error('HV008', 'fdw_invalid_column_number', self.fila,
self.columna))
return 'HV008: fdw_invalid_column_number \n'