예제 #1
0
파일: Checker.py 프로젝트: ChinJavier/tytus
def checkInsert(dbName, tableName, columns, values):
    lstErr.clear()
    table = S.extractTable(dbName, tableName)
    if table == 0:
        syntaxPostgreErrors.append("Error: 42000: La base de datos  " +
                                   str(dbName) + " no existe")
        return ["Error: No existe la base de datos"]
    elif table == 1:
        syntaxPostgreErrors.append("Error: 42P01: La tabla  " +
                                   str(tableName) + " no existe")
        return ["Error: No existe la tabla"]
    if columns != None:
        if len(columns) != len(values):
            syntaxPostgreErrors.append(
                "Error: 42611:  definicion en numero de columnas invalida ")
            return ["Columnas fuera de los limites"]
    else:
        if len(values) != len(table["columns"]):
            syntaxPostgreErrors.append(
                "Error: 42611:  definicion en numero de columnas invalida ")
            return ["Columnas fuera de los limites"]
    values = S.getValues(table, columns, values)
    if not values:
        syntaxPostgreErrors.append("Error: 42P10: Columnas no identificadas  ")
        return ["Error: Columnas no identificadas"]

    pks = []
    indexCol = 0
    for col in table["columns"]:
        x = Type.get(col["type"])
        value = values[indexCol]
        if not isinstance(value, Primitive):
            value = Primitive(x, value, 0, 0, 0)
            values[indexCol] = value
        if col["PK"]:
            pks.append(indexCol)
        indexCol += 1
    # Validar la llave primaria
    if pks:
        validatePrimary(dbName, tableName, values, pks)

    indexCol = 0
    for value in values:
        column = table["columns"][indexCol]
        if value.value != None and value.type != TYPE.NULL:
            value.value = convertDateTime(value.value, column["type"])
            if column["Unique"]:
                validateUnique(dbName, tableName, value.value, indexCol)
            if column["FK"] != None:
                validateForeign(dbName, column["FK"], value.value)
            if column["Constraint"] != None:
                validateConstraint(column["Constraint"], values, dbName,
                                   tableName, column["type"])
            select(column, value)
        else:
            value.value = None
            validateNotNull(column["NN"], column["name"])
        indexCol += 1
    return [listError(), values]
예제 #2
0
 def execute(self, environment):
     Struct.load()
     alter = Struct.alterColumnsTable(instruction.dbtemp, self.table, self.params)
     if alter == None:
         alter = Checker.checkValue(instruction.dbtemp, self.table)
         Struct.save()
     if alter == None:
         alter = "Tabla alterada: " + self.table
     return alter
예제 #3
0
    def execute(self, environment):
        Struct.load()
        Index = File.importFile("Index")
        exists = Index.get(self.name)
        result = []
        if not exists:
            if self.exists:
                result.append("El INDEX : " + self.name + " no existe")
            else:
                result.append("Error: El INDEX : " + self.name + " no existe")
            return result

        if not self.id:
            exists = Index.get(self.newName)
            if not exists:
                Index[self.newName] = Index.pop(self.name)
                result.append("Se cambio el nombre del INDEX : " + self.name +
                              " a " + self.newName)
            else:
                result.append("Error: El INDEX : " + self.newName +
                              " ya existe")
        else:
            column = self.newName
            index = Index[self.name]
            for c in index["Columns"]:
                if c["Name"] == column:
                    if type(self.id) == int:
                        table = index["Table"]
                        columns = Struct.extractColumns(
                            instruction.dbtemp, table)
                        if columns:
                            if self.id > len(columns):
                                result.append("Error fatal: INDEX " +
                                              self.name +
                                              "numero de columna invalido")
                            else:
                                col = columns[self.id - 1].name
                                c["Name"] = col
                                result.append("INDEX : " + self.name +
                                              " cambio la columna " + column +
                                              " por " + col)
                        else:
                            result.append("Error fatal: INDEX " + self.name)
                    else:
                        c["Name"] = self.id
                        result.append("INDEX : " + self.name +
                                      " cambio la columna " + column +
                                      " por " + self.id)

                    Index[self.name] = index
                    break
        if result == []:
            result.append("Error fatal: INDEX " + self.name +
                          " columna invalida : " + self.newName)
        File.exportFile(Index, "Index")
        return result
예제 #4
0
 def execute(self, environment):
     Struct.load()
     lista = []
     for value in self.values:
         lista.append(value.execute(environment).value)
     result = Struct.createType(self.exists, self.name, lista)
     if result == None:
         report = "Type creado"
     else:
         report = result
     return report
예제 #5
0
 def execute(self, environment):
     Struct.load()
     try:
         if self.option == "RENAME":
             valor = jsonMode.alterDatabase(self.name, self.newname)
             if valor == 2:
                 instruction.semanticErrors.append([
                     "La base de datos " + str(self.name) + " no existe",
                     self.row
                 ])
                 instruction.syntaxPostgreSQL.append(
                     "Error: 42000: La base de datos  " + str(self.name) +
                     " no existe")
                 return "La base de datos no existe: '" + self.name + "'."
             if valor == 3:
                 instruction.semanticErrors.append([
                     "La base de datos " + str(self.newname) + " ya existe",
                     self.row,
                 ])
                 instruction.syntaxPostgreSQL.append(
                     "Error: 42P04: La base de datos  " +
                     str(self.newname) + " ya existe")
                 return "El nuevo nombre para la base de datos existe"
             if valor == 1:
                 instruction.syntaxPostgreSQL.append(
                     "Error: XX000: Error interno")
                 return "Hubo un problema en la ejecucion de la sentencia"
             if valor == 0:
                 Struct.alterDatabaseRename(self.name, self.newname)
                 return ("Base de datos renombrada: " + self.name + " - " +
                         self.newname)
             return "Error ALTER DATABASE RENAME: " + self.newname
         elif self.option == "OWNER":
             valor = Struct.alterDatabaseOwner(self.name, self.newname)
             if valor == 0:
                 return "Instruccion ejecutada con exito ALTER DATABASE OWNER"
             instruction.syntaxPostgreSQL.append(
                 "Error: XX000: Error interno")
             return "Error ALTER DATABASE OWNER"
         instruction.syntaxPostgreSQL.append("Error: XX000: Error interno")
         return "Fatal Error ALTER DATABASE: " + self.newname
     except:
         instruction.syntaxPostgreSQL.append(
             "Error: P0001: Error en la instruccion ALTER DATABASE")
예제 #6
0
 def execute(self, environment):
     Struct.load()
     tempDf = None
     for i in range(len(self.tables)):
         exec = self.tables[i].execute(environment)
         data = exec[0]
         types = exec[1]
         if isinstance(self.tables[i], Select):
             newNames = {}
             subqAlias = self.aliases[i]
             for (columnName, columnData) in data.iteritems():
                 colSplit = columnName.split(".")
                 if len(colSplit) >= 2:
                     newNames[columnName] = subqAlias + "." + colSplit[1]
                     types[subqAlias + "." + colSplit[1]] = columnName
                 else:
                     newNames[columnName] = subqAlias + "." + colSplit[0]
                     types[subqAlias + "." + colSplit[0]] = columnName
             data.rename(columns=newNames, inplace=True)
             environment.addVar(subqAlias, subqAlias, "TABLE", self.row,
                                self.column)
         else:
             sym = Symbol(
                 self.tables[i].name,
                 None,
                 self.tables[i].row,
                 self.tables[i].column,
             )
             environment.addSymbol(self.tables[i].name, sym)
             if self.aliases[i]:
                 environment.addSymbol(self.aliases[i], sym)
         if i == 0:
             tempDf = data
         else:
             tempDf = self.crossJoin([tempDf, data])
         environment.dataFrame = tempDf
         try:
             environment.types.update(types)
         except:
             instruction.syntaxPostgreSQL.append(
                 "Error: P0001: Error en la instruccion SELECT clausula FROM"
             )
     return
예제 #7
0
    def execute(self, environment):
        Struct.load()
        result = jsonMode.createDatabase(self.name)
        """
        0: insert
        1: error
        2: exists
        """

        if self.mode == None:
            self.mode = 1

        if result == 0:
            Struct.createDatabase(self.name, self.mode, self.owner)
            report = "Base de datos: " + self.name + " insertada."
        elif result == 1:
            instruction.syntaxPostgreSQL.append("Error: XX000: Error interno")
            report = "Error al insertar la base de datos: " + self.name
        elif result == 2 and self.replace:
            Struct.replaceDatabase(self.name, self.mode, self.owner)
            report = "Base de datos '" + self.name + " ' reemplazada."
        elif result == 2 and self.exists:
            report = "Base de datos no insertada, " + self.name + " ya existe."
        else:
            instruction.semanticErrors.append([
                "La base de datos " + str(self.name) + " ya existe", self.row
            ])
            instruction.syntaxPostgreSQL.append(
                "Error: 42P04: La base de datos  " + str(self.name) +
                " ya existe")
            report = "Error: La base de datos ya existe"
        return report
예제 #8
0
 def execute(self, environment):
     Struct.load()
     try:
         if self.structure == "TABLE":
             if instruction.dbtemp != "":
                 valor = jsonMode.dropTable(instruction.dbtemp, self.name)
                 if valor == 2:
                     instruction.semanticErrors.append([
                         "La base de datos " + str(instruction.dbtemp) +
                         " no existe",
                         self.row,
                     ])
                     instruction.syntaxPostgreSQL.append(
                         "Error: 42000: La base de datos  " +
                         str(instruction.dbtemp) + " no existe")
                     return "La base de datos no existe"
                 if valor == 3:
                     instruction.semanticErrors.append([
                         "La tabla " + str(self.name) + " no existe",
                         self.row
                     ])
                     instruction.syntaxPostgreSQL.append(
                         "Error: 42P01: La tabla  " + str(self.name) +
                         " no existe")
                     return "La tabla no existe en la base de datos"
                 if valor == 1:
                     instruction.syntaxPostgreSQL.append(
                         "Error: XX000: Error interno")
                     return "Hubo un problema en la ejecucion de la sentencia DROP"
                 if valor == 0:
                     Struct.dropTable(instruction.dbtemp, self.name)
                     return "DROP TABLE Se elimino la tabla: " + self.name
             instruction.syntaxPostgreSQL.append(
                 "Error: 42000: Base de datos no especificada ")
             return "El nombre de la base de datos no esta especificado operacion no realizada"
         else:
             valor = jsonMode.dropDatabase(self.name)
             if valor == 1:
                 instruction.syntaxPostgreSQL.append(
                     "Error: XX000: Error interno")
                 return "Hubo un problema en la ejecucion de la sentencia"
             if valor == 2:
                 instruction.semanticErrors.append([
                     "La base de datos " + str(self.name) + " no existe",
                     self.row,
                 ])
                 instruction.syntaxPostgreSQL.append(
                     "Error: 42000: La base de datos  " + str(self.name) +
                     " no existe")
                 return "La base de datos no existe"
             if valor == 0:
                 Struct.dropDatabase(self.name)
                 return "Instruccion ejecutada con exito DROP DATABASE"
         instruction.syntaxPostgreSQL.append(
             "Error: XX000: Error interno DROPTABLE")
         return "Fatal Error: DROP TABLE"
     except:
         instruction.syntaxPostgreSQL.append(
             "Error: P0001: Error en la instruccion DROP")
예제 #9
0
파일: Checker.py 프로젝트: ChinJavier/tytus
def validateConstraint(values, record, database, table, type_):
    # values = [name,[exp1,exp2,op,type1,type2]]
    # record = [val1,val2,...,valn]
    name = values[0]
    value1 = values[1][0]
    value2 = values[1][1]

    op = values[1][2]

    type1 = values[1][3]
    type2 = values[1][4]

    index1 = 0
    index1 = 0

    if type1 == "ID":
        index1 = S.getIndex(database, table, value1)
        value1 = record[index1].value

    if type2 == "ID":
        index2 = S.getIndex(database, table, value2)
        value2 = record[index2].value

    insert = CheckOperation(value1, value2, type_, op)

    try:
        if not insert:
            lstErr.append("El registro no cumple con la restriccion: ", name)
            syntaxPostgreErrors.append(
                "Error: 23000: El registro no cumple con la restriccion " +
                str(name))
        elif insert:
            return
        else:
            lstErr.append(insert)

    except:
        lstErr.append(insert)
예제 #10
0
    def execute(self, environment):
        Struct.load()
        name = self.idIndex
        if self.existIndex(name):
            return "Error: ya existe un index con el nombre " + name
        table = Struct.extractTable(instruction.dbtemp, self.idTable)
        if table == 1 or table == 0:
            return ("Error: no existe la tabla " + self.idTable +
                    " en la base de datos " + instruction.dbtemp)
        try:
            Index = File.importFile("Index")
            indexBody = {}
            indexBody["Table"] = self.idTable
            indexBody["Unique"] = self.unique
            indexBody["Method"] = self.usingMethod
            indexBody["Columns"] = []
            for c in self.optList:
                col = {}
                col["Name"] = c[0]
                col["Order"] = c[1]
                if c[2]:
                    nulls = c[2][0]
                    if c[2][1]:
                        nulls += " " + c[2][1]
                else:
                    if col["Order"] == "DESC":
                        nulls = "NULLS FIRST"
                    else:
                        nulls = "NULLS LAST"

                col["Nulls"] = nulls
                indexBody["Columns"].append(col)

            Index[name] = indexBody
            File.exportFile(Index, "Index")
            return "Index " + name + " creado"
        except:
            return "Error fatal"
예제 #11
0
 def execute(self, environment):
     Struct.load()
     # insert = [posiblesErrores,noColumnas]
     insert = Struct.insertTable(instruction.dbtemp, self.name,
                                 self.columns, self.inherits)
     error = insert[0]
     nCol = insert[1]
     if not error:
         error = Checker.checkValue(instruction.dbtemp, self.name)
     """
     Result
     0: insert
     1: error
     2: not found database
     3: exists table
     """
     if not error:
         result = jsonMode.createTable(instruction.dbtemp, self.name, nCol)
         if result == 0:
             pass
         elif result == 1:
             instruction.syntaxPostgreSQL.append(
                 "Error: XX000: Error interno")
             return "Error: No se puede crear la tabla: " + self.name
         elif result == 2:
             instruction.semanticErrors.append("La base de datos " +
                                               instruction.dbtemp +
                                               " no existe")
             instruction.syntaxPostgreSQL.append(
                 "Error: 3F000: base de datos" + instruction.dbtemp +
                 " no existe")
             return "Error: Base de datos no encontrada: " + instruction.dbtemp
         elif result == 3 and self.exists:
             instruction.semanticErrors.append(
                 ["La tabla " + str(self.name) + " ya existe", self.row])
             instruction.syntaxPostgreSQL.append(
                 "Error: 42P07: La tabla  " + str(self.name) + " ya existe")
             return "La tabla ya existe en la base de datos"
         else:
             instruction.semanticErrors.append(
                 ["La tabla " + str(self.name) + " ya existe", self.row])
             instruction.syntaxPostgreSQL.append(
                 "Error: 42P07: tabla duplicada")
             return "Error: ya existe la tabla " + self.name
         pk = Struct.extractPKIndexColumns(instruction.dbtemp, self.name)
         addPK = 0
         if pk:
             addPK = jsonMode.alterAddPK(instruction.dbtemp, self.name, pk)
         if addPK != 0:
             instruction.syntaxPostgreSQL.append(
                 "Error: 23505: Error en llaves primarias de la instruccion CREATE TABLE de la tabla "
                 + str(self.name))
         return "Tabla " + self.name + " creada"
     else:
         Struct.dropTable(instruction.dbtemp, self.name)
         return error
예제 #12
0
파일: Checker.py 프로젝트: ChinJavier/tytus
def checkValue(dbName, tableName):
    lstErr.clear()
    table = S.extractTable(dbName, tableName)
    if table == 0 and table == 1:
        return
    for col in table["columns"]:
        if col["Default"] != None:
            if col["Default"][1] != 9:
                value = Primitive(TypeNumber.get(col["Default"][1]),
                                  col["Default"][0], 0, 0, 0)
                select(col, value)
                if len(lstErr) != 0:
                    col["Default"] = None
            else:
                col["Default"] = None

    return listError()
예제 #13
0
파일: Checker.py 프로젝트: ChinJavier/tytus
def validateForeign(database, values, value):
    # values = [references,column]
    references = values[0]
    column = values[1]
    records = jsonMode.extractTable(database, references)
    if records == []:
        syntaxPostgreErrors.append("Error: 23503: El valor " + str(value) +
                                   " no es una llave foranea ")
        lstErr.append("El Valor " + str(value) + " no es una llave foranea")
        return
    index = S.getIndex(database, references, column)
    for record in records:
        if value == record[index]:
            return
    lstErr.append("El Valor " + str(value) + " no es una llave primaria")
    syntaxPostgreErrors.append("Error: 23505: El valor " + str(value) +
                               " no es una llave primaria ")
예제 #14
0
 def ambiguityBetweenColumns(self, column):
     """
     Encargada de buscar ambiguedad de una columna entre todas
     las tablas de la clausula FROM
     """
     env = self
     i = 0
     table = None
     for t in env.tables:
         lst = Struct.extractColumns(env.database, t)
         for l in lst:
             if l.name == column:
                 i += 1
                 table = t
                 break
     if i > 1:
         print("Error: Existe ambiguedad entre la culumna:", column)
         return [True, None]
     return [False, table]
예제 #15
0
 def execute(self, environment):
     result = jsonMode.extractTable(instruction.dbtemp, self.name)
     if result == None:
         instruction.semanticErrors.append([
             "La tabla " + str(self.name) +
             " no pertenece a la base de datos " + instruction.dbtemp,
             self.row,
         ])
         instruction.syntaxPostgreSQL.append("Error: 42P01: la relacion " +
                                             instruction.dbtemp + "." +
                                             str(self.name) + " no existe")
         return "FATAL ERROR TABLE ID"
     # Almacena una lista con con el nombre y tipo de cada columna
     lst = Struct.extractColumns(instruction.dbtemp, self.name)
     columns = [l.name for l in lst]
     newColumns = [self.name + "." + col for col in columns]
     df = pd.DataFrame(result, columns=newColumns)
     environment.addTable(self.name)
     tempTypes = {}
     for i in range(len(newColumns)):
         tempTypes[newColumns[i]] = lst[i].type
     return [df, tempTypes]
예제 #16
0
import sys

sys.path.append("../../..")
from routes.analizer.storage import BPlusMode as jsonMode
from routes.analizer.typechecker.Metadata import Struct
from routes.analizer.typechecker import Checker
from routes.analizer.reports import Nodo
from routes.analizer.reports import AST

ast = AST.AST()
root = None

envVariables = []

# carga de datos
Struct.load()

# variable encargada de almacenar la base de datos a utilizar
dbtemp = ""
# listas encargadas de almacenar los errores semanticos
syntaxPostgreSQL = list()
semanticErrors = list()


def makeAst(root):
    ast.makeAst(root)


class Instruction:
    """
    Esta clase representa una instruccion
예제 #17
0
 def execute(self, environment):
     try:
         Struct.load()
         # 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"
         )
예제 #18
0
파일: Checker.py 프로젝트: ChinJavier/tytus
import routes.analizer.typechecker.Metadata.Struct as S
from routes.analizer.abstract.expression import Expression
from routes.analizer.statement.expressions.primitive import Primitive
from routes.analizer.typechecker.Types.Type import Type
from routes.analizer.typechecker.Types.Type import TypeNumber
from routes.analizer.typechecker.Types.Validations import Number as N
from routes.analizer.typechecker.Types.Validations import Character as C
from routes.analizer.typechecker.Types.Validations import Time as T
from routes.analizer.storage import BPlusMode as jsonMode
from routes.analizer.abstract.expression import TYPE
from datetime import datetime

lstErr = []
dbActual = ""
S.load()

syntaxPostgreErrors = []


def addError(error):
    if error != None:
        lstErr.append(error)


def unir(errors):
    for err in errors:
        lstErr.append(err)


def numeric(col, val):
    x = col["type"]
예제 #19
0
파일: insert.py 프로젝트: ChinJavier/tytus
    def execute(self, environment):
        try:
            Struct.load()
            lista = []
            params = []
            tab = self.tabla

            for p in self.parametros:
                params.append(p.execute(environment))

            result = Checker.checkInsert(
                instruction.dbtemp, self.tabla, self.columns, params
            )

            if result[0] == None:
                for p in result[1]:
                    if p == None:
                        lista.append(p)
                    else:
                        lista.append(p.value)
                res = jsonMode.insert(instruction.dbtemp, tab, lista)
                if res == 2:
                    instruction.semanticErrors.append(
                        [
                            "La base de datos " + instruction.dbtemp + " no existe",
                            self.row,
                        ]
                    )
                    instruction.syntaxPostgreSQL.append(
                        "Error: 42000: La base de datos  "
                        + str(instruction.dbtemp)
                        + " no existe"
                    )
                    return "La base de datos no existe"
                elif res == 3:
                    instruction.semanticErrors.append(
                        ["La tabla " + str(tab) + " no existe", self.row]
                    )
                    instruction.syntaxPostgreSQL.append(
                        "Error: 42P01: La tabla " + str(tab) + " no existe"
                    )
                    return "No existe la tabla"
                elif res == 5:
                    instruction.semanticErrors.append(
                        [
                            "La instruccion INSERT tiene mas o menos registros que columnas",
                            self.row,
                        ]
                    )
                    instruction.syntaxPostgreSQL.append(
                        "Error: 42611: INSERT tiene mas o menos registros que columnas "
                    )
                    return "Columnas fuera de los limites"
                elif res == 4:
                    instruction.semanticErrors.append(
                        [
                            "El valor de la clave esta duplicada, viola la restriccion unica",
                            self.row,
                        ]
                    )
                    instruction.syntaxPostgreSQL.append(
                        "Error: 23505: el valor de clave esta duplicada, viola la restricción única "
                    )
                    return "Llaves primarias duplicadas"
                elif res == 1:
                    instruction.syntaxPostgreSQL.append("Error: XX000: Error interno")
                    return "Error en la operacion"
                elif res == 0:
                    return "Fila Insertada correctamente"
            else:
                return result[0]
        except:
            instruction.syntaxPostgreSQL.append(
                "Error: P0001: Error en la instruccion INSERT"
            )
            pass