localcli.h

一个不错的fastdb使用例子

//-< LOCALCLI.H >----------------------------------------------------*--------*
// FastDB                    Version 1.0         (c) 1999  GARRET    *     ?  *
// (Main Memory Database Management System)                          *   /\|  *
//                                                                   *  /  \  *
//                          Created:     20-Jun-2002  K.A. Knizhnik  * / [] \ *
//                          Last update: 20-Jun-2002  K.A. Knizhnik  * GARRET *
//-------------------------------------------------------------------*--------*
// Header file for local C interface to database
//-------------------------------------------------------------------*--------*

#include "fastdb.h"
#include "compiler.h"
#include "cli.h"
#include "cliproto.h"
#include "array.h"

inline int map_type(dbFieldDescriptor* fd)
{
  return (fd->type < dbField::tpArray)
         ? fd2cli_type_mapping[fd->type]
         : (fd->type == dbField::tpArray && fd->components->type < dbField::tpArray)
         ? cli_array_of_oid + fd2cli_type_mapping[fd->components->type]
         : cli_unknown;
}


struct parameter_binding
{
  parameter_binding* next;
  char*   name;
  int     var_type;
  int     var_len;
  void*   var_ptr;
};

struct column_binding
{
  column_binding*    next;
  dbFieldDescriptor* field;
  char*              name;
  int                var_type;
  int*               var_len;
  void*              var_ptr;
  cli_column_get_ex  get_fnc;
  cli_column_set_ex  set_fnc;
};

struct session_desc;

struct statement_desc
{
  int                id;
  statement_desc*    next;
  dbQuery            query;
  dbAnyCursor        cursor;
  dbTableDescriptor* table;
  column_binding*    columns;
  parameter_binding* params;
  session_desc*      session;
  bool               first_fetch;
  bool               for_update;
  bool               prepared;
  bool               updated;
  cli_oid_t          oid;
  int                n_params;
  int                n_columns;
  int                n_autoincremented_columns;
  int                param_size;
  void*              record_struct;
  dbSmallBuffer      sql;

  statement_desc(int id, statement_desc* next)
  {
    this->id = id;
    this->next = next;
  }

  statement_desc()
  {}

}

;


class sql_scanner
{

private:
  char*  p;
  char*  ident;

public:

  int     get
    ();

  char* current_position()
  {
    return p;
  }

  char* identifier()
  {
    return ident;
  }

  sql_scanner(char* sql)
  {
    p = sql;
  }
};

struct session_desc
{
  int              id;
  char*            name;
  session_desc*    next;
  statement_desc*  stmts;
  dbDatabase*      db;
  dbMutex          mutex;
  dbTableDescriptor* dropped_tables;
  dbTableDescriptor* existed_tables;

  session_desc(int id, session_desc* next)
  {
    this->id = id;
    this->next = next;
  }

  session_desc()
  {}

}

;

template<class T>

class fixed_size_object_allocator
{

protected:
  T*          free_chain;
  dbMutex     mutex;

public:
  T* allocate()
  {
    dbCriticalSection cs(mutex);
    T* obj = free_chain;

    if (obj == NULL)
    {
      obj = new T();
    }
    else
    {
      free_chain = obj->next;
    }

    return obj;
  }

  void free(T* desc)
  {
    dbCriticalSection cs(mutex);
    desc->next = free_chain;
    free_chain = desc;
  }

  fixed_size_object_allocator()
  {
    free_chain = NULL;
  }

  ~fixed_size_object_allocator()
  {
    T *obj, *next;

    for (obj = free_chain; obj != NULL; obj = next)
    {
      next = obj->next;
      delete obj;
    }
  }
};

template<class T>

class descriptor_table : public fixed_size_object_allocator<T>
{

public:
  T**         table;
  int         descriptor_table_size;

public:
  descriptor_table()
  {
    int i;
    descriptor_table_size = 16;
    table = new T*[descriptor_table_size];
    T* next = NULL;

    for (i = 0; i < descriptor_table_size; i++)
    {
      table[i] = next = new T(i, next);
    }

    free_chain = next;
  }

  ~descriptor_table()
  {
    if (table)
      delete[] table;
  }

  T* get
    (int desc)
  {
    dbCriticalSection cs(mutex);
    return (desc >= descriptor_table_size) ? (T*)0 : table[desc];
  }

  T* allocate()
  {
    dbCriticalSection cs(mutex);

    if (free_chain == NULL)
    {
      int i, n;
      T** desc = new T*[descriptor_table_size * 2];
      memcpy(desc, table, descriptor_table_size*sizeof(T*));
      delete[] table;
      table = desc;
      T* next = NULL;

      for (i = descriptor_table_size, n = i*2; i < n; i++)
      {
        table[i] = next = new T(i, next);
      }

      free_chain = next;
      descriptor_table_size = n;
    }

    T* desc = free_chain;
    free_chain = desc->next;
    return desc;
  }
};

class FASTDB_DLL_ENTRY dbCLI
{

private:
  fixed_size_object_allocator<column_binding> column_allocator;
  fixed_size_object_allocator<parameter_binding> parameter_allocator;

  descriptor_table<session_desc>   sessions;
  descriptor_table<statement_desc> statements;

  session_desc* active_session_list;

  dbMutex sessionMutex;

public:
  static dbCLI instance;

  dbCLI()
  {
    active_session_list = NULL;
  }

  int create_session(char const* databasePath,
                     char const* filePath,
                     unsigned    transactionCommitDelay,
                     int         openAttr,
                     size_t      initDatabaseSize,
                     size_t      extensionQuantum,
                     size_t      initIndexSize,
                     size_t      fileSizeLimit);


  int create_replication_node(int         nodeId,
                              int         nServers,
                              char*       nodeNames[],
                              char const* databaseName,
                              char const* filePath,
                              int         openAttr,
                              size_t      initDatabaseSize,
                              size_t      extensionQuantum,
                              size_t      initIndexSize,
                              size_t      fileSizeLimit);

  int create_statement(int session, char const* sql);

  session_desc* get_session(int id)
  {
    return sessions.get(id);
  }

  int bind_parameter(int         statement,
                     char const* param_name,
                     int         var_type,
                     void*       var_ptr);

  int bind_column(int         statement,
                  char const* column_name,
                  int         var_type,
                  int*        var_len,
                  void*       var_ptr);

  int bind_array_column(int               statement,
                        char const*       column_name,
                        int               var_type,
                        void*             var_ptr,

                        cli_column_set_ex set
                          ,
                          cli_column_get_ex get
                           );

  int fetch(int statement, int for_update);

  int fetch_columns(statement_desc* stmt);

  int store_columns(char* buf, statement_desc* stmt);

  int insert(int statement, cli_oid_t* oid);

  int update(int statement);

  int freeze(int statement);

  int unfreeze(int statement);

  int get_first(int statement);

  int get_last(int statement);

  int get_next(int statement);

  int get_prev(int statement);

  int skip(int statement, int n);

  int seek(int statement, cli_oid_t oid);

  cli_oid_t get_current_oid(int statement);

  int free_statement(int statement);

  int free_statement(statement_desc* stmt);

  int commit(int session);

  int precommit(int session);

  int abort(int session);

  int remove
    (int statement);

  int describe(int session, char const* table, cli_field_descriptor** fields);

  int show_tables(int session, cli_table_descriptor** tables);

  int match_columns(char const* table_name, statement_desc* stmt);

  int create_table(int session, char const* tableName, int nColumns,
                   cli_field_descriptor* columns);

  int drop_table(int session, char const* tableName);

  int alter_index(int session, char const* tableName, char const* fieldName, int newFlags);

  cli_error_handler set_error_handler(int session, cli_error_handler new_handler);

  int attach(int session);

  int detach(int session, int detach_mode);

  int get_database_state(int session, cli_database_monitor* monitor);

  int close(int session);

  int prepare_query(int session, char const* query);

  int execute_query(int statement, int for_update, void* record_struct, va_list params);

  int insert_struct(int session, char const* table_name, void* record_struct, cli_oid_t* oid);

  static int create_table(dbDatabase* db, char const* tableName, int nColumns,
                          cli_field_descriptor* columns);

  static int alter_index(dbDatabase* db, char const* tableName, char const* fieldName, int newFlags);
};