include/yaz/cql.h

   1 /* This file is part of the YAZ toolkit.
   2  * Copyright (C) 1995-2008 Index Data.
   3  * All rights reserved.
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are met:
   6  *
   7  *     * Redistributions of source code must retain the above copyright
   8  *       notice, this list of conditions and the following disclaimer.
   9  *     * Redistributions in binary form must reproduce the above copyright
  10  *       notice, this list of conditions and the following disclaimer in the
  11  *       documentation and/or other materials provided with the distribution.
  12  *     * Neither the name of Index Data nor the names of its contributors
  13  *       may be used to endorse or promote products derived from this
  14  *       software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
  17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19  * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
  20  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  21  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  22  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  23  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 /** \file cql.h
  29     \brief Header with public definitions about CQL.
  30 */
  31
  32 #ifndef CQL_H_INCLUDED
  33 #define CQL_H_INCLUDED
  34 #include <stdio.h>
  35 #include <yaz/nmem.h>
  36
  37 YAZ_BEGIN_CDECL
  38
  39 /** \brief CQL parser handle (opaque pointer) */
  40 typedef struct cql_parser *CQL_parser;
  41
  42 /** \brief creates a CQL parser.
  43     \returns CCL parser
  44
  45     Returns CQL parser or NULL if parser could not be created.
  46  */
  47 YAZ_EXPORT
  48 CQL_parser cql_parser_create(void);
  49
  50 /** \brief destroys a CQL parser.
  51     \param cp CQL parser
  52
  53     This function does nothing if NULL if received.
  54  */
  55 YAZ_EXPORT
  56 void cql_parser_destroy(CQL_parser cp);
  57
  58 /** \brief parses a CQL query (string)
  59     \param cp CQL parser
  60     \param str CQL string
  61     \retval 0 success
  62     \retval !=0 failure
  63  */
  64 YAZ_EXPORT
  65 int cql_parser_string(CQL_parser cp, const char *str);
  66
  67 /** \brief parses CQL query (query stream)
  68     \param cp CQL parser
  69     \param getbyte function which reads one character from stream
  70     \param ungetbyte function which unreads one character from stream
  71     \param client_data data to be passed to stream functions
  72     \retval 0 success
  73     \retval !=0 failure
  74
  75     This function is similar to cql_parser_string but takes a
  76     functions to read each query character from a stream.
  77
  78     The functions pointers getbytes, ungetbyte are similar to
  79     that known from stdios getc, ungetc.
  80 */
  81 YAZ_EXPORT
  82 int cql_parser_stream(CQL_parser cp,
  83                       int (*getbyte)(void *client_data),
  84                       void (*ungetbyte)(int b, void *client_data),
  85                       void *client_data);
  86
  87 /** \brief parses CQL query (from FILE)
  88     \param cp CQL parser
  89     \param f file where query is read from
  90     \retval 0 success
  91     \retval !=0 failure
  92
  93     This function is similar to cql_parser_string but reads from
  94     stdio FILE handle instead.
  95 */
  96 YAZ_EXPORT
  97 int cql_parser_stdio(CQL_parser cp, FILE *f);
  98
  99 /** \brief Node type: search term */
 100 #define CQL_NODE_ST 1
 101 /** \brief Node type: boolean */
 102 #define CQL_NODE_BOOL 2
 103 /** \brief CQL parse tree (node)
 104  */
 105 struct cql_node {
 106     /** node type */
 107     int which;
 108     union {
 109         /** which == CQL_NODE_ST */
 110         struct {
 111             /** CQL index */
 112             char *index;
 113             /** CQL index URI or NULL if no URI */
 114             char *index_uri;
 115             /** Search term */
 116             char *term;
 117             /** relation */
 118             char *relation;
 119             /** relation URL or NULL if no relation URI) */
 120             char *relation_uri;
 121             /** relation modifiers */
 122             struct cql_node *modifiers;
 123             /** term list */
 124             struct cql_node *extra_terms;
 125         } st;
 126         /** which == CQL_NODE_BOOL */
 127         struct {
 128             /** operator name "and", "or", ... */
 129             char *value;
 130             /** left operand */
 131             struct cql_node *left;
 132             /** right operand */
 133             struct cql_node *right;
 134             /** modifiers (NULL for no list) */
 135             struct cql_node *modifiers;
 136         } boolean;
 137     } u;
 138 };
 139
 140 /** \brief Private structure that describes the CQL properties (profile)
 141  */
 142 struct cql_properties;
 143
 144 /** \brief Structure used by cql_buf_write_handler
 145  */
 146 struct cql_buf_write_info {
 147     int max;
 148     int off;
 149     char *buf;
 150 };
 151
 152 /** \brief Handler for cql_buf_write_info
 153  */
 154 YAZ_EXPORT
 155 void cql_buf_write_handler(const char *b, void *client_data);
 156
 157 /** \brief Prints a CQL node and all sub nodes.
 158     Hence this function prints the parse tree which is as returned by
 159     cql_parser_result.
 160 */
 161 YAZ_EXPORT
 162 void cql_node_print(struct cql_node *cn);
 163
 164 /** \brief creates a search clause node (st). */
 165 YAZ_EXPORT
 166 struct cql_node *cql_node_mk_sc(NMEM nmem, const char *index,
 167                                 const char *relation, const char *term);
 168
 169 /** \brief applies a prefix+uri to "unresolved" index and relation URIs.
 170     "unresolved" URIs are those nodes where member index_uri / relation_uri
 171     is NULL.
 172 */
 173 YAZ_EXPORT
 174 struct cql_node *cql_apply_prefix(NMEM nmem, struct cql_node *cn,
 175                                   const char *prefix, const char *uri);
 176
 177 /** \brief creates a boolean node. */
 178 YAZ_EXPORT
 179 struct cql_node *cql_node_mk_boolean(NMEM nmem, const char *op);
 180
 181 /** \brief destroys a node and its children. */
 182 YAZ_EXPORT
 183 void cql_node_destroy(struct cql_node *cn);
 184
 185 /** duplicates a node (returns a copy of supplied node) . */
 186 YAZ_EXPORT
 187 struct cql_node *cql_node_dup (NMEM nmem, struct cql_node *cp);
 188
 189 /** \brief returns the parse tree of the most recently parsed CQL query.
 190     \param cp CQL parser
 191     \returns CQL node or NULL for failure
 192 */
 193 YAZ_EXPORT
 194 struct cql_node *cql_parser_result(CQL_parser cp);
 195
 196 /** \brief converts CQL tree to XCQL and writes to user-defined stream
 197     \param cn CQL node (tree)
 198     \param pr print function
 199     \param client_data data to be passed to pr function
 200  */
 201 YAZ_EXPORT
 202 void cql_to_xml(struct cql_node *cn,
 203                 void (*pr)(const char *buf, void *client_data),
 204                 void *client_data);
 205 /** \brief converts CQL tree to XCQL and writes to file
 206     \param cn CQL node (tree)
 207     \param f file handle
 208  */
 209 YAZ_EXPORT
 210 void cql_to_xml_stdio(struct cql_node *cn, FILE *f);
 211
 212 /** \brief converts CQL tree to XCQL and writes result to buffer
 213     \param cn CQL node (tree)
 214     \param out buffer
 215     \param max size of buffer (max chars to write)
 216     \returns length of resulting buffer
 217  */
 218 YAZ_EXPORT
 219 int cql_to_xml_buf(struct cql_node *cn, char *out, int max);
 220
 221 /** \brief stream handle for file (used by cql_to_xml_stdio) */
 222 YAZ_EXPORT
 223 void cql_fputs(const char *buf, void *client_data);
 224
 225 /** \brief CQL transform handle.
 226     The transform describes how to convert from CQL to PQF (Type-1 AKA RPN).
 227 */
 228 typedef struct cql_transform_t_ *cql_transform_t;
 229
 230 /** \brief creates a CQL transform handle from am opened file handle
 231     \param f file where transformation spec is read
 232     \returns transform handle or NULL for failure
 233
 234     The transformation spec is read from a FILE handle which is assumed
 235     opened for reading.
 236 */
 237 YAZ_EXPORT
 238 cql_transform_t cql_transform_open_FILE (FILE *f);
 239
 240 /** \brief creates a CQL transform handle from a file
 241     \param fname name of where transformation spec is read
 242     \returns transform handle or NULL for failure
 243 */
 244 YAZ_EXPORT
 245 cql_transform_t cql_transform_open_fname(const char *fname);
 246
 247 /** \brief destroys a CQL transform handle
 248     \param ct CQL transform handle
 249  */
 250 YAZ_EXPORT
 251 void cql_transform_close(cql_transform_t ct);
 252
 253 /** \brief tranforms PQF given a CQL tree
 254     \param ct CQL transform handle
 255     \param cn CQL node tree
 256     \param pr print function
 257     \param client_data data to be passed to pr
 258     \retval 0 success
 259     \retval != 0 error
 260
 261     The result is written to a user-defined stream.
 262 */
 263 YAZ_EXPORT
 264 int cql_transform(cql_transform_t ct,
 265                   struct cql_node *cn,
 266                   void (*pr)(const char *buf, void *client_data),
 267                   void *client_data);
 268
 269 /** \brief transforms PQF given a CQL tree (from FILE)
 270     \param ct CQL transform handle
 271     \param cn CQL tree
 272     \param f FILE where output is written
 273     \retval 0 success
 274     \retval !=0 failure (error code)
 275
 276     The result is written to a file specified by FILE handle (which must
 277     be opened for writing.
 278 */
 279 YAZ_EXPORT
 280 int cql_transform_FILE(cql_transform_t ct,
 281                        struct cql_node *cn, FILE *f);
 282
 283 /** \brief transforms PQF given a CQL tree (from FILE)
 284     \param ct CQL transform handle
 285     \param cn CQL tree
 286     \param out buffer for output
 287     \param max maximum bytes for output (size of buffer)
 288     \retval 0 success
 289     \retval !=0 failure (error code)
 290  */
 291 YAZ_EXPORT
 292 int cql_transform_buf(cql_transform_t ct,
 293                       struct cql_node *cn, char *out, int max);
 294
 295 /** \brief returns additional information for last transform
 296     \param ct CQL transform handle
 297     \param addinfo additional info (result)
 298     \returns error code
 299  */
 300 YAZ_EXPORT
 301 int cql_transform_error(cql_transform_t ct, const char **addinfo);
 302
 303 /** \brief sets error and addinfo for transform
 304     \param ct CQL transform handle
 305     \param error error code
 306     \param addinfo additional info
 307  */
 308 YAZ_EXPORT
 309 void cql_transform_set_error(cql_transform_t ct, int error, const char *addinfo);
 310
 311 /** \brief returns the CQL message corresponding to a given error code.
 312     \param code error code
 313     \returns text message
 314 */
 315 YAZ_EXPORT
 316 const char *cql_strerror(int code);
 317
 318 /** \brief returns the standard CQL context set URI.
 319     \returns CQL URI string
 320 */
 321 YAZ_EXPORT
 322 const char *cql_uri(void);
 323
 324 /** \brief compares two CQL strings (ala strcmp)
 325     \param s1 string 1
 326     \param s2 string 2
 327     \returns comparison value
 328     Compares two CQL strings (for relations, operators, etc)
 329     (unfortunately defined as case-insensitive unlike XML etc)
 330 */
 331 YAZ_EXPORT
 332 int cql_strcmp(const char *s1, const char *s2);
 333
 334 /** \brief compares two CQL strings (ala strncmp)
 335     \param s1 string 1
 336     \param s2 string 2
 337     \param n size
 338     \returns comparison value
 339     Compares two CQL strings at most n bytes
 340     (unfortunately defined as case-insensitive unlike XML etc)
 341  */
 342 YAZ_EXPORT
 343 int cql_strncmp(const char *s1, const char *s2, size_t n);
 344
 345 YAZ_END_CDECL
 346
 347 #endif
 348 /* CQL_H_INCLUDED */
 349 /*
 350  * Local variables:
 351  * c-basic-offset: 4
 352  * indent-tabs-mode: nil
 353  * End:
 354  * vim: shiftwidth=4 tabstop=8 expandtab
 355  */
 356