Dies ist die alte 4D Dokumentations-Website. Die neue und aktualisierte Dokumentation finden Sie unter developer.4d.com

Home

 
4D v19.8
dataClass.query()

dataClass.query() 


 

dataClass.query() ( queryString | formula {; value}{; value2 ; ... ; valueN}{; querySettings}) -> Funktionsergebnis 
Parameter Typ   Beschreibung
queryString | formula  Text, Objekt in Suchkriterium als String oder Formel Objekt
value  Mixed in Wert(e) zum Vergleichen bei Platzhalter(n)
querySettings  Objekt in Suchoptionen: parameters, attributes, arg, allowFormulas, context, queryPath, queryPlan
Funktionsergebnis  EntitySelection in Neue Entity-Selection mit den Entities der dataClass, die zum Suchkriterium passen

Die Methode dataClass.query() sucht für alle Entities in der DataClass nach Entities, welche die in queryString oder formula und (optional) value angegebenen Suchkriterien erfüllen, und gibt ein neues Objekt vom Typ EntitySelection zurück, das alle gefundenen Entities der DataClass enthält. Lazy loading wird angewendet.

Werden keine passenden Entities gefunden, wird eine leere EntitySelection zurückgegeben.

Der Parameter queryString verwendet folgende Syntax:

attributePath|formula comparator value {logicalOperator attributePath|formula comparator value} {order by attributePath {desc | asc}}

Definitionen:

    • attributePath: Name des Dataclass Attributs, in dem Sie die Suche ausführen wollen. Das kann ein einfacher Name, z.B. "country" oder ein gültiger Attributspfad sein, z.B. "country.name". Bei einem Attributspfad vom Typ Collection verwenden Sie eckige Klammern [ ] zum Verwalten aller Vorkommen, z.B. "children[ ].age". Sie können auch einen Platzhalter verwenden (siehe unten)

      Hinweis: Sie können nicht nach Attributen suchen, die im Namen Sonderzeichen, wie "." "[ ]" oder "=", ">", "#" enthalten, da sie im Such-String nicht korrekt gewertet werden. Für solche Fälle müssen Sie Platzhalter verwenden. Weitere Informationen dazu finden Sie im unteren Abschnitt Platzhalter verwenden

    • formula: Eine gültige Formel (siehe Formel), als Text oder Objekt übergeben. Die Formel wird für jede bearbeitete Entity(*) gewertet und muss einen boolean Wert zurückgeben. Innerhalb der Formel ist die Entity über das Objekt This verfügbar.  
      • Text: Der Formel als String muss die Anweisung eval() vorangestellt werden, damit der Suchlauf den Ausdruck korrekt bewertet. Zum Beispiel: 
         "eval(length(This.lastname) >=30)"
      • Objekt: Die Formel als Objekt wird als Platzhalter übergeben (siehe unten). Die Formel muss mit dem Befehl Formula oder Formula from string erstellt worden sein. 

(*) Ist die Formel nicht das einzige Suchkriterium, priorisiert der Optimierer der Such-Engine u.U. andere Kriterien, wie z.B. indizierte Attribute, so dass die Formel nur für eine Teilmenge der Entities gewertet wird.

Formeln in Suchen können Parameter über $1 empfangen. Weitere Informationen dazu finden Sie im unteren Abschnitt Parameter formula.

Hinweise: 
- Sie können 
anstelle des Parameters queryString auch direkt den Parameter formula übergeben (wird bei komplexeren Formeln empfohlen). Siehe unteren Abschnitt Parameter formula
- Aus Sicherheitsgründen können Formelaufrufe innerhalb von Member-Methods query() nicht erlaubt sein. Weitere Informationen dazu finden Sie unter dem Parameter querySettings

  • comparator: Symbol zum Vergleichen von attributePath und value. Es gibt folgende Symbole:
    VergleichSymbol(e)Kommentar
    Ist gleich =, ==Erhält passende Daten, unterstützt den Joker @, berücksichtigt weder Groß- und Kleinschreibung noch diakritische Zeichen.
    ===, ISErhält passende Daten, bewertet @ als Standardzeichen, berücksichtigt weder Groß- und Kleinschreibung noch diakritische Zeichen.
    Ungleich zu#, !=unterstützt den Joker (@)
    !==, IS NOTbewertet @ als Standardzeichen
    Kleiner als <
    Größer als >
    Kleiner als oder gleich <=
    Größer als oder gleich >=
    Enthalten inINErhält Daten, die mit mindestens einem Wert in einer Collection bzw. einem Satz Werte übereinstimmen, unterstützt den Joker (@)
    Nicht enthalten in einer AnweisungNOTKlammern sind zwingend, wenn NOT vor einer Anweisung mit mehreren Operatoren verwendet wird
    Enthält Schlüsselwort%Schlüsselwörter lassen sich in Attributen vom Typ String oder Bild verwenden
  • value: Wert zum Vergleichen mit dem aktuellen Wert der Eigenschaft jeder Entity in der Entity-Selection oder Element in der Collection. Das kann ein Platzhalter (siehe Absatz unten Platzhalter verwenden) oder jeder Ausdruck vom gleichen Datentyp wie die Eigenschaft sein. Bei Werten von Konstanten gelten folgende Regeln:
    • Konstanten vom Typ Text können mit oder ohne einfache Anführungszeichen übergeben werden (siehe unten Anführungszeichen verwenden). Für eine Suche innerhalb eines anderen String (eine Suche "Enthalten in") verwenden Sie den Joker (@) in value, um den zu suchenden String zu isolieren, zum Beispiel: "@Smith@". Die Schlüsselwörter truefalse sind verboten.
    • Konstanten vom Typ Booleantrue oder false (unterscheiden zwischen Groß- und Kleinschreibung).
    • Konstanten vom Typ Zahl: der Punkt dient als Dezimaltrenner.
    • Konstanten vom Typ Datum: Es gilt das Format YYYY-MM-DD
    • Null Konstante: Die Suche mit dem Schlüsselwort "null" findet die Eigenschaften null und undefined.  
    • Bei einer Suche mit einem IN Vergleichsoperator muss value eine Collection sein bzw. Werte, die zum Typ des Attributspfads zwischen eckigen Klammern [] passen, getrennt durch Kommas (bei Strings müssen Anführungszeichen " mit "\" abschließen)
  • logicalOperator: verbindet mehrere Bedingungen in der Suche (optional). Es gibt folgende logische Operatoren (Sie können Name oder Symbol übergeben):
    KonjunktionSymbol(e)
    AND&, &&, and
    OR|, ||, or


  • order by attributePath: Sie können eine Anweisung order by attributePath in der Suche hinzufügen, so dass die Ergebniswerte sortiert werden. Sie können mehrere Sortieranweisungen, durch Komma getrennt, verwenden, (z.B. order by attributePath1 desc, attributePath2 asc). Die Sortierung ist standardmäßig aufsteigend. Übergeben Sie 'desc' für absteigende Reihenfolge und 'asc' für aufsteigende Reihenfolge.
    Hinweis: Mit dieser Anweisung wird die zurückgegebene Entity Selection sortiert. Weitere Informationen dazu finden Sie im Abschnitt Sortierte vs unsortierte Entity-Selections). 

Anführungszeichen verwenden
Innerhalb der Suche müssen Sie einfache Anführungszeichen ' ' setzen, doppelte Anführungszeichen " " verwenden Sie zum Umrahmen der gesamten Suche. Andernfalls wird ein Fehler generiert. Zum Beispiel:

"employee.name = 'smith' AND employee.firstname = 'john'"

Hinweis: Einzelne Anführungszeichen, z.B. ein Apostroph, werden in gesuchten Werten nicht unterstützt, da sie den Suchstring unterbrechen. So erzeugt die Suche "comp.name = 'John's pizza' " einen Fehler. Für solche Fälle sollten Sie Platzhalter verwenden (siehe unten).

Klammern verwenden
Mit Klammern in einer Suche können Sie Prioritäten beim Berechnen setzen. Zum Beispiel:

"(employee.age >= 30 OR employee.age <= 65) AND (employee.salary <= 10000 OR employee.status = 'Manager')"

Alternativ zum Einfügen einer Formel im Parameter queryString (siehe oben) können Sie ein Objekt formula direkt als boolean Suchkriterium übergeben. Wir empfehlen für Suchen das Objekt formula, da sie tokenisiert ist und Code leichter zu suchen/lesen ist. 

Die Formel muss mit dem Befehl Formula oder Formula from string erstellt werden. In diesem Fall:

  • Wird formula für jede Entity bewertet und muss wahr oder falsch zurückgeben. Ist das Ergebnis der Formel während dem Suchlauf kein boolean, wird es als falsch gewertet.
  • Die Entity in formula ist über das Objekt This verfügbar.  
  • Ist das Objekt formula null, wird der Fehler 1626 generiert ("Text oder Formel wird erwartet"). Sie können den Fehler mit einer Methode abfangen, installiert mit dem Befehl ON ERR CALL.

Hinweis: Aus Sicherheitsgründen können innerhalb von Member-Methods query() Formelaufrufe nicht erlaubt sein. Weitere Informationen dazu finden Sie unter dem Parameter querySettings

Parameter an Formeln übergeben

Jede von der Member-Method query() aufgerufene formula kann Parameter empfangen:

  • Parameter müssen über die Eigenschaft (Objekt) args des Parameters querySettings übergeben werden.
  • Die Formel empfängt dieses Objekt args als Parameter $1.

Dieser kurze Code zeigt, wie Parameter an Methoden übergeben werden:

 $settings:=New object("args";New object("exclude";"-")) //args Objekt zum Übergeben von Parametern
 $es:=ds.Students.query("eval(checkName($1.exclude))";$settings//args wird in $1 empfangen

Weitere Anwendungen finden Sie unter Beispiel 3.

4D Server: In der Client/Server-Architektur werden Formeln auf dem Server ausgeführt. In diesem Kontext wird nur das Objekt querySettings.args an die Formeln gesendet.

Sie können im Parameter queryString Platzhalter für die Argumente attributePath, formula und value verwenden. Platzhalter sind Tags, die Sie in Suchstrings einfügen und die beim Bewerten durch einen anderen Wert ersetzt werden. Der Wert von Platzhaltern wird einmal am Anfang bewertet; er wird nicht für jedes Element bewertet.

Es gibt zwei Arten von Platzhaltern: Platzhalter als Index und Platzhalter als Name:

-Platzhalter als IndexPlatzhalter als Name
DefinitionParameter werden eingefügt als :paramIndex (z.B. :1, :2...) in queryString und ihre Werte werden als Sequenz der Parameter value geliefert. Sie können bis zu 128 Parameter value verwendenParameter werden eingefügt als :paramName (z.B. :myparam) und ihre Werte werden in den Objekten Attribute bzw. Parameter in querySettings geliefert.
Beispiel
 $r:=class.query(":1=:2";"city";"Chicago")
 $o.attributes:=New object("att";"city")
 $o.parameters:=New object("name";"Chicago")
 $r:=class.query(":att=:name";$o)

Sie können in queryString alle Argumentarten miteinander mischen. queryString kann für die Parameter attributePath, formula und value folgendes enthalten:

  • direkte Werte (keine Platzhalter), 
  • Platzhalter als Index bzw. Platzhalter als Name

Platzhalter in Suchen werden aus folgenden Gründen empfohlen:

  1. Verhindert Einfügen von böswilligem Code: Verwenden Sie direkt von Benutzern gefüllte Variablen im Suchstring, könnte ein Benutzer die Suchbedingungen durch Einfügen zusätzlicher Suchargumente verändern. Nehmen wir beispielsweise folgenden Suchstring:
     $vquery:="status = 'public' & name = "+myname //Benutzer gibt Namen ein
     $result:=$col.query($vquery)

    Diese Suche scheint abgesichert, da nicht-öffentliche Daten gefiltert werden. Gibt der Benutzer jedoch im Bereich myname etwas ein wie OR status='private', wäre der Suchstring beim Interpretieren verändert und könnte private Daten zurückgeben.
    Mit Platzhaltern ist ein Überschreiben der Sicherheitsbedingungen nicht möglich:
     $result:=$col.query("status='public' & name=:1";$myname)

    Gibt der Benutzer hier OR status='private' im Bereich myname ein, wird das im Suchstring nicht interpretiert, sondern nur als Wert übergeben. Die Suche nach einer Person mit Namen "smith OR status='private'" schlägt einfach fehl.

  2. Sie müssen sich nicht um Probleme mit Formatierung oder Zeichen kümmern, insbesondere wenn die Parameter attributePath und value nicht-alphanumerische Zeichen wie ".", "[' enthalten.

  3. Sie können Variablen oder Ausdrücke in Suchargumenten verwenden. Beispiele:
     $result:=$col.query("address.city = :1 & name =:2";$city;$myVar+"@")
     $result2:=$col.query("company.name = :1";"John's Pizzas")

Nach Nullwerten suchen
Beim Suchen nach Nullwerten können Sie keine Syntax mit Platzhaltern verwenden, da die Such-Engine Null als einen unerwarteten Vergleichswert betrachtet. Führen Sie beispielsweise folgende Suche aus:

 $vSingles:=ds.Person.query("spouse = :1";Null// funktioniert NICHT

erhalten Sie nicht das erwartete Ergebnis, da der Nullwert von 4D als ein Fehler gewertet wird, der sich aus der Bewertung des Parameters ergibt (z.B. ein Attribut aus einer anderen Suche). Für derartige Suchen müssen Sie die direkte Suchsyntax verwenden:
 $vSingles:=ds.Person.query("spouse = null") //korrekte Syntax

Bei der Suche in Collections in Objektattributen mit mehreren per UND Operator verbundenen Suchkriterien wollen Sie sicherstellen, dass nur Entities mit Elementen zurückgegeben werden, auf die alle Kriterien passen und keine Entities mit Kriterien in verschiedenen Elementen. Dazu müssen Sie die Suchkriterien mit Collection-Elementen verknüpfen, damit nur solche Elemente mit verknüpften Kriterien gefunden werden.

Nehmen wir z.B. folgende Entities: 

Entity 1:
ds.People.name: "martin"
ds.People.places: 
    { "locations" : [ {
                "kind":"home",
                "city":"paris" 
            } ] }

Entity 2:
ds.People.name: "smith"
ds.People.places: 
    { "locations" : [ {
                "kind":"home",
                "city":"lyon" 
            } , {
                "kind":"office",
                "city":"paris" 
            } ] }

Sie wollen Personen mit dem Element locations "home" in der Stadt "paris" finden.  Schreiben Sie:

 ds.People.query("places.locations[].kind= :1 and places.locations[].city= :2";"home";"paris")

... gibt die Suche "martin" und "smith" zurück, da in der Entity "smith" das Element locations "kind" den Wert "home" und das Element locations "city" den Wert "paris" hat, auch wenn es unterschiedliche Elemente sind.

Wollen Sie nur Entities mit den passende Kriterien im gleichen Element der Collection erhalten, müssen Sie Kriterien verknüpfen. Dazu machen Sie folgendes:

  • Sie fügen im ersten Pfad zum Verknüpfen einen Buchstaben in die [] ein und wiederholen diesen in allen verknüpften Kriterien, also locations[a].city und locations[a].kind. Sie können jeden Buchstaben des lateinischen Alphabets verwenden (keine Unterscheidung zwischen Groß- und Kleinschreibung).
  • Für ein anderes verknüpftes Kriterium in derselben Suche verwenden Sie einen anderen Buchstaben. Sie können in einer Suche bis zu 26 Kombinationen von Kriterien verwenden. 

Schreiben Sie jetzt:

 ds.People.query("places.locations[a].kind= :1 and places.locations[a].city= :2";"home";"paris")

... gibt die Suche nur "martin" zurück, denn hier hat im Element locations "kind" den Wert "home" und "city" den Wert "paris". Die Suche gibt dagegen nicht "smith" zurück, da die Werte "home" und "paris" nicht im gleichen Element der Collection sind.

Im Parameter querySettings können Sie ein Objekt mit zusätzlichen Optionen übergeben. Es gibt folgende Eigenschaften:

EigenschaftTypBeschreibung
parametersObjektPlatzhalter mit Namen für Werte in queryString. Werte werden als property / value Paare ausgedrückt, wobei property der Platzhaltername für einen Wert in queryString (":placeholder") ist und value der zu vergleichende Wert. Sie können Platzhalter als Index (Werte werden direkt in Parametern value übergeben) und Platzhalter als Name in derselben Suche mischen.
attributesObjektPlatzhalter mit Namen für Attributpfade in queryString. Attribute werden als property / value Paare ausgedrückt, wobei property der Platzhaltername für einen Attributpfad in queryString (":placeholder") ist und value ein String oder eine Collection von Strings sein kann. Jeder value ist ein Pfad, der entweder ein skalares oder relationales Attribut der Dataclass oder eine Eigenschaft in einem Objekfeld der Dataclass angibt
TypBeschreibung
StringattributePath ausgedrückt mit der Objektnotation, z.B. "name" oder "user.address.zipCode"
Collection von StringsJeder String der Collection stellt eine Ebene von attributePath dar, z.B. ["name"] oder ["user","address","zipCode"]. Über eine Collection können Sie nach Attributen mit Namen suchen, die nicht mit der Objektnotation kompatibel sind , z.B. ["4Dv17.1","en/fr"]
Sie können Platzhalter als Index (Werte werden direkt in Parametern value übergeben) und Platzhalter als Name in derselben Suche mischen.
argsObjektParameter zur Übergabe an Formeln, sofern vorhanden. Das Objekt args wird in Formeln in $1 empfangen und so sind seine Werte über die property $1 verfügbar (siehe Beispiel 3). 
allowFormulasBooleanWahr, um Formelaufrufe in der Suche zu erlauben (standard). Falsch, um keine Formelaufrufe zu erlauben. Ist falsch gesetzt und erhält query() eine Formel, wird ein Fehler gesendet (1278 - Formel ist in dieser Member-Method nicht erlaubt).
contextTextBezeichnung des automatischen Optimierungskontexts für die Entity-Selection. Diesen Kontext verwendet der Code beim Verwalten der Entity-Selection, so dass sie von der Optimierung profitiert. Dieses Feature wurde für den Client/Server Betrieb eingerichtet. Weitere Informationen dazu finden Sie im Abschnitt Client/Server Optimierung.
queryPlanBooleanGibt in der resultierenden Entity Collection direkt vor der Ausführung die ausführliche Beschreibung der Suche zurück oder nicht, z.B. die geplante Suche. Die zurückgegebene Eigenschaft ist ein Objekt mit jeder geplanten Suche und untergeordneten Suchen bei komplexen Suchläufen. Diese Option ist während der Entwicklungsphase einer Anwendung hilfreich und wird in der Regel zusammen mit queryPath verwendet. Standard wenn weggelassen: false. Hinweis: Dieser Parameter wird nur von den Methoden entitySelection.query() und dataClass.query() unterstützt.
queryPathBooleanGibt in der resultierenden Entity Collection die ausführliche Beschreibung der aktuell durchgeführten Suche zurück oder nicht. Die zurückgegebene Eigenschaft ist ein Objekt mit dem aktuellen Pfad für die Suche (in der Regel identisch mit queryPlan, kann unterschiedlich sein, wenn die Engine die Suche optimiert), sowie Bearbeitungszeit und die Anzahl der gefundenen Datensätze. Diese Option ist während der Entwicklungsphase einer Anwendung hilfreich. Standard wenn weggelassen: false. Hinweis: Dieser Parameter wird nur von den Methoden entitySelection.query() und dataClass.query() unterstützt.

Über queryPlan und queryPath
Die in queryPlan/queryPath gespeicherten Angaben enthalten den Suchtyp (indiziert und sequentiell) und jede notwendige Untersuche zusammen mit den Verbindungsoperatoren. Suchpfade enthalten auch die Anzahl der gefundenen Entities und die erforderliche Zeit zum Ausführen jedes Suchkriteriums. Das sind nützliche Informationen, die Sie beim Entwickeln Ihrer Anwendung analysieren können. Die Beschreibung des Suchplans und seines Pfads sind im allgemeinen identisch. Sie können u.U. unterschiedlich sein, da 4D beim Ausführen der Suche dynamische Optimierungen zum Verbessern der Performance einfügen kann. Die 4D Engine kann z.B. dynamisch eine indizierte Suche in eine sequentielle umwandeln, wenn sie diese für schneller hält. Das kann bei geringer Anzahl der gesuchten Entities der Fall sein.

Führen Sie beispielsweise folgende Suche aus:

 $sel:=ds.Employee.query("salary < :1 and employer.name = :2 or employer.revenues > :3";50000;"Lima West Kilo";10000000;New object("queryPath";True;"queryPlan";True))

queryPlan:

{Or:[{And:[{item:[index : Employee.salary ] < 50000},{item:Join on Table : Company  :  Employee.employerID = Company.ID,subquery:[{item:[index : Company.name ] = Lima West Kilo}]}]},{item:Join on Table : Company  :  Employee.employerID = Company.ID,subquery:[{item:[index : Company.revenues ] > 10000000}]}]}

queryPath:

{steps:[{description:OR,time:63,recordsfounds:1388132,steps:[{description:AND,time:32,recordsfounds:131,steps:[{description:[index : Employee.salary ] < 50000,time:16,recordsfounds:728260},{description:Join on Table : Company  :  Employee.employerID = Company.ID,time:0,recordsfounds:131,steps:[{steps:[{description:[index : Company.name ] = Lima West Kilo,time:0,recordsfounds:1}]}]}]},{description:Join on Table : Company  :  Employee.employerID = Company.ID,time:31,recordsfounds:1388132,steps:[{steps:[{description:[index : Company.revenues ] > 10000000,time:0,recordsfounds:933}]}]}]}]}

Hier sehen Sie verschiedene Beispiele für Suchen.

Suche nach String:

 $entitySelection:=ds.Customer.query("firstName = 'S@'")

Suche mit einer Anweisung NOT:

 $entitySelection:=ds.Employee.query("not (firstName=Kim)")

Suche mit einem Datum:

 $entitySelection:=ds.Employee.query("birthDate > :1";"1970-01-01")
 $entitySelection:=ds.Employee.query("birthDate <= :1";Current date-10950)

Suche mit Platzhaltern als Index für Werte:

 $entitySelection:=ds.Customer.query("(firstName = :1 or firstName = :2) and (lastName = :3 or lastName = :4)";"D@";"R@";"S@";"K@")

Suche mit Platzhaltern als Index für Werte in einer verknüpften dataClass:

 $entitySelection:=ds.Employee.query("lastName = :1 and manager.lastName = :2";"M@";"S@")

Suche mit Platzhaltern als Index mit Werten in absteigender Reihenfolge:

 $entitySelection:=ds.Student.query("nationality = :1 order by campus.name desc, lastname";"French")

Suche mit Platzhaltern als Name für Werte:

 C_OBJECT($querySettings;$managedCustomers)
 $querySettings:=New object
 $querySettings.parameters:=New object("userId";1234;"extraInfo";New object("name";"Smith"))
 $managedCustomers:=ds.Customer.query("salesperson.userId = :userId and name = :extraInfo.name";$querySettings)

Suche mit Platzhaltern als Name und als Index für Werte:

 C_OBJECT($querySettings;$managedCustomers)
 $querySettings:=New object
 $querySettings.parameters:=New object("userId";1234)
 $managedCustomers:=ds.Customer.query("salesperson.userId = :userId and name=:1";"Smith";$querySettings)

Suche mit queryPlan und queryPath Objekten:

 $entitySelection:=ds.Employee.query("(firstName = :1 or firstName = :2) and (lastName = :3 or lastName = :4)";"D@";"R@";"S@";"K@";New object("queryPlan";True;"queryPath";True))
 
  //Sie können dann diese Eigenschaften in der resultierenden Entity-Selection erhalten
 C_OBJECT($queryPlan;$queryPath)
 $queryPlan:=$entitySelection.queryPlan
 $queryPath:=$entitySelection.queryPath

Suche mit einem Attributspfad vom Typ Collection:

 $entitySelection:=ds.Employee.query("additionalInfo.hobbies[].name = horsebackriding")

Suche mit einem Attributspfad vom Typ Collection und verknüpften Attributen:

 $entitySelection:=ds.Employee.query("extraInfo.hobbies[a].name = :1 and extraInfo.hobbies[a].level=:2";"horsebackriding";2)

Suche mit einem Attributspfad vom Typ Collection und mehreren verknüpften Attributen:

 $entitySelection:=ds.Employee.query("extraInfo.hobbies[a].name = :1 and extraInfo.hobbies[a].level = :2 and extraInfo.hobbies[b].name = :3 and extraInfo.hobbies[b].level = :4";"horsebackriding";2;"Tennis";5)

Suche mit einem Attributspfad vom Typ Object:

 $entitySelection:=ds.Employee.query("extra.eyeColor = :1";"blue")

Suche mit einer Anweisung IN:

 $entitySelection:=ds.Employee.query("firstName in :1";New collection("Kim";"Dixie"))

Suche mit einer Anweisung NOT (IN):

 $entitySelection:=ds.Employee.query("not (firstName in :1)";New collection("John";"Jane"))

Suche mit Platzhaltern als Index für Attribute:

 C_OBJECT($es)
 $es:=ds.Employee.query(":1 = 1234 and :2 = 'Smith'";"salesperson.userId";"name")
  //salesperson ist eine verknüpfte Entity

Suche mit Platzhaltern als Index für Attribute und Platzhaltern als Name für Werte: 

 C_OBJECT($es;$querySettings)
 $querySettings:=New object
 $querySettings.parameters:=New object("customerName";"Smith")
 $es:=ds.Customer.query(":1 = 1234 and :2 = :customerName";"salesperson.userId";"name";$querySettings)
  //salesperson ist eine verknüpfte Entity

Suche mit Platzhaltern als Index für Attribute und Werte: 

 C_OBJECT($es)
 $es:=ds.Clients.query(":1 = 1234 and :2 = :3";"salesperson.userId";"name";"Smith")
  //salesperson ist eine verknüpfte Entity

Dieses Beispiel zeigt Suchen mit Platzhaltern mit Namen für Attribute. 

Vorgegeben ist eine Dataclass Employee mit 2 Entities:

  • Entity 1:
    name: "Marie"
    number: 46
    softwares:{
    "Word 10.2": "Installed",
    "Excel 11.3": "To be upgraded",
    "Powerpoint 12.4": "Not installed"
    }
  • Entity 2
    name: "Sophie"
    number: 47
    softwares:{
    "Word 10.2": "Not installed",
    "Excel 11.3": "To be upgraded",
    "Powerpoint 12.4": "Not installed" 
    }

Suche mit Platzhaltern mit Namen für Attribute:

 C_OBJECT($querySettings;$es)
 $querySettings:=New object
 $querySettings.attributes:=New object("attName";"name";"attWord";New collection("softwares";"Word 10.2"))
 $es:=ds.Employee.query(":attName = 'Marie' and :attWord = 'Installed'";$querySettings)
  //$es.length=1 (Employee Marie)

Suche mit Platzhaltern mit Namen für Attribute und Werte: 

 C_OBJECT($es;$querySettings)
 C_TEXT($name)
 $querySettings:=New object
  //Platzhalter mit Namen für Werte
  //Der Benutzer wird nach einem Namen gefragt
 $name:=Request("Please enter the name to search:")
 If(OK=1)
    $querySettings.parameters:=New object("givenName";$name)
  //Platzhalter mit Namen für Attributpfade
    $querySettings.attributes:=New object("attName";"name")
    $es:=ds.Employee.query(":attName= :givenName";$querySettings)
 End if

Diese Beispiele zeigen verschiedene Wege, um Formeln mit oder ohne Parameter in Ihren Suchen zu verwenden:

Die Formel ist als Text mit eval() im Parameter queryString vorgegeben:

 C_OBJECT($es)
 $es:=ds.Students.query("eval(length(This.lastname) >=30) and nationality='French'")

Die Formel ist als Objekt über Platzhalter vorgegeben:

 C_OBJECT($es;$formula)
 $formula:=Formula(Length(This.lastname)>=30)
 $es:=ds.Students.query(":1 and nationality='French'";$formula)

Nur ein Objekt Formula ist als Kriterium vorgegeben:

 C_OBJECT($es;$formula)
 $formula:=Formula(Length(This.lastname)>=30)
 $es:=ds.Students.query($formula)

Es lassen sich mehrere Formeln anwenden:

 C_OBJECT($formula1;$1;$formula2;$0)
 $formula1:=$1
 $formula2:=Formula(Length(This.firstname)>=30)
 $0:=ds.Students.query(":1 and :2 and nationality='French'";$formula1;$formula2)

Eine Formel als Text in queryString empfängt einen Parameter:

 C_OBJECT($es;$settings)
 $settings:=New object()
 $settings.args:=New object("filter";"-")
 $es:=ds.Students.query("eval(checkName($1.filter)) and nationality=:1";"French";$settings)

  //checkName method:
 C_TEXT($1;$exclude)
 $exclude:=$1
 $0:=(Position($exclude;This.lastname)=0)

Ein Objekt Formula als Platzhalter empfängt mit derselben Methode checkName einen Parameter:

 C_OBJECT($es;$settings;$formula)
 $formula:=Formula(checkName($1.filter))
 $settings:=New object()
 $settings.args:=New object("filter";"-")
 $es:=ds.Students.query(":1 and nationality=:2";$formula;"French";$settings)
 $settings.args.filter:="*" // change the parameters without updating the $formula object
 $es:=ds.Students.query(":1 and nationality=:2";$formula;"French";$settings)

Keine Formeln zulassen, z.B. wenn der Benutzer eine Suche eingibt:

 C_OBJECT($es;$settings)
 C_TEXT($queryString)
 $queryString:=Request("Enter your query:")
 if(OK=1)
    $settings:=New object("allowFormulas";False)
    $es:=ds.Students.query($queryString;$settings//Enthält $queryString eine Formel, wird ein Fehler generiert
 End if



Siehe auch 

4D Blog - Add values to your generic orda queries
4D Blog - Placeholders for attribute paths in ORDA queries
collection.query( )
dataClass.all()
dataClass.newSelection()
DESCRIBE QUERY EXECUTION
entitySelection.query()
entitySelection.queryPath
entitySelection.queryPlan
GET QUERY DESTINATION
QUERY
SET QUERY DESTINATION

 
EIGENSCHAFTEN 

Produkt: 4D
Thema: ORDA - DataClass

Dieser Befehl ändert die Systemvariable Error

 
SEITENINHALT 
 
GESCHICHTE 

Erstellt: 4D v17
Geändert: 4D v17 R5
Geändert: 4D v17 R6

 
ARTIKELVERWENDUNG

4D Programmiersprache ( 4D v19)
4D Programmiersprache ( 4D v19.1)
4D Programmiersprache ( 4D v19.4)
4D Programmiersprache ( 4D v19.5)
4D Programmiersprache ( 4D v19.6)
4D Programmiersprache ( 4D v19.7)
4D Programmiersprache ( 4D v19.8)