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