Langage algébrique vers langage SQL

Bonjour,

Cela fait quelques jours que je me creuse la tête pour trouver un algorythme me permettant de transformer des requetes en lagage algébrique (par exemple : R1 = projection Table (attribut)
                                       R2 = selection R1 (attribut = "10")
Ceci a pour but bien evidement d'afficher le résultat de la requete dans une datagrid

Mon programme est adapté pour n'importe qu'elle base access, et le nombre de requetes peut etre illimitée. J'ai déjà fait la partie analyse sémantique des requetes algébriques et l'exécution des requetes sql dans la base access. Mais il me manque le milieu

Si vous pouviez m'aider ...

Salut,

Interessant ce que tu veux faire, çà peut être simple si les requêtes algébriques restent simple, mais si elles sont plus complexes je pense que tu vas galérer. Sinon si ce ne sont que des projection et des selection ca ne me semble pas trop compliqué a réaliser.

Dans un premier temps il faudrait créer une tableau les_tables (chaine de caractères string) un tableau les_champs, et un tableau les restrictions ou selection les_restrictions.

Ensuite il faudrait parcourir tes requêtes algébriques en utilisant de sfonctions de manipulations de chaine de caractères et récupérer à chaque fois, table, champ et restriction.

Ensuite tu reconstruis ta requêtes SQL en commencant par le tableau les_champs

exemple :
marequete = "SELECT ";
Tant que les_champs Faire
   marequete = les_champs[i];
FTQ

et ainsi de suite pour les tables et pour les restrictions.

Mais franchement ce sera tranquil pour des requetes simples, mais pour le reste

Allez bonne chance

Oui c'est sur, mais j'ai aussi l'opérateur JOINTURE, UNION, INTERSECTION, DIFFERENCE, PRODUIT. en langage algébrique c'est facil suffit de faire ligne a ligne, mais en sql c'est différent ... la derniere projection doit se retrouver au niveau du select etc ... y'a pas d'ordre précis.

Alors j'avais penser à effectuer chaque requete algébrique (transformée en sql) les une a la suite des autres, mais le probleme est le suivant:

imaginons R1 = selection client (ville = "paris")
                R2 = projection R1 (nom)

Ce qui donnerait si on les fait les unes a la suite des autres

pour R1 :

select *
from client
where ville = 'PARIS'

et pour R2

select nom
from ??????

si tu pouvais juste me dire si y'a moyen de faire comme ca, alors j'ai trouver ma solution, sinon je suis dans la *****


J'ai deja réussi a tout découper, récupéré les noms de tables et attributs de chacune présente dans la bas, vérifié que les nom s des tables et attributs existent bien, j'ai aussi fait la fin du programme, c'est a dire envoyer la requete et recevoir et afficher le résultat. Il me manque plus que la transformation

Euh je vois pas trop le problème ..., moi je préconisais de récupérer les tables, les champs, mais aussi les restrictions. donc dance le cas que tu proposes dans le tableau restriction il y aurai ville="paris" et dans le tableau champ (champ a afficher) il y aurait nom donc en reconstruisant en sql je ne vois pas trop le problème.Si c'est la première restriction tu met where ... pour les autres tu met and ...

tu disais que ct la dernière projection qu'il fallait prendre en compte ben dans ce cas tu ne prend que les champs de la dernière projection... et les autres tu les utilises uniquement dans tes restrictions ou selections (j'ai jamais compris pourquoi ils ont appelé ca sélection sachant qu'en sql select c'est une projection m'enfin)...

Je sais pas si tu as bien compris ce que je voulais dire ... tiens moi au courant

J'ai une idée qui me tourne dans la tête ta méthode peut être aussi bonne mais je ne sais pas si tous les sgbd acceptent ce genre de requêtes sql, j'en ai fais je crois sur PostgreSQL. En fait il est possible pour reprendre ton exemple de faire des requêtes du style:

SELECT nom FROM (SELECT * FROM client WHERE ville="paris") R1;

Cela permettrait de traiter les requêtes une par une mais je ne sais pas si ca fonctionnerais aussi bien dans tous les types de requêtes , voilà ciao

utilise un filtre....

Pseudo-code :

Dim R1 as New Recordset
R1 = Conn.OpenRecordset ( "SELECT [NOM],[CP] FROM [VILLE]")
...
...
RS.Filter = "[CP] = '75015'"
RS.MoveFirst
Do Until RS.EOF
     ....
     RS.MoveNext
Loop

Renfield
Admin CodeS-SourceS - MVP Visual Basic

Salut DJ_FleX, salut Axel971, salut Renfield,

DJ_FleX, la technique d'Axel971 n'était pas mauvaise, mais elle n'est pas complètement compatible avec toutes les bases de données (Access, par exemple, n'exécutera pas un traitement de lots SQL me semble-t-il. Donc si tu fais 2 projections sans aucun lien entre elle, Access n'en exécutera qu'une!).

Renfield préconise de t'appuyer sur le moteur d'exécution du langage VB (et les objets d'accès aux données, bien entendu), et c'est, à mon avis aussi, un bon choix. Dans ton exemple R1 est un recordset résultant de la 1ère sélection, et il est la source de la projection suivante.

Mais c'est là qu'intervient une difficulté supplémentaire.

En effet, dans le cas d'une imbrication de plusieurs opérations algébriques, tu risques de retrouver avec des tas de curseurs (et autant de recordset) dans tous les sens, et une foison d'algorithmes à optimiser toi-même (tu perds l'optimisation native d'un moteur SQL, autant dire que tu perds beaucoup).

Il conviendrait mieux alors de, systématiquement, créer une table temporaire du résultat de tes opérations (à chacune d'entre elles). Et comme, ce n'est une sinécure en s'appuyant sur VB (problèmes d'ordre de création de règles d'intégrité sur toute la structure de la table, et taille du code à fournir), il te serait plutôt utile de demander à SQL de le faire (en implémentant tout le temps un INSERT INTO, pour chaque opération algébrique traduite). 
Ensuite, il ne reste, à ta charge, qu'une gestion des diverses tables temporaires créées par tes opérations, pour éviter que la base de données n'explose. Pour cela, tu pourrais gérer une entité transactionnelle qui encapsulerait un traitement de lots (un groupe d'opérations traduites), et affecter aux tables temporaires une durée de vie, une portée,une visibilité... (comme des variables).

Cependant, tu dis avoir conçu la partie exécution des requêtes SQL. Il est donc important que tu nous dises quel choix technique tu as retenu pour ce faire.

à+

rvblog^{n
Je veux ton bien... et je l'aurais... mais jamais avant la page 4}

Bonjour,

J'ai donc commencé l'intepréteur algébrique en langage SQL, voici ce que cela donne.
D'abord je donne ce sur quoi je me suis appuyé :
R1 = PROJECTION NOMTABLE (attribut, attribut2, etc)
R2 = SELECTION NOMTABLE (attribut = "truc" ET attribut2 = 3)
R3 = JOINTURE [NOMTABLE(NOMTABLE.propriété = NOMTABLE2.propriété)NOMTABLE]
R4 = UNION (TABLE1, TABLE2)
R5 = INTERSECTION (TABLE1, TABLE2)
R6 = DIFFERENCE (TABLE1, TABLE2)
R6 = MINUS (TABLE1, TABLE2)
R7 = PRODUIT (TABLE1, TABLE2)
R8 = COMPTE TABLE (Attribut)
R9 = CUMUL TABLE (Attribut)
R10 = MAX TABLE (Attribut)
R11 = MIN TABLE (Attribut)
R12 = MOY TABLE (Attribut)

J'ajoute que je suis débutant en la matière donc :$

Code :

Module Module1

Dim decoupage() AsString

Dim table() AsString

Dim sql AsString

Dim sql2 AsString

Dim intermede() AsString

Dim i AsInteger

Dim j AsInteger

Function tests(ByRef decoupage)

' Nous vérifions que l'une des entitées n'est pas un opérateur logique PAS, ET ou OU.

' Si c'est le cas nous le transformons en sont équivalent SQL.

If decoupage = "ET"Then

decoupage = " AND "

Else

If decoupage = "OU"Then

decoupage = " OR "

Else

If decoupage = "PAS"Then

decoupage = " NOT "

EndIf

EndIf

EndIf

' Ici nous nous occupons de remplacer les doubles quotes par de simple quote pour le langage SQL.

' S'il n'y en a pas, aucun effet sur la chaîne. S'il n'y en a qu'au début ou en fin de mot, alors on ne remplace que ce qui est nécessaire.

' NB : Cette fonction n'est disponible qu'après VB5, c'est à dire VB6 minimum. Il faut donc faire attention à ce que les autres modules utilisés

' ne soit pas utilisés dans une version antérieure.

decoupage = decoupage.Replace(Chr(34), "'")

EndFunction

Function proprietes(ByRef sql, ByRef intermede, ByRef decoupage)

i = decoupage.Length - 1

If i > 4 Then

j = 5

sql = String.Concat(sql, intermede(1))

sql = String.Concat(sql, " ")

While j < i

tests(decoupage(j))

sql = String.Concat(sql, decoupage(j))

sql = String.Concat(sql, " ")

j = j + 1

EndWhile

' decoupage(j) = etc)

intermede = Split(decoupage(j), ")")

' intermede(0) = etc

' intermede(1) = ""

'

' On remplace les doubles quotes par de simples quotes, ceci est utilisé dans le cas de la séléction.

intermede(0) = intermede(0).Replace(Chr(34), "'")

sql = String.Concat(sql, intermede(0))

Else

' intermede(0) = ""

' intermede(1) = attribut)

intermede = Split(intermede(1), ")")

' intermede(0) = attribut

' intermede(1) = ""

'

' On remplace les doubles quotes par de simples quotes, ceci est utilisé dans le cas de la séléction.

intermede(0) = intermede(0).Replace(Chr(34), "'")

sql = String.Concat(sql, intermede(0))

EndIf

EndFunction

Function proj(ByRef sql)

' R1 = PROJECTION TABLE (attribut, attribut2, etc)

' decoupage(3) = TABLE

' decoupage(4) = (attribut,

' decoupage(5) = attribut2,

' decoupage(6) = etc)

intermede = Split(decoupage(4), "(")

' intermede(0) = ""

' intermede(1) = attribut

proprietes(sql, intermede, decoupage)

sql = String.Concat(sql, " FROM ")

sql = String.Concat(sql, decoupage(3))

EndFunction

Function sel(ByRef sql)

' R2 = SELECTION TABLE (Prédicat1 = Nombre ET Prédicat2 = "Chaine")

' decoupage(3) = TABLE

' decoupage(4) = (Prédicat1

' deoupage(6) = Nombre

' decoupage(7) = ET

' decoupage(8) = Prédicat2

' decoupage(10) = "Chaîne")

intermede = Split(decoupage(4), "(")

sql = String.Concat(sql, intermede(1))

sql = String.Concat(sql, " FROM ")

sql = String.Concat(sql, decoupage(3))

sql = String.Concat(sql, (Chr(10) + Chr(13)))

sql = String.Concat(sql, "WHERE ")

proprietes(sql, intermede, decoupage)

EndFunction

Function join(ByRef sql)

Dim table2() AsString

'R3 = JOINTURE [TABLE1(TABLE1.Propriété1 = TABLE2.Propriété2)TABLE2]

' decoupage(3) : [TABLE1(TABLE1.Propriété1

' decoupage(4) : =

' decoupage(5) : TABLE2.Propriété2)TABLE2]

table = Split(decoupage(3), "(")

' table(0) : [TABLE1

' table(1) : TABLE1.Propriété1

intermede = Split(table(1), ".")

' intermede(0) = TABLE1

' intermede(1) = Propriété1

table = Split(decoupage(5), ")")

' table(0) : TABLE2.Propriété2

' table(1) : TABLE2]

table2 = Split(table(0), ".")

' table2(0) : TABLE2

' table2(1) : Propriété2

sql = String.Concat(sql, intermede(1))

sql = String.Concat(sql, ", ")

sql = String.Concat(sql, table2(1))

sql = String.Concat(sql, " FROM ")

sql = String.Concat(sql, intermede(0))

sql = String.Concat(sql, ", ")

sql = String.Concat(sql, table2(0))

sql = String.Concat(sql, (Chr(10) + Chr(13)))

sql = String.Concat(sql, "WHERE ")

sql = String.Concat(sql, intermede(1))

sql = String.Concat(sql, " ")

sql = String.Concat(sql, decoupage(4))

sql = String.Concat(sql, " ")

sql = String.Concat(sql, table2(1))

EndFunction

Function union(ByRef sql)

' Nous voudrions ceci : SELECT * FROM Table1

' union (SELECT * FROM Table2);

' R4 = UNION (TABLE1, TABLE2)

' decoupage(3) = (TABLE1,

' decoupage(4) = TABLE2)

sql = String.Concat(sql, "* FROM ")

table = Split(decoupage(3), "(")

' table(0) = ""

' table(1) = TABLE1,

intermede = Split(table(1), ",")

' intermede(0) = TABLE1

' intermede(1) = ""

sql = String.Concat(sql, intermede(0))

sql = String.Concat(sql, (Chr(10) + Chr(13)))

sql = String.Concat(sql, "UNION (SELECT * FROM ")

sql = String.Concat(sql, decoupage(4))

EndFunction

Function inter(ByRef sql)

' On voudrait ceci : SELECT DISTINCT Table1.* FROM Table1, Table2

' WHERE Table1.* = Table2.*;

' R5 = INTERSECTION (TABLE1, TABLE2)

' decoupage(3) = (TABLE1,

' decoupage(4) = TABLE2)

sql = String.Concat(sql, "DISTINCT ")

table = Split(decoupage(3), "(")

' table(0) = ""

' table(1) = TABLE1,

intermede = Split(decoupage(4), ")")

' intermede(0) = TABLE2

' intermede(1) = ""

sql2 = table(1).Replace(",", ".")

' sql2 = TABLE1.

sql = String.Concat(sql, sql2)

sql = String.Concat(sql, "* ")

sql = String.Concat(sql, " FROM ")

sql = String.Concat(sql, table(1))

sql = String.Concat(sql, intermede(0))

sql = String.Concat(sql, (Chr(10) + Chr(13)))

sql = String.Concat(sql, "WHERE ")

sql = String.Concat(sql, sql2)

sql = String.Concat(sql, "* = ")

sql = String.Concat(sql, intermede(0))

sql = String.Concat(sql, ".*")

EndFunction

Function diff(ByRef sql)

' On voudrait ceci : Select * From TABLE1 Where * Not In (Select * From TABLE2);

' R6 = DIFFERENCE (TABLE1, TABLE2)

' R6 = MINUS (TABLE1, TABLE2)

' decoupage(3) = (TABLE1,

' decoupage(4) = TABLE2)

sql = String.Concat(sql, "* FROM ")

table = Split(decoupage(3), "(")

' table(0) = ""

' table(1) = TABLE1,

table = Split(table(1), ",")

' table(0) = TABLE1

' table(1) = ""

sql = String.Concat(sql, table(0))

sql = String.Concat(sql, (Chr(10) + Chr(13)))

sql = String.Concat(sql, "WHERE * ")

sql = String.Concat(sql, "Not In (SELECT * FROM ")

sql = String.Concat(sql, decoupage(4))

EndFunction

Function prod(ByRef sql)

' On veut obtenir ceci : SELECT TABLE1.*, TABLE2.* FROM TABLE1, TABLE2

' Access ne sachant que faire, prendra les tuples de la TABLE1 et les associera à chaque fois aux tuples de la TABLE2

' de sorte que nous obtenions TABLE1 x TABLE2

' R7 = PRODUIT (TABLE1, TABLE2)

' decoupage(3) = (TABLE1,

' decoupage(4) = TABLE2)

table = Split(decoupage(3), "(")

' table(0) = ""

' table(1) = TABLE1,

intermede = Split(decoupage(4), ")")

' intermede(0) = TABLE2

' intermede(1) = ""

sql2 = table(1).Replace(",", ".")

' sql2 = TABLE1.

sql = String.Concat(sql, sql2)

sql = String.Concat(sql, "*, ")

sql = String.Concat(sql, intermede(0))

sql = String.Concat(sql, ".*")

sql = String.Concat(sql, " FROM ")

sql = String.Concat(sql, table(1))

sql = String.Concat(sql, " ")

sql = String.Concat(sql, intermede(0))

EndFunction

Function calcul(ByRef sql, ByRef sql2)

' Rx = OPERATEUR TABLE (Attribut)

' où x est un chiffre entre 8 et 12 (pour voir les exmemples donnés).

' Dans le fichier.txt ce peut être n'importe quel chiffre.

' découpage(3) = TABLE

' decoupage(4) = (Attribut)

sql = String.Concat(sql, sql2)

sql = String.Concat(sql, decoupage(4))

sql = String.Concat(sql, " FROM ")

sql = String.Concat(sql, decoupage(3))

EndFunction

Sub Main()

Dim algebre AsString

Console.WriteLine("Phrase : ")

algebre = Console.ReadLine()

decoupage = Split(algebre, " ")

sql = "SELECT "

SelectCase decoupage(2)

Case"PROJECTION"

' Syntaxe présumée : R1 = PROJECTION TABLE (attribut, attribut2, etc)

proj(sql)

Case"SELECTION"

' Syntaxe présumée : R2 = SELECTION TABLE (Prédicat1 = Nombre ET Prédicat2 = "Chaine")

sel(sql)

Case"JOINTURE"

' Syntaxe présumée : R3 = JOINTURE [TABLE1(TABLE1.Propriété1 = TABLE2.Propriété2)TABLE2]

join(sql)

Case"UNION"

' Syntaxe présumée : R4 = UNION (TABLE1, TABLE2)

union(sql)

Case"INTERSECTION"

' Syntaxe présumée : R5 = INTERSECTION (TABLE1, TABLE2)

inter(sql)

Case"DIFFERENCE"

' Syntaxe présumée : R6 = DIFFERENCE (TABLE1, TABLE2)

diff(sql)

Case"MINUS"

' Syntaxe présumée : R6 = MINUS (TABLE1, TABLE2)

diff(sql)

Case"PRODUIT"

' Syntaxe présumée : R7 = PRODUIT (TABLE1, TABLE2)

prod(sql)

Case"COMPTE"

' Syntaxe présumée : R8 = COMPTE TABLE (Attribut)

sql2 = "count"

calcul(sql, sql2)

Case"CUMUL"

' Syntaxe présumée : R9 = CUMUL TABLE (Attribut)

sql2 = "sum"

calcul(sql, sql2)

Case"MAX"

' Syntaxe présumée : R9 = CUMUL TABLE (Attribut)

sql2 = "max"

calcul(sql, sql2)

Case"MIN"

' Syntaxe présumée : R9 = CUMUL TABLE (Attribut)

sql2 = "min"

calcul(sql, sql2)

Case"MOY"

' Syntaxe présumée : R9 = CUMUL TABLE (Attribut)

sql2 = "avg"

calcul(sql, sql2)

EndSelect

sql = String.Concat(sql, ";")

MsgBox(sql, MsgBoxStyle.Information, "Salut")

EndSub

EndModule

Qu'en pensez vous ?

Salut,

Ca m'a l'air bien... mais n'étant pas un grand fana du basic , sinon ca fonctionne bien?

Bien je ne sais pas, mais cela fonctionne. On a une console DOS qui s'ouvre, demande une phrase, on écrit R1 = PROJECTION BUREAU (Attribut1, Attribut) par exemple, et lui il ressort SELECT Attribut1, Attribut FROM BUREAU;
Evidemment avant ce programme il en faut un autre qui vérifie la syntaxe, c'est pour cela que je montre la syntaxe sur laquelle je me suis basée, une seule faute d'espace et le programme plante lamentablement (du moins je crois, je me suis pas amusé à entrer des données fausses ...)