Documentation for client-side CQL.

[ZOOM-Perl-moved-to-github.git] / lib / ZOOM.pod

diff --git a/lib/ZOOM.pod b/lib/ZOOM.pod
index ebd3c55..f0d8dec 100644 (file)
--- a/lib/ZOOM.pod
+++ b/lib/ZOOM.pod
@@ -1,4 +1,6 @@
-# $Id: ZOOM.pod,v 1.20 2005-12-13 16:03:14 mike Exp $
+### Add documentation for logging.
+
+# $Id: ZOOM.pod,v 1.26 2005-12-22 11:58:03 mike Exp $

 
 use strict;
 use warnings;
 
 use strict;
 use warnings;

@@ -38,8 +40,8 @@ API such as ZOOM is that all implementations should be compatible
 anyway; but knowing that the same code is running is reassuring.)
 
 The ZOOM module provides two enumerations (C<ZOOM::Error> and
 anyway; but knowing that the same code is running is reassuring.)
 
 The ZOOM module provides two enumerations (C<ZOOM::Error> and

-C<ZOOM::Event>), a single utility function C<diag_str()> in the C<ZOOM>
-package itself, and eight classes:
+C<ZOOM::Event>), two utility functions C<diag_str()> and C<event()> in
+the C<ZOOM> package itself, and eight classes:

 C<ZOOM::Exception>,
 C<ZOOM::Options>,
 C<ZOOM::Connection>,
 C<ZOOM::Exception>,
 C<ZOOM::Options>,
 C<ZOOM::Connection>,

@@ -49,11 +51,12 @@ C<ZOOM::Record>,
 C<ZOOM::ScanSet>
 and
 C<ZOOM::Package>.
 C<ZOOM::ScanSet>
 and
 C<ZOOM::Package>.

-Of these, the Query class is abstract, and has two concrete
+Of these, the Query class is abstract, and has three concrete

 subclasses:
 subclasses:

-C<ZOOM::Query::CQL>
+C<ZOOM::Query::CQL>,
+C<ZOOM::Query::PQF>

 and
 and

-C<ZOOM::Query::PQF>.
+C<ZOOM::Query::CQL2RPN>.

 Many useful ZOOM applications can be built using only the Connection,
 ResultSet, Record and Exception classes, as in the example
 code-snippet above.
 Many useful ZOOM applications can be built using only the Connection,
 ResultSet, Record and Exception classes, as in the example
 code-snippet above.

@@ -76,7 +79,7 @@ In general, method calls throw an exception if anything goes wrong, so
 you don't need to test for success after each call.  See the section
 below on the Exception class for details.
 
 you don't need to test for success after each call.  See the section
 below on the Exception class for details.
 

-=head1 UTILITY FUNCTION
+=head1 UTILITY FUNCTIONS

 
 =head2 ZOOM::diag_str()
 
 
 =head2 ZOOM::diag_str()
 

@@ -92,6 +95,23 @@ C<ZOOM::Connection::errcode()>,
 irrespective of whether it is a member of the C<ZOOM::Error>
 enumeration or drawn from the BIB-1 diagnostic set.
 
 irrespective of whether it is a member of the C<ZOOM::Error>
 enumeration or drawn from the BIB-1 diagnostic set.
 

+=head2 ZOOM::event()
+
+B<Warning.>
+Lark's vomit.  Do not read this section.
+
+ $which = ZOOM::event([ $conn1, $conn2, $conn3 ]);
+
+Used only in complex asynchronous applications, this function takes a
+reference to a list of Connection objects, waits until an event
+occurs on any one of them, and returns an integer indicating which of
+the connections it occurred on.  The return value is a 1-based index
+into the list; 0 is returned if no event occurs within the longest
+timeout specified by the C<timeout> options of all the connections.
+
+B<Warning.>
+This function is not yet implemented.
+

 =head1 CLASSES
 
 The eight ZOOM classes are described here in ``sensible order'':
 =head1 CLASSES
 
 The eight ZOOM classes are described here in ``sensible order'':

@@ -277,13 +297,18 @@ and it creates and returns a new ResultSet object representing the set
 of records resulting from the search.
 
 Since queries using PQF (Prefix Query Format) are so common, we make
 of records resulting from the search.
 
 Since queries using PQF (Prefix Query Format) are so common, we make

-them a special case by providing a C<search_prefix()> method.  This is
+them a special case by providing a C<search_pqf()> method.  This is

 identical to C<search()> except that it accepts a string containing
 the query rather than an object, thereby obviating the need to create
 a C<ZOOM::Query::PQF> object.  See the documentation of that class for
 information about PQF.
 
 identical to C<search()> except that it accepts a string containing
 the query rather than an object, thereby obviating the need to create
 a C<ZOOM::Query::PQF> object.  See the documentation of that class for
 information about PQF.
 

-=head4 scan()
+=head4 scan() / scan_pqf()
+
+ $rs = $conn->scan(new ZOOM::Query::CQL('title=dinosaur'));
+ # The next two lines are equivalent
+ $rs = $conn->scan(new ZOOM::Query::PQF('@attr 1=4 dinosaur'));
+ $rs = $conn->scan_pqf('@attr 1=4 dinosaur');

 
 Many Z39.50 servers allow you to browse their indexes to find terms to
 search for.  This is done using the C<scan> method, which creates and
 
 Many Z39.50 servers allow you to browse their indexes to find terms to
 search for.  This is done using the C<scan> method, which creates and

@@ -299,13 +324,11 @@ or single words (e.g. the title ``I<The Empire Strikes Back>'', or the
 four words ``Back'', ``Empire'', ``Strikes'' and ``The'', interleaved
 with words from other titles in the same index.
 
 four words ``Back'', ``Empire'', ``Strikes'' and ``The'', interleaved
 with words from other titles in the same index.
 

-All of this is done by using a single term from the PQF query as the
-C<scan()> argument.  (At present, only PQF is supported, although
-there is no reason in principle why CQL and other query syntaxes
-should not be supported in future).  The attributes associated with
+All of this is done by using a Query object representing a query of a
+single term as the C<scan()> argument.  The attributes associated with

 the term indicate which index is to be used, and the term itself
 indicates the point in the index at which to start the scan.  For
 the term indicate which index is to be used, and the term itself
 indicates the point in the index at which to start the scan.  For

-example, if the argument is C<@attr 1=4 fish>, then
+example, if the argument is the query C<@attr 1=4 fish>, then

 
 =over 4
 
 
 =over 4
 

@@ -355,6 +378,12 @@ each one returned in the ScanSet.  By default, no terms are skipped,
 but overriding this can be useful to get a high-level overview of the
 index.
 
 but overriding this can be useful to get a high-level overview of the
 index.
 

+Since scans using PQF (Prefix Query Format) are so common, we make
+them a special case by providing a C<scan_pqf()> method.  This is
+identical to C<scan()> except that it accepts a string containing the
+query rather than an object, thereby obviating the need to create a
+C<ZOOM::Query::PQF> object.
+

 =back
 
 =head4 package()
 =back
 
 =head4 package()

@@ -368,6 +397,20 @@ Creates and returns a new C<ZOOM::Package>, to be used in invoking an
 Extended Service.  An options block may optionally be passed in.  See
 the C<ZOOM::Package> documentation.
 
 Extended Service.  An options block may optionally be passed in.  See
 the C<ZOOM::Package> documentation.
 

+=head4 last_event()
+
+ if ($conn->last_event() == ZOOM::Event::CONNECT) {
+     print "Connected!\n";
+ }
+
+Returns a C<ZOOM::Event> enumerated value indicating the type of the
+last event that occurred on the connection.  This is used only in
+complex asynchronous applications - see the section below on
+C<ZOOM::Event> for more information.
+
+B<Warning.>
+This method has not been tested.
+

 =head4 destroy()
 
  $conn->destroy()
 =head4 destroy()
 
  $conn->destroy()

@@ -396,7 +439,7 @@ need the C<size()>, C<record()> and C<sort()> methods.
 
 There is no C<new()> method nor any other explicit constructor.  The
 only way to create a new ResultSet is by using C<search()> (or
 
 There is no C<new()> method nor any other explicit constructor.  The
 only way to create a new ResultSet is by using C<search()> (or

-C<search_prefix()>) on a Connection.
+C<search_pqf()>) on a Connection.

 
 See the description of the C<Result Set> class in the ZOOM Abstract
 API at
 
 See the description of the C<Result Set> class in the ZOOM Abstract
 API at

@@ -894,7 +937,7 @@ types of query.  The sole purpose of a Query object is to be used in a
 C<search()> on a Connection; because PQF is such a common special
 case, the shortcut Connection method C<search_pqf()> is provided.
 
 C<search()> on a Connection; because PQF is such a common special
 case, the shortcut Connection method C<search_pqf()> is provided.
 

-The following Query subclasses are provided, both of the providing the
+The following Query subclasses are provided, each providing the

 same set of methods described below:
 
 =over 4
 same set of methods described below:
 
 =over 4

@@ -917,6 +960,19 @@ http://www.loc.gov/standards/sru/cql/
 and in a slight out-of-date but nevertheless useful tutorial at
 http://zing.z3950.org/cql/intro.html
 
 and in a slight out-of-date but nevertheless useful tutorial at
 http://zing.z3950.org/cql/intro.html
 

+=item ZOOM::Query::CQL2RPN
+
+Implements CQL by compiling it on the client-side into a Z39.50
+Type-1 (RPN) query, and sending that.  This provides essentially the
+same functionality as C<ZOOM::Query::CQL>, but it will work against
+any standard Z39.50 server rather than only against the small subset
+that support CQL natively.  The drawback is that, because the
+compilation is done on the client side, a configuration file is
+required to direct the mapping of CQL constructs such as index names,
+relations and modifiers into Type-1 query attributes.  An example CQL
+configuration file is included in the ZOOM-Perl distribution, in the
+file C<samples/cql/pqf.properties>
+

 =back
 
 See the description of the C<Query> class in the ZOOM Abstract
 =back
 
 See the description of the C<Query> class in the ZOOM Abstract

@@ -927,14 +983,25 @@ http://zoom.z3950.org/api/zoom-current.html#3.3
 
 =head4 new()
 
 
 =head4 new()
 

- $q = new ZOOM::Query::CQL('title=dinosaur'));
- $q = new ZOOM::Query::PQF('@attr 1=4 dinosaur'));
+ $q = new ZOOM::Query::CQL('title=dinosaur');
+ $q = new ZOOM::Query::PQF('@attr 1=4 dinosaur');

 
 Creates a new query object, compiling the query passed as its argument
 according to the rules of the particular query-type being
 instantiated.  If compilation fails, an exception is thrown.
 Otherwise, the query may be passed to the C<Connection> method
 
 Creates a new query object, compiling the query passed as its argument
 according to the rules of the particular query-type being
 instantiated.  If compilation fails, an exception is thrown.
 Otherwise, the query may be passed to the C<Connection> method

-<search()>.
+C<search()>.
+
+ $conn->option(cqlfile => "samples/cql/pqf.properties");
+ $q = new ZOOM::Query::CQL2RPN('title=dinosaur', $conn);
+
+Note that for the C<ZOOM::Query::CQL2RPN> subclass, the Connection
+must also be passed into the constructor.  This is used for two
+purposes: first, its C<cqlfile> option is used to find the CQL
+configuration file that directs the translations into RPN; and second,
+if compilation fails, then diagnostic information is cached in the
+Connection and be retrieved using C<$conn-E<gt>errcode()> and related
+methods.

 
 =head4 sortby()
 
 
 =head4 sortby()
 

@@ -945,9 +1012,6 @@ is run on the query, the result is automatically sorted.  The sort
 specification language is the same as the C<yaz> sort-specification
 type of the C<ResultSet> method C<sort()>, described above.
 
 specification language is the same as the C<yaz> sort-specification
 type of the C<ResultSet> method C<sort()>, described above.
 

-B<It ought to be possible to sort by CQL query, too, but at present
-limitations in the underlying ZOOM-C library make this impossible.>
-

 =head4 destroy()
 
  $p->destroy()
 =head4 destroy()
 
  $p->destroy()

@@ -1048,7 +1112,32 @@ be useful.  Though I can't imagine how.
 
 =head4 set_callback()
 
 
 =head4 set_callback()
 

-I<###>
+ sub cb {
+     ($udata, $key) = @;
+     return "$udata-$key-$udata";
+ }
+ $o->set_callback(\&cb, "xyz");
+ assert($o->option("foo") eq "xyz-foo-xyz");
+
+This method allows a callback function to be installed in an option
+set, so that the values of options can be calculated algorithmically
+rather than, as usual, looked up in a table.  Along with the callback
+function itself, an additional datum is provided: when an option is
+subsequently looked up, this datum is passed to the callback function
+along with the key; and its return value is returned to the caller as
+the value of the option.
+
+B<Warning.>
+Although it ought to be possible to specify callback function using
+the C<\&name> syntax above, or a literal C<sub { code }> code
+reference, the complexities of the Perl-internal memory management
+system mean that the function must currently be specified as a string
+containing the fully-qualified name, e.g. C<"main::cb">.>
+
+B<Warning.>
+The current implementation of the this method leaks memory, not only
+when the callback is installed, but on every occasion that it is
+consulted to look up an option value.

 
 =head4 destroy()
 
 
 =head4 destroy()