def analyseJUD(text, expression, count, flag, OP, c):
"""
Analyse une opération de jointure entrée au clavier.
Le paramètre OP spécifie le type de l'Opération à créer:
1) OP = "J" => Join
2) OP = "U" => Union
") OP = "D" => Diff
Syntaxe attendue :
-exemple1 : Join(Rel(name);Rel(name))
-exemple2 : Join(*expr1*;*expre2*)
-exemple3 : Union(*expr1*;*expre2*)
-exemple4 : Diff(*expr1*;*expre2*)
Note : expr1 et expr2 sont des expressions SPJRUD entrée au clavier en respectant la syntaxe.
"""
flag.append(False)
param1 = None
param2 = None
if(OP == "J"):
currentExpression = o.Join(param1,param2, c)
elif (OP == "U"):
currentExpression = o.Union(param1,param2, c)
elif (OP == "D"):
currentExpression = o.Diff(param1,param2, c)
#On analyse le param1
count += 1
if(text[count:count+3] == "Rel"):
currentExpression.param1=(e.Relation(analyseRel(text, count), c))
while(text[count] != ";"):
count += 1
else:
tempExpr = None
tempf = []
#On effectue une seconde récursion pour déterminer le premier paramètre
l = analyseLen(text, count)
tempExpr = analyseInput(text, tempExpr, count, tempf, c)
currentExpression.param1 = tempExpr
#On calcule l'indice de début du param2
count += l
#On analyse le param2
count += 1
if(text[count:count+3] == "Rel"):
flag[-1] = True
currentExpression.param2=(e.Relation(analyseRel(text, count), c))
else:
flag[-1] = False
if (expression != None):
#Ce n'est pas la première opération de l'expression : On ajoute l'opération à l'expression existante
expression.addExpr(currentExpression)
return expression, flag, count
else:
#C'est la première opération de l'expression
expression = currentExpression
return expression, flag, count
def joinSql(table, table2, c, n):
tempTable = Expression.Relation("temp" + str(n), c)
rd.createTempAs(
"temp" + str(n),
rd.selectSql("*", table.name + " Natural Join " + table2.name, "", c),
c)
return tempTable
def selectionSqlAttr(attr1, attr2, table, c, n):
tempTable = Expression.Relation("temp" + str(n), c)
rd.createTempAs(
"temp" + str(n),
rd.selectSql("*", table, " WHERE " + attr1.name + "=" + attr2.name, c),
c)
return tempTable
def selectionSqlCst(attr, cst, table, c, n):
tempTable = Expression.Relation("temp" + str(n), c)
rd.createTempAs(
"temp" + str(n),
rd.selectSql("*", table,
" WHERE " + attr.name + "='" + str(cst.valeur) + "'", c),
c)
return tempTable
def analyseSelect(text, expression, count, flag, c):
"""
Analyse une opération de Sélection entrée au clavier.
Syntaxe attendue :
-exemple1 : Select(attr1,Cst(value),Rel(name))
-exemple2 : Select(attr1,attr2,Rel(name))
Note : Pas d'espace, pas de guillemets, 'Cst' est un mot réservé.
Une Cst peut être soit un chaîne de caractère, soit un nombre
Le dernier paramètre peut être autre chose qu'une relation (Ex : une autre expression)
"""
flag.append(False)
param1 = None
attr = None
param2 = None
currentExpression = o.Selection(param1, param2, attr, c)
#On analyse le param1 (L'attribut que l'on sélectionne)
count += 1
attr, j = analyseAttr(text,count)
count = j
currentExpression.param1 = e.Attribut(attr)
#On analyse attr (Le deuxième élément de l'égalité)
count += 1
if(text[count : count +3] == "Cst"):
#On égalise avec une constante
count += 4
vCst= ""
while(text[count] != ")") :
vCst += text[count]
count += 1
#On détermine le type de la constante
if (vCst.isalpha() == False):
vCst = float(vCst)
currentExpression.attr = e.Cst(vCst)
count += 1
else:
#On égalise avec un attribut
attr, j = analyseAttr(text,count)
count = j
currentExpression.attr = e.Attribut(attr)
#On analyse param2 (La relation ou l'expression sur laquelle on applique cette sélection)
count += 1
if(text[count:count+3] == "Rel"):
#C'est une relation, l'expression est donc complète
flag[-1] = True
currentExpression.param2=(e.Relation(analyseRel(text, count), c))
else:
flag[-1] = False
if (expression != None):
#Ce n'est pas la première opération de l'expression : On ajoute l'opération à l'expression existante
expression.addExpr(currentExpression)
return expression, flag, count
else:
#C'est la première opération de l'expression
expression = currentExpression
return expression, flag, count
def renameSql(old, new, table, c, n):
tempTable = Expression.Relation("temp" + str(n), c)
where = ""
rd.createTempAs("tempRename", rd.selectSql("*", table.name, where, c), c)
rd.modifAttr("tempRename", "RENAME COLUMN", old.name + " to " + new.name,
c)
sel = rd.selectSql("*", "tempRename", where, c)
rd.createTempAs("temp" + str(n), sel, c)
c.execute("DROP TABLE tempRename")
return tempTable
def projectionSql(attrlist, table, c, n):
where = " GROUP BY "
attrs = ""
for i in range(len(attrlist)):
if i != len(attrlist) - 1:
attrs += str(attrlist[i]) + ", "
else:
attrs += str(attrlist[i]) + " "
rd.createTempAs("temp" + str(n),
rd.selectSql(attrlist, table, where + attrs, c), c)
tempTable = Expression.Relation("temp" + str(n), c)
return tempTable
def unionSql(table, table2, c, n):
tempTable = Expression.Relation("temp" + str(n), c)
sel1 = rd.selectSql("*", table.name, "", c)
colstab = rd.getColAndTypes(table.name, c)
cols = ""
for i in range(len(colstab)):
if i != len(colstab) - 1:
cols += colstab[i][0] + ", "
else:
cols += colstab[i][0] + " "
sel2 = "SELECT " + cols + " FROM " + table2.name
rd.createTempAs("temp" + str(n), sel1 + " UNION " + sel2, c)
return tempTable
def analyseProj(text, expression, count, flag, c):
"""
Analyse une opération de Projection entrée au clavier.
Syntaxe attendue :
-exemple1 : Proj([attr1,attr2],Rel(name))
-exemple2 : Proj([attr1,attr2],Expression)
Note : Pas d'espace, pas de guillemets.
"""
flag.append(False)
listAttr = e.ListeAttribut([])
param2 = None
currentExpression = o.Proj(listAttr, param2, c)
#On analyse la liste d'attributs
count += 2
endAttr = count
while (text[endAttr] != ']'):
endAttr+=1
l = text[count:endAttr].split(",")
for a in l :
currentExpression.param1.liste.append(e.Attribut(a))
count = endAttr
#On analyse la relation sur laquelle on applique la projection
count += 2
if(text[count:count+3] == "Rel"):
#C'est une relation, l'expression est donc complète
flag[-1] = True
currentExpression.param2=(e.Relation(analyseRel(text, count), c))
else:
flag[-1] = False
if (expression != None):
#Ce n'est pas la première opération de l'expression : On ajoute l'opération à l'expression existante
expression.addExpr(currentExpression)
return expression, flag, count
else:
#C'est la première opération de l'expression
expression = currentExpression
return expression, flag, count
def analyseRename(text, expression, count,flag, c):
"""
Analyse une opération de Renommage entrée au clavier.
Syntaxe attendue :
-exemple1 : Rename(oldName,newName,Rel(name))
"""
flag.append(False)
newAttr = None
param1 = None
param2 = None
currentExpression = o.Rename(param1, param2, newAttr, c)
#On analyse newAttr
count += 1
nAttr, j = analyseAttr(text, count)
currentExpression.param1 = e.Attribut(nAttr)
count = j
#On analyse le param1
count += 1
nParam1, j = analyseAttr(text, count)
currentExpression.newAttr = e.Attribut(nParam1)
count = j
#On analyse le param2
count += 1
if(text[count:count+3] == "Rel"):
flag[-1] = True
currentExpression.param2=(e.Relation(analyseRel(text, count), c))
else:
flag[-1] = False
if (expression != None):
#Ce n'est pas la première opération de l'expression : On ajoute l'opération à l'expression existante
expression.addExpr(currentExpression)
return expression, flag, count
else:
#C'est la première opération de l'expression
expression = currentExpression
return expression, flag, count
