doc/tools.xml

   1  <chapter id="tools"><title>Supporting Tools</title>
   2
   3   <para>
   4    In support of the service API - primarily the ASN module, which
   5    provides the pro-grammatic interface to the Z39.50 APDUs, &yaz; contains
   6    a collection of tools that support the development of applications.
   7   </para>
   8
   9   <sect1 id="tools.query"><title>Query Syntax Parsers</title>
  10
  11    <para>
  12     Since the type-1 (RPN) query structure has no direct, useful string
  13     representation, every origin application needs to provide some form of
  14     mapping from a local query notation or representation to a
  15     <token>Z_RPNQuery</token> structure. Some programmers will prefer to
  16     construct the query manually, perhaps using
  17     <function>odr_malloc()</function> to simplify memory management.
  18     The &yaz; distribution includes three separate, query-generating tools
  19     that may be of use to you.
  20    </para>
  21
  22    <sect2 id="PQF"><title>Prefix Query Format</title>
  23
  24     <para>
  25      Since RPN or reverse polish notation is really just a fancy way of
  26      describing a suffix notation format (operator follows operands), it
  27      would seem that the confusion is total when we now introduce a prefix
  28      notation for RPN. The reason is one of simple laziness - it's somewhat
  29      simpler to interpret a prefix format, and this utility was designed
  30      for maximum simplicity, to provide a baseline representation for use
  31      in simple test applications and scripting environments (like Tcl). The
  32      demonstration client included with YAZ uses the PQF.
  33     </para>
  34
  35     <note>
  36      <para>
  37       The PQF have been adopted by other parties developing Z39.50
  38       software. It is often referred to as Prefix Query Notation
  39       - PQN.
  40      </para>
  41     </note>
  42     <para>
  43      The PQF is defined by the pquery module in the YAZ library.
  44      There are two sets of function that have similar behavior. First
  45      set operates on a PQF parser handle, second set doesn't. First set
  46      set of functions are more flexible than the second set. Second set
  47      is obsolete and is only provided to ensure backwards compatibility.
  48     </para>
  49     <para>
  50      First set of functions all operate on a PQF parser handle:
  51     </para>
  52     <synopsis>
  53      #include &lt;yaz/pquery.h&gt;
  54
  55      YAZ_PQF_Parser yaz_pqf_create(void);
  56
  57      void yaz_pqf_destroy(YAZ_PQF_Parser p);
  58
  59      Z_RPNQuery *yaz_pqf_parse(YAZ_PQF_Parser p, ODR o, const char *qbuf);
  60
  61      Z_AttributesPlusTerm *yaz_pqf_scan(YAZ_PQF_Parser p, ODR o,
  62                           Odr_oid **attributeSetId, const char *qbuf);
  63
  64      int yaz_pqf_error(YAZ_PQF_Parser p, const char **msg, size_t *off);
  65     </synopsis>
  66     <para>
  67      A PQF parser is created and destructed by functions
  68      <function>yaz_pqf_create</function> and
  69      <function>yaz_pqf_destroy</function> respectively.
  70      Function <function>yaz_pqf_parse</function> parses query given
  71      by string <literal>qbuf</literal>. If parsing was successful,
  72      a Z39.50 RPN Query is returned which is created using ODR stream
  73      <literal>o</literal>. If parsing failed, a NULL pointer is
  74      returned.
  75      Function <function>yaz_pqf_scan</function> takes a scan query in
  76      <literal>qbuf</literal>. If parsing was successful, the function
  77      returns attributes plus term pointer and modifies
  78      <literal>attributeSetId</literal> to hold attribute set for the
  79      scan request - both allocated using ODR stream <literal>o</literal>.
  80      If parsing failed, yaz_pqf_scan returns a NULL pointer.
  81      Error information for bad queries can be obtained by a call to
  82      <function>yaz_pqf_error</function> which returns an error code and
  83      modifies <literal>*msg</literal> to point to an error description,
  84      and modifies <literal>*off</literal> to the offset within last
  85      query were parsing failed.
  86     </para>
  87     <para>
  88      The second set of functions are declared as follows:
  89     </para>
  90     <synopsis>
  91      #include &lt;yaz/pquery.h&gt;
  92
  93      Z_RPNQuery *p_query_rpn(ODR o, oid_proto proto, const char *qbuf);
  94
  95      Z_AttributesPlusTerm *p_query_scan(ODR o, oid_proto proto,
  96                              Odr_oid **attributeSetP, const char *qbuf);
  97
  98      int p_query_attset(const char *arg);
  99     </synopsis>
 100     <para>
 101      The function <function>p_query_rpn()</function> takes as arguments an
 102       &odr; stream (see section <link linkend="odr">The ODR Module</link>)
 103      to provide a memory source (the structure created is released on
 104      the next call to <function>odr_reset()</function> on the stream), a
 105      protocol identifier (one of the constants <token>PROTO_Z3950</token> and
 106      <token>PROTO_SR</token>), an attribute set reference, and
 107      finally a null-terminated string holding the query string.
 108     </para>
 109     <para>
 110      If the parse went well, <function>p_query_rpn()</function> returns a
 111      pointer to a <literal>Z_RPNQuery</literal> structure which can be
 112      placed directly into a <literal>Z_SearchRequest</literal>.
 113      If parsing failed, due to syntax error, a NULL pointer is returned.
 114     </para>
 115     <para>
 116      The <literal>p_query_attset</literal> specifies which attribute set
 117      to use if the query doesn't specify one by the
 118      <literal>@attrset</literal> operator.
 119      The <literal>p_query_attset</literal> returns 0 if the argument is a
 120      valid attribute set specifier; otherwise the function returns -1.
 121     </para>
 122
 123     <para>
 124      The grammar of the PQF is as follows:
 125     </para>
 126
 127     <literallayout>
 128      query ::= top-set query-struct.
 129
 130      top-set ::= [ '@attrset' string ]
 131
 132      query-struct ::= attr-spec | simple | complex | '@term' term-type query
 133
 134      attr-spec ::= '@attr' [ string ] string query-struct
 135
 136      complex ::= operator query-struct query-struct.
 137
 138      operator ::= '@and' | '@or' | '@not' | '@prox' proximity.
 139
 140      simple ::= result-set | term.
 141
 142      result-set ::= '@set' string.
 143
 144      term ::= string.
 145
 146      proximity ::= exclusion distance ordered relation which-code unit-code.
 147
 148      exclusion ::= '1' | '0' | 'void'.
 149
 150      distance ::= integer.
 151
 152      ordered ::= '1' | '0'.
 153
 154      relation ::= integer.
 155
 156      which-code ::= 'known' | 'private' | integer.
 157
 158      unit-code ::= integer.
 159
 160      term-type ::= 'general' | 'numeric' | 'string' | 'oid' | 'datetime' | 'null'.
 161     </literallayout>
 162
 163     <para>
 164      You will note that the syntax above is a fairly faithful
 165      representation of RPN, except for the Attribute, which has been
 166      moved a step away from the term, allowing you to associate one or more
 167      attributes with an entire query structure. The parser will
 168      automatically apply the given attributes to each term as required.
 169     </para>
 170
 171     <para>
 172      The @attr operator is followed by an attribute specification
 173      (<literal>attr-spec</literal> above). The specification consists
 174      of an optional attribute set, an attribute type-value pair and
 175      a sub-query. The attribute type-value pair is packed in one string:
 176      an attribute type, an equals sign, and an attribute value, like this:
 177      <literal>@attr 1=1003</literal>.
 178      The type is always an integer but the value may be either an
 179      integer or a string (if it doesn't start with a digit character).
 180      A string attribute-value is encoded as a Type-1 ``complex''
 181      attribute with the list of values containing the single string
 182      specified, and including no semantic indicators.
 183     </para>
 184
 185     <para>
 186      Version 3 of the Z39.50 specification defines various encoding of terms.
 187      Use <literal>@term </literal> <replaceable>type</replaceable>
 188      <replaceable>string</replaceable>,
 189      where type is one of: <literal>general</literal>,
 190      <literal>numeric</literal> or <literal>string</literal>
 191      (for InternationalString).
 192      If no term type has been given, the <literal>general</literal> form
 193      is used.  This is the only encoding allowed in both versions 2 and 3
 194      of the Z39.50 standard.
 195     </para>
 196
 197     <sect3 id="PQF-prox">
 198       <title>Using Proximity Operators with PQF</title>
 199       <note>
 200         <para>
 201           This is an advanced topic, describing how to construct
 202           queries that make very specific requirements on the
 203           relative location of their operands.
 204           You may wish to skip this section and go straight to
 205           <link linkend="pqf-examples">the example PQF queries</link>.
 206         </para>
 207         <para>
 208           <warning>
 209             <para>
 210               Most Z39.50 servers do not support proximity searching, or
 211               support only a small subset of the full functionality that
 212               can be expressed using the PQF proximity operator.  Be
 213               aware that the ability to <emphasis>express</emphasis> a
 214               query in PQF is no guarantee that any given server will
 215               be able to <emphasis>execute</emphasis> it.
 216             </para>
 217           </warning>
 218         </para>
 219       </note>
 220       <para>
 221         The proximity operator <literal>@prox</literal> is a special
 222         and more restrictive version of the conjunction operator
 223         <literal>@and</literal>.  Its semantics are described in
 224         section 3.7.2 (Proximity) of Z39.50 the standard itself, which
 225         can be read on-line at
 226         <ulink url="&url.z39.50.proximity;"/>
 227       </para>
 228       <para>
 229         In PQF, the proximity operation is represented by a sequence
 230         of the form
 231         <screen>
 232 @prox <replaceable>exclusion</replaceable> <replaceable>distance</replaceable> <replaceable>ordered</replaceable> <replaceable>relation</replaceable> <replaceable>which-code</replaceable> <replaceable>unit-code</replaceable>
 233         </screen>
 234         in which the meanings of the parameters are as described in in
 235         the standard, and they can take the following values:
 236         <itemizedlist>
 237           <listitem><formalpara><title>exclusion</title><para>
 238             0 = false (i.e. the proximity condition specified by the
 239             remaining parameters must be satisfied) or
 240             1 = true (the proximity condition specified by the
 241             remaining parameters must <emphasis>not</emphasis> be
 242             satisifed).
 243           </para></formalpara></listitem>
 244           <listitem><formalpara><title>distance</title><para>
 245             An integer specifying the difference between the locations
 246             of the operands: e.g. two adjacent words would have
 247             distance=1 since their locations differ by one unit.
 248           </para></formalpara></listitem>
 249           <listitem><formalpara><title>ordered</title><para>
 250             1 = ordered (the operands must occur in the order the
 251             query specifies them) or
 252             0 = unordered (they may appear in either order).
 253           </para></formalpara></listitem>
 254           <listitem><formalpara><title>relation</title><para>
 255             Recognised values are
 256             1 (lessThan),
 257             2 (lessThanOrEqual),
 258             3 (equal),
 259             4 (greaterThanOrEqual),
 260             5 (greaterThan) and
 261             6 (notEqual).
 262           </para></formalpara></listitem>
 263           <listitem><formalpara><title>which-code</title><para>
 264             <literal>known</literal>
 265             or
 266             <literal>k</literal>
 267             (the unit-code parameter is taken from the well-known list
 268             of alternatives described in below) or
 269             <literal>private</literal>
 270             or
 271             <literal>p</literal>
 272             (the unit-code paramater has semantics specific to an
 273             out-of-band agreement such as a profile).
 274           </para></formalpara></listitem>
 275           <listitem><formalpara><title>unit-code</title><para>
 276             If the which-code parameter is <literal>known</literal>
 277             then the recognised values are
 278             1 (character),
 279             2 (word),
 280             3 (sentence),
 281             4 (paragraph),
 282             5 (section),
 283             6 (chapter),
 284             7 (document),
 285             8 (element),
 286             9 (subelement),
 287             10 (elementType) and
 288             11 (byte).
 289             If which-code is <literal>private</literal> then the
 290             acceptable values are determined by the profile.
 291           </para></formalpara></listitem>
 292         </itemizedlist>
 293         (The numeric values of the relation and well-known unit-code
 294         parameters are taken straight from
 295         <ulink url="&url.z39.50.proximity.asn1;"
 296         >the ASN.1</ulink> of the proximity structure in the standard.)
 297       </para>
 298     </sect3>
 299
 300     <sect3 id="pqf-examples"><title>PQF queries</title>
 301
 302      <example id="example.pqf.simple.terms">
 303       <title>PQF queries using simple terms</title>
 304       <para>
 305        <screen>
 306         dylan
 307
 308         "bob dylan"
 309        </screen>
 310       </para>
 311      </example>
 312      <example id="pqf.example.pqf.boolean.operators">
 313       <title>PQF boolean operators</title>
 314       <para>
 315        <screen>
 316         @or "dylan" "zimmerman"
 317
 318         @and @or dylan zimmerman when
 319
 320         @and when @or dylan zimmerman
 321        </screen>
 322       </para>
 323      </example>
 324      <example id="example.pqf.result.sets">
 325       <title>PQF references to result sets</title>
 326       <para>
 327        <screen>
 328         @set Result-1
 329
 330         @and @set seta @set setb
 331        </screen>
 332       </para>
 333      </example>
 334      <example id="example.pqf.attributes">
 335       <title>Attributes for terms</title>
 336       <para>
 337        <screen>
 338         @attr 1=4 computer
 339
 340         @attr 1=4 @attr 4=1 "self portrait"
 341
 342         @attrset exp1 @attr 1=1 CategoryList
 343
 344         @attr gils 1=2008 Copenhagen
 345
 346         @attr 1=/book/title computer
 347        </screen>
 348       </para>
 349      </example>
 350      <example id="example.pqf.proximity">
 351       <title>PQF Proximity queries</title>
 352       <para>
 353        <screen>
 354         @prox 0 3 1 2 k 2 dylan zimmerman
 355        </screen>
 356        <note><para>
 357          Here the parameters 0, 3, 1, 2, k and 2 represent exclusion,
 358          distance, ordered, relation, which-code and unit-code, in that
 359          order.  So:
 360          <itemizedlist>
 361           <listitem><para>
 362             exclusion = 0: the proximity condition must hold
 363            </para></listitem>
 364           <listitem><para>
 365             distance = 3: the terms must be three units apart
 366            </para></listitem>
 367           <listitem><para>
 368             ordered = 1: they must occur in the order they are specified
 369            </para></listitem>
 370           <listitem><para>
 371             relation = 2: lessThanOrEqual (to the distance of 3 units)
 372            </para></listitem>
 373           <listitem><para>
 374             which-code is ``known'', so the standard unit-codes are used
 375            </para></listitem>
 376           <listitem><para>
 377             unit-code = 2: word.
 378            </para></listitem>
 379          </itemizedlist>
 380          So the whole proximity query means that the words
 381          <literal>dylan</literal> and <literal>zimmerman</literal> must
 382          both occur in the record, in that order, differing in position
 383          by three or fewer words (i.e. with two or fewer words between
 384          them.)  The query would find ``Bob Dylan, aka. Robert
 385          Zimmerman'', but not ``Bob Dylan, born as Robert Zimmerman''
 386          since the distance in this case is four.
 387         </para></note>
 388       </para>
 389      </example>
 390      <example id="example.pqf.search.term.type">
 391       <title>PQF specification of search term type</title>
 392       <para>
 393        <screen>
 394         @term string "a UTF-8 string, maybe?"
 395        </screen>
 396       </para>
 397      </example>
 398      <example id="example.pqf.mixed.queries">
 399       <title>PQF mixed queries</title>
 400       <para>
 401        <screen>
 402         @or @and bob dylan @set Result-1
 403
 404         @attr 4=1 @and @attr 1=1 "bob dylan" @attr 1=4 "slow train coming"
 405
 406         @and @attr 2=4 @attr gils 1=2038 -114 @attr 2=2 @attr gils 1=2039 -109
 407       </screen>
 408        <note>
 409         <para>
 410          The last of these examples is a spatial search: in
 411          <ulink url="http://www.gils.net/prof_v2.html#sec_7_4"
 412           >the GILS attribute set</ulink>,
 413          access point
 414          2038 indicates West Bounding Coordinate and
 415          2030 indicates East Bounding Coordinate,
 416          so the query is for areas extending from -114 degrees
 417          to no more than -109 degrees.
 418         </para>
 419        </note>
 420       </para>
 421      </example>
 422     </sect3>
 423    </sect2>
 424    <sect2 id="CCL"><title>CCL</title>
 425
 426     <para>
 427      Not all users enjoy typing in prefix query structures and numerical
 428      attribute values, even in a minimalistic test client. In the library
 429      world, the more intuitive Common Command Language - CCL (ISO 8777)
 430      has enjoyed some popularity - especially before the widespread
 431      availability of graphical interfaces. It is still useful in
 432      applications where you for some reason or other need to provide a
 433      symbolic language for expressing boolean query structures.
 434     </para>
 435
 436     <sect3 id="ccl.syntax">
 437      <title>CCL Syntax</title>
 438
 439      <para>
 440       The CCL parser obeys the following grammar for the FIND argument.
 441       The syntax is annotated by in the lines prefixed by
 442       <literal>--</literal>.
 443      </para>
 444
 445      <screen>
 446       CCL-Find ::= CCL-Find Op Elements
 447                 | Elements.
 448
 449       Op ::= "and" | "or" | "not"
 450       -- The above means that Elements are separated by boolean operators.
 451
 452       Elements ::= '(' CCL-Find ')'
 453                 | Set
 454                 | Terms
 455                 | Qualifiers Relation Terms
 456                 | Qualifiers Relation '(' CCL-Find ')'
 457                 | Qualifiers '=' string '-' string
 458       -- Elements is either a recursive definition, a result set reference, a
 459       -- list of terms, qualifiers followed by terms, qualifiers followed
 460       -- by a recursive definition or qualifiers in a range (lower - upper).
 461
 462       Set ::= 'set' = string
 463       -- Reference to a result set
 464
 465       Terms ::= Terms Prox Term
 466              | Term
 467       -- Proximity of terms.
 468
 469       Term ::= Term string
 470             | string
 471       -- This basically means that a term may include a blank
 472
 473       Qualifiers ::= Qualifiers ',' string
 474                   | string
 475       -- Qualifiers is a list of strings separated by comma
 476
 477       Relation ::= '=' | '>=' | '&lt;=' | '&lt;>' | '>' | '&lt;'
 478       -- Relational operators. This really doesn't follow the ISO8777
 479       -- standard.
 480
 481       Prox ::= '%' | '!'
 482       -- Proximity operator
 483
 484      </screen>
 485
 486      <example id="example.ccl.queries">
 487       <title>CCL queries</title>
 488       <para>
 489        The following queries are all valid:
 490       </para>
 491
 492       <screen>
 493        dylan
 494
 495        "bob dylan"
 496
 497        dylan or zimmerman
 498
 499        set=1
 500
 501        (dylan and bob) or set=1
 502
 503        righttrunc?
 504
 505        "notrunc?"
 506
 507        singlechar#mask
 508
 509       </screen>
 510       <para>
 511        Assuming that the qualifiers <literal>ti</literal>,
 512        <literal>au</literal>
 513        and <literal>date</literal> are defined we may use:
 514       </para>
 515
 516       <screen>
 517        ti=self portrait
 518
 519        au=(bob dylan and slow train coming)
 520
 521        date>1980 and (ti=((self portrait)))
 522
 523       </screen>
 524      </example>
 525
 526     </sect3>
 527     <sect3 id="ccl.qualifiers">
 528      <title>CCL Qualifiers</title>
 529
 530      <para>
 531       Qualifiers are used to direct the search to a particular searchable
 532       index, such as title (ti) and author indexes (au). The CCL standard
 533       itself doesn't specify a particular set of qualifiers, but it does
 534       suggest a few short-hand notations. You can customize the CCL parser
 535       to support a particular set of qualifiers to reflect the current target
 536       profile. Traditionally, a qualifier would map to a particular
 537       use-attribute within the BIB-1 attribute set. It is also
 538       possible to set other attributes, such as the structure
 539       attribute.
 540      </para>
 541
 542      <para>
 543       A  CCL profile is a set of predefined CCL qualifiers that may be
 544       read from a file or set in the CCL API.
 545       The YAZ client reads its CCL qualifiers from a file named
 546       <filename>default.bib</filename>. There are four types of
 547       lines in a CCL profile: qualifier specification,
 548       qualifier alias, comments and directives.
 549      </para>
 550      <sect4 id="ccl.qualifier.specification">
 551       <title>Qualifier specification</title>
 552       <para>
 553        A qualifier specification is of the form:
 554       </para>
 555
 556       <para>
 557        <replaceable>qualifier-name</replaceable>
 558        [<replaceable>attributeset</replaceable><literal>,</literal>]<replaceable>type</replaceable><literal>=</literal><replaceable>val</replaceable>
 559        [<replaceable>attributeset</replaceable><literal>,</literal>]<replaceable>type</replaceable><literal>=</literal><replaceable>val</replaceable> ...
 560       </para>
 561
 562       <para>
 563        where <replaceable>qualifier-name</replaceable> is the name of the
 564        qualifier to be used (eg. <literal>ti</literal>),
 565        <replaceable>type</replaceable> is attribute type in the attribute
 566        set (Bib-1 is used if no attribute set is given) and
 567        <replaceable>val</replaceable> is attribute value.
 568        The <replaceable>type</replaceable> can be specified as an
 569        integer or as it be specified either as a single-letter:
 570        <literal>u</literal> for use,
 571        <literal>r</literal> for relation,<literal>p</literal> for position,
 572        <literal>s</literal> for structure,<literal>t</literal> for truncation
 573        or <literal>c</literal> for completeness.
 574        The attributes for the special qualifier name <literal>term</literal>
 575        are used when no CCL qualifier is given in a query.
 576        <table id="ccl.common.bib1.attributes">
 577         <title>Common Bib-1 attributes</title>
 578         <tgroup cols="2">
 579          <colspec colwidth="2*" colname="type"></colspec>
 580          <colspec colwidth="9*" colname="description"></colspec>
 581          <thead>
 582           <row>
 583            <entry>Type</entry>
 584            <entry>Description</entry>
 585           </row>
 586          </thead>
 587          <tbody>
 588           <row>
 589            <entry><literal>u=</literal><replaceable>value</replaceable></entry>
 590            <entry>
 591             Use attribute (1). Common use attributes are
 592             1 Personal-name, 4 Title, 7 ISBN, 8 ISSN, 30 Date,
 593             62 Subject, 1003 Author), 1016 Any. Specify value
 594             as an integer.
 595            </entry>
 596           </row>
 597
 598           <row>
 599            <entry><literal>r=</literal><replaceable>value</replaceable></entry>
 600            <entry>
 601             Relation attribute (2). Common values are
 602             1 &lt;, 2 &lt;=, 3 =, 4 &gt;=, 5 &gt;, 6 &lt;&gt;,
 603             100 phonetic, 101 stem, 102 relevance, 103 always matches.
 604            </entry>
 605           </row>
 606
 607           <row>
 608            <entry><literal>p=</literal><replaceable>value</replaceable></entry>
 609            <entry>
 610             Position attribute (3). Values: 1 first in field, 2
 611             first in any subfield, 3 any position in field.
 612            </entry>
 613           </row>
 614
 615           <row>
 616            <entry><literal>s=</literal><replaceable>value</replaceable></entry>
 617            <entry>
 618             Structure attribute (4). Values: 1 phrase, 2 word,
 619             3 key, 4 year, 5 date, 6 word list, 100 date (un),
 620             101 name (norm), 102 name (un), 103 structure, 104 urx,
 621             105 free-form-text, 106 document-text, 107 local-number,
 622             108 string, 109 numeric string.
 623            </entry>
 624           </row>
 625
 626           <row>
 627            <entry><literal>t=</literal><replaceable>value</replaceable></entry>
 628            <entry>
 629             Truncation attribute (5). Values: 1 right, 2 left,
 630             3 left&amp; right, 100 none, 101 process #, 102 regular-1,
 631             103 regular-2, 104 CCL.
 632            </entry>
 633           </row>
 634
 635           <row>
 636            <entry><literal>c=</literal><replaceable>value</replaceable></entry>
 637            <entry>
 638             Completeness attribute (6). Values: 1 incomplete subfield,
 639             2 complete subfield, 3 complete field.
 640            </entry>
 641           </row>
 642
 643          </tbody>
 644          </tgroup>
 645         </table>
 646       </para>
 647       <para>
 648        Refer to <xref linkend="bib1"/> or the complete
 649        <ulink url="&url.z39.50.attset.bib1;">list of Bib-1 attributes</ulink>
 650       </para>
 651       <para>
 652        It is also possible to specify non-numeric attribute values,
 653        which are used in combination with certain types.
 654        The special combinations are:
 655
 656        <table id="ccl.special.attribute.combos">
 657         <title>Special attribute combos</title>
 658         <tgroup cols="2">
 659          <colspec colwidth="2*" colname="name"></colspec>
 660          <colspec colwidth="9*" colname="description"></colspec>
 661          <thead>
 662           <row>
 663            <entry>Name</entry>
 664            <entry>Description</entry>
 665           </row>
 666          </thead>
 667          <tbody>
 668           <row>
 669            <entry><literal>s=pw</literal></entry><entry>
 670             The structure is set to either word or phrase depending
 671             on the number of tokens in a term (phrase-word).
 672            </entry>
 673           </row>
 674           <row>
 675            <entry><literal>s=al</literal></entry><entry>
 676             Each token in the term is ANDed. (and-list).
 677             This does not set the structure at all.
 678            </entry>
 679           </row>
 680
 681           <row><entry><literal>s=ol</literal></entry><entry>
 682             Each token in the term is ORed. (or-list).
 683             This does not set the structure at all.
 684            </entry>
 685           </row>
 686
 687           <row><entry><literal>s=ag</literal></entry><entry>
 688             Tokens that appears as phrases (with blank in them) gets
 689             structure phrase attached. Tokens that appers as words
 690             gets structure phrase attached. Phrases and words are
 691             ANDed. This is a variant of s=al and s=pw, with the main
 692             difference that words are not split (with operator AND)
 693             but instead kept in one RPN token. This facility appeared
 694             in YAZ 4.2.38.
 695            </entry>
 696           </row>
 697
 698           <row><entry><literal>r=o</literal></entry><entry>
 699             Allows ranges and the operators greather-than, less-than, ...
 700             equals.
 701             This sets Bib-1 relation attribute accordingly (relation
 702             ordered). A query construct is only treated as a range if
 703             dash is used and that is surrounded by white-space. So
 704             <literal>-1980</literal> is treated as term
 705             <literal>"-1980"</literal> not <literal>&lt;= 1980</literal>.
 706             If <literal>- 1980</literal> is used, however, that is
 707             treated as a range.
 708            </entry>
 709           </row>
 710
 711           <row><entry><literal>r=r</literal></entry><entry>
 712             Similar to <literal>r=o</literal> but assumes that terms
 713             are non-negative (not prefixed with <literal>-</literal>).
 714             Thus, a dash will always be treated as a range.
 715             The construct <literal>1980-1990</literal> is
 716             treated as a range with <literal>r=r</literal> but as a
 717             single term <literal>"1980-1990"</literal> with
 718             <literal>r=o</literal>. The special attribute
 719             <literal>r=r</literal> is available in YAZ 2.0.24 or later.
 720            </entry>
 721           </row>
 722
 723           <row><entry><literal>t=l</literal></entry><entry>
 724             Allows term to be left-truncated.
 725             If term is of the form <literal>?x</literal>, the resulting
 726             Type-1 term is <literal>x</literal> and truncation is left.
 727            </entry>
 728           </row>
 729
 730           <row><entry><literal>t=r</literal></entry><entry>
 731             Allows term to be right-truncated.
 732             If term is of the form <literal>x?</literal>, the resulting
 733             Type-1 term is <literal>x</literal> and truncation is right.
 734            </entry>
 735           </row>
 736
 737           <row><entry><literal>t=n</literal></entry><entry>
 738             If term is does not include <literal>?</literal>, the
 739             truncation attribute is set to none (100).
 740            </entry>
 741           </row>
 742
 743           <row><entry><literal>t=b</literal></entry><entry>
 744             Allows term to be both left&amp;right truncated.
 745             If term is of the form <literal>?x?</literal>, the
 746             resulting term is <literal>x</literal> and trunctation is
 747             set to both left&amp;right.
 748            </entry>
 749           </row>
 750
 751           <row><entry><literal>t=x</literal></entry><entry>
 752             Allows masking anywhere in a term, thus fully supporting
 753             # (mask one character) and ? (zero or more of any).
 754             If masking is used, trunction is set to 102 (regexp-1 in term)
 755             and the term is converted accordingly to a regular expression.
 756            </entry>
 757           </row>
 758
 759           <row><entry><literal>t=z</literal></entry><entry>
 760             Allows masking anywhere in a term, thus fully supporting
 761             # (mask one character) and ? (zero or more of any).
 762             If masking is used, trunction is set to 104 (Z39.58 in term)
 763             and the term is converted accordingly to Z39.58 masking term -
 764             actually the same truncation as CCL itself.
 765            </entry>
 766           </row>
 767
 768          </tbody>
 769         </tgroup>
 770        </table>
 771       </para>
 772       <example id="example.ccl.profile"><title>CCL profile</title>
 773        <para>
 774         Consider the following definition:
 775        </para>
 776
 777        <screen>
 778         ti       u=4 s=1
 779         au       u=1 s=1
 780         term     s=105
 781         ranked   r=102
 782         date     u=30 r=o
 783       </screen>
 784        <para>
 785         <literal>ti</literal> and <literal>au</literal> both set
 786         structure attribute to phrase (s=1).
 787         <literal>ti</literal>
 788         sets the use-attribute to 4. <literal>au</literal> sets the
 789         use-attribute to 1.
 790         When no qualifiers are used in the query the structure-attribute is
 791         set to free-form-text (105) (rule for <literal>term</literal>).
 792         The <literal>date</literal> sets the relation attribute to
 793         the relation used in the CCL query and sets the use attribute
 794         to 30 (Bib-1 Date).
 795        </para>
 796        <para>
 797         You can combine attributes. To Search for "ranked title" you
 798         can do
 799         <screen>
 800          ti,ranked=knuth computer
 801         </screen>
 802         which will set relation=ranked, use=title, structure=phrase.
 803        </para>
 804        <para>
 805         Query
 806         <screen>
 807          date > 1980
 808         </screen>
 809         is a valid query. But
 810         <screen>
 811          ti > 1980
 812         </screen>
 813         is invalid.
 814        </para>
 815       </example>
 816      </sect4>
 817      <sect4 id="ccl.qualifier.alias">
 818       <title>Qualifier alias</title>
 819       <para>
 820        A qualifier alias is of the form:
 821       </para>
 822       <para>
 823        <replaceable>q</replaceable>
 824        <replaceable>q1</replaceable> <replaceable>q2</replaceable> ..
 825       </para>
 826       <para>
 827        which declares <replaceable>q</replaceable> to
 828        be an alias for <replaceable>q1</replaceable>,
 829        <replaceable>q2</replaceable>... such that the CCL
 830        query <replaceable>q=x</replaceable> is equivalent to
 831        <replaceable>q1=x or q2=x or ...</replaceable>.
 832       </para>
 833      </sect4>
 834
 835      <sect4 id="ccl.comments">
 836       <title>Comments</title>
 837       <para>
 838        Lines with white space or lines that begin with
 839        character <literal>#</literal> are treated as comments.
 840       </para>
 841      </sect4>
 842
 843      <sect4 id="ccl.directives">
 844       <title>Directives</title>
 845       <para>
 846        Directive specifications takes the form
 847       </para>
 848       <para><literal>@</literal><replaceable>directive</replaceable> <replaceable>value</replaceable>
 849       </para>
 850       <table id="ccl.directives.table">
 851        <title>CCL directives</title>
 852        <tgroup cols="3">
 853         <colspec colwidth="2*" colname="name"></colspec>
 854         <colspec colwidth="8*" colname="description"></colspec>
 855         <colspec colwidth="1*" colname="default"></colspec>
 856         <thead>
 857          <row>
 858           <entry>Name</entry>
 859           <entry>Description</entry>
 860           <entry>Default</entry>
 861          </row>
 862         </thead>
 863         <tbody>
 864          <row>
 865           <entry>truncation</entry>
 866           <entry>Truncation character</entry>
 867           <entry><literal>?</literal></entry>
 868          </row>
 869          <row>
 870           <entry>field</entry>
 871           <entry>Specifies how multiple fields are to be
 872            combined. There are two modes: <literal>or</literal>:
 873            multiple qualifier fields are ORed,
 874            <literal>merge</literal>: attributes for the qualifier
 875            fields are merged and assigned to one term.
 876            </entry>
 877           <entry><literal>merge</literal></entry>
 878          </row>
 879          <row>
 880           <entry>case</entry>
 881           <entry>Specifies if CCL operators and qualifiers should be
 882            compared with case sensitivity or not. Specify 1 for
 883            case sensitive; 0 for case insensitive.</entry>
 884           <entry><literal>1</literal></entry>
 885          </row>
 886
 887          <row>
 888           <entry>and</entry>
 889           <entry>Specifies token for CCL operator AND.</entry>
 890           <entry><literal>and</literal></entry>
 891          </row>
 892
 893          <row>
 894           <entry>or</entry>
 895           <entry>Specifies token for CCL operator OR.</entry>
 896           <entry><literal>or</literal></entry>
 897          </row>
 898
 899          <row>
 900           <entry>not</entry>
 901           <entry>Specifies token for CCL operator NOT.</entry>
 902           <entry><literal>not</literal></entry>
 903          </row>
 904
 905          <row>
 906           <entry>set</entry>
 907           <entry>Specifies token for CCL operator SET.</entry>
 908           <entry><literal>set</literal></entry>
 909          </row>
 910         </tbody>
 911         </tgroup>
 912       </table>
 913      </sect4>
 914     </sect3>
 915     <sect3 id="ccl.api">
 916      <title>CCL API</title>
 917      <para>
 918       All public definitions can be found in the header file
 919       <filename>ccl.h</filename>. A profile identifier is of type
 920       <literal>CCL_bibset</literal>. A profile must be created with the call
 921       to the function <function>ccl_qual_mk</function> which returns a profile
 922       handle of type <literal>CCL_bibset</literal>.
 923      </para>
 924
 925      <para>
 926       To read a file containing qualifier definitions the function
 927       <function>ccl_qual_file</function> may be convenient. This function
 928       takes an already opened <literal>FILE</literal> handle pointer as
 929       argument along with a <literal>CCL_bibset</literal> handle.
 930      </para>
 931
 932      <para>
 933       To parse a simple string with a FIND query use the function
 934      </para>
 935      <screen>
 936 struct ccl_rpn_node *ccl_find_str(CCL_bibset bibset, const char *str,
 937                                   int *error, int *pos);
 938      </screen>
 939      <para>
 940       which takes the CCL profile (<literal>bibset</literal>) and query
 941       (<literal>str</literal>) as input. Upon successful completion the RPN
 942       tree is returned. If an error occur, such as a syntax error, the integer
 943       pointed to by <literal>error</literal> holds the error code and
 944       <literal>pos</literal> holds the offset inside query string in which
 945       the parsing failed.
 946      </para>
 947
 948      <para>
 949       An English representation of the error may be obtained by calling
 950       the <literal>ccl_err_msg</literal> function. The error codes are
 951       listed in <filename>ccl.h</filename>.
 952      </para>
 953
 954      <para>
 955       To convert the CCL RPN tree (type
 956       <literal>struct ccl_rpn_node *</literal>)
 957       to the Z_RPNQuery of YAZ the function <function>ccl_rpn_query</function>
 958       must be used. This function which is part of YAZ is implemented in
 959       <filename>yaz-ccl.c</filename>.
 960       After calling this function the CCL RPN tree is probably no longer
 961       needed. The <literal>ccl_rpn_delete</literal> destroys the CCL RPN tree.
 962      </para>
 963
 964      <para>
 965       A CCL profile may be destroyed by calling the
 966       <function>ccl_qual_rm</function> function.
 967      </para>
 968
 969      <para>
 970       The token names for the CCL operators may be changed by setting the
 971       globals (all type <literal>char *</literal>)
 972       <literal>ccl_token_and</literal>, <literal>ccl_token_or</literal>,
 973       <literal>ccl_token_not</literal> and <literal>ccl_token_set</literal>.
 974       An operator may have aliases, i.e. there may be more than one name for
 975       the operator. To do this, separate each alias with a space character.
 976      </para>
 977     </sect3>
 978    </sect2>
 979    <sect2 id="cql"><title>CQL</title>
 980     <para>
 981      <ulink url="&url.cql;">CQL</ulink>
 982       - Common Query Language - was defined for the
 983      <ulink url="&url.sru;">SRU</ulink> protocol.
 984      In many ways CQL has a similar syntax to CCL.
 985      The objective of CQL is different. Where CCL aims to be
 986      an end-user language, CQL is <emphasis>the</emphasis> protocol
 987      query language for SRU.
 988     </para>
 989     <tip>
 990      <para>
 991       If you are new to CQL, read the
 992       <ulink url="&url.cql.intro;">Gentle Introduction</ulink>.
 993      </para>
 994     </tip>
 995     <para>
 996      The CQL parser in &yaz; provides the following:
 997      <itemizedlist>
 998       <listitem>
 999        <para>
1000         It parses and validates a CQL query.
1001        </para>
1002       </listitem>
1003       <listitem>
1004        <para>
1005         It generates a C structure that allows you to convert
1006         a CQL query to some other query language, such as SQL.
1007        </para>
1008       </listitem>
1009       <listitem>
1010        <para>
1011         The parser converts a valid CQL query to PQF, thus providing a
1012         way to use CQL for both SRU servers and Z39.50 targets at the
1013         same time.
1014        </para>
1015       </listitem>
1016       <listitem>
1017        <para>
1018         The parser converts CQL to
1019         <ulink url="&url.xcql;">XCQL</ulink>.
1020         XCQL is an XML representation of CQL.
1021         XCQL is part of the SRU specification. However, since SRU
1022         supports CQL only, we don't expect XCQL to be widely used.
1023         Furthermore, CQL has the advantage over XCQL that it is
1024         easy to read.
1025        </para>
1026       </listitem>
1027      </itemizedlist>
1028     </para>
1029     <sect3 id="cql.parsing"><title>CQL parsing</title>
1030      <para>
1031       A CQL parser is represented by the <literal>CQL_parser</literal>
1032       handle. Its contents should be considered &yaz; internal (private).
1033       <synopsis>
1034 #include &lt;yaz/cql.h&gt;
1035
1036 typedef struct cql_parser *CQL_parser;
1037
1038 CQL_parser cql_parser_create(void);
1039 void cql_parser_destroy(CQL_parser cp);
1040       </synopsis>
1041      A parser is created by <function>cql_parser_create</function> and
1042      is destroyed by <function>cql_parser_destroy</function>.
1043      </para>
1044      <para>
1045       To parse a CQL query string, the following function
1046       is provided:
1047       <synopsis>
1048 int cql_parser_string(CQL_parser cp, const char *str);
1049       </synopsis>
1050       A CQL query is parsed by the <function>cql_parser_string</function>
1051       which takes a query <parameter>str</parameter>.
1052       If the query was valid (no syntax errors), then zero is returned;
1053       otherwise -1 is returned to indicate a syntax error.
1054      </para>
1055      <para>
1056       <synopsis>
1057 int cql_parser_stream(CQL_parser cp,
1058                       int (*getbyte)(void *client_data),
1059                       void (*ungetbyte)(int b, void *client_data),
1060                       void *client_data);
1061
1062 int cql_parser_stdio(CQL_parser cp, FILE *f);
1063       </synopsis>
1064       The functions <function>cql_parser_stream</function> and
1065       <function>cql_parser_stdio</function> parses a CQL query
1066       - just like <function>cql_parser_string</function>.
1067       The only difference is that the CQL query can be
1068       fed to the parser in different ways.
1069       The <function>cql_parser_stream</function> uses a generic
1070       byte stream as input. The <function>cql_parser_stdio</function>
1071       uses a <literal>FILE</literal> handle which is opened for reading.
1072      </para>
1073     </sect3>
1074
1075     <sect3 id="cql.tree"><title>CQL tree</title>
1076      <para>
1077       The the query string is valid, the CQL parser
1078       generates a tree representing the structure of the
1079       CQL query.
1080      </para>
1081      <para>
1082       <synopsis>
1083 struct cql_node *cql_parser_result(CQL_parser cp);
1084       </synopsis>
1085       <function>cql_parser_result</function> returns the
1086       a pointer to the root node of the resulting tree.
1087      </para>
1088      <para>
1089       Each node in a CQL tree is represented by a
1090       <literal>struct cql_node</literal>.
1091       It is defined as follows:
1092       <synopsis>
1093 #define CQL_NODE_ST 1
1094 #define CQL_NODE_BOOL 2
1095 #define CQL_NODE_SORT 3
1096 struct cql_node {
1097     int which;
1098     union {
1099         struct {
1100             char *index;
1101             char *index_uri;
1102             char *term;
1103             char *relation;
1104             char *relation_uri;
1105             struct cql_node *modifiers;
1106         } st;
1107         struct {
1108             char *value;
1109             struct cql_node *left;
1110             struct cql_node *right;
1111             struct cql_node *modifiers;
1112         } boolean;
1113         struct {
1114             char *index;
1115             struct cql_node *next;
1116             struct cql_node *modifiers;
1117             struct cql_node *search;
1118         } sort;
1119     } u;
1120 };
1121       </synopsis>
1122       There are three node types: search term (ST), boolean (BOOL)
1123       and sortby (SORT).
1124       A modifier is treated as a search term too.
1125      </para>
1126      <para>
1127       The search term node has five members:
1128       <itemizedlist>
1129        <listitem>
1130         <para>
1131          <literal>index</literal>: index for search term.
1132          If an index is unspecified for a search term,
1133          <literal>index</literal> will be NULL.
1134         </para>
1135        </listitem>
1136        <listitem>
1137         <para>
1138          <literal>index_uri</literal>: index URi for search term
1139          or NULL if none could be resolved for the index.
1140         </para>
1141        </listitem>
1142        <listitem>
1143         <para>
1144          <literal>term</literal>: the search term itself.
1145         </para>
1146        </listitem>
1147        <listitem>
1148         <para>
1149          <literal>relation</literal>: relation for search term.
1150         </para>
1151        </listitem>
1152        <listitem>
1153         <para>
1154          <literal>relation_uri</literal>: relation URI for search term.
1155         </para>
1156        </listitem>
1157        <listitem>
1158         <para>
1159          <literal>modifiers</literal>: relation modifiers for search
1160          term. The <literal>modifiers</literal> list itself of cql_nodes
1161          each of type <literal>ST</literal>.
1162         </para>
1163        </listitem>
1164       </itemizedlist>
1165      </para>
1166
1167      <para>
1168       The boolean node represents <literal>and</literal>,
1169       <literal>or</literal>, <literal>not</literal> +
1170       proximity.
1171       <itemizedlist>
1172        <listitem>
1173         <para>
1174          <literal>left</literal> and <literal>right</literal>: left
1175          - and right operand respectively.
1176         </para>
1177        </listitem>
1178        <listitem>
1179         <para>
1180          <literal>modifiers</literal>: proximity arguments.
1181         </para>
1182        </listitem>
1183       </itemizedlist>
1184      </para>
1185
1186      <para>
1187       The sort node represents both the SORTBY clause.
1188      </para>
1189
1190     </sect3>
1191     <sect3 id="cql.to.pqf"><title>CQL to PQF conversion</title>
1192      <para>
1193       Conversion to PQF (and Z39.50 RPN) is tricky by the fact
1194       that the resulting RPN depends on the Z39.50 target
1195       capabilities (combinations of supported attributes).
1196       In addition, the CQL and SRU operates on index prefixes
1197       (URI or strings), whereas the RPN uses Object Identifiers
1198       for attribute sets.
1199      </para>
1200      <para>
1201       The CQL library of &yaz; defines a <literal>cql_transform_t</literal>
1202       type. It represents a particular mapping between CQL and RPN.
1203       This handle is created and destroyed by the functions:
1204      <synopsis>
1205 cql_transform_t cql_transform_open_FILE (FILE *f);
1206 cql_transform_t cql_transform_open_fname(const char *fname);
1207 void cql_transform_close(cql_transform_t ct);
1208       </synopsis>
1209       The first two functions create a tranformation handle from
1210       either an already open FILE or from a filename respectively.
1211      </para>
1212      <para>
1213       The handle is destroyed by <function>cql_transform_close</function>
1214       in which case no further reference of the handle is allowed.
1215      </para>
1216      <para>
1217       When a <literal>cql_transform_t</literal> handle has been created
1218       you can convert to RPN.
1219       <synopsis>
1220 int cql_transform_buf(cql_transform_t ct,
1221                       struct cql_node *cn, char *out, int max);
1222       </synopsis>
1223       This function converts the CQL tree <literal>cn</literal>
1224       using handle <literal>ct</literal>.
1225       For the resulting PQF, you supply a buffer <literal>out</literal>
1226       which must be able to hold at at least <literal>max</literal>
1227       characters.
1228      </para>
1229      <para>
1230       If conversion failed, <function>cql_transform_buf</function>
1231       returns a non-zero SRU error code; otherwise zero is returned
1232       (conversion successful).  The meanings of the numeric error
1233       codes are listed in the SRU specifications at
1234       <ulink url="&url.sru.diagnostics.list;"/>
1235      </para>
1236      <para>
1237       If conversion fails, more information can be obtained by calling
1238       <synopsis>
1239 int cql_transform_error(cql_transform_t ct, char **addinfop);
1240       </synopsis>
1241       This function returns the most recently returned numeric
1242       error-code and sets the string-pointer at
1243       <literal>*addinfop</literal> to point to a string containing
1244       additional information about the error that occurred: for
1245       example, if the error code is 15 (``Illegal or unsupported context
1246       set''), the additional information is the name of the requested
1247       context set that was not recognised.
1248      </para>
1249      <para>
1250       The SRU error-codes may be translated into brief human-readable
1251       error messages using
1252       <synopsis>
1253 const char *cql_strerror(int code);
1254       </synopsis>
1255      </para>
1256      <para>
1257       If you wish to be able to produce a PQF result in a different
1258       way, there are two alternatives.
1259       <synopsis>
1260 void cql_transform_pr(cql_transform_t ct,
1261                       struct cql_node *cn,
1262                       void (*pr)(const char *buf, void *client_data),
1263                       void *client_data);
1264
1265 int cql_transform_FILE(cql_transform_t ct,
1266                        struct cql_node *cn, FILE *f);
1267       </synopsis>
1268       The former function produces output to a user-defined
1269       output stream. The latter writes the result to an already
1270       open <literal>FILE</literal>.
1271      </para>
1272     </sect3>
1273     <sect3 id="cql.to.rpn">
1274      <title>Specification of CQL to RPN mappings</title>
1275      <para>
1276       The file supplied to functions
1277       <function>cql_transform_open_FILE</function>,
1278       <function>cql_transform_open_fname</function> follows
1279       a structure found in many Unix utilities.
1280       It consists of mapping specifications - one per line.
1281       Lines starting with <literal>#</literal> are ignored (comments).
1282      </para>
1283      <para>
1284       Each line is of the form
1285       <literallayout>
1286        <replaceable>CQL pattern</replaceable><literal> = </literal> <replaceable> RPN equivalent</replaceable>
1287       </literallayout>
1288      </para>
1289      <para>
1290       An RPN pattern is a simple attribute list. Each attribute pair
1291       takes the form:
1292       <literallayout>
1293        [<replaceable>set</replaceable>] <replaceable>type</replaceable><literal>=</literal><replaceable>value</replaceable>
1294       </literallayout>
1295       The attribute <replaceable>set</replaceable> is optional.
1296       The <replaceable>type</replaceable> is the attribute type,
1297       <replaceable>value</replaceable> the attribute value.
1298      </para>
1299      <para>
1300       The character <literal>*</literal> (asterisk) has special meaning
1301       when used in the RPN pattern.
1302       Each occurrence of <literal>*</literal> is substituted with the
1303       CQL matching name (index, relation, qualifier etc).
1304       This facility can be used to copy a CQL name verbatim to the RPN result.
1305      </para>
1306      <para>
1307       The following CQL patterns are recognized:
1308       <variablelist>
1309        <varlistentry><term>
1310          <literal>index.</literal><replaceable>set</replaceable><literal>.</literal><replaceable>name</replaceable>
1311         </term>
1312         <listitem>
1313          <para>
1314           This pattern is invoked when a CQL index, such as
1315           dc.title is converted. <replaceable>set</replaceable>
1316           and <replaceable>name</replaceable> are the context set and index
1317           name respectively.
1318           Typically, the RPN specifies an equivalent use attribute.
1319          </para>
1320          <para>
1321           For terms not bound by an index the pattern
1322           <literal>index.cql.serverChoice</literal> is used.
1323           Here, the prefix <literal>cql</literal> is defined as
1324           <literal>http://www.loc.gov/zing/cql/cql-indexes/v1.0/</literal>.
1325           If this pattern is not defined, the mapping will fail.
1326          </para>
1327          <para>
1328           The pattern,
1329           <literal>index.</literal><replaceable>set</replaceable><literal>.*</literal>
1330           is used when no other index pattern is matched.
1331         </para>
1332         </listitem>
1333        </varlistentry>
1334        <varlistentry><term>
1335          <literal>qualifier.</literal><replaceable>set</replaceable><literal>.</literal><replaceable>name</replaceable>
1336          (DEPRECATED)
1337         </term>
1338         <listitem>
1339          <para>
1340           For backwards compatibility, this is recognised as a synonym of
1341           <literal>index.</literal><replaceable>set</replaceable><literal>.</literal><replaceable>name</replaceable>
1342          </para>
1343         </listitem>
1344        </varlistentry>
1345        <varlistentry><term>
1346          <literal>relation.</literal><replaceable>relation</replaceable>
1347         </term>
1348         <listitem>
1349          <para>
1350           This pattern specifies how a CQL relation is mapped to RPN.
1351           <replaceable>pattern</replaceable> is name of relation
1352           operator. Since <literal>=</literal> is used as
1353           separator between CQL pattern and RPN, CQL relations
1354           including <literal>=</literal> cannot be
1355           used directly. To avoid a conflict, the names
1356           <literal>ge</literal>,
1357           <literal>eq</literal>,
1358           <literal>le</literal>,
1359           must be used for CQL operators, greater-than-or-equal,
1360           equal, less-than-or-equal respectively.
1361           The RPN pattern is supposed to include a relation attribute.
1362          </para>
1363          <para>
1364           For terms not bound by a relation, the pattern
1365           <literal>relation.scr</literal> is used. If the pattern
1366           is not defined, the mapping will fail.
1367          </para>
1368          <para>
1369           The special pattern, <literal>relation.*</literal> is used
1370           when no other relation pattern is matched.
1371          </para>
1372         </listitem>
1373        </varlistentry>
1374
1375        <varlistentry><term>
1376          <literal>relationModifier.</literal><replaceable>mod</replaceable>
1377         </term>
1378         <listitem>
1379          <para>
1380           This pattern specifies how a CQL relation modifier is mapped to RPN.
1381           The RPN pattern is usually a relation attribute.
1382          </para>
1383         </listitem>
1384        </varlistentry>
1385
1386        <varlistentry><term>
1387          <literal>structure.</literal><replaceable>type</replaceable>
1388         </term>
1389         <listitem>
1390          <para>
1391           This pattern specifies how a CQL structure is mapped to RPN.
1392           Note that this CQL pattern is somewhat to similar to
1393           CQL pattern <literal>relation</literal>.
1394           The <replaceable>type</replaceable> is a CQL relation.
1395          </para>
1396          <para>
1397           The pattern, <literal>structure.*</literal> is used
1398           when no other structure pattern is matched.
1399           Usually, the RPN equivalent specifies a structure attribute.
1400          </para>
1401         </listitem>
1402        </varlistentry>
1403
1404        <varlistentry><term>
1405          <literal>position.</literal><replaceable>type</replaceable>
1406         </term>
1407         <listitem>
1408          <para>
1409           This pattern specifies how the anchor (position) of
1410           CQL is mapped to RPN.
1411           The <replaceable>type</replaceable> is one
1412           of <literal>first</literal>, <literal>any</literal>,
1413           <literal>last</literal>, <literal>firstAndLast</literal>.
1414          </para>
1415          <para>
1416           The pattern, <literal>position.*</literal> is used
1417           when no other position pattern is matched.
1418          </para>
1419         </listitem>
1420        </varlistentry>
1421
1422        <varlistentry><term>
1423          <literal>set.</literal><replaceable>prefix</replaceable>
1424         </term>
1425         <listitem>
1426          <para>
1427           This specification defines a CQL context set for a given prefix.
1428           The value on the right hand side is the URI for the set -
1429           <emphasis>not</emphasis> RPN. All prefixes used in
1430           index patterns must be defined this way.
1431          </para>
1432         </listitem>
1433        </varlistentry>
1434
1435        <varlistentry><term>
1436          <literal>set</literal>
1437         </term>
1438         <listitem>
1439          <para>
1440           This specification defines a default CQL context set for index names.
1441           The value on the right hand side is the URI for the set.
1442          </para>
1443         </listitem>
1444        </varlistentry>
1445
1446       </variablelist>
1447      </para>
1448      <example id="example.cql.to.rpn.mapping">
1449       <title>CQL to RPN mapping file</title>
1450       <para>
1451        This simple file defines two context sets, three indexes and three
1452        relations, a position pattern and a default structure.
1453       </para>
1454       <programlisting><![CDATA[
1455        set.cql  = http://www.loc.gov/zing/cql/context-sets/cql/v1.1/
1456        set.dc   = http://www.loc.gov/zing/cql/dc-indexes/v1.0/
1457
1458        index.cql.serverChoice = 1=1016
1459        index.dc.title         = 1=4
1460        index.dc.subject       = 1=21
1461
1462        relation.<             = 2=1
1463        relation.eq            = 2=3
1464        relation.scr           = 2=3
1465
1466        position.any           = 3=3 6=1
1467
1468        structure.*            = 4=1
1469 ]]>
1470       </programlisting>
1471       <para>
1472        With the mappings above, the CQL query
1473        <screen>
1474         computer
1475        </screen>
1476        is converted to the PQF:
1477        <screen>
1478         @attr 1=1016 @attr 2=3 @attr 4=1 @attr 3=3 @attr 6=1 "computer"
1479        </screen>
1480        by rules <literal>index.cql.serverChoice</literal>,
1481        <literal>relation.scr</literal>, <literal>structure.*</literal>,
1482        <literal>position.any</literal>.
1483       </para>
1484       <para>
1485        CQL query
1486        <screen>
1487         computer^
1488        </screen>
1489        is rejected, since <literal>position.right</literal> is
1490        undefined.
1491       </para>
1492       <para>
1493        CQL query
1494        <screen>
1495         >my = "http://www.loc.gov/zing/cql/dc-indexes/v1.0/" my.title = x
1496        </screen>
1497        is converted to
1498        <screen>
1499         @attr 1=4 @attr 2=3 @attr 4=1 @attr 3=3 @attr 6=1 "x"
1500        </screen>
1501       </para>
1502      </example>
1503      <example id="example.cql.to.rpn.string">
1504       <title>CQL to RPN string attributes</title>
1505       <para>
1506        In this example we allow any index to be passed to RPN as
1507        a use attribute.
1508       </para>
1509       <programlisting><![CDATA[
1510        # Identifiers for prefixes used in this file. (index.*)
1511        set.cql  = info:srw/cql-context-set/1/cql-v1.1
1512        set.rpn  = http://bogus/rpn
1513        set      = http://bogus/rpn
1514
1515        # The default index when none is specified by the query
1516        index.cql.serverChoice     = 1=any
1517
1518        index.rpn.*                = 1=*
1519        relation.eq                = 2=3
1520        structure.*                = 4=1
1521        position.any               = 3=3
1522 ]]>
1523       </programlisting>
1524       <para>
1525        The <literal>http://bogus/rpn</literal> context set is also the default
1526        so we can make queries such as
1527        <screen>
1528         title = a
1529        </screen>
1530        which is converted to
1531        <screen>
1532         @attr 2=3 @attr 4=1 @attr 3=3 @attr 1=title "a"
1533        </screen>
1534       </para>
1535      </example>
1536      <example id="example.cql.to.rpn.bathprofile">
1537       <title>CQL to RPN using Bath Profile</title>
1538       <para>
1539        The file <filename>etc/pqf.properties</filename> has mappings from
1540        the Bath Profile and Dublin Core to RPN.
1541        If YAZ is installed as a package it's usually located
1542        in <filename>/usr/share/yaz/etc</filename> and part of the
1543        development package, such as <literal>libyaz-dev</literal>.
1544       </para>
1545      </example>
1546     </sect3>
1547     <sect3 id="cql.xcql"><title>CQL to XCQL conversion</title>
1548      <para>
1549       Conversion from CQL to XCQL is trivial and does not
1550       require a mapping to be defined.
1551       There three functions to choose from depending on the
1552       way you wish to store the resulting output (XML buffer
1553       containing XCQL).
1554       <synopsis>
1555 int cql_to_xml_buf(struct cql_node *cn, char *out, int max);
1556 void cql_to_xml(struct cql_node *cn,
1557                 void (*pr)(const char *buf, void *client_data),
1558                 void *client_data);
1559 void cql_to_xml_stdio(struct cql_node *cn, FILE *f);
1560       </synopsis>
1561       Function <function>cql_to_xml_buf</function> converts
1562       to XCQL and stores result in a user supplied buffer of a given
1563       max size.
1564      </para>
1565      <para>
1566       <function>cql_to_xml</function> writes the result in
1567       a user defined output stream.
1568       <function>cql_to_xml_stdio</function> writes to a
1569       a file.
1570      </para>
1571     </sect3>
1572     <sect3 id="rpn.to.cql">
1573      <title>PQF to CQL conversion</title>
1574      <para>
1575       Conversion from PQF to CQL is offered by the two functions shown
1576       below. The former uses a generic stream for result. The latter
1577       puts result in a WRBUF (string container).
1578      <synopsis>
1579 #include &lt;yaz/rpn2cql.h>
1580
1581 int cql_transform_rpn2cql_stream(cql_transform_t ct,
1582                                  void (*pr)(const char *buf, void *client_data),
1583                                  void *client_data,
1584                                  Z_RPNQuery *q);
1585
1586 int cql_transform_rpn2cql_wrbuf(cql_transform_t ct,
1587                                 WRBUF w,
1588                                 Z_RPNQuery *q);
1589       </synopsis>
1590       The configuration is the same as used in CQL to PQF conversions.
1591      </para>
1592     </sect3>
1593    </sect2>
1594   </sect1>
1595   <sect1 id="tools.oid"><title>Object Identifiers</title>
1596
1597    <para>
1598     The basic YAZ representation of an OID is an array of integers,
1599     terminated with the value -1. This integer is of type
1600     <literal>Odr_oid</literal>.
1601    </para>
1602    <para>
1603     Fundamental OID operations and the type <literal>Odr_oid</literal>
1604     are defined in <filename>yaz/oid_util.h</filename>.
1605    </para>
1606    <para>
1607     An OID can either be declared as a automatic variable or it can
1608     allocated using the memory utilities or ODR/NMEM. It's
1609     guaranteed that an OID can fit in <literal>OID_SIZE</literal> integers.
1610    </para>
1611    <example id="tools.oid.bib1.1"><title>Create OID on stack</title>
1612     <para>
1613      We can create an OID for the Bib-1 attribute set with:
1614      <screen>
1615       Odr_oid bib1[OID_SIZE];
1616       bib1[0] = 1;
1617       bib1[1] = 2;
1618       bib1[2] = 840;
1619       bib1[3] = 10003;
1620       bib1[4] = 3;
1621       bib1[5] = 1;
1622       bib1[6] = -1;
1623      </screen>
1624     </para>
1625    </example>
1626    <para>
1627     And OID may also be filled from a string-based representation using
1628     dots (.). This is achieved by function
1629     <screen>
1630      int oid_dotstring_to_oid(const char *name, Odr_oid *oid);
1631     </screen>
1632     This functions returns 0 if name could be converted; -1 otherwise.
1633    </para>
1634    <example id="tools.oid.bib1.2"><title>Using oid_oiddotstring_to_oid</title>
1635     <para>
1636      We can fill the Bib-1 attribute set OID easier with:
1637      <screen>
1638       Odr_oid bib1[OID_SIZE];
1639       oid_oiddotstring_to_oid("1.2.840.10003.3.1", bib1);
1640      </screen>
1641    </para>
1642    </example>
1643    <para>
1644     We can also allocate an OID dynamically on a ODR stream with:
1645    <screen>
1646     Odr_oid *odr_getoidbystr(ODR o, const char *str);
1647    </screen>
1648     This creates an OID from string-based representation using dots.
1649     This function take an &odr; stream as parameter. This stream is used to
1650     allocate memory for the data elements, which is released on a
1651     subsequent call to <function>odr_reset()</function> on that stream.
1652    </para>
1653
1654    <example id="tools.oid.bib1.3"><title>Using odr_getoidbystr</title>
1655     <para>
1656      We can create a OID for the Bib-1 attribute set with:
1657      <screen>
1658       Odr_oid *bib1 = odr_getoidbystr(odr, "1.2.840.10003.3.1");
1659      </screen>
1660     </para>
1661    </example>
1662
1663    <para>
1664     The function
1665     <screen>
1666      char *oid_oid_to_dotstring(const Odr_oid *oid, char *oidbuf)
1667     </screen>
1668     does the reverse of <function>oid_oiddotstring_to_oid</function>. It
1669     converts an OID to the string-based representation using dots.
1670     The supplied char buffer <literal>oidbuf</literal> holds the resulting
1671     string and must be at least <literal>OID_STR_MAX</literal> in size.
1672    </para>
1673
1674    <para>
1675     OIDs can be copied with <function>oid_oidcpy</function> which takes
1676     two OID lists as arguments. Alternativly, an OID copy can be allocated
1677     on a ODR stream with:
1678     <screen>
1679      Odr_oid *odr_oiddup(ODR odr, const Odr_oid *o);
1680     </screen>
1681    </para>
1682
1683    <para>
1684     OIDs can be compared with <function>oid_oidcmp</function> which returns
1685     zero if the two OIDs provided are identical; non-zero otherwise.
1686    </para>
1687
1688    <sect2 id="tools.oid.database"><title>OID database</title>
1689     <para>
1690      From YAZ version 3 and later, the oident system has been replaced
1691      by an OID database. OID database is a misnomer .. the old odient
1692      system was also a database.
1693     </para>
1694     <para>
1695      The OID database is really just a map between named Object Identifiers
1696      (string) and their OID raw equivalents. Most operations either
1697      convert from string to OID or other way around.
1698     </para>
1699     <para>
1700      Unfortunately, whenever we supply a string we must also specify the
1701      <emphasis>OID class</emphasis>. The class is necessary because some
1702      strings correspond to multiple OIDs. An example of such a string is
1703      <literal>Bib-1</literal> which may either be an attribute-set
1704      or a diagnostic-set.
1705     </para>
1706     <para>
1707      Applications using the YAZ database should include
1708      <filename>yaz/oid_db.h</filename>.
1709     </para>
1710     <para>
1711      A YAZ database handle is of type <literal>yaz_oid_db_t</literal>.
1712      Actually that's a pointer. You need not think deal with that.
1713      YAZ has a built-in database which can be considered "constant" for
1714      most purposes.
1715      We can get hold that by using function <function>yaz_oid_std</function>.
1716     </para>
1717     <para>
1718      All functions with prefix <function>yaz_string_to_oid</function>
1719      converts from class + string to OID. We have variants of this
1720      operation due to different memory allocation strategies.
1721     </para>
1722     <para>
1723      All functions with prefix
1724      <function>yaz_oid_to_string</function> converts from OID to string
1725      + class.
1726     </para>
1727
1728     <example id="tools.oid.bib1.4"><title>Create OID with YAZ DB</title>
1729      <para>
1730       We can create an OID for the Bib-1 attribute set on the ODR stream
1731       odr with:
1732      <screen>
1733         Odr_oid *bib1 =
1734          yaz_string_to_oid_odr(yaz_oid_std(), CLASS_ATTSET, "Bib-1", odr);
1735       </screen>
1736       This is more complex than using <function>odr_getoidbystr</function>.
1737       You would only use <function>yaz_string_to_oid_odr</function> when the
1738       string (here Bib-1) is supplied by a user or configuration.
1739      </para>
1740     </example>
1741
1742    </sect2>
1743    <sect2 id="tools.oid.std"><title>Standard OIDs</title>
1744
1745     <para>
1746      All the object identifers in the standard OID database as returned
1747      by <function>yaz_oid_std</function> can referenced directly in a
1748      program as a constant OID.
1749      Each constant OID is prefixed with <literal>yaz_oid_</literal> -
1750      followed by OID class (lowercase) - then by OID name (normalized and
1751      lowercase).
1752     </para>
1753     <para>
1754      See <xref linkend="list-oids"/> for list of all object identifiers
1755      built into YAZ.
1756      These are declared in <filename>yaz/oid_std.h</filename> but are
1757      included by <filename>yaz/oid_db.h</filename> as well.
1758     </para>
1759
1760     <example id="tools.oid.bib1.5"><title>Use a built-in OID</title>
1761      <para>
1762       We can allocate our own OID filled with the constant OID for
1763       Bib-1 with:
1764       <screen>
1765         Odr_oid *bib1 = odr_oiddup(o, yaz_oid_attset_bib1);
1766       </screen>
1767      </para>
1768     </example>
1769    </sect2>
1770   </sect1>
1771   <sect1 id="tools.nmem"><title>Nibble Memory</title>
1772
1773    <para>
1774     Sometimes when you need to allocate and construct a large,
1775     interconnected complex of structures, it can be a bit of a pain to
1776     release the associated memory again. For the structures describing the
1777     Z39.50 PDUs and related structures, it is convenient to use the
1778     memory-management system of the &odr; subsystem (see
1779     <xref linkend="odr.use"/>). However, in some circumstances
1780     where you might otherwise benefit from using a simple nibble memory
1781     management system, it may be impractical to use
1782     <function>odr_malloc()</function> and <function>odr_reset()</function>.
1783     For this purpose, the memory manager which also supports the &odr;
1784     streams is made available in the NMEM module. The external interface
1785     to this module is given in the <filename>nmem.h</filename> file.
1786    </para>
1787
1788    <para>
1789     The following prototypes are given:
1790    </para>
1791
1792    <screen>
1793     NMEM nmem_create(void);
1794     void nmem_destroy(NMEM n);
1795     void *nmem_malloc(NMEM n, size_t size);
1796     void nmem_reset(NMEM n);
1797     size_t nmem_total(NMEM n);
1798     void nmem_init(void);
1799     void nmem_exit(void);
1800    </screen>
1801
1802    <para>
1803     The <function>nmem_create()</function> function returns a pointer to a
1804     memory control handle, which can be released again by
1805     <function>nmem_destroy()</function> when no longer needed.
1806     The function <function>nmem_malloc()</function> allocates a block of
1807     memory of the requested size. A call to <function>nmem_reset()</function>
1808     or <function>nmem_destroy()</function> will release all memory allocated
1809     on the handle since it was created (or since the last call to
1810     <function>nmem_reset()</function>. The function
1811     <function>nmem_total()</function> returns the number of bytes currently
1812     allocated on the handle.
1813    </para>
1814
1815    <para>
1816     The nibble memory pool is shared amongst threads. POSIX
1817     mutex'es and WIN32 Critical sections are introduced to keep the
1818     module thread safe. Function <function>nmem_init()</function>
1819     initializes the nibble memory library and it is called automatically
1820     the first time the <literal>YAZ.DLL</literal> is loaded. &yaz; uses
1821     function <function>DllMain</function> to achieve this. You should
1822     <emphasis>not</emphasis> call <function>nmem_init</function> or
1823     <function>nmem_exit</function> unless you're absolute sure what
1824     you're doing. Note that in previous &yaz; versions you'd have to call
1825     <function>nmem_init</function> yourself.
1826    </para>
1827
1828   </sect1>
1829
1830   <sect1 id="tools.log"><title>Log</title>
1831   <para>
1832    &yaz; has evolved a fairly complex log system which should be useful both
1833    for debugging &yaz; itself, debugging applications that use &yaz;, and for
1834    production use of those applications.
1835   </para>
1836   <para>
1837    The log functions are declared in header <filename>yaz/log.h</filename>
1838     and implemented in <filename>src/log.c</filename>.
1839     Due to name clash with syslog and some math utilities the logging
1840     interface has been modified as of YAZ 2.0.29. The obsolete interface
1841     is still available if in header file <filename>yaz/log.h</filename>.
1842     The key points of the interface are:
1843   </para>
1844   <screen>
1845    void yaz_log(int level, const char *fmt, ...)
1846
1847    void yaz_log_init(int level, const char *prefix, const char *name);
1848    void yaz_log_init_file(const char *fname);
1849    void yaz_log_init_level(int level);
1850    void yaz_log_init_prefix(const char *prefix);
1851    void yaz_log_time_format(const char *fmt);
1852    void yaz_log_init_max_size(int mx);
1853
1854    int yaz_log_mask_str(const char *str);
1855    int yaz_log_module_level(const char *name);
1856   </screen>
1857
1858   <para>
1859    The reason for the whole log module is the <function>yaz_log</function>
1860    function. It takes a bitmask indicating the log levels, a
1861    <literal>printf</literal>-like format string, and a variable number of
1862    arguments to log.
1863   </para>
1864
1865   <para>
1866    The <literal>log level</literal> is a bit mask, that says on which level(s)
1867    the log entry should be made, and optionally set some behaviour of the
1868    logging. In the most simple cases, it can be one of <literal>YLOG_FATAL,
1869    YLOG_DEBUG, YLOG_WARN, YLOG_LOG</literal>. Those can be combined with bits
1870    that modify the way the log entry is written:<literal>YLOG_ERRNO,
1871    YLOG_NOTIME, YLOG_FLUSH</literal>.
1872    Most of the rest of the bits are deprecated, and should not be used. Use
1873    the dynamic log levels instead.
1874   </para>
1875
1876   <para>
1877    Applications that use &yaz;, should not use the LOG_LOG for ordinary
1878    messages, but should make use of the dynamic loglevel system. This consists
1879    of two parts, defining the loglevel and checking it.
1880   </para>
1881
1882   <para>
1883    To define the log levels, the (main) program should pass a string to
1884    <function>yaz_log_mask_str</function> to define which log levels are to be
1885    logged. This string should be a comma-separated list of log level names,
1886    and can contain both hard-coded names and dynamic ones. The log level
1887    calculation starts with <literal>YLOG_DEFAULT_LEVEL</literal> and adds a bit
1888    for each word it meets, unless the word starts with a '-', in which case it
1889    clears the bit. If the string <literal>'none'</literal> is found,
1890    all bits are cleared. Typically this string comes from the command-line,
1891    often identified by <literal>-v</literal>. The
1892    <function>yaz_log_mask_str</function> returns a log level that should be
1893    passed to <function>yaz_log_init_level</function> for it to take effect.
1894   </para>
1895
1896   <para>
1897    Each module should check what log bits it should be used, by calling
1898    <function>yaz_log_module_level</function> with a suitable name for the
1899    module. The name is cleared from a preceding path and an extension, if any,
1900    so it is quite possible to use <literal>__FILE__</literal> for it. If the
1901    name has been passed to <function>yaz_log_mask_str</function>, the routine
1902    returns a non-zero bitmask, which should then be used in consequent calls
1903    to yaz_log. (It can also be tested, so as to avoid unnecessary calls to
1904    yaz_log, in time-critical places, or when the log entry would take time
1905    to construct.)
1906   </para>
1907
1908   <para>
1909    Yaz uses the following dynamic log levels:
1910    <literal>server, session, request, requestdetail</literal> for the server
1911    functionality.
1912    <literal>zoom</literal> for the zoom client api.
1913    <literal>ztest</literal> for the simple test server.
1914    <literal>malloc, nmem, odr, eventl</literal> for internal debugging of yaz itself.
1915    Of course, any program using yaz is welcome to define as many new ones, as
1916    it needs.
1917   </para>
1918
1919   <para>
1920    By default the log is written to stderr, but this can be changed by a call
1921    to <function>yaz_log_init_file</function> or
1922    <function>yaz_log_init</function>. If the log is directed to a file, the
1923    file size is checked at every write, and if it exceeds the limit given in
1924    <function>yaz_log_init_max_size</function>, the log is rotated. The
1925    rotation keeps one old version (with a <literal>.1</literal> appended to
1926    the name). The size defaults to 1GB. Setting it to zero will disable the
1927    rotation feature.
1928   </para>
1929
1930   <screen>
1931   A typical yaz-log looks like this
1932   13:23:14-23/11 yaz-ztest(1) [session] Starting session from tcp:127.0.0.1 (pid=30968)
1933   13:23:14-23/11 yaz-ztest(1) [request] Init from 'YAZ' (81) (ver 2.0.28) OK
1934   13:23:17-23/11 yaz-ztest(1) [request] Search Z: @attrset Bib-1 foo  OK:7 hits
1935   13:23:22-23/11 yaz-ztest(1) [request] Present: [1] 2+2  OK 2 records returned
1936   13:24:13-23/11 yaz-ztest(1) [request] Close OK
1937   </screen>
1938
1939   <para>
1940    The log entries start with a time stamp. This can be omitted by setting the
1941    <literal>YLOG_NOTIME</literal> bit in the loglevel. This way automatic tests
1942    can be hoped to produce identical log files, that are easy to diff. The
1943    format of the time stamp can be set with
1944    <function>yaz_log_time_format</function>, which takes a format string just
1945    like <function>strftime</function>.
1946   </para>
1947
1948   <para>
1949    Next in a log line comes the prefix, often the name of the program. For
1950    yaz-based servers, it can also contain the session number. Then
1951    comes one or more logbits in square brackets, depending on the logging
1952    level set by <function>yaz_log_init_level</function> and the loglevel
1953    passed to <function>yaz_log_init_level</function>. Finally comes the format
1954    string and additional values passed to <function>yaz_log</function>
1955   </para>
1956
1957   <para>
1958    The log level <literal>YLOG_LOGLVL</literal>, enabled by the string
1959    <literal>loglevel</literal>, will log all the log-level affecting
1960    operations. This can come in handy if you need to know what other log
1961    levels would be useful. Grep the logfile for <literal>[loglevel]</literal>.
1962   </para>
1963
1964   <para>
1965    The log system is almost independent of the rest of &yaz;, the only
1966    important dependence is of <filename>nmem</filename>, and that only for
1967    using the semaphore definition there.
1968   </para>
1969
1970   <para>
1971    The dynamic log levels and log rotation were introduced in &yaz; 2.0.28. At
1972    the same time, the log bit names were changed from
1973    <literal>LOG_something</literal> to <literal>YLOG_something</literal>,
1974    to avoid collision with <filename>syslog.h</filename>.
1975   </para>
1976
1977   </sect1>
1978
1979   <sect1 id="marc"><title>MARC</title>
1980
1981    <para>
1982     YAZ provides a fast utility for working with MARC records.
1983     Early versions of the MARC utility only allowed decoding of ISO2709.
1984     Today the utility may both encode - and decode to a varity of formats.
1985    </para>
1986    <synopsis><![CDATA[
1987     #include <yaz/marcdisp.h>
1988
1989     /* create handler */
1990     yaz_marc_t yaz_marc_create(void);
1991     /* destroy */
1992     void yaz_marc_destroy(yaz_marc_t mt);
1993
1994     /* set XML mode YAZ_MARC_LINE, YAZ_MARC_SIMPLEXML, ... */
1995     void yaz_marc_xml(yaz_marc_t mt, int xmlmode);
1996     #define YAZ_MARC_LINE      0
1997     #define YAZ_MARC_SIMPLEXML 1
1998     #define YAZ_MARC_OAIMARC   2
1999     #define YAZ_MARC_MARCXML   3
2000     #define YAZ_MARC_ISO2709   4
2001     #define YAZ_MARC_XCHANGE   5
2002     #define YAZ_MARC_CHECK     6
2003     #define YAZ_MARC_TURBOMARC 7
2004
2005     /* supply iconv handle for character set conversion .. */
2006     void yaz_marc_iconv(yaz_marc_t mt, yaz_iconv_t cd);
2007
2008     /* set debug level, 0=none, 1=more, 2=even more, .. */
2009     void yaz_marc_debug(yaz_marc_t mt, int level);
2010
2011     /* decode MARC in buf of size bsize. Returns >0 on success; <=0 on failure.
2012     On success, result in *result with size *rsize. */
2013     int yaz_marc_decode_buf(yaz_marc_t mt, const char *buf, int bsize,
2014                             const char **result, size_t *rsize);
2015
2016     /* decode MARC in buf of size bsize. Returns >0 on success; <=0 on failure.
2017        On success, result in WRBUF */
2018     int yaz_marc_decode_wrbuf(yaz_marc_t mt, const char *buf,
2019                               int bsize, WRBUF wrbuf);
2020 ]]>
2021    </synopsis>
2022    <note>
2023     <para>
2024      The synopsis is just a basic subset of all functionality. Refer
2025      to the actual header file <filename>marcdisp.h</filename> for
2026      details.
2027     </para>
2028    </note>
2029    <para>
2030     A MARC conversion handle must be created by using
2031     <function>yaz_marc_create</function> and destroyed
2032     by calling <function>yaz_marc_destroy</function>.
2033   </para>
2034    <para>
2035     All other function operate on a <literal>yaz_marc_t</literal> handle.
2036     The output is specified by a call to <function>yaz_marc_xml</function>.
2037     The <literal>xmlmode</literal> must be one of
2038     <variablelist>
2039      <varlistentry>
2040       <term>YAZ_MARC_LINE</term>
2041       <listitem>
2042        <para>
2043         A simple line-by-line format suitable for display but not
2044         recommend for further (machine) processing.
2045        </para>
2046       </listitem>
2047      </varlistentry>
2048
2049      <varlistentry>
2050       <term>YAZ_MARC_MARCXML</term>
2051       <listitem>
2052        <para>
2053         <ulink url="&url.marcxml;">MARCXML</ulink>.
2054        </para>
2055       </listitem>
2056      </varlistentry>
2057
2058      <varlistentry>
2059       <term>YAZ_MARC_ISO2709</term>
2060       <listitem>
2061        <para>
2062         ISO2709 (sometimes just referred to as "MARC").
2063        </para>
2064       </listitem>
2065      </varlistentry>
2066
2067      <varlistentry>
2068       <term>YAZ_MARC_XCHANGE</term>
2069       <listitem>
2070        <para>
2071         <ulink url="&url.marcxchange;">MarcXchange</ulink>.
2072        </para>
2073       </listitem>
2074      </varlistentry>
2075
2076      <varlistentry>
2077       <term>YAZ_MARC_CHECK</term>
2078       <listitem>
2079        <para>
2080         Pseudo format for validation only. Does not generate
2081         any real output except diagnostics.
2082        </para>
2083       </listitem>
2084      </varlistentry>
2085
2086      <varlistentry>
2087       <term>YAZ_MARC_TURBOMARC</term>
2088       <listitem>
2089        <para>
2090         XML format with same semantics as MARCXML but more compact
2091         and geared towards fast processing with XSLT. Refer to
2092         <xref linkend="tools.turbomarc"/> for more information.
2093        </para>
2094       </listitem>
2095      </varlistentry>
2096
2097     </variablelist>
2098    </para>
2099    <para>
2100     The actual conversion functions are
2101     <function>yaz_marc_decode_buf</function> and
2102     <function>yaz_marc_decode_wrbuf</function> which decodes and encodes
2103     a MARC record. The former function operates on simple buffers, the
2104     stores the resulting record in a WRBUF handle (WRBUF is a simple string
2105     type).
2106    </para>
2107    <example id="example.marc.display">
2108     <title>Display of MARC record</title>
2109     <para>
2110      The following program snippet illustrates how the MARC API may
2111      be used to convert a MARC record to the line-by-line format:
2112      <programlisting><![CDATA[
2113       void print_marc(const char *marc_buf, int marc_buf_size)
2114       {
2115          char *result;      /* for result buf */
2116          size_t result_len;    /* for size of result */
2117          yaz_marc_t mt = yaz_marc_create();
2118          yaz_marc_xml(mt, YAZ_MARC_LINE);
2119          yaz_marc_decode_buf(mt, marc_buf, marc_buf_size,
2120                              &result, &result_len);
2121          fwrite(result, result_len, 1, stdout);
2122          yaz_marc_destroy(mt);  /* note that result is now freed... */
2123       }
2124 ]]>
2125       </programlisting>
2126     </para>
2127    </example>
2128    <sect2 id="tools.turbomarc">
2129     <title>TurboMARC</title>
2130     <para>
2131      TurboMARC is yet another XML encoding of a MARC record. The format
2132      was designed for fast processing with XSLT.
2133     </para>
2134     <para>
2135      Applications like
2136      Pazpar2 uses XSLT to convert an XML encoded MARC record to an internal
2137      representation. This conversion mostly check the tag of a MARC field
2138      to determine the basic rules in the conversion. This check is
2139      costly when that is tag is encoded as an attribute in MARCXML.
2140      By having the tag value as the element instead, makes processing
2141      many times faster (at least for Libxslt).
2142     </para>
2143     <para>
2144      TurboMARC is encoded as follows:
2145      <itemizedlist>
2146       <listitem><para>
2147         Record elements is part of namespace
2148         "<literal>http://www.indexdata.com/turbomarc</literal>".
2149        </para></listitem>
2150       <listitem><para>
2151         A record is enclosed in element <literal>r</literal>.
2152        </para></listitem>
2153       <listitem><para>
2154         A collection of records is enclosed in element
2155         <literal>collection</literal>.
2156        </para></listitem>
2157       <listitem><para>
2158         The leader is encoded as element <literal>l</literal> with the
2159         leader content as its (text) value.
2160        </para></listitem>
2161       <listitem><para>
2162         A control field is encoded as element <literal>c</literal> concatenated
2163         with the tag value of the control field if the tag value
2164         matches the regular expression <literal>[a-zA-Z0-9]*</literal>.
2165         If the tag value do not match the regular expression
2166         <literal>[a-zA-Z0-9]*</literal> the control field is encoded
2167         as element <literal>c</literal> and attribute <literal>code</literal>
2168         will hold the tag value.
2169         This rule ensure that in the rare cases where a tag value might
2170         result in a non-wellformed XML YAZ encode it as a coded attribute
2171         (as in MARCXML).
2172        </para>
2173        <para>
2174         The control field content is the the text value of this element.
2175         Indicators are encoded as attribute names
2176         <literal>i1</literal>, <literal>i2</literal>, etc.. and
2177         corresponding values for each indicator.
2178        </para></listitem>
2179       <listitem><para>
2180         A data field is encoded as element <literal>d</literal> concatenated
2181         with the tag value of the data field or using the attribute
2182         <literal>code</literal> as described in the rules for control fields.
2183         The children of the data field element is subfield elements.
2184         Each subfield element is encoded as <literal>s</literal>
2185         concatenated with the sub field code.
2186         The text of the subfield element is the contents of the subfield.
2187         Indicators are encoded as attributes for the data field element similar
2188         to the encoding for control fields.
2189        </para></listitem>
2190      </itemizedlist>
2191     </para>
2192    </sect2>
2193   </sect1>
2194
2195   <sect1 id="tools.retrieval">
2196    <title>Retrieval Facility</title>
2197    <para>
2198     YAZ version 2.1.20 or later includes a Retrieval facility tool
2199     which allows a SRU/Z39.50 to describe itself and perform record
2200     conversions. The idea is the following:
2201
2202     <itemizedlist>
2203      <listitem>
2204       <para>
2205        An SRU/Z39.50 client sends a retrieval request which includes
2206        a combination of the following parameters: syntax (format),
2207        schema (or element set name).
2208       </para>
2209      </listitem>
2210
2211      <listitem>
2212       <para>
2213        The retrieval facility is invoked with parameters in a
2214        server/proxy. The retrieval facility matches the parameters a set of
2215        "supported" retrieval types.
2216        If there is no match, the retrieval signals an error
2217        (syntax and / or schema not supported).
2218       </para>
2219      </listitem>
2220
2221      <listitem>
2222       <para>
2223        For a successful match, the backend is invoked with the same
2224        or altered retrieval parameters (syntax, schema). If
2225        a record is received from the backend, it is converted to the
2226        frontend name / syntax.
2227       </para>
2228      </listitem>
2229
2230      <listitem>
2231       <para>
2232        The resulting record is sent back the client and tagged with
2233        the frontend syntax / schema.
2234       </para>
2235      </listitem>
2236
2237     </itemizedlist>
2238    </para>
2239    <para>
2240     The Retrieval facility is driven by an XML configuration. The
2241     configuration is neither Z39.50 ZeeRex or SRU ZeeRex. But it
2242     should be easy to generate both of them from the XML configuration.
2243     (unfortunately the two versions
2244     of ZeeRex differ substantially in this regard).
2245    </para>
2246    <sect2 id="tools.retrieval.format">
2247     <title>Retrieval XML format</title>
2248     <para>
2249      All elements should be covered by namespace
2250      <literal>http://indexdata.com/yaz</literal> .
2251      The root element node must be <literal>retrievalinfo</literal>.
2252     </para>
2253     <para>
2254      The <literal>retrievalinfo</literal> must include one or
2255      more <literal>retrieval</literal> elements. Each
2256     <literal>retrieval</literal> defines specific combination of
2257      syntax, name and identifier supported by this retrieval service.
2258     </para>
2259     <para>
2260      The <literal>retrieval</literal> element may include any of the
2261      following attributes:
2262      <variablelist>
2263       <varlistentry><term><literal>syntax</literal> (REQUIRED)</term>
2264        <listitem>
2265         <para>
2266          Defines the record syntax. Possible values is any
2267          of the names defined in YAZ' OID database or a raw
2268          OID in (n.n ... n).
2269         </para>
2270        </listitem>
2271       </varlistentry>
2272       <varlistentry><term><literal>name</literal> (OPTIONAL)</term>
2273        <listitem>
2274         <para>
2275          Defines the name of the retrieval format. This can be
2276          any string. For SRU, the value, is equivalent to schema (short-hand);
2277          for Z39.50 it's equivalent to simple element set name.
2278          For YAZ 3.0.24 and later this name may be specified as a glob
2279          expression with operators
2280          <literal>*</literal> and <literal>?</literal>.
2281         </para>
2282        </listitem>
2283       </varlistentry>
2284       <varlistentry><term><literal>identifier</literal> (OPTIONAL)</term>
2285        <listitem>
2286         <para>
2287          Defines the URI schema name of the retrieval format. This can be
2288          any string. For SRU, the value, is equivalent to URI schema.
2289          For Z39.50, there is no equivalent.
2290         </para>
2291        </listitem>
2292       </varlistentry>
2293      </variablelist>
2294     </para>
2295     <para>
2296      The <literal>retrieval</literal> may include one
2297      <literal>backend</literal> element. If a <literal>backend</literal>
2298      element is given, it specifies how the records are retrieved by
2299      some backend and how the records are converted from the backend to
2300      the "frontend".
2301     </para>
2302     <para>
2303      The attributes, <literal>name</literal> and <literal>syntax</literal>
2304      may be specified for the <literal>backend</literal> element. These
2305      semantics of these attributes is equivalent to those for the
2306      <literal>retrieval</literal>. However, these values are passed to
2307      the "backend".
2308     </para>
2309     <para>
2310      The <literal>backend</literal> element may includes one or more
2311      conversion instructions (as children elements). The supported
2312      conversions are:
2313      <variablelist>
2314       <varlistentry><term><literal>marc</literal></term>
2315        <listitem>
2316         <para>
2317          The <literal>marc</literal> element specifies a conversion
2318          to - and from ISO2709 encoded MARC and
2319          <ulink url="&url.marcxml;">&acro.marcxml;</ulink>/MarcXchange.
2320          The following attributes may be specified:
2321
2322          <variablelist>
2323           <varlistentry><term><literal>inputformat</literal> (REQUIRED)</term>
2324            <listitem>
2325             <para>
2326              Format of input. Supported values are
2327             <literal>marc</literal> (for ISO2709); and <literal>xml</literal>
2328              for MARCXML/MarcXchange.
2329             </para>
2330            </listitem>
2331           </varlistentry>
2332
2333           <varlistentry><term><literal>outputformat</literal> (REQUIRED)</term>
2334            <listitem>
2335             <para>
2336              Format of output. Supported values are
2337             <literal>line</literal> (MARC line format);
2338             <literal>marcxml</literal> (for MARCXML),
2339             <literal>marc</literal> (ISO2709),
2340             <literal>marcxhcange</literal> (for MarcXchange).
2341             </para>
2342            </listitem>
2343           </varlistentry>
2344
2345           <varlistentry><term><literal>inputcharset</literal> (OPTIONAL)</term>
2346            <listitem>
2347             <para>
2348              Encoding of input. For XML input formats, this need not
2349              be given, but for ISO2709 based inputformats, this should
2350              be set to the encoding used. For MARC21 records, a common
2351              inputcharset value  would be <literal>marc-8</literal>.
2352             </para>
2353            </listitem>
2354           </varlistentry>
2355
2356           <varlistentry><term><literal>outputcharset</literal> (OPTIONAL)</term>
2357            <listitem>
2358             <para>
2359              Encoding of output. If outputformat is XML based, it is
2360              strongly recommened to use <literal>utf-8</literal>.
2361             </para>
2362            </listitem>
2363           </varlistentry>
2364
2365          </variablelist>
2366         </para>
2367        </listitem>
2368       </varlistentry>
2369       <varlistentry><term><literal>xslt</literal></term>
2370        <listitem>
2371         <para>
2372          The <literal>xslt</literal> element specifies a conversion
2373          via &acro.xslt;. The following attributes may be specified:
2374
2375          <variablelist>
2376           <varlistentry><term><literal>stylesheet</literal> (REQUIRED)</term>
2377            <listitem>
2378             <para>
2379              Stylesheet file.
2380             </para>
2381            </listitem>
2382           </varlistentry>
2383          </variablelist>
2384
2385         </para>
2386        </listitem>
2387       </varlistentry>
2388      </variablelist>
2389     </para>
2390    </sect2>
2391    <sect2 id="tools.retrieval.examples">
2392     <title>Retrieval Facility Examples</title>
2393     <example id="tools.retrieval.marc21">
2394      <title>MARC21 backend</title>
2395      <para>
2396       A typical way to use the retrieval facility is to enable XML
2397       for servers that only supports ISO2709 encoded MARC21 records.
2398      </para>
2399      <programlisting><![CDATA[
2400      <retrievalinfo>
2401        <retrieval syntax="usmarc" name="F"/>
2402        <retrieval syntax="usmarc" name="B"/>
2403        <retrieval syntax="xml" name="marcxml"
2404                   identifier="info:srw/schema/1/marcxml-v1.1">
2405          <backend syntax="usmarc" name="F">
2406            <marc inputformat="marc" outputformat="marcxml"
2407                  inputcharset="marc-8"/>
2408          </backend>
2409        </retrieval>
2410        <retrieval syntax="xml" name="dc">
2411          <backend syntax="usmarc" name="F">
2412            <marc inputformat="marc" outputformat="marcxml"
2413                  inputcharset="marc-8"/>
2414            <xslt stylesheet="MARC21slim2DC.xsl"/>
2415          </backend>
2416        </retrieval>
2417      </retrievalinfo>
2418 ]]>
2419      </programlisting>
2420      <para>
2421       This means that our frontend supports:
2422       <itemizedlist>
2423        <listitem>
2424         <para>
2425          MARC21 F(ull) records.
2426         </para>
2427        </listitem>
2428        <listitem>
2429         <para>
2430          MARC21 B(rief) records.
2431         </para>
2432        </listitem>
2433
2434        <listitem>
2435         <para>
2436          MARCXML records.
2437         </para>
2438        </listitem>
2439
2440        <listitem>
2441         <para>
2442          Dublin core records.
2443         </para>
2444        </listitem>
2445       </itemizedlist>
2446      </para>
2447     </example>
2448    </sect2>
2449    <sect2 id="tools.retrieval.api">
2450     <title>API</title>
2451     <para>
2452      It should be easy to use the retrieval systems from applications. Refer
2453      to the headers
2454      <filename>yaz/retrieval.h</filename> and
2455      <filename>yaz/record_conv.h</filename>.
2456     </para>
2457    </sect2>
2458   </sect1>
2459  </chapter>
2460
2461  <!-- Keep this comment at the end of the file
2462  Local variables:
2463  mode: sgml
2464  sgml-omittag:t
2465  sgml-shorttag:t
2466  sgml-minimize-attributes:nil
2467  sgml-always-quote-attributes:t
2468  sgml-indent-step:1
2469  sgml-indent-data:t
2470  sgml-parent-document: "yaz.xml"
2471  sgml-local-catalogs: nil
2472  sgml-namecase-general:t
2473  End:
2474  -->