Filewatcher File Search File Search
Catalog
Content Search
» » » » » libqdbm-dev_1.8.74-1.1_i386.deb » Content »
pkg://libqdbm-dev_1.8.74-1.1_i386.deb:221800/usr/share/man/man3/  info  control  downloads

libqdbm-dev - QDBM Database Libraries [development]…  more info»

odeum.3.gz

ODEUM(3)               Quick Database Manager               ODEUM(3)



NAME
       Odeum - the inverted API of QDBM


SYNOPSIS
       #include <depot.h>
       #include <cabin.h>
       #include <odeum.h>
       #include <stdlib.h>

       typedef struct { int id; int score; } ODPAIR;

       ODEUM *odopen(const char *name, int omode);

       int odclose(ODEUM *odeum);

       int  odput(ODEUM  *odeum,  const  ODDOC  *doc,  int wmax, int
       over);

       int odout(ODEUM *odeum, const char *uri);

       int odoutbyid(ODEUM *odeum, int id);

       ODDOC *odget(ODEUM *odeum, const char *uri);

       ODDOC *odgetbyid(ODEUM *odeum, int id);

       int odgetidbyuri(ODEUM *odeum, const char *uri);

       int odcheck(ODEUM *odeum, int id);

       ODPAIR *odsearch(ODEUM *odeum, const char *word, int max, int
       *np);

       int odsearchdnum(ODEUM *odeum, const char *word);

       int oditerinit(ODEUM *odeum);

       ODDOC *oditernext(ODEUM *odeum);

       int odsync(ODEUM *odeum);

       int odoptimize(ODEUM *odeum);

       char *odname(ODEUM *odeum);

       double odfsiz(ODEUM *odeum);

       int odbnum(ODEUM *odeum);

       int odbusenum(ODEUM *odeum);

       int oddnum(ODEUM *odeum);

       int odwnum(ODEUM *odeum);

       int odwritable(ODEUM *odeum);

       int odfatalerror(ODEUM *odeum);

       int odinode(ODEUM *odeum);

       time_t odmtime(ODEUM *odeum);

       int odmerge(const char *name, const CBLIST *elemnames);

       int odremove(const char *name);

       ODDOC *oddocopen(const char *uri);

       void oddocclose(ODDOC *doc);

       void  oddocaddattr(ODDOC  *doc,  const char *name, const char
       *value);

       void oddocaddword(ODDOC *doc, const char *normal, const  char
       *asis);

       int oddocid(const ODDOC *doc);

       const char *oddocuri(const ODDOC *doc);

       const char *oddocgetattr(const ODDOC *doc, const char *name);

       const CBLIST *oddocnwords(const ODDOC *doc);

       const CBLIST *oddocawords(const ODDOC *doc);

       CBMAP *oddocscores(const ODDOC *doc, int max, ODEUM *odeum);

       CBLIST *odbreaktext(const char *text);

       char *odnormalizeword(const char *asis);

       ODPAIR  *odpairsand(ODPAIR *apairs, int anum, ODPAIR *bpairs,
       int bnum, int *np);

       ODPAIR *odpairsor(ODPAIR *apairs, int anum,  ODPAIR  *bpairs,
       int bnum, int *np);

       ODPAIR   *odpairsnotand(ODPAIR   *apairs,  int  anum,  ODPAIR
       *bpairs, int bnum, int *np);

       void odpairssort(ODPAIR *pairs, int pnum);

       double odlogarithm(double x);

       double odvectorcosine(const int *avec, const int  *bvec,  int
       vnum);

       void odsettuning(int ibnum, int idnum, int cbnum, int csiz);

       void  odanalyzetext(ODEUM  *odeum,  const  char *text, CBLIST
       *awords, CBLIST *nwords);

       void odsetcharclass(ODEUM  *odeum,  const  char  *spacechars,
       const char *delimchars, const char *gluechars);

       ODPAIR  *odquery(ODEUM  *odeum,  const  char *query, int *np,
       CBLIST *errors);


DESCRIPTION
       Odeum is  the  API  which  handles  an  inverted  index.   An
       inverted index is a data structure to retrieve a list of some
       documents that include one of words which were extracted from
       a population of documents.  It is easy to realize a full-text
       search system with an  inverted  index.   Odeum  provides  an
       abstract   data   structure   which  consists  of  words  and
       attributes of a document.  It is  used  when  an  application
       stores  a  document  into  a database and when an application
       retrieves some documents from a database.

       Odeum does not provide methods to extract the text  from  the
       original  data  of  a  document.  It should be implemented by
       applications.  Although Odeum provides utilities  to  extract
       words  from  a  text,  it is oriented to such languages whose
       words are separated with space characters as English.  If  an
       application  handles  such languages which need morphological
       analysis or N-gram analysis as Japanese, or if an application
       perform  more  such rarefied analysis of natural languages as
       stemming, its own analyzing method can be adopted.  Result of
       search  is  expressed as an array contains elements which are
       structures composed of the ID number  of  documents  and  its
       score.  In order to search with two or more words, Odeum pro‐
       vides utilities of set operations.

       Odeum is implemented,  based  on  Curia,  Cabin,  and  Villa.
       Odeum  creates  a database with a directory name.  Some data‐
       bases of Curia and Villa are placed in the  specified  direc‐
       tory.   For example, `casket/docs', `casket/index', and `cas‐
       ket/rdocs' are created in the case that a database  directory
       named  as `casket'.  `docs' is a database directory of Curia.
       The key of each record is the ID number of  a  document,  and
       the  value  is such attributes as URI.  `index' is a database
       directory of Curia.  The key of each record is the normalized
       form  of a word, and the value is an array whose element is a
       pair of the ID number of a document including  the  word  and
       its  score.  `rdocs' is a database file of Villa.  The key of
       each record is the URI of a document, and the value is its ID
       number.

       In   order  to  use  Odeum,  you  should  include  `depot.h',
       `cabin.h', `odeum.h' and  `stdlib.h'  in  the  source  files.
       Usually, the following description will be near the beginning
       of a source file.

              #include <depot.h>
              #include <cabin.h>
              #include <odeum.h>
              #include <stdlib.h>

       A pointer to `ODEUM' is used as a database handle.   A  data‐
       base  handle  is opened with the function `odopen' and closed
       with `odclose'.  You should not refer directly to any  member
       of  the  handle.   If a fatal error occurs in a database, any
       access method via the handle except `odclose' will  not  work
       and  return  error  status.  Although a process is allowed to
       use multiple database handles at the same  time,  handles  of
       the same database file should not be used.

       A  pointer  to `ODDOC' is used as a document handle.  A docu‐
       ment handle is  opened  with  the  function  `oddocopen'  and
       closed  with  `oddocclose'.  You should not refer directly to
       any member of the handle.  A document consists of  attributes
       and  words.  Each word is expressed as a pair of a normalized
       form and a appearance form.

       Odeum also assign the external variable  `dpecode'  with  the
       error  code.  The function `dperrmsg' is used in order to get
       the message of the error code.

       Structures of `ODPAIR'  type  is  used  in  order  to  handle
       results of search.

       typedef struct { int id; int score; } ODPAIR;
              `id'  specifies  the ID number of a document.  `score'
              specifies the score  calculated  from  the  number  of
              searching words in the document.

       The function `odopen' is used in order to get a database han‐
       dle.

       ODEUM *odopen(const char *name, int omode);
              `name' specifies the name  of  a  database  directory.
              `omode' specifies the connection mode: `OD_OWRITER' as
              a writer, `OD_OREADER' as a reader.  If  the  mode  is
              `OD_OWRITER',  the  following  may be added by bitwise
              or: `OD_OCREAT', which means it creates a new database
              if  not  exist,  `OD_OTRUNC', which means it creates a
              new  database  regardless  if  one  exists.   Both  of
              `OD_OREADER'  and `OD_OWRITER' can be added to by bit‐
              wise or: `OD_ONOLCK', which means it opens a  database
              directory  without file locking, or `OD_OLCKNB', which
              means locking  is  performed  without  blocking.   The
              return value is the database handle or `NULL' if it is
              not successful.  While  connecting  as  a  writer,  an
              exclusive  lock  is invoked to the database directory.
              While connecting as a reader, a shared lock is invoked
              to  the  database  directory.  The thread blocks until
              the lock is achieved.  If  `OD_ONOLCK'  is  used,  the
              application is responsible for exclusion control.

       The  function  `odclose' is used in order to close a database
       handle.

       int odclose(ODEUM *odeum);
              `odeum' specifies a database handle.   If  successful,
              the  return value is true, else, it is false.  Because
              the region of a closed handle is released, it  becomes
              impossible  to use the handle.  Updating a database is
              assured to be written when the handle is closed.  If a
              writer  opens  a database but does not close it appro‐
              priately, the database will be broken.

       The function `odput' is used in order to store a document.

       int odput(ODEUM *odeum,  const  ODDOC  *doc,  int  wmax,  int
       over);
              `odeum'  specifies  a  database  handle connected as a
              writer.  `doc' specifies a  document  handle.   `wmax'
              specifies  the max number of words to be stored in the
              document database.  If it is negative, the  number  is
              unlimited.   `over'  specifies whether the data of the
              duplicated document is overwritten or not.  If  it  is
              false  and  the URI of the document is duplicated, the
              function returns as  an  error.   If  successful,  the
              return value is true, else, it is false.

       The  function  `odout'  is used in order to delete a document
       specified by a URI.

       int odout(ODEUM *odeum, const char *uri);
              `odeum' specifies a database  handle  connected  as  a
              writer.   `uri'  specifies  the string of the URI of a
              document.  If successful, the return  value  is  true,
              else, it is false.  False is returned when no document
              corresponds to the specified URI.

       The function `odoutbyid' is used in order to delete  a  docu‐
       ment specified by an ID number.

       int odoutbyid(ODEUM *odeum, int id);
              `odeum'  specifies  a  database  handle connected as a
              writer.  `id' specifies the ID number of  a  document.
              If  successful,  the return value is true, else, it is
              false.  False is returned when no document corresponds
              to the specified ID number.

       The  function `odget' is used in order to retrieve a document
       specified by a URI.

       ODDOC *odget(ODEUM *odeum, const char *uri);
              `odeum' specifies a database handle.  `uri'  specifies
              the  string  of the URI of a document.  If successful,
              the return value is the handle  of  the  corresponding
              document, else, it is `NULL'.  `NULL' is returned when
              no document corresponds to the specified URI.  Because
              the  handle  of  the  return  value is opened with the
              function `oddocopen', it should  be  closed  with  the
              function `oddocclose'.

       The function `odgetbyid' is used in order to retrieve a docu‐
       ment by an ID number.

       ODDOC *odgetbyid(ODEUM *odeum, int id);
              `odeum' specifies a database handle.   `id'  specifies
              the  ID  number  of  a  document.   If successful, the
              return value is the handle of the corresponding  docu‐
              ment,  else, it is `NULL'.  `NULL' is returned when no
              document  corresponds  to  the  specified  ID  number.
              Because  the handle of the return value is opened with
              the function `oddocopen', it should be closed with the
              function `oddocclose'.

       The  function `odgetidbyuri' is used in order to retrieve the
       ID of the document specified by a URI.

       int odgetidbyuri(ODEUM *odeum, const char *uri);
              `odeum' specifies a database handle.  `uri'  specifies
              the  string the URI of a document.  If successful, the
              return value is the ID number of the  document,  else,
              it is -1.  -1 is returned when no document corresponds
              to the specified URI.

       The function `odcheck' is used in order to check whether  the
       document specified by an ID number exists.

       int odcheck(ODEUM *odeum, int id);
              `odeum'  specifies  a database handle.  `id' specifies
              the ID number of a document.  The return value is true
              if the document exists, else, it is false.

       The  function  `odsearch'  is  used  in  order  to search the
       inverted index for documents including a particular word.

       ODPAIR *odsearch(ODEUM *odeum, const char *word, int max, int
       *np);
              `odeum' specifies a database handle.  `word' specifies
              a searching word.  `max' specifies the max  number  of
              documents  to be retrieve.  `np' specifies the pointer
              to a variable to which the number of the  elements  of
              the  return  value  is  assigned.   If successful, the
              return value is the pointer to an array, else,  it  is
              `NULL'.  Each element of the array is a pair of the ID
              number and the score of  a  document,  and  sorted  in
              descending order of their scores.  Even if no document
              corresponds to the specified word, it is not error but
              returns  an  dummy  array.   Because the region of the
              return value is allocated with the `malloc'  call,  it
              should  be  released  with the `free' call if it is no
              longer in use.  Note that each element of the array of
              the return value can be data of a deleted document.

       The function `odsearchnum' is used in order to get the number
       of documents including a word.

       int odsearchdnum(ODEUM *odeum, const char *word);
              `odeum' specifies a database handle.  `word' specifies
              a  searching word.  If successful, the return value is
              the number of documents including the word,  else,  it
              is -1.  Because this function does not read the entity
              of the inverted index, it is faster than `odsearch'.

       The function `oditerinit' is used in order to initialize  the
       iterator of a database handle.

       int oditerinit(ODEUM *odeum);
              `odeum'  specifies  a database handle.  If successful,
              the return value is true,  else,  it  is  false.   The
              iterator  is  used  in  order to access every document
              stored in a database.

       The function `oditernext' is used in order to  get  the  next
       key of the iterator.

       ODDOC *oditernext(ODEUM *odeum);
              `odeum'  specifies  a database handle.  If successful,
              the return value is the handle of the  next  document,
              else,  it is `NULL'.  `NULL' is returned when no docu‐
              ment is to be get out of the iterator.  It is possible
              to  access every document by iteration of calling this
              function.  However, it is not assured if updating  the
              database  is  occurred  while the iteration.  Besides,
              the order of this traversal  access  method  is  arbi‐
              trary,  so  it is not assured that the order of string
              matches the one of the traversal access.  Because  the
              handle of the return value is opened with the function
              `oddocopen', it should be  closed  with  the  function
              `oddocclose'.

       The  function `odsync' is used in order to synchronize updat‐
       ing contents with the files and the devices.

       int odsync(ODEUM *odeum);
              `odeum' specifies a database  handle  connected  as  a
              writer.   If  successful,  the  return  value is true,
              else, it is  false.   This  function  is  useful  when
              another process uses the connected database directory.

       The  function  `odoptimize'  is  used  in order to optimize a
       database.

       int odoptimize(ODEUM *odeum);
              `odeum' specifies a database  handle  connected  as  a
              writer.   If  successful,  the  return  value is true,
              else, it is false.  Elements of the deleted  documents
              in the inverted index are purged.

       The  function  `odname' is used in order to get the name of a
       database.

       char *odname(ODEUM *odeum);
              `odeum' specifies a database handle.   If  successful,
              the  return  value is the pointer to the region of the
              name of the database, else, it is `NULL'.  Because the
              region of the return value is allocated with the `mal‐
              loc' call, it should be released with the `free'  call
              if it is no longer in use.

       The  function `odfsiz' is used in order to get the total size
       of database files.

       double odfsiz(ODEUM *odeum);
              `odeum' specifies a database handle.   If  successful,
              the  return  value  is  the total size of the database
              files, else, it is -1.0.

       The function `odbnum' is used in order to get the total  num‐
       ber  of  the  elements  of  the bucket arrays in the inverted
       index.

       int odbnum(ODEUM *odeum);
              `odeum' specifies a database handle.   If  successful,
              the  return  value is the total number of the elements
              of the bucket arrays, else, it is -1.

       The function `odbusenum' is used in order to  get  the  total
       number  of  the  used  elements  of  the bucket arrays in the
       inverted index.

       int odbusenum(ODEUM *odeum);
              `odeum' specifies a database handle.   If  successful,
              the  return value is the total number of the used ele‐
              ments of the bucket arrays, else, it is -1.

       The function `oddnum' is used in order to get the  number  of
       the documents stored in a database.

       int oddnum(ODEUM *odeum);
              `odeum'  specifies  a database handle.  If successful,
              the return value is the number of the documents stored
              in the database, else, it is -1.

       The  function  `odwnum' is used in order to get the number of
       the words stored in a database.

       int odwnum(ODEUM *odeum);
              `odeum' specifies a database handle.   If  successful,
              the  return value is the number of the words stored in
              the database, else, it is -1.  Because of the I/O buf‐
              fer,  the  return value may be less than the hard num‐
              ber.

       The function `odwritable' is used in order to check whether a
       database handle is a writer or not.

       int odwritable(ODEUM *odeum);
              `odeum' specifies a database handle.  The return value
              is true if the handle is a writer, false if not.

       The function `odfatalerror' is used in order to check whether
       a database has a fatal error or not.

       int odfatalerror(ODEUM *odeum);
              `odeum' specifies a database handle.  The return value
              is true if the database has a fatal  error,  false  if
              not.

       The function `odinode' is used in order to get the inode num‐
       ber of a database directory.

       int odinode(ODEUM *odeum);
              `odeum' specifies a database handle.  The return value
              is the inode number of the database directory.

       The function `odmtime' is used in order to get the last modi‐
       fied time of a database.

       time_t odmtime(ODEUM *odeum);
              `odeum' specifies a database handle.  The return value
              is the last modified time of the database.

       The function `odmerge' is used in order to merge plural data‐
       base directories.

       int odmerge(const char *name, const CBLIST *elemnames);
              `name' specifies the name of a database  directory  to
              create.  `elemnames' specifies a list of names of ele‐
              ment databases.  If successful, the  return  value  is
              true,  else,  it  is  false.  If two or more documents
              which have the same URL come  in,  the  first  one  is
              adopted and the others are ignored.

       The function `odremove' is used in order to remove a database
       directory.

       int odremove(const char *name);
              `name' specifies the name of a database directory.  If
              successful,  the  return  value  is  true, else, it is
              false.  A database directory can contain databases  of
              other  APIs  of  QDBM,  they  are also removed by this
              function.

       The function `oddocopen' is used in order to get  a  document
       handle.

       ODDOC *oddocopen(const char *uri);
              `uri'  specifies  the  URI  of a document.  The return
              value is a document handle.  The ID number  of  a  new
              document is not defined.  It is defined when the docu‐
              ment is stored in a database.

       The function `oddocclose' is used in order to close  a  docu‐
       ment handle.

       void oddocclose(ODDOC *doc);
              `doc' specifies a document handle.  Because the region
              of a closed handle is released, it becomes  impossible
              to use the handle.

       The  function  `oddocaddattr'  is  used  in  order  to add an
       attribute to a document.

       void oddocaddattr(ODDOC *doc, const char  *name,  const  char
       *value);
              `doc'  specifies  a document handle.  `name' specifies
              the string of the name of an attribute.  `value' spec‐
              ifies the string of the value of the attribute.

       The function `oddocaddword' is used in order to add a word to
       a document.

       void oddocaddword(ODDOC *doc, const char *normal, const  char
       *asis);
              `doc' specifies a document handle.  `normal' specifies
              the string of the normalized form of a word.   Normal‐
              ized  forms are treated as keys of the inverted index.
              If the normalized form of a word is an  empty  string,
              the  word  is  not  reflected  in  the inverted index.
              `asis' specifies the string of the appearance form  of
              the  word.   Appearance forms are used after the docu‐
              ment is retrieved by an application.

       The function `oddocid' is used in order to get the ID  number
       of a document.

       int oddocid(const ODDOC *doc);
              `doc'  specifies  a document handle.  The return value
              is the ID number of a document.

       The function `oddocuri' is used in order to get the URI of  a
       document.

       const char *oddocuri(const ODDOC *doc);
              `doc'  specifies  a document handle.  The return value
              is the string of the URI of a document.

       The function `oddocgetattr' is used in order to get the value
       of an attribute of a document.

       const char *oddocgetattr(const ODDOC *doc, const char *name);
              `doc'  specifies  a document handle.  `name' specifies
              the string of the name of an  attribute.   The  return
              value  is the string of the value of the attribute, or
              `NULL' if no attribute corresponds.

       The function `oddocnwords' is used in order to get  the  list
       handle contains words in normalized form of a document.

       const CBLIST *oddocnwords(const ODDOC *doc);
              `doc'  specifies  a document handle.  The return value
              is the list handle contains words in normalized form.

       The function `oddocawords' is used in order to get  the  list
       handle contains words in appearance form of a document.

       const CBLIST *oddocawords(const ODDOC *doc);
              `doc'  specifies  a document handle.  The return value
              is the list handle contains words in appearance form.

       The function `oddocscores' is used in order to  get  the  map
       handle contains keywords in normalized form and their scores.

       CBMAP *oddocscores(const ODDOC *doc, int max, ODEUM *odeum);
              `doc'  specifies  a  document handle.  `max' specifies
              the max number of keywords to get.  `odeum'  specifies
              a  database handle with which the IDF for weighting is
              calculate.  If it is `NULL',  it  is  not  used.   The
              return  value  is the map handle contains keywords and
              their  scores.   Scores  are  expressed   as   decimal
              strings.   Because  the  handle of the return value is
              opened with the function  `cbmapopen',  it  should  be
              closed  with  the  function  `cbmapclose'  if it is no
              longer in use.

       The function `odbreaktext' is used in order to break  a  text
       into words in appearance form.

       CBLIST *odbreaktext(const char *text);
              `text'  specifies  the  string  of a text.  The return
              value is the list handle contains words in  appearance
              form.   Words  are separated with space characters and
              such delimiters as period, comma and so  on.   Because
              the  handle  of  the  return  value is opened with the
              function `cblistopen', it should be  closed  with  the
              function `cblistclose' if it is no longer in use.

       The  function  `odnormalizeword' is used in order to make the
       normalized form of a word.

       char *odnormalizeword(const char *asis);
              `asis' specifies the string of the appearance form  of
              a word.  The return value is is the string of the nor‐
              malized form of the word.  Alphabets of the ASCII code
              are  unified into lower cases.  Words composed of only
              delimiters are treated as empty strings.  Because  the
              region of the return value is allocated with the `mal‐
              loc' call, it should be released with the `free'  call
              if it is no longer in use.

       The  function `odpairsand' is used in order to get the common
       elements of two sets of documents.

       ODPAIR *odpairsand(ODPAIR *apairs, int anum, ODPAIR  *bpairs,
       int bnum, int *np);
              `apairs'  specifies the pointer to the former document
              array.  `anum' specifies the number of the elements of
              the  former  document  array.   `bpairs' specifies the
              pointer to the latter document array.   `bnum'  speci‐
              fies the number of the elements of the latter document
              array.  `np' specifies the pointer to  a  variable  to
              which  the  number of the elements of the return value
              is assigned.  The return value is the pointer to a new
              document  array  whose elements commonly belong to the
              specified two sets.  Elements of the array are  sorted
              in  descending  order  of  their  scores.  Because the
              region of the return value is allocated with the `mal‐
              loc'  call, it should be released with the `free' call
              if it is no longer in use.

       The function `odpairsor' is used in order to get the  sum  of
       elements of two sets of documents.

       ODPAIR  *odpairsor(ODPAIR  *apairs, int anum, ODPAIR *bpairs,
       int bnum, int *np);
              `apairs' specifies the pointer to the former  document
              array.  `anum' specifies the number of the elements of
              the former document  array.   `bpairs'  specifies  the
              pointer  to  the latter document array.  `bnum' speci‐
              fies the number of the elements of the latter document
              array.   `np'  specifies  the pointer to a variable to
              which the number of the elements of the  return  value
              is assigned.  The return value is the pointer to a new
              document array whose elements belong to both or either
              of  the specified two sets.  Elements of the array are
              sorted in descending order of their  scores.   Because
              the  region  of the return value is allocated with the
              `malloc' call, it should be released with  the  `free'
              call if it is no longer in use.

       The function `odpairsnotand' is used in order to get the dif‐
       ference set of documents.

       ODPAIR  *odpairsnotand(ODPAIR  *apairs,  int   anum,   ODPAIR
       *bpairs, int bnum, int *np);
              `apairs'  specifies the pointer to the former document
              array.  `anum' specifies the number of the elements of
              the  former  document  array.   `bpairs' specifies the
              pointer to the latter document array  of  the  sum  of
              elements.  `bnum' specifies the number of the elements
              of the latter  document  array.   `np'  specifies  the
              pointer  to a variable to which the number of the ele‐
              ments of the return value  is  assigned.   The  return
              value  is  the  pointer  to a new document array whose
              elements belong to the former set but not to the  lat‐
              ter set.  Elements of the array are sorted in descend‐
              ing order of their scores.  Because the region of  the
              return  value  is allocated with the `malloc' call, it
              should be released with the `free' call if  it  is  no
              longer in use.

       The  function `odpairssort' is used in order to sort a set of
       documents in descending order of scores.

       void odpairssort(ODPAIR *pairs, int pnum);
              `pairs' specifies the pointer  to  a  document  array.
              `pnum'  specifies  the  number  of the elements of the
              document array.

       The function `odlogarithm' is used in order to get the  natu‐
       ral logarithm of a number.

       double odlogarithm(double x);
              `x' specifies a number.  The return value is the natu‐
              ral logarithm of the number.  If the number  is  equal
              to  or  less  than 1.0, the return value is 0.0.  This
              function is useful when an application calculates  the
              IDF of search results.

       The  function  `odvectorcosine'  is  used in order to get the
       cosine of the angle of two vectors.

       double odvectorcosine(const int *avec, const int  *bvec,  int
       vnum);
              `avec'  specifies the pointer to one array of numbers.
              `bvec' specifies the pointer to  the  other  array  of
              numbers.   `vnum'  specifies the number of elements of
              each array.  The return value is  the  cosine  of  the
              angle of two vectors.  This function is useful when an
              application calculates similarity of documents.

       The function `odsettuning' is used in order to set the global
       tuning parameters.

       void odsettuning(int ibnum, int idnum, int cbnum, int csiz);
              `ibnum'  specifies  the number of buckets for inverted
              indexes.  `idnum' specifies  the  division  number  of
              inverted index.  `cbnum' specifies the number of buck‐
              ets for dirty buffers.  `csiz' specifies  the  maximum
              bytes  to  use  memory for dirty buffers.  The default
              setting  is  equivalent  to   `odsettuning(32749,   7,
              262139,  8388608)'.   This  function  should be called
              before opening a handle.

       The function `odanalyzetext' is used in order to break a text
       into  words  and  store  appearance forms and normalized form
       into lists.

       void odanalyzetext(ODEUM *odeum,  const  char  *text,  CBLIST
       *awords, CBLIST *nwords);
              `odeum' specifies a database handle.  `text' specifies
              the string of a text.  `awords' specifies a list  han‐
              dle  into  which  appearance  form is store.  `nwords'
              specifies a list handle into which normalized form  is
              store.   If  it  is  `NULL', it is ignored.  Words are
              separated with space characters and such delimiters as
              period, comma and so on.

       The  function  `odsetcharclass'  is  used in order to set the
       classes of characters used by `odanalyzetext'.

       void odsetcharclass(ODEUM  *odeum,  const  char  *spacechars,
       const char *delimchars, const char *gluechars);
              `odeum'  specifies  a  database  handle.  `spacechars'
              spacifies a string contains space characters.  `delim‐
              chars'  spacifies  a string contains delimiter charac‐
              ters.  `gluechars' spacifies a  string  contains  glue
              characters.

       The  function  `odquery' is used in order to query a database
       using a small boolean query language.

       ODPAIR *odquery(ODEUM *odeum, const  char  *query,  int  *np,
       CBLIST *errors);
              `odeum'  specifies  a database handle.  'query' speci‐
              fies the  text  of  the  query.   `np'  specifies  the
              pointer  to a variable to which the number of the ele‐
              ments of the return value is assigned.  `errors' spec‐
              ifies  a  list  handle  into  which error messages are
              stored.  If it is `NULL', it is ignored.  If  success‐
              ful,  the  return  value  is  the pointer to an array,
              else, it is `NULL'.  Each element of the  array  is  a
              pair of the ID number and the score of a document, and
              sorted in descending order of their scores.   Even  if
              no document corresponds to the specified condition, it
              is not error but returns an dummy array.  Because  the
              region of the return value is allocated with the `mal‐
              loc' call, it should be released with the `free'  call
              if  it is no longer in use.  Note that each element of
              the array of the return value can be data of a deleted
              document.

       If QDBM was built with POSIX thread enabled, the global vari‐
       able `dpecode' is treated as thread specific data, and  func‐
       tions  of  Odeum  are  reentrant.   In  that  case,  they are
       thread-safe as long as a handle is not accessed by threads at
       the  same time, on the assumption that `errno', `malloc', and
       so on are thread-safe.

       If QDBM was built with ZLIB enabled, records in the  database
       for  document  attributes  are compressed.  In that case, the
       size of the database is reduced to 30% or  less.   Thus,  you
       should  enable  ZLIB  if  you use Odeum.  A database of Odeum
       created without ZLIB enabled is not available on  environment
       with  ZLIB  enabled, and vice versa.  If ZLIB was not enabled
       but LZO, LZO is used instead.

       The query language of the function `odquery' is a basic  lan‐
       guage following this grammar:

              expr ::= subexpr ( op subexpr )*
              subexpr ::= WORD
              subexpr ::= LPAREN expr RPAREN

       Operators are "&" (AND), "|" (OR), and "!" (NOTAND).  You can
       use parenthesis to group sub-expressions together in order to
       change  order  of  operations.   The given query is broken up
       using the function `odanalyzetext', so if you want to specify
       different  text  breaking  rules,  then make sure that you at
       least set "&", "|", "!", "(", and ")" to be delimiter charac‐
       ters.   Consecutive  words  are treated as having an implicit
       "&" operator between them, so "zed shaw" is actually  "zed  &
       shaw".

       The  encoding  of  the query text should be the same with the
       encoding of target documents.  Moreover, each of space  char‐
       acters,  delimiter  characters, and glue characters should be
       single byte.


SEE ALSO
       qdbm(3), depot(3), curia(3),  relic(3),  hovel(3),  cabin(3),
       villa(3), ndbm(3), gdbm(3)



Man Page                     2004-04-22                     ODEUM(3)
Results 1 - 1 of 1
Help - FTP Sites List - Software Dir.
Search over 15 billion files
© 1997-2017 FileWatcher.com