Ejemplo n.º 1
0
    def ejecutar(createDataBase, ts, consola, exceptions):

        if createDataBase.caso == 1 and createDataBase.exists == False or createDataBase.exists == True:
            #create database
            lb = showDatabases()
            for bd in lb:
                if bd == createDataBase.id:
                    if createDataBase.exists:
                        print("no pasa nada")
                    else:
                        consola.append(
                            f"La Base de Datos {createDataBase.id} ya existe, error al crear\n"
                        )
                    return

            createDatabase(str(createDataBase.id))
            entorno_bd = {}
            ts_local = TS.TablaDeSimbolos(entorno_bd)
            # simbolo (self, categoria,id, tipo, valor,Entorno):
            simbolo = TS.Simbolo(
                TS.TIPO_DATO.BASEDEDATOS, createDataBase.id, None, 0,
                ts_local)  # inicializamos con 0 como valor por defecto
            ts.agregar_sim(simbolo)
            consola.append(
                f"Se creo la base de datos {createDataBase.id} exitosamente\n")
            print(ts.simbolos)

        elif createDataBase.caso == 2 and createDataBase.exists == False:
            #create or replace
            lb = showDatabases()
            for bd in lb:
                if bd == createDataBase.id:

                    # se borra a nivel de memoria en disco
                    dropDatabase(str(createDataBase.id))
                    # se quita el id de la tabla de simbolos
                    ts.eliminar_sim(str(createDataBase.id))
                    # simbolo (self, categoria,id, tipo, valor,Entorno):
                    # se vuelve a crear un entorno para agregar de nuevo la base de datos
                    createDatabase(str(createDataBase.id))
                    entorno = {}
                    ts_local = TS.TablaDeSimbolos(entorno)
                    simbolo = TS.Simbolo(
                        None, createDataBase.id, TS.TIPO_DATO.BASEDEDATOS, 0,
                        ts_local)  # inicializamos con 0 como valor por defecto
                    ts.agregar_sim(simbolo)
                    consola.append(
                        f"Replace, la base de datos {createDataBase.id} se ha creado exitosamente\n"
                    )
                    print(ts.simbolos)
                    return

            createDatabase(str(createDataBase.id))
            ts_local = TS.TablaDeSimbolos(ts.simbolos)
            # simbolo (self, categoria,id, tipo, valor,Entorno):
            simbolo = TS.Simbolo(
                None, createDataBase.id, TS.TIPO_DATO.BASEDEDATOS, 0,
                ts_local)  # inicializamos con 0 como valor por defecto
            ts.agregar_sim(simbolo)
            consola.append(
                f"Se creo la base de datos {createDataBase.id} exitosamente\n")
            print(ts.simbolos)

        elif createDataBase.caso == 2 and createDataBase.exists == True:
            #create or replace if not exists
            lb = showDatabases()
            for bd in lb:
                if bd == createDataBase.id:

                    if createDataBase.exists:
                        print("no pasa nada")
                    else:
                        consola.append(
                            "La Base de Datos ya existe no se puede reemplazar"
                        )

                    return

            createDatabase(str(createDataBase.id))
            ts_local = TS.TablaDeSimbolos(ts.simbolos)
            # simbolo (self, categoria,id, tipo, valor,Entorno):
            simbolo = TS.Simbolo(
                None, createDataBase.id, TS.TIPO_DATO.BASEDEDATOS, 0,
                ts_local)  # inicializamos con 0 como valor por defecto
            ts.agregar_sim(simbolo)
            consola.append(
                f"Se creo la base de datos {createDataBase.id} exitosamente\n")
            print(ts.simbolos)
Ejemplo n.º 2
0
    def ejecutar(CreateTable, ts, consola, exceptions):

        if ts.validar_sim("usedatabase1234") == 1:

            # nombre de la bd
            bdactual = ts.buscar_sim("usedatabase1234")
            # se busca el simbolo y por lo tanto se pide el entorno de la bd
            BD = ts.buscar_sim(bdactual.valor)
            entornoBD = BD.Entorno

            if entornoBD.validar_sim(CreateTable.id) == 1:
                consola.append("42P07	duplicate_table\n")
                consola.append(
                    f"22005	error_in_assignment,No se creo la tabla {CreateTable.id}\n"
                )

                return

            # creo el entorno de la tabla
            print("Creando entorno tabla")
            nuevo_entorno_tabla = {}
            tsTabla = TS.TablaDeSimbolos(nuevo_entorno_tabla)
            # recorrer campos y le mando el entorno de la tabla quien es el que adentro de este
            # existaran los campos

            banderaTodoBien = True
            cantidad_columnas = len(CreateTable.campos)
            for campo in CreateTable.campos:

                if campo.caso == 2 or campo.caso == 3:
                    if entornoBD.validar_sim(campo.tablaR) == 1:
                        #referencia la tabla a cual se desea hacer la llave foranea
                        obtener_simbolo = entornoBD.buscar_sim(campo.tablaR)

                        entornoTablarefrencia = obtener_simbolo.Entorno

                        for campito in campo.idR:
                            if entornoTablarefrencia.validar_sim(
                                    campito.id) == 1:
                                print("todo bien")
                            else:
                                banderaTodoBien = False
                                break

                        if banderaTodoBien:
                            print("todo esta bien")
                            banderaTodoBien = Campo.ejecutar(
                                campo, tsTabla, consola, exceptions)
                            print(banderaTodoBien)
                            if campo.caso == 2 or campo.caso == 3 or campo.caso == 4:
                                cantidad_columnas = cantidad_columnas - 1
                            if not banderaTodoBien:
                                break

                    else:
                        banderaTodoBien = False

                else:
                    banderaTodoBien = Campo.ejecutar(campo, tsTabla, consola,
                                                     exceptions)
                    print(banderaTodoBien)
                    if campo.caso == 2 or campo.caso == 3 or campo.caso == 4:
                        cantidad_columnas = cantidad_columnas - 1
                    if not banderaTodoBien:
                        break

            if banderaTodoBien:

                if str(CreateTable.idInherits) != str(None):
                    print("---------", CreateTable.idInherits)
                    print(entornoBD.validar_sim(CreateTable.idInherits))
                    if entornoBD.validar_sim(CreateTable.idInherits) == 1:

                        simboloTabla = entornoBD.buscar_sim(
                            CreateTable.idInherits)
                        entornoTablaPadre = simboloTabla.Entorno
                        lista_campos = entornoTablaPadre.simbolos
                        contador = 0
                        for item in lista_campos:
                            simbolo_nuevo = TS.Simbolo(
                                lista_campos.get(item).categoria,
                                lista_campos.get(item).id,
                                lista_campos.get(item).tipo,
                                lista_campos.get(item).valor,
                                lista_campos.get(item).Entorno)
                            tsTabla.agregar_sim(simbolo_nuevo)
                            contador = contador + 1

                        nueva_tabla = TS.Simbolo(TS.TIPO_DATO.TABLA,
                                                 CreateTable.id, None,
                                                 cantidad_columnas + contador,
                                                 tsTabla)
                        entornoBD.agregar_sim(nueva_tabla)
                        createTable(bdactual.valor, CreateTable.id,
                                    cantidad_columnas + contador)
                        columnas = tsTabla.simbolos
                        print("Agregando llaves primarias")
                        i = 0
                        pks = []
                        for columna in columnas:
                            print(columnas.get(columna).id)

                            for data in columnas.get(columna).valor:
                                print("     data: ", data)
                                if 'PRIMARYKEY' in data:
                                    pks.append(i)

                            i = i + 1
                        alterAddPK(BD.id, CreateTable.id, pks)
                        consola.append(
                            f"Se creo la tabla {CreateTable.id}, exitosamente\n"
                        )

                    else:
                        consola.append(
                            f"f42P16	invalid_table_definition, no se creo la tabla {CreateTable.id}"
                        )

                else:
                    nueva_tabla = TS.Simbolo(TS.TIPO_DATO.TABLA,
                                             CreateTable.id, None,
                                             cantidad_columnas, tsTabla)
                    entornoBD.agregar_sim(nueva_tabla)

                    createTable(bdactual.valor, CreateTable.id,
                                cantidad_columnas)
                    columnas = tsTabla.simbolos
                    print("Agregando llaves primarias")
                    i = 0
                    pks = []
                    for columna in columnas:
                        print(columnas.get(columna).id)

                        for data in columnas.get(columna).valor:
                            print("     data: ", data)
                            if 'PRIMARYKEY' in data:
                                pks.append(i)

                        i = i + 1
                    alterAddPK(BD.id, CreateTable.id, pks)
                    consola.append(
                        f"Se creo la tabla {CreateTable.id}, exitosamente\n")

            else:
                consola.append(
                    f"22005	error_in_assignment,No se creo la tabla {CreateTable.id} campos incosistente \n"
                )
                exceptions.append(
                    "Error semantico-22005	error_in_assignment-Columnas check-fila-columna"
                )

        else:

            consola.append(
                "22005	error_in_assignment, No se ha seleccionado una BD\n")
            exceptions.append(
                "Error semantico-22005	error_in_assignment-No se ha seleccionado DB-fila-columna"
            )