     QL(IQL)                      DABA 16                      QL(IQL)

     NAME
          ql - DABA-Anfragesprache (Query Language)

     BESCHREIBUNG
          Das Folgende ist eine Beschreibung  der  allgemeinen  Syntax
          von  QL.  Die einzelnen Anweisungen der QL und die einzelnen
          Monitor- Kommandos sind als separate Komponentenbeschreibun-
          gen  dieses  Handbuches aufgefuehrt.  Die vorliegende Kompo-
          nentenbeschreibung erlaeutert lexikalische Klassen  und  ha-
          eufiger  verwendete  syntaktische  Einheiten,  aus denen die
          Teile der QL Anweisungen gebildet werden.

          1. Kommentare
          -------------

          Ein Kommentar ist eine beliebig gewaehlte Folge von Zeichen,
          die links durch "/*" und rechts durch "*/" begrenzt werden.

          /* Das ist ein Kommentar */




          2. Namen
          --------

          Namen in QL sind Folgen von maximal 12 alphanumerischen Zei-
          chen  (Buchstaben und Ziffern), die mit einem Buchstaben be-
          ginnen.  Das Unterstreichungszeichen (_) gilt als Buchstabe.
          Alle  verwendeten  Grossbuchstaben, ausser in Zeichenketten,
          werden automatisch und stillschweigend in die ihnen entspre-
          chenden Kleinbuchstaben umgewandelt.

          3. Schluesselwoerter
          ------------------

          Die folgenden Zeichenfolgen sind als Schluesselwoerte reser-
          viert und duerfen nicht anderweitig (z.B. fuer Identifikato-
          ren, Namen oder andere Bezeichner benutzt werden):

          [4m     abs                 all                 and[0m
          [4m     any                 append              ascii[0m
          [4m     at                  atan                avg[0m
          [4m     avgu                by                  concat[0m
          [4m     copy                cos                 count[0m
          [4m     countu              create              dba[0m
          [4m     define              delete              destroy[0m
          [4m     distribute          exp                 float4[0m
          [4m     float8              from                help[0m
          [4m     in                  index               integrity[0m
          [4m     int1                int2                int4[0m
          [4m     int4                integrity           into[0m
          [4m     into                is                  log[0m
          [4m     max                 min                 mod[0m
          [4m     modify              not                 of[0m
          [4m     on                  onto                or[0m
          [4m     permit              print               range[0m
          [4m     replace             retrieve            save[0m
          [4m     sin                 sqrt                sum[0m
          [4m     sumu                to                  unique[0m
          [4m     until               usercode            view[0m
          [4m     where                                   [0m


          4. Konstanten
          -------------

          Entsprechend den in QL verfuegbaren  Datentypen  zur  Daten-
          speicherung gibt es drei Typen von Konstanten.




          4.1. Zeichenketten (String)-Konstanten
          --------------------------------------

          Zeichenketten in QL sind Folgen von  1  bis  255  beliebiger
          ASCII-Zeichen,  die durch das doppelte Anfuehrungszeichen ("
          ") begrenzt werden.  Grossbuchstaben innerhalb von  Zeichen-
          ketten  werden genauso akzeptiert, wie sie angegeben werden.
          Um Begrenzer-Zeichen (Quotes) in Zeichenketten  einzubetten,
          ist  es notwendig, dass den Begrenzern ein Backslash-Zeichen
          "\"  vorangeht.   Gleiche  Konventionen  gelten   fuer   das
          Backslash-Zeichen "\" selbst.

          Innerhalb von Zeichenketten sind nur druckbare  Zeichen  er-
          laubt.   Nicht druckbare Zeichen (z.B. Steuerzeichen) werden
          in Leerzeichen (Blanks) konvertiert.

          4.2. Festkomma(Integer)-Konstanten
          ----------------------------------

          Festkomma-Konstanten in QL besitzen einen  Wertebereich  von
          -2  147  483  648  bis +2 147 483 647.  Festkomma-Konstanten
          ausserhalb dieser Grenzen werden  in  das  Gleitkomma-Format
          konvertiert.  Wenn die Festkommazahl kleiner als 32 768 oder
          groesser als -32 767 ist, wird sie als 2-Byte  Festkommazahl
          dargestellt.  Andernfalls wird sie in eine 4-Byte Festkomma-
          zahl konvertiert.

          4.3. Gleitkomma (Floating point)-Konstanten
          -------------------------------------------

          Gleitkomma-Konstanten koennen  aus  einem  festen  (Integer)
          Teil, einem Dezimalpunkt (kein Dezimalkomma !) und einem ge-
          brochenem Teil (zusammen als Mantisse bezeichnet) sowie  ei-
          nem  Exponenten  bestehen.  Die folgende Notation stellt das
          dar:

                  {<dig>} [.<dig>] [e|E [+|-] {<dig>}]

          Hierbei ist <dig> eine Ziffer, [] repraesentiert  das  wahl-
          weise  Vorhandensein   (einmal  oder  keinmal),  {} bedeutet
          keinmal oder mehrmals und | repraesentiert eine Alternative.
          Ein  Exponent  ohne Mantisse erhaelt als Mantisse 1 zogeord-
          net.  In dieser, die Gleitkomma-Konstante darstellenden Zei-
          chenfolge, duerfen keine weiteren Zeichen eingefuegt werden.
          Gleikomma-Konstanten doppelter  Genauigkeit  besitzen  einen
          Wertebereich  von ungefaehr -10**38 bis +10**38 und eine Ge-
          nauigkeit von 17 Dezimalziffern.



          5. Attribute
          ------------

          Ein Attribut ist eine Konstruktion der Form :

                  variable.domain

          Variable (tuple_variable) identifiziert eine bestimmte Rela-
          tion  und  kann als Repraesentant fuer die Zeilen oder Tupel
          der Relation betrachtet werden.  Eine  Variable  wird  einer
          Relation  mittels einer range Anweisung zugeordnet.  Die Do-
          maene domain ist der Name einer der  Spalten  der  Relation,
          ueber  die  die Variable definiert ist.  Zusammen bilden sie
          ein Attribut, das Werte  der  benannten  Domaene  repraesen-
          tiert.

          6. Arithmetische Operatoren
          ---------------------------

          Arithmetische Operatoren haben  Ausdruecke  von  numerischem
          Typ  als  Operanden.   Einstellige Operatoren gruppieren von
          rechts nach  links,  waehrend  zweistellige  Operatoren  von
          links  nach  rechts gruppieren.  Die Operatoren (in der Rei-
          henfolge absteigenden Vorranges) sind :

                  +,-     (einstellig) plus, minus
                  **      Potenzierung
                  *,/     Multiplikation, Division
                  +,-     (zweistellig) Addition, Subtraktion

          Klammern koennen fuer eine bestimmte  Gruppierung  der  Vor-
          rangfolge benutzt werden.  Arithmetischer Ueberlauf und eine
          Division durch Null werden bei  Festkomma-Operationen  nicht
          geprueft.  Gleitkomma-Operationen pruefen auf Ueberlauf, Un-
          terlauf und Division durch Null nur, wenn die  erforderliche
          Maschinen-Hardware existiert und verfuegbar (aktiv) ist.

          7. Ausdruck (a_expr)
          --------------------

          Ein Ausdruck kann Folgendes sein :

               Konstante
               Attribut
               funktionaler Ausdruck
               Aggregat oder Aggregat-Funktion
               eine Kombination numerischer Ausdruecke
                          und arithmetischer Operatoren

          Im folgenden wird in diesem Dokument auf  einen  allgemeinen
          Ausdruck mit dem Namen a_expr verwiesen.

          8. Formate
          ----------

          Jeder Ausdruck a_expr besitzt  ein  Format,  das  durch  die
          Buchstaben  (c, i oder f, fuer Character (Zeichenkette), In-
          teger (Festkomma) oder Floating  (Gleitkomma)  Datenformate)
          und  eine  Zahl,  die die Anzahl der Speicherung benoetigten
          Byte anzeigt.  Die aktuell unterstuetzten  Formate  sind  in
          nachfolgender  Tabelle  augelistet,  wobei die Wertebereiche
          numerischer Formate in Klammern dargestellt sind.

               c1 - c255      Character Daten von 1-255 Byte Laenge
               i1             1-Byte Integer (-128 bis +127)
               i2             2-Byte Integer (-32 768 bis +32 767)
               i4             4-Byte Integer  (-2 147 483 648 bis
                              +2 147 483 647)
               f4             4-Byte Floating (-10**38 bis +10**38,
                              7 Dezimalstellen Genauigkeit)
               f8             8-Byte Floating (-10**38 bis +10**38,
                              17 Dezimalstellen Genauigkeit)

          Ein numerisches Format kann in ein anderes numerisches  For-
          mat  konvertiert  oder  durch ein anderes numerisches Format
          ersetzt werden.

          9. Format-Konvertierung
          -----------------------

          Beim Operieren ueber zwei numerische  Domaenen  unterschied-
          lichen  Formates fuehrt DABA notwendige Konvertierungen aus,
          um identische Formate zu erzeugen.

          Beim Operieren ueber einer Festkomma- und einer  Gleitkomma-
          zahl wird die Festkommazahl vor der Operation in eine Gleit-
          kommazahl konvertiert.  Beim Operieren ueber zwei Festkomma-
          zahlen  unterschiedlicher  Laengen, wird die kuerzere in die
          Laenge der laengeren Zahl konvertiert.  Beim Operieren ueber
          zwei Gleitkommazahlen verschiedener Laengen wird die laenge-
          re in die Laenge der kuerzeren Zahl konvertiert.

          Die folgende Tabelle fasst die moeglichen Kombinationen  zu-
          sammen :

                      i1      i2      i4      f4      f8

              i1 -    i1      i2      i4      f4      f8
              i2 -    i2      i2      i4      f4      f8
              i4 -    i4      i4      i4      f4      f8
              f4 -    f4      f4      f4      f4      f4
              f8 -    f8      f8      f8      f4      f8

          DABA unterstuetzt fuenf Formatkonvertierungs-Operatoren, die
          anstelle obiger Standardaktionen spezifizierbar sind.  Diese
          Operatoren sind :

              int1(a_expr)      Ergebnisformat i1
              int2(a_expr)      Ergebnisformat i2
              int4(a_expr)      Ergebnisformat i4
              float4(a_expr)    Ergebnisformat f4
              float8(a_expr)    Ergebnisformat f8

          Die Formatkonvertierungs-Operatoren konvertieren  ihr  Argu-
          ment a_expr in das gewuenschte Format.  A_expr kann ein all-
          gemeiner Ausdruck einschliesslich  Zeichenkette  (Character)
          sein.   Wenn  ein  Character-Wert  nicht  konvertiert werden
          kann, wird ein Fehler angezeigt und die  Verarbeitung  abge-
          brochen.   Das  kann  nur  eintreten,  wenn  die  Syntax der
          Character-Werte unkorrekt ist.

          Ueberlauf bei der Konvertierung wird nicht geprueft.



          10. Zielliste (target_list)
          ---------------------------

          Eine Zielliste ist eine in  Klammern  eingeschlossene  Liste
          mit  einem  oder  mehreren Elementen, die durch Kommas sepa-
          riert werden.  Jedes der Elemente muss  eine  der  folgenden
          Formen haben :

          a) result_attname is a_expr

          Result_attname ist der Name des  zu  erzeugenden  Attributes
          (oder  ein  bereits existierender Attributname fuer den Fall
          einer Aenderungsanweisung).   Das  Gleichheitszeichen  ("=")
          kann  statt  is benutzt werden.  In dem Fall, wo a_expr kein
          einfaches Attribut ist, muss diese Form verwendet werden, um
          dem Ausdruck einen Ergebnisnamen zuzuordnen.

          b) attribute

          Im Falle einer retrieve Anweisung wird die resultierende Do-
          maene den gleichen Namen annehmen, den auch das wiederzufin-
          dende Attribut besitzt.  Im Falle einer  Aenderungsanweisung
          (append,  replace) muss die zu aendernde Relation eine Doma-
          ene mit genau diesem bezeichneten Namen besitzen.

          Innnerhalb der Zielliste kann das Schluesselwort all verwen-
          det  werden,  um alle Domaenen zu repraesentieren.  Zum Bei-
          spiel wird :

               range of p is personal
               retrieve (p.all) where p.gehalt > 1000

          alle Domaenen der Relation  "personal"  wiederfinden,  deren
          Tupel die Qualifikation (gehalt > 1000) erfuellen.  All kann
          in der Zielliste einer retrieve oder einer append  Anweisung
          verwendet werden.  Die Domaenen werden in ihrer Erstellungs-
          reihenfolge, d.h.  in der gleichen Reihenfolge, in  der  sie
          in der create Anweisung aufgelistet wurden, eingefuegt.

          11. Vergleichsoperatoren (Comparison operators)
          -----------------------------------------------

          Vergleichsoperatoren, die allgemeine Ausdruecke (a_expr) als
          Operanden haben, sind :

                  <       (kleiner als)
                  <=      (kleiner als oder gleich)
                  >       (groesser als)
                  >=      (groesser als oder gleich)
                  =       (gleich)
                  !=      (ungleich)

          Sie besitzen alle den gleichen Vorrang.  Beim Vergleich zwi-
          schen Zeichenketten werden alle Blanks ignoriert.

          12. Logische Operatoren
          -----------------------

          Die nachfolgend  aufgefuehrten  logischen  Operatoren  haben
          Klauseln  als  Operatoren  und  gruppieren  von  links  nach
          rechts.

                  not     (logisches NOT; Negation)
                  and     (logisches AND ("UND"); Konjunktion)
                  or      (logisches ODER; Disjunktion)

          Not hat von den drei Operatoren den hoechsten Vorrang.   And
          und  or  besitzen gleichen Vorrang.  Klammern sind fuer spe-
          zielle Gruppierungen anwendbar.

          13. Qualifikation (qual)
          ------------------------

          Eine Qualifikation qualification besteht aus einer  beliebi-
          gen  Anzahl von Klauseln, die durch logische Operatoren ver-
          knuepft werden.

          Eine Klausel (clause) ist  ein  Paar  von  Ausdruecken,  die
          durch einen Vergleichsoperator verknuepft werden :

                  a_expr comparison_operator a_expr

          Klammern sind zum individuellen Gruppieren anwendbar.   Eine
          Qualifikation kann somit folgendes sein :

              clause
              not qual
              qual or qual
              qual and qual
              ( qual )

          14. Funktionale Ausdruecke
          -------------------------

          Ein funktionaler Ausdruck functional expression besteht  aus
          einem  Funktionsnamen,  der von einem geklammerten Operanden
          (bzw. einer Liste geklammerter Operanden, durch  Kommas  ge-
          trennt) gefolgt wird.  Funktionale Ausdruecke koennen in be-
          liebiger Tiefe geschachtelt werden.  In der folgenden  Liste
          repraesentiert n einen allgemeinen Ausdruck numerischen For-
          mates.  Das Format der Ergebnisse wird rechts dargestellt.

               [4mabs[0m([7mn[0m) -       gleich n (Absolutwert)
               [4mascii[0m([7mn[0m) -     Zeichenkette (konvertiert  numerisch  in
                              Zeichendarstellung)
               [4matan[0m([7mn[0m) -      f8 (Arcustangents)
               [4mconcat[0m([7ma,b[0m) -  Character (Verketten  von  Zeichenkette;
                              s.a. 16.2)
               [4mcos[0m([7mn[0m) -       f8 (Kosinus)
               [4mexp[0m([7mn[0m) -       f8 (Potenz von n )
               [4mlog[0m([7mn[0m) -       f8 (natuerlicher Logarithmus)
               [4mmod[0m([7mn,b[0m) -     gleich b (n modulo b.  n und  b  muessen
                              sein i1, i2, or i4)
               [4msin[0m([7mn[0m) -       f8 (Sinus)
               [4msqrt[0m([7mn[0m) -      f8 (Quadratwurzel)

          15. Aggregat-Ausdruecke
          ----------------------

          Aggregat-Ausdruecke ermoeglichen es, ueber  eine  Menge  von
          Tupeln zusammengefasste Werte zu ermitteln.




          15.1. Aggregat-Operatoren
          -------------------------

          Die Definitionen der  Aggregat-Funktionen  sind  nachfolgend
          aufgefuehrt :

               [4mcount[0m -         (i4) zaehlen der Vorkommen (Ereignisse)
               [4mcountu[0m -        (i4) zaehlen der einzigartigen
                                (unique,verschiedenen) Vorkommen
               [4msum[0m -           Summation
               [4msumu[0m -          Summation einzigartiger Vorkommen
               [4mavg[0m -           (f8) Durchschnitt (sum/count)
               [4mavgu[0m -          (f8) unique Durchschnitt (sumu/countu)
               [4mmax[0m -           Maximum
               [4mmin[0m -           Minimum
               [4many[0m -           (i2) Der Wert  ist  1,  wenn  irgendein
                              (any)  Tupel die Qualifikation erfuellt,
                              sonst 0

          15.2. Einfache Aggregate
          ------------------------

          aggregation_operator ( a_expr [ where qual ] )

          Ein einfaches Aggregat ergibt einen einfachen skalaren Wert.
          A_expr  wird  ueber  eine Menge Tupel, die die Qualifikation
          erfuellen (oder ueber alle Tupel im Geltungsbereich des Aus-
          druckes,  wenn  keine  Qualifikation  angegeben ist), aggre-
          giert.  Die Operatoren sum und avg verlangen ein numerisches
          Format  von  a_expr; count, any, max und min erlauben sowohl
          Attribute vom Character-Format als auch ein numerisches For-
          mat von a_expr.

          Einfache Aggregate sind vollstaendig lokal!   Das  bedeutet,
          sie  werden von der uebrigen Anfrage logisch abgetrennt, se-
          parat verarbeitet und durch ihren skalaren Wert ersetzt.

          15.3. Das any- Aggregat
          -------------------------

          Manchmal moechte man wissen, ob es irgendwelche Tupel  gibt,
          die  eine bestimmte Qualifikation erfuellen.  Eine Moeglich-
          keit das zu erfahren , ist die Benutzung des count  Aggrega-
          tes mit nachfolgender Pruefung auf Null oder verschieden von
          Null.  Die Benutzung von any anstatt von count ist effizien-
          ter,  da  die Verarbeitung von any gestoppt wird, wenn erst-
          malig ein Tupel die Qualifikation erfuellt.

          Das any Aggregat gibt 1 zurueck, wenn die Qualifikation  er-
          fuellt ist, sonst 0.

          15.4. Aggregat Funktionen
          -------------------------

          aggregation_operator ( a_expr by by_domain
          {, by_domain} [ where qual ] )

          Aggregate-Funktionen sind Erweiterungen einfacher Aggregate.
          Der  by  Operator gruppiert (d.h. portioniert) die Menge der
          sich qualifizierenden  Tupel  entsprechend  den  Werten  der
          by_domain.  Fuer mehr als eine by_domain, stellen die Werte,
          nach denen gruppiert wird,  die  Verkettung  (Aneinanderrei-
          hung) der individuellen Werte der by_domain dar.  A_expr ist
          analog einfachen Ausdruecken.  Die Aggregat-Funktion  ergibt
          eine  Menge  von Aggregaten als Ergebnis, je eines fuer jede
          Portion, in die die  Menge  qualifizierter  Tupel  gruppiert
          wurde.   Der  Aggregat-Wert, der waehrend der Berechnung der
          Anfrage verwendet wird, ist der Wert, der  mit  der  Portion
          verbunden  ist, in die die gerade verarbeiteten fallen wuer-
          den.

          Anders als bei einfachen Aggregaten sind Aggregat-Funktionen
          nicht  vollstaendig  lokal.   Die  by_list,  durch  die sich
          Aggregat-Funktionen von einfachen Aggregaten  unterscheiden,
          ist  fuer die Anfrage global.  Domaenen der by_list sind au-
          tomatisch mit anderen Domaenen der  Anfrage  verbunden,  die
          auch zur gleichen Relation gehoeren.

          Beispiel:
                  /* Finde das Durchschnittsgehalt der Beschaeftigten,
                  fuer jeden Leiter */
                  range of p is personal
                  retrieve (p.leiter, dgehalt=avg(p.gehalt by p.leiter))

          15.5. Aggregate ueber "unique"-Werten
          ------------------------------------

          Manchmal ist es notwendig, ueber die "unique" (einzigartigen
          , verschiedenen) Werte eines Ausdruckes zu aggregieren.  Die
          avgu, sumuund countu Aggregate unterdruecken alle  doppelten
          Werte,  bevor  sie die Aggregation ausfuehren.  Zum Beispiel
          wuerde :

                  count(p.leiter)

          ermitteln, wieviele Tupel das  Attribut  p.leiter  besitzen.
          Aber

                  countu(p.leiter)

          wuerde ermitteln, wieviele unterschiedliche  (unique)  Werte
          von p.leiter existieren..

          16. Spezielle Zeichen-Operatoren
          --------------------------------

          Speziell fuer Zeichenketten-Domaenen gibt es drei  besondere
          Unterstuetzungen.

          16.1. Zeichen zur Mustersuche (Pattern matching)
          ------------------------------------------------

          Es gibt drei Spezifikationen mit vier Sonderzeichen, die ei-
          ne  spezielle Bedeutung besitzen, wenn sie in Zeichenketten-
          Konstanten (Strings) verwendet werden :

              *     entspricht einer Zeichenkette von einem oder  meh-
                    reren Zeichen.
              ?     entspricht einem einzelnen, beliebugen Zeichen.
              [..]  entspricht entweder einem Zeichen  aus  der  Menge
                    der  innerhalb der Klammern spezifizierten Zeichen
                    (kommaseparierte Liste) oder einem Zeichenbereich,
                    wofuer  die Liste die Unter- und Obergrenze (sepa-
                    riert durch Bindestrich) enthalten muss.

          Diese speziellen Zeichen sind innerhalb der Zeichenkette  in
          beliebiger  Kombination  nutzbar, um eine Vielzahl von Tests
          zu formulieren.  Beispiele :

               where p.name = "*" - qualifiziert jeden beliebigen  Na-
                                   men.
               where p.name = "G*" - qualifiziert alle mit "G"  begin-
                                   nenden Namen
               where p.name = "*eter" - qualifiziert alle  mit  "eter"
                                   endenden Namen
               where p.name = "*[aeiou]*"  -  qualifiziert  Nmaen  mit
                                   kleinen Vokalen.
               where p.name = "Schulz?" - qualifiziert 7 Zeichen,  die
                                   mit "Schulz" beginnen.
               where p.name = "[A-J]*" - qualifiziert mit A,B,..,J be-
                                   ginnende Namen.

          Die Spezialbedeutung eines  Sonderzeichens  zur  Mustersuche
          wird  aufgehoben,  wenn ihm ein Backslash-Zeichen "\" voran-
          geht.  So wird z.B. durch "\*" auf das Zeichen  "*"  verwie-
          sen.  Zeichen zur Mustersuche, die innerhalb der target_list
          (Zielliste) auftreten, muessen stets  durch  ein  Backslash-
          Zeichen kaschiert werden.  Beispielsweise ist :

                  titel = "\*\*\* daba \*\*\*"

          die korrekte Art, den String "*** daba ***" der Domaene "ti-
          tel" zuzuordnen.

          16.2. Verkettung (Concatination)
          --------------------------------

          Es gibt einen Verkettungsoperator, der zwei Zeichenketten zu
          einer  verkettet.   Seine  Syntax ist "concat(feld1,feld2)".
          Die Laenge der neuen Zeichenkette ist gleich der  Summe  der
          Laengen  der  beiden  Zeichenketten.   Rechtsbuendige (End-)
          Blanks im ersten Feld werden entfernt, das zweite Feld  wird
          angekettet,  und  in der Laenge der entfernten Blanks werden
          in der Ergebnis-Zeichenkette Blanks aufgefuellt.  Das Ergeb-
          nis  ist  niemals auf eine Laenge 0 verkuerzt.  Verkettungen
          koennen innerhalb anderer Verkettungen beliebig geschachtelt
          werden.  So wird beispielsweise :

                  name = concat(concat(x.nachname, ","), x.vorname)

          den Nachnamen mit einem Komma verketten und daran  den  Vor-
          namen anketten.



          16.3.  Konvertierung  des  numerischen   Formates   in   das
                Zeichenketten- Format (ascii)
          ------------------------------------------------------------

          Die ascii Funktion kann benutzt werden, um  ein  numerisches
          Feld  in  eine Zeichen-Repraesentation zu konvertieren.  Das
          kann bedeutungsvoll sein, wenn ein numerischer Wert mit  ei-
          nem Zeichen-Wert verglichen werden soll.  Beispiel :

                  retrieve ( ... )
                          where x.chardomain = ascii(x.numdomain)

          Ascii kann auch auf einen Zeichenketten-Wert angewendet wer-
          den.  Das Ergebnis ist dabei der unveraenderte Zeichen-Wert.
          Die  numerischen  Konvertierungsformate  werden  durch   das
          Druckformat  bestimmt,  das beim daba-Start angebbar ist und
          dann das Standardformat ueberschreibt (s.a. daba(mutos)).

     SIEHE AUCH
          append(ql), iql(mutos), delete(ql), range(ql),  replace(ql),
          retrieve(ql).




     FEHLERQUELLEN
          Die maximale Anzahl von Variablen, die in einer Anfrage  be-
          nutzt werden kann, ist 10.

          Numerischer Ueberlauf, Unterlauf  und  eine  Division  durch
          Null werden nicht entdeckt und bleiben ungeprueft.
