def execute(self, environment):
try:
# Verificamos que no pueden venir mas de 1 tabla en el clausula FROM
if len(self.fromcl.tables) > 1:
instruction.semanticErrors.append(
["Error sintactico cerco e en ','", self.row])
instruction.syntaxPostgreSQL.append(
"Error: 42601: Error sintactico cerca de , en la linea " +
str(self.row))
return "Error: syntax error at or near ','"
newEnv = Environment(environment, instruction.dbtemp)
instruction.envVariables.append(newEnv)
self.fromcl.execute(newEnv)
value = [newEnv.dataFrame[p] for p in newEnv.dataFrame]
labels = [p for p in newEnv.dataFrame]
for i in range(len(labels)):
newEnv.dataFrame[labels[i]] = value[i]
if self.wherecl == None:
w2 = newEnv.dataFrame.filter(labels)
else:
wh = self.wherecl.execute(newEnv)
w2 = wh.filter(labels)
# Si la clausula WHERE devuelve un dataframe vacio
if w2.empty:
return "Operacion UPDATE completada"
# Logica para realizar el update
table = self.fromcl.tables[0].name
pk = Struct.extractPKIndexColumns(instruction.dbtemp, table)
# Se obtienen las parametros de las llaves primarias para proceder a eliminar
rows = []
if pk:
for row in w2.values:
rows.append([row[p] for p in pk])
else:
rows.append([i for i in w2.index])
print(rows)
# Obtenemos las variables a cambiar su valor
ids = [p.id for p in self.values]
values = [p.execute(newEnv).value for p in self.values]
ids = Struct.getListIndex(instruction.dbtemp, table, ids)
if len(ids) != len(values):
return "Error: Columnas no encontradas"
temp = {}
for i in range(len(ids)):
temp[ids[i]] = values[i]
print(temp, rows)
# TODO: La funcion del STORAGE esta bugueada
bug = False
for row in rows:
result = jsonMode.update(instruction.dbtemp, table, temp, rows)
if result != 0:
bug = True
break
if bug:
return ["Error: Funcion UPDATE del Storage", temp, rows]
return "Operacion UPDATE completada"
except:
instruction.syntaxPostgreSQL.append(
"Error: P0001: Error en la instruccion UPDATE")
def execute(self, environment):
newEnv = Environment(environment, instruction.dbtemp)
instruction.envVariables.append(newEnv)
s1 = self.s1.execute(newEnv)
s2 = self.s2.execute(newEnv)
df1 = s1[0]
df2 = s2[0]
types1 = list(s1[1].values())
types2 = list(s2[1].values())
if len(df1.columns) != len(df2.columns):
instruction.syntaxPostgreSQL.append(
"Error: 42611: INTERSEC definicion en numero de columnas invalida "
)
return "Error: El numero de columnas no coinciden"
for i in range(len(types1)):
if types1[i] != types2[i]:
instruction.semanticErrors.append([
"Error discrepancia de tipo de datos entre columnas",
self.row
])
instruction.syntaxPostgreSQL.append(
"Error: 42804: discrepancia de tipo de datos entre columnas "
)
return "Error: Los tipos de columnas no coinciden"
df = df1.merge(df2).drop_duplicates(ignore_index=True)
return [df, types1]
def execute(self, environment):
try:
newEnv = Environment(environment, instruction.dbtemp)
instruction.envVariables.append(newEnv)
labels = []
values = {}
for i in range(len(self.params)):
v = self.params[i].execute(newEnv)
values[self.params[i].temp] = [v.value]
labels.append(self.params[i].temp)
newEnv.types[labels[i]] = v.type
newEnv.dataFrame = pd.DataFrame(values)
return [newEnv.dataFrame, newEnv.types]
except:
instruction.syntaxPostgreSQL.append(
"Error: P0001: Error en la instruccion SELECT")
def execute(self, environment):
newEnv = Environment(environment, instruction.dbtemp)
instruction.envVariables.append(newEnv)
s1 = self.s1.execute(newEnv)
s2 = self.s2.execute(newEnv)
df1 = s1[0]
df2 = s2[0]
types1 = list(s1[1].values())
types2 = list(s2[1].values())
if len(df1.columns) != len(df2.columns):
instruction.syntaxPostgreSQL.append(
"Error: 42611: EXCEPT definicion en numero de columnas invalida "
)
return "Error: El numero de columnas no coinciden"
for i in range(len(types1)):
if types1[i] != types2[i]:
instruction.semanticErrors.append([
"Error discrepancia de tipo de datos entre columnas",
self.row
])
instruction.syntaxPostgreSQL.append(
"Error: 42804: discrepancia de tipo de datos entre columnas"
)
return "Error: Los tipos de columnas no coinciden"
df = df1.merge(
df2, how="outer",
indicator=True).loc[lambda x: x["_merge"] == "left_only"]
del df["_merge"]
return [df, types1]
def execute(self, environment):
try:
newEnv = Environment(environment, instruction.dbtemp)
instruction.envVariables.append(newEnv)
self.fromcl.execute(newEnv)
if self.wherecl != None:
self.wherecl.execute(newEnv)
if self.groupbyCl != None:
newEnv.groupCols = len(self.groupbyCl)
groupDf = None
groupEmpty = True
if self.params:
params = []
for p in self.params:
if isinstance(p, TableAll):
result = p.execute(newEnv)
for r in result:
params.append(r)
else:
params.append(p)
labels = [p.temp for p in params]
if self.groupbyCl != None:
value = []
for i in range(len(params)):
ex = params[i].execute(newEnv)
val = ex.value
newEnv.types[labels[i]] = ex.type
# Si no es columna de agrupacion
if i < len(self.groupbyCl):
if not (isinstance(val, pd.core.series.Series)
or isinstance(val, pd.DataFrame)):
nval = {
val: [
val for i in range(
len(newEnv.dataFrame.index))
]
}
nval = pd.DataFrame(nval)
val = nval
newEnv.dataFrame = pd.concat(
[newEnv.dataFrame, val], axis=1)
else:
if groupEmpty:
countGr = newEnv.groupCols
# Obtiene las ultimas columnas metidas (Las del group by)
df = newEnv.dataFrame.iloc[:, -countGr:]
cols = list(df.columns)
groupDf = df.groupby(cols).sum().reset_index()
groupDf = pd.concat([groupDf, val], axis=1)
groupEmpty = False
else:
groupDf = pd.concat([groupDf, val], axis=1)
if groupEmpty:
countGr = newEnv.groupCols
# Obtiene las ultimas columnas metidas (Las del group by)
df = newEnv.dataFrame.iloc[:, -countGr:]
cols = list(df.columns)
groupDf = df.groupby(cols).sum().reset_index()
groupEmpty = False
else:
value = [p.execute(newEnv) for p in params]
for j in range(len(labels)):
newEnv.types[labels[j]] = value[j].type
newEnv.dataFrame[labels[j]] = value[j].value
else:
value = [newEnv.dataFrame[p] for p in newEnv.dataFrame]
labels = [p for p in newEnv.dataFrame]
if value != []:
if self.wherecl == None:
df_ = newEnv.dataFrame
if self.orderByCl:
df_ = self.orderByCl.execute(df_, newEnv)
df_ = df_.filter(labels)
if self.limitCl:
df_ = self.limitCl.execute(df_, newEnv)
if self.distinct:
return [df_.drop_duplicates(), newEnv.types]
return [df_, newEnv.types]
df_ = newEnv.dataFrame
if self.orderByCl:
df_ = self.orderByCl.execute(df_, newEnv)
df_ = df_.filter(labels)
if self.limitCl:
df_ = self.limitCl.execute(df_, newEnv)
if self.distinct:
return [df_.drop_duplicates(), newEnv.types]
return [df_, newEnv.types]
else:
newNames = {}
i = 0
for (columnName, columnData) in groupDf.iteritems():
newNames[columnName] = labels[i]
i += 1
groupDf.rename(columns=newNames, inplace=True)
df_ = groupDf
if self.limitCl:
df_ = self.limitCl.execute(df_, newEnv)
if self.orderByCl:
df_ = self.orderByCl.execute(df_, newEnv)
if self.distinct:
return [df_.drop_duplicates(), newEnv.types]
return [df_, newEnv.types]
except:
instruction.syntaxPostgreSQL.append(
"Error: P0001: Error en la instruccion SELECT")