Пример #1
0
def procesar_constraint(instr,ts,tc,tabla):
    if instr.tipo == 'UNIQUE':
        if instr.opciones_constraint != []:
            temp = TS.Simbolo(instr.id,'CONSTRAINT',0,tabla)
            ts.agregar(temp)
            for ids in instr.opciones_constraint:
                buscar = tc.obtenerReturn(useCurrentDatabase,tabla,ids.id)
                if buscar == False:
                    print('No Encontrado')
                else:
                    tempA = buscar.listaCons
                    tempA.append(OPCIONES_CONSTRAINT.UNIQUE)
                    tipo = TC.Tipo(useCurrentDatabase,tabla,ids.id,buscar.tipo,buscar.tamanio,ids,instr.referencia,tempA)
                    tc.actualizar(tipo,useCurrentDatabase,tabla,ids.id)
                
    elif instr.tipo == 'FOREIGN':
        if instr.opciones_constraint != []:
            temp = TS.Simbolo(instr.id,'CONSTRAINT',0,tabla)
            ts.agregar(temp)
            for ids in instr.opciones_constraint:
                buscar = tc.obtenerReturn(useCurrentDatabase,tabla,instr.columna)
                if buscar == False:
                    print('No Encontrado')
                else:
                    tempA = buscar.listaCons
                    tempA.append(OPCIONES_CONSTRAINT.FOREIGN)
                    tipo = TC.Tipo(useCurrentDatabase,tabla,instr.columna,buscar.tipo,buscar.tamanio,ids,instr.referencia,tempA)
                    tc.actualizar(tipo,useCurrentDatabase,tabla,instr.columna)

    elif instr.tipo == 'CHECK':
        if instr.opciones_constraint != []:
            temp = TS.Simbolo(instr.id,'CONSTRAINT',0,tabla)
            ts.agregar(temp)
            for ids in instr.opciones_constraint:
                if type(ids.exp1) == ExpresionIdentificador:
                    buscar = tc.obtenerReturn(useCurrentDatabase,tabla,ids.exp1.id)
                    if buscar == False:
                        print('No Encontrado')
                    else:
                        tempA = buscar.listaCons
                        tempA.append(OPCIONES_CONSTRAINT.CHECK)
                        tipo = TC.Tipo(useCurrentDatabase,tabla,ids.exp1.id,buscar.tipo,buscar.tamanio,"","",tempA)
                        tc.actualizar(tipo,useCurrentDatabase,tabla,ids.exp1.id)
                else: 
                    buscar = tc.obtenerReturn(useCurrentDatabase,tabla,ids.exp2.id)
                    if buscar == False:
                        print('No Encontrado')
                    else:
                        tempA = buscar.listaCons
                        tempA.append(OPCIONES_CONSTRAINT.CHECK)
                        tipo = TC.Tipo(useCurrentDatabase,tabla,ids.exp2.id,buscar.tipo,buscar.tamanio,"","",tempA)
                        tc.actualizar(tipo,useCurrentDatabase,tabla,ids.exp2.id)
Пример #2
0
def procesar_alterdatabase(instr,ts,tc):
    global salida
    
    if isinstance(instr.tipo_id,ExpresionIdentificador) : 
        global salida
        print('OWNER ' + str(instr.tipo_id.id))

    elif isinstance(instr.tipo_id, ExpresionComillaSimple) : 
        print('OWNER ' + str(instr.tipo_id.val))
        
    else:
        result = j.alterDatabase(str(instr.id_tabla),str(instr.tipo_id))
        if result == 0:
            tipo = TC.Tipo(useCurrentDatabase,instr.id_tabla,instr.id_tabla,"",OPCIONES_CONSTRAINT.CHECK,None,None)
            tc.actualizarDatabase(tipo,instr.id_tabla,instr.tipo_id)
            temp1 = ts.obtener(instr.id_tabla,"")
            temp2 = TS.Simbolo(instr.tipo_id,temp1.tipo,temp1.valor,temp1.ambito)
            ts.actualizarDB(temp2,temp1.id)
            ts.actualizarDBTable(temp1.id,temp2.id)
            salida = "\nALTER DATABASE"            

        elif result == 1 :
            salida = "\nERROR:  internal_error \nSQL state: XX000 "
        elif result == 2 :
            salida = "\nERROR:  database \"" + str(instr.id_tabla) +"\" does not exist \nSQL state: 3D000"
        elif result == 3 :
            salida = "\nERROR:  database \"" + str(instr.tipo_id) +"\" alredy exists\nSQL state: 42P04"
Пример #3
0
def procesar_Foranea(instr,ts,tc,tabla):
    buscar = tc.obtenerReturn(useCurrentDatabase,tabla,instr.nombre_tabla)
    if buscar == False:
        print('No Encontrado')
    else:
        tempA = buscar.listaCons
        tempA.append(OPCIONES_CONSTRAINT.FOREIGN)
        tipo = TC.Tipo(useCurrentDatabase,tabla,instr.nombre_tabla,buscar.tipo,buscar.tamanio,instr.campo_referencia,instr.referencia_tabla,tempA)
        tc.actualizar(tipo,useCurrentDatabase,tabla,instr.nombre_tabla)
Пример #4
0
def procesar_listaId(instr,ts,tc,tabla):
    if instr.identificadores != []:
        for ids in instr.identificadores:
            buscar = tc.obtenerReturn(useCurrentDatabase,tabla,ids.id)
            if buscar == False:
                print('No Encontrado')
            else:
                tempA = buscar.listaCons
                tempA.append(OPCIONES_CONSTRAINT.UNIQUE)
                tipo = TC.Tipo(useCurrentDatabase,tabla,ids.id,buscar.tipo,buscar.tamanio,"","",tempA)
                tc.actualizar(tipo,useCurrentDatabase,tabla,ids.id)
Пример #5
0
def procesar_constraint(instr,ts,tc,tabla):
    if instr.tipo == 'UNIQUE':
        if instr.opciones_constraint != []:
            for ids in instr.opciones_constraint:
                tipo = TC.Tipo(tabla,ids.id,None,OPCIONESCREATE_TABLE.UNIQUE,None,None)
                tc.actualizarRestriccion(tipo,tabla,ids.id,OPCIONESCREATE_TABLE.UNIQUE)
    elif instr.tipo == 'FOREING':
        if instr.opciones_constraint != []:
            for ids in instr.opciones_constraint:
                tipo = TC.Tipo(tabla,instr.columna,None,OPCIONESCREATE_TABLE.FORANEA,ids,instr.referencia)
                tc.actualizarLlaveForanea(tipo,tabla,instr.columna,OPCIONESCREATE_TABLE.FORANEA,instr.referencia,ids)
    elif instr.tipo == 'CHECK':
        if instr.opciones_constraint != []:
            for ids in instr.opciones_constraint:
                if type(ids.exp1) == ExpresionIdentificador:
                    tipo = TC.Tipo(tabla,ids.exp1.id,None,OPCIONES_CONSTRAINT.CHECK,None,None)
                    tc.actualizarRestriccion(tipo,tabla,ids.exp1.id,OPCIONES_CONSTRAINT.CHECK)
                else: 
                    tipo = TC.Tipo(tabla,ids.exp2.id,None,OPCIONES_CONSTRAINT.CHECK,None,None)
                    tc.actualizarRestriccion(tipo,tabla,ids.exp2.id,OPCIONES_CONSTRAINT.CHECK)
Пример #6
0
def procesar_Definicion(instr,ts,tc,tabla) :
    tipo_dato = ""
    tamanio = ""
    if(isinstance(instr.tipo_datos,Etiqueta_tipo)):
        tipo_dato = instr.tipo_datos.etiqueta
        tamanio = ""
    elif(isinstance(instr.tipo_datos,ExpresionNumero)):
        tipo_dato = instr.tipo_datos.etiqueta
        tamanio = instr.tipo_datos.val
    elif(isinstance(instr.tipo_datos,Etiqueta_Interval)):
        tipo_dato = instr.tipo_datos.etiqueta
        tamanio = instr.tipo_datos.ext_time
    elif(isinstance(instr.tipo_datos,ExpresionTiempo)):
        tipo_dato = instr.tipo_datos.operador
        tamanio =  ""
    elif(isinstance(instr.tipo_datos,Expresion_Caracter)):
        tipo_dato = instr.tipo_datos.etiqueta
        tamanio =  instr.val
    
    if instr.opciones_constraint == None:
        buscar = tc.obtenerReturn(useCurrentDatabase,tabla,instr.id)
        if buscar == False:
            tipo = TC.Tipo(useCurrentDatabase,tabla,instr.id,tipo_dato,tamanio,"","",[])
            tc.agregar(tipo)
        else:
            print('No Encontrado')
            
    else:
        buscar = tc.obtenerReturn(useCurrentDatabase,tabla,instr.id)
        if buscar == False:
            tipo = TC.Tipo(useCurrentDatabase,tabla,instr.id,tipo_dato,tamanio,"","",[])
            tc.agregar(tipo)
        else:
            print('No Encontrado')
            
        for ins in instr.opciones_constraint:
            if isinstance(ins, definicion_constraint): 
                procesar_constraintDefinicion(ins,ts,tc,tabla,instr.id)
Пример #7
0
def procesar_primaria(instr,ts,tc,tabla):
    global pks
    pk = []
    for ids in instr.id:
        buscar = tc.obtenerReturn(useCurrentDatabase,tabla,ids.id)
        if buscar == False:
            print('No Encontrado')
        else:
            tempA = buscar.listaCons
            tempA.append(OPCIONES_CONSTRAINT.PRIMARY)
            tipo = TC.Tipo(useCurrentDatabase,tabla,ids.id,buscar.tipo,buscar.tamanio,"","",tempA)
            tc.actualizar(tipo,useCurrentDatabase,tabla,ids.id)
            
            pos = tc.getPos(useCurrentDatabase,tabla,ids.id)
            pk.append(pos)

    pks = pk
Пример #8
0
def procesar_altertable(instr,ts,tc):
    if instr.etiqueta == TIPO_ALTER_TABLE.ADD_CHECK:
        global salida
        if instr.expresionlogica.operador == OPERACION_LOGICA.AND or instr.expresionlogica.operador == OPERACION_LOGICA.OR: 
            print(instr.identificador)
            print(instr.expresionlogica.exp1.exp1.id)
            print(instr.expresionlogica.exp1.exp2.val)
            print(instr.expresionlogica.operador)
            print(instr.expresionlogica.exp2.exp1.id)
            print(instr.expresionlogica.exp2.exp2.val)
        else:
            print(instr.identificador)
            if isinstance(instr.expresionlogica.exp1,ExpresionIdentificador):
                print(instr.expresionlogica.exp1.id)
                buscar = tc.obtenerReturn(useCurrentDatabase,instr.identificador,instr.expresionlogica.exp1.id)
                if buscar == False:
                    print('No Encontrado')
                else:
                    tempA = buscar.listaCons
                    tempA.append(OPCIONES_CONSTRAINT.CHECK)
                    tipo = TC.Tipo(useCurrentDatabase,instr.identificador,instr.expresionlogica.exp1.id,buscar.tipo,buscar.tamanio,"","",tempA)
                    tc.actualizar(tipo,useCurrentDatabase,instr.identificador,instr.expresionlogica.exp1.id)
                    
                    salida = "\nALTER TABLE" 

            elif isinstance(instr.expresionlogica.exp2,ExpresionIdentificador):
                print(instr.expresionlogica.exp2.id)
                buscar = tc.obtenerReturn(useCurrentDatabase,instr.identificador,instr.expresionlogica.exp2.id)
                if buscar == False:
                    print('No Encontrado')
                else:
                    salida = "\nALTER TABLE" 
                    tempA = buscar.listaCons
                    tempA.append(OPCIONES_CONSTRAINT.CHECK)
                    tipo = TC.Tipo(useCurrentDatabase,instr.identificador,instr.expresionlogica.exp2.id,buscar.tipo,buscar.tamanio,"","",tempA)
                    tc.actualizar(tipo,useCurrentDatabase,instr.identificador,instr.expresionlogica.exp2.id)
                    salida = "\nALTER TABLE" 


    elif instr.etiqueta == TIPO_ALTER_TABLE.ADD_FOREIGN:
        buscar = tc.obtenerReturn(useCurrentDatabase,instr.identificador,instr.columnid)
        if buscar == False:
            print('No Encontrado')
        else:
            tempA = buscar.listaCons
            tempA.append(OPCIONES_CONSTRAINT.FOREIGN)
            tipo = TC.Tipo(useCurrentDatabase,instr.identificador,instr.columnid,buscar.tipo,buscar.tamanio,instr.lista_campos,instr.tocolumnid,tempA)
            tc.actualizar(tipo,useCurrentDatabase,instr.identificador,instr.columnid)
            salida = "\nALTER TABLE" 

    elif instr.etiqueta == TIPO_ALTER_TABLE.ADD_CONSTRAINT_CHECK:
        if instr.expresionlogica.operador == TIPO_LOGICA.AND or instr.expresionlogica.operador == TIPO_LOGICA.OR: 
            print(instr.expresionlogica.exp1.exp1.id)
            print(instr.expresionlogica.exp1.exp2.val)
            print(instr.expresionlogica.operador)
            print(instr.expresionlogica.exp2.exp1.id)
            print(instr.expresionlogica.exp2.exp2.val)
            
        else:
            temp = TS.Simbolo(instr.columnid,'CONSTRAINT',0,instr.identificador)
            ts.agregar(temp)
            if type(instr.expresionlogica.exp1) == ExpresionIdentificador:
                buscar = tc.obtenerReturn(useCurrentDatabase,instr.identificador,instr.expresionlogica.exp1.id)
                if buscar == False:
                    print('No Encontrado')
                else:
                    tempA = buscar.listaCons
                    tempA.append(OPCIONES_CONSTRAINT.CHECK)
                    tipo = TC.Tipo(useCurrentDatabase,instr.identificador,instr.expresionlogica.exp1.id,buscar.tipo,buscar.tamanio,"","",tempA)
                    tc.actualizar(tipo,useCurrentDatabase,instr.identificador,instr.expresionlogica.exp1.id)
                    salida = "\nALTER TABLE" 
            else:
                print(instr.expresionlogica.exp1.val)
                print(instr.expresionlogica.exp2.id)
                buscar = tc.obtenerReturn(useCurrentDatabase,instr.identificador,instr.expresionlogica.exp2.id)
                if buscar == False:
                    print('No Encontrado')
                else:
                    tempA = buscar.listaCons
                    tempA.append(OPCIONES_CONSTRAINT.CHECK)
                    tipo = TC.Tipo(useCurrentDatabase,instr.identificador,instr.expresionlogica.exp2.id,buscar.tipo,buscar.tamanio,"","",tempA)
                    tc.actualizar(tipo,useCurrentDatabase,instr.identificador,instr.expresionlogica.exp2.id)
                    salida = "\nALTER TABLE" 

    elif instr.etiqueta == TIPO_ALTER_TABLE.ADD_CONSTRAINT_UNIQUE:
        print(instr.identificador)
        print(instr.columnid)
        if instr.lista_campos != []:
            temp = TS.Simbolo(instr.columnid,'CONSTRAINT',0,instr.identificador)
            ts.agregar(temp)
            
            for datos in instr.lista_campos:
                print(datos.id)
                buscar = tc.obtenerReturn(useCurrentDatabase,instr.identificador,datos.id)
                if buscar == False:
                    print('Encontrado')
                else:
                    tempA = buscar.listaCons
                    tempA.append(OPCIONES_CONSTRAINT.UNIQUE)
                    tipo = TC.Tipo(useCurrentDatabase,instr.identificador,datos.id,buscar.tipo,buscar.tamanio,"","",tempA)
                    tc.actualizar(tipo,useCurrentDatabase,instr.identificador,datos.id)
                    salida = "\nALTER TABLE" 

    elif instr.etiqueta == TIPO_ALTER_TABLE.ADD_CONSTRAINT_FOREIGN:
        temp = TS.Simbolo(instr.columnid,'CONSTRAINT',0,instr.identificador)
        ts.agregar(temp)
        buscar = tc.obtenerReturn(useCurrentDatabase,instr.identificador,instr.tocolumnid)
        if buscar == False:
            print('No Encontrado')
        else:
            tempA = buscar.listaCons
            tempA.append(OPCIONES_CONSTRAINT.FOREIGN)
            tipo = TC.Tipo(useCurrentDatabase,instr.identificador,instr.tocolumnid,buscar.tipo,buscar.tamanio,instr.lista_ref,instr.lista_campos,tempA)
            tc.actualizar(tipo,useCurrentDatabase,instr.identificador,instr.tocolumnid)
            salida = "\nALTER TABLE" 
        

        salida = "\nALTER TABLE" 

    elif instr.etiqueta == TIPO_ALTER_TABLE.ALTER_COLUMN:
        print(instr.identificador)
        if instr.lista_campos != []:
            for lista in instr.lista_campos:
                print(lista.identificador.id)
                print(lista.tipo.id)
                print(lista.par1)

                tipodatoo = TIPO_DE_DATOS.text_ 
                tamanioD = ""
                if lista.tipo.id.upper() == 'TEXT':
                    tipodatoo = TIPO_DE_DATOS.text_ 
                    tamanioD = ""
                elif lista.tipo.id.upper() == 'FLOAT':
                    tipodatoo = TIPO_DE_DATOS.float_ 
                elif lista.tipo.id.upper() == 'INTEGER':
                    tipodatoo = TIPO_DE_DATOS.integer_ 
                    tamanioD = ""
                elif lista.tipo.id.upper() == 'SMALLINT':
                    tipodatoo = TIPO_DE_DATOS.smallint_ 
                elif lista.tipo.id.upper() == 'MONEY':
                    tipodatoo = TIPO_DE_DATOS.money 
                elif lista.tipo.id.upper() == 'BIGINT':
                    tipodatoo = TIPO_DE_DATOS.bigint 
                elif lista.tipo.id.upper() == 'REAL':
                    tipodatoo = TIPO_DE_DATOS.real 
                elif lista.tipo.id.upper() == 'DOUBLE':
                    tipodatoo = TIPO_DE_DATOS.double 
                elif lista.tipo.id.upper() == 'INTERVAL':
                    tipodatoo = TIPO_DE_DATOS.interval 
                    tamanioD = lista.par1
                elif lista.tipo.id.upper() == 'TIME':
                    tipodatoo = TIPO_DE_DATOS.time 
                elif lista.tipo.id.upper() == 'TIMESTAMP':
                    tipodatoo = TIPO_DE_DATOS.timestamp 
                elif lista.tipo.id.upper() == 'DATE':
                    tipodatoo = TIPO_DE_DATOS.date 
                elif lista.tipo.id.upper() == 'VARING':
                    tipodatoo = TIPO_DE_DATOS.varing 
                    tamanioD = lista.par1
                elif lista.tipo.id.upper() == 'VARCHAR':
                    tipodatoo = TIPO_DE_DATOS.varchar 
                    tamanioD = lista.par1
                elif lista.tipo.id.upper() == 'CHAR':
                    tipodatoo = TIPO_DE_DATOS.char 
                    tamanioD = lista.par1
                elif lista.tipo.id.upper() == 'CHARACTER':
                    tipodatoo = TIPO_DE_DATOS.character 
                    tamanioD = lista.par1
                elif lista.tipo.id.upper() == 'DECIMAL':
                    tipodatoo = TIPO_DE_DATOS.decimal 
                    tamanioD = lista.par1
                elif lista.tipo.id.upper() == 'NUMERIC':
                    tipodatoo = TIPO_DE_DATOS.numeric           
                    tamanioD = lista.par1
                elif lista.tipo.id.upper() == 'DOUBLE':
                    tipodatoo = TIPO_DE_DATOS.double_precision

                buscar = tc.obtenerReturn(useCurrentDatabase,instr.identificador,lista.identificador.id)
                if buscar == False:
                    print('No Encontrado')
                else:
                    tipo = TC.Tipo(useCurrentDatabase,instr.identificador,lista.identificador.id,buscar.tipo,tamanioD,buscar.referencia,buscar.tablaRef,buscar.listaCons)
                    tc.actualizar(tipo,useCurrentDatabase,instr.identificador,lista.identificador.id)
                    salida = "\nALTER TABLE"
    
    elif instr.etiqueta == TIPO_ALTER_TABLE.ALTER_COLUMN_NULL:
        #print(instr.identificador,instr.columnid)
        
        buscar = tc.obtenerReturn(useCurrentDatabase,instr.identificador,instr.columnid)
        if buscar == False:
            print('No Encontrado')
        else:
            tempA = buscar.listaCons
            tempA.append(OPCIONES_CONSTRAINT.NULL)
            tipo = TC.Tipo(useCurrentDatabase,instr.identificador,instr.columnid,buscar.tipo,buscar.tamanio,"","",tempA)
            tc.actualizar(tipo,useCurrentDatabase,instr.identificador,instr.columnid)
            salida = "\nALTER TABLE"   

    elif instr.etiqueta == TIPO_ALTER_TABLE.ALTER_COLUMN_NOT_NULL:
        buscar = tc.obtenerReturn(useCurrentDatabase,instr.identificador,instr.columnid)
        if buscar == False:
            print('No Encontrado')
        else:
            tempA = buscar.listaCons
            tempA.append(OPCIONES_CONSTRAINT.NOT_NULL)
            tipo = TC.Tipo(useCurrentDatabase,instr.identificador,instr.columnid,buscar.tipo,buscar.tamanio,"","",tempA)
            tc.actualizar(tipo,useCurrentDatabase,instr.identificador,instr.columnid)
            salida = "\nALTER TABLE"        
    
    elif instr.etiqueta ==  TIPO_ALTER_TABLE.DROP_CONSTRAINT:
        print(instr.identificador)
        if instr.lista_campos != []:
            for datos in instr.lista_campos:
                print(datos.id)
                ts.deleteConstraint(datos.id,instr.identificador)
            salida = "\nALTER TABLE" 

    elif instr.etiqueta ==  TIPO_ALTER_TABLE.RENAME_COLUMN:
        # NO EXISTE :(
        print(instr.identificador)
        print(instr.columnid)
        print(instr.tocolumnid)
        salida = "\nALTER TABLE" 
    
    elif instr.etiqueta == TIPO_ALTER_TABLE.DROP_COLUMN:
        #print('Tabla',instr.identificador)
        if instr.lista_campos != []:
            for datos in instr.lista_campos:
                #print('Columna',datos.id)
                
                pos = tc.getPos(useCurrentDatabase,instr.identificador,datos.id)
                print(pos)
                #result = j.alterDropColumn('world','countries',1)
                #print(result)
                result = 0
                if result == 0:
                    tc.eliminarID(useCurrentDatabase,instr.identificador,datos.id)
                    temp1 = ts.obtener(instr.identificador,useCurrentDatabase)
                    temp2 = TS.Simbolo(temp1.id,temp1.tipo,temp1.valor-1,temp1.ambito)
                    ts.actualizarDB(temp2,instr.identificador)
                    salida = "\nALTER TABLE"            
                    print(salida)

                elif result == 1 :
                    salida = "\nERROR:  internal_error \nSQL state: XX000 "
                elif result == 2 :
                    salida = "\nERROR:  database \"" + str(useCurrentDatabase) +"\" does not exist \nSQL state: 3D000"
                elif result == 3 :
                    salida = "\nERROR:  relation \"" + str(instr.identificador) +"\" does not exist\nSQL state: 42P01"
                elif result == 4 :
                    salida = "\nERROR:  key cannot be removed\nSQL state: 42P04"
                elif result == 5 :
                    salida = "\nERROR:  column out of bounds\nSQL state: 42P05"

                

    elif instr.etiqueta ==  TIPO_ALTER_TABLE.ADD_COLUMN:
        tipodatoo = TIPO_DE_DATOS.text_ 
        tamanioD = ""
        if instr.lista_campos[0].tipo.id.upper() == 'TEXT':
            tipodatoo = TIPO_DE_DATOS.text_ 
            tamanioD = ""
        elif instr.lista_campos[0].tipo.id.upper() == 'FLOAT':
            tipodatoo = TIPO_DE_DATOS.float_ 
        elif instr.lista_campos[0].tipo.id.upper() == 'INTEGER':
            tipodatoo = TIPO_DE_DATOS.integer_ 
            tamanioD = ""
        elif instr.lista_campos[0].tipo.id.upper() == 'SMALLINT':
            tipodatoo = TIPO_DE_DATOS.smallint_ 
        elif instr.lista_campos[0].tipo.id.upper() == 'MONEY':
            tipodatoo = TIPO_DE_DATOS.money 
        elif instr.lista_campos[0].tipo.id.upper() == 'BIGINT':
            tipodatoo = TIPO_DE_DATOS.bigint 
        elif instr.lista_campos[0].tipo.id.upper() == 'REAL':
            tipodatoo = TIPO_DE_DATOS.real 
        elif instr.lista_campos[0].tipo.id.upper() == 'DOUBLE':
            tipodatoo = TIPO_DE_DATOS.double 
        elif instr.lista_campos[0].tipo.id.upper() == 'INTERVAL':
            tipodatoo = TIPO_DE_DATOS.interval 
            tamanioD = instr.lista_campos[0].par1
        elif instr.lista_campos[0].tipo.id.upper() == 'TIME':
            tipodatoo = TIPO_DE_DATOS.time 
        elif instr.lista_campos[0].tipo.id.upper() == 'TIMESTAMP':
            tipodatoo = TIPO_DE_DATOS.timestamp 
        elif instr.lista_campos[0].tipo.id.upper() == 'DATE':
            tipodatoo = TIPO_DE_DATOS.date 
        elif instr.lista_campos[0].tipo.id.upper() == 'VARING':
            tipodatoo = TIPO_DE_DATOS.varing 
            tamanioD = instr.lista_campos[0].par1
        elif instr.lista_campos[0].tipo.id.upper() == 'VARCHAR':
            tipodatoo = TIPO_DE_DATOS.varchar 
            tamanioD = instr.lista_campos[0].par1
        elif instr.lista_campos[0].tipo.id.upper() == 'CHAR':
            tipodatoo = TIPO_DE_DATOS.char 
            tamanioD = instr.lista_campos[0].par1
        elif instr.lista_campos[0].tipo.id.upper() == 'CHARACTER':
            tipodatoo = TIPO_DE_DATOS.character 
            tamanioD = instr.lista_campos[0].par1
        elif instr.lista_campos[0].tipo.id.upper() == 'DECIMAL':
            tipodatoo = TIPO_DE_DATOS.decimal 
            tamanioD = instr.lista_campos[0].par1
        elif instr.lista_campos[0].tipo.id.upper() == 'NUMERIC':
            tipodatoo = TIPO_DE_DATOS.numeric           
            tamanioD = instr.lista_campos[0].par1 
        elif instr.lista_campos[0].tipo.id.upper() == 'DOUBLE':
            tipodatoo = TIPO_DE_DATOS.double_precision
        
        if instr.lista_campos != []:
            for datos in instr.lista_campos:
                result = j.alterAddColumn(str(useCurrentDatabase),str(instr.identificador),1)
                if result == 0:
                    buscar = tc.obtenerReturn(useCurrentDatabase,instr.identificador,datos.identificador.id)
                    if buscar == False:
                        tipo = TC.Tipo(useCurrentDatabase,instr.identificador,datos.identificador.id,tipodatoo,tamanioD,"","",[])
                        tc.agregar(tipo)
                    else:
                        print('New')
                    
                    temp1 = ts.obtener(instr.identificador,useCurrentDatabase)
                    temp2 = TS.Simbolo(temp1.id,temp1.tipo,temp1.valor+1,temp1.ambito)
                    ts.actualizarDB(temp2,instr.identificador)
                    salida = "\nALTER TABLE"            

                elif result == 1 :
                    salida = "\nERROR:  internal_error \nSQL state: XX000 "
                elif result == 2 :
                    salida = "\nERROR:  database \"" + str(useCurrentDatabase) +"\" does not exist \nSQL state: 3D000"
                elif result == 3 :
                    salida = "\nERROR:  relation \"" + str(instr.tipo_id) +"\" does not exist\nSQL state: 42P01"
Пример #9
0
def procesar_constraintDefinicion(instr,ts,tc,tabla,id_column):
    #print(tabla,id,instr.id,instr.tipo)
    global pks
    if instr.id == None:
        if instr.tipo == OPCIONES_CONSTRAINT.NOT_NULL:
            buscar = tc.obtenerReturn(useCurrentDatabase,tabla,id_column)
            if buscar == False:
                print('Encontrado')
            else:
                tempA = buscar.listaCons
                tempA.append(OPCIONES_CONSTRAINT.NOT_NULL)
                tipo = TC.Tipo(useCurrentDatabase,tabla,id_column,buscar.tipo,buscar.tamanio,"","",tempA)
                tc.actualizar(tipo,useCurrentDatabase,tabla,id_column)
        elif instr.tipo == OPCIONES_CONSTRAINT.NULL:
            buscar = tc.obtenerReturn(useCurrentDatabase,tabla,id_column)
            if buscar == False:
                print('Encontrado')
            else:
                tempA = buscar.listaCons
                tempA.append(OPCIONES_CONSTRAINT.NULL)
                tipo = TC.Tipo(useCurrentDatabase,tabla,id_column,buscar.tipo,buscar.tamanio,"","",tempA)
                tc.actualizar(tipo,useCurrentDatabase,tabla,id_column)
        elif instr.tipo == OPCIONES_CONSTRAINT.PRIMARY:
            pk = []
            buscar = tc.obtenerReturn(useCurrentDatabase,tabla,id_column)
            if buscar == False:
                print('Encontrado')
            else:
                tempA = buscar.listaCons
                tempA.append(OPCIONES_CONSTRAINT.PRIMARY)
                tipo = TC.Tipo(useCurrentDatabase,tabla,id_column,buscar.tipo,buscar.tamanio,"","",tempA)
                tc.actualizar(tipo,useCurrentDatabase,tabla,id_column)
                pos = tc.getPos(useCurrentDatabase,tabla,id_column)
                pk.append(pos)
                
            pks = pk
                
            


        elif instr.tipo == OPCIONES_CONSTRAINT.FOREIGN:
            buscar = tc.obtenerReturn(useCurrentDatabase,tabla,id_column)
            if buscar == False:
                print('Encontrado')
            else:
                tempA = buscar.listaCons
                tempA.append(OPCIONES_CONSTRAINT.FOREIGN)
                tipo = TC.Tipo(useCurrentDatabase,tabla,id_column,buscar.tipo,buscar.tamanio,"","",tempA)
                tc.actualizar(tipo,useCurrentDatabase,tabla,id_column)
        elif instr.tipo == OPCIONES_CONSTRAINT.UNIQUE:
            buscar = tc.obtenerReturn(useCurrentDatabase,tabla,id_column)
            if buscar == False:
                print('Encontrado')
            else:
                tempA = buscar.listaCons
                tempA.append(OPCIONES_CONSTRAINT.UNIQUE)
                tipo = TC.Tipo(useCurrentDatabase,tabla,id_column,buscar.tipo,buscar.tamanio,"","",tempA)
                tc.actualizar(tipo,useCurrentDatabase,tabla,id_column)
        elif instr.tipo == OPCIONES_CONSTRAINT.DEFAULT:
            if instr.opciones_constraint != []:
                buscar = tc.obtenerReturn(useCurrentDatabase,tabla,id_column)
                if buscar == False:
                    print('Encontrado')
                else:
                    tempA = buscar.listaCons
                    tempA.append(OPCIONES_CONSTRAINT.DEFAULT)
                    tipo = TC.Tipo(useCurrentDatabase,tabla,id_column,buscar.tipo,buscar.tamanio,"","",tempA)
                    tc.actualizar(tipo,useCurrentDatabase,tabla,id_column)
        elif instr.tipo == OPCIONES_CONSTRAINT.CHECK:
            buscar = tc.obtenerReturn(useCurrentDatabase,tabla,id_column)
            if buscar == False:
                print('Encontrado')
            else:
                tempA = buscar.listaCons
                tempA.append(OPCIONES_CONSTRAINT.CHECK)
                tipo = TC.Tipo(useCurrentDatabase,tabla,id_column,buscar.tipo,buscar.tamanio,"","",tempA)
                tc.actualizar(tipo,useCurrentDatabase,tabla,id_column)

    else:
        if instr.tipo == OPCIONES_CONSTRAINT.UNIQUE:
            if instr.opciones_constraint == None:
                temp = TS.Simbolo(instr.id,'CONSTRAINT',0,tabla)
                ts.agregar(temp)
                buscar = tc.obtenerReturn(useCurrentDatabase,tabla,id_column)
                if buscar == False:
                    print('Encontrado')
                else:
                    tempA = buscar.listaCons
                    tempA.append(OPCIONES_CONSTRAINT.UNIQUE)
                    tipo = TC.Tipo(useCurrentDatabase,tabla,id_column,buscar.tipo,buscar.tamanio,"","",tempA)
                    tc.actualizar(tipo,useCurrentDatabase,tabla,id_column)
        elif instr.tipo == OPCIONES_CONSTRAINT.CHECK:
            if instr.opciones_constraint != None:
                temp = TS.Simbolo(instr.id,'CONSTRAINT',0,tabla)
                ts.agregar(temp)
                buscar = tc.obtenerReturn(useCurrentDatabase,tabla,id_column)
                if buscar == False:
                    print('Encontrado')
                else:
                    tempA = buscar.listaCons
                    tempA.append(OPCIONES_CONSTRAINT.CHECK)
                    tipo = TC.Tipo(useCurrentDatabase,tabla,id_column,buscar.tipo,buscar.tamanio,"","",tempA)
                    tc.actualizar(tipo,useCurrentDatabase,tabla,id_column)
Пример #10
0
def procesar_Foranea(instr,ts,tc,tabla):
    # print(instr.nombre_tabla,instr.referencia_tabla,instr.campo_referencia)
    tipo = TC.Tipo(tabla,instr.nombre_tabla,None,OPCIONESCREATE_TABLE.PRIMARIA,instr.campo_referencia,instr.referencia_tabla)
    tc.actualizarLlaveForanea(tipo,tabla,instr.nombre_tabla,OPCIONESCREATE_TABLE.FORANEA,instr.referencia_tabla,instr.campo_referencia)
Пример #11
0
def procesar_primaria(instr,ts,tc,tabla):
    tipo = TC.Tipo(tabla,instr.id,None,OPCIONESCREATE_TABLE.PRIMARIA,None,None)
    tc.actualizarRestriccion(tipo,tabla,instr.id,OPCIONESCREATE_TABLE.PRIMARIA)
Пример #12
0
def procesar_listaId(instr,ts,tc,tabla):
    if instr.identificadores != []:
        for ids in instr.identificadores:
            tipo = TC.Tipo(tabla,ids.id,None,OPCIONESCREATE_TABLE.UNIQUE,None,None)
            tc.actualizarRestriccion(tipo,tabla,ids.id,OPCIONESCREATE_TABLE.UNIQUE)
Пример #13
0
def procesar_Definicion(instr,ts,tc,tabla) :
    tipo = TC.Tipo(tabla,instr.id,instr.tipo_datos.etiqueta,instr.etiqueta,instr.id_referencia,None)
    tc.agregar(tipo)
Пример #14
0
import tc as TC
from expresiones import *

tc_global = TC.TablaDeTipos()

variable = TC.Tipo('Compi2', 'usuario', 'id_usuario', 'varchar(50)', None,
                   None, None,
                   [OPCIONES_CONSTRAINT.FOREIGN, OPCIONES_CONSTRAINT.NOT_NULL])
tc_global.agregar(variable)
variable1 = TC.Tipo(
    'Compi2', 'usuario1', 'id_usuario2', 'varchar(50)', None, None, None,
    [OPCIONES_CONSTRAINT.FOREIGN, OPCIONES_CONSTRAINT.NOT_NULL])
tc_global.agregar(variable1)
variable2 = TC.Tipo(
    'Compi2', 'usuario', 'usuario', 'varchar(50)', None, None, None,
    [OPCIONES_CONSTRAINT.FOREIGN, OPCIONES_CONSTRAINT.NOT_NULL])
tc_global.agregar(variable2)

print(tc_global.getPos('Compi2', 'usuario1', 'id_usuario2'))

#tc_global.eliminarTabla('Compi2','usuario2')
#tc_global.eliminarID('Compi2','usuario2','id_usuario')
#tc_global.eliminarDatabase('Compi2')

i = 0
while i < len(tc_global.tipos):
    j = 0
    while j < len(tc_global.tipos[i].listaCons):
        print(str(i + 1), str(tc_global.tipos[i].database),
              str(tc_global.tipos[i].tabla), str(tc_global.tipos[i].id),
              str(tc_global.tipos[i].tipo),