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
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
def dot(self):
new = Nodo.Nodo("TRUNCATE")
n = Nodo.Nodo(self.name)
new.addNode(n)
global root
root = new
# ast.makeAst(root)
return new
def dot(self):
new = Nodo.Nodo("USE_DATABASE")
n = Nodo.Nodo(self.db)
new.addNode(n)
global root
root = new
# ast.makeAst(root)
return new
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
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
def dot(self):
f = Nodo.Nodo(self.func)
p = Nodo.Nodo("PARAMS")
new = Nodo.Nodo("CALL")
new.addNode(f)
new.addNode(p)
p.addNode(self.colData.dot())
return new
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())
new.addNode(self.wherecl.dot())
return new
def dot(self):
new = Nodo.Nodo("DROP")
t = Nodo.Nodo(self.structure)
n = Nodo.Nodo(self.name)
new.addNode(t)
new.addNode(n)
global root
root = new
# ast.makeAst(root)
return new
def dot(self):
new = Nodo.Nodo("RAISE")
string1 = Nodo.Nodo("STRING")
string2 = self.string2.dot()
if self.notice:
notice_ = Nodo.Nodo("NOTICE")
new.addNode(notice_)
new.addNode(string1)
new.addNode(string2)
return new
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
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
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
def dot(self):
f = Nodo.Nodo("EXTRACT")
p = Nodo.Nodo("PARAMS")
new = Nodo.Nodo("CALL")
new.addNode(f)
new.addNode(p)
nstr = Nodo.Nodo(str(self.colData.temp))
nopt = Nodo.Nodo(str(self.opt))
p.addNode(nopt)
p.addNode(nstr)
return new
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(Nodo.Nodo('*'))
else:
p.addNode(self.colData.dot())
return new
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
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)
global root
root = new
# ast.makeAst(root)
return new
def dot(self):
new = Nodo.Nodo("FROM")
for t in self.tables:
t1 = Nodo.Nodo(t.name)
new.addNode(t1)
for a in self.aliases:
a1 = Nodo.Nodo(a)
new.addNode(a1)
global root
root = new
return new
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
def dot(self):
texto = "CREATE_INDEX"
if self.type:
texto = self.type + "_" + texto
new = Nodo.Nodo(texto)
indice = Nodo.Nodo("INDEX")
nombre = Nodo.Nodo(self.index)
indice.addNode(nombre)
tabla = Nodo.Nodo("TABLE")
tNombre = Nodo.Nodo(self.table)
tabla.addNode(tNombre)
fields = Nodo.Nodo("FIELDS")
if isinstance(self.fields, list):
for campo in self.fields:
field = Nodo.Nodo(campo)
fields.addNode(field)
else:
field = Nodo.Nodo(self.fields)
fields.addNode(field)
new.addNode(indice)
new.addNode(tabla)
new.addNode(fields)
return new
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)
global root
root = new
# ast.makeAst(root)
return new
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())
new.addNode(self.fromcl.dot())
new.addNode(self.wherecl.dot())
global root
root = new
return new
def dot(self):
new = Nodo.Nodo("INSERT_INTO")
t = Nodo.Nodo(self.tabla)
par = Nodo.Nodo("PARAMS")
for p in self.parametros:
par.addNode(p.dot())
new.addNode(t)
new.addNode(par)
global root
root = new
# ast.makeAst(root)
return new
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
def dot(self):
n1 = self.exp1.dot()
new = Nodo.Nodo(self.operator)
new.addNode(n1)
global root
root = new
return new
def dot(self):
n1 = self.exp1.dot()
n2 = self.exp2.dot()
new = Nodo.Nodo(self.operator)
new.addNode(n1)
new.addNode(n2)
return new
def dot(self):
n1 = self.optNot + " IN"
new = Nodo.Nodo(n1)
new.addNode(self.colData.dot())
new.addNode(self.subquery.dot())
return new
def Tree(n):
if len(listInst) > 0:
l = listInst.pop()
n.addNode(l)
inst = Nodo.Nodo("INST")
n.addNode(inst)
Tree(inst)
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
def dot(self):
f = Nodo.Nodo("EXTRACT")
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
