api.h

Go to the documentation of this file.

/* This file is part of the Zebra server.
   Copyright (C) Index Data
 
Zebra is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2, or (at your option) any later
version.
 
Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
*/
 
#ifndef IDZEBRA_API_H
#define IDZEBRA_API_H
 
#include <yaz/odr.h>
#include <yaz/proto.h>
#include <idzebra/res.h>
#include <idzebra/version.h>
#include <idzebra/recctrl.h>
 
YAZ_BEGIN_CDECL
 
typedef struct {
    zint processed;
    zint inserted;
    zint updated;
    zint deleted;
    long utime;
    long stime;
} ZebraTransactionStatus;
 
typedef struct {
    int errCode;         /* non-zero if error when fetching this */
    char *errString;     /* error string */
    int position;        /* position of record in result set (1,2,..) */
    char *buf;           /* record buffer (void pointer really) */
    int len;             /* length */
    const Odr_oid *format; /* record syntax */
    char *base;
    zint sysno;
    int  score;
} ZebraRetrievalRecord;
 
typedef struct {
    zint occurrences;    /* scan term occurrences */
    char *term;          /* scan term string */
    char *display_term;  /* display scan term entry */
} ZebraScanEntry;
 
typedef struct zebra_session *ZebraHandle;
 
typedef struct zebra_service *ZebraService;
 
YAZ_EXPORT
ZebraService zebra_start(const char *configName
    ) ZEBRA_GCC_ATTR((warn_unused_result));
 
YAZ_EXPORT
ZebraService zebra_start_res(const char *configName,
                             Res def_res, Res over_res
    ) ZEBRA_GCC_ATTR((warn_unused_result));
 
YAZ_EXPORT
ZEBRA_RES zebra_stop(ZebraService zs);
 
YAZ_EXPORT
void zebra_filter_info(ZebraService zs, void *cd,
                       void (*cb)(void *cd, const char *name));
 
 
YAZ_EXPORT
ZebraHandle zebra_open(ZebraService zs, Res res
    ) ZEBRA_GCC_ATTR((warn_unused_result));
 
YAZ_EXPORT
ZEBRA_RES zebra_close(ZebraHandle zh);
 
YAZ_EXPORT
int zebra_errCode(ZebraHandle zh);
 
YAZ_EXPORT
const char *zebra_errString(ZebraHandle zh);
 
YAZ_EXPORT
char *zebra_errAdd(ZebraHandle zh);
 
YAZ_EXPORT
void zebra_result(ZebraHandle zh, int *code, char **addinfo);
 
 
YAZ_EXPORT
const char *zebra_get_encoding(ZebraHandle zh);
 
ZEBRA_RES zebra_set_approx_limit(ZebraHandle zh, zint approx_limit);
 
YAZ_EXPORT
ZEBRA_RES zebra_search_PQF(ZebraHandle zh, const char *pqf_query,
                           const char *setname, zint *hits);
 
YAZ_EXPORT
ZEBRA_RES zebra_search_RPN_x(ZebraHandle zh, ODR o, Z_RPNQuery *query,
                           const char *setname, zint *hits,
                           int *estimated_hit_count,
                           int *partial_resultset);
 
 
YAZ_EXPORT
ZEBRA_RES zebra_search_RPN(ZebraHandle zh, ODR o, Z_RPNQuery *query,
                              const char *setname, zint *hits);
 
YAZ_EXPORT
ZEBRA_RES zebra_records_retrieve(ZebraHandle zh, ODR stream,
                                 const char *setname,
                                 Z_RecordComposition *comp,
                                 const Odr_oid *input_format,
                                 int num_recs,
                                 ZebraRetrievalRecord *recs);
YAZ_EXPORT
int zebra_deleteResultSet(ZebraHandle zh, int function,
                          int num_setnames, char **setnames,
                          int *statuses);
 
 
YAZ_EXPORT
ZEBRA_RES zebra_result_set_term_no(ZebraHandle zh, const char *setname,
                                   int *num_terms);
 
YAZ_EXPORT
ZEBRA_RES zebra_result_set_term_info(ZebraHandle zh, const char *setname,
                                     int no, zint *count, int *approx,
                                     char *termbuf, size_t *termlen,
                                     const char **term_ref_id);
 
 
YAZ_EXPORT ZEBRA_RES zebra_scan(ZebraHandle zh, ODR stream,
                                Z_AttributesPlusTerm *zapt,
                                const Odr_oid *attributeset,
                                int *position, int *num_entries,
                                ZebraScanEntry **entries,
                                int *is_partial,
                                const char *setname);
 
YAZ_EXPORT
ZEBRA_RES zebra_scan_PQF(ZebraHandle zh, ODR stream, const char *query,
                         int *position, int *num_entries,
                         ZebraScanEntry **entries,
                         int *is_partial, const char *setname);
 
YAZ_EXPORT
ZEBRA_RES zebra_auth(ZebraHandle zh, const char *user, const char *pass);
 
YAZ_EXPORT
int zebra_string_norm(ZebraHandle zh, const char *index_type,
                      const char *input_str,
                      int input_len, char *output_str, int output_len);
 
YAZ_EXPORT
ZEBRA_RES zebra_create_database(ZebraHandle zh, const char *db);
 
YAZ_EXPORT
ZEBRA_RES zebra_drop_database(ZebraHandle zh, const char *db);
 
YAZ_EXPORT
ZEBRA_RES zebra_admin_shutdown(ZebraHandle zh);
 
YAZ_EXPORT
ZEBRA_RES zebra_admin_start(ZebraHandle zh);
 
YAZ_EXPORT
ZEBRA_RES zebra_shutdown(ZebraService zs);
 
YAZ_EXPORT
ZEBRA_RES zebra_admin_import_begin(ZebraHandle zh, const char *database,
                                   const char *record_type);
 
YAZ_EXPORT
ZEBRA_RES zebra_admin_import_segment(ZebraHandle zh,
                                     Z_Segment *segment);
 
YAZ_EXPORT
ZEBRA_RES zebra_admin_import_end(ZebraHandle zh);
 
YAZ_EXPORT
ZEBRA_RES zebra_begin_trans(ZebraHandle zh, int rw
    ) ZEBRA_GCC_ATTR((warn_unused_result));
 
YAZ_EXPORT
ZEBRA_RES zebra_end_trans(ZebraHandle zh
    ) ZEBRA_GCC_ATTR((warn_unused_result));
 
YAZ_EXPORT
ZEBRA_RES zebra_end_transaction(ZebraHandle zh,
                                ZebraTransactionStatus *stat);
 
YAZ_EXPORT
ZEBRA_RES zebra_commit(ZebraHandle zh);
 
YAZ_EXPORT
ZEBRA_RES zebra_clean(ZebraHandle zh);
 
YAZ_EXPORT
ZEBRA_RES zebra_init(ZebraHandle zh);
 
YAZ_EXPORT
ZEBRA_RES zebra_compact(ZebraHandle zh);
 
YAZ_EXPORT
ZEBRA_RES zebra_repository_index(ZebraHandle zh, const char *path,
                                 enum zebra_recctrl_action_t action);
 
YAZ_EXPORT
ZEBRA_RES zebra_repository_update(ZebraHandle zh, const char *path);
 
YAZ_EXPORT
ZEBRA_RES zebra_repository_delete(ZebraHandle zh, const char *path);
 
YAZ_EXPORT
ZEBRA_RES zebra_repository_show(ZebraHandle zh, const char *path);
 
YAZ_EXPORT
ZEBRA_RES zebra_add_record(ZebraHandle zh, const char *buf, int buf_size);
 
YAZ_EXPORT
ZEBRA_RES zebra_update_record(ZebraHandle zh,
                              enum zebra_recctrl_action_t action,
                              const char *recordType,
                              zint *sysno, const char *match,
                              const char *fname,
                              const char *buf, int buf_size);
 
YAZ_EXPORT
ZEBRA_RES zebra_sort(ZebraHandle zh, ODR stream,
                     int num_input_setnames,
                     const char **input_setnames,
                     const char *output_setname,
                     Z_SortKeySpecList *sort_sequence,
                     int *sort_status
    ) ZEBRA_GCC_ATTR((warn_unused_result));
 
YAZ_EXPORT
ZEBRA_RES zebra_select_databases(ZebraHandle zh, int num_bases,
                                 const char **basenames
    ) ZEBRA_GCC_ATTR((warn_unused_result));
 
YAZ_EXPORT
ZEBRA_RES zebra_select_database(ZebraHandle zh, const char *basename
    ) ZEBRA_GCC_ATTR((warn_unused_result));
 
YAZ_EXPORT
void zebra_shadow_enable(ZebraHandle zh, int value);
 
YAZ_EXPORT
int zebra_register_statistics(ZebraHandle zh, int dumpdict);
 
YAZ_EXPORT
ZEBRA_RES zebra_record_encoding(ZebraHandle zh, const char *encoding);
 
YAZ_EXPORT
ZEBRA_RES zebra_octet_term_encoding(ZebraHandle zh, const char *encoding);
 
/* Resources */
YAZ_EXPORT
void zebra_set_resource(ZebraHandle zh, const char *name, const char *value);
YAZ_EXPORT
const char *zebra_get_resource(ZebraHandle zh,
                               const char *name, const char *defaultvalue);
 
 
YAZ_EXPORT
void zebra_pidfname(ZebraService zs, char *path);
 
typedef struct {
    char *term;
    char *db;
    zint sysno;
    int score;
} ZebraMetaRecord;
 
YAZ_EXPORT
ZebraMetaRecord *zebra_meta_records_create(ZebraHandle zh,
                                           const char *name,
                                           int num, zint *positions);
 
 
YAZ_EXPORT
ZebraMetaRecord *zebra_meta_records_create_range(ZebraHandle zh,
                                                 const char *name,
                                                 zint start, int num);
 
YAZ_EXPORT
void zebra_meta_records_destroy(ZebraHandle zh, ZebraMetaRecord *records,
                                int num);
 
YAZ_EXPORT
struct BFiles_struct *zebra_get_bfs(ZebraHandle zh);
 
YAZ_EXPORT
ZEBRA_RES zebra_set_limit(ZebraHandle zh, int complement_flag, zint *ids);
 
YAZ_EXPORT
ZEBRA_RES zebra_set_break_handler(ZebraHandle zh,
                                  int (*f)(void *client_data),
                                  void *client_data);
 
YAZ_EXPORT
ZEBRA_RES zebra_register_check(ZebraHandle zh, const char *spec);
 
YAZ_END_CDECL
 
#endif
/*
 * Local variables:
 * c-basic-offset: 4
 * c-file-style: "Stroustrup"
 * indent-tabs-mode: nil
 * End:
 * vim: shiftwidth=4 tabstop=8 expandtab
 */