Esempio n. 1
0
 def dot(self):
     new = Nodo.Nodo("DROP")
     t = Nodo.Nodo(self.structure)
     n = Nodo.Nodo(self.name)
     new.addNode(t)
     new.addNode(n)
     return new
Esempio n. 2
0
    def dot(self):
        new = Nodo.Nodo("CREATE_INDEX")
        if self.unique:
            uniqueNode = Nodo.Nodo("UNIQUE")
            new.addNode(uniqueNode)
        if self.usingMethod:
            uhNode = Nodo.Nodo("USING_HASH")
            new.addNode(uhNode)
        id1 = Nodo.Nodo(str(self.idIndex))
        id2 = Nodo.Nodo(str(self.idTable))
        new.addNode(id1)
        new.addNode(id2)

        listNode = Nodo.Nodo("INDEX_LIST")
        new.addNode(listNode)

        for l in self.optList:

            if l[0] != None:
                l1 = Nodo.Nodo(str(l[0]))
                listNode.addNode(l1)
            if l[1] != None:
                l2 = Nodo.Nodo(str(l[1]))
                listNode.addNode(l2)
            if l[2]:
                l3 = Nodo.Nodo("NULLS")
                listNode.addNode(l3)
                if l[2][1] != None:
                    l4 = Nodo.Nodo(str(l[2][1]))
                    listNode.addNode(l4)

        if self.whereCl != None:
            new.addNode(self.whereCl.dot())

        return new
Esempio n. 3
0
    def dot(self):
        new = Nodo.Nodo("SHOW_DATABASES")
        if self.like != None:
            l = Nodo.Nodo("LIKE")
            ls = Nodo.Nodo(self.like)
            new.addNode(l)
            l.addNode(ls)

        return new
Esempio n. 4
0
 def dot(self):
     f = Nodo.Nodo(self.function)
     p = Nodo.Nodo("PARAMS")
     new = Nodo.Nodo("CALL")
     new.addNode(f)
     new.addNode(p)
     for par in self.params:
         p.addNode(par.dot())
     return new
Esempio n. 5
0
 def dot(self):
     new = Nodo.Nodo("UPDATE")
     new.addNode(self.fromcl.dot())
     assigNode = Nodo.Nodo("SET")
     new.addNode(assigNode)
     for v in self.values:
         assigNode.addNode(v.dot())
     if self.wherecl:
         new.addNode(self.wherecl.dot())
     return new
Esempio n. 6
0
 def dot(self):
     new = Nodo.Nodo("LIMIT")
     numN = Nodo.Nodo(str(self.num))
     new.addNode(numN)
     if self.offset != None:
         off = Nodo.Nodo("OFFSET")
         new.addNode(off)
         offId = Nodo.Nodo(str(self.offset))
         off.addNode(offId)
     return new
Esempio n. 7
0
 def dot(self):
     new = Nodo.Nodo("SELECT")
     paramNode = Nodo.Nodo("PARAMS")
     new.addNode(paramNode)
     if len(self.params) == 0:
         asterisco = Nodo.Nodo("*")
         paramNode.addNode(asterisco)
     else:
         for p in self.params:
             paramNode.addNode(p.dot())
     return new
Esempio n. 8
0
    def dot(self):
        new = Nodo.Nodo("ALTER_DATABASE")
        iddb = Nodo.Nodo(self.name)
        new.addNode(iddb)

        optionNode = Nodo.Nodo(self.option)
        new.addNode(optionNode)
        valOption = Nodo.Nodo(self.newname)
        optionNode.addNode(valOption)

        return new
Esempio n. 9
0
    def dot(self):
        f = Nodo.Nodo(self.func)
        p = Nodo.Nodo("PARAMS")
        new = Nodo.Nodo("CALL")
        new.addNode(f)
        new.addNode(p)

        if self.colData != "*":
            p.addNode(self.colData.dot())
        else:
            p.addNode(Nodo.Nodo("*"))
        return new
Esempio n. 10
0
 def dot(self):
     new = Nodo.Nodo("CREATE_TYPE")
     if self.exists:
         exNode = Nodo.Nodo("IF_NOT_EXISTS")
         new.addNode(exNode)
     idNode = Nodo.Nodo(self.name)
     new.addNode(idNode)
     paramsNode = Nodo.Nodo("PARAMS")
     new.addNode(paramsNode)
     for v in self.values:
         paramsNode.addNode(v.dot())
     return new
Esempio n. 11
0
 def dot(self):
     new = Nodo.Nodo("FROM")
     for t in self.tables:
         if isinstance(t, Select):
             n = t.dot()
             new.addNode(n)
         else:
             t1 = Nodo.Nodo(t.name)
             new.addNode(t1)
     for a in self.aliases:
         a1 = Nodo.Nodo(a)
         new.addNode(a1)
     return new
Esempio n. 12
0
    def dot(self):
        new = Nodo.Nodo("INSERT_INTO")
        t = Nodo.Nodo(self.tabla)
        par = Nodo.Nodo("PARAMS")
        new.addNode(t)
        for p in self.parametros:
            par.addNode(p.dot())

        if self.columns != None:
            colNode = Nodo.Nodo("COLUMNS")
            for c in self.columns:
                colNode.addNode(Nodo.Nodo(str(c)))
            new.addNode(colNode)

        new.addNode(par)
        return new
Esempio n. 13
0
def Tree(n):
    if len(listInst) > 0:
        l = listInst.pop()
        n.addNode(l)
        inst = Nodo.Nodo("INST")
        n.addNode(inst)
        Tree(inst)
Esempio n. 14
0
    def dot(self):

        n1 = self.optNot + " IN"
        new = Nodo.Nodo(n1)
        new.addNode(self.colData.dot())
        new.addNode(self.subquery.dot())
        return new
Esempio n. 15
0
 def dot(self):
     n1 = self.exp1.dot()
     n2 = self.exp2.dot()
     new = Nodo.Nodo(self.operator)
     new.addNode(n1)
     new.addNode(n2)
     return new
Esempio n. 16
0
    def dot(self):
        new = Nodo.Nodo("SELECT")
        paramNode = Nodo.Nodo("PARAMS")
        new.addNode(paramNode)
        if self.distinct:
            dis = Nodo.Nodo("DISTINCT")
            new.addNode(dis)
        if len(self.params) == 0:
            asterisco = Nodo.Nodo("*")
            paramNode.addNode(asterisco)
        else:
            for p in self.params:
                paramNode.addNode(p.dot())
        new.addNode(self.fromcl.dot())
        if self.wherecl != None:
            new.addNode(self.wherecl.dot())

        if self.groupbyCl != None:
            gb = Nodo.Nodo("GROUP_BY")
            new.addNode(gb)
            for g in self.groupbyCl:
                gb.addNode(g.dot())
            if self.havingCl != None:
                hv = Nodo.Nodo("HAVING")
                new.addNode(hv)
                hv.addNode(self.havingCl.dot())

        if self.limitCl != None:
            new.addNode(self.limitCl.dot())

        if self.orderByCl != None:
            new.addNode(self.orderByCl.dot())

        return new
Esempio n. 17
0
 def dot(self):
     f = Nodo.Nodo("date_part")
     p = Nodo.Nodo("PARAMS")
     new = Nodo.Nodo("CALL")
     new.addNode(f)
     new.addNode(p)
     ntype = Nodo.Nodo(str(self.type))
     nstr = Nodo.Nodo(str(self.str))
     nopt = Nodo.Nodo(str(self.opt))
     p.addNode(nopt)
     p.addNode(ntype)
     p.addNode(nstr)
     return new
Esempio n. 18
0
    def dot(self):
        new = Nodo.Nodo("CREATE_DATABASE")
        if self.exists:
            ex = Nodo.Nodo("EXISTS")
            new.addNode(ex)

        n = Nodo.Nodo(self.name)
        new.addNode(n)
        if self.owner != None:
            ow = Nodo.Nodo("OWNER")
            own = Nodo.Nodo(self.owner)
            ow.addNode(own)
            new.addNode(ow)
        if self.mode != None:
            mod = Nodo.Nodo("MODE")
            mod2 = Nodo.Nodo(str(self.mode))
            mod.addNode(mod2)
            new.addNode(mod)
        return new
Esempio n. 19
0
 def dot(self):
     new = Nodo.Nodo("=")
     idNode = Nodo.Nodo(str(self.id))
     new.addNode(idNode)
     new.addNode(self.value.dot())
     return new
Esempio n. 20
0
 def dot(self):
     new = Nodo.Nodo("CHECK")
     new.addNode(Nodo.Nodo(str(self.value)))
     return new
Esempio n. 21
0
 def dot(self):
     new = Nodo.Nodo("WHERE")
     new.addNode(self.series.dot())
     return new
Esempio n. 22
0
 def dot(self):
     new = Nodo.Nodo("INTERSECT")
     new.addNode(self.s1.dot())
     new.addNode(self.s2.dot())
     return new
Esempio n. 23
0
 def dot(self):
     new = Nodo.Nodo("UNION")
     new.addNode(self.s1.dot())
     new.addNode(self.s2.dot())
     return new
Esempio n. 24
0
 def dot(self):
     new = Nodo.Nodo("EXCEPT")
     new.addNode(self.s1.dot())
     new.addNode(self.s2.dot())
     return new
Esempio n. 25
0
 def dot(self):
     new = Nodo.Nodo(str(self.table))
     punto = Nodo.Nodo(".*")
     new.addNode(punto)
     return new
Esempio n. 26
0
    def dot(self):
        new = Nodo.Nodo("USE_DATABASE")
        n = Nodo.Nodo(self.db)
        new.addNode(n)

        return new
Esempio n. 27
0
 def dot(self):
     new = Nodo.Nodo("TRUNCATE")
     n = Nodo.Nodo(self.name)
     new.addNode(n)
     return new
Esempio n. 28
0
 def dot(self):
     n1 = self.exp.dot()
     new = Nodo.Nodo(self.operator)
     new.addNode(n1)
     return new
Esempio n. 29
0
    def dot(self):
        new = Nodo.Nodo("CREATE_TABLE")

        if self.exists:
            ex = Nodo.Nodo("EXISTS")
            new.addNode(ex)
        n = Nodo.Nodo(self.name)
        new.addNode(n)
        c = Nodo.Nodo("COLUMNS")
        new.addNode(c)

        for cl in self.columns:
            if not cl[0]:
                id = Nodo.Nodo(cl[1])
                c.addNode(id)
                typ = Nodo.Nodo("TYPE")
                c.addNode(typ)
                typ1 = Nodo.Nodo(cl[2][0])
                typ.addNode(typ1)
                par = cl[2][1]
                if par[0] != None:
                    params = Nodo.Nodo("PARAMS")
                    typ.addNode(params)
                    for parl in par:
                        parl1 = Nodo.Nodo(str(parl))
                        params.addNode(parl1)

                colOpts = cl[3]
                if colOpts != None:
                    coNode = Nodo.Nodo("OPTIONS")
                    c.addNode(coNode)
                    for co in colOpts:
                        if co[0] == "NULL":
                            if co[1]:
                                notNullNode = Nodo.Nodo("NOT_NULL")
                            else:
                                notNullNode = Nodo.Nodo("NULL")
                            coNode.addNode(notNullNode)
                        elif co[0] == "DEFAULT":
                            defaultNode = Nodo.Nodo("DEFAULT")
                            coNode.addNode(defaultNode)
                            litDefaultNode = Nodo.Nodo(str(co[1]))
                            defaultNode.addNode(litDefaultNode)

                        elif co[0] == "PRIMARY":
                            primaryNode = Nodo.Nodo("PRIMARY_KEY")
                            coNode.addNode(primaryNode)

                        elif co[0] == "REFERENCES":
                            referencesNode = Nodo.Nodo("REFERENCES")
                            coNode.addNode(referencesNode)
                            idReferences = Nodo.Nodo(str(co[1]))
                            referencesNode.addNode(idReferences)
                        else:
                            constNode = Nodo.Nodo("CONSTRAINT")
                            coNode.addNode(constNode)
            else:
                if cl[1][0] == "UNIQUE":
                    uniqueNode = Nodo.Nodo("UNIQUE")
                    c.addNode(uniqueNode)
                    idlist = cl[1][1]

                    for il in idlist:
                        nl = Nodo.Nodo(str(il))
                        uniqueNode.addNode(nl)

                if cl[1][0] == "PRIMARY":
                    primNode = Nodo.Nodo("PRIMARY_KEY")
                    c.addNode(primNode)
                    idlist = cl[1][1]

                    for il in idlist:
                        nl = Nodo.Nodo(str(il))
                        primNode.addNode(nl)
                if cl[1][0] == "FOREIGN":
                    forNode = Nodo.Nodo("FOREIGN_KEY")
                    c.addNode(forNode)
                    idlist = cl[1][1]
                    for il in idlist:
                        nl = Nodo.Nodo(str(il))
                        forNode.addNode(nl)
                    refNode = Nodo.Nodo("REFERENCES")
                    forNode.addNode(refNode)
                    idNode = Nodo.Nodo(str(cl[1][2]))
                    refNode.addNode(idNode)
                    idlist2 = cl[1][3]
                    for il2 in idlist2:
                        nl2 = Nodo.Nodo(str(il2))
                        refNode.addNode(nl2)

        if self.inherits != None:
            inhNode = Nodo.Nodo("INHERITS")
            new.addNode(inhNode)
            inhNode2 = Nodo.Nodo(str(self.inherits))
            inhNode.addNode(inhNode2)
        return new
Esempio n. 30
0
 def dot(self):
     new = Nodo.Nodo(self.val)
     return new