Reguläre Ausdrücke z.B. SQL

[ProgOldie]

Hallo,
ich habe mich schon etwas in reguläre Ausdrücke eingearbeitet. Die folgende Aufgabe ist aber zu hoch für mich, weshalb ich etwas Hilfe brauche.

Unter Verwendung der Schlüsselworte Select,From,Where (groß- und Kleinschreibung möglich) möchte ich aus einer Anfrage des Typs Select Spalten From Tabelle Where Bedingung
die Werte für Spalten,Tabelle,Bedingung erhalten.

Beispiel: SELECT Nachname, Vorname, Alter FrOm Personen WHeRE Alter > 12
sollte ergeben:
Spalten=Nachname, Vorname, Alter
Tabelle=Personen
Bedingung=Alter>12

Geht so etwas mit den Mitteln für reguläre Ausdrücke und wenn ja, wie?

[H.Brill]

Kommt auf die Datenbank an.
Für Oracle SQL : http://sql-plsql-de.blogspot.de/2009/02 ... nbank.html

Gibt's auch für MySQL. Einfach mal googlen.

[NicTheQuick]

Er will keine Datenbankabfrage mit regulären Ausdrücken erstellen, sondern einfach nur den String "SELECT Nachname, Vorname, Alter FrOm Personen WHeRE Alter > 12" aufdröseln in seine Bestandteile. Das ist wahrscheinlich nicht so schwer, aber ich hab PB grad nicht zur Hand um es zu testen. Solange du keine komplizierteren Ausdrücken damit auswerten willst, sollte das aber gehen.

[Kiffi]

wie Nic schon schrieb, ist es nicht so schwierig, wenn der Query einfach gehalten ist:

Code: Alles auswählen

EnableExplicit

Define Query.s
Define AnzahlToken, TokenCounter
Define Token.s
Define IsSpalte, IsTabelle, IsBedingung
Define SpaltenString.s, TabelleString.s, BedingungString.s

Query = "SELECT Nachname, Vorname, Alter FrOm Personen WHeRE Alter > 12"

AnzahlToken = CountString(Query, " ")

For TokenCounter = 1 To AnzahlToken + 1
  
  Token = StringField(Query, TokenCounter, " ")
  
  Select LCase(Token)
      
    Case "select"
      
      IsSpalte    = #True
      IsTabelle   = #False
      IsBedingung = #False
      
    Case "from"
      
      IsSpalte    = #False
      IsTabelle   = #True
      IsBedingung = #False
      
    Case "where"
      
      IsSpalte    = #False
      IsTabelle   = #False
      IsBedingung = #True
      
    Default
      
      If IsSpalte
        SpaltenString + Token
      ElseIf IsTabelle
        TabelleString + Token
      ElseIf IsBedingung
        BedingungString + Token
      EndIf
      
  EndSelect
  
Next

Debug "Spalten: " + SpaltenString
Debug "Tabelle: " + TabelleString
Debug "Bedingung: " + BedingungString

Grüße ... Peter

[ProgOldie]

Es ging mir um genau das, was Nick beschrieben hat, nämlich um eine Anwendung von Regulären Ausdrücken.
Dank an Kiffi für die gewissermaßen 'händische' Lösung. So etwas hatte ich auch schon probiert unter Verwendung von

Code: Alles auswählen

Procedure.i findkey(query.s,key.s)
  ;findet 'key', auch wenn es am Anfang oder am Ende steht
  ProcedureReturn FindString(" "+query+" "," "+key+" ",1,#PB_String_NoCase)
EndProcedure

Vielleicht kann mir doch noch jemand bei der Lösung mit reglären Ausdrücken helfen.

[NicTheQuick]

Erst mal eine Zwischenfrage. Sehen deine SQL-Ausdrücke immer genau so aus, oder kann auch sowas hier vorkommen:
"SELECT spalte1 AS user, spalte2 AS `from` FROM `where` WHERE spalte3 = CONCAT("id=", id);"
Spricht Spaltennamen und Tabellennamen, die so heißen wie die Schlüsselwörter, oder das AS-Schlüsselwort, oder Dinge wie CONCAT. Oder geht es wirklich nur um deine einfache Abfrage?

[ProgOldie]

Hallo Nick,
ich wollt zunächst nur 'mal einen Einstieg haben und habe dazu das simple Beispiel
SELECT Spalten From Tabelle Where Bedingung
gewählt.

Wenn das mit regulären Ausdrücken erst 'mal steht, kann ich mich vermutlich weiterhangeln.

[NicTheQuick]

Ich hätte es jetzt mal so gebaut:

Code: Alles auswählen

Define regex.i = CreateRegularExpression(#PB_Any, "SELECT\s+(\w+(\s*,\s*\w+)*)\s+FROM\s+(\w+)\s+WHERE\s+(.+);", #PB_RegularExpression_NoCase)

s.s = "select spalte1, spalte2, spalte3 from tabelle where bedingung = 1;"

Debug ExamineRegularExpression(regex, s)
Debug NextRegularExpressionMatch(regex)

Debug "Spalten: " + RegularExpressionGroup(regex, 1)
Debug "Tabelle: " + RegularExpressionGroup(regex, 3)
Debug "Bedingung: " + RegularExpressionGroup(regex, 4)

Ausgabe:

1
1
Spalten: spalte1, spalte2, spalte3
Tabelle: tabelle
Bedingung: bedingung = 1

Ich muss dazu sagen, dass ich das das erste mal so in Purebasic mache. Ich bin vor allem etwas verwirrt, dass ich Klammer auf und zu nicht escapen kann, sodass es nicht als Gruppierung benutzt wird. Weiß da jemand, wie das geht?

Edit 1
Auf diese Weise werden noch Leerzeichen am Ende vor dem ; ignoriert:

Code: Alles auswählen

Define regex.i = CreateRegularExpression(#PB_Any, "SELECT\s+(\w+(\s*,\s*\w+)*)\s+FROM\s+(\w+)\s+WHERE\s+(.+?)\s*;", #PB_RegularExpression_NoCase)

s.s = "select from from from where where = 1  ;"

Debug ExamineRegularExpression(regex, s)
Debug NextRegularExpressionMatch(regex)

Debug "Spalten: '" + RegularExpressionGroup(regex, 1) + "'"
Debug "Tabelle: '" + RegularExpressionGroup(regex, 3) + "'"
Debug "Bedingung: '" + RegularExpressionGroup(regex, 4) + "'"

[ProgOldie]

Danke, das ist mir schon 'mal eine gute Starthilfe!
Wenn das mit der Gruppierung noch klappen würde, könnte das sicher auch nicht schaden.

[ProgOldie]

Mit den Forums-Tipps habe ich das Ganze jetzt 'mal mit Gruppen gemacht. Dabei ist auch gleich eingebaut, dass die Where-Clausel fehlen kann. (Dann ist Sel="").

Code: Alles auswählen

EnableExplicit
Define.s Spaltenliste,Tabelle,Selection,queryFormat,query
Define.i regex

Spaltenliste="(?<Spalten>\s+(\w+(\s*,\s*\w+)*)\s+)"   ;mit vorhergehenden und nachgestellten Leerzeichen
Tabelle="(?<Tab>\w+)\s*"
Selection="(WHERE\s+(?<Sel>.+?)\s*){0,1};"            ;Where-Clausel kann auch fehlen, dann Sel=""

queryFormat="SELECT"+Spaltenliste+"FROM\s+"+Tabelle+Selection
regex= CreateRegularExpression(#PB_Any,queryFormat, #PB_RegularExpression_NoCase)

query= "select spalte1, spalte2, spalte3 from Personen where Spalte2=1 ;                                    ;"

Debug ExamineRegularExpression(regex, query)

While NextRegularExpressionMatch(regex)
  Debug "Spaltenliste:" + RegularExpressionNamedGroup(regex, "Spalten")
  Debug "Tab:" + RegularExpressionNamedGroup(regex, "Tab")
  Debug "Sel:" + RegularExpressionNamedGroup(regex, "Sel")
Wend

Fazit: Reguläre Ausdrücke in PB sind eine feine, wenn auch gewöhnungsbedürftige Sache.

Edit1: Ich habe die Variablenbezeichner etwas geändert, damit es verständlicher wird