/* =================================================================
 Copyright (C) 2014 BizStation Corp All rights reserved.

 This program 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
 of the License, or (at your option) any later version.

 This program 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., 59 Temple Place - Suite 330, Boston, MA
 02111-1307, USA.
 ================================================================= */

/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 3.0.2
 * ----------------------------------------------------------------------------- */
#ifndef SWIGRUBY
#define SWIGRUBY
#endif

#ifdef __cplusplus
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigMovePointer {
    T *ptr;
    SwigMovePointer(T *p) : ptr(p) { }
    ~SwigMovePointer() { delete ptr; }
    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  operator T&() const { return *pointer.ptr; }
  T *operator&() { return pointer.ptr; }
};

template <typename T> T SwigValueInit() {
  return T();
}
#endif


struct SWIG_CHAR
{
    int alloc;
    char* str;
    SWIG_CHAR() :alloc(0), str(0){}
    ~SWIG_CHAR()
    {
        if (alloc) delete[] str;
    }
};

/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif

/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#   define SWIGINLINE inline
# else
#   define SWIGINLINE
# endif
#endif

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__))
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__))
# else
#   define SWIGUNUSED
# endif
#endif

#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif

#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods */
#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#  ifndef GCC_HASCLASSVISIBILITY
#    define GCC_HASCLASSVISIBILITY
#  endif
#endif

#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif
#endif

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif


/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif

/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#   define SWIGINLINE inline
# else
#   define SWIGINLINE
# endif
#endif

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__))
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__))
# else
#   define SWIGUNUSED
# endif
#endif

#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif

#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods */
#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#  ifndef GCC_HASCLASSVISIBILITY
#    define GCC_HASCLASSVISIBILITY
#  endif
#endif

#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif
#endif

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif


/* -----------------------------------------------------------------------------
 * swigrun.swg
 *
 * This file contains generic C API SWIG runtime support for pointer
 * type checking.
 * ----------------------------------------------------------------------------- */

/* This should only be incremented when either the layout of swig_type_info changes,
   or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "4"

/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif

/*
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
  creating a static or dynamic library from the SWIG runtime code.
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.

  But only do this if strictly necessary, ie, if you have problems
  with your compiler or suchlike.
*/

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

/*  Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif

/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN        0x1
#define SWIG_CAST_NEW_MEMORY       0x2

/* Flags for new pointer objects */
#define SWIG_POINTER_OWN           0x1


/*
   Flags/methods for returning states.

   The SWIG conversion methods, as ConvertPtr, return an integer
   that tells if the conversion was successful or not. And if not,
   an error code can be returned (see swigerrors.swg for the codes).

   Use the following macros/flags to set or process the returning
   states.

   In old versions of SWIG, code such as the following was usually written:

     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
       // success code
     } else {
       //fail code
     }

   Now you can be more explicit:

    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
    } else {
      // fail code
    }

   which is the same really, but now you can also do

    Type *ptr;
    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
      if (SWIG_IsNewObj(res) {
        ...
    delete *ptr;
      } else {
        ...
      }
    } else {
      // fail code
    }

   I.e., now SWIG_ConvertPtr can return new objects and you can
   identify the case and take care of the deallocation. Of course that
   also requires SWIG_ConvertPtr to return new result values, such as

      int SWIG_ConvertPtr(obj, ptr,...) {
        if (<obj is ok>) {
          if (<need new object>) {
            *ptr = <ptr to new allocated object>;
            return SWIG_NEWOBJ;
          } else {
            *ptr = <ptr to old object>;
            return SWIG_OLDOBJ;
          }
        } else {
          return SWIG_BADOBJ;
        }
      }

   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
   SWIG errors code.

   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
   allows to return the 'cast rank', for example, if you have this

       int food(double)
       int fooi(int);

   and you call

      food(1)   // cast rank '1'  (1 -> 1.0)
      fooi(1)   // cast rank '0'

   just use the SWIG_AddCast()/SWIG_CheckState()
*/

#define SWIG_OK                    (0)
#define SWIG_ERROR                 (-1)
#define SWIG_IsOK(r)               (r >= 0)
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)

/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT         (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
/* The TmpMask is for in/out typemaps that use temporal objects */
#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ                (SWIG_ERROR)
#define SWIG_OLDOBJ                (SWIG_OK)
#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del mask methods */
#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))

/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
#  ifndef SWIG_TypeRank
#    define SWIG_TypeRank             unsigned long
#  endif
#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
#    define SWIG_MAXCASTRANK          (2)
#  endif
#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) {
  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) {
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
#  define SWIG_AddCast(r) (r)
#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif


#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);

/* Structure to store information on one type */
typedef struct swig_type_info {
  const char             *name;         /* mangled name of this type */
  const char             *str;          /* human readable name of this type */
  swig_dycast_func        dcast;        /* dynamic cast function down a hierarchy */
  struct swig_cast_info  *cast;         /* linked list of types that can cast into this type */
  void                   *clientdata;       /* language specific type data */
  int                    owndata;       /* flag if the structure owns the clientdata */
} swig_type_info;

/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
  swig_type_info         *type;         /* pointer to type that is equivalent to this type */
  swig_converter_func     converter;        /* function to cast the void pointers */
  struct swig_cast_info  *next;         /* pointer to next cast in linked list */
  struct swig_cast_info  *prev;         /* pointer to the previous cast */
} swig_cast_info;

/* Structure used to store module information
 * Each module generates one structure like this, and the runtime collects
 * all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
  swig_type_info         **types;       /* Array of pointers to swig_type_info structures that are in this module */
  size_t                 size;              /* Number of types in this module */
  struct swig_module_info *next;        /* Pointer to next element in circularly linked list */
  swig_type_info         **type_initial;    /* Array of initially generated type structures */
  swig_cast_info         **cast_initial;    /* Array of initially generated casting structures */
  void                    *clientdata;      /* Language specific module data */
} swig_module_info;

/*
  Compare two type names skipping the space characters, therefore
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.

  Return 0 when the two name types are equivalent, as in
  strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
          const char *f2, const char *l2) {
  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
    while ((*f1 == ' ') && (f1 != l1)) ++f1;
    while ((*f2 == ' ') && (f2 != l2)) ++f2;
    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
  }
  return (int)((l1 - f1) - (l2 - f2));
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
  int equiv = 1;
  const char* te = tb + strlen(tb);
  const char* ne = nb;
  while (equiv != 0 && *ne) {
    for (nb = ne; *ne; ++ne) {
      if (*ne == '|') break;
    }
    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
    if (*ne) ++ne;
  }
  return equiv;
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}

/*
  Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (strcmp(iter->type->name, c) == 0) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

/*
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (iter->type == from) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

/*
  Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}

/*
   Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
  swig_type_info *lastty = ty;
  if (!ty || !ty->dcast) return ty;
  while (ty && (ty->dcast)) {
    ty = (*ty->dcast)(ptr);
    if (ty) lastty = ty;
  }
  return lastty;
}

/*
  Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
  return ty->name;
}

/*
  Return the pretty name associated with this type,
  that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
  /* The "str" field contains the equivalent pretty names of the
     type, separated by vertical-bar characters.  We choose
     to print the last name, as it is often (?) the most
     specific. */
  if (!type) return NULL;
  if (type->str != NULL) {
    const char *last_name = type->str;
    const char *s;
    for (s = type->str; *s; s++)
      if (*s == '|') last_name = s+1;
    return last_name;
  }
  else
    return type->name;
}

/*
   Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  swig_cast_info *cast = ti->cast;
  /* if (ti->clientdata == clientdata) return; */
  ti->clientdata = clientdata;

  while (cast) {
    if (!cast->converter) {
      swig_type_info *tc = cast->type;
      if (!tc->clientdata) {
    SWIG_TypeClientData(tc, clientdata);
      }
    }
    cast = cast->next;
  }
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
  SWIG_TypeClientData(ti, clientdata);
  ti->owndata = 1;
}

/*
  Search for a swig_type_info structure only by mangled name
  Search is a O(log #types)

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
                            swig_module_info *end,
                    const char *name) {
  swig_module_info *iter = start;
  do {
    if (iter->size) {
      size_t l = 0;
      size_t r = iter->size - 1;
      do {
    /* since l+r >= 0, we can (>> 1) instead (/ 2) */
    size_t i = (l + r) >> 1;
    const char *iname = iter->types[i]->name;
    if (iname) {
      int compare = strcmp(name, iname);
      if (compare == 0) {
        return iter->types[i];
      } else if (compare < 0) {
        if (i) {
          r = i - 1;
        } else {
          break;
        }
      } else if (compare > 0) {
        l = i + 1;
      }
    } else {
      break; /* should never happen */
    }
      } while (l <= r);
    }
    iter = iter->next;
  } while (iter != end);
  return 0;
}

/*
  Search for a swig_type_info structure for either a mangled name or a human readable name.
  It first searches the mangled names of the types, which is a O(log #types)
  If a type is not found it then searches the human readable names, which is O(#types).

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start,
                     swig_module_info *end,
             const char *name) {
  /* STEP 1: Search the name field using binary search */
  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
  if (ret) {
    return ret;
  } else {
    /* STEP 2: If the type hasn't been found, do a complete search
       of the str field (the human readable name) */
    swig_module_info *iter = start;
    do {
      size_t i = 0;
      for (; i < iter->size; ++i) {
    if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
      return iter->types[i];
      }
      iter = iter->next;
    } while (iter != end);
  }

  /* neither found a match */
  return 0;
}

/*
   Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
  static const char hex[17] = "0123456789abcdef";
  const unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu =  u + sz;
  for (; u != eu; ++u) {
    unsigned char uu = *u;
    *(c++) = hex[(uu & 0xf0) >> 4];
    *(c++) = hex[uu & 0xf];
  }
  return c;
}

/*
   Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
  unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu = u + sz;
  for (; u != eu; ++u) {
    char d = *(c++);
    unsigned char uu;
    if ((d >= '0') && (d <= '9'))
      uu = ((d - '0') << 4);
    else if ((d >= 'a') && (d <= 'f'))
      uu = ((d - ('a'-10)) << 4);
    else
      return (char *) 0;
    d = *(c++);
    if ((d >= '0') && (d <= '9'))
      uu |= (d - '0');
    else if ((d >= 'a') && (d <= 'f'))
      uu |= (d - ('a'-10));
    else
      return (char *) 0;
    *u = uu;
  }
  return c;
}

/*
   Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
  char *r = buff;
  if ((2*sizeof(void *) + 2) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,&ptr,sizeof(void *));
  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
  strcpy(r,name);
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      *ptr = (void *) 0;
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sizeof(void *));
}

SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
  char *r = buff;
  size_t lname = (name ? strlen(name) : 0);
  if ((2*sz + 2 + lname) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,ptr,sz);
  if (lname) {
    strncpy(r,name,lname+1);
  } else {
    *r = 0;
  }
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      memset(ptr,0,sz);
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sz);
}

#ifdef __cplusplus
}
#endif

/*  Errors in SWIG */
#define  SWIG_UnknownError         -1
#define  SWIG_IOError              -2
#define  SWIG_RuntimeError         -3
#define  SWIG_IndexError           -4
#define  SWIG_TypeError            -5
#define  SWIG_DivisionByZero       -6
#define  SWIG_OverflowError        -7
#define  SWIG_SyntaxError          -8
#define  SWIG_ValueError           -9
#define  SWIG_SystemError          -10
#define  SWIG_AttributeError       -11
#define  SWIG_MemoryError          -12
#define  SWIG_NullReferenceError   -13



#include <ruby.h>

/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
 * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
 * issue for now by disabling this.
 * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
 */
#ifdef rb_intern
# undef rb_intern
#endif

/* Remove global macros defined in Ruby's win32.h */
#ifdef write
# undef write
#endif
#ifdef read
# undef read
#endif
#ifdef bind
# undef bind
#endif
#ifdef close
# undef close
#endif
#ifdef connect
# undef connect
#endif


/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
#ifndef NUM2LL
#define NUM2LL(x) NUM2LONG((x))
#endif
#ifndef LL2NUM
#define LL2NUM(x) INT2NUM((long) (x))
#endif
#ifndef ULL2NUM
#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
#endif

/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
#ifndef NUM2ULL
#ifdef HAVE_LONG_LONG
#define NUM2ULL(x) rb_num2ull((x))
#else
#define NUM2ULL(x) NUM2ULONG(x)
#endif
#endif

/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
/* Define these for older versions so we can just write code the new way */
#ifndef RSTRING_LEN
# define RSTRING_LEN(x) RSTRING(x)->len
#endif
#ifndef RSTRING_PTR
# define RSTRING_PTR(x) RSTRING(x)->ptr
#endif
#ifndef RSTRING_END
# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
#endif
#ifndef RARRAY_LEN
# define RARRAY_LEN(x) RARRAY(x)->len
#endif
#ifndef RARRAY_PTR
# define RARRAY_PTR(x) RARRAY(x)->ptr
#endif
#ifndef RFLOAT_VALUE
# define RFLOAT_VALUE(x) RFLOAT(x)->value
#endif
#ifndef DOUBLE2NUM
# define DOUBLE2NUM(x) rb_float_new(x)
#endif
#ifndef RHASH_TBL
# define RHASH_TBL(x) (RHASH(x)->tbl)
#endif
#ifndef RHASH_ITER_LEV
# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
#endif
#ifndef RHASH_IFNONE
# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
#endif
#ifndef RHASH_SIZE
# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
#endif
#ifndef RHASH_EMPTY_P
# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
#endif
#ifndef RSTRUCT_LEN
# define RSTRUCT_LEN(x) RSTRUCT(x)->len
#endif
#ifndef RSTRUCT_PTR
# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
#endif



/*
 * Need to be very careful about how these macros are defined, especially
 * when compiling C++ code or C code with an ANSI C compiler.
 *
 * VALUEFUNC(f) is a macro used to typecast a C function that implements
 * a Ruby method so that it can be passed as an argument to API functions
 * like rb_define_method() and rb_define_singleton_method().
 *
 * VOIDFUNC(f) is a macro used to typecast a C function that implements
 * either the "mark" or "free" stuff for a Ruby Data object, so that it
 * can be passed as an argument to API functions like Data_Wrap_Struct()
 * and Data_Make_Struct().
 */
 
#ifdef __cplusplus
#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
#    define PROTECTFUNC(f) ((VALUE (*)()) f)
#    define VALUEFUNC(f) ((VALUE (*)()) f)
#    define VOIDFUNC(f)  ((void (*)()) f)
#  else
#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
#      define PROTECTFUNC(f) ((VALUE (*)()) f)
#      define VALUEFUNC(f) ((VALUE (*)()) f)
#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
#    else /* These definitions should work for Ruby 1.7+ */
#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
#    endif
#  endif
#else
#  define VALUEFUNC(f) (f)
#  define VOIDFUNC(f) (f)
#endif

/* Don't use for expressions have side effect */
#ifndef RB_STRING_VALUE
#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
#endif
#ifndef StringValue
#define StringValue(s) RB_STRING_VALUE(s)
#endif
#ifndef StringValuePtr
#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
#endif
#ifndef StringValueLen
#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
#endif
#ifndef SafeStringValue
#define SafeStringValue(v) do {\
    StringValue(v);\
    rb_check_safe_str(v);\
} while (0)
#endif

#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
#endif

static VALUE _mSWIG = Qnil;

/* -----------------------------------------------------------------------------
 * error manipulation
 * ----------------------------------------------------------------------------- */


/* Define some additional error types */
#define SWIG_ObjectPreviouslyDeletedError  -100


/* Define custom exceptions for errors that do not map to existing Ruby
   exceptions.  Note this only works for C++ since a global cannot be
   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/

SWIGINTERN VALUE 
getNullReferenceError(void) {
  static int init = 0;
  static VALUE rb_eNullReferenceError ;
  if (!init) {
    init = 1;
    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
  }
  return rb_eNullReferenceError;
} 

SWIGINTERN VALUE 
getObjectPreviouslyDeletedError(void) {
  static int init = 0;
  static VALUE rb_eObjectPreviouslyDeleted ;
  if (!init) {
    init = 1;
    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
  }
  return rb_eObjectPreviouslyDeleted;
} 


SWIGINTERN VALUE
SWIG_Ruby_ErrorType(int SWIG_code) {
  VALUE type;
  switch (SWIG_code) {
  case SWIG_MemoryError:
    type = rb_eNoMemError;
    break;
  case SWIG_IOError:
    type = rb_eIOError;
    break;
  case SWIG_RuntimeError:
    type = rb_eRuntimeError;
    break;
  case SWIG_IndexError:
    type = rb_eIndexError;
    break;
  case SWIG_TypeError:
    type = rb_eTypeError;
    break;
  case SWIG_DivisionByZero:
    type = rb_eZeroDivError;
    break;
  case SWIG_OverflowError:
    type = rb_eRangeError;
    break;
  case SWIG_SyntaxError:
    type = rb_eSyntaxError;
    break;
  case SWIG_ValueError:
    type = rb_eArgError;
    break;
  case SWIG_SystemError:
    type = rb_eFatal;
    break;
  case SWIG_AttributeError:
    type = rb_eRuntimeError;
    break;
  case SWIG_NullReferenceError:
    type = getNullReferenceError();
    break;
  case SWIG_ObjectPreviouslyDeletedError:
    type = getObjectPreviouslyDeletedError();
    break;
  case SWIG_UnknownError:
    type = rb_eRuntimeError;
    break;
  default:
    type = rb_eRuntimeError;
  }
  return type;
}


/* This function is called when a user inputs a wrong argument to
   a method.
 */
SWIGINTERN 
const char* Ruby_Format_TypeError( const char* msg,
                   const char* type, 
                   const char* name, 
                   const int argn,
                   VALUE input )
{
  char buf[128];
  VALUE str;
  VALUE asStr;
  if ( msg && *msg )
    {
      str = rb_str_new2(msg);
    }
  else
    {
      str = rb_str_new(NULL, 0);
    }

  str = rb_str_cat2( str, "Expected argument " );
  sprintf( buf, "%d of type ", argn-1 );
  str = rb_str_cat2( str, buf );
  str = rb_str_cat2( str, type );
  str = rb_str_cat2( str, ", but got " );
  str = rb_str_cat2( str, rb_obj_classname(input) );
  str = rb_str_cat2( str, " " );
  asStr = rb_inspect(input);
  if ( RSTRING_LEN(asStr) > 30 )
    {
      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
      str = rb_str_cat2( str, "..." );
    }
  else
    {
      str = rb_str_append( str, asStr );
    }

  if ( name )
    {
      str = rb_str_cat2( str, "\n\tin SWIG method '" );
      str = rb_str_cat2( str, name );
      str = rb_str_cat2( str, "'" );
    }

  return StringValuePtr( str );
}

/* This function is called when an overloaded method fails */
SWIGINTERN 
void Ruby_Format_OverloadedError(
                 const int argc,
                 const int maxargs,
                 const char* method, 
                 const char* prototypes 
                 )
{
  const char* msg = "Wrong # of arguments";
  if ( argc <= maxargs ) msg = "Wrong arguments";
  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
       "Possible C/C++ prototypes are:\n%s",
       msg, method, prototypes);
}

/* -----------------------------------------------------------------------------
 * rubytracking.swg
 *
 * This file contains support for tracking mappings from 
 * Ruby objects to C++ objects.  This functionality is needed
 * to implement mark functions for Ruby's mark and sweep
 * garbage collector.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#endif

/* Ruby 1.8 actually assumes the first case. */
#if SIZEOF_VOIDP == SIZEOF_LONG
#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
#else
#  error sizeof(void*) is not the same as long or long long
#endif


/* Global Ruby hash table to store Trackings from C/C++
   structs to Ruby Objects. 
*/
static VALUE swig_ruby_trackings = Qnil;

/* Global variable that stores a reference to the ruby
   hash table delete function. */
static ID swig_ruby_hash_delete;

/* Setup a Ruby hash table to store Trackings */
SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
  /* Create a ruby hash table to store Trackings from C++ 
     objects to Ruby objects. */

  /* Try to see if some other .so has already created a 
     tracking hash table, which we keep hidden in an instance var
     in the SWIG module.
     This is done to allow multiple DSOs to share the same
     tracking table.
  */
  ID trackings_id = rb_intern( "@__trackings__" );
  VALUE verbose = rb_gv_get("VERBOSE");
  rb_gv_set("VERBOSE", Qfalse);
  swig_ruby_trackings = rb_ivar_get( _mSWIG, trackings_id );
  rb_gv_set("VERBOSE", verbose);

  /* No, it hasn't.  Create one ourselves */ 
  if ( swig_ruby_trackings == Qnil )
    {
      swig_ruby_trackings = rb_hash_new();
      rb_ivar_set( _mSWIG, trackings_id, swig_ruby_trackings );
    }

  /* Now store a reference to the hash table delete function
     so that we only have to look it up once.*/
  swig_ruby_hash_delete = rb_intern("delete");
}

/* Get a Ruby number to reference a pointer */
SWIGRUNTIME VALUE SWIG_RubyPtrToReference(void* ptr) {
  /* We cast the pointer to an unsigned long
     and then store a reference to it using
     a Ruby number object. */

  /* Convert the pointer to a Ruby number */
  return SWIG2NUM(ptr);
}

/* Get a Ruby number to reference an object */
SWIGRUNTIME VALUE SWIG_RubyObjectToReference(VALUE object) {
  /* We cast the object to an unsigned long
     and then store a reference to it using
     a Ruby number object. */

  /* Convert the Object to a Ruby number */
  return SWIG2NUM(object);
}

/* Get a Ruby object from a previously stored reference */
SWIGRUNTIME VALUE SWIG_RubyReferenceToObject(VALUE reference) {
  /* The provided Ruby number object is a reference
     to the Ruby object we want.*/

  /* Convert the Ruby number to a Ruby object */
  return NUM2SWIG(reference);
}

/* Add a Tracking from a C/C++ struct to a Ruby object */
SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
  /* In a Ruby hash table we store the pointer and
     the associated Ruby object.  The trick here is
     that we cannot store the Ruby object directly - if
     we do then it cannot be garbage collected.  So
     instead we typecast it as a unsigned long and
     convert it to a Ruby number object.*/

  /* Get a reference to the pointer as a Ruby number */
  VALUE key = SWIG_RubyPtrToReference(ptr);

  /* Get a reference to the Ruby object as a Ruby number */
  VALUE value = SWIG_RubyObjectToReference(object);

  /* Store the mapping to the global hash table. */
  rb_hash_aset(swig_ruby_trackings, key, value);
}

/* Get the Ruby object that owns the specified C/C++ struct */
SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
  /* Get a reference to the pointer as a Ruby number */
  VALUE key = SWIG_RubyPtrToReference(ptr);

  /* Now lookup the value stored in the global hash table */
  VALUE value = rb_hash_aref(swig_ruby_trackings, key);
    
  if (value == Qnil) {
    /* No object exists - return nil. */
    return Qnil;
  }
  else {
    /* Convert this value to Ruby object */
    return SWIG_RubyReferenceToObject(value);
  }
}

/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
   is very important to remove objects once they are destroyed
   since the same memory address may be reused later to create
   a new object. */
SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
  /* Get a reference to the pointer as a Ruby number */
  VALUE key = SWIG_RubyPtrToReference(ptr);

  /* Delete the object from the hash table by calling Ruby's
     do this we need to call the Hash.delete method.*/
  rb_funcall(swig_ruby_trackings, swig_ruby_hash_delete, 1, key);
}

/* This is a helper method that unlinks a Ruby object from its
   underlying C++ object.  This is needed if the lifetime of the
   Ruby object is longer than the C++ object */
SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
  VALUE object = SWIG_RubyInstanceFor(ptr);

  if (object != Qnil) {
    DATA_PTR(object) = 0;
  }
}


#ifdef __cplusplus
}
#endif

/* -----------------------------------------------------------------------------
 * Ruby API portion that goes into the runtime
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#endif

SWIGINTERN VALUE
SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
  if (NIL_P(target)) {
    target = o;
  } else {
    if (TYPE(target) != T_ARRAY) {
      VALUE o2 = target;
      target = rb_ary_new();
      rb_ary_push(target, o2);
    }
    rb_ary_push(target, o);
  }
  return target;
}

/* For ruby1.8.4 and earlier. */
#ifndef RUBY_INIT_STACK
   RUBY_EXTERN void Init_stack(VALUE* addr);
#  define RUBY_INIT_STACK \
   VALUE variable_in_this_stack_frame; \
   Init_stack(&variable_in_this_stack_frame);
#endif


#ifdef __cplusplus
}
#endif


/* -----------------------------------------------------------------------------
 * rubyrun.swg
 *
 * This file contains the runtime support for Ruby modules
 * and includes code for managing global variables and pointer
 * type checking.
 * ----------------------------------------------------------------------------- */

/* For backward compatibility only */
#define SWIG_POINTER_EXCEPTION  0

/* for raw pointers */
#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
#define swig_owntype                                    ruby_owntype

/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)

/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)

/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)

/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)


/* Runtime API */

#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer)         SWIG_Ruby_SetModule(pointer)


/* Error manipulation */

#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
#define SWIG_Error(code, msg)                   rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
#define SWIG_fail                               goto fail                


/* Ruby-specific SWIG API */

#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
#define SWIG_define_class(ty)                           SWIG_Ruby_define_class(ty)
#define SWIG_NewClassInstance(value, ty)                SWIG_Ruby_NewClassInstance(value, ty)
#define SWIG_MangleStr(value)                           SWIG_Ruby_MangleStr(value)        
#define SWIG_CheckConvert(value, ty)                    SWIG_Ruby_CheckConvert(value, ty)     

#include "assert.h"

/* -----------------------------------------------------------------------------
 * pointers/data manipulation
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#endif

typedef struct {
  VALUE klass;
  VALUE mImpl;
  void  (*mark)(void *);
  void  (*destroy)(void *);
  int trackObjects;
} swig_class;


/* Global pointer used to keep some internal SWIG stuff */
static VALUE _cSWIG_Pointer = Qnil;
static VALUE swig_runtime_data_type_pointer = Qnil;

/* Global IDs used to keep some internal SWIG stuff */
static ID swig_arity_id = 0;
static ID swig_call_id  = 0;

/*
  If your swig extension is to be run within an embedded ruby and has
  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
  This will reset ruby's stack frame on each entry point from the main 
  program the first time a virtual director function is invoked (in a 
  non-recursive way).
  If this is not done, you run the risk of Ruby trashing the stack.
*/

#ifdef RUBY_EMBEDDED

#  define SWIG_INIT_STACK                            \
      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
      ++swig_virtual_calls;
#  define SWIG_RELEASE_STACK --swig_virtual_calls;
#  define Ruby_DirectorTypeMismatchException(x) \
          rb_raise( rb_eTypeError, "%s", x ); return c_result;

      static unsigned int swig_virtual_calls = 0;

#else  /* normal non-embedded extension */

#  define SWIG_INIT_STACK
#  define SWIG_RELEASE_STACK
#  define Ruby_DirectorTypeMismatchException(x) \
          throw Swig::DirectorTypeMismatchException( x );

#endif  /* RUBY_EMBEDDED */


SWIGRUNTIME VALUE 
getExceptionClass(void) {
  static int init = 0;
  static VALUE rubyExceptionClass ;
  if (!init) {
    init = 1;
    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
  }
  return rubyExceptionClass;
} 

/* This code checks to see if the Ruby object being raised as part
   of an exception inherits from the Ruby class Exception.  If so,
   the object is simply returned.  If not, then a new Ruby exception
   object is created and that will be returned to Ruby.*/
SWIGRUNTIME VALUE
SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
  VALUE exceptionClass = getExceptionClass();
  if (rb_obj_is_kind_of(obj, exceptionClass)) {
    return obj;
  }  else {
    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
  }
}

/* Initialize Ruby runtime support */
SWIGRUNTIME void
SWIG_Ruby_InitRuntime(void)
{
  if (_mSWIG == Qnil) {
    _mSWIG = rb_define_module("SWIG");
    swig_call_id  = rb_intern("call");
    swig_arity_id = rb_intern("arity");
  }
}

/* Define Ruby class for C type */
SWIGRUNTIME void
SWIG_Ruby_define_class(swig_type_info *type)
{
  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
  sprintf(klass_name, "TYPE%s", type->name);
  if (NIL_P(_cSWIG_Pointer)) {
    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
  }
  rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
  free((void *) klass_name);
}

/* Create a new pointer object */
SWIGRUNTIME VALUE
SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
{
  int own =  flags & SWIG_POINTER_OWN; 
  int track;
  char *klass_name;
  swig_class *sklass;
  VALUE klass;
  VALUE obj;
  
  if (!ptr)
    return Qnil;
  
  if (type->clientdata) {
    sklass = (swig_class *) type->clientdata;
        
    /* Are we tracking this class and have we already returned this Ruby object? */
    track = sklass->trackObjects;
    if (track) {
      obj = SWIG_RubyInstanceFor(ptr);
      
      /* Check the object's type and make sure it has the correct type.
        It might not in cases where methods do things like 
        downcast methods. */
      if (obj != Qnil) {
        VALUE value = rb_iv_get(obj, "@__swigtype__");
        const char* type_name = RSTRING_PTR(value);
                
        if (strcmp(type->name, type_name) == 0) {
          return obj;
        }
      }
    }

    /* Create a new Ruby object */
    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
               ( own ? VOIDFUNC(sklass->destroy) : 
                 (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
                 ), ptr);

    /* If tracking is on for this class then track this object. */
    if (track) {
      SWIG_RubyAddTracking(ptr, obj);
    }
  } else {
    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
    sprintf(klass_name, "TYPE%s", type->name);
    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
    free((void *) klass_name);
    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
  }
  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
  
  return obj;
}

/* Create a new class instance (always owned) */
SWIGRUNTIME VALUE
SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
{
  VALUE obj;
  swig_class *sklass = (swig_class *) type->clientdata;
  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
  return obj;
}

/* Get type mangle from class name */
SWIGRUNTIMEINLINE char *
SWIG_Ruby_MangleStr(VALUE obj)
{
  VALUE stype = rb_iv_get(obj, "@__swigtype__");
  return StringValuePtr(stype);
}

/* Acquire a pointer value */
typedef void (*ruby_owntype)(void*);

SWIGRUNTIME ruby_owntype
SWIG_Ruby_AcquirePtr(VALUE obj, ruby_owntype own) {
  if (obj) {
    ruby_owntype oldown = RDATA(obj)->dfree;
    RDATA(obj)->dfree = own;
    return oldown;
  } else {
    return 0;
  }
}

/* Convert a pointer value */
SWIGRUNTIME int
SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, ruby_owntype *own)
{
  char *c;
  swig_cast_info *tc;
  void *vptr = 0;

  /* Grab the pointer */
  if (NIL_P(obj)) {
    *ptr = 0;
    return SWIG_OK;
  } else {
    if (TYPE(obj) != T_DATA) {
      return SWIG_ERROR;
    }
    Data_Get_Struct(obj, void, vptr);
  }
  
  if (own) *own = RDATA(obj)->dfree;
    
  /* Check to see if the input object is giving up ownership
     of the underlying C struct or C++ object.  If so then we
     need to reset the destructor since the Ruby object no 
     longer owns the underlying C++ object.*/ 
  if (flags & SWIG_POINTER_DISOWN) {
    /* Is tracking on for this class? */
    int track = 0;
    if (ty && ty->clientdata) {
      swig_class *sklass = (swig_class *) ty->clientdata;
      track = sklass->trackObjects;
    }
        
    if (track) {
      /* We are tracking objects for this class.  Thus we change the destructor
       * to SWIG_RubyRemoveTracking.  This allows us to
       * remove the mapping from the C++ to Ruby object
       * when the Ruby object is garbage collected.  If we don't
       * do this, then it is possible we will return a reference 
       * to a Ruby object that no longer exists thereby crashing Ruby. */
      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
    } else {    
      RDATA(obj)->dfree = 0;
    }
  }

  /* Do type-checking if type info was provided */
  if (ty) {
    if (ty->clientdata) {
      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
        if (vptr == 0) {
          /* The object has already been deleted */
          return SWIG_ObjectPreviouslyDeletedError;
        }
        *ptr = vptr;
        return SWIG_OK;
      }
    }
    if ((c = SWIG_MangleStr(obj)) == NULL) {
      return SWIG_ERROR;
    }
    tc = SWIG_TypeCheck(c, ty);
    if (!tc) {
      return SWIG_ERROR;
    } else {
      int newmemory = 0;
      *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
      assert(!newmemory); /* newmemory handling not yet implemented */
    }
  } else {
    *ptr = vptr;
  }
  
  return SWIG_OK;
}

/* Check convert */
SWIGRUNTIMEINLINE int
SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
{
  char *c = SWIG_MangleStr(obj);
  if (!c) return 0;
  return SWIG_TypeCheck(c,ty) != 0;
}

SWIGRUNTIME VALUE
SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
  char result[1024];
  char *r = result;
  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r, ptr, sz);
  strcpy(r, type->name);
  return rb_str_new2(result);
}

/* Convert a packed value value */
SWIGRUNTIME int
SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
  swig_cast_info *tc;
  const char  *c;

  if (TYPE(obj) != T_STRING) goto type_error;
  c = StringValuePtr(obj);
  /* Pointer values must start with leading underscore */
  if (*c != '_') goto type_error;
  c++;
  c = SWIG_UnpackData(c, ptr, sz);
  if (ty) {
    tc = SWIG_TypeCheck(c, ty);
    if (!tc) goto type_error;
  }
  return SWIG_OK;

 type_error:
  return SWIG_ERROR;
}

SWIGRUNTIME swig_module_info *
SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
{
  VALUE pointer;
  swig_module_info *ret = 0;
  VALUE verbose = rb_gv_get("VERBOSE");

 /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
  rb_gv_set("VERBOSE", Qfalse);
  
  /* first check if pointer already created */
  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
  if (pointer != Qnil) {
    Data_Get_Struct(pointer, swig_module_info, ret);
  }

  /* reinstate warnings */
  rb_gv_set("VERBOSE", verbose);
  return ret;
}

SWIGRUNTIME void 
SWIG_Ruby_SetModule(swig_module_info *pointer)
{
  /* register a new class */
  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
  /* create and store the structure pointer to a global variable */
  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
}

/* This function can be used to check whether a proc or method or similarly
   callable function has been passed.  Usually used in a %typecheck, like:

   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
        $result = SWIG_Ruby_isCallable( $input );
   }
 */
SWIGINTERN
int SWIG_Ruby_isCallable( VALUE proc )
{
  if ( rb_respond_to( proc, swig_call_id ) )
    return 1;
  return 0;
}

/* This function can be used to check the arity (number of arguments)
   a proc or method can take.  Usually used in a %typecheck.
   Valid arities will be that equal to minimal or those < 0
   which indicate a variable number of parameters at the end.
 */
SWIGINTERN
int SWIG_Ruby_arity( VALUE proc, int minimal )
{
  if ( rb_respond_to( proc, swig_arity_id ) )
    {
      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
      int arity = NUM2INT(num);
      if ( arity < 0 && (arity+1) < -minimal ) return 1;
      if ( arity == minimal ) return 1;
      return 1;
    }
  return 0;
}


#ifdef __cplusplus
}
#endif



#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 

#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 



  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 


/* -------- TYPES TABLE (BEGIN) -------- */

#define SWIGTYPE_p_HWND swig_types[0]
#define SWIGTYPE_p_boost__functionT_int_fbzs__db__protocol__tdap__client__fields_const_RF_t swig_types[1]
#define SWIGTYPE_p_boost__shared_ptrT_bzs__db__protocol__tdap__client__database_t swig_types[2]
#define SWIGTYPE_p_boost__shared_ptrT_bzs__db__protocol__tdap__client__filter_t swig_types[3]
#define SWIGTYPE_p_boost__shared_ptrT_bzs__db__protocol__tdap__client__idatabaseManager_t swig_types[4]
#define SWIGTYPE_p_boost__shared_ptrT_bzs__db__protocol__tdap__client__table_t swig_types[5]
#define SWIGTYPE_p_boost__timer swig_types[6]
#define SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS swig_types[7]
#define SWIGTYPE_p_bzs__db__protocol__tdap__btrDate swig_types[8]
#define SWIGTYPE_p_bzs__db__protocol__tdap__btrDateTime swig_types[9]
#define SWIGTYPE_p_bzs__db__protocol__tdap__btrTime swig_types[10]
#define SWIGTYPE_p_bzs__db__protocol__tdap__btrTimeStamp swig_types[11]
#define SWIGTYPE_p_bzs__db__protocol__tdap__btrVersion swig_types[12]
#define SWIGTYPE_p_bzs__db__protocol__tdap__btrVersions swig_types[13]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable swig_types[14]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__autoMemory swig_types[15]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__avg swig_types[16]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__connectParams swig_types[17]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__count swig_types[18]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__database swig_types[19]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef swig_types[20]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__field swig_types[21]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames swig_types[22]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldShare swig_types[23]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__fielddefs swig_types[24]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__fields swig_types[25]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldsBase swig_types[26]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexFindNavi_t_t swig_types[27]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexNavi_t_t swig_types[28]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexRvFindNavi_t_t swig_types[29]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexRvNavi_t_t swig_types[30]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_stepNavi_t_t swig_types[31]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_stepRvNavi_t_t swig_types[32]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__groupFuncBase swig_types[33]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__groupQuery swig_types[34]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__idatabaseManager swig_types[35]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__max swig_types[36]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__memoryRecord swig_types[37]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__min swig_types[38]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase swig_types[39]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable swig_types[40]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager swig_types[41]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__preparedQuery swig_types[42]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__query swig_types[43]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase swig_types[44]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset swig_types[45]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__recordsetQuery swig_types[46]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__refarymem swig_types[47]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__snapshotT_boost__shared_ptrT_bzs__db__protocol__tdap__client__database_t_t swig_types[48]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__snapshotT_bzs__db__protocol__tdap__client__idatabaseManager_p_t swig_types[49]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__sortFields swig_types[50]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__sum swig_types[51]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__table swig_types[52]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__tableIteratorT_indexFindNavi_t swig_types[53]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__tableIteratorT_indexNavi_t swig_types[54]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__tableIteratorT_indexRvFindNavi_t swig_types[55]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__tableIteratorT_indexRvNavi_t swig_types[56]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__tableIteratorT_stepNavi_t swig_types[57]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__tableIteratorT_stepRvNavi_t swig_types[58]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__transactionT_boost__shared_ptrT_bzs__db__protocol__tdap__client__database_t_t swig_types[59]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__transactionT_boost__shared_ptrT_bzs__db__protocol__tdap__client__idatabaseManager_t_t swig_types[60]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__writableRecord swig_types[61]
#define SWIGTYPE_p_bzs__db__protocol__tdap__fielddef swig_types[62]
#define SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_20_t swig_types[63]
#define SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_64_t swig_types[64]
#define SWIGTYPE_p_bzs__db__protocol__tdap__keySegment swig_types[65]
#define SWIGTYPE_p_bzs__db__protocol__tdap__keydef swig_types[66]
#define SWIGTYPE_p_bzs__db__protocol__tdap__tabledef swig_types[67]
#define SWIGTYPE_p_bzs__rtl__benchmark swig_types[68]
#define SWIGTYPE_p_char swig_types[69]
#define SWIGTYPE_p_f_unsigned_short_p_void_p_void_p_unsigned_int_p_void_unsigned_short_char_p_unsigned_char__short swig_types[70]
#define SWIGTYPE_p_int swig_types[71]
#define SWIGTYPE_p_iterator swig_types[72]
#define SWIGTYPE_p_p_bzs__db__protocol__tdap__client__fields swig_types[73]
#define SWIGTYPE_p_p_bzs__db__protocol__tdap__client__fieldsBase swig_types[74]
#define SWIGTYPE_p_p_bzs__db__protocol__tdap__client__memoryRecord swig_types[75]
#define SWIGTYPE_p_p_bzs__db__protocol__tdap__client__writableRecord swig_types[76]
#define SWIGTYPE_p_p_bzs__db__protocol__tdap__tabledef swig_types[77]
#define SWIGTYPE_p_preparedQuery swig_types[78]
#define SWIGTYPE_p_short swig_types[79]
#define SWIGTYPE_p_std___tstring swig_types[80]
#define SWIGTYPE_p_std__vectorT_bzs__db__protocol__tdap__client__fieldsBase_p_t__iterator swig_types[81]
#define SWIGTYPE_p_trdVersiton swig_types[82]
#define SWIGTYPE_p_unsigned_char swig_types[83]
#define SWIGTYPE_p_unsigned_int swig_types[84]
#define SWIGTYPE_p_unsigned_short swig_types[85]
#define SWIGTYPE_p_value_type swig_types[86]
#define SWIGTYPE_p_void swig_types[87]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__last swig_types[88]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__first swig_types[89]
#define SWIGTYPE_p_bzs__db__protocol__tdap__client__sortField swig_types[90]
#define SWIGTYPE_p_BOOKMARK swig_types[91]
static swig_type_info *swig_types[93];
static swig_module_info swig_module = {swig_types, 92, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)

/* -------- TYPES TABLE (END) -------- */

#define SWIG_init    Init_transactd
#define SWIG_name    "Transactd"

static VALUE mTransactd;

#define SWIG_RUBY_THREAD_BEGIN_BLOCK
#define SWIG_RUBY_THREAD_END_BLOCK


#define SWIGVERSION 0x030002 
#define SWIG_VERSION SWIGVERSION


#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 


#include <stdexcept>


#if defined(__MINGW32__) && defined(__GNUC__)
#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ <= 5)
#define _SYS_TIME_H_
#else
#define _GETTIMEOFDAY_DEFINED
#endif
#endif


#include "ruby/encoding.h"
#undef stat
#include <bzs/env/tstring.h>

rb_encoding* rb_enc_find_from_codepage(int codePage)
{
  if (codePage <= 0 || codePage >= 10000000)
    codePage = GetACP();
  char cpname[10];
  sprintf(cpname, "CP%2d", codePage);
  return rb_enc_find(cpname);
}


#include <build/swig/referencecounter.h>
referenceCounter g_refCounter;
static void mark_activeTable(void* ptr) {
  g_refCounter.mark();
}


#ifdef __cplusplus
extern "C" {
#endif

/* Ruby 1.9 changed the file name of this header */
#ifdef HAVE_RUBY_IO_H
#include "ruby/io.h"
#else
#include "rubyio.h"
#endif

#ifdef __cplusplus
}
#endif


#ifdef __cplusplus
extern "C" {
#endif
#ifdef HAVE_SYS_TIME_H
# include <sys/time.h>
struct timeval rb_time_timeval(VALUE);
#endif
#ifdef __cplusplus
}
#endif


#include <string>


#include <build/swig/validatablepointer.h>
validatablePointerList g_vPtrList;


#include <bzs/env/crosscompile.h>
#include <bzs/env/compiler.h>
#include <bzs/db/protocol/tdap/client/export.h>
#include <bzs/db/protocol/tdap/btrDate.h>
#include <bzs/db/blobStructs.h>
#include <bzs/db/protocol/tdap/mysql/characterset.h>
#include <bzs/db/transactd/connectionRecord.h>

#ifdef LINUX
#include <linux/linuxTypes.h>
#include <linux/charsetConvert.h>
#include <bzs/env/mbcswchrLinux.h>
#endif

#include <bzs/env/tstring.h>
#include <bzs/rtl/benchmark.h>
#include <bzs/rtl/datetime.h>
#include <bzs/rtl/stringBuffers.h>
#include <bzs/rtl/strtrim.h>
#include <bzs/db/protocol/tdap/btrDate.h>
#include <bzs/db/protocol/tdap/myDateTime.cpp>
#include <bzs/db/protocol/tdap/client/sharedData.h>
#include <bzs/db/protocol/tdap/tdapcapi.h>
#include <bzs/db/protocol/tdap/tdapSchema.h>
#include <bzs/db/protocol/tdap/client/nsTable.h>
#include <bzs/db/protocol/tdap/client/connMgr.h>
#include <bzs/db/protocol/tdap/client/bulkInsert.h>
#include <bzs/db/protocol/tdap/client/dbDef.h>
#include <bzs/db/protocol/tdap/client/table.h>
#include <bzs/db/protocol/tdap/client/nsDatabase.h>
#include <bzs/db/protocol/tdap/client/database.h>
#include <bzs/db/protocol/tdap/mysql/characterset.h>
#include <bzs/db/protocol/tdap/client/field.h>
#include <bzs/db/protocol/tdap/client/fields.h>
#include <bzs/db/protocol/tdap/client/memRecord.h>
#include <bzs/db/protocol/tdap/client/recordset.h>
#include <bzs/db/protocol/tdap/client/activeTable.h>
#include <bzs/db/protocol/tdap/client/groupQuery.h>
#include <bzs/db/protocol/tdap/client/pooledDatabaseManager.h>

using namespace bzs::db::protocol::tdap;
using namespace bzs::db::protocol::tdap::client;


#if HAVE_RB_THREAD_CALL_WITHOUT_GVL || HAVE_RB_THREAD_BLOCKING_REGION

#include <build/swig/ruby/threadBlockRegionWrapper.h>

#ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL
    #include <ruby/thread.h>
    #define TRANSACTD_RB_CALL_WITHOUT_GVL( func, arg ) \
        rb_thread_call_without_gvl((void *(*)(void *))func, &arg, RUBY_UBF_IO, NULL)
#else
    // use rb_thread_blocking_region only if rb_thread_call_without_gvl is not defined.
    #define TRANSACTD_RB_CALL_WITHOUT_GVL( func, arg ) \
        rb_thread_blocking_region((rb_blocking_function_t*) func, &arg, RUBY_UBF_IO, NULL)
#endif

BTRCALLID_PTR MYTICALLID_ORIGINAL = NULL;
BTRCALLID_PTR BTRVCALLID_ORIGINAL = NULL;

void MYTICALLID_ArgumentWrapper(BTRCALLIDArgs* args)
{
    args->result = MYTICALLID_ORIGINAL(args->op, args->pbk, args->data,
        args->datalen, args->keybuf, args->keylen, args->keyNum, args->cid);
}

short_td __STDCALL MYTICALLID_WITHOUT_GVL(ushort_td op, void* pbk, void* data,
  uint_td* datalen, void* keybuf, keylen_td keylen, char_td keyNum, uchar_td* cid)
{
    BTRCALLIDArgs args;
    args.op = op;
    args.pbk = pbk;
    args.data = data;
    args.datalen = datalen;
    args.keybuf = keybuf;
    args.keylen = keylen;
    args.keyNum = keyNum;
    args.cid = cid;
    args.result = 0;
    TRANSACTD_RB_CALL_WITHOUT_GVL(MYTICALLID_ArgumentWrapper, args);
    return args.result;
}

void BTRCALLID_ArgumentWrapper(BTRCALLIDArgs* args)
{
    args->result = BTRVCALLID_ORIGINAL(args->op, args->pbk, args->data,
        args->datalen, args->keybuf, args->keylen, args->keyNum, args->cid);
}

short_td __STDCALL BTRVCALLID_WITHOUT_GVL(ushort_td op, void* pbk, void* data,
  uint_td* datalen, void* keybuf, keylen_td keylen, char_td keyNum, uchar_td* cid)
{
    BTRCALLIDArgs args;
    args.op = op;
    args.pbk = pbk;
    args.data = data;
    args.datalen = datalen;
    args.keybuf = keybuf;
    args.keylen = keylen;
    args.keyNum = keyNum;
    args.cid = cid;
    args.result = 0;
    TRANSACTD_RB_CALL_WITHOUT_GVL(BTRCALLID_ArgumentWrapper, args);
    return args.result;
}

#endif // HAVE_RB_THREAD_CALL_WITHOUT_GVL || HAVE_RB_THREAD_BLOCKING_REGION


#include <limits.h>
#if !defined(SWIG_NO_LLONG_MAX)
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
#   define LLONG_MAX __LONG_LONG_MAX__
#   define LLONG_MIN (-LLONG_MAX - 1LL)
#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
# endif
#endif


  #define SWIG_From_long   LONG2NUM 


SWIGINTERNINLINE VALUE
SWIG_From_int  (int value)
{    
  return SWIG_From_long  (value);
}


SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
  static int init = 0;
  static swig_type_info* info = 0;
  if (!init) {
    info = SWIG_TypeQuery("_p_char");
    init = 1;
  }
  return info;
}


SWIGINTERNINLINE VALUE 
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
  if (carray) {
    if (size > LONG_MAX) {
      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
      return pchar_descriptor ? 
    SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : Qnil;
    } else {
      return rb_str_new(carray, static_cast< long >(size));
    }
  } else {
    return Qnil;
  }
}


SWIGINTERNINLINE VALUE 
SWIG_FromCharPtr(const char *cptr)
{ 
  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
}


SWIGINTERN int
SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
{
  if (TYPE(obj) == T_STRING) {
    char *cstr = StringValuePtr(obj); 
    size_t size = RSTRING_LEN(obj) + 1;
    if (cptr)  {
      if (alloc) {
        if (*alloc == SWIG_NEWOBJ) {
           *cptr = reinterpret_cast< char* >(memcpy((new char[size]), cstr, sizeof(char)*(size)));
        } else {
          *cptr = cstr;
          *alloc = SWIG_OLDOBJ;
        } 
      }
    }
    if (psize) *psize = size;
    return SWIG_OK;
  } else {
    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    if (pchar_descriptor) {
      void* vptr = 0;
      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
        if (cptr) *cptr = (char *)vptr;
        if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
        if (alloc) *alloc = SWIG_OLDOBJ;
        return SWIG_OK;
      }
    }
  }  
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsCharArray(VALUE obj, char *val, size_t size)
{ 
  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
  if (SWIG_IsOK(res)) {
    /* special case of single char conversion when we don't need space for NUL */
    if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
    if (csize <= size) {
      if (val) {
    if (csize) memcpy(val, cptr, csize*sizeof(char));
    if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
      }
      if (alloc == SWIG_NEWOBJ) {
    delete[] cptr;
    res = SWIG_DelNewMask(res);
      }      
      return res;
    }
    if (alloc == SWIG_NEWOBJ) delete[] cptr;
  }
  return SWIG_TypeError;
}


size_t
SWIG_strnlen(const char* s, size_t maxlen)
{
  const char *p;
  for (p = s; maxlen-- && *p; p++)
    ;
  return p - s;
}


SWIGINTERN VALUE
SWIG_ruby_failed(void)
{
  return Qnil;
} 


/*@SWIG:/usr/local/share/swig/3.0.2/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
{
  VALUE obj = args[0];
  VALUE type = TYPE(obj);
  unsigned long *res = (unsigned long *)(args[1]);
  *res = type == T_FIXNUM ? NUM2ULONG(obj) : rb_big2ulong(obj);
  return obj;
}
/*@SWIG@*/

SWIGINTERN int
SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val) 
{
  VALUE type = TYPE(obj);
  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
    unsigned long v;
    VALUE a[2];
    a[0] = obj;
    a[1] = (VALUE)(&v);
    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
      if (val) *val = v;
      return SWIG_OK;
    }
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_short (VALUE obj, unsigned short *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > USHRT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned short >(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE VALUE
SWIG_From_unsigned_SS_long  (unsigned long value)
{
  return ULONG2NUM(value); 
}


SWIGINTERNINLINE VALUE
SWIG_From_unsigned_SS_short  (unsigned short value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_char (VALUE obj, unsigned char *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UCHAR_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned char >(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE VALUE
SWIG_From_unsigned_SS_char  (unsigned char value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}


/*@SWIG:/usr/local/share/swig/3.0.2/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
{
  VALUE obj = args[0];
  VALUE type = TYPE(obj);
  long *res = (long *)(args[1]);
  *res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj);
  return obj;
}
/*@SWIG@*/

SWIGINTERN int
SWIG_AsVal_long (VALUE obj, long* val)
{
  VALUE type = TYPE(obj);
  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
    long v;
    VALUE a[2];
    a[0] = obj;
    a[1] = (VALUE)(&v);
    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
      if (val) *val = v;
      return SWIG_OK;
    }
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_int (VALUE obj, int *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < INT_MIN || v > INT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< int >(v);
    }
  }  
  return res;
}

SWIGINTERN bzs::db::protocol::tdap::keySegment *bzs_db_protocol_tdap_keydef_segment(bzs::db::protocol::tdap::keydef *self,int const index){
    return &(self->segments[index]);
  }

SWIGINTERN int
SWIG_AsVal_short (VALUE obj, short *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < SHRT_MIN || v > SHRT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< short >(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE VALUE
SWIG_From_bool  (bool value)
{
  return value ? Qtrue : Qfalse;
}


/*@SWIG:/usr/local/share/swig/3.0.2/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE *args)
{
  VALUE obj = args[0];
  VALUE type = TYPE(obj);
  double *res = (double *)(args[1]);
  *res = NUM2DBL(obj); (void)type;
  return obj;
}
/*@SWIG@*/

SWIGINTERN int
SWIG_AsVal_double (VALUE obj, double *val)
{
  VALUE type = TYPE(obj);
  if ((type == T_FLOAT) || (type == T_FIXNUM) || (type == T_BIGNUM)) {
    double v;
    VALUE a[2];
    a[0] = obj;
    a[1] = (VALUE)(&v);
    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2DBL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
      if (val) *val = v;
      return SWIG_OK;
    }
  }
  return SWIG_TypeError;
}


  #define SWIG_From_double   rb_float_new 





SWIGINTERNINLINE VALUE
SWIG_From_unsigned_SS_int  (unsigned int value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}

SWIGINTERN char const *bzs_db_protocol_tdap_fielddef_name(bzs::db::protocol::tdap::fielddef const *self){
     return self->name();
  }

SWIGINTERNINLINE VALUE
SWIG_From_short  (short value)
{    
  return SWIG_From_long  (value);
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_int (VALUE obj, unsigned int *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UINT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned int >(v);
    }
  }  
  return res;
}

SWIGINTERN bzs::db::protocol::tdap::fielddef *bzs_db_protocol_tdap_tabledef_fieldDef(bzs::db::protocol::tdap::tabledef *self,int const index){
    return &(self->fieldDefs[index]);
  }
SWIGINTERN bzs::db::protocol::tdap::keydef *bzs_db_protocol_tdap_tabledef_keyDef(bzs::db::protocol::tdap::tabledef *self,int const index){
    return &(self->keyDefs[index]);
  }
SWIGINTERN bzs::db::protocol::tdap::btrVersion *bzs_db_protocol_tdap_btrVersions_version(bzs::db::protocol::tdap::btrVersions *self,int const index){
    return &(self->versions[index]);
  }

SWIGINTERNINLINE VALUE
SWIG_From_char  (char c) 
{ 
  return SWIG_FromCharPtrAndSize(&c,1);
}


SWIGINTERN int
SWIG_AsVal_char (VALUE obj, char *val)
{    
  int res = SWIG_AsCharArray(obj, val, 1);
  if (!SWIG_IsOK(res)) {
    long v;
    res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
    if (SWIG_IsOK(res)) {
      if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
    if (val) *val = static_cast< char >(v);
      } else {
    res = SWIG_OverflowError;
      }
    }
  }
  return res;
}


SWIGINTERN int
SWIG_AsVal_bool (VALUE obj, bool *val)
{
  if (obj == Qtrue) {
    if (val) *val = true;
    return SWIG_OK;
  } else if (obj == Qfalse) {
    if (val) *val = false;
    return SWIG_OK;
  } else {
    int res = 0;
    if (SWIG_AsVal_int (obj, &res) == SWIG_OK) {    
      if (val) *val = res ? true : false;
      return SWIG_OK;
    }
  }  
  return SWIG_TypeError;
}


SWIGINTERNINLINE VALUE 
SWIG_From_long_SS_long  (long long value)
{
  return LL2NUM(value);
}


SWIGINTERNINLINE VALUE
SWIG_From_float  (float value)
{    
  return SWIG_From_double  (value);
}


#include <float.h>


#include <math.h>


/* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
#ifndef SWIG_isfinite
# if defined(isfinite)
#  define SWIG_isfinite(X) (isfinite(X))
# elif defined(_MSC_VER)
#  define SWIG_isfinite(X) (_finite(X))
# elif defined(__sun) && defined(__SVR4)
#  include <ieeefp.h>
#  define SWIG_isfinite(X) (finite(X))
# endif
#endif


/* Accept infinite as a valid float value unless we are unable to check if a value is finite */
#ifdef SWIG_isfinite
# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X))
#else
# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX))
#endif


SWIGINTERN int
SWIG_AsVal_float (VALUE obj, float *val)
{
  double v;
  int res = SWIG_AsVal_double (obj, &v);
  if (SWIG_IsOK(res)) {
    if (SWIG_Float_Overflow_Check(v)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< float >(v);
    }
  }  
  return res;
}


/*@SWIG:/usr/local/share/swig/3.0.2/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
SWIGINTERN VALUE SWIG_AUX_NUM2LL(VALUE *args)
{
  VALUE obj = args[0];
  VALUE type = TYPE(obj);
  long long *res = (long long *)(args[1]);
  *res = type == T_FIXNUM ? NUM2LL(obj) : rb_big2ll(obj);
  return obj;
}
/*@SWIG@*/

SWIGINTERN int
SWIG_AsVal_long_SS_long (VALUE obj, long long *val)
{
  VALUE type = TYPE(obj);
  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
    long long v;
    VALUE a[2];
    a[0] = obj;
    a[1] = (VALUE)(&v);
    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
      if (val) *val = v;
      return SWIG_OK;
    }
  }
  return SWIG_TypeError;
}
SWIGINTERN void *bzs_db_protocol_tdap_client_table_getFVbin__SWIG_0(bzs::db::protocol::tdap::client::table *self,short index,uint_td &table_getFVbin_size){
    return self->getFVbin(index, table_getFVbin_size);
  }
SWIGINTERN void *bzs_db_protocol_tdap_client_table_getFVbin__SWIG_1(bzs::db::protocol::tdap::client::table *self,_TCHAR const *fieldName,uint_td &table_getFVbin_size){
    return self->getFVbin(fieldName, table_getFVbin_size);
  }
SWIGINTERN _TCHAR const *bzs_db_protocol_tdap_client_table_keyValueDescription(bzs::db::protocol::tdap::client::table *self,_TCHAR *keyValueDescription_buf){
    self->keyValueDescription(keyValueDescription_buf, 1024 * 8);
    return keyValueDescription_buf;
  }
SWIGINTERN preparedQuery *bzs_db_protocol_tdap_client_table_prepare__SWIG_0(bzs::db::protocol::tdap::client::table *self,bzs::db::protocol::tdap::client::queryBase const *q,bool serverPrepare=false){
    preparedQuery* p = new preparedQuery(self->setQuery(q, serverPrepare));
    return p;
  }
SWIGINTERN preparedQuery *bzs_db_protocol_tdap_client_table_setQuery__SWIG_0(bzs::db::protocol::tdap::client::table *self,bzs::db::protocol::tdap::client::queryBase const *q,bool serverPrepare=false){
    preparedQuery* p = new preparedQuery(self->setQuery(q, serverPrepare));
    return p;
  }
SWIGINTERN void bzs_db_protocol_tdap_client_table_setPrepare(bzs::db::protocol::tdap::client::table *self,preparedQuery *q){
    self->setPrepare(q->getFilter());
  }
SWIGINTERN void bzs_db_protocol_tdap_client_table_release(bzs::db::protocol::tdap::client::table *self){
    if (bzs::db::protocol::tdap::client::nsdatabase::testTablePtr(self))
      self->release();
  }

SWIGINTERNINLINE int
SWIG_AsVal_size_t (VALUE obj, size_t *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
  if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
  return res;
}

SWIGINTERN bzs::db::protocol::tdap::client::query *new_bzs_db_protocol_tdap_client_query(){
    return bzs::db::protocol::tdap::client::query::create();
  }
SWIGINTERN bzs::db::protocol::tdap::client::database *new_bzs_db_protocol_tdap_client_database(){
    bzs::db::protocol::tdap::client::nsdatabase::setExecCodePage(CP_UTF8);
    return bzs::db::protocol::tdap::client::database::create();
  }
SWIGINTERN bzs::db::protocol::tdap::client::table *bzs_db_protocol_tdap_client_database_openTable__SWIG_0(bzs::db::protocol::tdap::client::database *self,_TCHAR const *tableName,short mode=0,bool autoCreate=true,_TCHAR const *ownerName=NULL,_TCHAR const *uri=NULL){
    bzs::db::protocol::tdap::client::table* tb =
      self->openTable(tableName, mode, autoCreate, ownerName, uri);
    g_vPtrList.add(tb);
    return tb;
  }
SWIGINTERN bzs::db::protocol::tdap::client::table *bzs_db_protocol_tdap_client_database_openTable__SWIG_5(bzs::db::protocol::tdap::client::database *self,short fileNum,short mode=TD_OPEN_NORMAL,bool autoCreate=true,_TCHAR const *ownerName=NULL,_TCHAR const *uri=NULL){
    bzs::db::protocol::tdap::client::table* tb =
      self->openTable(fileNum, mode, autoCreate, ownerName, uri);
    g_vPtrList.add(tb);
    return tb;
  }

/*@SWIG:/usr/local/share/swig/3.0.2/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
SWIGINTERN VALUE SWIG_AUX_NUM2ULL(VALUE *args)
{
  VALUE obj = args[0];
  VALUE type = TYPE(obj);
  long long *res = (long long *)(args[1]);
  *res = type == T_FIXNUM ? NUM2ULL(obj) : rb_big2ull(obj);
  return obj;
}
/*@SWIG@*/

SWIGINTERN int
SWIG_AsVal_unsigned_SS_long_SS_long (VALUE obj, unsigned long long *val)
{ 
  VALUE type = TYPE(obj);
  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
    unsigned long long v;
    VALUE a[2];
    a[0] = obj;
    a[1] = (VALUE)(&v);
    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
      if (val) *val = v;
      return SWIG_OK;
    }
  }
  return SWIG_TypeError;
}


SWIGINTERNINLINE VALUE 
SWIG_From_unsigned_SS_long_SS_long  (unsigned long long value)
{
  return ULL2NUM(value);
}


SWIGINTERNINLINE VALUE
SWIG_From_size_t  (size_t value)
{    
  return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
}

SWIGINTERN bzs::db::protocol::tdap::client::fielddefs *new_bzs_db_protocol_tdap_client_fielddefs(){
    return bzs::db::protocol::tdap::client::fielddefs::create();
  }
SWIGINTERN void bzs_db_protocol_tdap_client_fieldsBase___getitem____SWIG_0(bzs::db::protocol::tdap::client::fieldsBase const *self,short fieldsBase_getitem_index){
  }
SWIGINTERN void bzs_db_protocol_tdap_client_fieldsBase___getitem____SWIG_1(bzs::db::protocol::tdap::client::fieldsBase const *self,_TCHAR const *fieldsBase_getitem_index){
  }
SWIGINTERN void bzs_db_protocol_tdap_client_fieldsBase_getFieldByIndexRef(bzs::db::protocol::tdap::client::fieldsBase const *self,short index,bzs::db::protocol::tdap::client::field &return_field){
    return_field = self->operator[](index);
  }
SWIGINTERN void bzs_db_protocol_tdap_client_fieldsBase_getFieldByNameRef(bzs::db::protocol::tdap::client::fieldsBase const *self,_TCHAR const *name,bzs::db::protocol::tdap::client::field &return_field){
    return_field = self->operator[](name);
  }
SWIGINTERN bzs::db::protocol::tdap::client::memoryRecord *new_bzs_db_protocol_tdap_client_memoryRecord(bzs::db::protocol::tdap::client::fielddefs &fds){
    return bzs::db::protocol::tdap::client::memoryRecord::create(fds);
  }
SWIGINTERN bzs::db::protocol::tdap::client::fieldNames *new_bzs_db_protocol_tdap_client_fieldNames(){
    return bzs::db::protocol::tdap::client::fieldNames::create();
  }
SWIGINTERN bzs::db::protocol::tdap::client::recordsetQuery *new_bzs_db_protocol_tdap_client_recordsetQuery(){
    return bzs::db::protocol::tdap::client::recordsetQuery::create();
  }
SWIGINTERN bzs::db::protocol::tdap::client::groupQuery *new_bzs_db_protocol_tdap_client_groupQuery(){
    return bzs::db::protocol::tdap::client::groupQuery::create();
  }
SWIGINTERN bzs::db::protocol::tdap::client::sum *new_bzs_db_protocol_tdap_client_sum__SWIG_0(bzs::db::protocol::tdap::client::fieldNames const &targetNames,_TCHAR const *resultName=NULL){
    return bzs::db::protocol::tdap::client::sum::create(targetNames, resultName);
  }
SWIGINTERN bzs::db::protocol::tdap::client::count *new_bzs_db_protocol_tdap_client_count(_TCHAR const *resultName){
    return bzs::db::protocol::tdap::client::count::create(resultName);
  }
SWIGINTERN bzs::db::protocol::tdap::client::avg *new_bzs_db_protocol_tdap_client_avg__SWIG_0(bzs::db::protocol::tdap::client::fieldNames const &targetNames,_TCHAR const *resultName=NULL){
    return bzs::db::protocol::tdap::client::avg::create(targetNames, resultName);
  }
SWIGINTERN bzs::db::protocol::tdap::client::min *new_bzs_db_protocol_tdap_client_min__SWIG_0(bzs::db::protocol::tdap::client::fieldNames const &targetNames,_TCHAR const *resultName=NULL){
    return bzs::db::protocol::tdap::client::min::create(targetNames, resultName);
  }
SWIGINTERN bzs::db::protocol::tdap::client::max *new_bzs_db_protocol_tdap_client_max__SWIG_0(bzs::db::protocol::tdap::client::fieldNames const &targetNames,_TCHAR const *resultName=NULL){
    return bzs::db::protocol::tdap::client::max::create(targetNames, resultName);
  }
SWIGINTERN bzs::db::protocol::tdap::client::last *new_bzs_db_protocol_tdap_client_last__SWIG_0(bzs::db::protocol::tdap::client::fieldNames const &targetNames,_TCHAR const *resultName=NULL){
    return bzs::db::protocol::tdap::client::last::create(targetNames, resultName);
  }
SWIGINTERN bzs::db::protocol::tdap::client::first *new_bzs_db_protocol_tdap_client_first__SWIG_0(bzs::db::protocol::tdap::client::fieldNames const &targetNames,_TCHAR const *resultName=NULL){
    return bzs::db::protocol::tdap::client::first::create(targetNames, resultName);
  }
SWIGINTERN void bzs_db_protocol_tdap_client_recordset_getRow(bzs::db::protocol::tdap::client::recordset *self,size_t index,bzs::db::protocol::tdap::client::fieldsBase **return_record){
    *return_record = &(self->operator[](index));
  }
SWIGINTERN bzs::db::protocol::tdap::client::recordset *new_bzs_db_protocol_tdap_client_recordset(){
    return bzs::db::protocol::tdap::client::recordset::create();
  }
SWIGINTERN bzs::db::protocol::tdap::client::activeTable *new_bzs_db_protocol_tdap_client_activeTable__SWIG_0(bzs::db::protocol::tdap::client::idatabaseManager *mgr,_TCHAR const *tableName){
    bzs::db::protocol::tdap::client::activeTable* p =
      bzs::db::protocol::tdap::client::activeTable::create(mgr, tableName);
    g_refCounter.add(p, mgr);
    g_vPtrList.add(p->table().get());
    return p;
  }
SWIGINTERN bzs::db::protocol::tdap::client::activeTable *new_bzs_db_protocol_tdap_client_activeTable__SWIG_1(bzs::db::protocol::tdap::client::database *db,_TCHAR const *tableName, short mode){
    bzs::db::protocol::tdap::client::activeTable* p =
      bzs::db::protocol::tdap::client::activeTable::create(db, tableName, mode);
    g_refCounter.add(p, db);
    g_vPtrList.add(p->table().get());
    return p;
  }
SWIGINTERN bzs::db::protocol::tdap::client::preparedQuery *bzs_db_protocol_tdap_client_activeTable_prepare__SWIG_0(bzs::db::protocol::tdap::client::activeTable *self,bzs::db::protocol::tdap::client::queryBase &q,bool serverPrepare=false){
    preparedQuery* p = new preparedQuery(self->prepare(q, serverPrepare));
    return p;
  }
SWIGINTERN void bzs_db_protocol_tdap_client_activeTable_release(bzs::db::protocol::tdap::client::activeTable *self){
    self->releaseTable();
  }
SWIGINTERN bzs::db::protocol::tdap::client::table *bzs_db_protocol_tdap_client_activeTable_table(bzs::db::protocol::tdap::client::activeTable *self){
    return self->table().get();
  }
SWIGINTERN bzs::db::protocol::tdap::client::table *bzs_db_protocol_tdap_client_pooledDbManager_table(bzs::db::protocol::tdap::client::pooledDbManager *self,_TCHAR const *name){
    return self->table(name).get();
  }
static swig_class SwigClassBOOKMARK;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BOOKMARK_allocate(VALUE self) {
#else
SWIGINTERN VALUE
_wrap_BOOKMARK_allocate(int argc, VALUE *argv, VALUE self) {
#endif


    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_BOOKMARK);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
}


SWIGINTERN VALUE
_wrap_new_BOOKMARK(int argc, VALUE *argv, VALUE self) {
    BOOKMARK *result = 0;

    if ((argc < 0) || (argc > 0)) {
        rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)", argc); SWIG_fail;
    }
    {
        try {
            result = (BOOKMARK *)new BOOKMARK();
            DATA_PTR(self) = result;
        }
        catch (bzs::rtl::exception& e) {
            static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
            rb_raise(bzs_rtl_error, (*bzs::rtl::getMsg(e)).c_str());
        }
        catch (std::exception &e) {
            static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
            rb_raise(cpp_std_error, e.what());
        }
    }
    return self;
fail:
    return Qnil;
}


SWIGINTERN VALUE
_wrap_BOOKMARK_isEmpty(int argc, VALUE *argv, VALUE self) {
    BOOKMARK *arg1 = (BOOKMARK *)0;
    void *argp1 = 0;
    int res1 = 0;
    bool result;
    VALUE vresult = Qnil;

    if ((argc < 0) || (argc > 0)) {
        rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)", argc); SWIG_fail;
    }
    res1 = SWIG_ConvertPtr(self, &argp1, SWIGTYPE_p_BOOKMARK, 0 | 0);
    if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError("", "BOOKMARK *", "isEmpty", 1, self));
    }
    arg1 = reinterpret_cast< BOOKMARK * >(argp1);
    {
        try {
            result = (bool)(arg1)->isEmpty();
        }
        catch (bzs::rtl::exception& e) {
            static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
            rb_raise(bzs_rtl_error, (*bzs::rtl::getMsg(e)).c_str());
        }
        catch (std::exception &e) {
            static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
            rb_raise(cpp_std_error, e.what());
        }
    }
    vresult = SWIG_From_bool(static_cast< bool >(result));
    return vresult;
fail:
    return Qnil;
}


SWIGINTERN void
free_BOOKMARK(BOOKMARK *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_canRecoverNetError(int argc, VALUE *argv, VALUE self) {
    short arg1;
    short val1;
    int ecode1 = 0;
    bool result;
    VALUE vresult = Qnil;

    if ((argc < 1) || (argc > 1)) {
        rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)", argc); SWIG_fail;
    }
    ecode1 = SWIG_AsVal_short(argv[0], &val1);
    if (!SWIG_IsOK(ecode1)) {
        SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError("", "short", "canRecoverNetError", 1, argv[0]));
    }
    arg1 = static_cast< short >(val1);
    {
        try {
            result = (bool)canRecoverNetError(arg1);
        }
        catch (bzs::rtl::exception& e) {
            static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
            rb_raise(bzs_rtl_error, (*bzs::rtl::getMsg(e)).c_str());
        }
        catch (std::exception &e) {
            static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
            rb_raise(cpp_std_error, e.what());
        }
    }
    vresult = SWIG_From_bool(static_cast< bool >(result));
    return vresult;
fail:
    return Qnil;
}


static swig_class SwigClassFLAGS;

SWIGINTERN VALUE
_wrap_FLAGS_all_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","all", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","all", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  if (arg1) (arg1)->all = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_all_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","all", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  result = (unsigned short) ((arg1)->all);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bit0_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bit0", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","bit0", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  if (arg1) (arg1)->bit0 = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bit0_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bit0", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  result = (unsigned short) ((arg1)->bit0);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bit1_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bit1", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","bit1", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  if (arg1) (arg1)->bit1 = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bit1_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bit1", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  result = (unsigned short) ((arg1)->bit1);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bit2_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bit2", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","bit2", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  if (arg1) (arg1)->bit2 = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bit2_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bit2", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  result = (unsigned short) ((arg1)->bit2);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bit3_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bit3", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","bit3", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  if (arg1) (arg1)->bit3 = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bit3_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bit3", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  result = (unsigned short) ((arg1)->bit3);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bit4_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bit4", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","bit4", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  if (arg1) (arg1)->bit4 = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bit4_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bit4", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  result = (unsigned short) ((arg1)->bit4);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bit5_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bit5", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","bit5", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  if (arg1) (arg1)->bit5 = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bit5_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bit5", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  result = (unsigned short) ((arg1)->bit5);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bit6_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bit6", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","bit6", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  if (arg1) (arg1)->bit6 = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bit6_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bit6", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  result = (unsigned short) ((arg1)->bit6);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bit7_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bit7", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","bit7", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  if (arg1) (arg1)->bit7 = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bit7_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bit7", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  result = (unsigned short) ((arg1)->bit7);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bit8_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bit8", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","bit8", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  if (arg1) (arg1)->bit8 = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bit8_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bit8", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  result = (unsigned short) ((arg1)->bit8);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bit9_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bit9", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","bit9", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  if (arg1) (arg1)->bit9 = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bit9_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bit9", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  result = (unsigned short) ((arg1)->bit9);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bitA_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bitA", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","bitA", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  if (arg1) (arg1)->bitA = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bitA_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bitA", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  result = (unsigned short) ((arg1)->bitA);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bitB_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bitB", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","bitB", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  if (arg1) (arg1)->bitB = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bitB_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bitB", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  result = (unsigned short) ((arg1)->bitB);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bitC_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bitC", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","bitC", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  if (arg1) (arg1)->bitC = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bitC_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bitC", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  result = (unsigned short) ((arg1)->bitC);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bitD_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bitD", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","bitD", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  if (arg1) (arg1)->bitD = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bitD_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bitD", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  result = (unsigned short) ((arg1)->bitD);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bitE_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bitE", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","bitE", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  if (arg1) (arg1)->bitE = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bitE_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bitE", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  result = (unsigned short) ((arg1)->bitE);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bitF_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bitF", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","bitF", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  if (arg1) (arg1)->bitF = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FLAGS_bitF_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *arg1 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","bitF", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp1);
  result = (unsigned short) ((arg1)->bitF);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_FLAGS_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_FLAGS_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_FLAGS(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::FLAGS *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::FLAGS *)new bzs::db::protocol::tdap::FLAGS();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_bzs_db_protocol_tdap_FLAGS(bzs::db::protocol::tdap::FLAGS *arg1) {
    delete arg1;
}

static swig_class SwigClassKeySegment;

SWIGINTERN VALUE
_wrap_keySegment_fieldNum_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::keySegment *arg1 = (bzs::db::protocol::tdap::keySegment *) 0 ;
  uchar_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__keySegment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::keySegment *","fieldNum", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::keySegment * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uchar_td","fieldNum", 2, argv[0] ));
  } 
  arg2 = static_cast< uchar_td >(val2);
  if (arg1) (arg1)->fieldNum = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_keySegment_fieldNum_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::keySegment *arg1 = (bzs::db::protocol::tdap::keySegment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__keySegment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::keySegment *","fieldNum", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::keySegment * >(argp1);
  result = (uchar_td) ((arg1)->fieldNum);
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_keySegment_flags_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::keySegment *arg1 = (bzs::db::protocol::tdap::keySegment *) 0 ;
  bzs::db::protocol::tdap::FLAGS *arg2 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__keySegment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::keySegment *","flags", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::keySegment * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","flags", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp2);
  if (arg1) (arg1)->flags = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_keySegment_flags_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::keySegment *arg1 = (bzs::db::protocol::tdap::keySegment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::FLAGS *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__keySegment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::keySegment *","flags", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::keySegment * >(argp1);
  result = (bzs::db::protocol::tdap::FLAGS *)& ((arg1)->flags);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_keySegment_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_keySegment_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__keySegment);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_keySegment(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::keySegment *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::keySegment *)new bzs::db::protocol::tdap::keySegment();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_bzs_db_protocol_tdap_keySegment(bzs::db::protocol::tdap::keySegment *arg1) {
    delete arg1;
}

static swig_class SwigClassKeydef;

SWIGINTERN VALUE
_wrap_keydef_segmentCount_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::keydef *arg1 = (bzs::db::protocol::tdap::keydef *) 0 ;
  uchar_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__keydef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::keydef *","segmentCount", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::keydef * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uchar_td","segmentCount", 2, argv[0] ));
  } 
  arg2 = static_cast< uchar_td >(val2);
  if (arg1) (arg1)->segmentCount = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_keydef_segmentCount_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::keydef *arg1 = (bzs::db::protocol::tdap::keydef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__keydef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::keydef *","segmentCount", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::keydef * >(argp1);
  result = (uchar_td) ((arg1)->segmentCount);
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_keydef_segments_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::keydef *arg1 = (bzs::db::protocol::tdap::keydef *) 0 ;
  bzs::db::protocol::tdap::keySegment *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__keydef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::keydef *","segments", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::keydef * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__keySegment, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::keySegment [8]","segments", 2, argv[0] )); 
  } 
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::keySegment * >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)8; ++ii) *(bzs::db::protocol::tdap::keySegment *)&arg1->segments[ii] = *((bzs::db::protocol::tdap::keySegment *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""segments""' of type '""bzs::db::protocol::tdap::keySegment [8]""'");
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_keydef_segments_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::keydef *arg1 = (bzs::db::protocol::tdap::keydef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::keySegment *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__keydef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::keydef *","segments", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::keydef * >(argp1);
  result = (bzs::db::protocol::tdap::keySegment *)(bzs::db::protocol::tdap::keySegment *) ((arg1)->segments);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__keySegment, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_keydef_keyNumber_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::keydef *arg1 = (bzs::db::protocol::tdap::keydef *) 0 ;
  uchar_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__keydef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::keydef *","keyNumber", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::keydef * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uchar_td","keyNumber", 2, argv[0] ));
  } 
  arg2 = static_cast< uchar_td >(val2);
  if (arg1) (arg1)->keyNumber = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_keydef_keyNumber_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::keydef *arg1 = (bzs::db::protocol::tdap::keydef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__keydef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::keydef *","keyNumber", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::keydef * >(argp1);
  result = (uchar_td) ((arg1)->keyNumber);
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_keydef_segment(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::keydef *arg1 = (bzs::db::protocol::tdap::keydef *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bzs::db::protocol::tdap::keySegment *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__keydef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::keydef *","segment", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::keydef * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","segment", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (bzs::db::protocol::tdap::keySegment *)bzs_db_protocol_tdap_keydef_segment(arg1,arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__keySegment, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_keydef_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_keydef_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__keydef);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_keydef(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::keydef *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::keydef *)new bzs::db::protocol::tdap::keydef();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_bzs_db_protocol_tdap_keydef(bzs::db::protocol::tdap::keydef *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_MYSQL_FDNAME_SIZE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::MYSQL_FDNAME_SIZE));
  return _val;
}


SWIGINTERN VALUE
_wrap_MYSQL_TBNAME_SIZE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::MYSQL_TBNAME_SIZE));
  return _val;
}


SWIGINTERN VALUE
_wrap_PERVASIVE_FDNAME_SIZE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::PERVASIVE_FDNAME_SIZE));
  return _val;
}


SWIGINTERN VALUE
_wrap_FIELD_NAME_SIZE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::FIELD_NAME_SIZE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TABLE_NAME_SIZE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::TABLE_NAME_SIZE));
  return _val;
}


SWIGINTERN VALUE
_wrap_FILE_NAME_SIZE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::FILE_NAME_SIZE));
  return _val;
}


SWIGINTERN VALUE
_wrap_TABLEDEF_FILLER_SIZE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::TABLEDEF_FILLER_SIZE));
  return _val;
}


SWIGINTERN VALUE
_wrap_getTypeName(int argc, VALUE *argv, VALUE self) {
  short arg1 ;
  short val1 ;
  int ecode1 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_short(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "short","bzs::db::protocol::tdap::getTypeName", 1, argv[0] ));
  } 
  arg1 = static_cast< short >(val1);
  {
    try {
      result = (_TCHAR *)bzs::db::protocol::tdap::getTypeName(arg1);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_getTypeAlign(int argc, VALUE *argv, VALUE self) {
  short arg1 ;
  short val1 ;
  int ecode1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_short(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "short","bzs::db::protocol::tdap::getTypeAlign", 1, argv[0] ));
  } 
  arg1 = static_cast< short >(val1);
  {
    try {
      result = (int)bzs::db::protocol::tdap::getTypeAlign(arg1);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_lenByCharnum(int argc, VALUE *argv, VALUE self) {
  uchar_td arg1 ;
  uchar_td arg2 ;
  ushort_td arg3 ;
  unsigned char val1 ;
  int ecode1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  ushort_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_char(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "uchar_td","bzs::db::protocol::tdap::lenByCharnum", 1, argv[0] ));
  } 
  arg1 = static_cast< uchar_td >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uchar_td","bzs::db::protocol::tdap::lenByCharnum", 2, argv[1] ));
  } 
  arg2 = static_cast< uchar_td >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "ushort_td","bzs::db::protocol::tdap::lenByCharnum", 3, argv[2] ));
  } 
  arg3 = static_cast< ushort_td >(val3);
  {
    try {
      result = (ushort_td)bzs::db::protocol::tdap::lenByCharnum(arg1,arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_isStringType(int argc, VALUE *argv, VALUE self) {
  uchar_td arg1 ;
  unsigned char val1 ;
  int ecode1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_char(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "uchar_td","bzs::db::protocol::tdap::isStringType", 1, argv[0] ));
  } 
  arg1 = static_cast< uchar_td >(val1);
  {
    try {
      result = (bool)bzs::db::protocol::tdap::isStringType(arg1);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


static swig_class SwigClassFielddef_t_my;

SWIGINTERN VALUE
_wrap_fielddef_t_my_type_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef_t< 64 > *arg1 = (bzs::db::protocol::tdap::fielddef_t< 64 > *) 0 ;
  uchar_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_64_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef_t< 64 > *","type", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef_t< 64 > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uchar_td","type", 2, argv[0] ));
  } 
  arg2 = static_cast< uchar_td >(val2);
  if (arg1) (arg1)->type = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_t_my_type_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef_t< 64 > *arg1 = (bzs::db::protocol::tdap::fielddef_t< 64 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_64_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef_t< 64 > *","type", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef_t< 64 > * >(argp1);
  result = (uchar_td) ((arg1)->type);
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_t_my_len_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef_t< 64 > *arg1 = (bzs::db::protocol::tdap::fielddef_t< 64 > *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_64_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef_t< 64 > *","len", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef_t< 64 > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","len", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  if (arg1) (arg1)->len = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_t_my_len_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef_t< 64 > *arg1 = (bzs::db::protocol::tdap::fielddef_t< 64 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ushort_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_64_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef_t< 64 > *","len", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef_t< 64 > * >(argp1);
  result = (ushort_td) ((arg1)->len);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_t_my_decimals_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef_t< 64 > *arg1 = (bzs::db::protocol::tdap::fielddef_t< 64 > *) 0 ;
  uchar_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_64_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef_t< 64 > *","decimals", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef_t< 64 > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uchar_td","decimals", 2, argv[0] ));
  } 
  arg2 = static_cast< uchar_td >(val2);
  if (arg1) (arg1)->decimals = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_t_my_decimals_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef_t< 64 > *arg1 = (bzs::db::protocol::tdap::fielddef_t< 64 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_64_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef_t< 64 > *","decimals", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef_t< 64 > * >(argp1);
  result = (uchar_td) ((arg1)->decimals);
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_t_my_max_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef_t< 64 > *arg1 = (bzs::db::protocol::tdap::fielddef_t< 64 > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_64_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef_t< 64 > *","max", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef_t< 64 > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","max", 2, argv[0] ));
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->max = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_t_my_max_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef_t< 64 > *arg1 = (bzs::db::protocol::tdap::fielddef_t< 64 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_64_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef_t< 64 > *","max", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef_t< 64 > * >(argp1);
  result = (double) ((arg1)->max);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_t_my_min_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef_t< 64 > *arg1 = (bzs::db::protocol::tdap::fielddef_t< 64 > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_64_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef_t< 64 > *","min", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef_t< 64 > * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","min", 2, argv[0] ));
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->min = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_t_my_min_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef_t< 64 > *arg1 = (bzs::db::protocol::tdap::fielddef_t< 64 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_64_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef_t< 64 > *","min", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef_t< 64 > * >(argp1);
  result = (double) ((arg1)->min);
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_t_my_pos_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef_t< 64 > *arg1 = (bzs::db::protocol::tdap::fielddef_t< 64 > *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_64_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef_t< 64 > *","pos", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef_t< 64 > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","pos", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  if (arg1) (arg1)->pos = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_t_my_pos_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef_t< 64 > *arg1 = (bzs::db::protocol::tdap::fielddef_t< 64 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ushort_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_64_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef_t< 64 > *","pos", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef_t< 64 > * >(argp1);
  result = (ushort_td) ((arg1)->pos);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_t_my_ddfid_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef_t< 64 > *arg1 = (bzs::db::protocol::tdap::fielddef_t< 64 > *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_64_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef_t< 64 > *","ddfid", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef_t< 64 > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","ddfid", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  if (arg1) (arg1)->ddfid = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_t_my_ddfid_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef_t< 64 > *arg1 = (bzs::db::protocol::tdap::fielddef_t< 64 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ushort_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_64_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef_t< 64 > *","ddfid", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef_t< 64 > * >(argp1);
  result = (ushort_td) ((arg1)->ddfid);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_t_my_nullValue_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef_t< 64 > *arg1 = (bzs::db::protocol::tdap::fielddef_t< 64 > *) 0 ;
  uchar_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_64_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef_t< 64 > *","nullValue", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef_t< 64 > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uchar_td","nullValue", 2, argv[0] ));
  } 
  arg2 = static_cast< uchar_td >(val2);
  if (arg1) (arg1)->nullValue = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_t_my_nullValue_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef_t< 64 > *arg1 = (bzs::db::protocol::tdap::fielddef_t< 64 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_64_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef_t< 64 > *","nullValue", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef_t< 64 > * >(argp1);
  result = (uchar_td) ((arg1)->nullValue);
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_t_my_keylen_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef_t< 64 > *arg1 = (bzs::db::protocol::tdap::fielddef_t< 64 > *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_64_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef_t< 64 > *","keylen", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef_t< 64 > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","keylen", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  if (arg1) (arg1)->keylen = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_t_my_keylen_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef_t< 64 > *arg1 = (bzs::db::protocol::tdap::fielddef_t< 64 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ushort_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_64_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef_t< 64 > *","keylen", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef_t< 64 > * >(argp1);
  result = (ushort_td) ((arg1)->keylen);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_fielddef_t_my_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_fielddef_t_my_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_64_t);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_fielddef_t_my(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef_t< 64 > *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::fielddef_t< 64 > *)new bzs::db::protocol::tdap::fielddef_t< 64 >();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_bzs_db_protocol_tdap_fielddef_t_Sl_64_Sg_(bzs::db::protocol::tdap::fielddef_t< 64 > *arg1) {
    delete arg1;
}

static swig_class SwigClassFielddef;

SWIGINTERN VALUE
_wrap_fielddef_setName(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef *arg1 = (bzs::db::protocol::tdap::fielddef *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef *","setName", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","setName", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setName((char const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_typeName(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef *arg1 = (bzs::db::protocol::tdap::fielddef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef const *","typeName", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef * >(argp1);
  {
    try {
      result = (_TCHAR *)((bzs::db::protocol::tdap::fielddef const *)arg1)->typeName();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_align(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef *arg1 = (bzs::db::protocol::tdap::fielddef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef const *","align", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef * >(argp1);
  {
    try {
      result = (int)((bzs::db::protocol::tdap::fielddef const *)arg1)->align();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_setLenByCharnum(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef *arg1 = (bzs::db::protocol::tdap::fielddef *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef *","setLenByCharnum", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","setLenByCharnum", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  {
    try {
      (arg1)->setLenByCharnum(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_codePage(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef *arg1 = (bzs::db::protocol::tdap::fielddef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef const *","codePage", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef * >(argp1);
  {
    try {
      result = (unsigned int)((bzs::db::protocol::tdap::fielddef const *)arg1)->codePage();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_varLenBytes(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef *arg1 = (bzs::db::protocol::tdap::fielddef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef const *","varLenBytes", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef * >(argp1);
  {
    try {
      result = (int)((bzs::db::protocol::tdap::fielddef const *)arg1)->varLenBytes();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_blobLenBytes(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef *arg1 = (bzs::db::protocol::tdap::fielddef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef const *","blobLenBytes", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef * >(argp1);
  {
    try {
      result = (uint_td)((bzs::db::protocol::tdap::fielddef const *)arg1)->blobLenBytes();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_isStringType(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef *arg1 = (bzs::db::protocol::tdap::fielddef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef const *","isStringType", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef * >(argp1);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::fielddef const *)arg1)->isStringType();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_isNumericType(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef *arg1 = (bzs::db::protocol::tdap::fielddef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef const *","isNumericType", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef * >(argp1);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::fielddef const *)arg1)->isNumericType();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_charNum(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef *arg1 = (bzs::db::protocol::tdap::fielddef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef const *","charNum", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef * >(argp1);
  {
    try {
      result = (unsigned int)((bzs::db::protocol::tdap::fielddef const *)arg1)->charNum();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_setCharsetIndex(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef *arg1 = (bzs::db::protocol::tdap::fielddef *) 0 ;
  uchar_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef *","setCharsetIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uchar_td","setCharsetIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< uchar_td >(val2);
  {
    try {
      (arg1)->setCharsetIndex(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_charsetIndex(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef *arg1 = (bzs::db::protocol::tdap::fielddef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef const *","charsetIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef * >(argp1);
  {
    try {
      result = (uchar_td)((bzs::db::protocol::tdap::fielddef const *)arg1)->charsetIndex();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_name(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef *arg1 = (bzs::db::protocol::tdap::fielddef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef const *","name", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef * >(argp1);
  {
    try {
      result = (char *)bzs_db_protocol_tdap_fielddef_name((bzs::db::protocol::tdap::fielddef const *)arg1);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_trimPadChar(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef const *","trimPadChar", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef * >(argp1);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::fielddef const *)arg1)->trimPadChar();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_usePadChar(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef *arg1 = (bzs::db::protocol::tdap::fielddef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef const *","usePadChar", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef * >(argp1);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::fielddef const *)arg1)->usePadChar();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddef_setPadCharSettings(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef *","setUsePadChar", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::fielddef * >(argp1);
  
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setPadCharSettings", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setPadCharSettings", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  
  {
    try {
      (arg1)->setPadCharSettings(arg2, arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_fielddef_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_fielddef_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__fielddef);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_fielddef(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::fielddef *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::fielddef *)new bzs::db::protocol::tdap::fielddef();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_bzs_db_protocol_tdap_fielddef(bzs::db::protocol::tdap::fielddef *arg1) {
    delete arg1;
}

static swig_class SwigClassTabledef;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_tabledef_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_tabledef_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__tabledef);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_tabledef(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::tabledef *)new bzs::db::protocol::tdap::tabledef();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_cleanup(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","cleanup", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  {
    try {
      (arg1)->cleanup();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_fileName(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef const *","fileName", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  {
    try {
      result = (char *)((bzs::db::protocol::tdap::tabledef const *)arg1)->fileName();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_tableName(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef const *","tableName", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  {
    try {
      result = (char *)((bzs::db::protocol::tdap::tabledef const *)arg1)->tableName();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_setFileName(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","setFileName", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","setFileName", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setFileName((char const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_setTableName(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","setTableName", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","setTableName", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->setTableName((char const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_toChar(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if (argc != 1) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","toChar", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","toChar", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  
  arg4 = strlen(arg2) * 2;
  arg3 = new char[arg4];
  
  {
    try {
      result = (char *)(arg1)->toChar(arg3,(char const *)arg2,arg4);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  delete [] arg3;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  delete [] arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_id_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","id", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","id", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  if (arg1) (arg1)->id = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_id_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ushort_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","id", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  result = (ushort_td) ((arg1)->id);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_pageSize_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","pageSize", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","pageSize", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  if (arg1) (arg1)->pageSize = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_pageSize_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ushort_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","pageSize", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  result = (ushort_td) ((arg1)->pageSize);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_varSize_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","varSize", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","varSize", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  if (arg1) (arg1)->varSize = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_varSize_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ushort_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","varSize", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  result = (ushort_td) ((arg1)->varSize);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_preAlloc_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","preAlloc", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","preAlloc", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  if (arg1) (arg1)->preAlloc = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_preAlloc_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ushort_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","preAlloc", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  result = (ushort_td) ((arg1)->preAlloc);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_fieldCount_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","fieldCount", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","fieldCount", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  if (arg1) (arg1)->fieldCount = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_fieldCount_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ushort_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","fieldCount", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  result = (ushort_td) ((arg1)->fieldCount);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_keyCount_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  uchar_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","keyCount", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uchar_td","keyCount", 2, argv[0] ));
  } 
  arg2 = static_cast< uchar_td >(val2);
  if (arg1) (arg1)->keyCount = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_keyCount_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","keyCount", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  result = (uchar_td) ((arg1)->keyCount);
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_version_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","version", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","version", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  if (arg1) (arg1)->version = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_version_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","version", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  result = (short) ((arg1)->version);
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_charsetIndex_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  uchar_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","charsetIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uchar_td","charsetIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< uchar_td >(val2);
  if (arg1) (arg1)->charsetIndex = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_charsetIndex_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","charsetIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  result = (uchar_td) ((arg1)->charsetIndex);
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_flags_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  bzs::db::protocol::tdap::FLAGS *arg2 = (bzs::db::protocol::tdap::FLAGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","flags", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::FLAGS *","flags", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::FLAGS * >(argp2);
  if (arg1) (arg1)->flags = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_flags_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::FLAGS *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","flags", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  result = (bzs::db::protocol::tdap::FLAGS *)& ((arg1)->flags);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_primaryKeyNum_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  uchar_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","primaryKeyNum", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uchar_td","primaryKeyNum", 2, argv[0] ));
  } 
  arg2 = static_cast< uchar_td >(val2);
  if (arg1) (arg1)->primaryKeyNum = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_primaryKeyNum_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","primaryKeyNum", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  result = (uchar_td) ((arg1)->primaryKeyNum);
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_maxRecordLen_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","maxRecordLen", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","maxRecordLen", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  if (arg1) (arg1)->maxRecordLen = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_maxRecordLen_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ushort_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","maxRecordLen", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  result = (ushort_td) ((arg1)->maxRecordLen);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_ddfid_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","ddfid", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","ddfid", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  if (arg1) (arg1)->ddfid = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_ddfid_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ushort_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","ddfid", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  result = (ushort_td) ((arg1)->ddfid);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_fixedRecordLen_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","fixedRecordLen", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","fixedRecordLen", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  if (arg1) (arg1)->fixedRecordLen = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_fixedRecordLen_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ushort_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","fixedRecordLen", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  result = (ushort_td) ((arg1)->fixedRecordLen);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_schemaCodePage_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  uint_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","schemaCodePage", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint_td","schemaCodePage", 2, argv[0] ));
  } 
  arg2 = static_cast< uint_td >(val2);
  if (arg1) (arg1)->schemaCodePage = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_schemaCodePage_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","schemaCodePage", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  result = (uint_td) ((arg1)->schemaCodePage);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_parent_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  bzs::db::protocol::tdap::client::dbdef *arg2 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","parent", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef *","parent", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp2);
  if (arg1) (arg1)->parent = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_parent_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::dbdef *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","parent", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  result = (bzs::db::protocol::tdap::client::dbdef *) ((arg1)->parent);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_fieldDefs_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  bzs::db::protocol::tdap::fielddef *arg2 = (bzs::db::protocol::tdap::fielddef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","fieldDefs", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef *","fieldDefs", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::fielddef * >(argp2);
  if (arg1) (arg1)->fieldDefs = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_fieldDefs_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::fielddef *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","fieldDefs", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  result = (bzs::db::protocol::tdap::fielddef *) ((arg1)->fieldDefs);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_keyDefs_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  bzs::db::protocol::tdap::keydef *arg2 = (bzs::db::protocol::tdap::keydef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","keyDefs", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__keydef, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::keydef *","keyDefs", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::keydef * >(argp2);
  if (arg1) (arg1)->keyDefs = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_keyDefs_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::keydef *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","keyDefs", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  result = (bzs::db::protocol::tdap::keydef *) ((arg1)->keyDefs);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__keydef, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_fieldDef(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bzs::db::protocol::tdap::fielddef *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","fieldDef", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","fieldDef", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (bzs::db::protocol::tdap::fielddef *)bzs_db_protocol_tdap_tabledef_fieldDef(arg1,arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_tabledef_keyDef(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::tabledef *arg1 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bzs::db::protocol::tdap::keydef *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","keyDef", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","keyDef", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (bzs::db::protocol::tdap::keydef *)bzs_db_protocol_tdap_tabledef_keyDef(arg1,arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__keydef, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_bzs_db_protocol_tdap_tabledef(bzs::db::protocol::tdap::tabledef *arg1) {
    delete arg1;
}

static swig_class SwigClassBtrVersion;

SWIGINTERN VALUE
_wrap_btrVersion_majorVersion_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrVersion *arg1 = (bzs::db::protocol::tdap::btrVersion *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrVersion *","majorVersion", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrVersion * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","majorVersion", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  if (arg1) (arg1)->majorVersion = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrVersion_majorVersion_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrVersion *arg1 = (bzs::db::protocol::tdap::btrVersion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ushort_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrVersion *","majorVersion", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrVersion * >(argp1);
  result = (ushort_td) ((arg1)->majorVersion);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrVersion_minorVersion_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrVersion *arg1 = (bzs::db::protocol::tdap::btrVersion *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrVersion *","minorVersion", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrVersion * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","minorVersion", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  if (arg1) (arg1)->minorVersion = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrVersion_minorVersion_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrVersion *arg1 = (bzs::db::protocol::tdap::btrVersion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ushort_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrVersion *","minorVersion", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrVersion * >(argp1);
  result = (ushort_td) ((arg1)->minorVersion);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrVersion_type_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrVersion *arg1 = (bzs::db::protocol::tdap::btrVersion *) 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrVersion *","type", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrVersion * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned char","type", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned char >(val2);
  if (arg1) (arg1)->type = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrVersion_type_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrVersion *arg1 = (bzs::db::protocol::tdap::btrVersion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrVersion *","type", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrVersion * >(argp1);
  result = (unsigned char) ((arg1)->type);
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrVersion_moduleVersionShortString(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrVersion *arg1 = (bzs::db::protocol::tdap::btrVersion *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrVersion *","moduleVersionShortString", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrVersion * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR *","moduleVersionShortString", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (_TCHAR *)(arg1)->moduleVersionShortString(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrVersion_moduleTypeString(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrVersion *arg1 = (bzs::db::protocol::tdap::btrVersion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrVersion *","moduleTypeString", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrVersion * >(argp1);
  {
    try {
      result = (_TCHAR *)(arg1)->moduleTypeString();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_btrVersion_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_btrVersion_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__btrVersion);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_btrVersion(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrVersion *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::btrVersion *)new bzs::db::protocol::tdap::btrVersion();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_bzs_db_protocol_tdap_btrVersion(bzs::db::protocol::tdap::btrVersion *arg1) {
    delete arg1;
}

static swig_class SwigClassBtrVersions;

SWIGINTERN VALUE
_wrap_btrVersions_versions_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrVersions *arg1 = (bzs::db::protocol::tdap::btrVersions *) 0 ;
  bzs::db::protocol::tdap::btrVersion *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrVersions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrVersions *","versions", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrVersions * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__btrVersion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrVersion [4]","versions", 2, argv[0] )); 
  } 
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::btrVersion * >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)4; ++ii) *(bzs::db::protocol::tdap::btrVersion *)&arg1->versions[ii] = *((bzs::db::protocol::tdap::btrVersion *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""versions""' of type '""bzs::db::protocol::tdap::btrVersion [4]""'");
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrVersions_versions_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrVersions *arg1 = (bzs::db::protocol::tdap::btrVersions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::btrVersion *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrVersions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrVersions *","versions", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrVersions * >(argp1);
  result = (bzs::db::protocol::tdap::btrVersion *)(bzs::db::protocol::tdap::btrVersion *) ((arg1)->versions);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__btrVersion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrVersions_version(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrVersions *arg1 = (bzs::db::protocol::tdap::btrVersions *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bzs::db::protocol::tdap::btrVersion *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrVersions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrVersions *","version", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrVersions * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","version", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (bzs::db::protocol::tdap::btrVersion *)bzs_db_protocol_tdap_btrVersions_version(arg1,arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__btrVersion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_btrVersions_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_btrVersions_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__btrVersions);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_btrVersions(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrVersions *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::btrVersions *)new bzs::db::protocol::tdap::btrVersions();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_bzs_db_protocol_tdap_btrVersions(bzs::db::protocol::tdap::btrVersions *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_getFilterLogicTypeCode(int argc, VALUE *argv, VALUE self) {
  _TCHAR *arg1 = (_TCHAR *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  uchar_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_TCHAR const *","bzs::db::protocol::tdap::getFilterLogicTypeCode", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< _TCHAR * >(buf1);
  {
    try {
      result = (uchar_td)bzs::db::protocol::tdap::getFilterLogicTypeCode((char const *)arg1);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return Qnil;
}


static swig_class SwigClassNstable;

SWIGINTERN VALUE
_wrap_nstable_nsdb(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::nsdatabase *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable const *","nsdb", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::nsdatabase *)((bzs::db::protocol::tdap::client::nstable const *)arg1)->nsdb();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_tableid(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable const *","tableid", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      result = (short)((bzs::db::protocol::tdap::client::nstable const *)arg1)->tableid();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_setTableid(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","setTableid", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","setTableid", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      (arg1)->setTableid(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_isOpen(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable const *","isOpen", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::client::nstable const *)arg1)->isOpen();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_isUseTransactd(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable const *","isUseTransactd", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::client::nstable const *)arg1)->isUseTransactd();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_setAccessRights(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","setAccessRights", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned char","setAccessRights", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned char >(val2);
  {
    try {
      (arg1)->setAccessRights(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_datalen(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable const *","datalen", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      result = (uint_td)((bzs::db::protocol::tdap::client::nstable const *)arg1)->datalen();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_stat(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable const *","stat", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      result = (short_td)((bzs::db::protocol::tdap::client::nstable const *)arg1)->stat();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_keyNum(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable const *","keyNum", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      result = (char_td)((bzs::db::protocol::tdap::client::nstable const *)arg1)->keyNum();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_setKeyNum(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  char_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","setKeyNum", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char_td","setKeyNum", 2, argv[0] ));
  } 
  arg2 = static_cast< char_td >(val2);
  {
    try {
      (arg1)->setKeyNum(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_canRead(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable const *","canRead", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::client::nstable const *)arg1)->canRead();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_canWrite(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable const *","canWrite", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::client::nstable const *)arg1)->canWrite();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_canInsert(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable const *","canInsert", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::client::nstable const *)arg1)->canInsert();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_canDelete(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable const *","canDelete", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::client::nstable const *)arg1)->canDelete();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_getWriteImageLen(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","getWriteImageLen", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      result = (uint_td)(arg1)->getWriteImageLen();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_close(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","close", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      (arg1)->close();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_update__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  bzs::db::protocol::tdap::client::nstable::eUpdateType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","update", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable::eUpdateType","update", 2, argv[0] ));
  } 
  arg2 = static_cast< bzs::db::protocol::tdap::client::nstable::eUpdateType >(val2);
  {
    try {
      (arg1)->update(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_update__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","update", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      (arg1)->update();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_nstable_update(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_nstable_update__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_nstable_update__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "nstable.update", 
    "    void nstable.update(bzs::db::protocol::tdap::client::nstable::eUpdateType type)\n"
    "    void nstable.update()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_del__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","del", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","del", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->del(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_del__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","del", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      (arg1)->del();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_nstable_del(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_nstable_del__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_nstable_del__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "nstable.del", 
    "    void nstable.del(bool in_key)\n"
    "    void nstable.del()\n");
  
  return Qnil;
}



/*
  Document-method: Transactd::nstable.insert

  call-seq:
    insert(ncc=False) -> ushort_td
    insert -> ushort_td

Insert one or more new elements in the nstable.
*/
SWIGINTERN VALUE
_wrap_nstable_insert__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  ushort_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","insert", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","insert", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (ushort_td)(arg1)->insert(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_insert__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ushort_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","insert", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      result = (ushort_td)(arg1)->insert();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_nstable_insert(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_nstable_insert__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_nstable_insert__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "nstable.insert", 
    "    ushort_td nstable.insert(bool ncc)\n"
    "    ushort_td nstable.insert()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_createIndex__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","createIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","createIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->createIndex(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_createIndex__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","createIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      (arg1)->createIndex();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_nstable_createIndex(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_nstable_createIndex__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_nstable_createIndex__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "nstable.createIndex", 
    "    void nstable.createIndex(bool specifyKeyNum)\n"
    "    void nstable.createIndex()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_dropIndex__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","dropIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","dropIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->dropIndex(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_dropIndex__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","dropIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      (arg1)->dropIndex();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_nstable_dropIndex(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_nstable_dropIndex__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_nstable_dropIndex__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "nstable.dropIndex", 
    "    void nstable.dropIndex(bool norenumber)\n"
    "    void nstable.dropIndex()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_recordCount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  uint_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","recordCount", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","recordCount", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","recordCount", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (uint_td)(arg1)->recordCount(arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_recordCount__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  uint_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","recordCount", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","recordCount", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (uint_td)(arg1)->recordCount(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_recordCount__SWIG_2(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","recordCount", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      result = (uint_td)(arg1)->recordCount();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_nstable_recordCount(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_nstable_recordCount__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_nstable_recordCount__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_nstable_recordCount__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "nstable.recordCount", 
    "    uint_td nstable.recordCount(bool estimate, bool fromCurrent)\n"
    "    uint_td nstable.recordCount(bool estimate)\n"
    "    uint_td nstable.recordCount()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_beginBulkInsert(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","beginBulkInsert", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","beginBulkInsert", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->beginBulkInsert(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_abortBulkInsert(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","abortBulkInsert", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      (arg1)->abortBulkInsert();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_commitBulkInsert__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  ushort_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","commitBulkInsert", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","commitBulkInsert", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (ushort_td)(arg1)->commitBulkInsert(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_commitBulkInsert__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ushort_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","commitBulkInsert", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      result = (ushort_td)(arg1)->commitBulkInsert();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_nstable_commitBulkInsert(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_nstable_commitBulkInsert__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_nstable_commitBulkInsert__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "nstable.commitBulkInsert", 
    "    ushort_td nstable.commitBulkInsert(bool autoCommit)\n"
    "    ushort_td nstable.commitBulkInsert()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_seekFirst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","seekFirst", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","seekFirst", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  {
    try {
      (arg1)->seekFirst(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_seekFirst__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","seekFirst", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      (arg1)->seekFirst();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_nstable_seekFirst(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_nstable_seekFirst__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_nstable_seekFirst__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "nstable.seekFirst", 
    "    void nstable.seekFirst(ushort_td lockBias)\n"
    "    void nstable.seekFirst()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_seekLast__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","seekLast", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","seekLast", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  {
    try {
      (arg1)->seekLast(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_seekLast__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","seekLast", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      (arg1)->seekLast();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_nstable_seekLast(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_nstable_seekLast__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_nstable_seekLast__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "nstable.seekLast", 
    "    void nstable.seekLast(ushort_td lockBias)\n"
    "    void nstable.seekLast()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_seekPrev__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","seekPrev", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","seekPrev", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  {
    try {
      (arg1)->seekPrev(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_seekPrev__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","seekPrev", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      (arg1)->seekPrev();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_nstable_seekPrev(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_nstable_seekPrev__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_nstable_seekPrev__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "nstable.seekPrev", 
    "    void nstable.seekPrev(ushort_td lockBias)\n"
    "    void nstable.seekPrev()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_seekNext__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","seekNext", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","seekNext", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  {
    try {
      (arg1)->seekNext(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_seekNext__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","seekNext", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      (arg1)->seekNext();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_nstable_seekNext(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_nstable_seekNext__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_nstable_seekNext__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "nstable.seekNext", 
    "    void nstable.seekNext(ushort_td lockBias)\n"
    "    void nstable.seekNext()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_seek__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","seek", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","seek", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  {
    try {
      (arg1)->seek(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_seek__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","seek", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      (arg1)->seek();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_nstable_seek(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_nstable_seek__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_nstable_seek__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "nstable.seek", 
    "    void nstable.seek(ushort_td lockBias)\n"
    "    void nstable.seek()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_seekGreater(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  bool arg2 ;
  ushort_td arg3 = LOCK_BIAS_DEFAULT;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1 or 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","seekGreater", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","seekGreater", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (argc == 2) {
    ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "ushort_td","seekGreater", 3, argv[1] ));
    } 
    arg3 = static_cast< ushort_td >(val3);
  }
  {
    try {
      (arg1)->seekGreater(arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "nstable.seekGreater", 
    "    void nstable.seekGreater(bool orEqual, ushort_td lockBias)\n"
    "    void nstable.seekGreater(bool orEqual)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_seekLessThan(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  bool arg2 ;
  ushort_td arg3 = LOCK_BIAS_DEFAULT;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 1) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1 or 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","seekLessThan", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","seekLessThan", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (argc == 2) {
    ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "ushort_td","seekLessThan", 3, argv[1] ));
    } 
    arg3 = static_cast< ushort_td >(val3);
  }
  {
    try {
      (arg1)->seekLessThan(arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "nstable.seekLessThan", 
    "    void nstable.seekLessThan(bool orEqual, ushort_td lockBias)\n"
    "    void nstable.seekLessThan(bool orEqual)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_stepFirst__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","stepFirst", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","stepFirst", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  {
    try {
      (arg1)->stepFirst(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_stepFirst__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","stepFirst", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      (arg1)->stepFirst();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_nstable_stepFirst(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_nstable_stepFirst__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_nstable_stepFirst__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "nstable.stepFirst", 
    "    void nstable.stepFirst(ushort_td lockBias)\n"
    "    void nstable.stepFirst()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_stepLast__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","stepLast", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","stepLast", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  {
    try {
      (arg1)->stepLast(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_stepLast__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","stepLast", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      (arg1)->stepLast();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_nstable_stepLast(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_nstable_stepLast__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_nstable_stepLast__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "nstable.stepLast", 
    "    void nstable.stepLast(ushort_td lockBias)\n"
    "    void nstable.stepLast()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_stepPrev__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","stepPrev", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","stepPrev", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  {
    try {
      (arg1)->stepPrev(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_stepPrev__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","stepPrev", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      (arg1)->stepPrev();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_nstable_stepPrev(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_nstable_stepPrev__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_nstable_stepPrev__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "nstable.stepPrev", 
    "    void nstable.stepPrev(ushort_td lockBias)\n"
    "    void nstable.stepPrev()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_stepNext__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  ushort_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","stepNext", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ushort_td","stepNext", 2, argv[0] ));
  } 
  arg2 = static_cast< ushort_td >(val2);
  {
    try {
      (arg1)->stepNext(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_stepNext__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","stepNext", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      (arg1)->stepNext();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_nstable_stepNext(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_nstable_stepNext__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_nstable_stepNext__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "nstable.stepNext", 
    "    void nstable.stepNext(ushort_td lockBias)\n"
    "    void nstable.stepNext()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_bookmarkLen(int argc, VALUE *argv, VALUE self) {
    bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0;
    void *argp1 = 0;
    int res1 = 0;
    ushort_td result;
    VALUE vresult = Qnil;

    if ((argc < 0) || (argc > 0)) {
        rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)", argc); SWIG_fail;
    }
    res1 = SWIG_ConvertPtr(self, &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 | 0);
    if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError("", "bzs::db::protocol::tdap::client::nstable const *", "bookmarkLen", 1, self));
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
    {
        try {
            result = (ushort_td)((bzs::db::protocol::tdap::client::nstable const *)arg1)->bookmarkLen();
        }
        catch (bzs::rtl::exception& e) {
            static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
            rb_raise(bzs_rtl_error, (*bzs::rtl::getMsg(e)).c_str());
        }
        catch (std::exception &e) {
            static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
            rb_raise(cpp_std_error, e.what());
        }
    }
    vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
    return vresult;
fail:
    return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_bookmark(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bookmark_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","bookmark", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      result = (bookmark_td)(arg1)->bookmark();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj((new bookmark_td(static_cast< const bookmark_td& >(result))), SWIGTYPE_p_BOOKMARK, SWIG_POINTER_OWN | 0);
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_seekByBookmark__SWIG_2(int argc, VALUE *argv, VALUE self) {
    bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0;
    bookmark_td *arg2 = 0;
    ushort_td arg3;
    void *argp1 = 0;
    int res1 = 0;
    void *argp2 = 0;
    int res2 = 0;
    unsigned short val3;
    int ecode3 = 0;

    if ((argc < 2) || (argc > 2)) {
        rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)", argc); SWIG_fail;
    }
    res1 = SWIG_ConvertPtr(self, &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 | 0);
    if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError("", "bzs::db::protocol::tdap::client::nstable *", "seekByBookmark", 1, self));
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_BOOKMARK, 0);
    if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError("", "bookmark_td &", "seekByBookmark", 2, argv[0]));
    }
    if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bookmark_td &", "seekByBookmark", 2, argv[0]));
    }
    arg2 = reinterpret_cast< bookmark_td * >(argp2);
    ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
    if (!SWIG_IsOK(ecode3)) {
        SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError("", "ushort_td", "seekByBookmark", 3, argv[1]));
    }
    arg3 = static_cast< ushort_td >(val3);
    {
        try {
            (arg1)->seekByBookmark(*arg2, arg3);
        }
        catch (bzs::rtl::exception& e) {
            static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
            rb_raise(bzs_rtl_error, (*bzs::rtl::getMsg(e)).c_str());
        }
        catch (std::exception &e) {
            static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
            rb_raise(cpp_std_error, e.what());
        }
    }
    return Qnil;
fail:
    return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_seekByBookmark__SWIG_3(int argc, VALUE *argv, VALUE self) {
    bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0;
    bookmark_td *arg2 = 0;
    void *argp1 = 0;
    int res1 = 0;
    void *argp2 = 0;
    int res2 = 0;

    if ((argc < 1) || (argc > 1)) {
        rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)", argc); SWIG_fail;
    }
    res1 = SWIG_ConvertPtr(self, &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 | 0);
    if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError("", "bzs::db::protocol::tdap::client::nstable *", "seekByBookmark", 1, self));
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_BOOKMARK, 0);
    if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError("", "bookmark_td &", "seekByBookmark", 2, argv[0]));
    }
    if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bookmark_td &", "seekByBookmark", 2, argv[0]));
    }
    arg2 = reinterpret_cast< bookmark_td * >(argp2);
    {
        try {
            (arg1)->seekByBookmark(*arg2);
        }
        catch (bzs::rtl::exception& e) {
            static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
            rb_raise(bzs_rtl_error, (*bzs::rtl::getMsg(e)).c_str());
        }
        catch (std::exception &e) {
            static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
            rb_raise(cpp_std_error, e.what());
        }
    }
    return Qnil;
fail:
    return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_seekByBookmark__SWIG_4(int argc, VALUE *argv, VALUE self) {
    bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0;
    void *argp1 = 0;
    int res1 = 0;

    if ((argc < 0) || (argc > 0)) {
        rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)", argc); SWIG_fail;
    }
    res1 = SWIG_ConvertPtr(self, &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 | 0);
    if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError("", "bzs::db::protocol::tdap::client::nstable *", "seekByBookmark", 1, self));
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
    {
        try {
            (arg1)->seekByBookmark();
        }
        catch (bzs::rtl::exception& e) {
            static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
            rb_raise(bzs_rtl_error, (*bzs::rtl::getMsg(e)).c_str());
        }
        catch (std::exception &e) {
            static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
            rb_raise(cpp_std_error, e.what());
        }
    }
    return Qnil;
fail:
    return Qnil;
}


SWIGINTERN VALUE _wrap_nstable_seekByBookmark(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;

    argc = nargs + 1;
    argv[0] = self;
    if (argc > 4) SWIG_fail;
    for (ii = 1; (ii < argc); ++ii) {
        argv[ii] = args[ii - 1];
    }
    if (argc == 1) {
        int _v;
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
            return _wrap_nstable_seekByBookmark__SWIG_4(nargs, args, self);
        }
    }
    if (argc == 2) {
        int _v;
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_BOOKMARK, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
                return _wrap_nstable_seekByBookmark__SWIG_3(nargs, args, self);
            }
        }
    }
    if (argc == 3) {
        int _v;
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_BOOKMARK, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
                {
                    int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
                    _v = SWIG_CheckState(res);
                }
                if (_v) {
                    return _wrap_nstable_seekByBookmark__SWIG_2(nargs, args, self);
                }
            }
        }
    }

fail:
    Ruby_Format_OverloadedError(argc, 4, "nstable.seekByBookmark",
        "    void nstable.seekByBookmark(bookmark_td &bm, ushort_td lockBias)\n"
        "    void nstable.seekByBookmark(bookmark_td &bm)\n"
        "    void nstable.seekByBookmark()\n");

    return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_getPercentage__SWIG_0(int argc, VALUE *argv, VALUE self) {
    bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0;
    void *argp1 = 0;
    int res1 = 0;
    percentage_td result;
    VALUE vresult = Qnil;

    if ((argc < 0) || (argc > 0)) {
        rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)", argc); SWIG_fail;
    }
    res1 = SWIG_ConvertPtr(self, &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 | 0);
    if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError("", "bzs::db::protocol::tdap::client::nstable *", "getPercentage", 1, self));
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
    {
        try {
            result = (percentage_td)(arg1)->getPercentage();
        }
        catch (bzs::rtl::exception& e) {
            static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
            rb_raise(bzs_rtl_error, (*bzs::rtl::getMsg(e)).c_str());
        }
        catch (std::exception &e) {
            static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
            rb_raise(cpp_std_error, e.what());
        }
    }
    vresult = SWIG_From_int(static_cast< int >(result));
    return vresult;
fail:
    return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_getPercentage__SWIG_1(int argc, VALUE *argv, VALUE self) {
    bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0;
    bookmark_td *arg2 = 0;
    void *argp1 = 0;
    int res1 = 0;
    void *argp2 = 0;
    int res2 = 0;
    percentage_td result;
    VALUE vresult = Qnil;

    if ((argc < 1) || (argc > 1)) {
        rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)", argc); SWIG_fail;
    }
    res1 = SWIG_ConvertPtr(self, &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 | 0);
    if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError("", "bzs::db::protocol::tdap::client::nstable *", "getPercentage", 1, self));
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_BOOKMARK, 0);
    if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError("", "bookmark_td &", "getPercentage", 2, argv[0]));
    }
    if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bookmark_td &", "getPercentage", 2, argv[0]));
    }
    arg2 = reinterpret_cast< bookmark_td * >(argp2);
    {
        try {
            result = (percentage_td)(arg1)->getPercentage(*arg2);
        }
        catch (bzs::rtl::exception& e) {
            static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
            rb_raise(bzs_rtl_error, (*bzs::rtl::getMsg(e)).c_str());
        }
        catch (std::exception &e) {
            static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
            rb_raise(cpp_std_error, e.what());
        }
    }
    vresult = SWIG_From_int(static_cast< int >(result));
    return vresult;
fail:
    return Qnil;
}


SWIGINTERN VALUE _wrap_nstable_getPercentage(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[3];
    int ii;

    argc = nargs + 1;
    argv[0] = self;
    if (argc > 3) SWIG_fail;
    for (ii = 1; (ii < argc); ++ii) {
        argv[ii] = args[ii - 1];
    }
    if (argc == 1) {
        int _v;
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
            return _wrap_nstable_getPercentage__SWIG_0(nargs, args, self);
        }
    }
    if (argc == 2) {
        int _v;
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_BOOKMARK, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
                return _wrap_nstable_getPercentage__SWIG_1(nargs, args, self);
            }
        }
    }

fail:
    Ruby_Format_OverloadedError(argc, 3, "nstable.getPercentage",
        "    percentage_td nstable.getPercentage()\n"
        "    percentage_td nstable.getPercentage(bookmark_td &bm)\n");

    return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_seekByPercentage__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","seekByPercentage", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      (arg1)->seekByPercentage();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_seekByPercentage__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  percentage_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","seekByPercentage", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "percentage_td","seekByPercentage", 2, argv[0] ));
  } 
  arg2 = static_cast< percentage_td >(val2);
  {
    try {
      (arg1)->seekByPercentage(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_nstable_seekByPercentage(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_nstable_seekByPercentage__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_nstable_seekByPercentage__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "nstable.seekByPercentage", 
    "    void nstable.seekByPercentage()\n"
    "    void nstable.seekByPercentage(percentage_td pc)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_setOwnerName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  char_td arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","setOwnerName", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","setOwnerName", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  ecode3 = SWIG_AsVal_char(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "char_td","setOwnerName", 3, argv[1] ));
  } 
  arg3 = static_cast< char_td >(val3);
  {
    try {
      (arg1)->setOwnerName((_TCHAR const *)arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_setOwnerName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","setOwnerName", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","setOwnerName", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      (arg1)->setOwnerName((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_nstable_setOwnerName(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_nstable_setOwnerName__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_nstable_setOwnerName__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "nstable.setOwnerName", 
    "    void nstable.setOwnerName(_TCHAR const *name, char_td enctype)\n"
    "    void nstable.setOwnerName(_TCHAR const *name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_clearOwnerName(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","clearOwnerName", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      (arg1)->clearOwnerName();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_recordLength(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ushort_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","recordLength", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      result = (ushort_td)(arg1)->recordLength();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_stats__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *arg2 = (void *) 0 ;
  uint_td arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","stats", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","stats", 2, argv[0] )); 
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "uint_td","stats", 3, argv[1] ));
  } 
  arg3 = static_cast< uint_td >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","stats", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      (arg1)->stats(arg2,arg3,arg4);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_stats__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *arg2 = (void *) 0 ;
  uint_td arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","stats", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","stats", 2, argv[0] )); 
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "uint_td","stats", 3, argv[1] ));
  } 
  arg3 = static_cast< uint_td >(val3);
  {
    try {
      (arg1)->stats(arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_nstable_stats(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_nstable_stats__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_nstable_stats__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "nstable.stats", 
    "    void nstable.stats(void *databuffer, uint_td buflen, bool estimate)\n"
    "    void nstable.stats(void *databuffer, uint_td buflen)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_unlock__SWIG_0(int argc, VALUE *argv, VALUE self) {
    bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0;
    bookmark_td *arg2 = 0;
    void *argp1 = 0;
    int res1 = 0;
    void *argp2 = 0;
    int res2 = 0;

    if ((argc < 1) || (argc > 1)) {
        rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)", argc); SWIG_fail;
    }
    res1 = SWIG_ConvertPtr(self, &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 | 0);
    if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError("", "bzs::db::protocol::tdap::client::nstable *", "unlock", 1, self));
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_BOOKMARK, 0);
    if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError("", "bookmark_td &", "unlock", 2, argv[0]));
    }
    if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bookmark_td &", "unlock", 2, argv[0]));
    }
    arg2 = reinterpret_cast< bookmark_td * >(argp2);
    {
        try {
            (arg1)->unlock(*arg2);
        }
        catch (bzs::rtl::exception& e) {
            static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
            rb_raise(bzs_rtl_error, (*bzs::rtl::getMsg(e)).c_str());
        }
        catch (std::exception &e) {
            static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
            rb_raise(cpp_std_error, e.what());
        }
    }
    return Qnil;
fail:
    return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_unlock__SWIG_1(int argc, VALUE *argv, VALUE self) {
    bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0;
    void *argp1 = 0;
    int res1 = 0;

    if ((argc < 0) || (argc > 0)) {
        rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)", argc); SWIG_fail;
    }
    res1 = SWIG_ConvertPtr(self, &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 | 0);
    if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError("", "bzs::db::protocol::tdap::client::nstable *", "unlock", 1, self));
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
    {
        try {
            (arg1)->unlock();
        }
        catch (bzs::rtl::exception& e) {
            static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
            rb_raise(bzs_rtl_error, (*bzs::rtl::getMsg(e)).c_str());
        }
        catch (std::exception &e) {
            static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
            rb_raise(cpp_std_error, e.what());
        }
    }
    return Qnil;
fail:
    return Qnil;
}


SWIGINTERN VALUE _wrap_nstable_unlock(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[3];
    int ii;

    argc = nargs + 1;
    argv[0] = self;
    if (argc > 3) SWIG_fail;
    for (ii = 1; (ii < argc); ++ii) {
        argv[ii] = args[ii - 1];
    }
    if (argc == 1) {
        int _v;
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
            return _wrap_nstable_unlock__SWIG_1(nargs, args, self);
        }
    }
    if (argc == 2) {
        int _v;
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_BOOKMARK, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
                return _wrap_nstable_unlock__SWIG_0(nargs, args, self);
            }
        }
    }

fail:
    Ruby_Format_OverloadedError(argc, 3, "nstable.unlock",
        "    void nstable.unlock(bookmark_td &bm)\n"
        "    void nstable.unlock()\n");

    return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_mode(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable const *","mode", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      result = (char_td)((bzs::db::protocol::tdap::client::nstable const *)arg1)->mode();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_getFileName(int argc, VALUE *argv, VALUE self) {
  _TCHAR *arg1 = (_TCHAR *) 0 ;
  _TCHAR arg2[1024] = {NULL} ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if (argc != 1){
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_TCHAR const *","bzs::db::protocol::tdap::client::nstable::getFileName", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< _TCHAR * >(buf1);

  {
    try {
      result = (_TCHAR *)bzs::db::protocol::tdap::client::nstable::getFileName((char const *)arg1,arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_statMsg(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nstable *arg1 = (bzs::db::protocol::tdap::client::nstable *) 0 ;
  _TCHAR arg2[1024] = {NULL};
  void *argp1 = 0 ;
  int res1 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if (argc != 0){
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nstable *","statMsg", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nstable * >(argp1);
  {
    try {
      arg1->tdapErr((HWND)0, arg2);
      result = arg2;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_getDirURI(int argc, VALUE *argv, VALUE self) {
  _TCHAR *arg1 = (_TCHAR *) 0 ;
  _TCHAR arg2[1024] = {NULL};
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_TCHAR const *","bzs::db::protocol::tdap::client::nstable::getDirURI", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< _TCHAR * >(buf1);

  {
    try {
      result = (_TCHAR *)bzs::db::protocol::tdap::client::nstable::getDirURI((char const *)arg1,arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nstable_existsFile(int argc, VALUE *argv, VALUE self) {
  _TCHAR *arg1 = (_TCHAR *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_TCHAR const *","bzs::db::protocol::tdap::client::nstable::existsFile", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< _TCHAR * >(buf1);
  {
    try {
      result = (bool)bzs::db::protocol::tdap::client::nstable::existsFile((char const *)arg1);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return Qnil;
}


static swig_class SwigClassDbdef;

SWIGINTERN VALUE
_wrap_dbdef_tableCount(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef const *","tableCount", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  {
    try {
      result = (short)((bzs::db::protocol::tdap::client::dbdef const *)arg1)->tableCount();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_openMode(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef const *","openMode", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  {
    try {
      result = (short)((bzs::db::protocol::tdap::client::dbdef const *)arg1)->openMode();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_tableDefs(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bzs::db::protocol::tdap::tabledef *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef *","tableDefs", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableDefs", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (bzs::db::protocol::tdap::tabledef *)(arg1)->tableDefs(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_tableDefPtr(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bzs::db::protocol::tdap::tabledef **result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef *","tableDefPtr", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableDefPtr", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (bzs::db::protocol::tdap::tabledef **)(arg1)->tableDefPtr(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_setVersion(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef *","setVersion", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setVersion", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->setVersion(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_version(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef const *","version", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  {
    try {
      result = (int)((bzs::db::protocol::tdap::client::dbdef const *)arg1)->version();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_stat(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef const *","stat", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  {
    try {
      result = (short_td)((bzs::db::protocol::tdap::client::dbdef const *)arg1)->stat();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_validateTableDef(int argc, VALUE *argv, VALUE self) {
    bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0;
    short arg2;
    void *argp1 = 0;
    int res1 = 0;
    short val2;
    int ecode2 = 0;
    short result;
    VALUE vresult = Qnil;

    if ((argc < 1) || (argc > 1)) {
        rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)", argc); SWIG_fail;
    }
    res1 = SWIG_ConvertPtr(self, &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 | 0);
    if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError("", "bzs::db::protocol::tdap::client::dbdef *", "validateTableDef", 1, self));
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
    ecode2 = SWIG_AsVal_short(argv[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError("", "short", "validateTableDef", 2, argv[0]));
    }
    arg2 = static_cast< short >(val2);
    {
        try {
            result = (short)(arg1)->validateTableDef(arg2);
        }
        catch (bzs::rtl::exception& e) {
            static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
            rb_raise(bzs_rtl_error, (*bzs::rtl::getMsg(e)).c_str());
        }
        catch (std::exception &e) {
            static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
            rb_raise(cpp_std_error, e.what());
        }
    }
    vresult = SWIG_From_short(static_cast< short >(result));
    return vresult;
fail:
    return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_updateTableDef__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  short arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef *","updateTableDef", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","updateTableDef", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","updateTableDef", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      (arg1)->updateTableDef(arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_updateTableDef__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef *","updateTableDef", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","updateTableDef", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      (arg1)->updateTableDef(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_dbdef_updateTableDef(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_dbdef_updateTableDef__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_dbdef_updateTableDef__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "dbdef.updateTableDef", 
    "    void dbdef.updateTableDef(short tableIndex, bool forPsqlDdf)\n"
    "    void dbdef.updateTableDef(short tableIndex)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_insertField(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  short arg2 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  bzs::db::protocol::tdap::fielddef *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef *","insertField", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","insertField", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "short","insertField", 3, argv[1] ));
  } 
  arg3 = static_cast< short >(val3);
  {
    try {
      result = (bzs::db::protocol::tdap::fielddef *)(arg1)->insertField(arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_deleteField(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  short arg2 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef *","deleteField", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","deleteField", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "short","deleteField", 3, argv[1] ));
  } 
  arg3 = static_cast< short >(val3);
  {
    try {
      (arg1)->deleteField(arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_insertKey(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  short arg2 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  bzs::db::protocol::tdap::keydef *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef *","insertKey", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","insertKey", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "short","insertKey", 3, argv[1] ));
  } 
  arg3 = static_cast< short >(val3);
  {
    try {
      result = (bzs::db::protocol::tdap::keydef *)(arg1)->insertKey(arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__keydef, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_deleteKey(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  short arg2 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef *","deleteKey", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","deleteKey", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "short","deleteKey", 3, argv[1] ));
  } 
  arg3 = static_cast< short >(val3);
  {
    try {
      (arg1)->deleteKey(arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_insertTable(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  bzs::db::protocol::tdap::tabledef *arg2 = (bzs::db::protocol::tdap::tabledef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef *","insertTable", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::tabledef *","insertTable", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::tabledef * >(argp2);
  {
    try {
      (arg1)->insertTable(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_deleteTable(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef *","deleteTable", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","deleteTable", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      (arg1)->deleteTable(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_renumberTable(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  short arg2 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef *","renumberTable", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","renumberTable", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "short","renumberTable", 3, argv[1] ));
  } 
  arg3 = static_cast< short >(val3);
  {
    try {
      (arg1)->renumberTable(arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_tableNumByName(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef *","tableNumByName", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","tableNumByName", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (short)(arg1)->tableNumByName((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_getRecordLen(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  ushort_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef *","getRecordLen", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","getRecordLen", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      result = (ushort_td)(arg1)->getRecordLen(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_findKeynumByFieldNum(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  short arg2 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef *","findKeynumByFieldNum", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","findKeynumByFieldNum", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "short","findKeynumByFieldNum", 3, argv[1] ));
  } 
  arg3 = static_cast< short >(val3);
  {
    try {
      result = (short)(arg1)->findKeynumByFieldNum(arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_fieldNumByName(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  short arg2 ;
  _TCHAR *arg3 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef *","fieldNumByName", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","fieldNumByName", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "_TCHAR const *","fieldNumByName", 3, argv[1] ));
  }
  arg3 = reinterpret_cast< _TCHAR * >(buf3);
  {
    try {
      result = (short)(arg1)->fieldNumByName(arg2,(_TCHAR const *)arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return vresult;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_fieldValidLength(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  bzs::db::protocol::tdap::client::eFieldQuery arg2 ;
  uchar_td arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  uint_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef *","fieldValidLength", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::eFieldQuery","fieldValidLength", 2, argv[0] ));
  } 
  arg2 = static_cast< bzs::db::protocol::tdap::client::eFieldQuery >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "uchar_td","fieldValidLength", 3, argv[1] ));
  } 
  arg3 = static_cast< uchar_td >(val3);
  {
    try {
      result = (uint_td)(arg1)->fieldValidLength(arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_statMsg(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  _TCHAR arg2[1024] = {NULL};
  void *argp1 = 0 ;
  int res1 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if (argc != 0){
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef *","statMsg", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  {
    try {
      arg1->tdapErr((HWND)0, arg2);
      result = arg2;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_reopen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  char_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef *","reopen", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char_td","reopen", 2, argv[0] ));
  } 
  arg2 = static_cast< char_td >(val2);
  {
    try {
      (arg1)->reopen(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_reopen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef *","reopen", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  {
    try {
      (arg1)->reopen();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_dbdef_reopen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_dbdef_reopen__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_dbdef_reopen__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "dbdef.reopen", 
    "    void dbdef.reopen(char_td mode)\n"
    "    void dbdef.reopen()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_dbdef_mode(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::dbdef *arg1 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef const *","mode", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp1);
  {
    try {
      result = (char_td)((bzs::db::protocol::tdap::client::dbdef const *)arg1)->mode();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}


static swig_class SwigClassTable;

SWIGINTERN VALUE
_wrap_table_tableDef(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::tabledef *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table const *","tableDef", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::tabledef *)((bzs::db::protocol::tdap::client::table const *)arg1)->tableDef();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_tableDefPtr(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::tabledef **result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table const *","tableDefPtr", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::tabledef **)((bzs::db::protocol::tdap::client::table const *)arg1)->tableDefPtr();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_bzs__db__protocol__tdap__tabledef, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_valiableFormatType(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table const *","valiableFormatType", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::client::table const *)arg1)->valiableFormatType();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_blobFieldUsed(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table const *","blobFieldUsed", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::client::table const *)arg1)->blobFieldUsed();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_logicalToString(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table const *","logicalToString", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::client::table const *)arg1)->logicalToString();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_setLogicalToString(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","setLogicalToString", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setLogicalToString", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->setLogicalToString(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_optionalData(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table const *","optionalData", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  {
    try {
      result = (void *)((bzs::db::protocol::tdap::client::table const *)arg1)->optionalData();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_setOptionalData(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","setOptionalData", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","setOptionalData", 2, argv[0] )); 
  }
  {
    try {
      (arg1)->setOptionalData(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_myDateTimeValueByBtrv(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table const *","myDateTimeValueByBtrv", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::client::table const *)arg1)->myDateTimeValueByBtrv();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_bookmarksCount(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table const *","bookmarksCount", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  {
    try {
      result = (int)((bzs::db::protocol::tdap::client::table const *)arg1)->bookmarksCount();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_moveBookmarks(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","moveBookmarks", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","moveBookmarks", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  {
    try {
      (arg1)->moveBookmarks(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_bookmarks(int argc, VALUE *argv, VALUE self) {
    bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0;
    unsigned int arg2;
    void *argp1 = 0;
    int res1 = 0;
    unsigned int val2;
    int ecode2 = 0;
    bookmark_td result;
    VALUE vresult = Qnil;

    if ((argc < 1) || (argc > 1)) {
        rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)", argc); SWIG_fail;
    }
    res1 = SWIG_ConvertPtr(self, &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 | 0);
    if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError("", "bzs::db::protocol::tdap::client::table const *", "bookmarks", 1, self));
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
    ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError("", "unsigned int", "bookmarks", 2, argv[0]));
    }
    arg2 = static_cast< unsigned int >(val2);
    {
        try {
            result = ((bzs::db::protocol::tdap::client::table const *)arg1)->bookmarks(arg2);
        }
        catch (bzs::rtl::exception& e) {
            static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
            rb_raise(bzs_rtl_error, (*bzs::rtl::getMsg(e)).c_str());
        }
        catch (std::exception &e) {
            static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
            rb_raise(cpp_std_error, e.what());
        }
    }
    vresult = SWIG_NewPointerObj((new bookmark_td(static_cast< const bookmark_td& >(result))), SWIGTYPE_p_BOOKMARK, SWIG_POINTER_OWN | 0);
    return vresult;
fail:
    return Qnil;
}


SWIGINTERN VALUE
_wrap_table_clearBuffer(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","clearBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  {
    try {
      (arg1)->clearBuffer();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_getRecordHash(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","getRecordHash", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  {
    try {
      result = (unsigned int)(arg1)->getRecordHash();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_smartUpdate(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","smartUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  {
    try {
      (arg1)->smartUpdate();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Transactd::table.find

  call-seq:
    find(type=findForword)
    find

Find an element in the class.
*/
SWIGINTERN VALUE
_wrap_table_find__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  bzs::db::protocol::tdap::client::table::eFindType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","find", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table::eFindType","find", 2, argv[0] ));
  } 
  arg2 = static_cast< bzs::db::protocol::tdap::client::table::eFindType >(val2);
  {
    try {
      (arg1)->find(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_find__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","find", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  {
    try {
      (arg1)->find();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_table_find(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_table_find__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_table_find__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "table.find", 
    "    void table.find(bzs::db::protocol::tdap::client::table::eFindType type)\n"
    "    void table.find()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_findFirst(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","findFirst", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  {
    try {
      (arg1)->findFirst();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_findLast(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","findLast", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  {
    try {
      (arg1)->findLast();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_findNext__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","findNext", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","findNext", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->findNext(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_findNext__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","findNext", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  {
    try {
      (arg1)->findNext();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_table_findNext(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_table_findNext__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_table_findNext__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "table.findNext", 
    "    void table.findNext(bool notIncCurrent)\n"
    "    void table.findNext()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_findPrev__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","findPrev", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","findPrev", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->findPrev(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_findPrev__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","findPrev", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  {
    try {
      (arg1)->findPrev();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_table_findPrev(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_table_findPrev__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_table_findPrev__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "table.findPrev", 
    "    void table.findPrev(bool notIncCurrent)\n"
    "    void table.findPrev()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_lastFindDirection(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table const *","lastFindDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  {
    try {
      result = (short_td)((bzs::db::protocol::tdap::client::table const *)arg1)->lastFindDirection();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_statReasonOfFind(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table const *","statReasonOfFind", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  {
    try {
      result = (short_td)((bzs::db::protocol::tdap::client::table const *)arg1)->statReasonOfFind();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_bookmarkFindCurrent(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bookmark_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table const *","bookmarkFindCurrent", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  {
    try {
      result = (bookmark_td)((bzs::db::protocol::tdap::client::table const *)arg1)->bookmarkFindCurrent();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj((new bookmark_td(static_cast< const bookmark_td& >(result))), SWIGTYPE_p_BOOKMARK, SWIG_POINTER_OWN | 0);
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_setFilter__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  ushort_td arg3 ;
  ushort_td arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","setFilter", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","setFilter", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "ushort_td","setFilter", 3, argv[1] ));
  } 
  arg3 = static_cast< ushort_td >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "ushort_td","setFilter", 4, argv[2] ));
  } 
  arg4 = static_cast< ushort_td >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","setFilter", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      (arg1)->setFilter((_TCHAR const *)arg2,arg3,arg4,arg5);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_setFilter__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  ushort_td arg3 ;
  ushort_td arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","setFilter", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","setFilter", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "ushort_td","setFilter", 3, argv[1] ));
  } 
  arg3 = static_cast< ushort_td >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "ushort_td","setFilter", 4, argv[2] ));
  } 
  arg4 = static_cast< ushort_td >(val4);
  {
    try {
      (arg1)->setFilter((_TCHAR const *)arg2,arg3,arg4);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_table_setFilter(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[6];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 6) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_table_setFilter__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_table_setFilter__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "table.setFilter", 
    "    void table.setFilter(_TCHAR const *str, ushort_td rejectCount, ushort_td cacheCount, bool autoEscape)\n"
    "    void table.setFilter(_TCHAR const *str, ushort_td rejectCount, ushort_td cacheCount)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_fieldNumByName(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","fieldNumByName", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","fieldNumByName", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (short)(arg1)->fieldNumByName((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_getFVbyt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  unsigned char result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","getFVbyt", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","getFVbyt", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      result = (unsigned char)(arg1)->getFVbyt(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_getFVsht__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","getFVsht", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","getFVsht", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      result = (short)(arg1)->getFVsht(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_getFVint__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","getFVint", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","getFVint", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      result = (int)(arg1)->getFVint(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_getFVlng__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","getFVlng", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","getFVlng", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      result = (int)(arg1)->getFVlng(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_getFV64__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  __int64 result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","getFV64", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","getFV64", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      result = (arg1)->getFV64(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_long_SS_long(static_cast< long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_getFVflt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  float result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","getFVflt", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","getFVflt", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      result = (float)(arg1)->getFVflt(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_getFVdbl__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","getFVdbl", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","getFVdbl", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      result = (double)(arg1)->getFVdbl(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_getFVbyt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned char result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","getFVbyt", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","getFVbyt", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (unsigned char)(arg1)->getFVbyt((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_table_getFVbyt(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_table_getFVbyt__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_table_getFVbyt__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "table.getFVbyt", 
    "    unsigned char table.getFVbyt(short index)\n"
    "    unsigned char table.getFVbyt(_TCHAR const *fieldName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_getFVsht__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","getFVsht", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","getFVsht", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (short)(arg1)->getFVsht((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_table_getFVsht(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_table_getFVsht__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_table_getFVsht__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "table.getFVsht", 
    "    short table.getFVsht(short index)\n"
    "    short table.getFVsht(_TCHAR const *fieldName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_getFVint__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","getFVint", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","getFVint", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (int)(arg1)->getFVint((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_table_getFVint(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_table_getFVint__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_table_getFVint__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "table.getFVint", 
    "    int table.getFVint(short index)\n"
    "    int table.getFVint(_TCHAR const *fieldName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_getFVlng__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","getFVlng", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","getFVlng", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (int)(arg1)->getFVlng((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_table_getFVlng(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_table_getFVlng__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_table_getFVlng__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "table.getFVlng", 
    "    int table.getFVlng(short index)\n"
    "    int table.getFVlng(_TCHAR const *fieldName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_getFV64__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  __int64 result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","getFV64", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","getFV64", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (arg1)->getFV64((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_long_SS_long(static_cast< long long >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_table_getFV64(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_table_getFV64__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_table_getFV64__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "table.getFV64", 
    "    __int64 table.getFV64(short index)\n"
    "    __int64 table.getFV64(_TCHAR const *fieldName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_getFVflt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  float result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","getFVflt", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","getFVflt", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (float)(arg1)->getFVflt((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_table_getFVflt(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_table_getFVflt__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_table_getFVflt__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "table.getFVflt", 
    "    float table.getFVflt(short index)\n"
    "    float table.getFVflt(_TCHAR const *fieldName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_getFVdbl__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","getFVdbl", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","getFVdbl", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (double)(arg1)->getFVdbl((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_table_getFVdbl(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_table_getFVdbl__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_table_getFVdbl__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "table.getFVdbl", 
    "    double table.getFVdbl(short index)\n"
    "    double table.getFVdbl(_TCHAR const *fieldName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_getFVstr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","getFVstr", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","getFVstr", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      result = (char *)(arg1)->getFVstr(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_getFVstr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","getFVstr", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","getFVstr", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)(arg1)->getFVstr((char const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_table_getFVstr(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_table_getFVstr__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_table_getFVstr__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "table.getFVstr", 
    "    char const * table.getFVstr(short index)\n"
    "    char const * table.getFVstr(char const *fieldName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_fields(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::fields *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","fields", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::fields *) &(arg1)->fields();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__fields, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_setFV(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = 0x00 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int ecode2 = 0 ;
  short index = -1;
  if ((argc > 3) || (argc < 2))  SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","setFV", 1, self )); 
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
    VALUE type = TYPE(argv[0]);
    if ((type == T_FIXNUM) || (type == T_BIGNUM)){
      long long v = 0;
      int ecode = SWIG_AsVal_long_SS_long(argv[0], &v);
      if (!SWIG_IsOK(ecode)) {
        SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "short","setFV", 2, argv[0]));
      }
      index = (short)v;
    }else if (type == T_STRING){
      SWIG_CHAR v1;
      int ret = SWIG_AsCharPtrAndSize(argv[0], &v1.str, NULL, &v1.alloc);
      if (!SWIG_IsOK(ret)) {
        SWIG_exception_fail(SWIG_ArgError(ret), Ruby_Format_TypeError( "", "char *const","setFV", 2, argv[0]));
      }
      index = arg1->fieldNumByName(v1.str);
    }
  }
  {
    VALUE type = TYPE(argv[1]);
    if ((type == T_FIXNUM) || (type == T_BIGNUM)){
      long long v = 0;
      int ecode = SWIG_AsVal_long_SS_long(argv[1], &v);
      if (!SWIG_IsOK(ecode)) {
        SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "__int64","setFV", 3, argv[1]));
      }
      arg1->setFV(index, v);
    }
    else if (type == T_STRING){
      SWIG_CHAR v2;
      int ret = 0;
      
      SWIG_AsCharPtrAndSize(argv[1], &v2.str, NULL, &v2.alloc);
      if (!SWIG_IsOK(ret)) {
        SWIG_exception_fail(SWIG_ArgError(ret), Ruby_Format_TypeError( "", "char *const","setFV", 3, argv[1]));
      }
      if (argc == 2)
        arg1->setFV(index, v2.str);
      else {
        unsigned int val4 ;
        int ecode4 = SWIG_AsVal_unsigned_SS_int(argv[2], &val4);
        if (!SWIG_IsOK(ecode4)) {
          SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "uint_td","setFV", 4, argv[2] ));
        }
        arg1->setFV(index, v2.str, val4);
      }
    }
    else if (type == T_FLOAT){
      double v = 0;
      int ecode = SWIG_AsVal_double(argv[1], &v);
      if (!SWIG_IsOK(ecode)) {
        SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "double","setFV", 3, argv[1]));
      }
      arg1->setFV(index, v);
    }
    else{
      SWIG_exception_fail(SWIG_TypeError, Ruby_Format_TypeError( "", "__int64 or char *const or double","setFV", 3, argv[1]));
    }
  }

  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_getFVbin__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  short arg2 ;
  uint_td *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  uint_td temp3 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  {
    arg3 = &temp3;
  }
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","getFVbin", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","getFVbin", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      result = (void *)bzs_db_protocol_tdap_client_table_getFVbin__SWIG_0(arg1,arg2,*arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  {
    vresult = rb_str_new((const char *)result, *arg3);
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_getFVbin__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  uint_td *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  uint_td temp3 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  {
    arg3 = &temp3;
  }
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","getFVbin", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","getFVbin", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (void *)bzs_db_protocol_tdap_client_table_getFVbin__SWIG_1(arg1,(char const *)arg2,*arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  {
    vresult = rb_str_new((const char *)result, *arg3);
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_table_getFVbin(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_table_getFVbin__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_table_getFVbin__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "getFVbin", 
    "    void * getFVbin(short index, uint_td &table_getFVbin_size)\n"
    "    void * getFVbin(_TCHAR const *fieldName, uint_td &table_getFVbin_size)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_keyValueDescription(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _TCHAR tmpbuf2[1024*8] ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  {
    arg2 = tmpbuf2;
  }
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","keyValueDescription", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  {
    try {
      result = (_TCHAR *)bzs_db_protocol_tdap_client_table_keyValueDescription(arg1,arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_prepare__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  bzs::db::protocol::tdap::client::queryBase *arg2 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  preparedQuery *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase const *","prepare", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","prepare", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (preparedQuery *)bzs_db_protocol_tdap_client_table_prepare__SWIG_0(arg1,(bzs::db::protocol::tdap::client::queryBase const *)arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_preparedQuery, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_prepare__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  bzs::db::protocol::tdap::client::queryBase *arg2 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  preparedQuery *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase const *","prepare", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp2);
  {
    try {
      result = (preparedQuery *)bzs_db_protocol_tdap_client_table_prepare__SWIG_0(arg1,(bzs::db::protocol::tdap::client::queryBase const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_preparedQuery, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_table_prepare(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_table_prepare__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_table_prepare__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "prepare.new", 
    "    prepare.new(bzs::db::protocol::tdap::client::queryBase const *q, bool serverPrepare)\n"
    "    prepare.new(bzs::db::protocol::tdap::client::queryBase const *q)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_setQuery__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  bzs::db::protocol::tdap::client::queryBase *arg2 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  preparedQuery *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","setQuery", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase const *","setQuery", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setQuery", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (preparedQuery *)bzs_db_protocol_tdap_client_table_setQuery__SWIG_0(arg1,(bzs::db::protocol::tdap::client::queryBase const *)arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_preparedQuery, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_setQuery__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  bzs::db::protocol::tdap::client::queryBase *arg2 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  preparedQuery *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","setQuery", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase const *","setQuery", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp2);
  {
    try {
      result = (preparedQuery *)bzs_db_protocol_tdap_client_table_setQuery__SWIG_0(arg1,(bzs::db::protocol::tdap::client::queryBase const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_preparedQuery, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_table_setQuery(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_table_setQuery__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_table_setQuery__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "setQuery.new", 
    "    setQuery.new(bzs::db::protocol::tdap::client::queryBase const *q, bool serverPrepare)\n"
    "    setQuery.new(bzs::db::protocol::tdap::client::queryBase const *q)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_setPrepare(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  preparedQuery *arg2 = (preparedQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","setPrepare", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_preparedQuery, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "preparedQuery *","setPrepare", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< preparedQuery * >(argp2);
  {
    try {
      bzs_db_protocol_tdap_client_table_setPrepare(arg1,arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_table_release(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::table *arg1 = (bzs::db::protocol::tdap::client::table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","release", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp1);
  {
    try {
      bzs_db_protocol_tdap_client_table_release(arg1);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void delete_bzs_db_protocol_tdap_client_table(bzs::db::protocol::tdap::client::table *self){
    if (!g_vPtrList.remove(self))
    {
      if (bzs::db::protocol::tdap::client::nsdatabase::testTablePtr(self))
        self->release();
    }
  }
SWIGINTERN void
free_bzs_db_protocol_tdap_client_table(bzs::db::protocol::tdap::client::table *arg1) {
    delete_bzs_db_protocol_tdap_client_table(arg1);
}

static swig_class SwigClassQueryBase;


SWIGINTERN VALUE
_wrap_queryBase_clearSeekKeyValues(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase *","clearSeekKeyValues", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  {
    try {
      (arg1)->clearSeekKeyValues();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_clearSelectFields(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase *","clearSelectFields", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  {
    try {
      (arg1)->clearSelectFields();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_queryBase_addSeekKeyValue(int nargs, VALUE *args, VALUE self) {
    long long lv = 0;
    double dv = 0;
    bool reset = false;
    SWIG_CHAR buf;
    int res = 0;
    bzs::db::protocol::tdap::client::queryBase *q = 0;
    void* q_tmp;

    if (nargs < 1) goto fail2;

    if (nargs > 2) goto fail2;
    
    res = SWIG_ConvertPtr(self, &q_tmp, SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0);
    if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError("", "bzs::db::protocol::tdap::client::queryBase *", "addSeekKeyValue", 1, self));
    }
    q = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(q_tmp);

    try
    {

        VALUE type = TYPE(args[0]);
        if ((type == T_FIXNUM) || (type == T_BIGNUM)){
            res = SWIG_AsVal_long_SS_long(args[0], &lv);
            if (!SWIG_IsOK(res)) {
                SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError("", "__int64", "addSeekKeyValue", 2, args[0]));
            }
        }
        else if (type == T_STRING){
            res = SWIG_AsCharPtrAndSize(args[0], &buf.str, NULL, &buf.alloc);
            if (!SWIG_IsOK(res)) {
                SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError("", "char *const", "addSeekKeyValue", 2, args[0]));
            }
        }
        else if (type == T_FLOAT){
            res = SWIG_AsVal_double(args[0], &dv);
            if (!SWIG_IsOK(res)) {
                SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError("", "double", "addSeekKeyValue", 2, args[0]));
            }
        }
        else
            goto fail2;

        if (nargs > 1)
        {
            res = SWIG_AsVal_bool(args[1], &reset);
            if (!SWIG_IsOK(res)) {
                SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError("", "bool", "addSeekKeyValue", 3, args[1]));
            }
        }
        if ((type == T_FIXNUM) || (type == T_BIGNUM))
            q->addSeekKeyValue(lexical_cast(lv).c_str(), reset);
        else if (type == T_STRING)
            q->addSeekKeyValue(buf.str, reset);
        else if (type == T_FLOAT)
            q->addSeekKeyValue(lexical_cast(dv).c_str(), reset);

    }
    catch (bzs::rtl::exception& e)
    {
        static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
        rb_raise(bzs_rtl_error, (*bzs::rtl::getMsg(e)).c_str());
    }
    catch (std::exception &e)
    {
        static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
        rb_raise(cpp_std_error, e.what());
    }
    return Qnil;
fail:
    return Qnil;
fail2:
    Ruby_Format_OverloadedError(nargs + 1, 5, "queryBase.addSeekKeyValue",
        "    void queryBase.addSeekKeyValue(const T value, bool reset)\n"
        "    void queryBase.addSeekKeyValue(const T value)\n");

    return Qnil;
}

SWIGINTERN VALUE _wrap_queryBase_addSeekBookmark(int nargs, VALUE *args, VALUE self) {
    bookmark_td *bm = 0;
    int len = 0;
    bool reset = false;
    int res = 0;
    bzs::db::protocol::tdap::client::queryBase *q = 0;
    void* q_tmp;

    if (nargs < 2) goto fail2;

    if (nargs > 3) goto fail2;

    res = SWIG_ConvertPtr(self, &q_tmp, SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0);
    if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError("", "bzs::db::protocol::tdap::client::queryBase *", "addSeekBookmark", 1, self));
    }
    q = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(q_tmp);

    try
    {
        void* bm_tmp = 0;
        res = SWIG_ConvertPtr(args[0], &bm_tmp, SWIGTYPE_p_BOOKMARK, 0);
        if (!SWIG_IsOK(res)) {
            SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError("", "bookmark_td *", "addSeekBookmark", 2, args[0]));
        }
        bm = reinterpret_cast< bookmark_td* >(bm_tmp);

        res = SWIG_AsVal_int(args[1], &len);
        if (!SWIG_IsOK(res)) {
            SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError("", "int", "addSeekBookmark", 3, args[1]));
        }
        if (nargs > 2)
        {
            res = SWIG_AsVal_bool(args[2], &reset);
            if (!SWIG_IsOK(res)) {
                SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError("", "bool", "addSeekBookmark", 4, args[2]));
            }
        }

        q->addSeekBookmark(*bm, len, reset);
    }
    catch (bzs::rtl::exception& e)
    {
        static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
        rb_raise(bzs_rtl_error, (*bzs::rtl::getMsg(e)).c_str());
    }
    catch (std::exception &e)
    {
        static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
        rb_raise(cpp_std_error, e.what());
    }
    return Qnil;
fail:
    return Qnil;
fail2:
    Ruby_Format_OverloadedError(nargs + 1, 5, "queryBase.addSeekBookmark",
        "    void queryBase.addSeekBookmark(const T value, bool reset)\n"
        "    void queryBase.addSeekBookmark(const T value)\n");

    return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_reserveSeekKeyValueSize(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase *","reserveSeekKeyValueSize", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","reserveSeekKeyValueSize", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  {
    try {
      (arg1)->reserveSeekKeyValueSize(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_queryString__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase *","queryString", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","queryString", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","queryString", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      arg1->queryString((_TCHAR const *)arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return self;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_queryString__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase *","queryString", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","queryString", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      arg1->queryString((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return self;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_queryBase_queryString(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_queryBase_queryString__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_queryBase_queryString__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "queryBase.queryString", 
    "    bzs::db::protocol::tdap::client::queryBase & queryBase.queryString(_TCHAR const *str, bool autoEscape)\n"
    "    bzs::db::protocol::tdap::client::queryBase & queryBase.queryString(_TCHAR const *str)\n");
  
  return Qnil;
}



/*
  Document-method: Transactd::queryBase.reject

  call-seq:
    reject(v) -> queryBase

Iterate thru each element in the queryBase and reject those that fail a condition returning a new queryBase.  A block must be provided.
*/
SWIGINTERN VALUE
_wrap_queryBase_reject(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase *","reject", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","reject", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      arg1->reject(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_limit(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase *","limit", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","limit", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      arg1->limit(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_direction(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  bzs::db::protocol::tdap::client::table::eFindType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase *","direction", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table::eFindType","direction", 2, argv[0] ));
  } 
  arg2 = static_cast< bzs::db::protocol::tdap::client::table::eFindType >(val2);
  {
    try {
      arg1->direction(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_all(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase *","all", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  {
    try {
      arg1->all();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_optimize(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  bzs::db::protocol::tdap::client::queryBase::eOptimize arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase *","optimize", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase::eOptimize","optimize", 2, argv[0] ));
  } 
  arg2 = static_cast< bzs::db::protocol::tdap::client::queryBase::eOptimize >(val2);
  {
    try {
      arg1->optimize(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_bookmarkAlso(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase *","bookmarkAlso", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","bookmarkAlso", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      arg1->bookmarkAlso(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_toString(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase const *","toString", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  {
    try {
      result = (_TCHAR *)((bzs::db::protocol::tdap::client::queryBase const *)arg1)->toString();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_getDirection(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::table::eFindType result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase const *","getDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::table::eFindType)((bzs::db::protocol::tdap::client::queryBase const *)arg1)->getDirection();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_getReject(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase const *","getReject", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  {
    try {
      result = (int)((bzs::db::protocol::tdap::client::queryBase const *)arg1)->getReject();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_getLimit(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase const *","getLimit", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  {
    try {
      result = (int)((bzs::db::protocol::tdap::client::queryBase const *)arg1)->getLimit();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_isAll(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase const *","isAll", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::client::queryBase const *)arg1)->isAll();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_getJoinKeySize(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase const *","getJoinKeySize", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  {
    try {
      result = (int)((bzs::db::protocol::tdap::client::queryBase const *)arg1)->getJoinKeySize();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_getOptimize(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::queryBase::eOptimize result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase const *","getOptimize", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::queryBase::eOptimize)((bzs::db::protocol::tdap::client::queryBase const *)arg1)->getOptimize();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_isBookmarkAlso(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase const *","isBookmarkAlso", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::client::queryBase const *)arg1)->isBookmarkAlso();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_selectCount(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase const *","selectCount", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  {
    try {
      result = (short)((bzs::db::protocol::tdap::client::queryBase const *)arg1)->selectCount();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_getSelect(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase const *","getSelect", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","getSelect", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      result = (_TCHAR *)((bzs::db::protocol::tdap::client::queryBase const *)arg1)->getSelect(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_whereTokens(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase const *","whereTokens", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  {
    try {
      result = (short)((bzs::db::protocol::tdap::client::queryBase const *)arg1)->whereTokens();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_getWhereToken(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase const *","getWhereToken", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","getWhereToken", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      result = (_TCHAR *)((bzs::db::protocol::tdap::client::queryBase const *)arg1)->getWhereToken(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_setWhereToken(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  short arg2 ;
  _TCHAR *arg3 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase *","setWhereToken", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","setWhereToken", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "_TCHAR const *","setWhereToken", 3, argv[1] ));
  }
  arg3 = reinterpret_cast< _TCHAR * >(buf3);
  {
    try {
      (arg1)->setWhereToken(arg2,(_TCHAR const *)arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return Qnil;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_reverseAliasName(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  _TCHAR *arg3 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase *","reverseAliasName", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","reverseAliasName", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "_TCHAR const *","reverseAliasName", 3, argv[1] ));
  }
  arg3 = reinterpret_cast< _TCHAR * >(buf3);
  {
    try {
      (arg1)->reverseAliasName((_TCHAR const *)arg2,(_TCHAR const *)arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_stopAtLimit(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase *","stopAtLimit", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","stopAtLimit", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      arg1->stopAtLimit(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_isStopAtLimit(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::queryBase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase const *","isStopAtLimit", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::client::queryBase const *)arg1)->isStopAtLimit();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_queryBase_isSeekByBookmarks(int argc, VALUE *argv, VALUE self) {
    bzs::db::protocol::tdap::client::queryBase *arg1 = (bzs::db::protocol::tdap::client::queryBase *) 0;
    void *argp1 = 0;
    int res1 = 0;
    bool result;
    VALUE vresult = Qnil;

    if ((argc < 0) || (argc > 0)) {
        rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)", argc); SWIG_fail;
    }
    res1 = SWIG_ConvertPtr(self, &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0 | 0);
    if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError("", "bzs::db::protocol::tdap::client::queryBase const *", "isSeekByBookmarks", 1, self));
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp1);
    {
        try {
            result = (bool)((bzs::db::protocol::tdap::client::queryBase const *)arg1)->isSeekByBookmarks();
        }
        catch (bzs::rtl::exception& e) {
            static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
            rb_raise(bzs_rtl_error, (*bzs::rtl::getMsg(e)).c_str());
        }
        catch (std::exception &e) {
            static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
            rb_raise(cpp_std_error, e.what());
        }
    }
    vresult = SWIG_From_bool(static_cast< bool >(result));
    return vresult;
fail:
    return Qnil;
}



static swig_class SwigClassQuery;

SWIGINTERN VALUE
_wrap_query_reset(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::query *arg1 = (bzs::db::protocol::tdap::client::query *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::query *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::query * >(argp1);
  {
    try {
      arg1->reset();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_query_select(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::query *arg1 = 0x00;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const _TCHAR* fdn[11]={NULL};

  if (argc > 12) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__query, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::query *","select", 1, self )); 
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::query * >(argp1);
  }
  
  //Get key field names 
  {
    int alloc = 0;
    char* buf = NULL;
    for (int i=0;i<argc;++i)
    {
      int res = SWIG_AsCharPtrAndSize(argv[i], &buf, NULL, &alloc);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "_TCHAR const *","select", i+1, argv[i] ));
      }
      fdn[i] = reinterpret_cast<const _TCHAR * >(buf);
    }
  }
  
  {
    try {
      arg1->select(fdn[0], fdn[1], fdn[2], fdn[3], fdn[4], fdn[5], fdn[6], fdn[7], fdn[8], fdn[9], fdn[10]);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_query_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_query_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__client__query);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_query(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::query *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::client::query *)new_bzs_db_protocol_tdap_client_query();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void delete_bzs_db_protocol_tdap_client_query(bzs::db::protocol::tdap::client::query *self){
    self->release();
  }
SWIGINTERN void
free_bzs_db_protocol_tdap_client_query(bzs::db::protocol::tdap::client::query *arg1) {
    delete_bzs_db_protocol_tdap_client_query(arg1);
}

SWIGINTERN VALUE
_wrap_query_where(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::query *arg1 = (bzs::db::protocol::tdap::client::query *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  _TCHAR *arg3 = (_TCHAR *) 0 ;
  char *arg4 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3;
  SWIG_CHAR buf2;
  SWIG_CHAR buf3;

  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::query *","where<(p._TCHAR)>", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::query * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2.str, NULL, &buf2.alloc);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","where<(p._TCHAR)>", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2.str);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3.str, NULL, &buf3.alloc);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "_TCHAR const *","where<(p._TCHAR)>", 3, argv[1] ));
  }
  arg3 = reinterpret_cast< _TCHAR * >(buf3.str);
  {
    try {
      VALUE type = TYPE(argv[2]);
      if ((type == T_FIXNUM) || (type == T_BIGNUM)){
        long long v = 0;
        int ecode = SWIG_AsVal_long_SS_long(argv[2], &v);
        if (!SWIG_IsOK(ecode)) {
          SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "__int64","where", 3, argv[2]));
        }
        arg1->where(arg2, arg3, v);
      }
      else if (type == T_STRING){
        SWIG_CHAR buf4;
        int ret = SWIG_AsCharPtrAndSize(argv[2], &buf4.str, NULL, &buf4.alloc);
        if (!SWIG_IsOK(ret)) {
          SWIG_exception_fail(SWIG_ArgError(ret), Ruby_Format_TypeError( "", "char *const","where", 3, argv[2]));
        }
        arg1->where(arg2, arg3, buf4.str);
      }
      else if (type == T_FLOAT){
        double v = 0;
        int ecode = SWIG_AsVal_double(argv[2], &v);
        if (!SWIG_IsOK(ecode)) {
          SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "double","where", 3, argv[2]));
        }
        arg1->where(arg2, arg3, v);
      }
      else{
        SWIG_exception_fail(SWIG_TypeError, Ruby_Format_TypeError( "", "__int64 or char *const or double","where", 3, argv[2]));
      }
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;

}


SWIGINTERN VALUE
_wrap_query_and_(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::query *arg1 = (bzs::db::protocol::tdap::client::query *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  _TCHAR *arg3 = (_TCHAR *) 0 ;
  char *arg4 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 ;
  SWIG_CHAR buf2;
  SWIG_CHAR buf3;

  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::query *","and_<(p._TCHAR)>", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::query * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2.str, NULL, &buf2.alloc);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","and_<(p._TCHAR)>", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2.str);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3.str, NULL, &buf3.alloc);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "_TCHAR const *","and_<(p._TCHAR)>", 3, argv[1] ));
  }
  arg3 = reinterpret_cast< _TCHAR * >(buf3.str);


  {
    try {
      VALUE type = TYPE(argv[2]);
      if ((type == T_FIXNUM) || (type == T_BIGNUM)){
        long long v = 0;
        int ecode = SWIG_AsVal_long_SS_long(argv[2], &v);
        if (!SWIG_IsOK(ecode)) {
          SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "__int64","and_", 3, argv[2]));
        }
        arg1->and_(arg2, arg3, v);
      }
      else if (type == T_STRING){
        SWIG_CHAR buf4;
        int ret = SWIG_AsCharPtrAndSize(argv[2], &buf4.str, NULL, &buf4.alloc);
        if (!SWIG_IsOK(ret)) {
          SWIG_exception_fail(SWIG_ArgError(ret), Ruby_Format_TypeError( "", "char *const","and_", 3, argv[2]));
        }
        arg1->and_(arg2, arg3, buf4.str);

      }
      else if (type == T_FLOAT){
        double v = 0;
        int ecode = SWIG_AsVal_double(argv[2], &v);
        if (!SWIG_IsOK(ecode)) {
          SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "double","and_", 3, argv[2]));
        }
        arg1->and_(arg2, arg3, v);
      }
      else{
        SWIG_exception_fail(SWIG_TypeError, Ruby_Format_TypeError( "", "__int64 or char *const or double","and_", 3, argv[2]));
      }
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;

}


SWIGINTERN VALUE
_wrap_query_or_(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::query *arg1 = (bzs::db::protocol::tdap::client::query *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  _TCHAR *arg3 = (_TCHAR *) 0 ;
  char *arg4 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3;
  SWIG_CHAR buf2;
  SWIG_CHAR buf3;
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::query *","or_<(p._TCHAR)>", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::query * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2.str, NULL, &buf2.alloc);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","or_<(p._TCHAR)>", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2.str);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3.str, NULL, &buf3.alloc);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "_TCHAR const *","or_<(p._TCHAR)>", 3, argv[1] ));
  }
  arg3 = reinterpret_cast< _TCHAR * >(buf3.str);

  {
    try {
      VALUE type = TYPE(argv[2]);
      if ((type == T_FIXNUM) || (type == T_BIGNUM)){
        long long v = 0;
        int ecode = SWIG_AsVal_long_SS_long(argv[2], &v);
        if (!SWIG_IsOK(ecode)) {
          SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "__int64","or_", 3, argv[2]));
        }
        arg1->or_(arg2, arg3, v);
      }
      else if (type == T_STRING){
        SWIG_CHAR buf4;
        int ret = SWIG_AsCharPtrAndSize(argv[2], &buf4.str, NULL, &buf4.alloc);
        if (!SWIG_IsOK(ret)) {
          SWIG_exception_fail(SWIG_ArgError(ret), Ruby_Format_TypeError( "", "char *const","or_", 3, argv[2]));
        }
        arg1->or_(arg2, arg3, buf4.str);
      }
      else if (type == T_FLOAT){
        double v = 0;
        int ecode = SWIG_AsVal_double(argv[2], &v);
        if (!SWIG_IsOK(ecode)) {
          SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "double","or_", 3, argv[2]));
        }
        arg1->or_(arg2, arg3, v);
      }
      else{
        SWIG_exception_fail(SWIG_TypeError, Ruby_Format_TypeError( "", "__int64 or char *const or double","or_", 3, argv[2]));
      }

      
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_query_in(int nargs, VALUE *args, VALUE self) {
  bzs::db::protocol::tdap::client::query *arg1 = 0x00 ;
  void *argp1 = 0 ;
  int res1 = 0 ;

  if (nargs > 8) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__query, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::query *","in", 1, self )); 
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::query * >(argp1);
  }


  // addSeekKeyValues 
  {
    for (int i = 0; i < nargs; ++i){
      VALUE type = TYPE(args[i]);
      if ((type == T_FIXNUM) || (type == T_BIGNUM)){
        long long v = 0;
        int ecode = SWIG_AsVal_long_SS_long(args[i], &v);
        if (!SWIG_IsOK(ecode)) {
          SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "__int64","in", i+1, args[i]));
        }
        arg1->addSeekKeyValue(lexical_cast(v).c_str());
      }
      else if (type == T_STRING){
          SWIG_CHAR buf;
          int ret = SWIG_AsCharPtrAndSize(args[i], &buf.str, NULL, &buf.alloc);
        if (!SWIG_IsOK(ret)) {
          SWIG_exception_fail(SWIG_ArgError(ret), Ruby_Format_TypeError( "", "char *const","in", i+1, args[i]));
        }
        arg1->addSeekKeyValue(buf.str);
      }
      else if (type == T_FLOAT){
        double v = 0;
        int ecode = SWIG_AsVal_double(args[i], &v);
        if (!SWIG_IsOK(ecode)) {
          SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "double","in", i+1, args[i]));
        }
        arg1->addSeekKeyValue(lexical_cast(v).c_str());
      }
      else{
        SWIG_exception_fail(SWIG_TypeError, Ruby_Format_TypeError( "", "__int64 or char *const or double","in", i+1, args[i]));
      }
    }
  }
  return self;
fail:
  return Qnil;
}


static swig_class SwigClassNsdatabase;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_nsdatabase_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_nsdatabase_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_nsdatabase(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::client::nsdatabase *)new bzs::db::protocol::tdap::client::nsdatabase();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_enableTrn(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase const *","enableTrn", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  {
    try {
      result = (int)((bzs::db::protocol::tdap::client::nsdatabase const *)arg1)->enableTrn();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_stat(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase const *","stat", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  {
    try {
      result = (short)((bzs::db::protocol::tdap::client::nsdatabase const *)arg1)->stat();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_clientID(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar_td *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase const *","clientID", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  {
    try {
      result = (uchar_td *)((bzs::db::protocol::tdap::client::nsdatabase const *)arg1)->clientID();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_openTableCount(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase const *","openTableCount", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  {
    try {
      result = (short)((bzs::db::protocol::tdap::client::nsdatabase const *)arg1)->openTableCount();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_uri(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase const *","uri", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  {
    try {
      result = (_TCHAR *)((bzs::db::protocol::tdap::client::nsdatabase const *)arg1)->uri();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_uriMode(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase const *","uriMode", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::client::nsdatabase const *)arg1)->uriMode();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_lockWaitCount(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase const *","lockWaitCount", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  {
    try {
      result = (short)((bzs::db::protocol::tdap::client::nsdatabase const *)arg1)->lockWaitCount();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_lockWaitTime(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase const *","lockWaitTime", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  {
    try {
      result = (short)((bzs::db::protocol::tdap::client::nsdatabase const *)arg1)->lockWaitTime();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_setLockWaitCount(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","setLockWaitCount", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","setLockWaitCount", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      (arg1)->setLockWaitCount(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_setLockWaitTime(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","setLockWaitTime", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","setLockWaitTime", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      (arg1)->setLockWaitTime(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_setLocalSharing(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","setLocalSharing", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setLocalSharing", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->setLocalSharing(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_dropTable(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","dropTable", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","dropTable", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      (arg1)->dropTable((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_rename(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  _TCHAR *arg3 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","rename", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","rename", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "_TCHAR const *","rename", 3, argv[1] ));
  }
  arg3 = reinterpret_cast< _TCHAR * >(buf3);
  {
    try {
      (arg1)->rename((_TCHAR const *)arg2,(_TCHAR const *)arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_swapTablename(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  _TCHAR *arg3 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","swapTablename", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","swapTablename", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "_TCHAR const *","swapTablename", 3, argv[1] ));
  }
  arg3 = reinterpret_cast< _TCHAR * >(buf3);
  {
    try {
      (arg1)->swapTablename((_TCHAR const *)arg2,(_TCHAR const *)arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_beginTrn__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","beginTrn", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","beginTrn", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      (arg1)->beginTrn(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_beginTrn__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","beginTrn", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  {
    try {
      (arg1)->beginTrn();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_nsdatabase_beginTrn(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_nsdatabase_beginTrn__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_nsdatabase_beginTrn__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "nsdatabase.beginTrn", 
    "    void nsdatabase.beginTrn(short bias)\n"
    "    void nsdatabase.beginTrn()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_endTrn(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","endTrn", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  {
    try {
      (arg1)->endTrn();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_abortTrn(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","abortTrn", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  {
    try {
      (arg1)->abortTrn();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_nsdatabase_beginSnapshot(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = 0x00;
  short arg2;
  short val2;
  
  int _v;
  void *vptr = 0;
  int res;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3 || argc < 1) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  // check arg1 (nsdatabase)
  res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0);
  _v = SWIG_CheckState(res);
  if (! _v) SWIG_fail;
  if (!SWIG_IsOK(res)) {
    SWIG_exception_fail(SWIG_ArgError(res),
      Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","beginSnapshot", 1, argv[0] )); 
  }
  // cast arg1
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(vptr);
  // call beginSnapshot()
  if (argc == 1) {
    try {
      (arg1)->beginSnapshot();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
    return Qnil;
  }
  // check arg2
  if (argc == 2) {
    int res = SWIG_AsVal_short(argv[1], &val2);
    _v = SWIG_CheckState(res);
    if (! _v) SWIG_fail;
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "short","beginSnapshot", 2, argv[1] ));
    }
    // cast arg2
    arg2 = static_cast< short >(val2);
    // call beginSnapshot(short bias)
    try {
      (arg1)->beginSnapshot(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
    return Qnil;
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "nsdatabase.beginSnapshot", 
    "    void nsdatabase.beginSnapshot(short bias)\n"
    "    void nsdatabase.beginSnapshot()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_endSnapshot(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","endSnapshot", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  {
    try {
      (arg1)->endSnapshot();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_trxIsolationServer(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase const *","trxIsolationServer", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  {
    try {
      result = arg1->trxIsolationServer();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_long(result);
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_trxLockWaitTimeoutServer(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase const *","trxLockWaitTimeoutServer", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  {
    try {
      result = arg1->trxLockWaitTimeoutServer();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_long(result);
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_statMsg(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  _TCHAR arg2[1024] = {NULL};
  void *argp1 = 0 ;
  int res1 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if (argc != 0){
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","statMsg", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  {
    try {
      arg1->tdapErr((HWND)0, arg2);
      result = arg2;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_useLongFilename(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","useLongFilename", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  {
    try {
      result = (bool)(arg1)->useLongFilename();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_setUseLongFilename(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","setUseLongFilename", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setUseLongFilename", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->setUseLongFilename(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_setUseTransactd(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","setUseTransactd", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  {
    try {
      result = (bool)(arg1)->setUseTransactd();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_isTransactdUri(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","isTransactdUri", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","isTransactdUri", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (bool)(arg1)->isTransactdUri((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_isUseTransactd(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","isUseTransactd", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  {
    try {
      result = (bool)(arg1)->isUseTransactd();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_readDatabaseDirectory(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  _TCHAR arg2[255] = {NULL} ;
  uchar_td arg3 = 255 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE vresult = Qnil;

  
  if (argc != 0) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","readDatabaseDirectory", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
 
  {
    try {
      (arg1)->readDatabaseDirectory(arg2, arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(arg2, strlen(arg2), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_connect__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","connect", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","connect", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","connect", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (bool)(arg1)->connect((_TCHAR const *)arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_connect__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","connect", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","connect", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (bool)(arg1)->connect((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_nsdatabase_connect(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_nsdatabase_connect__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_nsdatabase_connect__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "nsdatabase.connect", 
    "    bool nsdatabase.connect(_TCHAR const *uri, bool newConnection)\n"
    "    bool nsdatabase.connect(_TCHAR const *uri)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_disconnect__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","disconnect", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","disconnect", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (bool)(arg1)->disconnect((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_disconnect__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","disconnect", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  {
    try {
      result = (bool)(arg1)->disconnect();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_nsdatabase_disconnect(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_nsdatabase_disconnect__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_nsdatabase_disconnect__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "nsdatabase.disconnect", 
    "    bool nsdatabase.disconnect(_TCHAR const *uri)\n"
    "    bool nsdatabase.disconnect()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_disconnectForReconnectTest(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","disconnectForReconnectTest", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  {
    try {
      result = (bool)(arg1)->disconnectForReconnectTest();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_reconnect(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::nsdatabase *arg1 = (bzs::db::protocol::tdap::client::nsdatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::nsdatabase *","reconnect", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::nsdatabase * >(argp1);
  {
    try {
      result = (bool)(arg1)->reconnect();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_trnsactionFlushWaitStatus(int argc, VALUE *argv, VALUE self) {
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bool)bzs::db::protocol::tdap::client::nsdatabase::trnsactionFlushWaitStatus();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_setExecCodePage(int argc, VALUE *argv, VALUE self) {
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned int","bzs::db::protocol::tdap::client::nsdatabase::setExecCodePage", 1, argv[0] ));
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      bzs::db::protocol::tdap::client::nsdatabase::setExecCodePage(arg1);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_execCodePage(int argc, VALUE *argv, VALUE self) {
  unsigned int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (unsigned int)bzs::db::protocol::tdap::client::nsdatabase::execCodePage();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_nsdatabase_setCheckTablePtr(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","bzs::db::protocol::tdap::client::nsdatabase::setCheckTablePtr", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      bzs::db::protocol::tdap::client::nsdatabase::setCheckTablePtr(arg1);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


static swig_class SwigClassDatabase;

SWIGINTERN VALUE
_wrap_database_dbDef(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::dbdef *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database const *","dbDef", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::dbdef *)((bzs::db::protocol::tdap::client::database const *)arg1)->dbDef();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_rootDir(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database const *","rootDir", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  {
    try {
      result = (_TCHAR *)((bzs::db::protocol::tdap::client::database const *)arg1)->rootDir();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_setRootDir(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","setRootDir", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","setRootDir", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      (arg1)->setRootDir((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_optionalData(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database const *","optionalData", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  {
    try {
      result = (void *)((bzs::db::protocol::tdap::client::database const *)arg1)->optionalData();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_setOptionalData(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","setOptionalData", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","setOptionalData", 2, argv[0] )); 
  }
  {
    try {
      (arg1)->setOptionalData(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_tableReadOnly(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database const *","tableReadOnly", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::client::database const *)arg1)->tableReadOnly();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_setTableReadOnly(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","setTableReadOnly", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setTableReadOnly", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->setTableReadOnly(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_open__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  short arg3 ;
  short arg4 ;
  _TCHAR *arg5 = (_TCHAR *) 0 ;
  _TCHAR *arg6 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","open", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","open", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  ecode3 = SWIG_AsVal_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "short","open", 3, argv[1] ));
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "short","open", 4, argv[2] ));
  } 
  arg4 = static_cast< short >(val4);
  res5 = SWIG_AsCharPtrAndSize(argv[3], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "_TCHAR const *","open", 5, argv[3] ));
  }
  arg5 = reinterpret_cast< _TCHAR * >(buf5);
  res6 = SWIG_AsCharPtrAndSize(argv[4], &buf6, NULL, &alloc6);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "_TCHAR const *","open", 6, argv[4] ));
  }
  arg6 = reinterpret_cast< _TCHAR * >(buf6);
  {
    try {
      result = (bool)(arg1)->open((_TCHAR const *)arg2,arg3,arg4,(_TCHAR const *)arg5,(_TCHAR const *)arg6);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_open__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  short arg3 ;
  short arg4 ;
  _TCHAR *arg5 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","open", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","open", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  ecode3 = SWIG_AsVal_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "short","open", 3, argv[1] ));
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "short","open", 4, argv[2] ));
  } 
  arg4 = static_cast< short >(val4);
  res5 = SWIG_AsCharPtrAndSize(argv[3], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "_TCHAR const *","open", 5, argv[3] ));
  }
  arg5 = reinterpret_cast< _TCHAR * >(buf5);
  {
    try {
      result = (bool)(arg1)->open((_TCHAR const *)arg2,arg3,arg4,(_TCHAR const *)arg5);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_open__SWIG_2(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  short arg3 ;
  short arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","open", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","open", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  ecode3 = SWIG_AsVal_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "short","open", 3, argv[1] ));
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "short","open", 4, argv[2] ));
  } 
  arg4 = static_cast< short >(val4);
  {
    try {
      result = (bool)(arg1)->open((_TCHAR const *)arg2,arg3,arg4);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_open__SWIG_3(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","open", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","open", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  ecode3 = SWIG_AsVal_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "short","open", 3, argv[1] ));
  } 
  arg3 = static_cast< short >(val3);
  {
    try {
      result = (bool)(arg1)->open((_TCHAR const *)arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_open__SWIG_4(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","open", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","open", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (bool)(arg1)->open((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_database_open(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_database_open__SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_database_open__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_database_open__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_database_open__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsCharPtrAndSize(argv[5], 0, NULL, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_database_open__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "database.open", 
    "    bool database.open(_TCHAR const *uri, short schemaType, short mode, _TCHAR const *dir, _TCHAR const *ownerName)\n"
    "    bool database.open(_TCHAR const *uri, short schemaType, short mode, _TCHAR const *dir)\n"
    "    bool database.open(_TCHAR const *uri, short schemaType, short mode)\n"
    "    bool database.open(_TCHAR const *uri, short schemaType)\n"
    "    bool database.open(_TCHAR const *uri)\n");
  
  return Qnil;
}



/*
  Document-method: Transactd::database.clone

  call-seq:
    clone -> database

Create a duplicate of the class.
*/
SWIGINTERN VALUE
_wrap_database_clone(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::database *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::database *)(arg1)->clone();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__database, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_create__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","create", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  ecode3 = SWIG_AsVal_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "short","create", 3, argv[1] ));
  } 
  arg3 = static_cast< short >(val3);
  {
    try {
      (arg1)->create((_TCHAR const *)arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_create__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","create", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      (arg1)->create((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_database_create(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_database_create__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_database_create__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "create.new", 
    "    create.new(_TCHAR const *uri, short type)\n"
    "    create.new(_TCHAR const *uri)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_drop(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","drop", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  {
    try {
      (arg1)->drop();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_dropTable(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","dropTable", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","dropTable", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      (arg1)->dropTable((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_close__SWIG_0(int argc, VALUE *argv, VALUE self) {
    bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0;
    bool arg2;
    void *argp1 = 0;
    int res1 = 0;
    bool val2;
    int ecode2 = 0;

    if ((argc < 1) || (argc > 1)) {
        rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)", argc); SWIG_fail;
    }
    res1 = SWIG_ConvertPtr(self, &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 | 0);
    if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError("", "bzs::db::protocol::tdap::client::database *", "close", 1, self));
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
    ecode2 = SWIG_AsVal_bool(argv[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError("", "bool", "close", 2, argv[0]));
    }
    arg2 = static_cast< bool >(val2);
    {
        try {
            (arg1)->close(arg2);
        }
        catch (bzs::rtl::exception& e) {
            static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
            rb_raise(bzs_rtl_error, (*bzs::rtl::getMsg(e)).c_str());
        }
        catch (std::exception &e) {
            static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
            rb_raise(cpp_std_error, e.what());
        }
    }
    return Qnil;
fail:
    return Qnil;
}


SWIGINTERN VALUE
_wrap_database_close__SWIG_1(int argc, VALUE *argv, VALUE self) {
    bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0;
    void *argp1 = 0;
    int res1 = 0;

    if ((argc < 0) || (argc > 0)) {
        rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)", argc); SWIG_fail;
    }
    res1 = SWIG_ConvertPtr(self, &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 | 0);
    if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError("", "bzs::db::protocol::tdap::client::database *", "close", 1, self));
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
    {
        try {
            (arg1)->close();
        }
        catch (bzs::rtl::exception& e) {
            static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
            rb_raise(bzs_rtl_error, (*bzs::rtl::getMsg(e)).c_str());
        }
        catch (std::exception &e) {
            static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
            rb_raise(cpp_std_error, e.what());
        }
    }
    return Qnil;
fail:
    return Qnil;
}


SWIGINTERN VALUE _wrap_database_close(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[3];
    int ii;

    argc = nargs + 1;
    argv[0] = self;
    if (argc > 3) SWIG_fail;
    for (ii = 1; (ii < argc); ++ii) {
        argv[ii] = args[ii - 1];
    }
    if (argc == 1) {
        int _v;
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
            return _wrap_database_close__SWIG_1(nargs, args, self);
        }
    }
    if (argc == 2) {
        int _v;
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
            {
                int res = SWIG_AsVal_bool(argv[1], NULL);
                _v = SWIG_CheckState(res);
            }
            if (_v) {
                return _wrap_database_close__SWIG_0(nargs, args, self);
            }
        }
    }

fail:
    Ruby_Format_OverloadedError(argc, 3, "database.close",
        "    void database.close(bool withDropDefaultSchema)\n"
        "    void database.close()\n");

    return Qnil;
}


SWIGINTERN VALUE
_wrap_database_aclReload(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","aclReload", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  {
    try {
      result = (short)arg1->aclReload();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_continuous__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  char_td arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","continuous", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char_td","continuous", 2, argv[0] ));
  } 
  arg2 = static_cast< char_td >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","continuous", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (short)(arg1)->continuous(arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_continuous__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  char_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","continuous", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char_td","continuous", 2, argv[0] ));
  } 
  arg2 = static_cast< char_td >(val2);
  {
    try {
      result = (short)(arg1)->continuous(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_continuous__SWIG_2(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","continuous", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  {
    try {
      result = (short)(arg1)->continuous();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_database_continuous(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_database_continuous__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_database_continuous__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_database_continuous__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "database.continuous", 
    "    short database.continuous(char_td op, bool inclideRepfile)\n"
    "    short database.continuous(char_td op)\n"
    "    short database.continuous()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_assignSchemaData(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  bzs::db::protocol::tdap::client::dbdef *arg2 = (bzs::db::protocol::tdap::client::dbdef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","assignSchemaData", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::dbdef *","assignSchemaData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::dbdef * >(argp2);
  {
    try {
      result = (short)(arg1)->assignSchemaData(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_copyTableData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  bzs::db::protocol::tdap::client::table *arg2 = (bzs::db::protocol::tdap::client::table *) 0 ;
  bzs::db::protocol::tdap::client::table *arg3 = (bzs::db::protocol::tdap::client::table *) 0 ;
  bool arg4 ;
  int arg5 ;
  short arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  short val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","copyTableData", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","copyTableData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","copyTableData", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","copyTableData", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","copyTableData", 5, argv[3] ));
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_short(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "short","copyTableData", 6, argv[4] ));
  } 
  arg6 = static_cast< short >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "int","copyTableData", 7, argv[5] ));
  } 
  arg7 = static_cast< int >(val7);
  {
    try {
      result = (short)(arg1)->copyTableData(arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_copyTableData__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  bzs::db::protocol::tdap::client::table *arg2 = (bzs::db::protocol::tdap::client::table *) 0 ;
  bzs::db::protocol::tdap::client::table *arg3 = (bzs::db::protocol::tdap::client::table *) 0 ;
  bool arg4 ;
  int arg5 ;
  short arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  short val6 ;
  int ecode6 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","copyTableData", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","copyTableData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","copyTableData", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","copyTableData", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","copyTableData", 5, argv[3] ));
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_short(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "short","copyTableData", 6, argv[4] ));
  } 
  arg6 = static_cast< short >(val6);
  {
    try {
      result = (short)(arg1)->copyTableData(arg2,arg3,arg4,arg5,arg6);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_copyTableData__SWIG_2(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  bzs::db::protocol::tdap::client::table *arg2 = (bzs::db::protocol::tdap::client::table *) 0 ;
  bzs::db::protocol::tdap::client::table *arg3 = (bzs::db::protocol::tdap::client::table *) 0 ;
  bool arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","copyTableData", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","copyTableData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","copyTableData", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","copyTableData", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","copyTableData", 5, argv[3] ));
  } 
  arg5 = static_cast< int >(val5);
  {
    try {
      result = (short)(arg1)->copyTableData(arg2,arg3,arg4,arg5);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_copyTableData__SWIG_3(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  bzs::db::protocol::tdap::client::table *arg2 = (bzs::db::protocol::tdap::client::table *) 0 ;
  bzs::db::protocol::tdap::client::table *arg3 = (bzs::db::protocol::tdap::client::table *) 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","copyTableData", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","copyTableData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::table *","copyTableData", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< bzs::db::protocol::tdap::client::table * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","copyTableData", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (short)(arg1)->copyTableData(arg2,arg3,arg4);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_database_copyTableData(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_database_copyTableData__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_database_copyTableData__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_short(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_database_copyTableData__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_short(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_database_copyTableData__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "database.copyTableData", 
    "    short database.copyTableData(bzs::db::protocol::tdap::client::table *dest, bzs::db::protocol::tdap::client::table *src, bool turbo, int offset, short keyNum, int maxSkip)\n"
    "    short database.copyTableData(bzs::db::protocol::tdap::client::table *dest, bzs::db::protocol::tdap::client::table *src, bool turbo, int offset, short keyNum)\n"
    "    short database.copyTableData(bzs::db::protocol::tdap::client::table *dest, bzs::db::protocol::tdap::client::table *src, bool turbo, int offset)\n"
    "    short database.copyTableData(bzs::db::protocol::tdap::client::table *dest, bzs::db::protocol::tdap::client::table *src, bool turbo)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_convertTable__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  short arg2 ;
  bool arg3 ;
  _TCHAR *arg4 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","convertTable", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","convertTable", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","convertTable", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_AsCharPtrAndSize(argv[2], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "_TCHAR const *","convertTable", 4, argv[2] ));
  }
  arg4 = reinterpret_cast< _TCHAR * >(buf4);
  {
    try {
      (arg1)->convertTable(arg2,arg3,(_TCHAR const *)arg4);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
fail:
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_convertTable__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  short arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","convertTable", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","convertTable", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","convertTable", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      (arg1)->convertTable(arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_database_convertTable(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_database_convertTable__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_database_convertTable__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "database.convertTable", 
    "    void database.convertTable(short tableIndex, bool turbo, _TCHAR const *ownerName)\n"
    "    void database.convertTable(short tableIndex, bool turbo)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_existsTableFile__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  short arg2 ;
  _TCHAR *arg3 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","existsTableFile", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","existsTableFile", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "_TCHAR const *","existsTableFile", 3, argv[1] ));
  }
  arg3 = reinterpret_cast< _TCHAR * >(buf3);
  {
    try {
      result = (bool)(arg1)->existsTableFile(arg2,(_TCHAR const *)arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return vresult;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_existsTableFile__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","existsTableFile", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","existsTableFile", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      result = (bool)(arg1)->existsTableFile(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_database_existsTableFile(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_database_existsTableFile__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_database_existsTableFile__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "database.existsTableFile", 
    "    bool database.existsTableFile(short tableIndex, _TCHAR const *ownerName)\n"
    "    bool database.existsTableFile(short tableIndex)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_getTableUri(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","getTableUri", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR *","getTableUri", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  ecode3 = SWIG_AsVal_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "short","getTableUri", 3, argv[1] ));
  } 
  arg3 = static_cast< short >(val3);
  {
    try {
      result = (_TCHAR *)(arg1)->getTableUri(arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_getBtrVersion(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  bzs::db::protocol::tdap::btrVersions *arg2 = (bzs::db::protocol::tdap::btrVersions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","getBtrVersion", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__btrVersions, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrVersions *","getBtrVersion", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::btrVersions * >(argp2);
  {
    try {
      (arg1)->getBtrVersion(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_isOpened(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database const *","isOpened", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::client::database const *)arg1)->isOpened();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_mode(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database const *","mode", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  {
    try {
      result = (char_td)((bzs::db::protocol::tdap::client::database const *)arg1)->mode();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_database_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_database_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__client__database);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_database(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::client::database *)new_bzs_db_protocol_tdap_client_database();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void delete_bzs_db_protocol_tdap_client_database(bzs::db::protocol::tdap::client::database *self){
    self->release();
  }
SWIGINTERN void
free_bzs_db_protocol_tdap_client_database(bzs::db::protocol::tdap::client::database *arg1) {
    delete_bzs_db_protocol_tdap_client_database(arg1);
}

SWIGINTERN VALUE
_wrap_database_openTable__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  short arg3 ;
  bool arg4 ;
  _TCHAR *arg5 = (_TCHAR *) 0 ;
  _TCHAR *arg6 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  bzs::db::protocol::tdap::client::table *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","openTable", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","openTable", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  ecode3 = SWIG_AsVal_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "short","openTable", 3, argv[1] ));
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","openTable", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_AsCharPtrAndSize(argv[3], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "_TCHAR const *","openTable", 5, argv[3] ));
  }
  arg5 = reinterpret_cast< _TCHAR * >(buf5);
  res6 = SWIG_AsCharPtrAndSize(argv[4], &buf6, NULL, &alloc6);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "_TCHAR const *","openTable", 6, argv[4] ));
  }
  arg6 = reinterpret_cast< _TCHAR * >(buf6);
  {
    try {
      result = (bzs::db::protocol::tdap::client::table *)bzs_db_protocol_tdap_client_database_openTable__SWIG_0(arg1,(char const *)arg2,arg3,arg4,(char const *)arg5,(char const *)arg6);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__table, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_openTable__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  short arg3 ;
  bool arg4 ;
  _TCHAR *arg5 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  bzs::db::protocol::tdap::client::table *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","openTable", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","openTable", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  ecode3 = SWIG_AsVal_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "short","openTable", 3, argv[1] ));
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","openTable", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_AsCharPtrAndSize(argv[3], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "_TCHAR const *","openTable", 5, argv[3] ));
  }
  arg5 = reinterpret_cast< _TCHAR * >(buf5);
  {
    try {
      result = (bzs::db::protocol::tdap::client::table *)bzs_db_protocol_tdap_client_database_openTable__SWIG_0(arg1,(char const *)arg2,arg3,arg4,(char const *)arg5);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__table, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_openTable__SWIG_2(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  short arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bzs::db::protocol::tdap::client::table *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","openTable", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","openTable", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  ecode3 = SWIG_AsVal_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "short","openTable", 3, argv[1] ));
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","openTable", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (bzs::db::protocol::tdap::client::table *)bzs_db_protocol_tdap_client_database_openTable__SWIG_0(arg1,(char const *)arg2,arg3,arg4);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__table, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_openTable__SWIG_3(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  bzs::db::protocol::tdap::client::table *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","openTable", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","openTable", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  ecode3 = SWIG_AsVal_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "short","openTable", 3, argv[1] ));
  } 
  arg3 = static_cast< short >(val3);
  {
    try {
      result = (bzs::db::protocol::tdap::client::table *)bzs_db_protocol_tdap_client_database_openTable__SWIG_0(arg1,(char const *)arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__table, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_openTable__SWIG_4(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bzs::db::protocol::tdap::client::table *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","openTable", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","openTable", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (bzs::db::protocol::tdap::client::table *)bzs_db_protocol_tdap_client_database_openTable__SWIG_0(arg1,(char const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__table, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_openTable__SWIG_5(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  short arg2 ;
  short arg3 ;
  bool arg4 ;
  _TCHAR *arg5 = (_TCHAR *) 0 ;
  _TCHAR *arg6 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  bzs::db::protocol::tdap::client::table *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","openTable", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","openTable", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "short","openTable", 3, argv[1] ));
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","openTable", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_AsCharPtrAndSize(argv[3], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "_TCHAR const *","openTable", 5, argv[3] ));
  }
  arg5 = reinterpret_cast< _TCHAR * >(buf5);
  res6 = SWIG_AsCharPtrAndSize(argv[4], &buf6, NULL, &alloc6);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "_TCHAR const *","openTable", 6, argv[4] ));
  }
  arg6 = reinterpret_cast< _TCHAR * >(buf6);
  {
    try {
      result = (bzs::db::protocol::tdap::client::table *)bzs_db_protocol_tdap_client_database_openTable__SWIG_5(arg1,arg2,arg3,arg4,(char const *)arg5,(char const *)arg6);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__table, SWIG_POINTER_OWN |  0 );
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
  return vresult;
fail:
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_openTable__SWIG_6(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  short arg2 ;
  short arg3 ;
  bool arg4 ;
  _TCHAR *arg5 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  bzs::db::protocol::tdap::client::table *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","openTable", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","openTable", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "short","openTable", 3, argv[1] ));
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","openTable", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_AsCharPtrAndSize(argv[3], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "_TCHAR const *","openTable", 5, argv[3] ));
  }
  arg5 = reinterpret_cast< _TCHAR * >(buf5);
  {
    try {
      result = (bzs::db::protocol::tdap::client::table *)bzs_db_protocol_tdap_client_database_openTable__SWIG_5(arg1,arg2,arg3,arg4,(char const *)arg5);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__table, SWIG_POINTER_OWN |  0 );
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return vresult;
fail:
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_openTable__SWIG_7(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  short arg2 ;
  short arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bzs::db::protocol::tdap::client::table *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","openTable", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","openTable", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "short","openTable", 3, argv[1] ));
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","openTable", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (bzs::db::protocol::tdap::client::table *)bzs_db_protocol_tdap_client_database_openTable__SWIG_5(arg1,arg2,arg3,arg4);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__table, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_openTable__SWIG_8(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  short arg2 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  bzs::db::protocol::tdap::client::table *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","openTable", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","openTable", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  ecode3 = SWIG_AsVal_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "short","openTable", 3, argv[1] ));
  } 
  arg3 = static_cast< short >(val3);
  {
    try {
      result = (bzs::db::protocol::tdap::client::table *)bzs_db_protocol_tdap_client_database_openTable__SWIG_5(arg1,arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__table, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_database_openTable__SWIG_9(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  bzs::db::protocol::tdap::client::table *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","openTable", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","openTable", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      result = (bzs::db::protocol::tdap::client::table *)bzs_db_protocol_tdap_client_database_openTable__SWIG_5(arg1,arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__table, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_database_openTable(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_database_openTable__SWIG_9(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_database_openTable__SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_database_openTable__SWIG_8(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_database_openTable__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_database_openTable__SWIG_7(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_database_openTable__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_database_openTable__SWIG_6(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_database_openTable__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsCharPtrAndSize(argv[5], 0, NULL, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_database_openTable__SWIG_5(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsCharPtrAndSize(argv[5], 0, NULL, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_database_openTable__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "openTable.new", 
    "    openTable.new(_TCHAR const *tableName, short mode, bool autoCreate, _TCHAR const *ownerName, _TCHAR const *uri)\n"
    "    openTable.new(_TCHAR const *tableName, short mode, bool autoCreate, _TCHAR const *ownerName)\n"
    "    openTable.new(_TCHAR const *tableName, short mode, bool autoCreate)\n"
    "    openTable.new(_TCHAR const *tableName, short mode)\n"
    "    openTable.new(_TCHAR const *tableName)\n"
    "    openTable.new(short fileNum, short mode, bool autoCreate, _TCHAR const *ownerName, _TCHAR const *uri)\n"
    "    openTable.new(short fileNum, short mode, bool autoCreate, _TCHAR const *ownerName)\n"
    "    openTable.new(short fileNum, short mode, bool autoCreate)\n"
    "    openTable.new(short fileNum, short mode)\n"
    "    openTable.new(short fileNum)\n");
  
  return Qnil;
}


static swig_class SwigClassBenchmark;

SWIGINTERN VALUE
_wrap_benchmark_start(int argc, VALUE *argv, VALUE self) {
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      bzs::rtl::benchmark::start();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_benchmark_stop(int argc, VALUE *argv, VALUE self) {
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (int)bzs::rtl::benchmark::stop();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_benchmark_showTimes(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  char *arg2 = (char *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","bzs::rtl::benchmark::showTimes", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","bzs::rtl::benchmark::showTimes", 2, argv[1] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      bzs::rtl::benchmark::showTimes(arg1,(char const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_benchmark_showTimeSec(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  char *arg2 = (char *) 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","bzs::rtl::benchmark::showTimeSec", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","bzs::rtl::benchmark::showTimeSec", 2, argv[1] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      bzs::rtl::benchmark::showTimeSec(arg1,(char const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_benchmark_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_benchmark_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__rtl__benchmark);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_benchmark(int argc, VALUE *argv, VALUE self) {
  bzs::rtl::benchmark *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::rtl::benchmark *)new bzs::rtl::benchmark();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_bzs_rtl_benchmark(bzs::rtl::benchmark *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_charsize(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","bzs::db::protocol::tdap::mysql::charsize", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      result = (unsigned int)bzs::db::protocol::tdap::mysql::charsize(arg1);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_charsetName(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","bzs::db::protocol::tdap::mysql::charsetName", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      result = (char *)bzs::db::protocol::tdap::mysql::charsetName(arg1);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_charsetIndex__SWIG_0(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  unsigned int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","bzs::db::protocol::tdap::mysql::charsetIndex", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (unsigned int)bzs::db::protocol::tdap::mysql::charsetIndex((char const *)arg1);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_charsetIndex__SWIG_1(int argc, VALUE *argv, VALUE self) {
  unsigned short arg1 ;
  unsigned short val1 ;
  int ecode1 = 0 ;
  unsigned int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_short(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned short","bzs::db::protocol::tdap::mysql::charsetIndex", 1, argv[0] ));
  } 
  arg1 = static_cast< unsigned short >(val1);
  {
    try {
      result = (unsigned int)bzs::db::protocol::tdap::mysql::charsetIndex(arg1);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_charsetIndex(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_short(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_charsetIndex__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_charsetIndex__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "charsetIndex", 
    "    unsigned int charsetIndex(char const *name)\n"
    "    unsigned int charsetIndex(unsigned short codePage)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_codePage(int argc, VALUE *argv, VALUE self) {
  unsigned short arg1 ;
  unsigned short val1 ;
  int ecode1 = 0 ;
  unsigned int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_short(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned short","bzs::db::protocol::tdap::mysql::codePage", 1, argv[0] ));
  } 
  arg1 = static_cast< unsigned short >(val1);
  {
    try {
      result = (unsigned int)bzs::db::protocol::tdap::mysql::codePage(arg1);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


static swig_class SwigClassBtrDate;

SWIGINTERN VALUE
_wrap_btrDate_dd_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrDate *arg1 = (bzs::db::protocol::tdap::btrDate *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrDate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrDate *","dd", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrDate * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","dd", 2, argv[0] ));
  } 
  arg2 = static_cast< char >(val2);
  if (arg1) (arg1)->dd = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrDate_dd_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrDate *arg1 = (bzs::db::protocol::tdap::btrDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrDate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrDate *","dd", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrDate * >(argp1);
  result = (char) ((arg1)->dd);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrDate_mm_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrDate *arg1 = (bzs::db::protocol::tdap::btrDate *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrDate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrDate *","mm", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrDate * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","mm", 2, argv[0] ));
  } 
  arg2 = static_cast< char >(val2);
  if (arg1) (arg1)->mm = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrDate_mm_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrDate *arg1 = (bzs::db::protocol::tdap::btrDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrDate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrDate *","mm", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrDate * >(argp1);
  result = (char) ((arg1)->mm);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrDate_yy_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrDate *arg1 = (bzs::db::protocol::tdap::btrDate *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrDate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrDate *","yy", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrDate * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","yy", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  if (arg1) (arg1)->yy = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrDate_yy_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrDate *arg1 = (bzs::db::protocol::tdap::btrDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrDate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrDate *","yy", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrDate * >(argp1);
  result = (short) ((arg1)->yy);
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrDate_i_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrDate *arg1 = (bzs::db::protocol::tdap::btrDate *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrDate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrDate *","i", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrDate * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","i", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->i = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrDate_i_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrDate *arg1 = (bzs::db::protocol::tdap::btrDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrDate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrDate *","i", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrDate * >(argp1);
  result = (int) ((arg1)->i);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_btrDate_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_btrDate_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__btrDate);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_btrDate(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrDate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::btrDate *)new bzs::db::protocol::tdap::btrDate();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_bzs_db_protocol_tdap_btrDate(bzs::db::protocol::tdap::btrDate *arg1) {
    delete arg1;
}

static swig_class SwigClassBtrTime;

SWIGINTERN VALUE
_wrap_btrTime_uu_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrTime *arg1 = (bzs::db::protocol::tdap::btrTime *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrTime *","uu", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrTime * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","uu", 2, argv[0] ));
  } 
  arg2 = static_cast< char >(val2);
  if (arg1) (arg1)->uu = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrTime_uu_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrTime *arg1 = (bzs::db::protocol::tdap::btrTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrTime *","uu", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrTime * >(argp1);
  result = (char) ((arg1)->uu);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrTime_ss_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrTime *arg1 = (bzs::db::protocol::tdap::btrTime *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrTime *","ss", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrTime * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","ss", 2, argv[0] ));
  } 
  arg2 = static_cast< char >(val2);
  if (arg1) (arg1)->ss = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrTime_ss_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrTime *arg1 = (bzs::db::protocol::tdap::btrTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrTime *","ss", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrTime * >(argp1);
  result = (char) ((arg1)->ss);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrTime_nn_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrTime *arg1 = (bzs::db::protocol::tdap::btrTime *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrTime *","nn", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrTime * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","nn", 2, argv[0] ));
  } 
  arg2 = static_cast< char >(val2);
  if (arg1) (arg1)->nn = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrTime_nn_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrTime *arg1 = (bzs::db::protocol::tdap::btrTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrTime *","nn", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrTime * >(argp1);
  result = (char) ((arg1)->nn);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrTime_hh_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrTime *arg1 = (bzs::db::protocol::tdap::btrTime *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrTime *","hh", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrTime * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","hh", 2, argv[0] ));
  } 
  arg2 = static_cast< char >(val2);
  if (arg1) (arg1)->hh = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrTime_hh_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrTime *arg1 = (bzs::db::protocol::tdap::btrTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrTime *","hh", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrTime * >(argp1);
  result = (char) ((arg1)->hh);
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrTime_i_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrTime *arg1 = (bzs::db::protocol::tdap::btrTime *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrTime *","i", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrTime * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","i", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->i = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrTime_i_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrTime *arg1 = (bzs::db::protocol::tdap::btrTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrTime *","i", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrTime * >(argp1);
  result = (int) ((arg1)->i);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_btrTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_btrTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__btrTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_btrTime(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::btrTime *)new bzs::db::protocol::tdap::btrTime();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_bzs_db_protocol_tdap_btrTime(bzs::db::protocol::tdap::btrTime *arg1) {
    delete arg1;
}

static swig_class SwigClassBtrDateTime;

SWIGINTERN VALUE
_wrap_btrDateTime_time_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrDateTime *arg1 = (bzs::db::protocol::tdap::btrDateTime *) 0 ;
  bzs::db::protocol::tdap::btrTime *arg2 = (bzs::db::protocol::tdap::btrTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrDateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrDateTime *","time", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrDateTime * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__btrTime, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrTime *","time", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::btrTime * >(argp2);
  if (arg1) (arg1)->time = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrDateTime_time_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrDateTime *arg1 = (bzs::db::protocol::tdap::btrDateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::btrTime *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrDateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrDateTime *","time", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrDateTime * >(argp1);
  result = (bzs::db::protocol::tdap::btrTime *)& ((arg1)->time);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__btrTime, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrDateTime_date_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrDateTime *arg1 = (bzs::db::protocol::tdap::btrDateTime *) 0 ;
  bzs::db::protocol::tdap::btrDate *arg2 = (bzs::db::protocol::tdap::btrDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrDateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrDateTime *","date", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrDateTime * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__btrDate, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrDate *","date", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::btrDate * >(argp2);
  if (arg1) (arg1)->date = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrDateTime_date_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrDateTime *arg1 = (bzs::db::protocol::tdap::btrDateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::btrDate *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrDateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrDateTime *","date", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrDateTime * >(argp1);
  result = (bzs::db::protocol::tdap::btrDate *)& ((arg1)->date);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__btrDate, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrDateTime_i64_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrDateTime *arg1 = (bzs::db::protocol::tdap::btrDateTime *) 0 ;
  __int64 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrDateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrDateTime *","i64", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrDateTime * >(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "__int64","i64", 2, argv[0] ));
  } 
  arg2 = static_cast< __int64 >(val2);
  if (arg1) (arg1)->i64 = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrDateTime_i64_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrDateTime *arg1 = (bzs::db::protocol::tdap::btrDateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  __int64 result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrDateTime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrDateTime *","i64", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrDateTime * >(argp1);
  result =  ((arg1)->i64);
  vresult = SWIG_From_long_SS_long(static_cast< long long >(result));
  return vresult;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_btrDateTime_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_btrDateTime_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__btrDateTime);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_btrDateTime(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrDateTime *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::btrDateTime *)new bzs::db::protocol::tdap::btrDateTime();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_bzs_db_protocol_tdap_btrDateTime(bzs::db::protocol::tdap::btrDateTime *arg1) {
    delete arg1;
}

static swig_class SwigClassBtrTimeStamp;

SWIGINTERN VALUE
_wrap_btrTimeStamp_i64_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrTimeStamp *arg1 = (bzs::db::protocol::tdap::btrTimeStamp *) 0 ;
  unsigned __int64 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrTimeStamp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrTimeStamp *","i64", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrTimeStamp * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned __int64","i64", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned __int64 >(val2);
  if (arg1) (arg1)->i64 = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrTimeStamp_i64_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrTimeStamp *arg1 = (bzs::db::protocol::tdap::btrTimeStamp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned __int64 result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrTimeStamp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrTimeStamp *","i64", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrTimeStamp * >(argp1);
  result =  ((arg1)->i64);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_btrTimeStamp__SWIG_0(int argc, VALUE *argv, VALUE self) {
  unsigned __int64 arg1 ;
  unsigned long long val1 ;
  int ecode1 = 0 ;
  bzs::db::protocol::tdap::btrTimeStamp *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned __int64","btrTimeStamp", 1, argv[0] ));
  } 
  arg1 = static_cast< unsigned __int64 >(val1);
  {
    try {
      result = (bzs::db::protocol::tdap::btrTimeStamp *)new bzs::db::protocol::tdap::btrTimeStamp(arg1);
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_btrTimeStamp__SWIG_1(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  bzs::db::protocol::tdap::btrTimeStamp *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","btrTimeStamp", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (bzs::db::protocol::tdap::btrTimeStamp *)new bzs::db::protocol::tdap::btrTimeStamp((char const *)arg1);
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return self;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_btrTimeStamp_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_btrTimeStamp_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__btrTimeStamp);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_btrTimeStamp__SWIG_2(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrDate arg1 ;
  bzs::db::protocol::tdap::btrTime arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bzs::db::protocol::tdap::btrTimeStamp *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__btrDate,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrDate","btrTimeStamp", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::btrDate","btrTimeStamp", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< bzs::db::protocol::tdap::btrDate * >(argp1));
    }
  }
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_bzs__db__protocol__tdap__btrTime,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrTime","btrTimeStamp", 2, argv[1] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::btrTime","btrTimeStamp", 2, argv[1]));
    } else {
      arg2 = *(reinterpret_cast< bzs::db::protocol::tdap::btrTime * >(argp2));
    }
  }
  {
    try {
      result = (bzs::db::protocol::tdap::btrTimeStamp *)new bzs::db::protocol::tdap::btrTimeStamp(arg1,arg2);
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_btrTimeStamp(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_btrTimeStamp__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_btrTimeStamp__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__btrDate, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__btrTime, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_btrTimeStamp__SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "btrTimeStamp.new", 
    "    btrTimeStamp.new(unsigned __int64 i)\n"
    "    btrTimeStamp.new(char const *p)\n"
    "    btrTimeStamp.new(bzs::db::protocol::tdap::btrDate d, bzs::db::protocol::tdap::btrTime t)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrTimeStamp_toString(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrTimeStamp *arg1 = (bzs::db::protocol::tdap::btrTimeStamp *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char tmpbuf2[255] ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  {
    arg2=tmpbuf2; 
  }
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrTimeStamp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrTimeStamp *","toString", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrTimeStamp * >(argp1);
  {
    try {
      result = (char *)(arg1)->toString(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrTimeStamp_fromString(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrTimeStamp *arg1 = (bzs::db::protocol::tdap::btrTimeStamp *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__btrTimeStamp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrTimeStamp *","fromString", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrTimeStamp * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","fromString", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->fromString((char const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN void
free_bzs_db_protocol_tdap_btrTimeStamp(bzs::db::protocol::tdap::btrTimeStamp *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_atobtrd(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  bzs::db::protocol::tdap::btrDate result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","bzs::db::protocol::tdap::atobtrd", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = bzs::db::protocol::tdap::atobtrd((char const *)arg1);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj((new bzs::db::protocol::tdap::btrDate(static_cast< const bzs::db::protocol::tdap::btrDate& >(result))), SWIGTYPE_p_bzs__db__protocol__tdap__btrDate, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrdtoa__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrDate *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  char tmpbuf2[255] ;
  bool val3 ;
  int ecode3 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  {
    arg2=tmpbuf2; 
  }
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__btrDate,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrDate const &","bzs::db::protocol::tdap::btrdtoa", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::btrDate const &","bzs::db::protocol::tdap::btrdtoa", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrDate * >(argp1);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","bzs::db::protocol::tdap::btrdtoa", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (char *)bzs::db::protocol::tdap::btrdtoa((bzs::db::protocol::tdap::btrDate const &)*arg1,arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrdtoa__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrDate *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  char tmpbuf2[255] ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  {
    arg2=tmpbuf2; 
  }
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__btrDate,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrDate const &","bzs::db::protocol::tdap::btrdtoa", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::btrDate const &","bzs::db::protocol::tdap::btrdtoa", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrDate * >(argp1);
  {
    try {
      result = (char *)bzs::db::protocol::tdap::btrdtoa((bzs::db::protocol::tdap::btrDate const &)*arg1,arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrttoa__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrTime *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  char tmpbuf2[255] ;
  bool val3 ;
  int ecode3 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  {
    arg2=tmpbuf2; 
  }
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__btrTime,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrTime const &","bzs::db::protocol::tdap::btrttoa", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::btrTime const &","bzs::db::protocol::tdap::btrttoa", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrTime * >(argp1);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","bzs::db::protocol::tdap::btrttoa", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (char *)bzs::db::protocol::tdap::btrttoa((bzs::db::protocol::tdap::btrTime const &)*arg1,arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrttoa__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrTime *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  char tmpbuf2[255] ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  {
    arg2=tmpbuf2; 
  }
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__btrTime,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrTime const &","bzs::db::protocol::tdap::btrttoa", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::btrTime const &","bzs::db::protocol::tdap::btrttoa", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrTime * >(argp1);
  {
    try {
      result = (char *)bzs::db::protocol::tdap::btrttoa((bzs::db::protocol::tdap::btrTime const &)*arg1,arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_atobtrt(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  bzs::db::protocol::tdap::btrTime result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","bzs::db::protocol::tdap::atobtrt", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = bzs::db::protocol::tdap::atobtrt((char const *)arg1);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj((new bzs::db::protocol::tdap::btrTime(static_cast< const bzs::db::protocol::tdap::btrTime& >(result))), SWIGTYPE_p_bzs__db__protocol__tdap__btrTime, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrdtoa__SWIG_2(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  char *arg2 = (char *) 0 ;
  bool arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  char tmpbuf2[255] ;
  bool val3 ;
  int ecode3 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  {
    arg2=tmpbuf2; 
  }
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","bzs::db::protocol::tdap::btrdtoa", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","bzs::db::protocol::tdap::btrdtoa", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (char *)bzs::db::protocol::tdap::btrdtoa(arg1,arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrdtoa__SWIG_3(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  char *arg2 = (char *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  char tmpbuf2[255] ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  {
    arg2=tmpbuf2; 
  }
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","bzs::db::protocol::tdap::btrdtoa", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      result = (char *)bzs::db::protocol::tdap::btrdtoa(arg1,arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_btrdtoa(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__btrDate, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_btrdtoa__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_btrdtoa__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__btrDate, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_btrdtoa__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_btrdtoa__SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "btrdtoa", 
    "    char const * btrdtoa(bzs::db::protocol::tdap::btrDate const &d, char *retbuf, bool type_vb)\n"
    "    char const * btrdtoa(bzs::db::protocol::tdap::btrDate const &d, char *retbuf)\n"
    "    char const * btrdtoa(int date, char *retbuf, bool type_vb)\n"
    "    char const * btrdtoa(int date, char *retbuf)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrttoa__SWIG_2(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  char *arg2 = (char *) 0 ;
  bool arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  char tmpbuf2[255] ;
  bool val3 ;
  int ecode3 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  {
    arg2=tmpbuf2; 
  }
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","bzs::db::protocol::tdap::btrttoa", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","bzs::db::protocol::tdap::btrttoa", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (char *)bzs::db::protocol::tdap::btrttoa(arg1,arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrttoa__SWIG_3(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  char *arg2 = (char *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  char tmpbuf2[255] ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  {
    arg2=tmpbuf2; 
  }
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","bzs::db::protocol::tdap::btrttoa", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      result = (char *)bzs::db::protocol::tdap::btrttoa(arg1,arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_btrttoa(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__btrTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_btrttoa__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_btrttoa__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__btrTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_btrttoa__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_btrttoa__SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "btrttoa", 
    "    char const * btrttoa(bzs::db::protocol::tdap::btrTime const &t, char *retbuf, bool type_vb)\n"
    "    char const * btrttoa(bzs::db::protocol::tdap::btrTime const &t, char *retbuf)\n"
    "    char const * btrttoa(int time, char *retbuf, bool type_vb)\n"
    "    char const * btrttoa(int time, char *retbuf)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrstoa__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrDateTime *arg1 = 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  char tmpbuf2[255] ;
  bool val3 ;
  int ecode3 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  {
    arg2=tmpbuf2; 
  }
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__btrDateTime,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrDateTime const &","bzs::db::protocol::tdap::btrstoa", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::btrDateTime const &","bzs::db::protocol::tdap::btrstoa", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrDateTime * >(argp1);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","bzs::db::protocol::tdap::btrstoa", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (_TCHAR *)bzs::db::protocol::tdap::btrstoa((bzs::db::protocol::tdap::btrDateTime const &)*arg1,arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrstoa__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrDateTime *arg1 = 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  char tmpbuf2[255] ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  {
    arg2=tmpbuf2; 
  }
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__btrDateTime,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrDateTime const &","bzs::db::protocol::tdap::btrstoa", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::btrDateTime const &","bzs::db::protocol::tdap::btrstoa", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrDateTime * >(argp1);
  {
    try {
      result = (_TCHAR *)bzs::db::protocol::tdap::btrstoa((bzs::db::protocol::tdap::btrDateTime const &)*arg1,arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_btrstoa__SWIG_2(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::btrDateTime *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__btrDateTime,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::btrDateTime const &","bzs::db::protocol::tdap::btrstoa", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::btrDateTime const &","bzs::db::protocol::tdap::btrstoa", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::btrDateTime * >(argp1);
  {
    try {
      result = (_TCHAR *)bzs::db::protocol::tdap::btrstoa((bzs::db::protocol::tdap::btrDateTime const &)*arg1);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_btrstoa(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__btrDateTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_btrstoa__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__btrDateTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_btrstoa__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__btrDateTime, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_btrstoa__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "btrstoa", 
    "    _TCHAR const * btrstoa(bzs::db::protocol::tdap::btrDateTime const &d, _TCHAR *retbuf, bool type_vb)\n"
    "    _TCHAR const * btrstoa(bzs::db::protocol::tdap::btrDateTime const &d, _TCHAR *retbuf)\n"
    "    _TCHAR const * btrstoa(bzs::db::protocol::tdap::btrDateTime const &d)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_atobtrs(int argc, VALUE *argv, VALUE self) {
  _TCHAR *arg1 = (_TCHAR *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  bzs::db::protocol::tdap::btrDateTime result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_TCHAR const *","bzs::db::protocol::tdap::atobtrs", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< _TCHAR * >(buf1);
  {
    try {
      result = bzs::db::protocol::tdap::atobtrs((char const *)arg1);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj((new bzs::db::protocol::tdap::btrDateTime(static_cast< const bzs::db::protocol::tdap::btrDateTime& >(result))), SWIGTYPE_p_bzs__db__protocol__tdap__btrDateTime, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_getNowDate(int argc, VALUE *argv, VALUE self) {
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (int)bzs::db::protocol::tdap::getNowDate();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_getNowTime(int argc, VALUE *argv, VALUE self) {
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (int)bzs::db::protocol::tdap::getNowTime();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


static swig_class SwigClassFielddefs;


/*
  Document-method: Transactd::fielddefs.clone

  call-seq:
    clone -> fielddefs

Create a duplicate of the class.
*/
SWIGINTERN VALUE
_wrap_fielddefs_clone(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fielddefs *arg1 = (bzs::db::protocol::tdap::client::fielddefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::fielddefs *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fielddefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fielddefs const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fielddefs * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::fielddefs *)((bzs::db::protocol::tdap::client::fielddefs const *)arg1)->clone();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__fielddefs, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddefs_indexByName(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fielddefs *arg1 = (bzs::db::protocol::tdap::client::fielddefs *) 0 ;
  std::_tstring *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fielddefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fielddefs const *","indexByName", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fielddefs * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std___tstring,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::_tstring const &","indexByName", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::_tstring const &","indexByName", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< std::_tstring * >(argp2);
  {
    try {
      result = (int)((bzs::db::protocol::tdap::client::fielddefs const *)arg1)->indexByName((std::_tstring const &)*arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddefs___getitem____SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fielddefs *arg1 = (bzs::db::protocol::tdap::client::fielddefs *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bzs::db::protocol::tdap::fielddef *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fielddefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fielddefs const *","operator []", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fielddefs * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","operator []", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (bzs::db::protocol::tdap::fielddef *) &((bzs::db::protocol::tdap::client::fielddefs const *)arg1)->operator [](arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddefs___getitem____SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fielddefs *arg1 = (bzs::db::protocol::tdap::client::fielddefs *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bzs::db::protocol::tdap::fielddef *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fielddefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fielddefs const *","operator []", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fielddefs * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","operator []", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (bzs::db::protocol::tdap::fielddef *) &((bzs::db::protocol::tdap::client::fielddefs const *)arg1)->operator []((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_fielddefs___getitem__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__fielddefs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_fielddefs___getitem____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__fielddefs, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_fielddefs___getitem____SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "fielddefs.__getitem__", 
    "    bzs::db::protocol::tdap::fielddef const & fielddefs.__getitem__(int index)\n"
    "    bzs::db::protocol::tdap::fielddef const & fielddefs.__getitem__(_TCHAR const *name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fielddefs_checkIndex(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fielddefs *arg1 = (bzs::db::protocol::tdap::client::fielddefs *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fielddefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fielddefs const *","checkIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fielddefs * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","checkIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::client::fielddefs const *)arg1)->checkIndex(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Transactd::fielddefs.size

  call-seq:
    size -> size_t

Size or Length of the fielddefs.
*/
SWIGINTERN VALUE
_wrap_fielddefs_size(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fielddefs *arg1 = (bzs::db::protocol::tdap::client::fielddefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fielddefs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fielddefs const *","size", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fielddefs * >(argp1);
  {
    try {
      result = ((bzs::db::protocol::tdap::client::fielddefs const *)arg1)->size();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_fielddefs_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_fielddefs_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__client__fielddefs);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_fielddefs(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fielddefs *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::client::fielddefs *)new_bzs_db_protocol_tdap_client_fielddefs();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void delete_bzs_db_protocol_tdap_client_fielddefs(bzs::db::protocol::tdap::client::fielddefs *self){
    self->release();
  }
SWIGINTERN void
free_bzs_db_protocol_tdap_client_fielddefs(bzs::db::protocol::tdap::client::fielddefs *arg1) {
    delete_bzs_db_protocol_tdap_client_fielddefs(arg1);
}

static swig_class SwigClassField;

SWIGINTERN VALUE
_wrap_new_field__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::field *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::client::field *)new bzs::db::protocol::tdap::client::field();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_field__SWIG_1(int argc, VALUE *argv, VALUE self) {
  unsigned char *arg1 = (unsigned char *) 0 ;
  bzs::db::protocol::tdap::fielddef *arg2 = 0 ;
  bzs::db::protocol::tdap::client::fielddefs *arg3 = (bzs::db::protocol::tdap::client::fielddefs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bzs::db::protocol::tdap::client::field *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "unsigned char *","field", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< unsigned char * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_bzs__db__protocol__tdap__fielddef,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::fielddef const &","field", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::fielddef const &","field", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::fielddef * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_bzs__db__protocol__tdap__client__fielddefs, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fielddefs *","field", 3, argv[2] )); 
  }
  arg3 = reinterpret_cast< bzs::db::protocol::tdap::client::fielddefs * >(argp3);
  {
    try {
      result = (bzs::db::protocol::tdap::client::field *)new bzs::db::protocol::tdap::client::field(arg1,(bzs::db::protocol::tdap::fielddef const &)*arg2,arg3);
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_field_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_field_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__client__field);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_field__SWIG_2(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::field *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::field *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__field,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::field const &","field", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::field const &","field", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::field * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::field *)new bzs::db::protocol::tdap::client::field((bzs::db::protocol::tdap::client::field const &)*arg1);
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_field(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_field__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__field, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_field__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_char, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__fielddefs, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_field__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "field.new", 
    "    field.new()\n"
    "    field.new(unsigned char *ptr, bzs::db::protocol::tdap::fielddef const &fd, bzs::db::protocol::tdap::client::fielddefs *fds)\n"
    "    field.new(bzs::db::protocol::tdap::client::field const &r)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_field_type(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::field *arg1 = (bzs::db::protocol::tdap::client::field *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__field, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::field const *","type", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::field * >(argp1);
  {
    try {
      result = (unsigned char)((bzs::db::protocol::tdap::client::field const *)arg1)->type();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_field_len(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::field *arg1 = (bzs::db::protocol::tdap::client::field *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__field, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::field const *","len", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::field * >(argp1);
  {
    try {
      result = (unsigned short)((bzs::db::protocol::tdap::client::field const *)arg1)->len();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_field_c_str(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::field *arg1 = (bzs::db::protocol::tdap::client::field *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__field, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::field const *","c_str", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::field * >(argp1);
  {
    try {
      result = (_TCHAR *)((bzs::db::protocol::tdap::client::field const *)arg1)->c_str();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_field_a_str(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::field *arg1 = (bzs::db::protocol::tdap::client::field *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__field, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::field const *","a_str", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::field * >(argp1);
  {
    try {
      result = (char *)((bzs::db::protocol::tdap::client::field const *)arg1)->a_str();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_field_i(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::field *arg1 = (bzs::db::protocol::tdap::client::field *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__field, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::field const *","i", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::field * >(argp1);
  {
    try {
      result = (int)((bzs::db::protocol::tdap::client::field const *)arg1)->i();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_field_i8(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::field *arg1 = (bzs::db::protocol::tdap::client::field *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__field, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::field const *","i8", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::field * >(argp1);
  {
    try {
      result = (int)((bzs::db::protocol::tdap::client::field const *)arg1)->i8();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_field_i16(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::field *arg1 = (bzs::db::protocol::tdap::client::field *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__field, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::field const *","i16", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::field * >(argp1);
  {
    try {
      result = (short)((bzs::db::protocol::tdap::client::field const *)arg1)->i16();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_field_i64(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::field *arg1 = (bzs::db::protocol::tdap::client::field *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  __int64 result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__field, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::field const *","i64", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::field * >(argp1);
  {
    try {
      result = ((bzs::db::protocol::tdap::client::field const *)arg1)->i64();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_long_SS_long(static_cast< long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_field_f(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::field *arg1 = (bzs::db::protocol::tdap::client::field *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__field, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::field const *","f", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::field * >(argp1);
  {
    try {
      result = (float)((bzs::db::protocol::tdap::client::field const *)arg1)->f();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_field_d(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::field *arg1 = (bzs::db::protocol::tdap::client::field *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__field, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::field const *","d", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::field * >(argp1);
  {
    try {
      result = (double)((bzs::db::protocol::tdap::client::field const *)arg1)->d();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_field___setitem__(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::field *arg1 = (bzs::db::protocol::tdap::client::field *) 0 ;
  void *arg2 = (void *) 0 ;
  uint_td arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__field, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::field *","setBin", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::field * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","setBin", 2, argv[0] )); 
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "uint_td","setBin", 3, argv[1] ));
  } 
  arg3 = static_cast< uint_td >(val3);
  {
    try {
      (arg1)->setBin((void const *)arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_field_getBin(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::field *arg1 = (bzs::db::protocol::tdap::client::field *) 0 ;
  uint_td *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint_td temp2 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  {
    arg2 = &temp2;
  }
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__field, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::field *","getBin", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::field * >(argp1);
  {
    try {
      result = (void *)(arg1)->getBin(*arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  {
    vresult = rb_str_new((const char *)result, *arg2);
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_field_comp__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::field *arg1 = (bzs::db::protocol::tdap::client::field *) 0 ;
  bzs::db::protocol::tdap::client::field *arg2 = 0 ;
  char arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__field, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::field const *","comp", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::field * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_bzs__db__protocol__tdap__client__field,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::field const &","comp", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::field const &","comp", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::field * >(argp2);
  ecode3 = SWIG_AsVal_char(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "char","comp", 3, argv[1] ));
  } 
  arg3 = static_cast< char >(val3);
  {
    try {
      result = (int)((bzs::db::protocol::tdap::client::field const *)arg1)->comp((bzs::db::protocol::tdap::client::field const &)*arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_field_comp__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::field *arg1 = (bzs::db::protocol::tdap::client::field *) 0 ;
  bzs::db::protocol::tdap::client::field *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__field, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::field const *","comp", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::field * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_bzs__db__protocol__tdap__client__field,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::field const &","comp", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::field const &","comp", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::field * >(argp2);
  {
    try {
      result = (int)((bzs::db::protocol::tdap::client::field const *)arg1)->comp((bzs::db::protocol::tdap::client::field const &)*arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_field_comp(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__field, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__field, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_field_comp__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__field, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__field, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_field_comp__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "field.comp", 
    "    int field.comp(bzs::db::protocol::tdap::client::field const &r, char logType)\n"
    "    int field.comp(bzs::db::protocol::tdap::client::field const &r)\n");
  
  return Qnil;
}


SWIGINTERN void
free_bzs_db_protocol_tdap_client_field(bzs::db::protocol::tdap::client::field *arg1) {
    delete arg1;
}

static swig_class SwigClassRecord;

SWIGINTERN void
free_bzs_db_protocol_tdap_client_fieldsBase(bzs::db::protocol::tdap::client::fieldsBase *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Record_isInvalidRecord(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldsBase *arg1 = (bzs::db::protocol::tdap::client::fieldsBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldsBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldsBase const *","isInvalidRecord", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldsBase * >(argp1);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::client::fieldsBase const *)arg1)->isInvalidRecord();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Record_getField__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldsBase *arg1 = (bzs::db::protocol::tdap::client::fieldsBase *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  bzs::db::protocol::tdap::client::field result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldsBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldsBase const *","operator []", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldsBase * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","operator []", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      result = ((bzs::db::protocol::tdap::client::fieldsBase const *)arg1)->operator [](arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj((new bzs::db::protocol::tdap::client::field(static_cast< const bzs::db::protocol::tdap::client::field& >(result))), SWIGTYPE_p_bzs__db__protocol__tdap__client__field, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Record_getField__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldsBase *arg1 = (bzs::db::protocol::tdap::client::fieldsBase *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bzs::db::protocol::tdap::client::field result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldsBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldsBase const *","operator []", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldsBase * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","operator []", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = ((bzs::db::protocol::tdap::client::fieldsBase const *)arg1)->operator []((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj((new bzs::db::protocol::tdap::client::field(static_cast< const bzs::db::protocol::tdap::client::field& >(result))), SWIGTYPE_p_bzs__db__protocol__tdap__client__field, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Record_getField(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldsBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Record_getField__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldsBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Record_getField__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Record.getField", 
    "    bzs::db::protocol::tdap::client::field Record.getField(short index)\n"
    "    bzs::db::protocol::tdap::client::field Record.getField(_TCHAR const *name)\n");
  
  return Qnil;
}



/*
  Document-method: Transactd::Record.size

  call-seq:
    size -> size_t

Size or Length of the Record.
*/
SWIGINTERN VALUE
_wrap_Record_size(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldsBase *arg1 = (bzs::db::protocol::tdap::client::fieldsBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldsBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldsBase const *","size", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldsBase * >(argp1);
  {
    try {
      result = ((bzs::db::protocol::tdap::client::fieldsBase const *)arg1)->size();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Record_indexByName(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldsBase *arg1 = (bzs::db::protocol::tdap::client::fieldsBase *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldsBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldsBase const *","indexByName", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldsBase * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","indexByName", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (short)((bzs::db::protocol::tdap::client::fieldsBase const *)arg1)->indexByName((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Record_fieldDefs(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldsBase *arg1 = (bzs::db::protocol::tdap::client::fieldsBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::fielddefs *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldsBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldsBase const *","fieldDefs", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldsBase * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::fielddefs *)((bzs::db::protocol::tdap::client::fieldsBase const *)arg1)->fieldDefs();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__fielddefs, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Record_clear(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldsBase *arg1 = (bzs::db::protocol::tdap::client::fieldsBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldsBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldsBase *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldsBase * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Transactd::Record.[]

  call-seq:
    [](fieldsBase_getitem_index)
    [](fieldsBase_getitem_index)

Element accessor/slicing.
*/
SWIGINTERN VALUE
_wrap_Record___getitem____SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldsBase *arg1 = (bzs::db::protocol::tdap::client::fieldsBase *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldsBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldsBase const *","__getitem__", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldsBase * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","__getitem__", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      bzs_db_protocol_tdap_client_fieldsBase___getitem____SWIG_0((bzs::db::protocol::tdap::client::fieldsBase const *)arg1,arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    bzs::db::protocol::tdap::client::field f = arg1->operator[](arg2);
    __int64 tmp_i64;
    double tmp_d;
    const _TCHAR* tmp_c_str;
    switch (f.type()) {
    case ft_integer:
    case ft_uinteger:
    case ft_autoinc:
    case ft_autoIncUnsigned:
    case ft_logical:
    case ft_bit:
      tmp_i64 = f.i64();
      vresult = SWIG_From_long_SS_long(static_cast< long long >(tmp_i64));
      break;
    case ft_float:
    case ft_decimal:
    case ft_money:
    case ft_numeric:
    case ft_bfloat:
    case ft_numericsts:
    case ft_numericsa:
    case ft_currency:
      tmp_d = f.d();
      vresult = SWIG_From_double(static_cast< double >(tmp_d));
      break;
    default:
      tmp_c_str = f.c_str();
      vresult = rb_enc_str_new(tmp_c_str, strlen(tmp_c_str), rb_enc_find_from_codepage(CP_UTF8));
    }
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Record___getitem____SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldsBase *arg1 = (bzs::db::protocol::tdap::client::fieldsBase *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldsBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldsBase const *","__getitem__", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldsBase * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","__getitem__", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      bzs_db_protocol_tdap_client_fieldsBase___getitem____SWIG_1((bzs::db::protocol::tdap::client::fieldsBase const *)arg1,(char const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    bzs::db::protocol::tdap::client::field f = arg1->operator[](arg2);
    __int64 tmp_i64;
    double tmp_d;
    const _TCHAR* tmp_c_str;
    switch (f.type()) {
    case ft_integer:
    case ft_uinteger:
    case ft_autoinc:
    case ft_autoIncUnsigned:
    case ft_logical:
    case ft_bit:
      tmp_i64 = f.i64();
      vresult = SWIG_From_long_SS_long(static_cast< long long >(tmp_i64));
      break;
    case ft_float:
    case ft_decimal:
    case ft_money:
    case ft_numeric:
    case ft_bfloat:
    case ft_numericsts:
    case ft_numericsa:
    case ft_currency:
      tmp_d = f.d();
      vresult = SWIG_From_double(static_cast< double >(tmp_d));
      break;
    default:
      tmp_c_str = f.c_str();
      vresult = rb_enc_str_new(tmp_c_str, strlen(tmp_c_str), rb_enc_find_from_codepage(CP_UTF8));
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Record___getitem__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldsBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Record___getitem____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldsBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Record___getitem____SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__getitem__", 
    "    void __getitem__(short fieldsBase_getitem_index)\n"
    "    void __getitem__(_TCHAR const *fieldsBase_getitem_index)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Record_getFieldByIndexRef(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldsBase *arg1 = (bzs::db::protocol::tdap::client::fieldsBase *) 0 ;
  short arg2 ;
  bzs::db::protocol::tdap::client::field *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldsBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldsBase const *","getFieldByIndexRef", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldsBase * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","getFieldByIndexRef", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_bzs__db__protocol__tdap__client__field,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::field &","getFieldByIndexRef", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::field &","getFieldByIndexRef", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< bzs::db::protocol::tdap::client::field * >(argp3);
  {
    try {
      bzs_db_protocol_tdap_client_fieldsBase_getFieldByIndexRef((bzs::db::protocol::tdap::client::fieldsBase const *)arg1,arg2,*arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Record_getFieldByNameRef(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldsBase *arg1 = (bzs::db::protocol::tdap::client::fieldsBase *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  bzs::db::protocol::tdap::client::field *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldsBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldsBase const *","getFieldByNameRef", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldsBase * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","getFieldByNameRef", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_bzs__db__protocol__tdap__client__field,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::field &","getFieldByNameRef", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::field &","getFieldByNameRef", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< bzs::db::protocol::tdap::client::field * >(argp3);
  {
    try {
      bzs_db_protocol_tdap_client_fieldsBase_getFieldByNameRef((bzs::db::protocol::tdap::client::fieldsBase const *)arg1,(char const *)arg2,*arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}

static swig_class SwigClassWritableRecord;


SWIGINTERN VALUE
_wrap_writableRecord_read__SWIG_0(int argc, VALUE *argv, VALUE self) {
    bzs::db::protocol::tdap::client::writableRecord *arg1 = (bzs::db::protocol::tdap::client::writableRecord *) 0;
    bool arg2;
    void *argp1 = 0;
    int res1 = 0;
    bool val2;
    int ecode2 = 0;
    bool result;
    VALUE vresult = Qnil;

    if ((argc < 1) || (argc > 1)) {
        rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)", argc); SWIG_fail;
    }
    res1 = SWIG_ConvertPtr(self, &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__writableRecord, 0 | 0);
    if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError("", "bzs::db::protocol::tdap::client::writableRecord *", "read", 1, self));
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::writableRecord * >(argp1);
    ecode2 = SWIG_AsVal_bool(argv[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError("", "bool", "read", 2, argv[0]));
    }
    arg2 = static_cast< bool >(val2);
    {
        try {
            result = (bool)(arg1)->read(arg2);
        }
        catch (bzs::rtl::exception& e) {
            static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
            rb_raise(bzs_rtl_error, (*bzs::rtl::getMsg(e)).c_str());
        }
        catch (std::exception &e) {
            static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
            rb_raise(cpp_std_error, e.what());
        }
    }
    vresult = SWIG_From_bool(static_cast< bool >(result));
    return vresult;
fail:
    return Qnil;
}


SWIGINTERN VALUE
_wrap_writableRecord_read__SWIG_1(int argc, VALUE *argv, VALUE self) {
    bzs::db::protocol::tdap::client::writableRecord *arg1 = (bzs::db::protocol::tdap::client::writableRecord *) 0;
    void *argp1 = 0;
    int res1 = 0;
    bool result;
    VALUE vresult = Qnil;

    if ((argc < 0) || (argc > 0)) {
        rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)", argc); SWIG_fail;
    }
    res1 = SWIG_ConvertPtr(self, &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__writableRecord, 0 | 0);
    if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError("", "bzs::db::protocol::tdap::client::writableRecord *", "read", 1, self));
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::writableRecord * >(argp1);
    {
        try {
            result = (bool)(arg1)->read();
        }
        catch (bzs::rtl::exception& e) {
            static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
            rb_raise(bzs_rtl_error, (*bzs::rtl::getMsg(e)).c_str());
        }
        catch (std::exception &e) {
            static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
            rb_raise(cpp_std_error, e.what());
        }
    }
    vresult = SWIG_From_bool(static_cast< bool >(result));
    return vresult;
fail:
    return Qnil;
}


SWIGINTERN VALUE
_wrap_writableRecord_read__SWIG_2(int argc, VALUE *argv, VALUE self) {
    bzs::db::protocol::tdap::client::writableRecord *arg1 = (bzs::db::protocol::tdap::client::writableRecord *) 0;
    bookmark_td *arg2 = 0;
    void *argp1 = 0;
    int res1 = 0;
    void *argp2 = 0;
    int res2 = 0;
    bool result;
    VALUE vresult = Qnil;

    if ((argc < 1) || (argc > 1)) {
        rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)", argc); SWIG_fail;
    }
    res1 = SWIG_ConvertPtr(self, &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__writableRecord, 0 | 0);
    if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError("", "bzs::db::protocol::tdap::client::writableRecord *", "read", 1, self));
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::writableRecord * >(argp1);
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_BOOKMARK, 0);
    if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError("", "bookmark_td &", "read", 2, argv[0]));
    }
    if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bookmark_td &", "read", 2, argv[0]));
    }
    arg2 = reinterpret_cast< bookmark_td * >(argp2);
    {
        try {
            result = (bool)(arg1)->read(*arg2);
        }
        catch (bzs::rtl::exception& e) {
            static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
            rb_raise(bzs_rtl_error, (*bzs::rtl::getMsg(e)).c_str());
        }
        catch (std::exception &e) {
            static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
            rb_raise(cpp_std_error, e.what());
        }
    }
    vresult = SWIG_From_bool(static_cast< bool >(result));
    return vresult;
fail:
    return Qnil;
}


SWIGINTERN VALUE _wrap_writableRecord_read(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[3];
    int ii;

    argc = nargs + 1;
    argv[0] = self;
    if (argc > 3) SWIG_fail;
    for (ii = 1; (ii < argc); ++ii) {
        argv[ii] = args[ii - 1];
    }
    if (argc == 1) {
        int _v;
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__writableRecord, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
            return _wrap_writableRecord_read__SWIG_1(nargs, args, self);
        }
    }
    if (argc == 2) {
        int _v;
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__writableRecord, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_BOOKMARK, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
                return _wrap_writableRecord_read__SWIG_2(nargs, args, self);
            }
        }
    }
    if (argc == 2) {
        int _v;
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__writableRecord, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
            {
                int res = SWIG_AsVal_bool(argv[1], NULL);
                _v = SWIG_CheckState(res);
            }
            if (_v) {
                return _wrap_writableRecord_read__SWIG_0(nargs, args, self);
            }
        }
    }

fail:
    Ruby_Format_OverloadedError(argc, 3, "writableRecord.read",
        "    bool writableRecord.read(bool KeysetAlrady)\n"
        "    bool writableRecord.read()\n"
        "    bool writableRecord.read(bookmark_td &bm)\n");

    return Qnil;
}


/*
  Document-method: Transactd::writableRecord.insert

  call-seq:
    insert

Insert one or more new elements in the writableRecord.
*/
SWIGINTERN VALUE
_wrap_writableRecord_insert(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::writableRecord *arg1 = (bzs::db::protocol::tdap::client::writableRecord *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__writableRecord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::writableRecord *","insert", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::writableRecord * >(argp1);
  {
    try {
      (arg1)->insert();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_writableRecord_del__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::writableRecord *arg1 = (bzs::db::protocol::tdap::client::writableRecord *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__writableRecord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::writableRecord *","del", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::writableRecord * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","del", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      (arg1)->del(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_writableRecord_del__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::writableRecord *arg1 = (bzs::db::protocol::tdap::client::writableRecord *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__writableRecord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::writableRecord *","del", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::writableRecord * >(argp1);
  {
    try {
      (arg1)->del();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_writableRecord_del(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__writableRecord, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_writableRecord_del__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__writableRecord, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_writableRecord_del__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "writableRecord.del", 
    "    void writableRecord.del(bool KeysetAlrady)\n"
    "    void writableRecord.del()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_writableRecord_update(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::writableRecord *arg1 = (bzs::db::protocol::tdap::client::writableRecord *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__writableRecord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::writableRecord *","update", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::writableRecord * >(argp1);
  {
    try {
      (arg1)->update();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_writableRecord_save(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::writableRecord *arg1 = (bzs::db::protocol::tdap::client::writableRecord *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__writableRecord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::writableRecord *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::writableRecord * >(argp1);
  {
    try {
      (arg1)->save();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_writableRecord___setitem__(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::writableRecord *arg1 = 0x00;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int index ;
  
  if ((argc > 2) || (argc < 2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__writableRecord, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::writableRecord const *","__setitem__", 1, self )); 
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::writableRecord * >(argp1);
  }
  {
    VALUE type = TYPE(argv[0]);
    if ((type == T_FIXNUM) || (type == T_BIGNUM)){
        int ecode = SWIG_AsVal_unsigned_SS_int(argv[0], &index);
        if (!SWIG_IsOK(ecode)) {
          SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "uint_td","__setitem__", 2, argv[0] ));
        }
    }else if (type == T_STRING){
        SWIG_CHAR buf;
        int ret = SWIG_AsCharPtrAndSize(argv[0], &buf.str, NULL, &buf.alloc);
      if (!SWIG_IsOK(ret)) {
        SWIG_exception_fail(SWIG_ArgError(ret), Ruby_Format_TypeError( "", "char *const","__setitem__", 2, argv[0]));
      }
      try {
          index = arg1->indexByName(buf.str);
      }
      catch (bzs::rtl::exception& e) {
        static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
        rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
      } catch (std::exception &e) {
        static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
        rb_raise(cpp_std_error, e.what());
      }
    }else
      SWIG_exception_fail(SWIG_TypeError, Ruby_Format_TypeError( "", "int or char *const ","__setitem__", 2, argv[0]));
  }
  
  {
    try {
      VALUE type = TYPE(argv[1]);
      if ((type == T_FIXNUM) || (type == T_BIGNUM)){
        long long v = 0;
        int ecode = SWIG_AsVal_long_SS_long(argv[1], &v);
        if (!SWIG_IsOK(ecode)) {
          SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "__int64","__setitem__", 3, argv[1]));
        }
        arg1->operator[]((short)index) = v;
      }
      else if (type == T_STRING){
          SWIG_CHAR buf;
          int ret = SWIG_AsCharPtrAndSize(argv[1], &buf.str, NULL, &buf.alloc);
        if (!SWIG_IsOK(ret)) {
          SWIG_exception_fail(SWIG_ArgError(ret), Ruby_Format_TypeError( "", "char *const","__setitem__", 3, argv[1]));
        }
        arg1->operator[]((short)index) = buf.str;
      }
      else if (type == T_FLOAT){
        double v = 0;
        int ecode = SWIG_AsVal_double(argv[1], &v);
        if (!SWIG_IsOK(ecode)) {
          SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "double","__setitem__", 3, argv[1]));
        }
        arg1->operator[]((short)index) = v;
      }
      else{
        SWIG_exception_fail(SWIG_TypeError, Ruby_Format_TypeError( "", "__int64 or char *const or double","__setitem__", 3, argv[1]));
      }
    }
    catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;

fail:
  return Qnil;
}


static swig_class SwigClassConnectParams;

SWIGINTERN VALUE
_wrap_new_connectParams__SWIG_0(int argc, VALUE *argv, VALUE self) {
  _TCHAR *arg1 = (_TCHAR *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  _TCHAR *arg3 = (_TCHAR *) 0 ;
  _TCHAR *arg4 = (_TCHAR *) 0 ;
  _TCHAR *arg5 = (_TCHAR *) 0 ;
  _TCHAR *arg6 = (_TCHAR *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  bzs::db::protocol::tdap::client::connectParams *result = 0 ;
  
  if ((argc < 4) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4 to 6)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_TCHAR const *","connectParams", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< _TCHAR * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","connectParams", 2, argv[1] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "_TCHAR const *","connectParams", 3, argv[2] ));
  }
  arg3 = reinterpret_cast< _TCHAR * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "_TCHAR const *","connectParams", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< _TCHAR * >(buf4);
  if (argc > 4) {
      res5 = SWIG_AsCharPtrAndSize(argv[4], &buf5, NULL, &alloc5);
      if (!SWIG_IsOK(res5)) {
        SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "_TCHAR const *","connectParams", 5, argv[4] ));
      }
      arg5 = reinterpret_cast< _TCHAR * >(buf5);
  }
  if (argc > 5) {
      res6 = SWIG_AsCharPtrAndSize(argv[5], &buf6, NULL, &alloc6);
      if (!SWIG_IsOK(res6)) {
        SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "_TCHAR const *","connectParams", 6, argv[5] ));
      }
      arg6 = reinterpret_cast< _TCHAR * >(buf6);
  }
  {
    try {
      result = (bzs::db::protocol::tdap::client::connectParams *)new bzs::db::protocol::tdap::client::connectParams((_TCHAR const *)arg1,(_TCHAR const *)arg2,(_TCHAR const *)arg3,(_TCHAR const *)arg4,(_TCHAR const *)arg5,(_TCHAR const *)arg6);
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
  return self;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_connectParams_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_connectParams_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__client__connectParams);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_connectParams__SWIG_1(int argc, VALUE *argv, VALUE self) {
  _TCHAR *arg1 = (_TCHAR *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  bzs::db::protocol::tdap::client::connectParams *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_TCHAR const *","connectParams", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< _TCHAR * >(buf1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::connectParams *)new bzs::db::protocol::tdap::client::connectParams((_TCHAR const *)arg1);
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return self;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_connectParams(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[6];
  int ii;
  
  argc = nargs;
  if (argc > 6) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_connectParams__SWIG_1(nargs, args, self);
    }
  }
  if (argc >= 4) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v && (argc > 4)) {
            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v && (argc > 5)) {
            int res = SWIG_AsCharPtrAndSize(argv[5], 0, NULL, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_connectParams__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "connectParams.new", 
    "    connectParams.new(_TCHAR const *protocol, _TCHAR const *hostOrIp, _TCHAR const *dbname, _TCHAR const *schemaTable)\n"
    "    connectParams.new(_TCHAR const *uri)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_connectParams_setMode(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::connectParams *arg1 = (bzs::db::protocol::tdap::client::connectParams *) 0 ;
  char_td arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__connectParams, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::connectParams *","setMode", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::connectParams * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char_td","setMode", 2, argv[0] ));
  } 
  arg2 = static_cast< char_td >(val2);
  {
    try {
      (arg1)->setMode(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_connectParams_setType(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::connectParams *arg1 = (bzs::db::protocol::tdap::client::connectParams *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__connectParams, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::connectParams *","setType", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::connectParams * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","setType", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      (arg1)->setType(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_connectParams_uri(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::connectParams *arg1 = (bzs::db::protocol::tdap::client::connectParams *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__connectParams, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::connectParams const *","uri", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::connectParams * >(argp1);
  {
    try {
      result = (_TCHAR *)((bzs::db::protocol::tdap::client::connectParams const *)arg1)->uri();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_connectParams_mode(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::connectParams *arg1 = (bzs::db::protocol::tdap::client::connectParams *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__connectParams, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::connectParams const *","mode", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::connectParams * >(argp1);
  {
    try {
      result = (char_td)((bzs::db::protocol::tdap::client::connectParams const *)arg1)->mode();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_connectParams_type(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::connectParams *arg1 = (bzs::db::protocol::tdap::client::connectParams *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__connectParams, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::connectParams const *","type", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::connectParams * >(argp1);
  {
    try {
      result = (short)((bzs::db::protocol::tdap::client::connectParams const *)arg1)->type();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_bzs_db_protocol_tdap_client_connectParams(bzs::db::protocol::tdap::client::connectParams *arg1) {
    delete arg1;
}


static swig_class SwigClassFieldNames;

SWIGINTERN VALUE
_wrap_fieldNames_reset(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldNames *arg1 = (bzs::db::protocol::tdap::client::fieldNames *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldNames *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldNames * >(argp1);
  {
    try {
      arg1->reset();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_fieldNames_keyField(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldNames *arg1 = 0x00 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char* fdn[11] = {NULL};
  
  if (argc > 11) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldNames *","keyField", 1, self )); 
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldNames * >(argp1);
  }
  
  //Get key field names 
  {
    int alloc = 0;
    char* buf = NULL;
    for (int i=0;i<argc;++i)
    {
      int res = SWIG_AsCharPtrAndSize(argv[i], &buf, NULL, &alloc);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "_TCHAR const *","keyField", i+1, argv[i] ));
      }
      fdn[i] = reinterpret_cast<const _TCHAR * >(buf);
    }
  }

  {
    try {
      arg1->keyField(fdn[0], fdn[1], fdn[2], fdn[3], fdn[4], fdn[5], fdn[6], fdn[7], fdn[8], fdn[9], fdn[10]);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_fieldNames_count(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldNames *arg1 = (bzs::db::protocol::tdap::client::fieldNames *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldNames const *","count", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldNames * >(argp1);
  {
    try {
      result = (int)((bzs::db::protocol::tdap::client::fieldNames const *)arg1)->count();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fieldNames___getitem__(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldNames *arg1 = (bzs::db::protocol::tdap::client::fieldNames *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldNames const *","operator []", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldNames * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","operator []", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (_TCHAR *)((bzs::db::protocol::tdap::client::fieldNames const *)arg1)->operator [](arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fieldNames_getValue(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldNames *arg1 = (bzs::db::protocol::tdap::client::fieldNames *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldNames const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldNames * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","getValue", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (_TCHAR *)((bzs::db::protocol::tdap::client::fieldNames const *)arg1)->getValue(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fieldNames_addValue(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldNames *arg1 = (bzs::db::protocol::tdap::client::fieldNames *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldNames *","addValue", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldNames * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","addValue", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      (arg1)->addValue((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_fieldNames_addValues(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldNames *arg1 = (bzs::db::protocol::tdap::client::fieldNames *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  _TCHAR *arg3 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldNames *","addValues", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldNames * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","addValues", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "_TCHAR const *","addValues", 3, argv[1] ));
  }
  arg3 = reinterpret_cast< _TCHAR * >(buf3);
  {
    try {
      (arg1)->addValues((_TCHAR const *)arg2,(_TCHAR const *)arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_fieldNames_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_fieldNames_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_fieldNames(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldNames *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::client::fieldNames *)new_bzs_db_protocol_tdap_client_fieldNames();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void delete_bzs_db_protocol_tdap_client_fieldNames(bzs::db::protocol::tdap::client::fieldNames *self){
    self->release();
  }
SWIGINTERN void
free_bzs_db_protocol_tdap_client_fieldNames(bzs::db::protocol::tdap::client::fieldNames *arg1) {
    delete_bzs_db_protocol_tdap_client_fieldNames(arg1);
}

static swig_class SwigClassSortField;

SWIGINTERN VALUE
_wrap_sortField_name_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::sortField *arg1 = (bzs::db::protocol::tdap::client::sortField *) 0 ;
  std::_tstring arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__sortField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::sortField *","name", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::sortField * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std___tstring,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::_tstring","name", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::_tstring","name", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< std::_tstring * >(argp2));
    }
  }
  if (arg1) (arg1)->name = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_sortField_name_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::sortField *arg1 = (bzs::db::protocol::tdap::client::sortField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::_tstring result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__sortField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::sortField *","name", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::sortField * >(argp1);
  result =  ((arg1)->name);
  vresult = SWIG_NewPointerObj((new std::_tstring(static_cast< const std::_tstring& >(result))), SWIGTYPE_p_std___tstring, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_sortField_asc_set(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::sortField *arg1 = (bzs::db::protocol::tdap::client::sortField *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__sortField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::sortField *","asc", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::sortField * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","asc", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->asc = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_sortField_asc_get(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::sortField *arg1 = (bzs::db::protocol::tdap::client::sortField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__sortField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::sortField *","asc", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::sortField * >(argp1);
  result = (bool) ((arg1)->asc);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_sortField_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_sortField_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__client__sortField);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_sortField(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::sortField *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::client::sortField *)new bzs::db::protocol::tdap::client::sortField();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_bzs_db_protocol_tdap_client_sortField(bzs::db::protocol::tdap::client::sortField *arg1) {
    delete arg1;
}

static swig_class SwigClassSortFields;

SWIGINTERN VALUE
_wrap_sortFields_add(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::sortFields *arg1 = (bzs::db::protocol::tdap::client::sortFields *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__sortFields, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::sortFields *","add", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::sortFields * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","add", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","add", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      (arg1)->add((_TCHAR const *)arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}



/*
  Document-method: Transactd::sortFields.size

  call-seq:
    size -> size_t

Size or Length of the sortFields.
*/
SWIGINTERN VALUE
_wrap_sortFields_size(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::sortFields *arg1 = (bzs::db::protocol::tdap::client::sortFields *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__sortFields, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::sortFields const *","size", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::sortFields * >(argp1);
  {
    try {
      result = ((bzs::db::protocol::tdap::client::sortFields const *)arg1)->size();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_sortFields___getitem__(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::sortFields *arg1 = (bzs::db::protocol::tdap::client::sortFields *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bzs::db::protocol::tdap::client::sortField *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__sortFields, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::sortFields const *","operator []", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::sortFields * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","operator []", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (bzs::db::protocol::tdap::client::sortField *) &((bzs::db::protocol::tdap::client::sortFields const *)arg1)->operator [](arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__sortField, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_sortFields_clear(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::sortFields *arg1 = (bzs::db::protocol::tdap::client::sortFields *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__sortFields, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::sortFields *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::sortFields * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
//  return Qnil;
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_sortFields_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_sortFields_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__client__sortFields);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_sortFields(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::sortFields *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::client::sortFields *)new bzs::db::protocol::tdap::client::sortFields();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_bzs_db_protocol_tdap_client_sortFields(bzs::db::protocol::tdap::client::sortFields *arg1) {
    delete arg1;
}

static swig_class SwigClassRecordsetQuery;

SWIGINTERN VALUE
_wrap_recordsetQuery_reset(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordsetQuery *arg1 = (bzs::db::protocol::tdap::client::recordsetQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordsetQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordsetQuery *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordsetQuery * >(argp1);
  {
    try {
      arg1->reset();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_recordsetQuery_toString(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordsetQuery *arg1 = (bzs::db::protocol::tdap::client::recordsetQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordsetQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordsetQuery const *","toString", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordsetQuery * >(argp1);
  {
    try {
      result = (_TCHAR *)((bzs::db::protocol::tdap::client::recordsetQuery const *)arg1)->toString();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_recordsetQuery_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_recordsetQuery_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__client__recordsetQuery);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_recordsetQuery(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordsetQuery *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::client::recordsetQuery *)new_bzs_db_protocol_tdap_client_recordsetQuery();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void delete_bzs_db_protocol_tdap_client_recordsetQuery(bzs::db::protocol::tdap::client::recordsetQuery *self){
    self->release();
  }
SWIGINTERN void
free_bzs_db_protocol_tdap_client_recordsetQuery(bzs::db::protocol::tdap::client::recordsetQuery *arg1) {
    delete_bzs_db_protocol_tdap_client_recordsetQuery(arg1);
}

SWIGINTERN VALUE
_wrap_recordsetQuery_when(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordsetQuery *arg1 = (bzs::db::protocol::tdap::client::recordsetQuery *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  _TCHAR *arg3 = (_TCHAR *) 0 ;
  char *arg4 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3;
  SWIG_CHAR buf2;
  SWIG_CHAR buf3;
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordsetQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordsetQuery *","when<(p._TCHAR)>", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordsetQuery * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2.str, NULL, &buf2.alloc);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","when<(p._TCHAR)>", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2.str);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3.str, NULL, &buf3.alloc);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "_TCHAR const *","when<(p._TCHAR)>", 3, argv[1] ));
  }
  arg3 = reinterpret_cast< _TCHAR * >(buf3.str);
  {
    try {
      VALUE type = TYPE(argv[2]);
      if ((type == T_FIXNUM) || (type == T_BIGNUM)){
        long long v = 0;
        int ecode = SWIG_AsVal_long_SS_long(argv[2], &v);
        if (!SWIG_IsOK(ecode)) {
          SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "__int64","when", 3, argv[2]));
        }
        arg1->when(arg2, arg3, v);
      }
      else if (type == T_STRING){
          SWIG_CHAR buf4;
          int ret = SWIG_AsCharPtrAndSize(argv[2], &buf4.str, NULL, &buf4.alloc);
        if (!SWIG_IsOK(ret)) {
          SWIG_exception_fail(SWIG_ArgError(ret), Ruby_Format_TypeError( "", "char *const","when", 3, argv[2]));
        }
        arg1->when(arg2, arg3, buf4.str);
      }
      else if (type == T_FLOAT){
        double v = 0;
        int ecode = SWIG_AsVal_double(argv[2], &v);
        if (!SWIG_IsOK(ecode)) {
          SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "double","when", 3, argv[2]));
        }
        arg1->when(arg2, arg3, v);
      }
      else{
        SWIG_exception_fail(SWIG_TypeError, Ruby_Format_TypeError( "", "__int64 or char *const or double","when", 3, argv[2]));
      }
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;

fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_recordsetQuery_and_(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordsetQuery *arg1 = (bzs::db::protocol::tdap::client::recordsetQuery *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  _TCHAR *arg3 = (_TCHAR *) 0 ;
  char *arg4 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3;
  SWIG_CHAR buf2;
  SWIG_CHAR buf3;
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordsetQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordsetQuery *","and_<(p._TCHAR)>", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordsetQuery * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2.str, NULL, &buf2.alloc);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","and_<(p._TCHAR)>", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2.str);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3.str, NULL, &buf3.alloc);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "_TCHAR const *","and_<(p._TCHAR)>", 3, argv[1] ));
  }
  arg3 = reinterpret_cast< _TCHAR * >(buf3.str);
  {
    try {
      VALUE type = TYPE(argv[2]);
      if ((type == T_FIXNUM) || (type == T_BIGNUM)){
        long long v = 0;
        int ecode = SWIG_AsVal_long_SS_long(argv[2], &v);
        if (!SWIG_IsOK(ecode)) {
          SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "__int64","and_", 3, argv[2]));
        }
        arg1->and_(arg2, arg3, v);
      }
      else if (type == T_STRING){
          SWIG_CHAR buf4;
          int ret = SWIG_AsCharPtrAndSize(argv[2], &buf4.str, NULL, &buf4.alloc);
        if (!SWIG_IsOK(ret)) {
          SWIG_exception_fail(SWIG_ArgError(ret), Ruby_Format_TypeError( "", "char *const","and_", 3, argv[2]));
        }
        arg1->and_(arg2, arg3, buf4.str);
      }
      else if (type == T_FLOAT){
        double v = 0;
        int ecode = SWIG_AsVal_double(argv[2], &v);
        if (!SWIG_IsOK(ecode)) {
          SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "double","and_", 3, argv[2]));
        }
        arg1->and_(arg2, arg3, v);
      }
      else{
        SWIG_exception_fail(SWIG_TypeError, Ruby_Format_TypeError( "", "__int64 or char *const or double","and_", 3, argv[2]));
      }
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;

fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_recordsetQuery_or_(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordsetQuery *arg1 = (bzs::db::protocol::tdap::client::recordsetQuery *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  _TCHAR *arg3 = (_TCHAR *) 0 ;
  char *arg4 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3;
  SWIG_CHAR buf2;
  SWIG_CHAR buf3;
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordsetQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordsetQuery *","or_<(p._TCHAR)>", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordsetQuery * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2.str, NULL, &buf2.alloc);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","or_<(p._TCHAR)>", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2.str);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3.str, NULL, &buf3.alloc);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "_TCHAR const *","or_<(p._TCHAR)>", 3, argv[1] ));
  }
  arg3 = reinterpret_cast< _TCHAR * >(buf3.str);
  {
    try {
      VALUE type = TYPE(argv[2]);
      if ((type == T_FIXNUM) || (type == T_BIGNUM)){
        long long v = 0;
        int ecode = SWIG_AsVal_long_SS_long(argv[2], &v);
        if (!SWIG_IsOK(ecode)) {
          SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "__int64","or_", 3, argv[2]));
        }
        arg1->or_(arg2, arg3, v);
      }
      else if (type == T_STRING){
          SWIG_CHAR buf4;
          int ret = SWIG_AsCharPtrAndSize(argv[2], &buf4.str, NULL, &buf4.alloc);
        if (!SWIG_IsOK(ret)) {
          SWIG_exception_fail(SWIG_ArgError(ret), Ruby_Format_TypeError( "", "char *const","or_", 3, argv[2]));
        }
        arg1->or_(arg2, arg3, buf4.str);
      }
      else if (type == T_FLOAT){
        double v = 0;
        int ecode = SWIG_AsVal_double(argv[2], &v);
        if (!SWIG_IsOK(ecode)) {
          SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "double","or_", 3, argv[2]));
        }
        arg1->or_(arg2, arg3, v);
      }
      else{
        SWIG_exception_fail(SWIG_TypeError, Ruby_Format_TypeError( "", "__int64 or char *const or double","or_", 3, argv[2]));
      }
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}

static swig_class SwigClassGroupFuncBase;

SWIGINTERN void
free_bzs_db_protocol_tdap_client_groupFuncBase(bzs::db::protocol::tdap::client::groupFuncBase *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_groupFuncBase_targetNames(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::groupFuncBase *arg1 = (bzs::db::protocol::tdap::client::groupFuncBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::fieldNames *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__groupFuncBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::groupFuncBase const *","targetNames", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::groupFuncBase * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::fieldNames *) &((bzs::db::protocol::tdap::client::groupFuncBase const *)arg1)->targetNames();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_groupFuncBase_resultName(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::groupFuncBase *arg1 = (bzs::db::protocol::tdap::client::groupFuncBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__groupFuncBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::groupFuncBase const *","resultName", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::groupFuncBase * >(argp1);
  {
    try {
      result = (_TCHAR *)((bzs::db::protocol::tdap::client::groupFuncBase const *)arg1)->resultName();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_groupFuncBase_setResultName(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::groupFuncBase *arg1 = (bzs::db::protocol::tdap::client::groupFuncBase *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__groupFuncBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::groupFuncBase *","setResultName", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::groupFuncBase * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","setResultName", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      (arg1)->setResultName((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_groupFuncBase_resultKey(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::groupFuncBase *arg1 = (bzs::db::protocol::tdap::client::groupFuncBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__groupFuncBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::groupFuncBase const *","resultKey", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::groupFuncBase * >(argp1);
  {
    try {
      result = (int)((bzs::db::protocol::tdap::client::groupFuncBase const *)arg1)->resultKey();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_groupFuncBase_reset(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::groupFuncBase *arg1 = (bzs::db::protocol::tdap::client::groupFuncBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__groupFuncBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::groupFuncBase *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::groupFuncBase * >(argp1);
  {
    try {
      (arg1)->reset();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Transactd::groupFuncBase.clone

  call-seq:
    clone -> groupFuncBase

Create a duplicate of the class.
*/
SWIGINTERN VALUE
_wrap_groupFuncBase_clone(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::groupFuncBase *arg1 = (bzs::db::protocol::tdap::client::groupFuncBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::groupFuncBase *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__groupFuncBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::groupFuncBase *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::groupFuncBase * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::groupFuncBase *)(arg1)->clone();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__groupFuncBase, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


static swig_class SwigClassGroupQuery;

SWIGINTERN VALUE
_wrap_groupQuery_reset(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::groupQuery *arg1 = (bzs::db::protocol::tdap::client::groupQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__groupQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::groupQuery *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::groupQuery * >(argp1);
  {
    try {
      arg1->reset();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_groupQuery_addFunction(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::groupQuery *arg1 = (bzs::db::protocol::tdap::client::groupQuery *) 0 ;
  bzs::db::protocol::tdap::client::groupFuncBase *arg2 = (bzs::db::protocol::tdap::client::groupFuncBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__groupQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::groupQuery *","addFunction", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::groupQuery * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__client__groupFuncBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::groupFuncBase *","addFunction", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::groupFuncBase * >(argp2);
  {
    try {
      arg1->addFunction(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_groupQuery_keyField(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::groupQuery *arg1 = (bzs::db::protocol::tdap::client::groupQuery *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char* fdn[11] = {NULL};

  if (argc > 11) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__groupQuery, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::groupQuery *","keyField", 1, self )); 
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::groupQuery * >(argp1);
  }
  
  //Get key field names 
  {
    int alloc = 0;
    char* buf = NULL;
    for (int i=0;i<argc;++i)
    {
      int res = SWIG_AsCharPtrAndSize(argv[i], &buf, NULL, &alloc);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "_TCHAR const *","keyField", i+1, argv[i] ));
      }
      fdn[i] = reinterpret_cast<const _TCHAR * >(buf);
    }
  }
  {
    try {
      arg1->keyField(fdn[0], fdn[1], fdn[2], fdn[3], fdn[4], fdn[5], fdn[6], fdn[7], fdn[8], fdn[9], fdn[10]);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_groupQuery_getKeyFields(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::groupQuery *arg1 = (bzs::db::protocol::tdap::client::groupQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::fieldNames *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__groupQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::groupQuery const *","getKeyFields", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::groupQuery * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::fieldNames *) &((bzs::db::protocol::tdap::client::groupQuery const *)arg1)->getKeyFields();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_groupQuery_getFunction(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::groupQuery *arg1 = (bzs::db::protocol::tdap::client::groupQuery *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bzs::db::protocol::tdap::client::groupFuncBase *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__groupQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::groupQuery const *","getFunction", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::groupQuery * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","getFunction", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (bzs::db::protocol::tdap::client::groupFuncBase *)((bzs::db::protocol::tdap::client::groupQuery const *)arg1)->getFunction(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__groupFuncBase, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_groupQuery_functionCount(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::groupQuery *arg1 = (bzs::db::protocol::tdap::client::groupQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__groupQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::groupQuery const *","functionCount", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::groupQuery * >(argp1);
  {
    try {
      result = (int)((bzs::db::protocol::tdap::client::groupQuery const *)arg1)->functionCount();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_groupQuery_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_groupQuery_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__client__groupQuery);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_groupQuery(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::groupQuery *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::client::groupQuery *)new_bzs_db_protocol_tdap_client_groupQuery();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void delete_bzs_db_protocol_tdap_client_groupQuery(bzs::db::protocol::tdap::client::groupQuery *self){
    self->release();
  }
SWIGINTERN void
free_bzs_db_protocol_tdap_client_groupQuery(bzs::db::protocol::tdap::client::groupQuery *arg1) {
    delete_bzs_db_protocol_tdap_client_groupQuery(arg1);
}

static swig_class SwigClassSum;



SWIGINTERN VALUE
_wrap_new_sum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldNames *arg1 = 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bzs::db::protocol::tdap::client::sum *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldNames const &","sum", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::fieldNames const &","sum", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldNames * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","sum", 2, argv[1] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (bzs::db::protocol::tdap::client::sum *)new_bzs_db_protocol_tdap_client_sum__SWIG_0((bzs::db::protocol::tdap::client::fieldNames const &)*arg1,(char const *)arg2);
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return self;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_sum_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_sum_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__client__sum);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_sum__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldNames *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::sum *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldNames const &","sum", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::fieldNames const &","sum", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldNames * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::sum *)new_bzs_db_protocol_tdap_client_sum__SWIG_0((bzs::db::protocol::tdap::client::fieldNames const &)*arg1);
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_sum(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_sum__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_sum__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "sum.new", 
    "    sum.new(bzs::db::protocol::tdap::client::fieldNames const &targetNames, _TCHAR const *resultName)\n"
    "    sum.new(bzs::db::protocol::tdap::client::fieldNames const &targetNames)\n");
  
  return Qnil;
}


SWIGINTERN void delete_bzs_db_protocol_tdap_client_sum(bzs::db::protocol::tdap::client::sum *self){
    self->release();
  }
SWIGINTERN void
free_bzs_db_protocol_tdap_client_sum(bzs::db::protocol::tdap::client::sum *arg1) {
    delete_bzs_db_protocol_tdap_client_sum(arg1);
}

static swig_class SwigClassCount;


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_count_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_count_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__client__count);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_count(int argc, VALUE *argv, VALUE self) {
  _TCHAR *arg1 = (_TCHAR *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  bzs::db::protocol::tdap::client::count *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_TCHAR const *","count", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< _TCHAR * >(buf1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::count *)new_bzs_db_protocol_tdap_client_count((char const *)arg1);
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return self;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return Qnil;
}


SWIGINTERN void delete_bzs_db_protocol_tdap_client_count(bzs::db::protocol::tdap::client::count *self){
    self->release();
  }
SWIGINTERN void
free_bzs_db_protocol_tdap_client_count(bzs::db::protocol::tdap::client::count *arg1) {
    delete_bzs_db_protocol_tdap_client_count(arg1);
}


static swig_class SwigClassFirst;


SWIGINTERN VALUE
_wrap_new_first__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldNames *arg1 = 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bzs::db::protocol::tdap::client::first *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldNames const &","first", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::fieldNames const &","first", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldNames * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","first", 2, argv[1] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (bzs::db::protocol::tdap::client::first *)new_bzs_db_protocol_tdap_client_first__SWIG_0((bzs::db::protocol::tdap::client::fieldNames const &)*arg1,(char const *)arg2);
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return self;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_first_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_first_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__client__first);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
 

SWIGINTERN VALUE
_wrap_new_first__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldNames *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::first *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldNames const &","first", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::fieldNames const &","first", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldNames * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::first *)new_bzs_db_protocol_tdap_client_first__SWIG_0((bzs::db::protocol::tdap::client::fieldNames const &)*arg1);
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_first(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_first__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_first__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "first.new", 
    "    first.new(bzs::db::protocol::tdap::client::fieldNames const &targetNames, _TCHAR const *resultName)\n"
    "    first.new(bzs::db::protocol::tdap::client::fieldNames const &targetNames)\n");
  
  return Qnil;
}


SWIGINTERN void delete_bzs_db_protocol_tdap_client_first(bzs::db::protocol::tdap::client::first *self){
    self->release();
  }
SWIGINTERN void
free_bzs_db_protocol_tdap_client_first(bzs::db::protocol::tdap::client::first *arg1) {
    delete_bzs_db_protocol_tdap_client_first(arg1);
}


static swig_class SwigClassLast;


SWIGINTERN VALUE
_wrap_new_last__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldNames *arg1 = 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bzs::db::protocol::tdap::client::last *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldNames const &","last", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::fieldNames const &","last", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldNames * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","last", 2, argv[1] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (bzs::db::protocol::tdap::client::last *)new_bzs_db_protocol_tdap_client_last__SWIG_0((bzs::db::protocol::tdap::client::fieldNames const &)*arg1,(char const *)arg2);
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return self;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_last_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_last_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__client__last);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_last__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldNames *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::last *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldNames const &","last", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::fieldNames const &","last", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldNames * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::last *)new_bzs_db_protocol_tdap_client_last__SWIG_0((bzs::db::protocol::tdap::client::fieldNames const &)*arg1);
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_last(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_last__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_last__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "last.new", 
    "    last.new(bzs::db::protocol::tdap::client::fieldNames const &targetNames, _TCHAR const *resultName)\n"
    "    last.new(bzs::db::protocol::tdap::client::fieldNames const &targetNames)\n");
  
  return Qnil;
}


SWIGINTERN void delete_bzs_db_protocol_tdap_client_last(bzs::db::protocol::tdap::client::last *self){
    self->release();
  }
SWIGINTERN void
free_bzs_db_protocol_tdap_client_last(bzs::db::protocol::tdap::client::last *arg1) {
    delete_bzs_db_protocol_tdap_client_last(arg1);
}


static swig_class SwigClassAvg;


SWIGINTERN VALUE
_wrap_new_avg__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldNames *arg1 = 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bzs::db::protocol::tdap::client::avg *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldNames const &","avg", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::fieldNames const &","avg", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldNames * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","avg", 2, argv[1] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (bzs::db::protocol::tdap::client::avg *)new_bzs_db_protocol_tdap_client_avg__SWIG_0((bzs::db::protocol::tdap::client::fieldNames const &)*arg1,(char const *)arg2);
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return self;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_avg_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_avg_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__client__avg);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_avg__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldNames *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::avg *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldNames const &","avg", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::fieldNames const &","avg", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldNames * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::avg *)new_bzs_db_protocol_tdap_client_avg__SWIG_0((bzs::db::protocol::tdap::client::fieldNames const &)*arg1);
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_avg(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_avg__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_avg__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "avg.new", 
    "    avg.new(bzs::db::protocol::tdap::client::fieldNames const &targetNames, _TCHAR const *resultName)\n"
    "    avg.new(bzs::db::protocol::tdap::client::fieldNames const &targetNames)\n");
  
  return Qnil;
}


SWIGINTERN void delete_bzs_db_protocol_tdap_client_avg(bzs::db::protocol::tdap::client::avg *self){
    self->release();
  }
SWIGINTERN void
free_bzs_db_protocol_tdap_client_avg(bzs::db::protocol::tdap::client::avg *arg1) {
    delete_bzs_db_protocol_tdap_client_avg(arg1);
}

static swig_class SwigClassMin;


SWIGINTERN VALUE
_wrap_new_min__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldNames *arg1 = 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bzs::db::protocol::tdap::client::min *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldNames const &","min", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::fieldNames const &","min", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldNames * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","min", 2, argv[1] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (bzs::db::protocol::tdap::client::min *)new_bzs_db_protocol_tdap_client_min__SWIG_0((bzs::db::protocol::tdap::client::fieldNames const &)*arg1,(char const *)arg2);
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return self;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_min_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_min_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__client__min);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_min__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldNames *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::min *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldNames const &","min", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::fieldNames const &","min", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldNames * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::min *)new_bzs_db_protocol_tdap_client_min__SWIG_0((bzs::db::protocol::tdap::client::fieldNames const &)*arg1);
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_min(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_min__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_min__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "min.new", 
    "    min.new(bzs::db::protocol::tdap::client::fieldNames const &targetNames, _TCHAR const *resultName)\n"
    "    min.new(bzs::db::protocol::tdap::client::fieldNames const &targetNames)\n");
  
  return Qnil;
}


SWIGINTERN void delete_bzs_db_protocol_tdap_client_min(bzs::db::protocol::tdap::client::min *self){
    self->release();
  }
SWIGINTERN void
free_bzs_db_protocol_tdap_client_min(bzs::db::protocol::tdap::client::min *arg1) {
    delete_bzs_db_protocol_tdap_client_min(arg1);
}

static swig_class SwigClassMax;


SWIGINTERN VALUE
_wrap_new_max__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldNames *arg1 = 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bzs::db::protocol::tdap::client::max *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldNames const &","max", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::fieldNames const &","max", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldNames * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","max", 2, argv[1] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (bzs::db::protocol::tdap::client::max *)new_bzs_db_protocol_tdap_client_max__SWIG_0((bzs::db::protocol::tdap::client::fieldNames const &)*arg1,(char const *)arg2);
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return self;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_max_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_max_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__client__max);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_max__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::fieldNames *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::max *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldNames const &","max", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::fieldNames const &","max", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldNames * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::max *)new_bzs_db_protocol_tdap_client_max__SWIG_0((bzs::db::protocol::tdap::client::fieldNames const &)*arg1);
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_max(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_max__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_max__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "max.new", 
    "    max.new(bzs::db::protocol::tdap::client::fieldNames const &targetNames, _TCHAR const *resultName)\n"
    "    max.new(bzs::db::protocol::tdap::client::fieldNames const &targetNames)\n");
  
  return Qnil;
}


SWIGINTERN void delete_bzs_db_protocol_tdap_client_max(bzs::db::protocol::tdap::client::max *self){
    self->release();
  }
SWIGINTERN void
free_bzs_db_protocol_tdap_client_max(bzs::db::protocol::tdap::client::max *arg1) {
    delete_bzs_db_protocol_tdap_client_max(arg1);
}

static swig_class SwigClassRecordset;


/*
  Document-method: Transactd::Recordset.clone

  call-seq:
    clone -> Recordset

Create a duplicate of the class.
*/
SWIGINTERN VALUE
_wrap_Recordset_clone(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *arg1 = (bzs::db::protocol::tdap::client::recordset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::recordset *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::recordset *)((bzs::db::protocol::tdap::client::recordset const *)arg1)->clone();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Recordset___getitem__(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *arg1 = (bzs::db::protocol::tdap::client::recordset *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bzs::db::protocol::tdap::client::row *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset const *","operator []", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","operator []", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  {
    try {
      result = (bzs::db::protocol::tdap::client::row *) &((bzs::db::protocol::tdap::client::recordset const *)arg1)->operator [](arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldsBase, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Transactd::Recordset.first

  call-seq:
    first -> Record

Return the first element in Recordset.
*/
SWIGINTERN VALUE
_wrap_Recordset_first(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *arg1 = (bzs::db::protocol::tdap::client::recordset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::row *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset const *","first", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::row *) &((bzs::db::protocol::tdap::client::recordset const *)arg1)->first();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldsBase, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Transactd::Recordset.last

  call-seq:
    last -> Record

Return the last element in Recordset.
*/
SWIGINTERN VALUE
_wrap_Recordset_last(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *arg1 = (bzs::db::protocol::tdap::client::recordset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::row *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset const *","last", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::row *) &((bzs::db::protocol::tdap::client::recordset const *)arg1)->last();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldsBase, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Transactd::Recordset.size

  call-seq:
    size -> size_t

Size or Length of the Recordset.
*/
SWIGINTERN VALUE
_wrap_Recordset_size(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *arg1 = (bzs::db::protocol::tdap::client::recordset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset const *","size", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp1);
  {
    try {
      result = ((bzs::db::protocol::tdap::client::recordset const *)arg1)->size();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Recordset_count(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *arg1 = (bzs::db::protocol::tdap::client::recordset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset const *","count", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp1);
  {
    try {
      result = ((bzs::db::protocol::tdap::client::recordset const *)arg1)->count();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Recordset_clearRecords(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *arg1 = (bzs::db::protocol::tdap::client::recordset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset *","clearRecords", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp1);
  {
    try {
      (arg1)->clearRecords();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Recordset_fieldDefs(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *arg1 = (bzs::db::protocol::tdap::client::recordset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::fielddefs *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset const *","fieldDefs", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::fielddefs *)((bzs::db::protocol::tdap::client::recordset const *)arg1)->fieldDefs();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__fielddefs, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Recordset_clear(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *arg1 = (bzs::db::protocol::tdap::client::recordset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Recordset_top(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *arg1 = (bzs::db::protocol::tdap::client::recordset *) 0 ;
  bzs::db::protocol::tdap::client::recordset *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bzs::db::protocol::tdap::client::recordset *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset const *","top", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset &","top", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::recordset &","top", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","top", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (bzs::db::protocol::tdap::client::recordset *) &((bzs::db::protocol::tdap::client::recordset const *)arg1)->top(*arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Recordset_begin(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *arg1 = (bzs::db::protocol::tdap::client::recordset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< std::vector< bzs::db::protocol::tdap::client::fieldsBase * >::iterator > result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset *","begin", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj((new bzs::db::protocol::tdap::client::recordset::iterator(static_cast< const bzs::db::protocol::tdap::client::recordset::iterator& >(result))), SWIGTYPE_p_std__vectorT_bzs__db__protocol__tdap__client__fieldsBase_p_t__iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Recordset_end(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *arg1 = (bzs::db::protocol::tdap::client::recordset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< std::vector< bzs::db::protocol::tdap::client::fieldsBase * >::iterator > result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset *","end", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj((new bzs::db::protocol::tdap::client::recordset::iterator(static_cast< const bzs::db::protocol::tdap::client::recordset::iterator& >(result))), SWIGTYPE_p_std__vectorT_bzs__db__protocol__tdap__client__fieldsBase_p_t__iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Recordset_erase__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *arg1 = (bzs::db::protocol::tdap::client::recordset *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< std::vector< bzs::db::protocol::tdap::client::fieldsBase * >::iterator > result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset *","erase", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","erase", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  {
    try {
      result = (arg1)->erase(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj((new bzs::db::protocol::tdap::client::recordset::iterator(static_cast< const bzs::db::protocol::tdap::client::recordset::iterator& >(result))), SWIGTYPE_p_std__vectorT_bzs__db__protocol__tdap__client__fieldsBase_p_t__iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Recordset_erase__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *arg1 = (bzs::db::protocol::tdap::client::recordset *) 0 ;
  bzs::db::protocol::tdap::client::recordset::iterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  SwigValueWrapper< std::vector< bzs::db::protocol::tdap::client::fieldsBase * >::iterator > result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset *","erase", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__vectorT_bzs__db__protocol__tdap__client__fieldsBase_p_t__iterator,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset::iterator const &","erase", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::recordset::iterator const &","erase", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset::iterator * >(argp2);
  {
    try {
      result = (arg1)->erase((bzs::db::protocol::tdap::client::recordset::iterator const &)*arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj((new bzs::db::protocol::tdap::client::recordset::iterator(static_cast< const bzs::db::protocol::tdap::client::recordset::iterator& >(result))), SWIGTYPE_p_std__vectorT_bzs__db__protocol__tdap__client__fieldsBase_p_t__iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Recordset_erase(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_bzs__db__protocol__tdap__client__fieldsBase_p_t__iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Recordset_erase__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Recordset_erase__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Recordset.erase", 
    "    bzs::db::protocol::tdap::client::recordset::iterator Recordset.erase(size_t index)\n"
    "    bzs::db::protocol::tdap::client::recordset::iterator Recordset.erase(bzs::db::protocol::tdap::client::recordset::iterator const &it)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Recordset_removeField(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *arg1 = (bzs::db::protocol::tdap::client::recordset *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset *","removeField", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","removeField", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->removeField(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Recordset_matchBy(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *arg1 = (bzs::db::protocol::tdap::client::recordset *) 0 ;
  bzs::db::protocol::tdap::client::recordsetQuery *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset *","matchBy", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_bzs__db__protocol__tdap__client__recordsetQuery,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordsetQuery &","matchBy", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::recordsetQuery &","matchBy", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::recordsetQuery * >(argp2);
  {
    try {
      arg1->matchBy(*arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Recordset_groupBy(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *arg1 = (bzs::db::protocol::tdap::client::recordset *) 0 ;
  bzs::db::protocol::tdap::client::groupQuery *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset *","groupBy", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_bzs__db__protocol__tdap__client__groupQuery,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::groupQuery &","groupBy", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::groupQuery &","groupBy", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::groupQuery * >(argp2);
  {
    try {
      arg1->groupBy(*arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Recordset_orderBy(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *arg1 =  0x00;
  bzs::db::protocol::tdap::client::sortFields *arg2 = 0x00;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;

  const char* fdn[8] = {NULL};

  if (argc > 8) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset *","orderBy", 1, self )); 
    }
    arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp1);
  }
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_bzs__db__protocol__tdap__client__sortFields,  0 );
  if (SWIG_IsOK(res2)) {
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::sortFields const &","orderBy", 2, argv[0])); 
    }
    arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::sortFields * >(argp2);
  }else {
    //Get key field names 
    int alloc = 0;
    char* buf = NULL;
    for (int i=0;i<argc;++i)
    {
      int res = SWIG_AsCharPtrAndSize(argv[i], &buf, NULL, &alloc);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "_TCHAR const *","orderBy", i+1, argv[i] ));
      }
      fdn[i] = reinterpret_cast<const _TCHAR * >(buf);
    }
  }

  {
    try {
      if (arg2)
        arg1->orderBy(*arg2);
      else
        arg1->orderBy(fdn[0], fdn[1], fdn[2], fdn[3], fdn[4], fdn[5], fdn[6], fdn[7]);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Recordset_reverse(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *arg1 = (bzs::db::protocol::tdap::client::recordset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset *","reverse", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp1);
  {
    try {
      arg1->reverse();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Recordset_appendField(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *arg1 = (bzs::db::protocol::tdap::client::recordset *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  int arg3 ;
  short arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset *","appendField", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","appendField", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","appendField", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "short","appendField", 4, argv[2] ));
  } 
  arg4 = static_cast< short >(val4);
  {
    try {
      (arg1)->appendField((_TCHAR const *)arg2,arg3,arg4);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Recordset_unionRecordset(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *arg1 = (bzs::db::protocol::tdap::client::recordset *) 0 ;
  bzs::db::protocol::tdap::client::recordset *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset *","operator +=", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset const &","operator +=", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::recordset const &","operator +=", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp2);
  {
    try {
      arg1->operator +=((bzs::db::protocol::tdap::client::recordset const &)*arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Recordset_getRow(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *arg1 = (bzs::db::protocol::tdap::client::recordset *) 0 ;
  size_t arg2 ;
  bzs::db::protocol::tdap::client::fieldsBase **arg3 = (bzs::db::protocol::tdap::client::fieldsBase **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset *","getRow", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getRow", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_p_bzs__db__protocol__tdap__client__fieldsBase, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::fieldsBase **","getRow", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< bzs::db::protocol::tdap::client::fieldsBase ** >(argp3);
  {
    try {
      bzs_db_protocol_tdap_client_recordset_getRow(arg1,arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Recordset_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Recordset_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Recordset(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::recordset *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::client::recordset *)new_bzs_db_protocol_tdap_client_recordset();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void delete_bzs_db_protocol_tdap_client_recordset(bzs::db::protocol::tdap::client::recordset *self){
    self->release();
  }
SWIGINTERN void
free_bzs_db_protocol_tdap_client_recordset(bzs::db::protocol::tdap::client::recordset *arg1) {
    delete_bzs_db_protocol_tdap_client_recordset(arg1);
}

static swig_class SwigClassPreparedQuery;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_preparedQuery_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_preparedQuery_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__client__preparedQuery);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_preparedQuery(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::pq_handle arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::preparedQuery *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_boost__shared_ptrT_bzs__db__protocol__tdap__client__filter_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::pq_handle","preparedQuery", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::pq_handle","preparedQuery", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< bzs::db::protocol::tdap::client::pq_handle * >(argp1));
    }
  }
  {
    try {
      result = (bzs::db::protocol::tdap::client::preparedQuery *)new bzs::db::protocol::tdap::client::preparedQuery(arg1);
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_preparedQuery_supplyValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::preparedQuery *arg1 = (bzs::db::protocol::tdap::client::preparedQuery *) 0 ;
  int arg2 ;
  _TCHAR *arg3 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__preparedQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::preparedQuery *","supplyValue", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::preparedQuery * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","supplyValue", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "_TCHAR const *","supplyValue", 3, argv[1] ));
  }
  arg3 = reinterpret_cast< _TCHAR * >(buf3);
  {
    try {
      result = (bool)(arg1)->supplyValue(arg2,(_TCHAR const *)arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return vresult;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_preparedQuery_supplyValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::preparedQuery *arg1 = (bzs::db::protocol::tdap::client::preparedQuery *) 0 ;
  int arg2 ;
  __int64 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  long long val3 ;
  int ecode3 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__preparedQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::preparedQuery *","supplyValue", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::preparedQuery * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","supplyValue", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_long_SS_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "__int64","supplyValue", 3, argv[1] ));
  } 
  arg3 = static_cast< __int64 >(val3);
  {
    try {
      result = (bool)(arg1)->supplyValue(arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_preparedQuery_supplyValue__SWIG_2(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::preparedQuery *arg1 = (bzs::db::protocol::tdap::client::preparedQuery *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__preparedQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::preparedQuery *","supplyValue", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::preparedQuery * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","supplyValue", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","supplyValue", 3, argv[1] ));
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = (bool)(arg1)->supplyValue(arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_preparedQuery_supplyValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__preparedQuery, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_preparedQuery_supplyValue__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__preparedQuery, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_preparedQuery_supplyValue__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__preparedQuery, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_preparedQuery_supplyValue__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "preparedQuery.supplyValue", 
    "    bool preparedQuery.supplyValue(int index, _TCHAR const *v)\n"
    "    bool preparedQuery.supplyValue(int index, __int64 v)\n"
    "    bool preparedQuery.supplyValue(int index, double v)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_preparedQuery_addValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::preparedQuery *arg1 = (bzs::db::protocol::tdap::client::preparedQuery *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__preparedQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::preparedQuery *","addValue", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::preparedQuery * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","addValue", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (bool)(arg1)->addValue((_TCHAR const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_preparedQuery_addValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::preparedQuery *arg1 = (bzs::db::protocol::tdap::client::preparedQuery *) 0 ;
  __int64 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__preparedQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::preparedQuery *","addValue", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::preparedQuery * >(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "__int64","addValue", 2, argv[0] ));
  } 
  arg2 = static_cast< __int64 >(val2);
  {
    try {
      result = (bool)(arg1)->addValue(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_preparedQuery_addValue__SWIG_2(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::preparedQuery *arg1 = (bzs::db::protocol::tdap::client::preparedQuery *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__preparedQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::preparedQuery *","addValue", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::preparedQuery * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","addValue", 2, argv[0] ));
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (bool)(arg1)->addValue(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_preparedQuery_addValue(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__preparedQuery, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_preparedQuery_addValue__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__preparedQuery, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_preparedQuery_addValue__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__preparedQuery, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_preparedQuery_addValue__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "preparedQuery.addValue", 
    "    bool preparedQuery.addValue(_TCHAR const *v)\n"
    "    bool preparedQuery.addValue(__int64 v)\n"
    "    bool preparedQuery.addValue(double v)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_preparedQuery_resetAddIndex(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::preparedQuery *arg1 = (bzs::db::protocol::tdap::client::preparedQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__preparedQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::preparedQuery *","resetAddIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::preparedQuery * >(argp1);
  {
    try {
      (arg1)->resetAddIndex();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_bzs_db_protocol_tdap_client_preparedQuery(bzs::db::protocol::tdap::client::preparedQuery *arg1) {
    delete arg1;
}

static swig_class SwigClassActiveTable;

SWIGINTERN VALUE
_wrap_activeTable_alias(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::activeTable *arg1 = (bzs::db::protocol::tdap::client::activeTable *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  _TCHAR *arg3 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::activeTable *","alias", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::activeTable * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","alias", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "_TCHAR const *","alias", 3, argv[1] ));
  }
  arg3 = reinterpret_cast< _TCHAR * >(buf3);
  {
    try {
      &(arg1)->alias((_TCHAR const *)arg2,(_TCHAR const *)arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return self;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_activeTable_resetAlias(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::activeTable *arg1 = (bzs::db::protocol::tdap::client::activeTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::activeTable *","resetAlias", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::activeTable * >(argp1);
  {
    try {
      arg1->resetAlias();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_activeTable_getWritableRecord(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::activeTable *arg1 = (bzs::db::protocol::tdap::client::activeTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::writableRecord *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::activeTable *","getWritableRecord", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::activeTable * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::writableRecord *) &(arg1)->getWritableRecord();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__writableRecord, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_activeTable_index(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::activeTable *arg1 = (bzs::db::protocol::tdap::client::activeTable *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::activeTable *","index", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::activeTable * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","index", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      arg1->index(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_activeTable_option(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::activeTable *arg1 = (bzs::db::protocol::tdap::client::activeTable *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::activeTable *","option", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::activeTable * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","option", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      arg1->option(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_activeTable__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::idatabaseManager *arg1 = (bzs::db::protocol::tdap::client::idatabaseManager *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bzs::db::protocol::tdap::client::activeTable *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::idatabaseManager *","activeTable", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::idatabaseManager * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","activeTable", 2, argv[1] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (bzs::db::protocol::tdap::client::activeTable *)new_bzs_db_protocol_tdap_client_activeTable__SWIG_0(arg1,(char const *)arg2);
      DATA_PTR(self) = result;
      SWIG_RubyAddTracking(result, self);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return self;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_activeTable_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_activeTable_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_activeTable__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::database *arg1 = (bzs::db::protocol::tdap::client::database *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  short arg3 = TD_OPEN_NORMAL;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bzs::db::protocol::tdap::client::activeTable *result = 0 ;
  
  if ((argc < 2) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::database *","activeTable", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::database * >(argp1);
  
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","activeTable", 2, argv[1] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);

  if (argc == 3)
  {
      VALUE type = TYPE(argv[2]);
      if ((type == T_FIXNUM) || (type == T_BIGNUM))
      {
          long long val = 0;
          int ecode = SWIG_AsVal_long_SS_long(argv[2], &val);
          if (!SWIG_IsOK(ecode))
              SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError("", "short", "mode", 3, argv[2]));
          arg3 = (short)val;
      }
  }

  {
    try {
      result = (bzs::db::protocol::tdap::client::activeTable *)new_bzs_db_protocol_tdap_client_activeTable__SWIG_1(arg1,(char const *)arg2, arg3);
      DATA_PTR(self) = result;
      SWIG_RubyAddTracking(result, self);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return self;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_activeTable(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_activeTable__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_activeTable__SWIG_1(nargs, args, self);
      }
    }
  }

  if (argc == 3) {
      int _v;
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
              return _wrap_new_activeTable__SWIG_1(nargs, args, self);
          }
      }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "activeTable.new", 
    "    activeTable.new(bzs::db::protocol::tdap::client::idatabaseManager *mgr, _TCHAR const *tableName)\n"
    "    activeTable.new(bzs::db::protocol::tdap::client::database *db, _TCHAR const *tableName)\n");
  
  return Qnil;
}


SWIGINTERN void delete_bzs_db_protocol_tdap_client_activeTable(bzs::db::protocol::tdap::client::activeTable *self){
    if (g_vPtrList.remove(self->table().get()))
    {
      if (nsdatabase::testTablePtr(self->table().get()))
        self->table()->nsdb()->setTestPtrIgnore(true);
    }
    g_refCounter.remove(self);
    self->release();
  }
SWIGINTERN void
free_bzs_db_protocol_tdap_client_activeTable(bzs::db::protocol::tdap::client::activeTable *arg1) {
    SWIG_RubyRemoveTracking(arg1);
    delete_bzs_db_protocol_tdap_client_activeTable(arg1);
}

SWIGINTERN VALUE
_wrap_activeTable_read__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::activeTable *arg1 = 0x00 ;
  bzs::db::protocol::tdap::client::queryBase *arg2 = 0x00 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bzs::db::protocol::tdap::client::recordset *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::activeTable *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::activeTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase &","read", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::queryBase &","read", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp2);
  {
    try {
      result = recordset::create();
      arg1->read(*result, *arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_activeTable_read__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::activeTable *arg1 = (bzs::db::protocol::tdap::client::activeTable *) 0 ;
  bzs::db::protocol::tdap::client::preparedQuery *arg2 = (bzs::db::protocol::tdap::client::preparedQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;

  bzs::db::protocol::tdap::client::recordset *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 9)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::activeTable *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::activeTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__client__preparedQuery, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::preparedQuery *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::preparedQuery * >(argp2);
  
  {
    arg2->resetAddIndex();
    for (int i = 1; i < argc; ++i){
      VALUE type = TYPE(argv[i]);
      if ((type == T_FIXNUM) || (type == T_BIGNUM)){
        long long val = 0;
        int ecode = SWIG_AsVal_long_SS_long(argv[i], &val);
        if (!SWIG_IsOK(ecode)) {
          SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "__int64","read", i+2, argv[i]));
        }
        arg2->addValue((__int64)val);
      }
      else if (type == T_STRING){
          SWIG_CHAR buf;
          int ret = SWIG_AsCharPtrAndSize(argv[i], &buf.str, NULL, &buf.alloc);
        if (!SWIG_IsOK(ret)) {
          SWIG_exception_fail(SWIG_ArgError(ret), Ruby_Format_TypeError( "", "char *const","read", i+2, argv[i]));
        }
        arg2->addValue(buf.str);
      }
      else if (type == T_FLOAT){
        double val = 0;
        int ecode = SWIG_AsVal_double(argv[i], &val);
        if (!SWIG_IsOK(ecode)) {
          SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "double","read", i+2, argv[i]));
        }
        arg2->addValue(val);
      }
      else if (type == T_NIL){
        break;
      }
      else{
        SWIG_exception_fail(SWIG_TypeError, Ruby_Format_TypeError( "", "integer or float or string","read",i+2, argv[i])); 
      }
    }
  }

  {
    try {
      result = recordset::create();
      arg1->read(*result, arg2->getFilter());
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_activeTable_read(int nargs, VALUE *args, VALUE self) {


  if ((nargs < 1)||(nargs > 9)) SWIG_fail;

  {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(self, &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      if (nargs == 1) {
        vptr = 0;
        int res = SWIG_ConvertPtr(args[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_activeTable_read__SWIG_0(nargs, args, self);
        }
      }
      vptr = 0;
      int res = SWIG_ConvertPtr(args[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__preparedQuery, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_activeTable_read__SWIG_1(nargs, args, self);
      }
    }
  }

fail:
  Ruby_Format_OverloadedError( nargs+1, 3, "read.new", 
    "    read.new(bzs::db::protocol::tdap::client::queryBase &q)\n"
    "    read.new(bzs::db::protocol::tdap::client::preparedQuery *q)\n");
  
  return Qnil;
}


SWIGINTERN VALUE _wrap_activeTable_readMore(int nargs, VALUE *args, VALUE self) {
  bzs::db::protocol::tdap::client::activeTable *arg1 =  0x00 ;
  bzs::db::protocol::tdap::client::recordset *result = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;

  VALUE vresult = Qnil;

  if (nargs != 0) SWIG_fail;
  
  //Get activeTable ptr
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::activeTable *","readMore", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::activeTable * >(argp1);
  
  {
    try {
      result = recordset::create();
      arg1->readMore(*result);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  Ruby_Format_OverloadedError( nargs+1, 11, "readMore", "    bzs::db::protocol::tdap::client::activeTable & readMore ");
  return Qnil;

}


SWIGINTERN VALUE
_wrap_activeTable_prepare__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::activeTable *arg1 = (bzs::db::protocol::tdap::client::activeTable *) 0 ;
  bzs::db::protocol::tdap::client::queryBase *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bzs::db::protocol::tdap::client::preparedQuery *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::activeTable *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::activeTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase &","prepare", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::queryBase &","prepare", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","prepare", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (bzs::db::protocol::tdap::client::preparedQuery *)bzs_db_protocol_tdap_client_activeTable_prepare__SWIG_0(arg1,*arg2,arg3);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__preparedQuery, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_activeTable_prepare__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::activeTable *arg1 = (bzs::db::protocol::tdap::client::activeTable *) 0 ;
  bzs::db::protocol::tdap::client::queryBase *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bzs::db::protocol::tdap::client::preparedQuery *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::activeTable *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::activeTable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::queryBase &","prepare", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::queryBase &","prepare", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp2);
  {
    try {
      result = (bzs::db::protocol::tdap::client::preparedQuery *)bzs_db_protocol_tdap_client_activeTable_prepare__SWIG_0(arg1,*arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__preparedQuery, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_activeTable_prepare(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_activeTable_prepare__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_activeTable_prepare__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "prepare.new", 
    "    prepare.new(bzs::db::protocol::tdap::client::queryBase &q, bool serverPrepare)\n"
    "    prepare.new(bzs::db::protocol::tdap::client::queryBase &q)\n");
  
  return Qnil;
}

SWIGINTERN VALUE _wrap_activeTable_join(int nargs, VALUE *args, VALUE self) {
  bzs::db::protocol::tdap::client::activeTable *arg1 =  0x00 ;
  bzs::db::protocol::tdap::client::recordset *arg2 = 0 ;
  bzs::db::protocol::tdap::client::queryBase *arg3q = 0 ;
  bzs::db::protocol::tdap::client::preparedQuery *arg3p = 0 ;
  _TCHAR *arg4 = (_TCHAR *) 0 ;
  _TCHAR *arg5 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  const _TCHAR* fdn[8]={NULL};

  //Check param count 
  if ( nargs > 10) SWIG_fail;
  
  //Get activeTable ptr
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::activeTable *","join", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::activeTable * >(argp1);

  //Get recordset ptr
  res2 = SWIG_ConvertPtr(args[0], &argp2, SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset &","join", 2, args[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::recordset &","join", 2, args[0])); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp2);

  //Get queryBase or preparedQuery ptr
  res3 = SWIG_ConvertPtr(args[1], &argp3, SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase,  0 );
  if (!SWIG_IsOK(res3)) {
    res3 = SWIG_ConvertPtr(args[1], &argp3, SWIGTYPE_p_bzs__db__protocol__tdap__client__preparedQuery,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "queryBase or preparedQuery &","join", 3, args[1] )); 
    }else{
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::preparedQuery &","join", 3, args[1])); 
      }
      arg3p = reinterpret_cast< bzs::db::protocol::tdap::client::preparedQuery * >(argp3);
    }
  }else {
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::queryBase &","join", 3, args[1])); 
    }
    arg3q = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp3);
  }
  
  //Get key field names 
  {
    int alloc = 0;
    char* buf = NULL;
    for (int i=2;i<nargs;++i)
    {
      int res = SWIG_AsCharPtrAndSize(args[i], &buf, NULL, &alloc);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "_TCHAR const *","join", i+2, args[i] ));
      }
      fdn[i-2] = reinterpret_cast<const _TCHAR * >(buf);
    }
  }
  
  //Execute join
  {
    try {
      if (arg3q)
        arg1->join(*arg2, *arg3q, fdn[0], fdn[1], fdn[2], fdn[3], fdn[4], fdn[5], fdn[6], fdn[7]);
      else
        arg1->join(*arg2, arg3p->getFilter(), fdn[0], fdn[1], fdn[2], fdn[3], fdn[4], fdn[5], fdn[6], fdn[7]);
      //result = *self;
      
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
    //vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable, 0 |  0 );
    return self;
  }

fail:
  Ruby_Format_OverloadedError( nargs+1, 11, "join", "    bzs::db::protocol::tdap::client::activeTable & join ");
  return Qnil;

}

SWIGINTERN VALUE _wrap_activeTable_outerJoin(int nargs, VALUE *args, VALUE self) {
  bzs::db::protocol::tdap::client::activeTable *arg1 =  0x00 ;
  bzs::db::protocol::tdap::client::recordset *arg2 = 0 ;
  bzs::db::protocol::tdap::client::queryBase *arg3q = 0 ;
  bzs::db::protocol::tdap::client::preparedQuery *arg3p = 0 ;
  _TCHAR *arg4 = (_TCHAR *) 0 ;
  _TCHAR *arg5 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  const _TCHAR* fdn[8]={NULL};

  //Check param count 
  if ( nargs > 10) SWIG_fail;
  
  //Get activeTable ptr
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::activeTable *","outerJoin", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::activeTable * >(argp1);

  //Get recordset ptr
  res2 = SWIG_ConvertPtr(args[0], &argp2, SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::recordset &","outerJoin", 2, args[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::recordset &","outerJoin", 2, args[0])); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::recordset * >(argp2);

  //Get queryBase or preparedQuery ptr
  res3 = SWIG_ConvertPtr(args[1], &argp3, SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase,  0 );
  if (!SWIG_IsOK(res3)) {
    res3 = SWIG_ConvertPtr(args[1], &argp3, SWIGTYPE_p_bzs__db__protocol__tdap__client__preparedQuery,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "queryBase or preparedQuery &","outerJoin", 3, args[1] )); 
    }else{
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::preparedQuery &","outerJoin", 3, args[1])); 
      }
      arg3p = reinterpret_cast< bzs::db::protocol::tdap::client::preparedQuery * >(argp3);
    }
  }else {
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::queryBase &","outerJoin", 3, args[1])); 
    }
    arg3q = reinterpret_cast< bzs::db::protocol::tdap::client::queryBase * >(argp3);
  }
  
  //Get key filed names 
  {
    int alloc = 0;
    char* buf = NULL;
    for (int i=2;i<nargs;++i)
    {
      int res = SWIG_AsCharPtrAndSize(args[i], &buf, NULL, &alloc);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "_TCHAR const *","outerJoin", i+2, args[i] ));
      }
      fdn[i-2] = reinterpret_cast< const _TCHAR * >(buf);
    }
  }
  
  //Execute outerJoin
  {
    try {
      if (arg3q)
        arg1->outerJoin(*arg2, *arg3q, fdn[0], fdn[1], fdn[2], fdn[3], fdn[4], fdn[5], fdn[6], fdn[7]);
      else
        arg1->outerJoin(*arg2, arg3p->getFilter(), fdn[0], fdn[1], fdn[2], fdn[3], fdn[4], fdn[5], fdn[6], fdn[7]);
      //result = *self;
      
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
    //vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable, 0 |  0 );
    return self;
  }

fail:
  Ruby_Format_OverloadedError( nargs+1, 11, "outerJoin", "    bzs::db::protocol::tdap::client::activeTable & outerJoin ");
  return Qnil;

}



SWIGINTERN VALUE
_wrap_activeTable_release(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::activeTable *arg1 = (bzs::db::protocol::tdap::client::activeTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::activeTable *","release", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::activeTable * >(argp1);
  {
    try {
      bzs_db_protocol_tdap_client_activeTable_release(arg1);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_activeTable_table(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::activeTable *arg1 = (bzs::db::protocol::tdap::client::activeTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::table *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::activeTable *","table", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::activeTable * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::table *)bzs_db_protocol_tdap_client_activeTable_table(arg1);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE _wrap_activeTable_keyValue(int nargs, VALUE *args, VALUE self) {
  bzs::db::protocol::tdap::client::activeTable *arg1 = 0x00;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  //Get activeTable ptr
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::activeTable *","join", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::activeTable * >(argp1);
  {
      //Get internal table tabledef keydef
    bzs::db::protocol::tdap::client::table_ptr tb = arg1->table();
    const bzs::db::protocol::tdap::tabledef* td = tb->tableDef();
    const bzs::db::protocol::tdap::keydef* kd = &td->keyDefs[tb->keyNum()];
    
    //Check keynum
    if (tb->keyNum() >= td->keyCount){
      SWIG_exception_fail(SWIG_ValueError, "Key number error.\n Invalid key number."); 
    }
    
    // Set params
    tb->clearBuffer();
    for (int i = 0; i < nargs; ++i){
      if (kd->segmentCount <= i)
        break;
      ushort_td fnum = kd->segments[i].fieldNum;
      VALUE type = TYPE(args[i]);
      if ((type == T_FIXNUM) || (type == T_BIGNUM)){
        long long val = 0;
        int ecode = SWIG_AsVal_long_SS_long(args[i], &val);
        if (!SWIG_IsOK(ecode)) {
          SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "__int64","keyValue", i+1, args[i]));
        }
        tb->setFV(fnum, (__int64)val);
      }
      else if (type == T_STRING){
          SWIG_CHAR buf;
          int ret = SWIG_AsCharPtrAndSize(args[i], &buf.str, NULL, &buf.alloc);
        if (!SWIG_IsOK(ret)) {
          SWIG_exception_fail(SWIG_ArgError(ret), Ruby_Format_TypeError( "", "char *const","keyValue", i+1, args[i]));
        }
        tb->setFV(fnum, buf.str);
      }
      else if (type == T_FLOAT){
        double val = 0;
        int ecode = SWIG_AsVal_double(args[i], &val);
        if (!SWIG_IsOK(ecode)) {
          SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "double","keyValue", i+1, args[i]));
        }
        tb->setFV(fnum, val);
      }
      else
        tb->setFV(fnum, (int)0);
    }
    return self;
  }

fail:
  Ruby_Format_OverloadedError(nargs+1, 10, "activeTable.keyValue","    bzs::db::protocol::tdap::client::activeTable & keyValue");
return Qnil;

}


static swig_class SwigClassPooledDbManager;

SWIGINTERN VALUE
_wrap_new_pooledDbManager__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::pooledDbManager *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bzs::db::protocol::tdap::client::pooledDbManager *)new bzs::db::protocol::tdap::client::pooledDbManager();
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_pooledDbManager_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_pooledDbManager_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_pooledDbManager__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::connectParams *arg1 = (bzs::db::protocol::tdap::client::connectParams *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::pooledDbManager *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__connectParams, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::connectParams const *","pooledDbManager", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::connectParams * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::pooledDbManager *)new bzs::db::protocol::tdap::client::pooledDbManager((bzs::db::protocol::tdap::client::connectParams const *)arg1);
      DATA_PTR(self) = result;
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_pooledDbManager(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_pooledDbManager__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__connectParams, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_pooledDbManager__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "pooledDbManager.new", 
    "    pooledDbManager.new()\n"
    "    pooledDbManager.new(bzs::db::protocol::tdap::client::connectParams const *param)\n");
  
  return Qnil;
}


SWIGINTERN void
free_bzs_db_protocol_tdap_client_pooledDbManager(bzs::db::protocol::tdap::client::pooledDbManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_pooledDbManager_use__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::pooledDbManager *arg1 = (bzs::db::protocol::tdap::client::pooledDbManager *) 0 ;
  bzs::db::protocol::tdap::client::connectParams *arg2 = (bzs::db::protocol::tdap::client::connectParams *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::pooledDbManager *","use", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::pooledDbManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bzs__db__protocol__tdap__client__connectParams, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::connectParams const *","use", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::connectParams * >(argp2);
  {
    try {
      (arg1)->use((bzs::db::protocol::tdap::client::connectParams const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_pooledDbManager_use__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::pooledDbManager *arg1 = (bzs::db::protocol::tdap::client::pooledDbManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::pooledDbManager *","use", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::pooledDbManager * >(argp1);
  {
    try {
      (arg1)->use();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_pooledDbManager_use(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_pooledDbManager_use__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__connectParams, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_pooledDbManager_use__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "pooledDbManager.use", 
    "    void pooledDbManager.use(bzs::db::protocol::tdap::client::connectParams const *param)\n"
    "    void pooledDbManager.use()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_pooledDbManager_unUse(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::pooledDbManager *arg1 = (bzs::db::protocol::tdap::client::pooledDbManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::pooledDbManager *","unUse", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::pooledDbManager * >(argp1);
  {
    try {
      (arg1)->unUse();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_pooledDbManager_reset(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::pooledDbManager *arg1 = (bzs::db::protocol::tdap::client::pooledDbManager *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::pooledDbManager *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::pooledDbManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","reset", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->reset(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_pooledDbManager_db(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::pooledDbManager *arg1 = (bzs::db::protocol::tdap::client::pooledDbManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bzs::db::protocol::tdap::client::database *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::pooledDbManager const *","db", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::pooledDbManager * >(argp1);
  {
    try {
      result = (bzs::db::protocol::tdap::client::database *)((bzs::db::protocol::tdap::client::pooledDbManager const *)arg1)->db();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__database, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_pooledDbManager_uri(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::pooledDbManager *arg1 = (bzs::db::protocol::tdap::client::pooledDbManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _TCHAR *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::pooledDbManager const *","uri", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::pooledDbManager * >(argp1);
  {
    try {
      result = (_TCHAR *)((bzs::db::protocol::tdap::client::pooledDbManager const *)arg1)->uri();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  {
    vresult = rb_enc_str_new(result, strlen(result), rb_enc_find_from_codepage(CP_UTF8));
  }
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_pooledDbManager_mode(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::pooledDbManager *arg1 = (bzs::db::protocol::tdap::client::pooledDbManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::pooledDbManager const *","mode", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::pooledDbManager * >(argp1);
  {
    try {
      result = (char_td)((bzs::db::protocol::tdap::client::pooledDbManager const *)arg1)->mode();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_char(static_cast< char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_pooledDbManager_isOpened(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::pooledDbManager *arg1 = (bzs::db::protocol::tdap::client::pooledDbManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::pooledDbManager const *","isOpened", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::pooledDbManager * >(argp1);
  {
    try {
      result = (bool)((bzs::db::protocol::tdap::client::pooledDbManager const *)arg1)->isOpened();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_pooledDbManager_setOption(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::pooledDbManager *arg1 = (bzs::db::protocol::tdap::client::pooledDbManager *) 0 ;
  __int64 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::pooledDbManager *","setOption", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::pooledDbManager * >(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "__int64","setOption", 2, argv[0] ));
  } 
  arg2 = static_cast< __int64 >(val2);
  {
    try {
      (arg1)->setOption(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_pooledDbManager_option(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::pooledDbManager *arg1 = (bzs::db::protocol::tdap::client::pooledDbManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  __int64 result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::pooledDbManager *","option", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::pooledDbManager * >(argp1);
  {
    try {
      result = (arg1)->option();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_long_SS_long(static_cast< long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_pooledDbManager_beginTrn(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::pooledDbManager *arg1 = (bzs::db::protocol::tdap::client::pooledDbManager *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::pooledDbManager *","beginTrn", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::pooledDbManager * >(argp1);
  ecode2 = SWIG_AsVal_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","beginTrn", 2, argv[0] ));
  } 
  arg2 = static_cast< short >(val2);
  {
    try {
      (arg1)->beginTrn(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_pooledDbManager_endTrn(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::pooledDbManager *arg1 = (bzs::db::protocol::tdap::client::pooledDbManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::pooledDbManager *","endTrn", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::pooledDbManager * >(argp1);
  {
    try {
      (arg1)->endTrn();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_pooledDbManager_abortTrn(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::pooledDbManager *arg1 = (bzs::db::protocol::tdap::client::pooledDbManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::pooledDbManager *","abortTrn", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::pooledDbManager * >(argp1);
  {
    try {
      (arg1)->abortTrn();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_pooledDbManager_enableTrn(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::pooledDbManager *arg1 = (bzs::db::protocol::tdap::client::pooledDbManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::pooledDbManager *","enableTrn", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::pooledDbManager * >(argp1);
  {
    try {
      result = (int)(arg1)->enableTrn();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_pooledDbManager_beginSnapshot(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  bzs::db::protocol::tdap::client::pooledDbManager *arg1 = 0x00;
  short arg2;
  short val2;
  
  int _v;
  void *vptr = 0;
  int res;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  // check arg1 (nsdatabase)
  res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0);
  _v = SWIG_CheckState(res);
  if (! _v) SWIG_fail;
  if (!SWIG_IsOK(res)) {
    SWIG_exception_fail(SWIG_ArgError(res),
      Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::pooledDbManager *","beginSnapshot", 1, argv[0] ));
  }
  // cast arg1
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::pooledDbManager * >(vptr);
  // call beginSnapshot()
  if (argc == 1) {
    try {
      (arg1)->beginSnapshot();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
    return Qnil;
  }
  // check arg2
  if (argc == 2) {
    int res = SWIG_AsVal_short(argv[1], &val2);
    _v = SWIG_CheckState(res);
    if (! _v) SWIG_fail;
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "short","beginSnapshot", 2, argv[1] ));
    }
    // cast arg2
    arg2 = static_cast< short >(val2);
    // call beginSnapshot(short bias)
    try {
      (arg1)->beginSnapshot(arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
    return Qnil;
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "pooledDbManager.beginSnapshot", 
    "    void pooledDbManager.beginSnapshot(short bias)\n"
    "    void pooledDbManager.beginSnapshot()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_pooledDbManager_endSnapshot(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::pooledDbManager *arg1 = (bzs::db::protocol::tdap::client::pooledDbManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::pooledDbManager *","endSnapshot", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::pooledDbManager * >(argp1);
  {
    try {
      (arg1)->endSnapshot();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_pooledDbManager_stat(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::pooledDbManager *arg1 = (bzs::db::protocol::tdap::client::pooledDbManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short_td result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::pooledDbManager const *","stat", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::pooledDbManager * >(argp1);
  {
    try {
      result = (short_td)((bzs::db::protocol::tdap::client::pooledDbManager const *)arg1)->stat();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_short(static_cast< short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_pooledDbManager_clientID(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::pooledDbManager *arg1 = (bzs::db::protocol::tdap::client::pooledDbManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uchar_td *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::pooledDbManager const *","clientID", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::pooledDbManager * >(argp1);
  {
    try {
      result = (uchar_td *)((bzs::db::protocol::tdap::client::pooledDbManager const *)arg1)->clientID();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_pooledDbManager_setMaxConnections(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","bzs::db::protocol::tdap::client::pooledDbManager::setMaxConnections", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      bzs::db::protocol::tdap::client::pooledDbManager::setMaxConnections(arg1);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_pooledDbManager_maxConnections(int argc, VALUE *argv, VALUE self) {
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (int)bzs::db::protocol::tdap::client::pooledDbManager::maxConnections();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_pooledDbManager_reserve(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  bzs::db::protocol::tdap::client::connectParams *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","bzs::db::protocol::tdap::client::pooledDbManager::reserve", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_bzs__db__protocol__tdap__client__connectParams,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::connectParams const &","bzs::db::protocol::tdap::client::pooledDbManager::reserve", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bzs::db::protocol::tdap::client::connectParams const &","bzs::db::protocol::tdap::client::pooledDbManager::reserve", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< bzs::db::protocol::tdap::client::connectParams * >(argp2);
  {
    try {
      bzs::db::protocol::tdap::client::pooledDbManager::reserve(arg1,(bzs::db::protocol::tdap::client::connectParams const &)*arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_pooledDbManager_usingCount(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::pooledDbManager *arg1 = (bzs::db::protocol::tdap::client::pooledDbManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::pooledDbManager const *","usingCount", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::pooledDbManager * >(argp1);
  {
    try {
      result = (int)((bzs::db::protocol::tdap::client::pooledDbManager const *)arg1)->usingCount();
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_pooledDbManager_table(int argc, VALUE *argv, VALUE self) {
  bzs::db::protocol::tdap::client::pooledDbManager *arg1 = (bzs::db::protocol::tdap::client::pooledDbManager *) 0 ;
  _TCHAR *arg2 = (_TCHAR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bzs::db::protocol::tdap::client::table *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "bzs::db::protocol::tdap::client::pooledDbManager *","table", 1, self )); 
  }
  arg1 = reinterpret_cast< bzs::db::protocol::tdap::client::pooledDbManager * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_TCHAR const *","table", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< _TCHAR * >(buf2);
  {
    try {
      result = (bzs::db::protocol::tdap::client::table *)bzs_db_protocol_tdap_client_pooledDbManager_table(arg1,(char const *)arg2);
    } catch (bzs::rtl::exception& e) {
      static VALUE bzs_rtl_error = rb_define_class("BZS_RTL_Error", rb_eStandardError);
      rb_raise(bzs_rtl_error, (* bzs::rtl::getMsg(e)).c_str());
    } catch (std::exception &e) {
      static VALUE cpp_std_error = rb_define_class("CPP_STD_Error", rb_eStandardError);
      rb_raise(cpp_std_error, e.what());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bzs__db__protocol__tdap__client__table, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}



/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_bzs__db__protocol__tdap__client__recordsetQueryTo_p_bzs__db__protocol__tdap__client__query(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::query *)  ((bzs::db::protocol::tdap::client::recordsetQuery *) x));
}
static void *_p_bzs__db__protocol__tdap__client__databaseTo_p_bzs__db__protocol__tdap__client__nsdatabase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::nsdatabase *)  ((bzs::db::protocol::tdap::client::database *) x));
}
static void *_p_bzs__db__protocol__tdap__fielddefTo_p_bzs__db__protocol__tdap__fielddef_tT_64_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::fielddef_t< 64 > *)  ((bzs::db::protocol::tdap::fielddef *) x));
}
static void *_p_bzs__db__protocol__tdap__client__fielddefsTo_p_bzs__db__protocol__tdap__client__fieldShare(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::fieldShare *)  ((bzs::db::protocol::tdap::client::fielddefs *) x));
}
static void *_p_bzs__db__protocol__tdap__client__maxTo_p_bzs__db__protocol__tdap__client__sum(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::sum *)  ((bzs::db::protocol::tdap::client::max *) x));
}
static void *_p_bzs__db__protocol__tdap__client__avgTo_p_bzs__db__protocol__tdap__client__sum(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::sum *)  ((bzs::db::protocol::tdap::client::avg *) x));
}
static void *_p_bzs__db__protocol__tdap__client__minTo_p_bzs__db__protocol__tdap__client__sum(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::sum *)  ((bzs::db::protocol::tdap::client::min *) x));
}
static void *_p_bzs__db__protocol__tdap__client__maxTo_p_bzs__db__protocol__tdap__client__groupFuncBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::groupFuncBase *) (bzs::db::protocol::tdap::client::sum *) ((bzs::db::protocol::tdap::client::max *) x));
}
static void *_p_bzs__db__protocol__tdap__client__avgTo_p_bzs__db__protocol__tdap__client__groupFuncBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::groupFuncBase *) (bzs::db::protocol::tdap::client::sum *) ((bzs::db::protocol::tdap::client::avg *) x));
}
static void *_p_bzs__db__protocol__tdap__client__minTo_p_bzs__db__protocol__tdap__client__groupFuncBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::groupFuncBase *) (bzs::db::protocol::tdap::client::sum *) ((bzs::db::protocol::tdap::client::min *) x));
}
static void *_p_bzs__db__protocol__tdap__client__sumTo_p_bzs__db__protocol__tdap__client__groupFuncBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::groupFuncBase *)  ((bzs::db::protocol::tdap::client::sum *) x));
}
static void *_p_bzs__db__protocol__tdap__client__countTo_p_bzs__db__protocol__tdap__client__groupFuncBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::groupFuncBase *)  ((bzs::db::protocol::tdap::client::count *) x));
}
static void *_p_bzs__db__protocol__tdap__client__lastTo_p_bzs__db__protocol__tdap__client__groupFuncBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::groupFuncBase *)  ((bzs::db::protocol::tdap::client::last *) x));
}
static void *_p_bzs__db__protocol__tdap__client__firstTo_p_bzs__db__protocol__tdap__client__groupFuncBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::groupFuncBase *)  ((bzs::db::protocol::tdap::client::first *) x));
}
static void *_p_bzs__db__protocol__tdap__client__memoryRecordTo_p_bzs__db__protocol__tdap__client__fieldsBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::fieldsBase *)  ((bzs::db::protocol::tdap::client::memoryRecord *) x));
}
static void *_p_bzs__db__protocol__tdap__client__writableRecordTo_p_bzs__db__protocol__tdap__client__fieldsBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::fieldsBase *) (bzs::db::protocol::tdap::client::memoryRecord *) ((bzs::db::protocol::tdap::client::writableRecord *) x));
}
static void *_p_bzs__db__protocol__tdap__client__fieldsTo_p_bzs__db__protocol__tdap__client__fieldsBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::fieldsBase *)  ((bzs::db::protocol::tdap::client::fields *) x));
}
static void *_p_p_bzs__db__protocol__tdap__client__memoryRecordTo_p_p_bzs__db__protocol__tdap__client__fieldsBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::fieldsBase **)  ((bzs::db::protocol::tdap::client::memoryRecord **) x));
}
static void *_p_p_bzs__db__protocol__tdap__client__writableRecordTo_p_p_bzs__db__protocol__tdap__client__fieldsBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::fieldsBase **) (bzs::db::protocol::tdap::client::memoryRecord *) ((bzs::db::protocol::tdap::client::writableRecord **) x));
}
static void *_p_p_bzs__db__protocol__tdap__client__fieldsTo_p_p_bzs__db__protocol__tdap__client__fieldsBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::fieldsBase **)  ((bzs::db::protocol::tdap::client::fields **) x));
}
static void *_p_bzs__db__protocol__tdap__client__queryTo_p_bzs__db__protocol__tdap__client__queryBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::queryBase *)  ((bzs::db::protocol::tdap::client::query *) x));
}
static void *_p_bzs__db__protocol__tdap__client__fieldsBaseTo_p_bzs__db__protocol__tdap__client__refarymem(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::refarymem *)  ((bzs::db::protocol::tdap::client::fieldsBase *) x));
}
static void *_p_bzs__db__protocol__tdap__client__autoMemoryTo_p_bzs__db__protocol__tdap__client__refarymem(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::refarymem *)  ((bzs::db::protocol::tdap::client::autoMemory *) x));
}
static void *_p_bzs__db__protocol__tdap__client__memoryRecordTo_p_bzs__db__protocol__tdap__client__refarymem(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::refarymem *) (bzs::db::protocol::tdap::client::fieldsBase *) ((bzs::db::protocol::tdap::client::memoryRecord *) x));
}
static void *_p_bzs__db__protocol__tdap__client__writableRecordTo_p_bzs__db__protocol__tdap__client__refarymem(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::refarymem *) (bzs::db::protocol::tdap::client::fieldsBase *)(bzs::db::protocol::tdap::client::memoryRecord *) ((bzs::db::protocol::tdap::client::writableRecord *) x));
}
static void *_p_bzs__db__protocol__tdap__client__fieldsTo_p_bzs__db__protocol__tdap__client__refarymem(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::refarymem *) (bzs::db::protocol::tdap::client::fieldsBase *) ((bzs::db::protocol::tdap::client::fields *) x));
}
static void *_p_bzs__db__protocol__tdap__client__dbdefTo_p_bzs__db__protocol__tdap__client__nstable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::nstable *)  ((bzs::db::protocol::tdap::client::dbdef *) x));
}
static void *_p_bzs__db__protocol__tdap__client__tableTo_p_bzs__db__protocol__tdap__client__nstable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::nstable *)  ((bzs::db::protocol::tdap::client::table *) x));
}
static void *_p_bzs__db__protocol__tdap__client__writableRecordTo_p_bzs__db__protocol__tdap__client__memoryRecord(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::memoryRecord *)  ((bzs::db::protocol::tdap::client::writableRecord *) x));
}
static void *_p_bzs__db__protocol__tdap__client__pooledDbManagerTo_p_bzs__db__protocol__tdap__client__idatabaseManager(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::idatabaseManager *)  ((bzs::db::protocol::tdap::client::pooledDbManager *) x));
}
static void *_p_bzs__db__protocol__tdap__client__maxTo_p_bzs__db__protocol__tdap__client__recordsetQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::recordsetQuery *) (bzs::db::protocol::tdap::client::groupFuncBase *)(bzs::db::protocol::tdap::client::sum *) ((bzs::db::protocol::tdap::client::max *) x));
}
static void *_p_bzs__db__protocol__tdap__client__avgTo_p_bzs__db__protocol__tdap__client__recordsetQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::recordsetQuery *) (bzs::db::protocol::tdap::client::groupFuncBase *)(bzs::db::protocol::tdap::client::sum *) ((bzs::db::protocol::tdap::client::avg *) x));
}
static void *_p_bzs__db__protocol__tdap__client__minTo_p_bzs__db__protocol__tdap__client__recordsetQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::recordsetQuery *) (bzs::db::protocol::tdap::client::groupFuncBase *)(bzs::db::protocol::tdap::client::sum *) ((bzs::db::protocol::tdap::client::min *) x));
}
static void *_p_bzs__db__protocol__tdap__client__sumTo_p_bzs__db__protocol__tdap__client__recordsetQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::recordsetQuery *) (bzs::db::protocol::tdap::client::groupFuncBase *) ((bzs::db::protocol::tdap::client::sum *) x));
}
static void *_p_bzs__db__protocol__tdap__client__groupFuncBaseTo_p_bzs__db__protocol__tdap__client__recordsetQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::recordsetQuery *)  ((bzs::db::protocol::tdap::client::groupFuncBase *) x));
}
static void *_p_bzs__db__protocol__tdap__client__countTo_p_bzs__db__protocol__tdap__client__recordsetQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::recordsetQuery *) (bzs::db::protocol::tdap::client::groupFuncBase *) ((bzs::db::protocol::tdap::client::count *) x));
}
static void *_p_bzs__db__protocol__tdap__client__lastTo_p_bzs__db__protocol__tdap__client__recordsetQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::recordsetQuery *) (bzs::db::protocol::tdap::client::groupFuncBase *) ((bzs::db::protocol::tdap::client::last *) x));
}
static void *_p_bzs__db__protocol__tdap__client__firstTo_p_bzs__db__protocol__tdap__client__recordsetQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((bzs::db::protocol::tdap::client::recordsetQuery *) (bzs::db::protocol::tdap::client::groupFuncBase *) ((bzs::db::protocol::tdap::client::first *) x));
}
static swig_type_info _swigt__p_BOOKMARK = { "_p_BOOKMARK", "bookmark_td *|BOOKMARK *", 0, 0, (void*)0, 0 };
static swig_type_info _swigt__p_HWND = {"_p_HWND", "HWND *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_boost__functionT_int_fbzs__db__protocol__tdap__client__fields_const_RF_t = {"_p_boost__functionT_int_fbzs__db__protocol__tdap__client__fields_const_RF_t", "boost::function< int (bzs::db::protocol::tdap::client::fields const &) > *|bzs::db::protocol::tdap::client::validationFunc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_boost__shared_ptrT_bzs__db__protocol__tdap__client__database_t = {"_p_boost__shared_ptrT_bzs__db__protocol__tdap__client__database_t", "boost::shared_ptr< bzs::db::protocol::tdap::client::database > *|bzs::db::protocol::tdap::client::database_ptr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_boost__shared_ptrT_bzs__db__protocol__tdap__client__filter_t = {"_p_boost__shared_ptrT_bzs__db__protocol__tdap__client__filter_t", "boost::shared_ptr< bzs::db::protocol::tdap::client::filter > *|bzs::db::protocol::tdap::client::pq_handle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_boost__shared_ptrT_bzs__db__protocol__tdap__client__idatabaseManager_t = {"_p_boost__shared_ptrT_bzs__db__protocol__tdap__client__idatabaseManager_t", "boost::shared_ptr< bzs::db::protocol::tdap::client::idatabaseManager > *|bzs::db::protocol::tdap::client::dbmanager_ptr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_boost__shared_ptrT_bzs__db__protocol__tdap__client__table_t = {"_p_boost__shared_ptrT_bzs__db__protocol__tdap__client__table_t", "boost::shared_ptr< bzs::db::protocol::tdap::client::table > *|bzs::db::protocol::tdap::client::table_ptr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_boost__timer = {"_p_boost__timer", "boost::timer *|boost_timer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__FLAGS = {"_p_bzs__db__protocol__tdap__FLAGS", "bzs::db::protocol::tdap::FLAGS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__btrDate = {"_p_bzs__db__protocol__tdap__btrDate", "bzs::db::protocol::tdap::btrDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__btrDateTime = {"_p_bzs__db__protocol__tdap__btrDateTime", "bzs::db::protocol::tdap::btrDateTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__btrTime = {"_p_bzs__db__protocol__tdap__btrTime", "bzs::db::protocol::tdap::btrTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__btrTimeStamp = {"_p_bzs__db__protocol__tdap__btrTimeStamp", "bzs::db::protocol::tdap::btrTimeStamp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__btrVersion = {"_p_bzs__db__protocol__tdap__btrVersion", "bzs::db::protocol::tdap::btrVersion *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__btrVersions = {"_p_bzs__db__protocol__tdap__btrVersions", "bzs::db::protocol::tdap::btrVersions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__activeTable = {"_p_bzs__db__protocol__tdap__client__activeTable", "bzs::db::protocol::tdap::client::activeTable *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__avg = {"_p_bzs__db__protocol__tdap__client__avg", "bzs::db::protocol::tdap::client::avg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__connectParams = {"_p_bzs__db__protocol__tdap__client__connectParams", "bzs::db::protocol::tdap::client::connectParams *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__count = {"_p_bzs__db__protocol__tdap__client__count", "bzs::db::protocol::tdap::client::count *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__database = {"_p_bzs__db__protocol__tdap__client__database", "bzs::db::protocol::tdap::client::database *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__dbdef = {"_p_bzs__db__protocol__tdap__client__dbdef", "bzs::db::protocol::tdap::client::dbdef *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__field = {"_p_bzs__db__protocol__tdap__client__field", "bzs::db::protocol::tdap::client::field *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__fieldNames = {"_p_bzs__db__protocol__tdap__client__fieldNames", "bzs::db::protocol::tdap::client::fieldNames *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__fieldShare = {"_p_bzs__db__protocol__tdap__client__fieldShare", "bzs::db::protocol::tdap::client::fieldShare *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__fielddefs = {"_p_bzs__db__protocol__tdap__client__fielddefs", "bzs::db::protocol::tdap::client::fielddefs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__fields = {"_p_bzs__db__protocol__tdap__client__fields", "bzs::db::protocol::tdap::client::fields *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__fieldsBase = {"_p_bzs__db__protocol__tdap__client__fieldsBase", "bzs::db::protocol::tdap::client::fieldsBase *|bzs::db::protocol::tdap::client::row *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexFindNavi_t_t = {"_p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexFindNavi_t_t", "bzs::db::protocol::tdap::client::filterdIterator< bzs::db::protocol::tdap::client::tableIterator< indexFindNavi > > *|bzs::db::protocol::tdap::client::filterdFindIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexNavi_t_t = {"_p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexNavi_t_t", "bzs::db::protocol::tdap::client::filterdIterator< bzs::db::protocol::tdap::client::tableIterator< indexNavi > > *|bzs::db::protocol::tdap::client::filterdIndexIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexRvFindNavi_t_t = {"_p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexRvFindNavi_t_t", "bzs::db::protocol::tdap::client::filterdIterator< bzs::db::protocol::tdap::client::tableIterator< indexRvFindNavi > > *|bzs::db::protocol::tdap::client::filterdFindRvIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexRvNavi_t_t = {"_p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexRvNavi_t_t", "bzs::db::protocol::tdap::client::filterdIterator< bzs::db::protocol::tdap::client::tableIterator< indexRvNavi > > *|bzs::db::protocol::tdap::client::filterdIndexRvIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_stepNavi_t_t = {"_p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_stepNavi_t_t", "bzs::db::protocol::tdap::client::filterdIterator< bzs::db::protocol::tdap::client::tableIterator< stepNavi > > *|bzs::db::protocol::tdap::client::filterdStepIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_stepRvNavi_t_t = {"_p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_stepRvNavi_t_t", "bzs::db::protocol::tdap::client::filterdIterator< bzs::db::protocol::tdap::client::tableIterator< stepRvNavi > > *|bzs::db::protocol::tdap::client::filterdStepRvIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__first = {"_p_bzs__db__protocol__tdap__client__first", "bzs::db::protocol::tdap::client::first *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__groupFuncBase = {"_p_bzs__db__protocol__tdap__client__groupFuncBase", "bzs::db::protocol::tdap::client::groupFuncBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__groupQuery = {"_p_bzs__db__protocol__tdap__client__groupQuery", "bzs::db::protocol::tdap::client::groupQuery *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__idatabaseManager = {"_p_bzs__db__protocol__tdap__client__idatabaseManager", "bzs::db::protocol::tdap::client::idatabaseManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__last = {"_p_bzs__db__protocol__tdap__client__last", "bzs::db::protocol::tdap::client::last *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__max = {"_p_bzs__db__protocol__tdap__client__max", "bzs::db::protocol::tdap::client::max *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__memoryRecord = {"_p_bzs__db__protocol__tdap__client__memoryRecord", "bzs::db::protocol::tdap::client::memoryRecord *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__min = {"_p_bzs__db__protocol__tdap__client__min", "bzs::db::protocol::tdap::client::min *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__nsdatabase = {"_p_bzs__db__protocol__tdap__client__nsdatabase", "bzs::db::protocol::tdap::client::nsdatabase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__nstable = {"_p_bzs__db__protocol__tdap__client__nstable", "bzs::db::protocol::tdap::client::nstable *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__pooledDbManager = {"_p_bzs__db__protocol__tdap__client__pooledDbManager", "bzs::db::protocol::tdap::client::pooledDbManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__preparedQuery = {"_p_bzs__db__protocol__tdap__client__preparedQuery", "bzs::db::protocol::tdap::client::preparedQuery *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__query = {"_p_bzs__db__protocol__tdap__client__query", "bzs::db::protocol::tdap::client::query *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__queryBase = {"_p_bzs__db__protocol__tdap__client__queryBase", "bzs::db::protocol::tdap::client::queryBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__recordset = {"_p_bzs__db__protocol__tdap__client__recordset", "bzs::db::protocol::tdap::client::recordset *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__recordsetQuery = {"_p_bzs__db__protocol__tdap__client__recordsetQuery", "bzs::db::protocol::tdap::client::recordsetQuery *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__refarymem = {"_p_bzs__db__protocol__tdap__client__refarymem", "bzs::db::protocol::tdap::client::refarymem *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__autoMemory = {"_p_bzs__db__protocol__tdap__client__autoMemory", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__snapshotT_boost__shared_ptrT_bzs__db__protocol__tdap__client__database_t_t = {"_p_bzs__db__protocol__tdap__client__snapshotT_boost__shared_ptrT_bzs__db__protocol__tdap__client__database_t_t", "bzs::db::protocol::tdap::client::dbSnapshot *|bzs::db::protocol::tdap::client::snapshot< boost::shared_ptr< bzs::db::protocol::tdap::client::database > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__snapshotT_bzs__db__protocol__tdap__client__idatabaseManager_p_t = {"_p_bzs__db__protocol__tdap__client__snapshotT_bzs__db__protocol__tdap__client__idatabaseManager_p_t", "bzs::db::protocol::tdap::client::snapshot< bzs::db::protocol::tdap::client::idatabaseManager * > *|bzs::db::protocol::tdap::client::dbmSnapshot *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__sortField = {"_p_bzs__db__protocol__tdap__client__sortField", "bzs::db::protocol::tdap::client::sortField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__sortFields = {"_p_bzs__db__protocol__tdap__client__sortFields", "bzs::db::protocol::tdap::client::sortFields *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__sum = {"_p_bzs__db__protocol__tdap__client__sum", "bzs::db::protocol::tdap::client::sum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__table = {"_p_bzs__db__protocol__tdap__client__table", "bzs::db::protocol::tdap::client::table *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__tableIteratorT_indexFindNavi_t = {"_p_bzs__db__protocol__tdap__client__tableIteratorT_indexFindNavi_t", "bzs::db::protocol::tdap::client::tableIterator< indexFindNavi > *|bzs::db::protocol::tdap::client::findIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__tableIteratorT_indexNavi_t = {"_p_bzs__db__protocol__tdap__client__tableIteratorT_indexNavi_t", "bzs::db::protocol::tdap::client::tableIterator< indexNavi > *|bzs::db::protocol::tdap::client::indexIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__tableIteratorT_indexRvFindNavi_t = {"_p_bzs__db__protocol__tdap__client__tableIteratorT_indexRvFindNavi_t", "bzs::db::protocol::tdap::client::tableIterator< indexRvFindNavi > *|bzs::db::protocol::tdap::client::findRvIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__tableIteratorT_indexRvNavi_t = {"_p_bzs__db__protocol__tdap__client__tableIteratorT_indexRvNavi_t", "bzs::db::protocol::tdap::client::tableIterator< indexRvNavi > *|bzs::db::protocol::tdap::client::indexRvIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__tableIteratorT_stepNavi_t = {"_p_bzs__db__protocol__tdap__client__tableIteratorT_stepNavi_t", "bzs::db::protocol::tdap::client::stepIterator *|bzs::db::protocol::tdap::client::tableIterator< stepNavi > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__tableIteratorT_stepRvNavi_t = {"_p_bzs__db__protocol__tdap__client__tableIteratorT_stepRvNavi_t", "bzs::db::protocol::tdap::client::stepRvIterator *|bzs::db::protocol::tdap::client::tableIterator< stepRvNavi > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__transactionT_boost__shared_ptrT_bzs__db__protocol__tdap__client__database_t_t = {"_p_bzs__db__protocol__tdap__client__transactionT_boost__shared_ptrT_bzs__db__protocol__tdap__client__database_t_t", "bzs::db::protocol::tdap::client::transaction< boost::shared_ptr< bzs::db::protocol::tdap::client::database > > *|bzs::db::protocol::tdap::client::dbTransaction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__transactionT_boost__shared_ptrT_bzs__db__protocol__tdap__client__idatabaseManager_t_t = {"_p_bzs__db__protocol__tdap__client__transactionT_boost__shared_ptrT_bzs__db__protocol__tdap__client__idatabaseManager_t_t", "bzs::db::protocol::tdap::client::transaction< boost::shared_ptr< bzs::db::protocol::tdap::client::idatabaseManager > > *|bzs::db::protocol::tdap::client::dbmTransaction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__client__writableRecord = {"_p_bzs__db__protocol__tdap__client__writableRecord", "bzs::db::protocol::tdap::client::writableRecord *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__fielddef = {"_p_bzs__db__protocol__tdap__fielddef", "bzs::db::protocol::tdap::fielddef *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__fielddef_tT_20_t = {"_p_bzs__db__protocol__tdap__fielddef_tT_20_t", "bzs::db::protocol::tdap::fielddef_t_pv *|bzs::db::protocol::tdap::fielddef_t< 20 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__fielddef_tT_64_t = {"_p_bzs__db__protocol__tdap__fielddef_tT_64_t", "bzs::db::protocol::tdap::fielddef_t_my *|bzs::db::protocol::tdap::fielddef_t< 64 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__keySegment = {"_p_bzs__db__protocol__tdap__keySegment", "bzs::db::protocol::tdap::keySegment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__keydef = {"_p_bzs__db__protocol__tdap__keydef", "bzs::db::protocol::tdap::keydef *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__db__protocol__tdap__tabledef = {"_p_bzs__db__protocol__tdap__tabledef", "bzs::db::protocol::tdap::tabledef *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bzs__rtl__benchmark = {"_p_bzs__rtl__benchmark", "bzs::rtl::benchmark *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "_TCHAR *|char *|char_td *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_unsigned_short_p_void_p_void_p_unsigned_int_p_void_unsigned_short_char_p_unsigned_char__short = {"_p_f_unsigned_short_p_void_p_void_p_unsigned_int_p_void_unsigned_short_char_p_unsigned_char__short", "BTRCALLID_PTR|short (*)(unsigned short,void *,void *,unsigned int *,void *,unsigned short,char,unsigned char *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "int *|percentage_td *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iterator = {"_p_iterator", "iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_bzs__db__protocol__tdap__client__fieldsBase = {"_p_p_bzs__db__protocol__tdap__client__fieldsBase", "bzs::db::protocol::tdap::client::fieldsBase **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_bzs__db__protocol__tdap__client__memoryRecord = {"_p_p_bzs__db__protocol__tdap__client__memoryRecord", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_bzs__db__protocol__tdap__client__writableRecord = {"_p_p_bzs__db__protocol__tdap__client__writableRecord", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_bzs__db__protocol__tdap__client__fields = {"_p_p_bzs__db__protocol__tdap__client__fields", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_bzs__db__protocol__tdap__tabledef = {"_p_p_bzs__db__protocol__tdap__tabledef", "bzs::db::protocol::tdap::tabledef **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_preparedQuery = {"_p_preparedQuery", "preparedQuery *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_short = {"_p_short", "short *|short_td *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std___tstring = {"_p_std___tstring", "std::_tstring *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_bzs__db__protocol__tdap__client__fieldsBase_p_t__iterator = {"_p_std__vectorT_bzs__db__protocol__tdap__client__fieldsBase_p_t__iterator", "bzs::db::protocol::tdap::client::recordset::iterator *|std::vector< bzs::db::protocol::tdap::client::fieldsBase * >::iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_trdVersiton = {"_p_trdVersiton", "trdVersiton *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|uchar_td *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "bookmark_td *|unsigned int *|uint_td *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|ushort_td *|keylen_td *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_void = {"_p_void", "void *|void_td *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_BOOKMARK,
  &_swigt__p_HWND,
  &_swigt__p_boost__functionT_int_fbzs__db__protocol__tdap__client__fields_const_RF_t,
  &_swigt__p_boost__shared_ptrT_bzs__db__protocol__tdap__client__database_t,
  &_swigt__p_boost__shared_ptrT_bzs__db__protocol__tdap__client__filter_t,
  &_swigt__p_boost__shared_ptrT_bzs__db__protocol__tdap__client__idatabaseManager_t,
  &_swigt__p_boost__shared_ptrT_bzs__db__protocol__tdap__client__table_t,
  &_swigt__p_boost__timer,
  &_swigt__p_bzs__db__protocol__tdap__FLAGS,
  &_swigt__p_bzs__db__protocol__tdap__btrDate,
  &_swigt__p_bzs__db__protocol__tdap__btrDateTime,
  &_swigt__p_bzs__db__protocol__tdap__btrTime,
  &_swigt__p_bzs__db__protocol__tdap__btrTimeStamp,
  &_swigt__p_bzs__db__protocol__tdap__btrVersion,
  &_swigt__p_bzs__db__protocol__tdap__btrVersions,
  &_swigt__p_bzs__db__protocol__tdap__client__activeTable,
  &_swigt__p_bzs__db__protocol__tdap__client__autoMemory,
  &_swigt__p_bzs__db__protocol__tdap__client__avg,
  &_swigt__p_bzs__db__protocol__tdap__client__connectParams,
  &_swigt__p_bzs__db__protocol__tdap__client__count,
  &_swigt__p_bzs__db__protocol__tdap__client__database,
  &_swigt__p_bzs__db__protocol__tdap__client__dbdef,
  &_swigt__p_bzs__db__protocol__tdap__client__field,
  &_swigt__p_bzs__db__protocol__tdap__client__fieldNames,
  &_swigt__p_bzs__db__protocol__tdap__client__fieldShare,
  &_swigt__p_bzs__db__protocol__tdap__client__fielddefs,
  &_swigt__p_bzs__db__protocol__tdap__client__fields,
  &_swigt__p_bzs__db__protocol__tdap__client__fieldsBase,
  &_swigt__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexFindNavi_t_t,
  &_swigt__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexNavi_t_t,
  &_swigt__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexRvFindNavi_t_t,
  &_swigt__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexRvNavi_t_t,
  &_swigt__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_stepNavi_t_t,
  &_swigt__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_stepRvNavi_t_t,
  &_swigt__p_bzs__db__protocol__tdap__client__groupFuncBase,
  &_swigt__p_bzs__db__protocol__tdap__client__groupQuery,
  &_swigt__p_bzs__db__protocol__tdap__client__idatabaseManager,
  &_swigt__p_bzs__db__protocol__tdap__client__max,
  &_swigt__p_bzs__db__protocol__tdap__client__memoryRecord,
  &_swigt__p_bzs__db__protocol__tdap__client__min,
  &_swigt__p_bzs__db__protocol__tdap__client__nsdatabase,
  &_swigt__p_bzs__db__protocol__tdap__client__nstable,
  &_swigt__p_bzs__db__protocol__tdap__client__pooledDbManager,
  &_swigt__p_bzs__db__protocol__tdap__client__preparedQuery,
  &_swigt__p_bzs__db__protocol__tdap__client__query,
  &_swigt__p_bzs__db__protocol__tdap__client__queryBase,
  &_swigt__p_bzs__db__protocol__tdap__client__recordset,
  &_swigt__p_bzs__db__protocol__tdap__client__recordsetQuery,
  &_swigt__p_bzs__db__protocol__tdap__client__refarymem,
  &_swigt__p_bzs__db__protocol__tdap__client__snapshotT_boost__shared_ptrT_bzs__db__protocol__tdap__client__database_t_t,
  &_swigt__p_bzs__db__protocol__tdap__client__snapshotT_bzs__db__protocol__tdap__client__idatabaseManager_p_t,
  &_swigt__p_bzs__db__protocol__tdap__client__sortField,
  &_swigt__p_bzs__db__protocol__tdap__client__sortFields,
  &_swigt__p_bzs__db__protocol__tdap__client__sum,
  &_swigt__p_bzs__db__protocol__tdap__client__table,
  &_swigt__p_bzs__db__protocol__tdap__client__tableIteratorT_indexFindNavi_t,
  &_swigt__p_bzs__db__protocol__tdap__client__tableIteratorT_indexNavi_t,
  &_swigt__p_bzs__db__protocol__tdap__client__tableIteratorT_indexRvFindNavi_t,
  &_swigt__p_bzs__db__protocol__tdap__client__tableIteratorT_indexRvNavi_t,
  &_swigt__p_bzs__db__protocol__tdap__client__tableIteratorT_stepNavi_t,
  &_swigt__p_bzs__db__protocol__tdap__client__tableIteratorT_stepRvNavi_t,
  &_swigt__p_bzs__db__protocol__tdap__client__transactionT_boost__shared_ptrT_bzs__db__protocol__tdap__client__database_t_t,
  &_swigt__p_bzs__db__protocol__tdap__client__transactionT_boost__shared_ptrT_bzs__db__protocol__tdap__client__idatabaseManager_t_t,
  &_swigt__p_bzs__db__protocol__tdap__client__writableRecord,
  &_swigt__p_bzs__db__protocol__tdap__fielddef,
  &_swigt__p_bzs__db__protocol__tdap__fielddef_tT_20_t,
  &_swigt__p_bzs__db__protocol__tdap__fielddef_tT_64_t,
  &_swigt__p_bzs__db__protocol__tdap__keySegment,
  &_swigt__p_bzs__db__protocol__tdap__keydef,
  &_swigt__p_bzs__db__protocol__tdap__tabledef,
  &_swigt__p_bzs__rtl__benchmark,
  &_swigt__p_char,
  &_swigt__p_f_unsigned_short_p_void_p_void_p_unsigned_int_p_void_unsigned_short_char_p_unsigned_char__short,
  &_swigt__p_int,
  &_swigt__p_iterator,
  &_swigt__p_p_bzs__db__protocol__tdap__client__fields,
  &_swigt__p_p_bzs__db__protocol__tdap__client__fieldsBase,
  &_swigt__p_p_bzs__db__protocol__tdap__client__memoryRecord,
  &_swigt__p_p_bzs__db__protocol__tdap__client__writableRecord,
  &_swigt__p_p_bzs__db__protocol__tdap__tabledef,
  &_swigt__p_preparedQuery,
  &_swigt__p_short,
  &_swigt__p_std___tstring,
  &_swigt__p_std__vectorT_bzs__db__protocol__tdap__client__fieldsBase_p_t__iterator,
  &_swigt__p_trdVersiton,
  &_swigt__p_unsigned_char,
  &_swigt__p_unsigned_int,
  &_swigt__p_unsigned_short,
  &_swigt__p_value_type,
  &_swigt__p_void,
  &_swigt__p_bzs__db__protocol__tdap__client__last,
  &_swigt__p_bzs__db__protocol__tdap__client__first,
};
static swig_cast_info _swigc__p_BOOKMARK[] = { { &_swigt__p_BOOKMARK, 0, 0, 0 }, { 0, 0, 0, 0 } };
static swig_cast_info _swigc__p_HWND[] = {  {&_swigt__p_HWND, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_boost__functionT_int_fbzs__db__protocol__tdap__client__fields_const_RF_t[] = {  {&_swigt__p_boost__functionT_int_fbzs__db__protocol__tdap__client__fields_const_RF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_boost__shared_ptrT_bzs__db__protocol__tdap__client__database_t[] = {  {&_swigt__p_boost__shared_ptrT_bzs__db__protocol__tdap__client__database_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_boost__shared_ptrT_bzs__db__protocol__tdap__client__filter_t[] = {  {&_swigt__p_boost__shared_ptrT_bzs__db__protocol__tdap__client__filter_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_boost__shared_ptrT_bzs__db__protocol__tdap__client__idatabaseManager_t[] = {  {&_swigt__p_boost__shared_ptrT_bzs__db__protocol__tdap__client__idatabaseManager_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_boost__shared_ptrT_bzs__db__protocol__tdap__client__table_t[] = {  {&_swigt__p_boost__shared_ptrT_bzs__db__protocol__tdap__client__table_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_boost__timer[] = {  {&_swigt__p_boost__timer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__FLAGS[] = {  {&_swigt__p_bzs__db__protocol__tdap__FLAGS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__btrDate[] = {  {&_swigt__p_bzs__db__protocol__tdap__btrDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__btrDateTime[] = {  {&_swigt__p_bzs__db__protocol__tdap__btrDateTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__btrTime[] = {  {&_swigt__p_bzs__db__protocol__tdap__btrTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__btrTimeStamp[] = {  {&_swigt__p_bzs__db__protocol__tdap__btrTimeStamp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__btrVersion[] = {  {&_swigt__p_bzs__db__protocol__tdap__btrVersion, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__btrVersions[] = {  {&_swigt__p_bzs__db__protocol__tdap__btrVersions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__activeTable[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__activeTable, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__avg[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__avg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__connectParams[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__connectParams, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__count[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__count, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__database[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__database, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__dbdef[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__dbdef, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__field[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__field, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__fieldNames[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__fieldNames, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__fieldShare[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__fielddefs, _p_bzs__db__protocol__tdap__client__fielddefsTo_p_bzs__db__protocol__tdap__client__fieldShare, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__fieldShare, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__fielddefs[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__fielddefs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__fields[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__fields, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__fieldsBase[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__fieldsBase, 0, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__memoryRecord, _p_bzs__db__protocol__tdap__client__memoryRecordTo_p_bzs__db__protocol__tdap__client__fieldsBase, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__writableRecord, _p_bzs__db__protocol__tdap__client__writableRecordTo_p_bzs__db__protocol__tdap__client__fieldsBase, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__fields, _p_bzs__db__protocol__tdap__client__fieldsTo_p_bzs__db__protocol__tdap__client__fieldsBase, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexFindNavi_t_t[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexFindNavi_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexNavi_t_t[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexNavi_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexRvFindNavi_t_t[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexRvFindNavi_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexRvNavi_t_t[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexRvNavi_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_stepNavi_t_t[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_stepNavi_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_stepRvNavi_t_t[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_stepRvNavi_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__first[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__first, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__groupFuncBase[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__sum, _p_bzs__db__protocol__tdap__client__sumTo_p_bzs__db__protocol__tdap__client__groupFuncBase, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__count, _p_bzs__db__protocol__tdap__client__countTo_p_bzs__db__protocol__tdap__client__groupFuncBase, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__max, _p_bzs__db__protocol__tdap__client__maxTo_p_bzs__db__protocol__tdap__client__groupFuncBase, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__avg, _p_bzs__db__protocol__tdap__client__avgTo_p_bzs__db__protocol__tdap__client__groupFuncBase, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__min, _p_bzs__db__protocol__tdap__client__minTo_p_bzs__db__protocol__tdap__client__groupFuncBase, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__last, _p_bzs__db__protocol__tdap__client__lastTo_p_bzs__db__protocol__tdap__client__groupFuncBase, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__first, _p_bzs__db__protocol__tdap__client__firstTo_p_bzs__db__protocol__tdap__client__groupFuncBase, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__groupFuncBase, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__groupQuery[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__groupQuery, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__idatabaseManager[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__idatabaseManager, 0, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__pooledDbManager, _p_bzs__db__protocol__tdap__client__pooledDbManagerTo_p_bzs__db__protocol__tdap__client__idatabaseManager, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__last[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__last, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__max[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__max, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__memoryRecord[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__memoryRecord, 0, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__writableRecord, _p_bzs__db__protocol__tdap__client__writableRecordTo_p_bzs__db__protocol__tdap__client__memoryRecord, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__min[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__min, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__nsdatabase[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__nsdatabase, 0, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__database, _p_bzs__db__protocol__tdap__client__databaseTo_p_bzs__db__protocol__tdap__client__nsdatabase, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__nstable[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__table, _p_bzs__db__protocol__tdap__client__tableTo_p_bzs__db__protocol__tdap__client__nstable, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__dbdef, _p_bzs__db__protocol__tdap__client__dbdefTo_p_bzs__db__protocol__tdap__client__nstable, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__nstable, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__pooledDbManager[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__pooledDbManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__preparedQuery[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__preparedQuery, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__query[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__recordsetQuery, _p_bzs__db__protocol__tdap__client__recordsetQueryTo_p_bzs__db__protocol__tdap__client__query, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__sum, 0, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__count, 0, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__query, 0, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__max, 0, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__avg, 0, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__min, 0, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__groupFuncBase, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__queryBase[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__recordsetQuery, 0, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__sum, 0, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__count, 0, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__query, _p_bzs__db__protocol__tdap__client__queryTo_p_bzs__db__protocol__tdap__client__queryBase, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__max, 0, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__queryBase, 0, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__avg, 0, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__min, 0, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__groupFuncBase, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__recordset[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__recordset, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__recordsetQuery[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__recordsetQuery, 0, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__sum, _p_bzs__db__protocol__tdap__client__sumTo_p_bzs__db__protocol__tdap__client__recordsetQuery, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__count, _p_bzs__db__protocol__tdap__client__countTo_p_bzs__db__protocol__tdap__client__recordsetQuery, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__max, _p_bzs__db__protocol__tdap__client__maxTo_p_bzs__db__protocol__tdap__client__recordsetQuery, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__avg, _p_bzs__db__protocol__tdap__client__avgTo_p_bzs__db__protocol__tdap__client__recordsetQuery, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__min, _p_bzs__db__protocol__tdap__client__minTo_p_bzs__db__protocol__tdap__client__recordsetQuery, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__last, _p_bzs__db__protocol__tdap__client__lastTo_p_bzs__db__protocol__tdap__client__recordsetQuery, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__first, _p_bzs__db__protocol__tdap__client__firstTo_p_bzs__db__protocol__tdap__client__recordsetQuery, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__groupFuncBase, _p_bzs__db__protocol__tdap__client__groupFuncBaseTo_p_bzs__db__protocol__tdap__client__recordsetQuery, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__autoMemory[] = {{&_swigt__p_bzs__db__protocol__tdap__client__autoMemory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__refarymem[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__refarymem, 0, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__fieldsBase, _p_bzs__db__protocol__tdap__client__fieldsBaseTo_p_bzs__db__protocol__tdap__client__refarymem, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__memoryRecord, _p_bzs__db__protocol__tdap__client__memoryRecordTo_p_bzs__db__protocol__tdap__client__refarymem, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__writableRecord, _p_bzs__db__protocol__tdap__client__writableRecordTo_p_bzs__db__protocol__tdap__client__refarymem, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__autoMemory, _p_bzs__db__protocol__tdap__client__autoMemoryTo_p_bzs__db__protocol__tdap__client__refarymem, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__fields, _p_bzs__db__protocol__tdap__client__fieldsTo_p_bzs__db__protocol__tdap__client__refarymem, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__snapshotT_boost__shared_ptrT_bzs__db__protocol__tdap__client__database_t_t[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__snapshotT_boost__shared_ptrT_bzs__db__protocol__tdap__client__database_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__snapshotT_bzs__db__protocol__tdap__client__idatabaseManager_p_t[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__snapshotT_bzs__db__protocol__tdap__client__idatabaseManager_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__sortField[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__sortField, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__sortFields[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__sortFields, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__sum[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__sum, 0, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__max, _p_bzs__db__protocol__tdap__client__maxTo_p_bzs__db__protocol__tdap__client__sum, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__avg, _p_bzs__db__protocol__tdap__client__avgTo_p_bzs__db__protocol__tdap__client__sum, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__client__min, _p_bzs__db__protocol__tdap__client__minTo_p_bzs__db__protocol__tdap__client__sum, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__table[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__table, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__tableIteratorT_indexFindNavi_t[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__tableIteratorT_indexFindNavi_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__tableIteratorT_indexNavi_t[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__tableIteratorT_indexNavi_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__tableIteratorT_indexRvFindNavi_t[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__tableIteratorT_indexRvFindNavi_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__tableIteratorT_indexRvNavi_t[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__tableIteratorT_indexRvNavi_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__tableIteratorT_stepNavi_t[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__tableIteratorT_stepNavi_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__tableIteratorT_stepRvNavi_t[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__tableIteratorT_stepRvNavi_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__transactionT_boost__shared_ptrT_bzs__db__protocol__tdap__client__database_t_t[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__transactionT_boost__shared_ptrT_bzs__db__protocol__tdap__client__database_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__transactionT_boost__shared_ptrT_bzs__db__protocol__tdap__client__idatabaseManager_t_t[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__transactionT_boost__shared_ptrT_bzs__db__protocol__tdap__client__idatabaseManager_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__client__writableRecord[] = {  {&_swigt__p_bzs__db__protocol__tdap__client__writableRecord, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__fielddef[] = {  {&_swigt__p_bzs__db__protocol__tdap__fielddef, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__fielddef_tT_20_t[] = {  {&_swigt__p_bzs__db__protocol__tdap__fielddef_tT_20_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__fielddef_tT_64_t[] = {  {&_swigt__p_bzs__db__protocol__tdap__fielddef, _p_bzs__db__protocol__tdap__fielddefTo_p_bzs__db__protocol__tdap__fielddef_tT_64_t, 0, 0},  {&_swigt__p_bzs__db__protocol__tdap__fielddef_tT_64_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__keySegment[] = {  {&_swigt__p_bzs__db__protocol__tdap__keySegment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__keydef[] = {  {&_swigt__p_bzs__db__protocol__tdap__keydef, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__db__protocol__tdap__tabledef[] = {  {&_swigt__p_bzs__db__protocol__tdap__tabledef, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bzs__rtl__benchmark[] = {  {&_swigt__p_bzs__rtl__benchmark, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_unsigned_short_p_void_p_void_p_unsigned_int_p_void_unsigned_short_char_p_unsigned_char__short[] = {  {&_swigt__p_f_unsigned_short_p_void_p_void_p_unsigned_int_p_void_unsigned_short_char_p_unsigned_char__short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iterator[] = {  {&_swigt__p_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_bzs__db__protocol__tdap__client__memoryRecord[] = {{&_swigt__p_p_bzs__db__protocol__tdap__client__memoryRecord, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_bzs__db__protocol__tdap__client__writableRecord[] = {{&_swigt__p_p_bzs__db__protocol__tdap__client__writableRecord, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_bzs__db__protocol__tdap__client__fields[] = {{&_swigt__p_p_bzs__db__protocol__tdap__client__fields, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_bzs__db__protocol__tdap__client__fieldsBase[] = {  {&_swigt__p_p_bzs__db__protocol__tdap__client__fieldsBase, 0, 0, 0},  {&_swigt__p_p_bzs__db__protocol__tdap__client__memoryRecord, _p_p_bzs__db__protocol__tdap__client__memoryRecordTo_p_p_bzs__db__protocol__tdap__client__fieldsBase, 0, 0},  {&_swigt__p_p_bzs__db__protocol__tdap__client__writableRecord, _p_p_bzs__db__protocol__tdap__client__writableRecordTo_p_p_bzs__db__protocol__tdap__client__fieldsBase, 0, 0},  {&_swigt__p_p_bzs__db__protocol__tdap__client__fields, _p_p_bzs__db__protocol__tdap__client__fieldsTo_p_p_bzs__db__protocol__tdap__client__fieldsBase, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_bzs__db__protocol__tdap__tabledef[] = {  {&_swigt__p_p_bzs__db__protocol__tdap__tabledef, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_preparedQuery[] = {  {&_swigt__p_preparedQuery, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std___tstring[] = {  {&_swigt__p_std___tstring, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_bzs__db__protocol__tdap__client__fieldsBase_p_t__iterator[] = {  {&_swigt__p_std__vectorT_bzs__db__protocol__tdap__client__fieldsBase_p_t__iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_trdVersiton[] = {  {&_swigt__p_trdVersiton, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};



static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_BOOKMARK,
  _swigc__p_HWND,
  _swigc__p_boost__functionT_int_fbzs__db__protocol__tdap__client__fields_const_RF_t,
  _swigc__p_boost__shared_ptrT_bzs__db__protocol__tdap__client__database_t,
  _swigc__p_boost__shared_ptrT_bzs__db__protocol__tdap__client__filter_t,
  _swigc__p_boost__shared_ptrT_bzs__db__protocol__tdap__client__idatabaseManager_t,
  _swigc__p_boost__shared_ptrT_bzs__db__protocol__tdap__client__table_t,
  _swigc__p_boost__timer,
  _swigc__p_bzs__db__protocol__tdap__FLAGS,
  _swigc__p_bzs__db__protocol__tdap__btrDate,
  _swigc__p_bzs__db__protocol__tdap__btrDateTime,
  _swigc__p_bzs__db__protocol__tdap__btrTime,
  _swigc__p_bzs__db__protocol__tdap__btrTimeStamp,
  _swigc__p_bzs__db__protocol__tdap__btrVersion,
  _swigc__p_bzs__db__protocol__tdap__btrVersions,
  _swigc__p_bzs__db__protocol__tdap__client__activeTable,
  _swigc__p_bzs__db__protocol__tdap__client__autoMemory,
  _swigc__p_bzs__db__protocol__tdap__client__avg,
  _swigc__p_bzs__db__protocol__tdap__client__connectParams,
  _swigc__p_bzs__db__protocol__tdap__client__count,
  _swigc__p_bzs__db__protocol__tdap__client__database,
  _swigc__p_bzs__db__protocol__tdap__client__dbdef,
  _swigc__p_bzs__db__protocol__tdap__client__field,
  _swigc__p_bzs__db__protocol__tdap__client__fieldNames,
  _swigc__p_bzs__db__protocol__tdap__client__fieldShare,
  _swigc__p_bzs__db__protocol__tdap__client__fielddefs,
  _swigc__p_bzs__db__protocol__tdap__client__fields,
  _swigc__p_bzs__db__protocol__tdap__client__fieldsBase,
  _swigc__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexFindNavi_t_t,
  _swigc__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexNavi_t_t,
  _swigc__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexRvFindNavi_t_t,
  _swigc__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_indexRvNavi_t_t,
  _swigc__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_stepNavi_t_t,
  _swigc__p_bzs__db__protocol__tdap__client__filterdIteratorT_bzs__db__protocol__tdap__client__tableIteratorT_stepRvNavi_t_t,
  _swigc__p_bzs__db__protocol__tdap__client__groupFuncBase,
  _swigc__p_bzs__db__protocol__tdap__client__groupQuery,
  _swigc__p_bzs__db__protocol__tdap__client__idatabaseManager,
  _swigc__p_bzs__db__protocol__tdap__client__max,
  _swigc__p_bzs__db__protocol__tdap__client__memoryRecord,
  _swigc__p_bzs__db__protocol__tdap__client__min,
  _swigc__p_bzs__db__protocol__tdap__client__nsdatabase,
  _swigc__p_bzs__db__protocol__tdap__client__nstable,
  _swigc__p_bzs__db__protocol__tdap__client__pooledDbManager,
  _swigc__p_bzs__db__protocol__tdap__client__preparedQuery,
  _swigc__p_bzs__db__protocol__tdap__client__query,
  _swigc__p_bzs__db__protocol__tdap__client__queryBase,
  _swigc__p_bzs__db__protocol__tdap__client__recordset,
  _swigc__p_bzs__db__protocol__tdap__client__recordsetQuery,
  _swigc__p_bzs__db__protocol__tdap__client__refarymem,
  _swigc__p_bzs__db__protocol__tdap__client__snapshotT_boost__shared_ptrT_bzs__db__protocol__tdap__client__database_t_t,
  _swigc__p_bzs__db__protocol__tdap__client__snapshotT_bzs__db__protocol__tdap__client__idatabaseManager_p_t,
  _swigc__p_bzs__db__protocol__tdap__client__sortField,
  _swigc__p_bzs__db__protocol__tdap__client__sortFields,
  _swigc__p_bzs__db__protocol__tdap__client__sum,
  _swigc__p_bzs__db__protocol__tdap__client__table,
  _swigc__p_bzs__db__protocol__tdap__client__tableIteratorT_indexFindNavi_t,
  _swigc__p_bzs__db__protocol__tdap__client__tableIteratorT_indexNavi_t,
  _swigc__p_bzs__db__protocol__tdap__client__tableIteratorT_indexRvFindNavi_t,
  _swigc__p_bzs__db__protocol__tdap__client__tableIteratorT_indexRvNavi_t,
  _swigc__p_bzs__db__protocol__tdap__client__tableIteratorT_stepNavi_t,
  _swigc__p_bzs__db__protocol__tdap__client__tableIteratorT_stepRvNavi_t,
  _swigc__p_bzs__db__protocol__tdap__client__transactionT_boost__shared_ptrT_bzs__db__protocol__tdap__client__database_t_t,
  _swigc__p_bzs__db__protocol__tdap__client__transactionT_boost__shared_ptrT_bzs__db__protocol__tdap__client__idatabaseManager_t_t,
  _swigc__p_bzs__db__protocol__tdap__client__writableRecord,
  _swigc__p_bzs__db__protocol__tdap__fielddef,
  _swigc__p_bzs__db__protocol__tdap__fielddef_tT_20_t,
  _swigc__p_bzs__db__protocol__tdap__fielddef_tT_64_t,
  _swigc__p_bzs__db__protocol__tdap__keySegment,
  _swigc__p_bzs__db__protocol__tdap__keydef,
  _swigc__p_bzs__db__protocol__tdap__tabledef,
  _swigc__p_bzs__rtl__benchmark,
  _swigc__p_char,
  _swigc__p_f_unsigned_short_p_void_p_void_p_unsigned_int_p_void_unsigned_short_char_p_unsigned_char__short,
  _swigc__p_int,
  _swigc__p_iterator,
  _swigc__p_p_bzs__db__protocol__tdap__client__fields,
  _swigc__p_p_bzs__db__protocol__tdap__client__fieldsBase,
  _swigc__p_p_bzs__db__protocol__tdap__client__memoryRecord,
  _swigc__p_p_bzs__db__protocol__tdap__client__writableRecord,
  _swigc__p_p_bzs__db__protocol__tdap__tabledef,
  _swigc__p_preparedQuery,
  _swigc__p_short,
  _swigc__p_std___tstring,
  _swigc__p_std__vectorT_bzs__db__protocol__tdap__client__fieldsBase_p_t__iterator,
  _swigc__p_trdVersiton,
  _swigc__p_unsigned_char,
  _swigc__p_unsigned_int,
  _swigc__p_unsigned_short,
  _swigc__p_value_type,
  _swigc__p_void,
  _swigc__p_bzs__db__protocol__tdap__client__last,
  _swigc__p_bzs__db__protocol__tdap__client__first,
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is tough by the requirement that no dynamic
 * memory is used. Also, since swig_type_info structures store pointers to
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization.
 * The idea is that swig generates all the structures that are needed.
 * The runtime then collects these partially filled structures.
 * The SWIG_InitializeModule function takes these initial arrays out of
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned statically to an initial
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast linked list. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns. So to actually build the cast linked list,
 * we find the array of casts associated with the type, and loop through it
 * adding the casts to the list. The one last trick we need to do is making
 * sure the type pointer in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded.
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 *     be correct.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif

#if 0
#define SWIGRUNTIME_DEBUG
#endif


SWIGRUNTIME void
SWIG_InitializeModule(void *clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int found, init;

  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
    /* Initialize the swig_module */
    swig_module.type_initial = swig_type_initial;
    swig_module.cast_initial = swig_cast_initial;
    swig_module.next = &swig_module;
    init = 1;
  } else {
    init = 0;
  }

  /* Try and load any already created modules */
  module_head = SWIG_GetModule(clientdata);
  if (!module_head) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
    module_head = &swig_module;
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    found=0;
    iter=module_head;
    do {
      if (iter==&swig_module) {
        found=1;
        break;
      }
      iter=iter->next;
    } while (iter!= module_head);

    /* if the is found in the list, then all is done and we may leave */
    if (found) return;
    /* otherwise we must add out module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }

  /* When multiple interpreters are used, a module could have already been initialized in
     a different interpreter, but not yet have a pointer in this interpreter.
     In this case, we do not want to continue adding types... everything should be
     set up already */
  if (init == 0) return;

  /* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
#endif
  for (i = 0; i < swig_module.size; ++i) {
    swig_type_info *type = 0;
    swig_type_info *ret;
    swig_cast_info *cast;

#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
#endif

    /* if there is another module already loaded */
    if (swig_module.next != &swig_module) {
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
    }
    if (type) {
      /* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
      if (swig_module.type_initial[i]->clientdata) {
    type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
      }
    } else {
      type = swig_module.type_initial[i];
    }

    /* Insert casting types */
    cast = swig_module.cast_initial[i];
    while (cast->type) {

      /* Don't need to add information already in the list */
      ret = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
    if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
      }
      if (ret) {
    if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
      cast->type = ret;
      ret = 0;
    } else {
      /* Check for casting already in the list */
      swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
      if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
      if (!ocast) ret = 0;
    }
      }

      if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        if (type->cast) {
          type->cast->prev = cast;
          cast->next = type->cast;
        }
        type->cast = cast;
      }
      cast++;
    }
    /* Set entry in modules->types array equal to the type */
    swig_module.types[i] = type;
  }
  swig_module.types[i] = 0;

#ifdef SWIGRUNTIME_DEBUG
  printf("**** SWIG_InitializeModule: Cast List ******\n");
  for (i = 0; i < swig_module.size; ++i) {
    int j = 0;
    swig_cast_info *cast = swig_module.cast_initial[i];
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
    while (cast->type) {
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
      cast++;
      ++j;
    }
  printf("---- Total casts: %d\n",j);
  }
  printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
  size_t i;
  swig_cast_info *equiv;
  static int init_run = 0;

  if (init_run) return;
  init_run = 1;

  for (i = 0; i < swig_module.size; i++) {
    if (swig_module.types[i]->clientdata) {
      equiv = swig_module.types[i]->cast;
      while (equiv) {
        if (!equiv->converter) {
          if (equiv->type && !equiv->type->clientdata)
            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
        }
        equiv = equiv->next;
      }
    }
  }
}

#ifdef __cplusplus
#if 0
{ /* c-mode */
#endif
}
#endif

/*

*/
#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT void Init_transactd(void) {
  size_t i;
  
  SWIG_InitRuntime();
  mTransactd = rb_define_module("Transactd");
  
  SWIG_InitializeModule(0);
  for (i = 0; i < swig_module.size; i++) {
    SWIG_define_class(swig_module.types[i]);
  }
  
  SWIG_RubyInitializeTrackings();
  
  bzs::db::protocol::tdap::client::nsdatabase::setCheckTablePtr(true);
#if HAVE_RB_THREAD_CALL_WITHOUT_GVL || HAVE_RB_THREAD_BLOCKING_REGION
  if (MYTICALLID_ORIGINAL == NULL)
  {
    MYTICALLID_ORIGINAL = bzs::db::protocol::tdap::client::getTrnsctdEntryPoint();
    if (MYTICALLID_ORIGINAL)
    bzs::db::protocol::tdap::client::setTrnsctdEntryPoint((BTRCALLID_PTR) MYTICALLID_WITHOUT_GVL);
    else
    bzs::db::protocol::tdap::client::setTrnsctdEntryPoint((BTRCALLID_PTR) NULL);
    
    BTRVCALLID_ORIGINAL = bzs::db::protocol::tdap::client::getBtrvEntryPoint();
    if (BTRVCALLID_ORIGINAL)
    bzs::db::protocol::tdap::client::setBtrvEntryPoint((BTRCALLID_PTR) BTRVCALLID_WITHOUT_GVL);
    else
    bzs::db::protocol::tdap::client::setBtrvEntryPoint((BTRCALLID_PTR) NULL);
  }
#endif // HAVE_RB_THREAD_CALL_WITHOUT_GVL || HAVE_RB_THREAD_BLOCKING_REGION
  
  rb_define_const(mTransactd, "CP_UTF8", SWIG_From_int(static_cast< int >(CP_UTF8)));
#ifdef _WIN32
  rb_define_const(mTransactd, "CP_ACP", SWIG_From_int(static_cast< int >(0)));
#else
  rb_define_const(mTransactd, "CP_ACP", SWIG_From_int(static_cast< int >(65001)));
#endif
  SwigClassBOOKMARK.klass = rb_define_class_under(mTransactd, "BOOKMARK", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_BOOKMARK, (void *)&SwigClassBOOKMARK);
  rb_define_alloc_func(SwigClassBOOKMARK.klass, _wrap_BOOKMARK_allocate);
  rb_define_method(SwigClassBOOKMARK.klass, "initialize", VALUEFUNC(_wrap_new_BOOKMARK), -1);
  rb_define_method(SwigClassBOOKMARK.klass, "isEmpty", VALUEFUNC(_wrap_BOOKMARK_isEmpty), -1);
  SwigClassBOOKMARK.mark = 0;
  SwigClassBOOKMARK.destroy = (void(*)(void *)) free_BOOKMARK;
  SwigClassBOOKMARK.trackObjects = 0;
  rb_define_const(mTransactd, "Ft_string", SWIG_From_int(static_cast< int >(ft_string)));
  rb_define_const(mTransactd, "Ft_integer", SWIG_From_int(static_cast< int >(ft_integer)));
  rb_define_const(mTransactd, "Ft_float", SWIG_From_int(static_cast< int >(ft_float)));
  rb_define_const(mTransactd, "Ft_date", SWIG_From_int(static_cast< int >(ft_date)));
  rb_define_const(mTransactd, "Ft_time", SWIG_From_int(static_cast< int >(ft_time)));
  rb_define_const(mTransactd, "Ft_decimal", SWIG_From_int(static_cast< int >(ft_decimal)));
  rb_define_const(mTransactd, "Ft_money", SWIG_From_int(static_cast< int >(ft_money)));
  rb_define_const(mTransactd, "Ft_logical", SWIG_From_int(static_cast< int >(ft_logical)));
  rb_define_const(mTransactd, "Ft_numeric", SWIG_From_int(static_cast< int >(ft_numeric)));
  rb_define_const(mTransactd, "Ft_bfloat", SWIG_From_int(static_cast< int >(ft_bfloat)));
  rb_define_const(mTransactd, "Ft_lstring", SWIG_From_int(static_cast< int >(ft_lstring)));
  rb_define_const(mTransactd, "Ft_zstring", SWIG_From_int(static_cast< int >(ft_zstring)));
  rb_define_const(mTransactd, "Ft_note", SWIG_From_int(static_cast< int >(ft_note)));
  rb_define_const(mTransactd, "Ft_lvar", SWIG_From_int(static_cast< int >(ft_lvar)));
  rb_define_const(mTransactd, "Ft_uinteger", SWIG_From_int(static_cast< int >(ft_uinteger)));
  rb_define_const(mTransactd, "Ft_autoinc", SWIG_From_int(static_cast< int >(ft_autoinc)));
  rb_define_const(mTransactd, "Ft_bit", SWIG_From_int(static_cast< int >(ft_bit)));
  rb_define_const(mTransactd, "Ft_numericsts", SWIG_From_int(static_cast< int >(ft_numericsts)));
  rb_define_const(mTransactd, "Ft_numericsa", SWIG_From_int(static_cast< int >(ft_numericsa)));
  rb_define_const(mTransactd, "Ft_currency", SWIG_From_int(static_cast< int >(ft_currency)));
  rb_define_const(mTransactd, "Ft_timestamp", SWIG_From_int(static_cast< int >(ft_timestamp)));
  rb_define_const(mTransactd, "Ft_blob", SWIG_From_int(static_cast< int >(ft_blob)));
  rb_define_const(mTransactd, "Ft_reserve22", SWIG_From_int(static_cast< int >(ft_reserve22)));
  rb_define_const(mTransactd, "Ft_reserve23", SWIG_From_int(static_cast< int >(ft_reserve23)));
  rb_define_const(mTransactd, "Ft_reserve24", SWIG_From_int(static_cast< int >(ft_reserve24)));
  rb_define_const(mTransactd, "Ft_wstring", SWIG_From_int(static_cast< int >(ft_wstring)));
  rb_define_const(mTransactd, "Ft_wzstring", SWIG_From_int(static_cast< int >(ft_wzstring)));
  rb_define_const(mTransactd, "Ft_guid", SWIG_From_int(static_cast< int >(ft_guid)));
  rb_define_const(mTransactd, "Ft_datetime", SWIG_From_int(static_cast< int >(ft_datetime)));
  rb_define_const(mTransactd, "Ft_myvarchar", SWIG_From_int(static_cast< int >(ft_myvarchar)));
  rb_define_const(mTransactd, "Ft_myvarbinary", SWIG_From_int(static_cast< int >(ft_myvarbinary)));
  rb_define_const(mTransactd, "Ft_mywvarchar", SWIG_From_int(static_cast< int >(ft_mywvarchar)));
  rb_define_const(mTransactd, "Ft_mywvarbinary", SWIG_From_int(static_cast< int >(ft_mywvarbinary)));
  rb_define_const(mTransactd, "Ft_mychar", SWIG_From_int(static_cast< int >(ft_mychar)));
  rb_define_const(mTransactd, "Ft_mywchar", SWIG_From_int(static_cast< int >(ft_mywchar)));
  rb_define_const(mTransactd, "Ft_mydate", SWIG_From_int(static_cast< int >(ft_mydate)));
  rb_define_const(mTransactd, "Ft_mytime", SWIG_From_int(static_cast< int >(ft_mytime)));
  rb_define_const(mTransactd, "Ft_mydatetime", SWIG_From_int(static_cast< int >(ft_mydatetime)));
  rb_define_const(mTransactd, "Ft_mytimestamp", SWIG_From_int(static_cast< int >(ft_mytimestamp)));
  rb_define_const(mTransactd, "Ft_mytext", SWIG_From_int(static_cast< int >(ft_mytext)));
  rb_define_const(mTransactd, "Ft_myblob", SWIG_From_int(static_cast< int >(ft_myblob)));
  rb_define_const(mTransactd, "Ft_autoIncUnsigned", SWIG_From_int(static_cast< int >(ft_autoIncUnsigned)));
  rb_define_const(mTransactd, "Ft_myfixedbinary", SWIG_From_int(static_cast< int >(ft_myfixedbinary)));
  rb_define_const(mTransactd, "Ft_nullindicator", SWIG_From_int(static_cast< int >(ft_nullindicator)));
  rb_define_const(mTransactd, "Charset_none", SWIG_From_int(static_cast< int >(charset_none)));
  rb_define_const(mTransactd, "Charset_latin1", SWIG_From_int(static_cast< int >(charset_latin1)));
  rb_define_const(mTransactd, "Charset_ascii", SWIG_From_int(static_cast< int >(charset_ascii)));
  rb_define_const(mTransactd, "Charset_sjis", SWIG_From_int(static_cast< int >(charset_sjis)));
  rb_define_const(mTransactd, "Charset_cp932", SWIG_From_int(static_cast< int >(charset_cp932)));
  rb_define_const(mTransactd, "Charset_utf8", SWIG_From_int(static_cast< int >(charset_utf8)));
  rb_define_const(mTransactd, "Charset_utf8mb4", SWIG_From_int(static_cast< int >(charset_utf8mb4)));
  rb_define_const(mTransactd, "Charset_usc2", SWIG_From_int(static_cast< int >(charset_usc2)));
  rb_define_const(mTransactd, "CMPLOGICAL_VAR_COMP_ALL", SWIG_From_int(static_cast< int >(CMPLOGICAL_VAR_COMP_ALL)));
  rb_define_const(mTransactd, "CMPLOGICAL_CMPACS", SWIG_From_int(static_cast< int >(CMPLOGICAL_CMPACS)));
  rb_define_const(mTransactd, "CMPLOGICAL_FIELD", SWIG_From_int(static_cast< int >(CMPLOGICAL_FIELD)));
  rb_define_const(mTransactd, "CMPLOGICAL_CASEINSENSITIVE", SWIG_From_int(static_cast< int >(CMPLOGICAL_CASEINSENSITIVE)));
  rb_define_const(mTransactd, "LOCK_BIAS_DEFAULT", SWIG_From_int(static_cast< int >(LOCK_BIAS_DEFAULT)));  
  rb_define_const(mTransactd, "LOCK_SINGLE_WAIT", SWIG_From_int(static_cast< int >(LOCK_SINGLE_WAIT)));
  rb_define_const(mTransactd, "LOCK_SINGLE_NOWAIT", SWIG_From_int(static_cast< int >(LOCK_SINGLE_NOWAIT)));
  rb_define_const(mTransactd, "LOCK_MULTI_WAIT", SWIG_From_int(static_cast< int >(LOCK_MULTI_WAIT)));
  rb_define_const(mTransactd, "LOCK_MULTI_NOWAIT", SWIG_From_int(static_cast< int >(LOCK_MULTI_NOWAIT)));
  rb_define_const(mTransactd, "NOWAIT_WRITE", SWIG_From_int(static_cast< int >(NOWAIT_WRITE)));
  rb_define_const(mTransactd, "PARALLEL_TRN", SWIG_From_int(static_cast< int >(PARALLEL_TRN)));
  rb_define_const(mTransactd, "TRN_ISO_READ_COMMITED", SWIG_From_int(static_cast< int >(TRN_ISO_READ_COMMITED)));
  rb_define_const(mTransactd, "TRN_ISO_REPEATABLE_READ", SWIG_From_int(static_cast< int >(TRN_ISO_REPEATABLE_READ)));
  rb_define_const(mTransactd, "TRN_ISO_SERIALIZABLE", SWIG_From_int(static_cast< int >(TRN_ISO_SERIALIZABLE)));
  rb_define_const(mTransactd, "SINGLELOCK_READ_COMMITED", SWIG_From_int(static_cast< int >(SINGLELOCK_READ_COMMITED)));
  rb_define_const(mTransactd, "MULTILOCK_READ_COMMITED", SWIG_From_int(static_cast< int >(MULTILOCK_READ_COMMITED)));
  rb_define_const(mTransactd, "MULTILOCK_REPEATABLE_READ", SWIG_From_int(static_cast< int >(MULTILOCK_REPEATABLE_READ)));
  rb_define_const(mTransactd, "MULTILOCK_ISO_SERIALIZABLE", SWIG_From_int(static_cast< int >(MULTILOCK_ISO_SERIALIZABLE)));
  rb_define_const(mTransactd, "SINGLELOCK_NOGAP", SWIG_From_int(static_cast< int >(SINGLELOCK_NOGAP)));
  rb_define_const(mTransactd, "MULTILOCK_NOGAP", SWIG_From_int(static_cast< int >(MULTILOCK_NOGAP)));
  rb_define_const(mTransactd, "MULTILOCK_GAP", SWIG_From_int(static_cast< int >(MULTILOCK_GAP)));
  rb_define_const(mTransactd, "CONSISTENT_READ", SWIG_From_int(static_cast< int >(CONSISTENT_READ)));
  rb_define_const(mTransactd, "MULTILOCK_GAP_SHARE", SWIG_From_int(static_cast< int >(MULTILOCK_GAP_SHARE)));
  rb_define_const(mTransactd, "MULTILOCK_NOGAP_SHARE", SWIG_From_int(static_cast< int >(MULTILOCK_NOGAP_SHARE)));
  rb_define_const(mTransactd, "ROW_LOCK_X", SWIG_From_int(static_cast< int >(ROW_LOCK_X)));
  rb_define_const(mTransactd, "ROW_LOCK_S", SWIG_From_int(static_cast< int >(ROW_LOCK_S)));
  rb_define_const(mTransactd, "SRV_ISO_READ_UNCOMMITED", SWIG_From_int(static_cast< int >(SRV_ISO_READ_UNCOMMITED)));
  rb_define_const(mTransactd, "SRV_ISO_READ_COMMITED", SWIG_From_int(static_cast< int >(SRV_ISO_READ_COMMITED)));
  rb_define_const(mTransactd, "SRV_ISO_REPEATABLE_READ", SWIG_From_int(static_cast< int >(SRV_ISO_REPEATABLE_READ)));
  rb_define_const(mTransactd, "SRV_ISO_SERIALIZABLE", SWIG_From_int(static_cast< int >(SRV_ISO_SERIALIZABLE)));
  rb_define_const(mTransactd, "TD_OPEN_NORMAL", SWIG_From_int(static_cast< int >(TD_OPEN_NORMAL)));
  rb_define_const(mTransactd, "TD_OPEN_READONLY", SWIG_From_int(static_cast< int >(TD_OPEN_READONLY)));
  rb_define_const(mTransactd, "TD_OPEN_EXCLUSIVE", SWIG_From_int(static_cast< int >(TD_OPEN_EXCLUSIVE)));
  rb_define_const(mTransactd, "TD_OPEN_READONLY_EXCLUSIVE", SWIG_From_int(static_cast< int >(TD_OPEN_READONLY_EXCLUSIVE)));
  rb_define_const(mTransactd, "BT_AL_LEFT", SWIG_From_int(static_cast< int >(BT_AL_LEFT)));
  rb_define_const(mTransactd, "BT_AL_CENTER", SWIG_From_int(static_cast< int >(BT_AL_CENTER)));
  rb_define_const(mTransactd, "BT_AL_RIGHT", SWIG_From_int(static_cast< int >(BT_AL_RIGHT)));
  rb_define_const(mTransactd, "STATUS_TABLE_YET_OPEN", SWIG_From_int(static_cast< int >(STATUS_TABLE_YET_OPEN)));
  rb_define_const(mTransactd, "STATUS_DURING_TRANSACTION", SWIG_From_int(static_cast< int >(STATUS_DURING_TRANSACTION)));
  rb_define_const(mTransactd, "STATUS_NO_ACR_UPDATE_DELETE", SWIG_From_int(static_cast< int >(STATUS_NO_ACR_UPDATE_DELETE)));
  rb_define_const(mTransactd, "STATUS_NO_ACR_INSERT", SWIG_From_int(static_cast< int >(STATUS_NO_ACR_INSERT)));
  rb_define_const(mTransactd, "STATUS_NO_ACR_READ", SWIG_From_int(static_cast< int >(STATUS_NO_ACR_READ)));
  rb_define_const(mTransactd, "STATUS_CANT_ALLOC_MEMORY", SWIG_From_int(static_cast< int >(STATUS_CANT_ALLOC_MEMORY)));
  rb_define_const(mTransactd, "STATUS_USE_KEYFIELD", SWIG_From_int(static_cast< int >(STATUS_USE_KEYFIELD)));
  rb_define_const(mTransactd, "STATUS_TOO_MANY_TABLES", SWIG_From_int(static_cast< int >(STATUS_TOO_MANY_TABLES)));
  rb_define_const(mTransactd, "STATUS_INVARID_PRM_KEY_NUM", SWIG_From_int(static_cast< int >(STATUS_INVARID_PRM_KEY_NUM)));
  rb_define_const(mTransactd, "STATUS_INVARID_PNT_KEY_NUM", SWIG_From_int(static_cast< int >(STATUS_INVARID_PNT_KEY_NUM)));
  rb_define_const(mTransactd, "STATUS_INVARID_REP_KEY_NUM", SWIG_From_int(static_cast< int >(STATUS_INVARID_REP_KEY_NUM)));
  rb_define_const(mTransactd, "STATUS_INVARID_FIELD_IDX", SWIG_From_int(static_cast< int >(STATUS_INVARID_FIELD_IDX)));
  rb_define_const(mTransactd, "STATUS_ALREADY_DELETED", SWIG_From_int(static_cast< int >(STATUS_ALREADY_DELETED)));
  rb_define_const(mTransactd, "STATUS_LMITS_MAX_TABLES", SWIG_From_int(static_cast< int >(STATUS_LMITS_MAX_TABLES)));
  rb_define_const(mTransactd, "STATUS_DB_YET_OPEN", SWIG_From_int(static_cast< int >(STATUS_DB_YET_OPEN)));
  rb_define_const(mTransactd, "STATUS_TABLENAME_NOTFOUND", SWIG_From_int(static_cast< int >(STATUS_TABLENAME_NOTFOUND)));
  rb_define_const(mTransactd, "STATUS_DIFFERENT_DBVERSION", SWIG_From_int(static_cast< int >(STATUS_DIFFERENT_DBVERSION)));
  rb_define_const(mTransactd, "STATUS_DUPLICATE_FIELDNAME", SWIG_From_int(static_cast< int >(STATUS_DUPLICATE_FIELDNAME)));
  rb_define_const(mTransactd, "STATUS_INVALID_TABLE_IDX", SWIG_From_int(static_cast< int >(STATUS_INVALID_TABLE_IDX)));
  rb_define_const(mTransactd, "STATUS_AUTH_DENIED", SWIG_From_int(static_cast< int >(STATUS_AUTH_DENIED)));
  rb_define_const(mTransactd, "STATUS_TOO_MANY_FIELDS", SWIG_From_int(static_cast< int >(STATUS_TOO_MANY_FIELDS)));
  rb_define_const(mTransactd, "STATUS_FILTERSTRING_ERROR", SWIG_From_int(static_cast< int >(STATUS_FILTERSTRING_ERROR)));
  rb_define_const(mTransactd, "STATUS_INVALID_FIELDLENGTH", SWIG_From_int(static_cast< int >(STATUS_INVALID_FIELDLENGTH)));
  rb_define_const(mTransactd, "STATUS_INVALID_KEYTYPE", SWIG_From_int(static_cast< int >(STATUS_INVALID_KEYTYPE)));
  rb_define_const(mTransactd, "STATUS_LVAR_NOTE_NOT_LAST", SWIG_From_int(static_cast< int >(STATUS_LVAR_NOTE_NOT_LAST)));
  rb_define_const(mTransactd, "STATUS_NODEF_FOR_CONVERT", SWIG_From_int(static_cast< int >(STATUS_NODEF_FOR_CONVERT)));
  rb_define_const(mTransactd, "STATUS_TRD_NEED_VARLENGTH", SWIG_From_int(static_cast< int >(STATUS_TRD_NEED_VARLENGTH)));
  rb_define_const(mTransactd, "STATUS_INVALID_VARIABLETABLE", SWIG_From_int(static_cast< int >(STATUS_INVALID_VARIABLETABLE)));
  rb_define_const(mTransactd, "STATUS_AUTOINC_SPACE_ERROR", SWIG_From_int(static_cast< int >(STATUS_AUTOINC_SPACE_ERROR)));
  rb_define_const(mTransactd, "STATUS_TOO_LONG_OWNERNAME", SWIG_From_int(static_cast< int >(STATUS_TOO_LONG_OWNERNAME)));
  rb_define_const(mTransactd, "STATUS_CANT_DEL_FOR_REL", SWIG_From_int(static_cast< int >(STATUS_CANT_DEL_FOR_REL)));
  rb_define_const(mTransactd, "STATUS_NO_AUTOINC_SPACE", SWIG_From_int(static_cast< int >(STATUS_NO_AUTOINC_SPACE)));
  rb_define_const(mTransactd, "STATUS_INVALID_RECLEN", SWIG_From_int(static_cast< int >(STATUS_INVALID_RECLEN)));
  rb_define_const(mTransactd, "STATUS_INVALID_FIELDVALUE", SWIG_From_int(static_cast< int >(STATUS_INVALID_FIELDVALUE)));
  rb_define_const(mTransactd, "STATUS_INVALID_VALLEN", SWIG_From_int(static_cast< int >(STATUS_INVALID_VALLEN)));
  rb_define_const(mTransactd, "STATUS_FIELDTYPE_NOTSUPPORT", SWIG_From_int(static_cast< int >(STATUS_FIELDTYPE_NOTSUPPORT)));
  rb_define_const(mTransactd, "STATUS_SUCCESS", SWIG_From_int(static_cast< int >(STATUS_SUCCESS)));
  rb_define_const(mTransactd, "STATUS_PROGRAM_ERROR", SWIG_From_int(static_cast< int >(STATUS_PROGRAM_ERROR)));
  rb_define_const(mTransactd, "STATUS_IO_ERROR", SWIG_From_int(static_cast< int >(STATUS_IO_ERROR)));
  rb_define_const(mTransactd, "STATUS_FILE_NOT_OPENED", SWIG_From_int(static_cast< int >(STATUS_FILE_NOT_OPENED)));
  rb_define_const(mTransactd, "STATUS_NOT_FOUND_TI", SWIG_From_int(static_cast< int >(STATUS_NOT_FOUND_TI)));
  rb_define_const(mTransactd, "STATUS_DUPPLICATE_KEYVALUE", SWIG_From_int(static_cast< int >(STATUS_DUPPLICATE_KEYVALUE)));
  rb_define_const(mTransactd, "STATUS_INVALID_KEYNUM", SWIG_From_int(static_cast< int >(STATUS_INVALID_KEYNUM)));
  rb_define_const(mTransactd, "STATUS_NO_CURRENT", SWIG_From_int(static_cast< int >(STATUS_NO_CURRENT)));
  rb_define_const(mTransactd, "STATUS_EOF", SWIG_From_int(static_cast< int >(STATUS_EOF)));
  rb_define_const(mTransactd, "STATUS_TABLE_NOTOPEN", SWIG_From_int(static_cast< int >(STATUS_TABLE_NOTOPEN)));
  rb_define_const(mTransactd, "STATUS_REQUESTER_DEACTIVE", SWIG_From_int(static_cast< int >(STATUS_REQUESTER_DEACTIVE)));
  rb_define_const(mTransactd, "STATUS_KEYBUFFERTOOSMALL", SWIG_From_int(static_cast< int >(STATUS_KEYBUFFERTOOSMALL)));
  rb_define_const(mTransactd, "STATUS_BUFFERTOOSMALL", SWIG_From_int(static_cast< int >(STATUS_BUFFERTOOSMALL)));
  rb_define_const(mTransactd, "STATUS_CANT_CREATE", SWIG_From_int(static_cast< int >(STATUS_CANT_CREATE)));
  rb_define_const(mTransactd, "STATUS_NOSUPPORT_OP", SWIG_From_int(static_cast< int >(STATUS_NOSUPPORT_OP)));
  rb_define_const(mTransactd, "STATUS_INVALID_BOOKMARK", SWIG_From_int(static_cast< int >(STATUS_INVALID_BOOKMARK)));
  rb_define_const(mTransactd, "STATUS_ACCESS_DENIED", SWIG_From_int(static_cast< int >(STATUS_ACCESS_DENIED)));
  rb_define_const(mTransactd, "STATUS_INVALID_OWNERNAME", SWIG_From_int(static_cast< int >(STATUS_INVALID_OWNERNAME)));
  rb_define_const(mTransactd, "STATUS_TABLE_EXISTS_ERROR", SWIG_From_int(static_cast< int >(STATUS_TABLE_EXISTS_ERROR)));
  rb_define_const(mTransactd, "STATUS_LIMMIT_OF_REJECT", SWIG_From_int(static_cast< int >(STATUS_LIMMIT_OF_REJECT)));
  rb_define_const(mTransactd, "STATUS_WARKSPACE_TOO_SMALL", SWIG_From_int(static_cast< int >(STATUS_WARKSPACE_TOO_SMALL)));
  rb_define_const(mTransactd, "STATUS_REACHED_FILTER_COND", SWIG_From_int(static_cast< int >(STATUS_REACHED_FILTER_COND)));
  rb_define_const(mTransactd, "STATUS_INVALID_FIELD_OFFSET", SWIG_From_int(static_cast< int >(STATUS_INVALID_FIELD_OFFSET)));
  rb_define_const(mTransactd, "STATUS_CHANGE_CONFLICT", SWIG_From_int(static_cast< int >(STATUS_CHANGE_CONFLICT)));
  rb_define_const(mTransactd, "STATUS_INVALID_LOCKTYPE", SWIG_From_int(static_cast< int >(STATUS_INVALID_LOCKTYPE)));
  rb_define_const(mTransactd, "STATUS_LOCK_ERROR", SWIG_From_int(static_cast< int >(STATUS_LOCK_ERROR)));
  rb_define_const(mTransactd, "STATUS_FILE_LOCKED", SWIG_From_int(static_cast< int >(STATUS_FILE_LOCKED)));
  rb_define_const(mTransactd, "STATUS_CANNOT_LOCK_TABLE", SWIG_From_int(static_cast< int >(STATUS_CANNOT_LOCK_TABLE)));
  rb_define_const(mTransactd, "STATUS_INVALID_KEYNAME", SWIG_From_int(static_cast< int >(STATUS_INVALID_KEYNAME)));
  rb_define_const(mTransactd, "STATUS_INVALID_DATASIZE", SWIG_From_int(static_cast< int >(STATUS_INVALID_DATASIZE)));
  rb_define_const(mTransactd, "STATUS_INVALID_FIELDNAME", SWIG_From_int(static_cast< int >(STATUS_INVALID_FIELDNAME)));
  rb_define_const(mTransactd, "ERROR_TD_INVALID_CLINETHOST", SWIG_From_int(static_cast< int >(ERROR_TD_INVALID_CLINETHOST)));
  rb_define_const(mTransactd, "ERROR_NO_DATABASE", SWIG_From_int(static_cast< int >(ERROR_NO_DATABASE)));
  rb_define_const(mTransactd, "ERROR_NOSPECIFY_TABLE", SWIG_From_int(static_cast< int >(ERROR_NOSPECIFY_TABLE)));
  rb_define_const(mTransactd, "ERROR_LOAD_CLIBRARY", SWIG_From_int(static_cast< int >(ERROR_LOAD_CLIBRARY)));
  rb_define_const(mTransactd, "ERROR_INDEX_RND_INIT", SWIG_From_int(static_cast< int >(ERROR_INDEX_RND_INIT)));
  rb_define_const(mTransactd, "STATUS_ALREADY_INSNAPSHOT", SWIG_From_int(static_cast< int >(STATUS_ALREADY_INSNAPSHOT)));
  rb_define_const(mTransactd, "STATUS_ALREADY_INTRANSACTION", SWIG_From_int(static_cast< int >(STATUS_ALREADY_INTRANSACTION)));
  rb_define_const(mTransactd, "SERVER_CLIENT_NOT_COMPATIBLE", SWIG_From_int(static_cast< int >(SERVER_CLIENT_NOT_COMPATIBLE)));
  rb_define_const(mTransactd, "NET_BAD_SRB_FORMAT", SWIG_From_int(static_cast< int >(NET_BAD_SRB_FORMAT)));
  rb_define_const(mTransactd, "ERROR_TD_HOSTNAME_NOT_FOUND", SWIG_From_int(static_cast< int >(ERROR_TD_HOSTNAME_NOT_FOUND)));
  rb_define_const(mTransactd, "ERROR_TD_CONNECTION_FAILURE", SWIG_From_int(static_cast< int >(ERROR_TD_CONNECTION_FAILURE)));
  rb_define_const(mTransactd, "ERROR_TD_NOT_CONNECTED", SWIG_From_int(static_cast< int >(ERROR_TD_NOT_CONNECTED)));
  rb_define_const(mTransactd, "ERROR_TD_NET_TIMEOUT", SWIG_From_int(static_cast< int >(ERROR_TD_NET_TIMEOUT)));
  rb_define_const(mTransactd, "ERROR_TD_NET_REMOTE_DISCONNECT", SWIG_From_int(static_cast< int >(ERROR_TD_NET_REMOTE_DISCONNECT)));
  rb_define_const(mTransactd, "ERROR_TD_NET_TOO_BIGDATA", SWIG_From_int(static_cast< int >(ERROR_TD_NET_TOO_BIGDATA)));
  rb_define_const(mTransactd, "ERROR_TD_NET_OTHER", SWIG_From_int(static_cast< int >(ERROR_TD_NET_OTHER)));
  rb_define_const(mTransactd, "ERROR_TD_C_CLIENT_UNKNOWN", SWIG_From_int(static_cast< int >(ERROR_TD_C_CLIENT_UNKNOWN)));
  rb_define_const(mTransactd, "ERROR_TD_RECONNECTED", SWIG_From_int(static_cast< int >(ERROR_TD_RECONNECTED)));
  rb_define_const(mTransactd, "TRANSACTD_SCHEMANAME", SWIG_FromCharPtr(TRANSACTD_SCHEMANAME));
  rb_define_const(mTransactd, "TYPE_SCHEMA_BDF", SWIG_From_int(static_cast< int >(TYPE_SCHEMA_BDF)));
  rb_define_const(mTransactd, "TYPE_SCHEMA_DDF", SWIG_From_int(static_cast< int >(TYPE_SCHEMA_DDF)));
  rb_define_const(mTransactd, "FILTER_CURRENT_TYPE_NOTINC", SWIG_From_int(static_cast< int >(FILTER_CURRENT_TYPE_NOTINC)));
  rb_define_const(mTransactd, "FILTER_CURRENT_TYPE_INC", SWIG_From_int(static_cast< int >(FILTER_CURRENT_TYPE_INC)));
  rb_define_const(mTransactd, "FILTER_CURRENT_TYPE_NOBOOKMARK", SWIG_From_int(static_cast< int >(FILTER_CURRENT_TYPE_NOBOOKMARK)));
  rb_define_const(mTransactd, "NIS_FILED_NAME", SWIG_FromCharPtr(NIS_FILED_NAME));
  rb_define_const(mTransactd, "OWNERNAME_SIZE", SWIG_From_int(static_cast< int >(OWNERNAME_SIZE)));
  rb_define_const(mTransactd, "TD_BACKUP_START", SWIG_From_int(static_cast< int >(TD_BACKUP_START)));
  rb_define_const(mTransactd, "TD_BACKUP_END", SWIG_From_int(static_cast< int >(TD_BACKUP_END)));
  rb_define_const(mTransactd, "TD_BACKUP_MODE_OK", SWIG_From_int(static_cast< int >(TD_BACKUP_MODE_OK)));
  rb_define_const(mTransactd, "TD_BACKUP_MODE_NOT_SUPPORT", SWIG_From_int(static_cast< int >(TD_BACKUP_MODE_NOT_SUPPORT)));
  rb_define_const(mTransactd, "TD_BACKUP_MODE_BUSY", SWIG_From_int(static_cast< int >(TD_BACKUP_MODE_BUSY)));
  rb_define_const(mTransactd, "TD_BACKUP_MODE_NOT_PERMIT", SWIG_From_int(static_cast< int >(TD_BACKUP_MODE_NOT_PERMIT)));
  rb_define_const(mTransactd, "TD_BACKUP_MODE_SERVER_ERROR", SWIG_From_int(static_cast< int >(TD_BACKUP_MODE_SERVER_ERROR)));
  rb_define_const(mTransactd, "MYSQL_USERNAME_MAX", SWIG_From_int(static_cast< int >(MYSQL_USERNAME_MAX)));
  rb_define_const(mTransactd, "HST_OPTION_NO_SCRAMBLE", SWIG_From_int(static_cast< int >(HST_OPTION_NO_SCRAMBLE)));
  rb_define_const(mTransactd, "CPP_INTERFACE_VER_MAJOR", SWIG_FromCharPtr(CPP_INTERFACE_VER_MAJOR));
  rb_define_const(mTransactd, "CPP_INTERFACE_VER_MINOR", SWIG_FromCharPtr(CPP_INTERFACE_VER_MINOR));
  rb_define_const(mTransactd, "CPP_INTERFACE_VER_RELEASE", SWIG_FromCharPtr(CPP_INTERFACE_VER_RELEASE));
  rb_define_const(mTransactd, "TRANSACTD_VER_MAJOR", SWIG_From_int(static_cast< int >(TRANSACTD_VER_MAJOR)));
  rb_define_const(mTransactd, "TRANSACTD_VER_MINOR", SWIG_From_int(static_cast< int >(TRANSACTD_VER_MINOR)));
  rb_define_const(mTransactd, "TRANSACTD_VER_RELEASE", SWIG_From_int(static_cast< int >(TRANSACTD_VER_RELEASE)));
  
  SwigClassFLAGS.klass = rb_define_class_under(mTransactd, "FLAGS", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__FLAGS, (void *) &SwigClassFLAGS);
  rb_define_alloc_func(SwigClassFLAGS.klass, _wrap_FLAGS_allocate);
  rb_define_method(SwigClassFLAGS.klass, "initialize", VALUEFUNC(_wrap_new_FLAGS), -1);
  rb_define_method(SwigClassFLAGS.klass, "all=", VALUEFUNC(_wrap_FLAGS_all_set), -1);
  rb_define_method(SwigClassFLAGS.klass, "all", VALUEFUNC(_wrap_FLAGS_all_get), -1);
  rb_define_method(SwigClassFLAGS.klass, "bit0=", VALUEFUNC(_wrap_FLAGS_bit0_set), -1);
  rb_define_method(SwigClassFLAGS.klass, "bit0", VALUEFUNC(_wrap_FLAGS_bit0_get), -1);
  rb_define_method(SwigClassFLAGS.klass, "bit1=", VALUEFUNC(_wrap_FLAGS_bit1_set), -1);
  rb_define_method(SwigClassFLAGS.klass, "bit1", VALUEFUNC(_wrap_FLAGS_bit1_get), -1);
  rb_define_method(SwigClassFLAGS.klass, "bit2=", VALUEFUNC(_wrap_FLAGS_bit2_set), -1);
  rb_define_method(SwigClassFLAGS.klass, "bit2", VALUEFUNC(_wrap_FLAGS_bit2_get), -1);
  rb_define_method(SwigClassFLAGS.klass, "bit3=", VALUEFUNC(_wrap_FLAGS_bit3_set), -1);
  rb_define_method(SwigClassFLAGS.klass, "bit3", VALUEFUNC(_wrap_FLAGS_bit3_get), -1);
  rb_define_method(SwigClassFLAGS.klass, "bit4=", VALUEFUNC(_wrap_FLAGS_bit4_set), -1);
  rb_define_method(SwigClassFLAGS.klass, "bit4", VALUEFUNC(_wrap_FLAGS_bit4_get), -1);
  rb_define_method(SwigClassFLAGS.klass, "bit5=", VALUEFUNC(_wrap_FLAGS_bit5_set), -1);
  rb_define_method(SwigClassFLAGS.klass, "bit5", VALUEFUNC(_wrap_FLAGS_bit5_get), -1);
  rb_define_method(SwigClassFLAGS.klass, "bit6=", VALUEFUNC(_wrap_FLAGS_bit6_set), -1);
  rb_define_method(SwigClassFLAGS.klass, "bit6", VALUEFUNC(_wrap_FLAGS_bit6_get), -1);
  rb_define_method(SwigClassFLAGS.klass, "bit7=", VALUEFUNC(_wrap_FLAGS_bit7_set), -1);
  rb_define_method(SwigClassFLAGS.klass, "bit7", VALUEFUNC(_wrap_FLAGS_bit7_get), -1);
  rb_define_method(SwigClassFLAGS.klass, "bit8=", VALUEFUNC(_wrap_FLAGS_bit8_set), -1);
  rb_define_method(SwigClassFLAGS.klass, "bit8", VALUEFUNC(_wrap_FLAGS_bit8_get), -1);
  rb_define_method(SwigClassFLAGS.klass, "bit9=", VALUEFUNC(_wrap_FLAGS_bit9_set), -1);
  rb_define_method(SwigClassFLAGS.klass, "bit9", VALUEFUNC(_wrap_FLAGS_bit9_get), -1);
  rb_define_method(SwigClassFLAGS.klass, "bitA=", VALUEFUNC(_wrap_FLAGS_bitA_set), -1);
  rb_define_method(SwigClassFLAGS.klass, "bitA", VALUEFUNC(_wrap_FLAGS_bitA_get), -1);
  rb_define_method(SwigClassFLAGS.klass, "bitB=", VALUEFUNC(_wrap_FLAGS_bitB_set), -1);
  rb_define_method(SwigClassFLAGS.klass, "bitB", VALUEFUNC(_wrap_FLAGS_bitB_get), -1);
  rb_define_method(SwigClassFLAGS.klass, "bitC=", VALUEFUNC(_wrap_FLAGS_bitC_set), -1);
  rb_define_method(SwigClassFLAGS.klass, "bitC", VALUEFUNC(_wrap_FLAGS_bitC_get), -1);
  rb_define_method(SwigClassFLAGS.klass, "bitD=", VALUEFUNC(_wrap_FLAGS_bitD_set), -1);
  rb_define_method(SwigClassFLAGS.klass, "bitD", VALUEFUNC(_wrap_FLAGS_bitD_get), -1);
  rb_define_method(SwigClassFLAGS.klass, "bitE=", VALUEFUNC(_wrap_FLAGS_bitE_set), -1);
  rb_define_method(SwigClassFLAGS.klass, "bitE", VALUEFUNC(_wrap_FLAGS_bitE_get), -1);
  rb_define_method(SwigClassFLAGS.klass, "bitF=", VALUEFUNC(_wrap_FLAGS_bitF_set), -1);
  rb_define_method(SwigClassFLAGS.klass, "bitF", VALUEFUNC(_wrap_FLAGS_bitF_get), -1);
  SwigClassFLAGS.mark = 0;
  SwigClassFLAGS.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_FLAGS;
  SwigClassFLAGS.trackObjects = 0;
  
  SwigClassKeySegment.klass = rb_define_class_under(mTransactd, "KeySegment", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__keySegment, (void *) &SwigClassKeySegment);
  rb_define_alloc_func(SwigClassKeySegment.klass, _wrap_keySegment_allocate);
  rb_define_method(SwigClassKeySegment.klass, "initialize", VALUEFUNC(_wrap_new_keySegment), -1);
  rb_define_method(SwigClassKeySegment.klass, "fieldNum=", VALUEFUNC(_wrap_keySegment_fieldNum_set), -1);
  rb_define_method(SwigClassKeySegment.klass, "fieldNum", VALUEFUNC(_wrap_keySegment_fieldNum_get), -1);
  rb_define_method(SwigClassKeySegment.klass, "flags=", VALUEFUNC(_wrap_keySegment_flags_set), -1);
  rb_define_method(SwigClassKeySegment.klass, "flags", VALUEFUNC(_wrap_keySegment_flags_get), -1);
  SwigClassKeySegment.mark = 0;
  SwigClassKeySegment.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_keySegment;
  SwigClassKeySegment.trackObjects = 0;
  rb_define_const(mTransactd, "MAX_KEY_SEGMENT", SWIG_From_int(static_cast< int >(MAX_KEY_SEGMENT)));
  
  SwigClassKeydef.klass = rb_define_class_under(mTransactd, "Keydef", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__keydef, (void *) &SwigClassKeydef);
  rb_define_alloc_func(SwigClassKeydef.klass, _wrap_keydef_allocate);
  rb_define_method(SwigClassKeydef.klass, "initialize", VALUEFUNC(_wrap_new_keydef), -1);
  rb_define_method(SwigClassKeydef.klass, "segmentCount=", VALUEFUNC(_wrap_keydef_segmentCount_set), -1);
  rb_define_method(SwigClassKeydef.klass, "segmentCount", VALUEFUNC(_wrap_keydef_segmentCount_get), -1);
  rb_define_method(SwigClassKeydef.klass, "segments=", VALUEFUNC(_wrap_keydef_segments_set), -1);
  rb_define_method(SwigClassKeydef.klass, "segments", VALUEFUNC(_wrap_keydef_segments_get), -1);
  rb_define_method(SwigClassKeydef.klass, "keyNumber=", VALUEFUNC(_wrap_keydef_keyNumber_set), -1);
  rb_define_method(SwigClassKeydef.klass, "keyNumber", VALUEFUNC(_wrap_keydef_keyNumber_get), -1);
  rb_define_method(SwigClassKeydef.klass, "segment", VALUEFUNC(_wrap_keydef_segment), -1);
  SwigClassKeydef.mark = 0;
  SwigClassKeydef.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_keydef;
  SwigClassKeydef.trackObjects = 0;
  rb_define_singleton_method(mTransactd, "MYSQL_FDNAME_SIZE", VALUEFUNC(_wrap_MYSQL_FDNAME_SIZE_get), 0);
  rb_define_singleton_method(mTransactd, "MYSQL_TBNAME_SIZE", VALUEFUNC(_wrap_MYSQL_TBNAME_SIZE_get), 0);
  rb_define_singleton_method(mTransactd, "PERVASIVE_FDNAME_SIZE", VALUEFUNC(_wrap_PERVASIVE_FDNAME_SIZE_get), 0);
  rb_define_singleton_method(mTransactd, "FIELD_NAME_SIZE", VALUEFUNC(_wrap_FIELD_NAME_SIZE_get), 0);
  rb_define_singleton_method(mTransactd, "TABLE_NAME_SIZE", VALUEFUNC(_wrap_TABLE_NAME_SIZE_get), 0);
  rb_define_singleton_method(mTransactd, "FILE_NAME_SIZE", VALUEFUNC(_wrap_FILE_NAME_SIZE_get), 0);
  rb_define_singleton_method(mTransactd, "TABLEDEF_FILLER_SIZE", VALUEFUNC(_wrap_TABLEDEF_FILLER_SIZE_get), 0);
  rb_define_module_function(mTransactd, "getTypeName", VALUEFUNC(_wrap_getTypeName), -1);
  rb_define_module_function(mTransactd, "getTypeAlign", VALUEFUNC(_wrap_getTypeAlign), -1);
  rb_define_module_function(mTransactd, "lenByCharnum", VALUEFUNC(_wrap_lenByCharnum), -1);
  rb_define_module_function(mTransactd, "isStringType", VALUEFUNC(_wrap_isStringType), -1);
  
  SwigClassFielddef_t_my.klass = rb_define_class_under(mTransactd, "Fielddef_t_my", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_64_t, (void *) &SwigClassFielddef_t_my);
  rb_define_alloc_func(SwigClassFielddef_t_my.klass, _wrap_fielddef_t_my_allocate);
  rb_define_method(SwigClassFielddef_t_my.klass, "initialize", VALUEFUNC(_wrap_new_fielddef_t_my), -1);
  rb_define_method(SwigClassFielddef_t_my.klass, "type=", VALUEFUNC(_wrap_fielddef_t_my_type_set), -1);
  rb_define_method(SwigClassFielddef_t_my.klass, "type", VALUEFUNC(_wrap_fielddef_t_my_type_get), -1);
  rb_define_method(SwigClassFielddef_t_my.klass, "len=", VALUEFUNC(_wrap_fielddef_t_my_len_set), -1);
  rb_define_method(SwigClassFielddef_t_my.klass, "len", VALUEFUNC(_wrap_fielddef_t_my_len_get), -1);
  rb_define_method(SwigClassFielddef_t_my.klass, "decimals=", VALUEFUNC(_wrap_fielddef_t_my_decimals_set), -1);
  rb_define_method(SwigClassFielddef_t_my.klass, "decimals", VALUEFUNC(_wrap_fielddef_t_my_decimals_get), -1);
  rb_define_method(SwigClassFielddef_t_my.klass, "max=", VALUEFUNC(_wrap_fielddef_t_my_max_set), -1);
  rb_define_method(SwigClassFielddef_t_my.klass, "max", VALUEFUNC(_wrap_fielddef_t_my_max_get), -1);
  rb_define_method(SwigClassFielddef_t_my.klass, "min=", VALUEFUNC(_wrap_fielddef_t_my_min_set), -1);
  rb_define_method(SwigClassFielddef_t_my.klass, "min", VALUEFUNC(_wrap_fielddef_t_my_min_get), -1);
  rb_define_method(SwigClassFielddef_t_my.klass, "pos=", VALUEFUNC(_wrap_fielddef_t_my_pos_set), -1);
  rb_define_method(SwigClassFielddef_t_my.klass, "pos", VALUEFUNC(_wrap_fielddef_t_my_pos_get), -1);
  rb_define_method(SwigClassFielddef_t_my.klass, "ddfid=", VALUEFUNC(_wrap_fielddef_t_my_ddfid_set), -1);
  rb_define_method(SwigClassFielddef_t_my.klass, "ddfid", VALUEFUNC(_wrap_fielddef_t_my_ddfid_get), -1);
  rb_define_method(SwigClassFielddef_t_my.klass, "nullValue=", VALUEFUNC(_wrap_fielddef_t_my_nullValue_set), -1);
  rb_define_method(SwigClassFielddef_t_my.klass, "nullValue", VALUEFUNC(_wrap_fielddef_t_my_nullValue_get), -1);
  rb_define_method(SwigClassFielddef_t_my.klass, "keylen=", VALUEFUNC(_wrap_fielddef_t_my_keylen_set), -1);
  rb_define_method(SwigClassFielddef_t_my.klass, "keylen", VALUEFUNC(_wrap_fielddef_t_my_keylen_get), -1);
  SwigClassFielddef_t_my.mark = 0;
  SwigClassFielddef_t_my.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_fielddef_t_Sl_64_Sg_;
  SwigClassFielddef_t_my.trackObjects = 0;
  
  SwigClassFielddef.klass = rb_define_class_under(mTransactd, "Fielddef", ((swig_class *) SWIGTYPE_p_bzs__db__protocol__tdap__fielddef_tT_64_t->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__fielddef, (void *) &SwigClassFielddef);
  rb_define_alloc_func(SwigClassFielddef.klass, _wrap_fielddef_allocate);
  rb_define_method(SwigClassFielddef.klass, "initialize", VALUEFUNC(_wrap_new_fielddef), -1);
  rb_define_method(SwigClassFielddef.klass, "setName", VALUEFUNC(_wrap_fielddef_setName), -1);
  rb_define_method(SwigClassFielddef.klass, "typeName", VALUEFUNC(_wrap_fielddef_typeName), -1);
  rb_define_method(SwigClassFielddef.klass, "align", VALUEFUNC(_wrap_fielddef_align), -1);
  rb_define_method(SwigClassFielddef.klass, "setLenByCharnum", VALUEFUNC(_wrap_fielddef_setLenByCharnum), -1);
  rb_define_method(SwigClassFielddef.klass, "codePage", VALUEFUNC(_wrap_fielddef_codePage), -1);
  rb_define_method(SwigClassFielddef.klass, "isStringType", VALUEFUNC(_wrap_fielddef_isStringType), -1);
  rb_define_method(SwigClassFielddef.klass, "isNumericType", VALUEFUNC(_wrap_fielddef_isNumericType), -1);
  rb_define_method(SwigClassFielddef.klass, "charNum", VALUEFUNC(_wrap_fielddef_charNum), -1);
  rb_define_method(SwigClassFielddef.klass, "setCharsetIndex", VALUEFUNC(_wrap_fielddef_setCharsetIndex), -1);
  rb_define_method(SwigClassFielddef.klass, "charsetIndex", VALUEFUNC(_wrap_fielddef_charsetIndex), -1);
  rb_define_method(SwigClassFielddef.klass, "varLenBytes", VALUEFUNC(_wrap_fielddef_varLenBytes), -1);
  rb_define_method(SwigClassFielddef.klass, "blobLenBytes", VALUEFUNC(_wrap_fielddef_blobLenBytes), -1);
  rb_define_method(SwigClassFielddef.klass, "name", VALUEFUNC(_wrap_fielddef_name), -1);
  rb_define_method(SwigClassFielddef.klass, "trimPadChar", VALUEFUNC(_wrap_fielddef_trimPadChar), -1);
  rb_define_method(SwigClassFielddef.klass, "usePadChar", VALUEFUNC(_wrap_fielddef_usePadChar), -1);
  rb_define_method(SwigClassFielddef.klass, "setPadCharSettings", VALUEFUNC(_wrap_fielddef_setPadCharSettings), -1);
  SwigClassFielddef.mark = 0;
  SwigClassFielddef.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_fielddef;
  SwigClassFielddef.trackObjects = 0;
  
  SwigClassTabledef.klass = rb_define_class_under(mTransactd, "Tabledef", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__tabledef, (void *) &SwigClassTabledef);
  rb_define_alloc_func(SwigClassTabledef.klass, _wrap_tabledef_allocate);
  rb_define_method(SwigClassTabledef.klass, "initialize", VALUEFUNC(_wrap_new_tabledef), -1);
  rb_define_method(SwigClassTabledef.klass, "cleanup", VALUEFUNC(_wrap_tabledef_cleanup), -1);
  rb_define_method(SwigClassTabledef.klass, "fileName", VALUEFUNC(_wrap_tabledef_fileName), -1);
  rb_define_method(SwigClassTabledef.klass, "tableName", VALUEFUNC(_wrap_tabledef_tableName), -1);
  rb_define_method(SwigClassTabledef.klass, "setFileName", VALUEFUNC(_wrap_tabledef_setFileName), -1);
  rb_define_method(SwigClassTabledef.klass, "setTableName", VALUEFUNC(_wrap_tabledef_setTableName), -1);
  rb_define_method(SwigClassTabledef.klass, "toChar", VALUEFUNC(_wrap_tabledef_toChar), -1);
  rb_define_method(SwigClassTabledef.klass, "id=", VALUEFUNC(_wrap_tabledef_id_set), -1);
  rb_define_method(SwigClassTabledef.klass, "id", VALUEFUNC(_wrap_tabledef_id_get), -1);
  rb_define_method(SwigClassTabledef.klass, "pageSize=", VALUEFUNC(_wrap_tabledef_pageSize_set), -1);
  rb_define_method(SwigClassTabledef.klass, "pageSize", VALUEFUNC(_wrap_tabledef_pageSize_get), -1);
  rb_define_method(SwigClassTabledef.klass, "varSize=", VALUEFUNC(_wrap_tabledef_varSize_set), -1);
  rb_define_method(SwigClassTabledef.klass, "varSize", VALUEFUNC(_wrap_tabledef_varSize_get), -1);
  rb_define_method(SwigClassTabledef.klass, "preAlloc=", VALUEFUNC(_wrap_tabledef_preAlloc_set), -1);
  rb_define_method(SwigClassTabledef.klass, "preAlloc", VALUEFUNC(_wrap_tabledef_preAlloc_get), -1);
  rb_define_method(SwigClassTabledef.klass, "fieldCount=", VALUEFUNC(_wrap_tabledef_fieldCount_set), -1);
  rb_define_method(SwigClassTabledef.klass, "fieldCount", VALUEFUNC(_wrap_tabledef_fieldCount_get), -1);
  rb_define_method(SwigClassTabledef.klass, "keyCount=", VALUEFUNC(_wrap_tabledef_keyCount_set), -1);
  rb_define_method(SwigClassTabledef.klass, "keyCount", VALUEFUNC(_wrap_tabledef_keyCount_get), -1);
  rb_define_method(SwigClassTabledef.klass, "version=", VALUEFUNC(_wrap_tabledef_version_set), -1);
  rb_define_method(SwigClassTabledef.klass, "version", VALUEFUNC(_wrap_tabledef_version_get), -1);
  rb_define_method(SwigClassTabledef.klass, "charsetIndex=", VALUEFUNC(_wrap_tabledef_charsetIndex_set), -1);
  rb_define_method(SwigClassTabledef.klass, "charsetIndex", VALUEFUNC(_wrap_tabledef_charsetIndex_get), -1);
  rb_define_method(SwigClassTabledef.klass, "flags=", VALUEFUNC(_wrap_tabledef_flags_set), -1);
  rb_define_method(SwigClassTabledef.klass, "flags", VALUEFUNC(_wrap_tabledef_flags_get), -1);
  rb_define_method(SwigClassTabledef.klass, "primaryKeyNum=", VALUEFUNC(_wrap_tabledef_primaryKeyNum_set), -1);
  rb_define_method(SwigClassTabledef.klass, "primaryKeyNum", VALUEFUNC(_wrap_tabledef_primaryKeyNum_get), -1);
  rb_define_method(SwigClassTabledef.klass, "maxRecordLen=", VALUEFUNC(_wrap_tabledef_maxRecordLen_set), -1);
  rb_define_method(SwigClassTabledef.klass, "maxRecordLen", VALUEFUNC(_wrap_tabledef_maxRecordLen_get), -1);
  rb_define_method(SwigClassTabledef.klass, "ddfid=", VALUEFUNC(_wrap_tabledef_ddfid_set), -1);
  rb_define_method(SwigClassTabledef.klass, "ddfid", VALUEFUNC(_wrap_tabledef_ddfid_get), -1);
  rb_define_method(SwigClassTabledef.klass, "fixedRecordLen=", VALUEFUNC(_wrap_tabledef_fixedRecordLen_set), -1);
  rb_define_method(SwigClassTabledef.klass, "fixedRecordLen", VALUEFUNC(_wrap_tabledef_fixedRecordLen_get), -1);
  rb_define_method(SwigClassTabledef.klass, "schemaCodePage=", VALUEFUNC(_wrap_tabledef_schemaCodePage_set), -1);
  rb_define_method(SwigClassTabledef.klass, "schemaCodePage", VALUEFUNC(_wrap_tabledef_schemaCodePage_get), -1);
  rb_define_method(SwigClassTabledef.klass, "parent=", VALUEFUNC(_wrap_tabledef_parent_set), -1);
  rb_define_method(SwigClassTabledef.klass, "parent", VALUEFUNC(_wrap_tabledef_parent_get), -1);
  rb_define_method(SwigClassTabledef.klass, "fieldDefs=", VALUEFUNC(_wrap_tabledef_fieldDefs_set), -1);
  rb_define_method(SwigClassTabledef.klass, "fieldDefs", VALUEFUNC(_wrap_tabledef_fieldDefs_get), -1);
  rb_define_method(SwigClassTabledef.klass, "keyDefs=", VALUEFUNC(_wrap_tabledef_keyDefs_set), -1);
  rb_define_method(SwigClassTabledef.klass, "keyDefs", VALUEFUNC(_wrap_tabledef_keyDefs_get), -1);
  rb_define_method(SwigClassTabledef.klass, "fieldDef", VALUEFUNC(_wrap_tabledef_fieldDef), -1);
  rb_define_method(SwigClassTabledef.klass, "keyDef", VALUEFUNC(_wrap_tabledef_keyDef), -1);
  SwigClassTabledef.mark = 0;
  SwigClassTabledef.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_tabledef;
  SwigClassTabledef.trackObjects = 0;
  
  SwigClassBtrVersion.klass = rb_define_class_under(mTransactd, "BtrVersion", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__btrVersion, (void *) &SwigClassBtrVersion);
  rb_define_alloc_func(SwigClassBtrVersion.klass, _wrap_btrVersion_allocate);
  rb_define_method(SwigClassBtrVersion.klass, "initialize", VALUEFUNC(_wrap_new_btrVersion), -1);
  rb_define_method(SwigClassBtrVersion.klass, "majorVersion=", VALUEFUNC(_wrap_btrVersion_majorVersion_set), -1);
  rb_define_method(SwigClassBtrVersion.klass, "majorVersion", VALUEFUNC(_wrap_btrVersion_majorVersion_get), -1);
  rb_define_method(SwigClassBtrVersion.klass, "minorVersion=", VALUEFUNC(_wrap_btrVersion_minorVersion_set), -1);
  rb_define_method(SwigClassBtrVersion.klass, "minorVersion", VALUEFUNC(_wrap_btrVersion_minorVersion_get), -1);
  rb_define_method(SwigClassBtrVersion.klass, "type=", VALUEFUNC(_wrap_btrVersion_type_set), -1);
  rb_define_method(SwigClassBtrVersion.klass, "type", VALUEFUNC(_wrap_btrVersion_type_get), -1);
  rb_define_method(SwigClassBtrVersion.klass, "moduleVersionShortString", VALUEFUNC(_wrap_btrVersion_moduleVersionShortString), -1);
  rb_define_method(SwigClassBtrVersion.klass, "moduleTypeString", VALUEFUNC(_wrap_btrVersion_moduleTypeString), -1);
  SwigClassBtrVersion.mark = 0;
  SwigClassBtrVersion.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_btrVersion;
  SwigClassBtrVersion.trackObjects = 0;
  
  SwigClassBtrVersions.klass = rb_define_class_under(mTransactd, "BtrVersions", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__btrVersions, (void *) &SwigClassBtrVersions);
  rb_define_alloc_func(SwigClassBtrVersions.klass, _wrap_btrVersions_allocate);
  rb_define_method(SwigClassBtrVersions.klass, "initialize", VALUEFUNC(_wrap_new_btrVersions), -1);
  rb_define_method(SwigClassBtrVersions.klass, "versions=", VALUEFUNC(_wrap_btrVersions_versions_set), -1);
  rb_define_method(SwigClassBtrVersions.klass, "versions", VALUEFUNC(_wrap_btrVersions_versions_get), -1);
  rb_define_method(SwigClassBtrVersions.klass, "version", VALUEFUNC(_wrap_btrVersions_version), -1);
  SwigClassBtrVersions.mark = 0;
  SwigClassBtrVersions.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_btrVersions;
  SwigClassBtrVersions.trackObjects = 0;
  rb_define_const(mTransactd, "ECend", SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::eCend)));
  rb_define_const(mTransactd, "ECand", SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::eCand)));
  rb_define_const(mTransactd, "ECor", SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::eCor)));
  rb_define_const(mTransactd, "EEqual", SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::eEqual)));
  rb_define_const(mTransactd, "EGreater", SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::eGreater)));
  rb_define_const(mTransactd, "ELess", SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::eLess)));
  rb_define_const(mTransactd, "ENotEq", SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::eNotEq)));
  rb_define_const(mTransactd, "EGreaterEq", SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::eGreaterEq)));
  rb_define_const(mTransactd, "ELessEq", SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::eLessEq)));
  rb_define_module_function(mTransactd, "getFilterLogicTypeCode", VALUEFUNC(_wrap_getFilterLogicTypeCode), -1);
  
  SwigClassNstable.klass = rb_define_class_under(mTransactd, "Nstable", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable, (void *) &SwigClassNstable);
  rb_undef_alloc_func(SwigClassNstable.klass);
  rb_define_const(SwigClassNstable.klass, "ChangeCurrentCc", SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::client::nstable::changeCurrentCc)));
  rb_define_const(SwigClassNstable.klass, "ChangeCurrentNcc", SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::client::nstable::changeCurrentNcc)));
  rb_define_const(SwigClassNstable.klass, "ChangeInKey", SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::client::nstable::changeInKey)));
  rb_define_const(SwigClassNstable.klass, "FindForword", SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::client::nstable::findForword)));
  rb_define_const(SwigClassNstable.klass, "FindBackForword", SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::client::nstable::findBackForword)));
  rb_define_const(SwigClassNstable.klass, "Inkey", SWIG_From_bool(static_cast< bool >(bzs::db::protocol::tdap::client::nstable::inkey)));
  rb_define_method(SwigClassNstable.klass, "nsdb", VALUEFUNC(_wrap_nstable_nsdb), -1);
  rb_define_method(SwigClassNstable.klass, "tableid", VALUEFUNC(_wrap_nstable_tableid), -1);
  rb_define_method(SwigClassNstable.klass, "setTableid", VALUEFUNC(_wrap_nstable_setTableid), -1);
  rb_define_method(SwigClassNstable.klass, "isOpen", VALUEFUNC(_wrap_nstable_isOpen), -1);
  rb_define_method(SwigClassNstable.klass, "isUseTransactd", VALUEFUNC(_wrap_nstable_isUseTransactd), -1);
  rb_define_method(SwigClassNstable.klass, "setAccessRights", VALUEFUNC(_wrap_nstable_setAccessRights), -1);
  rb_define_method(SwigClassNstable.klass, "datalen", VALUEFUNC(_wrap_nstable_datalen), -1);
  rb_define_method(SwigClassNstable.klass, "stat", VALUEFUNC(_wrap_nstable_stat), -1);
  rb_define_method(SwigClassNstable.klass, "keyNum", VALUEFUNC(_wrap_nstable_keyNum), -1);
  rb_define_method(SwigClassNstable.klass, "setKeyNum", VALUEFUNC(_wrap_nstable_setKeyNum), -1);
  rb_define_method(SwigClassNstable.klass, "canRead", VALUEFUNC(_wrap_nstable_canRead), -1);
  rb_define_method(SwigClassNstable.klass, "canWrite", VALUEFUNC(_wrap_nstable_canWrite), -1);
  rb_define_method(SwigClassNstable.klass, "canInsert", VALUEFUNC(_wrap_nstable_canInsert), -1);
  rb_define_method(SwigClassNstable.klass, "canDelete", VALUEFUNC(_wrap_nstable_canDelete), -1);
  rb_define_method(SwigClassNstable.klass, "getWriteImageLen", VALUEFUNC(_wrap_nstable_getWriteImageLen), -1);
  rb_define_method(SwigClassNstable.klass, "close", VALUEFUNC(_wrap_nstable_close), -1);
  rb_define_method(SwigClassNstable.klass, "update", VALUEFUNC(_wrap_nstable_update), -1);
  rb_define_method(SwigClassNstable.klass, "del", VALUEFUNC(_wrap_nstable_del), -1);
  rb_define_method(SwigClassNstable.klass, "insert", VALUEFUNC(_wrap_nstable_insert), -1);
  rb_define_method(SwigClassNstable.klass, "createIndex", VALUEFUNC(_wrap_nstable_createIndex), -1);
  rb_define_method(SwigClassNstable.klass, "dropIndex", VALUEFUNC(_wrap_nstable_dropIndex), -1);
  rb_define_method(SwigClassNstable.klass, "recordCount", VALUEFUNC(_wrap_nstable_recordCount), -1);
  rb_define_method(SwigClassNstable.klass, "beginBulkInsert", VALUEFUNC(_wrap_nstable_beginBulkInsert), -1);
  rb_define_method(SwigClassNstable.klass, "abortBulkInsert", VALUEFUNC(_wrap_nstable_abortBulkInsert), -1);
  rb_define_method(SwigClassNstable.klass, "commitBulkInsert", VALUEFUNC(_wrap_nstable_commitBulkInsert), -1);
  rb_define_method(SwigClassNstable.klass, "seekFirst", VALUEFUNC(_wrap_nstable_seekFirst), -1);
  rb_define_method(SwigClassNstable.klass, "seekLast", VALUEFUNC(_wrap_nstable_seekLast), -1);
  rb_define_method(SwigClassNstable.klass, "seekPrev", VALUEFUNC(_wrap_nstable_seekPrev), -1);
  rb_define_method(SwigClassNstable.klass, "seekNext", VALUEFUNC(_wrap_nstable_seekNext), -1);
  rb_define_method(SwigClassNstable.klass, "seek", VALUEFUNC(_wrap_nstable_seek), -1);
  rb_define_method(SwigClassNstable.klass, "seekGreater", VALUEFUNC(_wrap_nstable_seekGreater), -1);
  rb_define_method(SwigClassNstable.klass, "seekLessThan", VALUEFUNC(_wrap_nstable_seekLessThan), -1);
  rb_define_method(SwigClassNstable.klass, "stepFirst", VALUEFUNC(_wrap_nstable_stepFirst), -1);
  rb_define_method(SwigClassNstable.klass, "stepLast", VALUEFUNC(_wrap_nstable_stepLast), -1);
  rb_define_method(SwigClassNstable.klass, "stepPrev", VALUEFUNC(_wrap_nstable_stepPrev), -1);
  rb_define_method(SwigClassNstable.klass, "stepNext", VALUEFUNC(_wrap_nstable_stepNext), -1);
  rb_define_method(SwigClassNstable.klass, "bookmarkLen", VALUEFUNC(_wrap_nstable_bookmarkLen), -1);
  rb_define_method(SwigClassNstable.klass, "bookmark", VALUEFUNC(_wrap_nstable_bookmark), -1);
  rb_define_method(SwigClassNstable.klass, "seekByBookmark", VALUEFUNC(_wrap_nstable_seekByBookmark), -1);
  rb_define_method(SwigClassNstable.klass, "getPercentage", VALUEFUNC(_wrap_nstable_getPercentage), -1);
  rb_define_method(SwigClassNstable.klass, "seekByPercentage", VALUEFUNC(_wrap_nstable_seekByPercentage), -1);
  rb_define_method(SwigClassNstable.klass, "setOwnerName", VALUEFUNC(_wrap_nstable_setOwnerName), -1);
  rb_define_method(SwigClassNstable.klass, "clearOwnerName", VALUEFUNC(_wrap_nstable_clearOwnerName), -1);
  rb_define_method(SwigClassNstable.klass, "recordLength", VALUEFUNC(_wrap_nstable_recordLength), -1);
  rb_define_method(SwigClassNstable.klass, "stats", VALUEFUNC(_wrap_nstable_stats), -1);
  rb_define_method(SwigClassNstable.klass, "unlock", VALUEFUNC(_wrap_nstable_unlock), -1);
  rb_define_method(SwigClassNstable.klass, "mode", VALUEFUNC(_wrap_nstable_mode), -1);
  rb_define_method(SwigClassNstable.klass, "statMsg", VALUEFUNC(_wrap_nstable_statMsg), -1);
  rb_define_singleton_method(SwigClassNstable.klass, "getFileName", VALUEFUNC(_wrap_nstable_getFileName), -1);
  rb_define_singleton_method(SwigClassNstable.klass, "getDirURI", VALUEFUNC(_wrap_nstable_getDirURI), -1);
  rb_define_singleton_method(SwigClassNstable.klass, "existsFile", VALUEFUNC(_wrap_nstable_existsFile), -1);
  SwigClassNstable.mark = 0;
  SwigClassNstable.trackObjects = 0;
  rb_define_const(mTransactd, "TABLE_NUM_TMP", SWIG_From_int(static_cast< int >(TABLE_NUM_TMP)));
  rb_define_const(mTransactd, "EMinlen", SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::client::eMinlen)));
  rb_define_const(mTransactd, "EMaxlen", SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::client::eMaxlen)));
  rb_define_const(mTransactd, "EDefaultlen", SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::client::eDefaultlen)));
  rb_define_const(mTransactd, "EDecimals", SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::client::eDecimals)));
  
  SwigClassDbdef.klass = rb_define_class_under(mTransactd, "Dbdef", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__dbdef, (void *) &SwigClassDbdef);
  rb_undef_alloc_func(SwigClassDbdef.klass);
  rb_define_method(SwigClassDbdef.klass, "tableCount", VALUEFUNC(_wrap_dbdef_tableCount), -1);
  rb_define_method(SwigClassDbdef.klass, "openMode", VALUEFUNC(_wrap_dbdef_openMode), -1);
  rb_define_method(SwigClassDbdef.klass, "tableDefs", VALUEFUNC(_wrap_dbdef_tableDefs), -1);
  rb_define_method(SwigClassDbdef.klass, "tableDefPtr", VALUEFUNC(_wrap_dbdef_tableDefPtr), -1);
  rb_define_method(SwigClassDbdef.klass, "setVersion", VALUEFUNC(_wrap_dbdef_setVersion), -1);
  rb_define_method(SwigClassDbdef.klass, "version", VALUEFUNC(_wrap_dbdef_version), -1);
  rb_define_method(SwigClassDbdef.klass, "validateTableDef", VALUEFUNC(_wrap_dbdef_validateTableDef), -1);
  rb_define_method(SwigClassDbdef.klass, "stat", VALUEFUNC(_wrap_dbdef_stat), -1);
  rb_define_method(SwigClassDbdef.klass, "updateTableDef", VALUEFUNC(_wrap_dbdef_updateTableDef), -1);
  rb_define_method(SwigClassDbdef.klass, "insertField", VALUEFUNC(_wrap_dbdef_insertField), -1);
  rb_define_method(SwigClassDbdef.klass, "deleteField", VALUEFUNC(_wrap_dbdef_deleteField), -1);
  rb_define_method(SwigClassDbdef.klass, "insertKey", VALUEFUNC(_wrap_dbdef_insertKey), -1);
  rb_define_method(SwigClassDbdef.klass, "deleteKey", VALUEFUNC(_wrap_dbdef_deleteKey), -1);
  rb_define_method(SwigClassDbdef.klass, "insertTable", VALUEFUNC(_wrap_dbdef_insertTable), -1);
  rb_define_method(SwigClassDbdef.klass, "deleteTable", VALUEFUNC(_wrap_dbdef_deleteTable), -1);
  rb_define_method(SwigClassDbdef.klass, "renumberTable", VALUEFUNC(_wrap_dbdef_renumberTable), -1);
  rb_define_method(SwigClassDbdef.klass, "tableNumByName", VALUEFUNC(_wrap_dbdef_tableNumByName), -1);
  rb_define_method(SwigClassDbdef.klass, "getRecordLen", VALUEFUNC(_wrap_dbdef_getRecordLen), -1);
  rb_define_method(SwigClassDbdef.klass, "findKeynumByFieldNum", VALUEFUNC(_wrap_dbdef_findKeynumByFieldNum), -1);
  rb_define_method(SwigClassDbdef.klass, "fieldNumByName", VALUEFUNC(_wrap_dbdef_fieldNumByName), -1);
  rb_define_method(SwigClassDbdef.klass, "fieldValidLength", VALUEFUNC(_wrap_dbdef_fieldValidLength), -1);
  rb_define_method(SwigClassDbdef.klass, "statMsg", VALUEFUNC(_wrap_dbdef_statMsg), -1);
  rb_define_method(SwigClassDbdef.klass, "reopen", VALUEFUNC(_wrap_dbdef_reopen), -1);
  rb_define_method(SwigClassDbdef.klass, "mode", VALUEFUNC(_wrap_dbdef_mode), -1);
  SwigClassDbdef.mark = 0;
  SwigClassDbdef.trackObjects = 0;
  rb_define_const(mTransactd, "Null_str", SWIG_FromCharPtr(null_str));
  
  SwigClassTable.klass = rb_define_class_under(mTransactd, "Table", ((swig_class *) SWIGTYPE_p_bzs__db__protocol__tdap__client__nstable->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__table, (void *) &SwigClassTable);
  rb_undef_alloc_func(SwigClassTable.klass);
  rb_define_method(SwigClassTable.klass, "tableDef", VALUEFUNC(_wrap_table_tableDef), -1);
  rb_define_method(SwigClassTable.klass, "tableDefPtr", VALUEFUNC(_wrap_table_tableDefPtr), -1);
  rb_define_method(SwigClassTable.klass, "valiableFormatType", VALUEFUNC(_wrap_table_valiableFormatType), -1);
  rb_define_method(SwigClassTable.klass, "blobFieldUsed", VALUEFUNC(_wrap_table_blobFieldUsed), -1);
  rb_define_method(SwigClassTable.klass, "logicalToString", VALUEFUNC(_wrap_table_logicalToString), -1);
  rb_define_method(SwigClassTable.klass, "setLogicalToString", VALUEFUNC(_wrap_table_setLogicalToString), -1);
  rb_define_method(SwigClassTable.klass, "optionalData", VALUEFUNC(_wrap_table_optionalData), -1);
  rb_define_method(SwigClassTable.klass, "setOptionalData", VALUEFUNC(_wrap_table_setOptionalData), -1);
  rb_define_method(SwigClassTable.klass, "myDateTimeValueByBtrv", VALUEFUNC(_wrap_table_myDateTimeValueByBtrv), -1);
  rb_define_method(SwigClassTable.klass, "bookmarksCount", VALUEFUNC(_wrap_table_bookmarksCount), -1);
  rb_define_method(SwigClassTable.klass, "moveBookmarks", VALUEFUNC(_wrap_table_moveBookmarks), -1);
  rb_define_method(SwigClassTable.klass, "bookmarks", VALUEFUNC(_wrap_table_bookmarks), -1);
  rb_define_method(SwigClassTable.klass, "clearBuffer", VALUEFUNC(_wrap_table_clearBuffer), -1);
  rb_define_method(SwigClassTable.klass, "getRecordHash", VALUEFUNC(_wrap_table_getRecordHash), -1);
  rb_define_method(SwigClassTable.klass, "smartUpdate", VALUEFUNC(_wrap_table_smartUpdate), -1);
  rb_define_method(SwigClassTable.klass, "find", VALUEFUNC(_wrap_table_find), -1);
  rb_define_method(SwigClassTable.klass, "findFirst", VALUEFUNC(_wrap_table_findFirst), -1);
  rb_define_method(SwigClassTable.klass, "findLast", VALUEFUNC(_wrap_table_findLast), -1);
  rb_define_method(SwigClassTable.klass, "findNext", VALUEFUNC(_wrap_table_findNext), -1);
  rb_define_method(SwigClassTable.klass, "findPrev", VALUEFUNC(_wrap_table_findPrev), -1);
  rb_define_method(SwigClassTable.klass, "statReasonOfFind", VALUEFUNC(_wrap_table_statReasonOfFind), -1);
  rb_define_method(SwigClassTable.klass, "lastFindDirection", VALUEFUNC(_wrap_table_lastFindDirection), -1);
  rb_define_method(SwigClassTable.klass, "bookmarkFindCurrent", VALUEFUNC(_wrap_table_bookmarkFindCurrent), -1);
  rb_define_method(SwigClassTable.klass, "setFilter", VALUEFUNC(_wrap_table_setFilter), -1);
  rb_define_method(SwigClassTable.klass, "fieldNumByName", VALUEFUNC(_wrap_table_fieldNumByName), -1);
  rb_define_method(SwigClassTable.klass, "getFVbyt", VALUEFUNC(_wrap_table_getFVbyt), -1);
  rb_define_method(SwigClassTable.klass, "getFVsht", VALUEFUNC(_wrap_table_getFVsht), -1);
  rb_define_method(SwigClassTable.klass, "getFVint", VALUEFUNC(_wrap_table_getFVint), -1);
  rb_define_method(SwigClassTable.klass, "getFVlng", VALUEFUNC(_wrap_table_getFVlng), -1);
  rb_define_method(SwigClassTable.klass, "getFV64", VALUEFUNC(_wrap_table_getFV64), -1);
  rb_define_method(SwigClassTable.klass, "getFVflt", VALUEFUNC(_wrap_table_getFVflt), -1);
  rb_define_method(SwigClassTable.klass, "getFVdbl", VALUEFUNC(_wrap_table_getFVdbl), -1);
  rb_define_method(SwigClassTable.klass, "getFVstr", VALUEFUNC(_wrap_table_getFVstr), -1);
  rb_define_method(SwigClassTable.klass, "fields", VALUEFUNC(_wrap_table_fields), -1);
  rb_define_method(SwigClassTable.klass, "setFV", VALUEFUNC(_wrap_table_setFV), -1);
  rb_define_method(SwigClassTable.klass, "getFVbin", VALUEFUNC(_wrap_table_getFVbin), -1);
  rb_define_method(SwigClassTable.klass, "keyValueDescription", VALUEFUNC(_wrap_table_keyValueDescription), -1);
  rb_define_method(SwigClassTable.klass, "prepare", VALUEFUNC(_wrap_table_prepare), -1);
  rb_define_method(SwigClassTable.klass, "setQuery", VALUEFUNC(_wrap_table_setQuery), -1);
  rb_define_method(SwigClassTable.klass, "setPrepare", VALUEFUNC(_wrap_table_setPrepare), -1);
  rb_define_method(SwigClassTable.klass, "release", VALUEFUNC(_wrap_table_release), -1);
  SwigClassTable.mark = 0;
  SwigClassTable.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_table;
  SwigClassTable.trackObjects = 0;
  rb_define_const(mTransactd, "KEYVALUE_PTR", SWIG_From_int(static_cast< int >(KEYVALUE_PTR)));
  rb_define_const(mTransactd, "KEYVALUE_STR", SWIG_From_int(static_cast< int >(KEYVALUE_STR)));
  rb_define_const(mTransactd, "KEYVALUE_NEED_COPY", SWIG_From_int(static_cast< int >(KEYVALUE_NEED_COPY)));
  rb_define_const(mTransactd, "KEYVALUE_STR_NEED_COPY", SWIG_From_int(static_cast< int >(KEYVALUE_STR_NEED_COPY)));
  
  SwigClassQueryBase.klass = rb_define_class_under(mTransactd, "QueryBase", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase, (void *) &SwigClassQueryBase);
  rb_undef_alloc_func(SwigClassQueryBase.klass);
  rb_define_const(SwigClassQueryBase.klass, "None", SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::client::queryBase::none)));
  rb_define_const(SwigClassQueryBase.klass, "JoinHasOneOrHasMany", SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::client::queryBase::joinHasOneOrHasMany)));
  rb_define_const(SwigClassQueryBase.klass, "CombineCondition", SWIG_From_int(static_cast< int >(bzs::db::protocol::tdap::client::queryBase::combineCondition)));
  rb_define_method(SwigClassQueryBase.klass, "clearSeekKeyValues", VALUEFUNC(_wrap_queryBase_clearSeekKeyValues), -1);
  rb_define_method(SwigClassQueryBase.klass, "clearSelectFields", VALUEFUNC(_wrap_queryBase_clearSelectFields), -1);
  rb_define_method(SwigClassQueryBase.klass, "addSeekKeyValue", VALUEFUNC(_wrap_queryBase_addSeekKeyValue), -1);
  rb_define_method(SwigClassQueryBase.klass, "addSeekBookmark", VALUEFUNC(_wrap_queryBase_addSeekBookmark), -1);
  rb_define_method(SwigClassQueryBase.klass, "reserveSeekKeyValueSize", VALUEFUNC(_wrap_queryBase_reserveSeekKeyValueSize), -1);
  rb_define_method(SwigClassQueryBase.klass, "queryString", VALUEFUNC(_wrap_queryBase_queryString), -1);
  rb_define_method(SwigClassQueryBase.klass, "reject", VALUEFUNC(_wrap_queryBase_reject), -1);
  rb_define_method(SwigClassQueryBase.klass, "limit", VALUEFUNC(_wrap_queryBase_limit), -1);
  rb_define_method(SwigClassQueryBase.klass, "direction", VALUEFUNC(_wrap_queryBase_direction), -1);
  rb_define_method(SwigClassQueryBase.klass, "all", VALUEFUNC(_wrap_queryBase_all), -1);
  rb_define_method(SwigClassQueryBase.klass, "optimize", VALUEFUNC(_wrap_queryBase_optimize), -1);
  rb_define_method(SwigClassQueryBase.klass, "bookmarkAlso", VALUEFUNC(_wrap_queryBase_bookmarkAlso), -1);
  rb_define_method(SwigClassQueryBase.klass, "toString", VALUEFUNC(_wrap_queryBase_toString), -1);
  rb_define_method(SwigClassQueryBase.klass, "getDirection", VALUEFUNC(_wrap_queryBase_getDirection), -1);
  rb_define_method(SwigClassQueryBase.klass, "getReject", VALUEFUNC(_wrap_queryBase_getReject), -1);
  rb_define_method(SwigClassQueryBase.klass, "getLimit", VALUEFUNC(_wrap_queryBase_getLimit), -1);
  rb_define_method(SwigClassQueryBase.klass, "isAll", VALUEFUNC(_wrap_queryBase_isAll), -1);
  rb_define_method(SwigClassQueryBase.klass, "getJoinKeySize", VALUEFUNC(_wrap_queryBase_getJoinKeySize), -1);
  rb_define_method(SwigClassQueryBase.klass, "getOptimize", VALUEFUNC(_wrap_queryBase_getOptimize), -1);
  rb_define_method(SwigClassQueryBase.klass, "isBookmarkAlso", VALUEFUNC(_wrap_queryBase_isBookmarkAlso), -1);
  rb_define_method(SwigClassQueryBase.klass, "selectCount", VALUEFUNC(_wrap_queryBase_selectCount), -1);
  rb_define_method(SwigClassQueryBase.klass, "getSelect", VALUEFUNC(_wrap_queryBase_getSelect), -1);
  rb_define_method(SwigClassQueryBase.klass, "whereTokens", VALUEFUNC(_wrap_queryBase_whereTokens), -1);
  rb_define_method(SwigClassQueryBase.klass, "getWhereToken", VALUEFUNC(_wrap_queryBase_getWhereToken), -1);
  rb_define_method(SwigClassQueryBase.klass, "setWhereToken", VALUEFUNC(_wrap_queryBase_setWhereToken), -1);
  rb_define_method(SwigClassQueryBase.klass, "reverseAliasName", VALUEFUNC(_wrap_queryBase_reverseAliasName), -1);
  rb_define_method(SwigClassQueryBase.klass, "stopAtLimit", VALUEFUNC(_wrap_queryBase_stopAtLimit), -1);
  rb_define_method(SwigClassQueryBase.klass, "isStopAtLimit", VALUEFUNC(_wrap_queryBase_isStopAtLimit), -1);
  rb_define_method(SwigClassQueryBase.klass, "isSeekByBookmarks", VALUEFUNC(_wrap_queryBase_isSeekByBookmarks), -1);
  SwigClassQueryBase.mark = 0;
  SwigClassQueryBase.trackObjects = 0;
  
  SwigClassQuery.klass = rb_define_class_under(mTransactd, "Query", ((swig_class *) SWIGTYPE_p_bzs__db__protocol__tdap__client__queryBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__query, (void *) &SwigClassQuery);
  rb_define_alloc_func(SwigClassQuery.klass, _wrap_query_allocate);
  rb_define_method(SwigClassQuery.klass, "initialize", VALUEFUNC(_wrap_new_query), -1);
  rb_define_method(SwigClassQuery.klass, "reset", VALUEFUNC(_wrap_query_reset), -1);
  rb_define_method(SwigClassQuery.klass, "select", VALUEFUNC(_wrap_query_select), -1);
  rb_define_method(SwigClassQuery.klass, "where", VALUEFUNC(_wrap_query_where), -1);
  rb_define_method(SwigClassQuery.klass, "and_", VALUEFUNC(_wrap_query_and_), -1);
  rb_define_method(SwigClassQuery.klass, "or_", VALUEFUNC(_wrap_query_or_), -1);
  rb_define_method(SwigClassQuery.klass, "in", VALUEFUNC(_wrap_query_in), -1);
  SwigClassQuery.mark = 0;
  SwigClassQuery.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_query;
  SwigClassQuery.trackObjects = 0;
  
  SwigClassNsdatabase.klass = rb_define_class_under(mTransactd, "Nsdatabase", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase, (void *) &SwigClassNsdatabase);
  rb_define_alloc_func(SwigClassNsdatabase.klass, _wrap_nsdatabase_allocate);
  rb_define_method(SwigClassNsdatabase.klass, "initialize", VALUEFUNC(_wrap_new_nsdatabase), -1);
  rb_define_method(SwigClassNsdatabase.klass, "enableTrn", VALUEFUNC(_wrap_nsdatabase_enableTrn), -1);
  rb_define_method(SwigClassNsdatabase.klass, "stat", VALUEFUNC(_wrap_nsdatabase_stat), -1);
  rb_define_method(SwigClassNsdatabase.klass, "clientID", VALUEFUNC(_wrap_nsdatabase_clientID), -1);
  rb_define_method(SwigClassNsdatabase.klass, "openTableCount", VALUEFUNC(_wrap_nsdatabase_openTableCount), -1);
  rb_define_method(SwigClassNsdatabase.klass, "uri", VALUEFUNC(_wrap_nsdatabase_uri), -1);
  rb_define_method(SwigClassNsdatabase.klass, "uriMode", VALUEFUNC(_wrap_nsdatabase_uriMode), -1);
  rb_define_method(SwigClassNsdatabase.klass, "lockWaitCount", VALUEFUNC(_wrap_nsdatabase_lockWaitCount), -1);
  rb_define_method(SwigClassNsdatabase.klass, "lockWaitTime", VALUEFUNC(_wrap_nsdatabase_lockWaitTime), -1);
  rb_define_method(SwigClassNsdatabase.klass, "setLockWaitCount", VALUEFUNC(_wrap_nsdatabase_setLockWaitCount), -1);
  rb_define_method(SwigClassNsdatabase.klass, "setLockWaitTime", VALUEFUNC(_wrap_nsdatabase_setLockWaitTime), -1);
  rb_define_method(SwigClassNsdatabase.klass, "setLocalSharing", VALUEFUNC(_wrap_nsdatabase_setLocalSharing), -1);
  rb_define_method(SwigClassNsdatabase.klass, "dropTable", VALUEFUNC(_wrap_nsdatabase_dropTable), -1);
  rb_define_method(SwigClassNsdatabase.klass, "rename", VALUEFUNC(_wrap_nsdatabase_rename), -1);
  rb_define_method(SwigClassNsdatabase.klass, "swapTablename", VALUEFUNC(_wrap_nsdatabase_swapTablename), -1);
  rb_define_method(SwigClassNsdatabase.klass, "beginTrn", VALUEFUNC(_wrap_nsdatabase_beginTrn), -1);
  rb_define_method(SwigClassNsdatabase.klass, "endTrn", VALUEFUNC(_wrap_nsdatabase_endTrn), -1);
  rb_define_method(SwigClassNsdatabase.klass, "abortTrn", VALUEFUNC(_wrap_nsdatabase_abortTrn), -1);
  rb_define_method(SwigClassNsdatabase.klass, "beginSnapshot", VALUEFUNC(_wrap_nsdatabase_beginSnapshot), -1);
  rb_define_method(SwigClassNsdatabase.klass, "endSnapshot", VALUEFUNC(_wrap_nsdatabase_endSnapshot), -1);
  rb_define_method(SwigClassNsdatabase.klass, "trxIsolationServer", VALUEFUNC(_wrap_nsdatabase_trxIsolationServer), -1);
  rb_define_method(SwigClassNsdatabase.klass, "trxLockWaitTimeoutServer", VALUEFUNC(_wrap_nsdatabase_trxLockWaitTimeoutServer), -1);
  rb_define_method(SwigClassNsdatabase.klass, "statMsg", VALUEFUNC(_wrap_nsdatabase_statMsg), -1);
  rb_define_method(SwigClassNsdatabase.klass, "useLongFilename", VALUEFUNC(_wrap_nsdatabase_useLongFilename), -1);
  rb_define_method(SwigClassNsdatabase.klass, "setUseLongFilename", VALUEFUNC(_wrap_nsdatabase_setUseLongFilename), -1);
  rb_define_method(SwigClassNsdatabase.klass, "setUseTransactd", VALUEFUNC(_wrap_nsdatabase_setUseTransactd), -1);
  rb_define_method(SwigClassNsdatabase.klass, "isTransactdUri", VALUEFUNC(_wrap_nsdatabase_isTransactdUri), -1);
  rb_define_method(SwigClassNsdatabase.klass, "isUseTransactd", VALUEFUNC(_wrap_nsdatabase_isUseTransactd), -1);
  rb_define_method(SwigClassNsdatabase.klass, "readDatabaseDirectory", VALUEFUNC(_wrap_nsdatabase_readDatabaseDirectory), -1);
  rb_define_method(SwigClassNsdatabase.klass, "connect", VALUEFUNC(_wrap_nsdatabase_connect), -1);
  rb_define_method(SwigClassNsdatabase.klass, "disconnect", VALUEFUNC(_wrap_nsdatabase_disconnect), -1);
  rb_define_method(SwigClassNsdatabase.klass, "disconnectForReconnectTest", VALUEFUNC(_wrap_nsdatabase_disconnectForReconnectTest), -1);
  rb_define_method(SwigClassNsdatabase.klass, "reconnect", VALUEFUNC(_wrap_nsdatabase_reconnect), -1);
  rb_define_singleton_method(SwigClassNsdatabase.klass, "trnsactionFlushWaitStatus", VALUEFUNC(_wrap_nsdatabase_trnsactionFlushWaitStatus), -1);
  rb_define_singleton_method(SwigClassNsdatabase.klass, "setExecCodePage", VALUEFUNC(_wrap_nsdatabase_setExecCodePage), -1);
  rb_define_singleton_method(SwigClassNsdatabase.klass, "execCodePage", VALUEFUNC(_wrap_nsdatabase_execCodePage), -1);
  rb_define_singleton_method(SwigClassNsdatabase.klass, "setCheckTablePtr", VALUEFUNC(_wrap_nsdatabase_setCheckTablePtr), -1);
  SwigClassNsdatabase.mark = 0;
  SwigClassNsdatabase.trackObjects = 0;
  
  SwigClassDatabase.klass = rb_define_class_under(mTransactd, "Database", ((swig_class *) SWIGTYPE_p_bzs__db__protocol__tdap__client__nsdatabase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__database, (void *) &SwigClassDatabase);
  rb_define_alloc_func(SwigClassDatabase.klass, _wrap_database_allocate);
  rb_define_method(SwigClassDatabase.klass, "initialize", VALUEFUNC(_wrap_new_database), -1);
  rb_define_method(SwigClassDatabase.klass, "dbDef", VALUEFUNC(_wrap_database_dbDef), -1);
  rb_define_method(SwigClassDatabase.klass, "rootDir", VALUEFUNC(_wrap_database_rootDir), -1);
  rb_define_method(SwigClassDatabase.klass, "setRootDir", VALUEFUNC(_wrap_database_setRootDir), -1);
  rb_define_method(SwigClassDatabase.klass, "optionalData", VALUEFUNC(_wrap_database_optionalData), -1);
  rb_define_method(SwigClassDatabase.klass, "setOptionalData", VALUEFUNC(_wrap_database_setOptionalData), -1);
  rb_define_method(SwigClassDatabase.klass, "tableReadOnly", VALUEFUNC(_wrap_database_tableReadOnly), -1);
  rb_define_method(SwigClassDatabase.klass, "setTableReadOnly", VALUEFUNC(_wrap_database_setTableReadOnly), -1);
  rb_define_method(SwigClassDatabase.klass, "open", VALUEFUNC(_wrap_database_open), -1);
  rb_define_method(SwigClassDatabase.klass, "clone", VALUEFUNC(_wrap_database_clone), -1);
  rb_define_method(SwigClassDatabase.klass, "create", VALUEFUNC(_wrap_database_create), -1);
  rb_define_method(SwigClassDatabase.klass, "drop", VALUEFUNC(_wrap_database_drop), -1);
  rb_define_method(SwigClassDatabase.klass, "dropTable", VALUEFUNC(_wrap_database_dropTable), -1);
  rb_define_method(SwigClassDatabase.klass, "close", VALUEFUNC(_wrap_database_close), -1);
  rb_define_method(SwigClassDatabase.klass, "aclReload", VALUEFUNC(_wrap_database_aclReload), -1);
  rb_define_method(SwigClassDatabase.klass, "continuous", VALUEFUNC(_wrap_database_continuous), -1);
  rb_define_method(SwigClassDatabase.klass, "assignSchemaData", VALUEFUNC(_wrap_database_assignSchemaData), -1);
  rb_define_method(SwigClassDatabase.klass, "copyTableData", VALUEFUNC(_wrap_database_copyTableData), -1);
  rb_define_method(SwigClassDatabase.klass, "convertTable", VALUEFUNC(_wrap_database_convertTable), -1);
  rb_define_method(SwigClassDatabase.klass, "existsTableFile", VALUEFUNC(_wrap_database_existsTableFile), -1);
  rb_define_method(SwigClassDatabase.klass, "getTableUri", VALUEFUNC(_wrap_database_getTableUri), -1);
  rb_define_method(SwigClassDatabase.klass, "getBtrVersion", VALUEFUNC(_wrap_database_getBtrVersion), -1);
  rb_define_method(SwigClassDatabase.klass, "isOpened", VALUEFUNC(_wrap_database_isOpened), -1);
  rb_define_method(SwigClassDatabase.klass, "mode", VALUEFUNC(_wrap_database_mode), -1);
  rb_define_method(SwigClassDatabase.klass, "openTable", VALUEFUNC(_wrap_database_openTable), -1);
  SwigClassDatabase.mark = 0;
  SwigClassDatabase.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_database;
  SwigClassDatabase.trackObjects = 0;
  
  SwigClassBenchmark.klass = rb_define_class_under(mTransactd, "Benchmark", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__rtl__benchmark, (void *) &SwigClassBenchmark);
  rb_define_alloc_func(SwigClassBenchmark.klass, _wrap_benchmark_allocate);
  rb_define_method(SwigClassBenchmark.klass, "initialize", VALUEFUNC(_wrap_new_benchmark), -1);
  rb_define_singleton_method(SwigClassBenchmark.klass, "start", VALUEFUNC(_wrap_benchmark_start), -1);
  rb_define_singleton_method(SwigClassBenchmark.klass, "stop", VALUEFUNC(_wrap_benchmark_stop), -1);
  rb_define_singleton_method(SwigClassBenchmark.klass, "showTimes", VALUEFUNC(_wrap_benchmark_showTimes), -1);
  rb_define_singleton_method(SwigClassBenchmark.klass, "showTimeSec", VALUEFUNC(_wrap_benchmark_showTimeSec), -1);
  SwigClassBenchmark.mark = 0;
  SwigClassBenchmark.destroy = (void (*)(void *)) free_bzs_rtl_benchmark;
  SwigClassBenchmark.trackObjects = 0;
  rb_define_const(mTransactd, "MAX_CHAR_INFO", SWIG_From_int(static_cast< int >(MAX_CHAR_INFO)));
  rb_define_const(mTransactd, "CHARSET_LATIN1", SWIG_From_int(static_cast< int >(CHARSET_LATIN1)));
  rb_define_const(mTransactd, "CHARSET_CP850", SWIG_From_int(static_cast< int >(CHARSET_CP850)));
  rb_define_const(mTransactd, "CHARSET_ASCII", SWIG_From_int(static_cast< int >(CHARSET_ASCII)));
  rb_define_const(mTransactd, "CHARSET_SJIS", SWIG_From_int(static_cast< int >(CHARSET_SJIS)));
  rb_define_const(mTransactd, "CHARSET_UTF8", SWIG_From_int(static_cast< int >(CHARSET_UTF8)));
  rb_define_const(mTransactd, "CHARSET_USC2", SWIG_From_int(static_cast< int >(CHARSET_USC2)));
  rb_define_const(mTransactd, "CHARSET_UTF8B4", SWIG_From_int(static_cast< int >(CHARSET_UTF8B4)));
  rb_define_const(mTransactd, "CHARSET_UTF16LE", SWIG_From_int(static_cast< int >(CHARSET_UTF16LE)));
  rb_define_const(mTransactd, "CHARSET_CP932", SWIG_From_int(static_cast< int >(CHARSET_CP932)));
  rb_define_const(mTransactd, "CHARSET_EUCJ", SWIG_From_int(static_cast< int >(CHARSET_EUCJ)));
  rb_define_module_function(mTransactd, "charsize", VALUEFUNC(_wrap_charsize), -1);
  rb_define_module_function(mTransactd, "charsetName", VALUEFUNC(_wrap_charsetName), -1);
  rb_define_module_function(mTransactd, "charsetIndex", VALUEFUNC(_wrap_charsetIndex), -1);
  rb_define_module_function(mTransactd, "codePage", VALUEFUNC(_wrap_codePage), -1);
  
  SwigClassBtrDate.klass = rb_define_class_under(mTransactd, "BtrDate", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__btrDate, (void *) &SwigClassBtrDate);
  rb_define_alloc_func(SwigClassBtrDate.klass, _wrap_btrDate_allocate);
  rb_define_method(SwigClassBtrDate.klass, "initialize", VALUEFUNC(_wrap_new_btrDate), -1);
  rb_define_method(SwigClassBtrDate.klass, "dd=", VALUEFUNC(_wrap_btrDate_dd_set), -1);
  rb_define_method(SwigClassBtrDate.klass, "dd", VALUEFUNC(_wrap_btrDate_dd_get), -1);
  rb_define_method(SwigClassBtrDate.klass, "mm=", VALUEFUNC(_wrap_btrDate_mm_set), -1);
  rb_define_method(SwigClassBtrDate.klass, "mm", VALUEFUNC(_wrap_btrDate_mm_get), -1);
  rb_define_method(SwigClassBtrDate.klass, "yy=", VALUEFUNC(_wrap_btrDate_yy_set), -1);
  rb_define_method(SwigClassBtrDate.klass, "yy", VALUEFUNC(_wrap_btrDate_yy_get), -1);
  rb_define_method(SwigClassBtrDate.klass, "i=", VALUEFUNC(_wrap_btrDate_i_set), -1);
  rb_define_method(SwigClassBtrDate.klass, "i", VALUEFUNC(_wrap_btrDate_i_get), -1);
  SwigClassBtrDate.mark = 0;
  SwigClassBtrDate.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_btrDate;
  SwigClassBtrDate.trackObjects = 0;
  
  SwigClassBtrTime.klass = rb_define_class_under(mTransactd, "BtrTime", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__btrTime, (void *) &SwigClassBtrTime);
  rb_define_alloc_func(SwigClassBtrTime.klass, _wrap_btrTime_allocate);
  rb_define_method(SwigClassBtrTime.klass, "initialize", VALUEFUNC(_wrap_new_btrTime), -1);
  rb_define_method(SwigClassBtrTime.klass, "uu=", VALUEFUNC(_wrap_btrTime_uu_set), -1);
  rb_define_method(SwigClassBtrTime.klass, "uu", VALUEFUNC(_wrap_btrTime_uu_get), -1);
  rb_define_method(SwigClassBtrTime.klass, "ss=", VALUEFUNC(_wrap_btrTime_ss_set), -1);
  rb_define_method(SwigClassBtrTime.klass, "ss", VALUEFUNC(_wrap_btrTime_ss_get), -1);
  rb_define_method(SwigClassBtrTime.klass, "nn=", VALUEFUNC(_wrap_btrTime_nn_set), -1);
  rb_define_method(SwigClassBtrTime.klass, "nn", VALUEFUNC(_wrap_btrTime_nn_get), -1);
  rb_define_method(SwigClassBtrTime.klass, "hh=", VALUEFUNC(_wrap_btrTime_hh_set), -1);
  rb_define_method(SwigClassBtrTime.klass, "hh", VALUEFUNC(_wrap_btrTime_hh_get), -1);
  rb_define_method(SwigClassBtrTime.klass, "i=", VALUEFUNC(_wrap_btrTime_i_set), -1);
  rb_define_method(SwigClassBtrTime.klass, "i", VALUEFUNC(_wrap_btrTime_i_get), -1);
  SwigClassBtrTime.mark = 0;
  SwigClassBtrTime.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_btrTime;
  SwigClassBtrTime.trackObjects = 0;
  
  SwigClassBtrDateTime.klass = rb_define_class_under(mTransactd, "BtrDateTime", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__btrDateTime, (void *) &SwigClassBtrDateTime);
  rb_define_alloc_func(SwigClassBtrDateTime.klass, _wrap_btrDateTime_allocate);
  rb_define_method(SwigClassBtrDateTime.klass, "initialize", VALUEFUNC(_wrap_new_btrDateTime), -1);
  rb_define_method(SwigClassBtrDateTime.klass, "time=", VALUEFUNC(_wrap_btrDateTime_time_set), -1);
  rb_define_method(SwigClassBtrDateTime.klass, "time", VALUEFUNC(_wrap_btrDateTime_time_get), -1);
  rb_define_method(SwigClassBtrDateTime.klass, "date=", VALUEFUNC(_wrap_btrDateTime_date_set), -1);
  rb_define_method(SwigClassBtrDateTime.klass, "date", VALUEFUNC(_wrap_btrDateTime_date_get), -1);
  rb_define_method(SwigClassBtrDateTime.klass, "i64=", VALUEFUNC(_wrap_btrDateTime_i64_set), -1);
  rb_define_method(SwigClassBtrDateTime.klass, "i64", VALUEFUNC(_wrap_btrDateTime_i64_get), -1);
  SwigClassBtrDateTime.mark = 0;
  SwigClassBtrDateTime.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_btrDateTime;
  SwigClassBtrDateTime.trackObjects = 0;
  
  SwigClassBtrTimeStamp.klass = rb_define_class_under(mTransactd, "BtrTimeStamp", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__btrTimeStamp, (void *) &SwigClassBtrTimeStamp);
  rb_define_alloc_func(SwigClassBtrTimeStamp.klass, _wrap_btrTimeStamp_allocate);
  rb_define_method(SwigClassBtrTimeStamp.klass, "initialize", VALUEFUNC(_wrap_new_btrTimeStamp), -1);
  rb_define_method(SwigClassBtrTimeStamp.klass, "i64=", VALUEFUNC(_wrap_btrTimeStamp_i64_set), -1);
  rb_define_method(SwigClassBtrTimeStamp.klass, "i64", VALUEFUNC(_wrap_btrTimeStamp_i64_get), -1);
  rb_define_method(SwigClassBtrTimeStamp.klass, "toString", VALUEFUNC(_wrap_btrTimeStamp_toString), -1);
  rb_define_method(SwigClassBtrTimeStamp.klass, "fromString", VALUEFUNC(_wrap_btrTimeStamp_fromString), -1);
  SwigClassBtrTimeStamp.mark = 0;
  SwigClassBtrTimeStamp.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_btrTimeStamp;
  SwigClassBtrTimeStamp.trackObjects = 0;
  rb_define_module_function(mTransactd, "atobtrd", VALUEFUNC(_wrap_atobtrd), -1);
  rb_define_module_function(mTransactd, "atobtrt", VALUEFUNC(_wrap_atobtrt), -1);
  rb_define_module_function(mTransactd, "btrdtoa", VALUEFUNC(_wrap_btrdtoa), -1);
  rb_define_module_function(mTransactd, "btrttoa", VALUEFUNC(_wrap_btrttoa), -1);
  rb_define_module_function(mTransactd, "btrstoa", VALUEFUNC(_wrap_btrstoa), -1);
  rb_define_module_function(mTransactd, "atobtrs", VALUEFUNC(_wrap_atobtrs), -1);
  rb_define_module_function(mTransactd, "getNowDate", VALUEFUNC(_wrap_getNowDate), -1);
  rb_define_module_function(mTransactd, "getNowTime", VALUEFUNC(_wrap_getNowTime), -1);
  
  SwigClassFielddefs.klass = rb_define_class_under(mTransactd, "Fielddefs", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__fielddefs, (void *) &SwigClassFielddefs);
  rb_define_alloc_func(SwigClassFielddefs.klass, _wrap_fielddefs_allocate);
  rb_define_method(SwigClassFielddefs.klass, "initialize", VALUEFUNC(_wrap_new_fielddefs), -1);
  rb_define_method(SwigClassFielddefs.klass, "clone", VALUEFUNC(_wrap_fielddefs_clone), -1);
  rb_define_method(SwigClassFielddefs.klass, "indexByName", VALUEFUNC(_wrap_fielddefs_indexByName), -1);
  rb_define_method(SwigClassFielddefs.klass, "[]", VALUEFUNC(_wrap_fielddefs___getitem__), -1);
  rb_define_method(SwigClassFielddefs.klass, "checkIndex", VALUEFUNC(_wrap_fielddefs_checkIndex), -1);
  rb_define_method(SwigClassFielddefs.klass, "size", VALUEFUNC(_wrap_fielddefs_size), -1);
  SwigClassFielddefs.mark = 0;
  SwigClassFielddefs.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_fielddefs;
  SwigClassFielddefs.trackObjects = 0;
  
  SwigClassField.klass = rb_define_class_under(mTransactd, "Field", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__field, (void *) &SwigClassField);
  rb_define_alloc_func(SwigClassField.klass, _wrap_field_allocate);
  rb_define_method(SwigClassField.klass, "initialize", VALUEFUNC(_wrap_new_field), -1);
  rb_define_method(SwigClassField.klass, "type", VALUEFUNC(_wrap_field_type), -1);
  rb_define_method(SwigClassField.klass, "len", VALUEFUNC(_wrap_field_len), -1);
  rb_define_method(SwigClassField.klass, "c_str", VALUEFUNC(_wrap_field_c_str), -1);
  rb_define_method(SwigClassField.klass, "a_str", VALUEFUNC(_wrap_field_a_str), -1);
  rb_define_method(SwigClassField.klass, "i", VALUEFUNC(_wrap_field_i), -1);
  rb_define_method(SwigClassField.klass, "i8", VALUEFUNC(_wrap_field_i8), -1);
  rb_define_method(SwigClassField.klass, "i16", VALUEFUNC(_wrap_field_i16), -1);
  rb_define_method(SwigClassField.klass, "i64", VALUEFUNC(_wrap_field_i64), -1);
  rb_define_method(SwigClassField.klass, "f", VALUEFUNC(_wrap_field_f), -1);
  rb_define_method(SwigClassField.klass, "d", VALUEFUNC(_wrap_field_d), -1);
  rb_define_method(SwigClassField.klass, "[]=", VALUEFUNC(_wrap_field___setitem__), -1);
  rb_define_method(SwigClassField.klass, "getBin", VALUEFUNC(_wrap_field_getBin), -1);
  rb_define_method(SwigClassField.klass, "comp", VALUEFUNC(_wrap_field_comp), -1);
  SwigClassField.mark = 0;
  SwigClassField.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_field;
  SwigClassField.trackObjects = 0;
  
  SwigClassRecord.klass = rb_define_class_under(mTransactd, "Record", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldsBase, (void *) &SwigClassRecord);
  rb_undef_alloc_func(SwigClassRecord.klass);
  rb_define_method(SwigClassRecord.klass, "isInvalidRecord", VALUEFUNC(_wrap_Record_isInvalidRecord), -1);
  rb_define_method(SwigClassRecord.klass, "getField", VALUEFUNC(_wrap_Record_getField), -1);
  rb_define_method(SwigClassRecord.klass, "size", VALUEFUNC(_wrap_Record_size), -1);
  rb_define_method(SwigClassRecord.klass, "indexByName", VALUEFUNC(_wrap_Record_indexByName), -1);
  rb_define_method(SwigClassRecord.klass, "fieldDefs", VALUEFUNC(_wrap_Record_fieldDefs), -1);
  rb_define_method(SwigClassRecord.klass, "clear", VALUEFUNC(_wrap_Record_clear), -1);
  rb_define_method(SwigClassRecord.klass, "[]", VALUEFUNC(_wrap_Record___getitem__), -1);
  rb_define_method(SwigClassRecord.klass, "getFieldByIndexRef", VALUEFUNC(_wrap_Record_getFieldByIndexRef), -1);
  rb_define_method(SwigClassRecord.klass, "getFieldByNameRef", VALUEFUNC(_wrap_Record_getFieldByNameRef), -1);
  SwigClassRecord.mark = 0;
  SwigClassRecord.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_fieldsBase;
  SwigClassRecord.trackObjects = 0;
  rb_define_const(mTransactd, "ROW_MEM_BLOCK_RESERVE", SWIG_From_int(static_cast< int >(ROW_MEM_BLOCK_RESERVE)));
    
  SwigClassWritableRecord.klass = rb_define_class_under(mTransactd, "WritableRecord", ((swig_class *) SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldsBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__writableRecord, (void *) &SwigClassWritableRecord);
  rb_undef_alloc_func(SwigClassWritableRecord.klass);
  rb_define_method(SwigClassWritableRecord.klass, "read", VALUEFUNC(_wrap_writableRecord_read), -1);
  rb_define_method(SwigClassWritableRecord.klass, "insert", VALUEFUNC(_wrap_writableRecord_insert), -1);
  rb_define_method(SwigClassWritableRecord.klass, "del", VALUEFUNC(_wrap_writableRecord_del), -1);
  rb_define_method(SwigClassWritableRecord.klass, "update", VALUEFUNC(_wrap_writableRecord_update), -1);
  rb_define_method(SwigClassWritableRecord.klass, "save", VALUEFUNC(_wrap_writableRecord_save), -1);
  rb_define_method(SwigClassWritableRecord.klass, "[]=", VALUEFUNC(_wrap_writableRecord___setitem__), -1);
  SwigClassWritableRecord.mark = 0;
  SwigClassWritableRecord.trackObjects = 0;
  
  SwigClassConnectParams.klass = rb_define_class_under(mTransactd, "ConnectParams", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__connectParams, (void *) &SwigClassConnectParams);
  rb_define_alloc_func(SwigClassConnectParams.klass, _wrap_connectParams_allocate);
  rb_define_method(SwigClassConnectParams.klass, "initialize", VALUEFUNC(_wrap_new_connectParams), -1);
  rb_define_method(SwigClassConnectParams.klass, "setMode", VALUEFUNC(_wrap_connectParams_setMode), -1);
  rb_define_method(SwigClassConnectParams.klass, "setType", VALUEFUNC(_wrap_connectParams_setType), -1);
  rb_define_method(SwigClassConnectParams.klass, "uri", VALUEFUNC(_wrap_connectParams_uri), -1);
  rb_define_method(SwigClassConnectParams.klass, "mode", VALUEFUNC(_wrap_connectParams_mode), -1);
  rb_define_method(SwigClassConnectParams.klass, "type", VALUEFUNC(_wrap_connectParams_type), -1);
  SwigClassConnectParams.mark = 0;
  SwigClassConnectParams.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_connectParams;
  SwigClassConnectParams.trackObjects = 0;
  
  SwigClassFieldNames.klass = rb_define_class_under(mTransactd, "FieldNames", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__fieldNames, (void *) &SwigClassFieldNames);
  rb_define_alloc_func(SwigClassFieldNames.klass, _wrap_fieldNames_allocate);
  rb_define_method(SwigClassFieldNames.klass, "initialize", VALUEFUNC(_wrap_new_fieldNames), -1);
  rb_define_method(SwigClassFieldNames.klass, "reset", VALUEFUNC(_wrap_fieldNames_reset), -1);
  rb_define_method(SwigClassFieldNames.klass, "keyField", VALUEFUNC(_wrap_fieldNames_keyField), -1);
  rb_define_method(SwigClassFieldNames.klass, "count", VALUEFUNC(_wrap_fieldNames_count), -1);
  rb_define_method(SwigClassFieldNames.klass, "[]", VALUEFUNC(_wrap_fieldNames___getitem__), -1);
  rb_define_method(SwigClassFieldNames.klass, "getValue", VALUEFUNC(_wrap_fieldNames_getValue), -1);
  rb_define_method(SwigClassFieldNames.klass, "addValue", VALUEFUNC(_wrap_fieldNames_addValue), -1);
  rb_define_method(SwigClassFieldNames.klass, "addValues", VALUEFUNC(_wrap_fieldNames_addValues), -1);
  SwigClassFieldNames.mark = 0;
  SwigClassFieldNames.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_fieldNames;
  SwigClassFieldNames.trackObjects = 0;
  
  SwigClassSortField.klass = rb_define_class_under(mTransactd, "SortField", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__sortField, (void *) &SwigClassSortField);
  rb_define_alloc_func(SwigClassSortField.klass, _wrap_sortField_allocate);
  rb_define_method(SwigClassSortField.klass, "initialize", VALUEFUNC(_wrap_new_sortField), -1);
  rb_define_method(SwigClassSortField.klass, "name=", VALUEFUNC(_wrap_sortField_name_set), -1);
  rb_define_method(SwigClassSortField.klass, "name", VALUEFUNC(_wrap_sortField_name_get), -1);
  rb_define_method(SwigClassSortField.klass, "asc=", VALUEFUNC(_wrap_sortField_asc_set), -1);
  rb_define_method(SwigClassSortField.klass, "asc", VALUEFUNC(_wrap_sortField_asc_get), -1);
  SwigClassSortField.mark = 0;
  SwigClassSortField.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_sortField;
  SwigClassSortField.trackObjects = 0;
  
  SwigClassSortFields.klass = rb_define_class_under(mTransactd, "SortFields", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__sortFields, (void *) &SwigClassSortFields);
  rb_define_alloc_func(SwigClassSortFields.klass, _wrap_sortFields_allocate);
  rb_define_method(SwigClassSortFields.klass, "initialize", VALUEFUNC(_wrap_new_sortFields), -1);
  rb_define_method(SwigClassSortFields.klass, "add", VALUEFUNC(_wrap_sortFields_add), -1);
  rb_define_method(SwigClassSortFields.klass, "size", VALUEFUNC(_wrap_sortFields_size), -1);
  rb_define_method(SwigClassSortFields.klass, "[]", VALUEFUNC(_wrap_sortFields___getitem__), -1);
  rb_define_method(SwigClassSortFields.klass, "clear", VALUEFUNC(_wrap_sortFields_clear), -1);
  SwigClassSortFields.mark = 0;
  SwigClassSortFields.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_sortFields;
  SwigClassSortFields.trackObjects = 0;
  
  SwigClassRecordsetQuery.klass = rb_define_class_under(mTransactd, "RecordsetQuery", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__recordsetQuery, (void *) &SwigClassRecordsetQuery);
  rb_define_alloc_func(SwigClassRecordsetQuery.klass, _wrap_recordsetQuery_allocate);
  rb_define_method(SwigClassRecordsetQuery.klass, "initialize", VALUEFUNC(_wrap_new_recordsetQuery), -1);
  rb_define_method(SwigClassRecordsetQuery.klass, "reset", VALUEFUNC(_wrap_recordsetQuery_reset), -1);
  rb_define_method(SwigClassRecordsetQuery.klass, "toString", VALUEFUNC(_wrap_recordsetQuery_toString), -1);
  rb_define_method(SwigClassRecordsetQuery.klass, "when", VALUEFUNC(_wrap_recordsetQuery_when), -1);
  rb_define_method(SwigClassRecordsetQuery.klass, "and_", VALUEFUNC(_wrap_recordsetQuery_and_), -1);
  rb_define_method(SwigClassRecordsetQuery.klass, "or_", VALUEFUNC(_wrap_recordsetQuery_or_), -1);
  SwigClassRecordsetQuery.mark = 0;
  SwigClassRecordsetQuery.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_recordsetQuery;
  SwigClassRecordsetQuery.trackObjects = 0;
  
  SwigClassGroupFuncBase.klass = rb_define_class_under(mTransactd, "GroupFuncBase", ((swig_class *) SWIGTYPE_p_bzs__db__protocol__tdap__client__recordsetQuery->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__groupFuncBase, (void *) &SwigClassGroupFuncBase);
  rb_undef_alloc_func(SwigClassGroupFuncBase.klass);
  rb_define_method(SwigClassGroupFuncBase.klass, "targetNames", VALUEFUNC(_wrap_groupFuncBase_targetNames), -1);
  rb_define_method(SwigClassGroupFuncBase.klass, "resultName", VALUEFUNC(_wrap_groupFuncBase_resultName), -1);
  rb_define_method(SwigClassGroupFuncBase.klass, "setResultName", VALUEFUNC(_wrap_groupFuncBase_setResultName), -1);
  rb_define_method(SwigClassGroupFuncBase.klass, "resultKey", VALUEFUNC(_wrap_groupFuncBase_resultKey), -1);
  rb_define_method(SwigClassGroupFuncBase.klass, "reset", VALUEFUNC(_wrap_groupFuncBase_reset), -1);
  rb_define_method(SwigClassGroupFuncBase.klass, "clone", VALUEFUNC(_wrap_groupFuncBase_clone), -1);
  SwigClassGroupFuncBase.mark = 0;
  SwigClassGroupFuncBase.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_groupFuncBase;
  SwigClassGroupFuncBase.trackObjects = 0;
  
  SwigClassGroupQuery.klass = rb_define_class_under(mTransactd, "GroupQuery", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__groupQuery, (void *) &SwigClassGroupQuery);
  rb_define_alloc_func(SwigClassGroupQuery.klass, _wrap_groupQuery_allocate);
  rb_define_method(SwigClassGroupQuery.klass, "initialize", VALUEFUNC(_wrap_new_groupQuery), -1);
  rb_define_method(SwigClassGroupQuery.klass, "reset", VALUEFUNC(_wrap_groupQuery_reset), -1);
  rb_define_method(SwigClassGroupQuery.klass, "addFunction", VALUEFUNC(_wrap_groupQuery_addFunction), -1);
  rb_define_method(SwigClassGroupQuery.klass, "keyField", VALUEFUNC(_wrap_groupQuery_keyField), -1);
  rb_define_method(SwigClassGroupQuery.klass, "getKeyFields", VALUEFUNC(_wrap_groupQuery_getKeyFields), -1);
  rb_define_method(SwigClassGroupQuery.klass, "getFunction", VALUEFUNC(_wrap_groupQuery_getFunction), -1);
  rb_define_method(SwigClassGroupQuery.klass, "functionCount", VALUEFUNC(_wrap_groupQuery_functionCount), -1);
  SwigClassGroupQuery.mark = 0;
  SwigClassGroupQuery.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_groupQuery;
  SwigClassGroupQuery.trackObjects = 0;
  
  SwigClassSum.klass = rb_define_class_under(mTransactd, "Sum", ((swig_class *) SWIGTYPE_p_bzs__db__protocol__tdap__client__groupFuncBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__sum, (void *) &SwigClassSum);
  rb_define_alloc_func(SwigClassSum.klass, _wrap_sum_allocate);
  rb_define_method(SwigClassSum.klass, "initialize", VALUEFUNC(_wrap_new_sum), -1);
  SwigClassSum.mark = 0;
  SwigClassSum.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_sum;
  SwigClassSum.trackObjects = 0;
  
  SwigClassCount.klass = rb_define_class_under(mTransactd, "Count", ((swig_class *) SWIGTYPE_p_bzs__db__protocol__tdap__client__groupFuncBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__count, (void *) &SwigClassCount);
  rb_define_alloc_func(SwigClassCount.klass, _wrap_count_allocate);
  rb_define_method(SwigClassCount.klass, "initialize", VALUEFUNC(_wrap_new_count), -1);
  SwigClassCount.mark = 0;
  SwigClassCount.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_count;
  SwigClassCount.trackObjects = 0;
  
  SwigClassLast.klass = rb_define_class_under(mTransactd, "Last", ((swig_class *) SWIGTYPE_p_bzs__db__protocol__tdap__client__groupFuncBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__last, (void *) &SwigClassLast);
  rb_define_alloc_func(SwigClassLast.klass, _wrap_last_allocate);
  rb_define_method(SwigClassLast.klass, "initialize", VALUEFUNC(_wrap_new_last), -1);
  SwigClassLast.mark = 0;
  SwigClassLast.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_last;
  SwigClassLast.trackObjects = 0;

  SwigClassFirst.klass = rb_define_class_under(mTransactd, "First", ((swig_class *) SWIGTYPE_p_bzs__db__protocol__tdap__client__groupFuncBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__first, (void *) &SwigClassFirst);
  rb_define_alloc_func(SwigClassFirst.klass, _wrap_first_allocate);
  rb_define_method(SwigClassFirst.klass, "initialize", VALUEFUNC(_wrap_new_first), -1);
  SwigClassFirst.mark = 0;
  SwigClassFirst.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_first;
  SwigClassFirst.trackObjects = 0;
  
  SwigClassAvg.klass = rb_define_class_under(mTransactd, "Avg", ((swig_class *) SWIGTYPE_p_bzs__db__protocol__tdap__client__sum->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__avg, (void *) &SwigClassAvg);
  rb_define_alloc_func(SwigClassAvg.klass, _wrap_avg_allocate);
  rb_define_method(SwigClassAvg.klass, "initialize", VALUEFUNC(_wrap_new_avg), -1);
  SwigClassAvg.mark = 0;
  SwigClassAvg.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_avg;
  SwigClassAvg.trackObjects = 0;
  
  SwigClassMin.klass = rb_define_class_under(mTransactd, "Min", ((swig_class *) SWIGTYPE_p_bzs__db__protocol__tdap__client__sum->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__min, (void *) &SwigClassMin);
  rb_define_alloc_func(SwigClassMin.klass, _wrap_min_allocate);
  rb_define_method(SwigClassMin.klass, "initialize", VALUEFUNC(_wrap_new_min), -1);
  SwigClassMin.mark = 0;
  SwigClassMin.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_min;
  SwigClassMin.trackObjects = 0;
  
  SwigClassMax.klass = rb_define_class_under(mTransactd, "Max", ((swig_class *) SWIGTYPE_p_bzs__db__protocol__tdap__client__sum->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__max, (void *) &SwigClassMax);
  rb_define_alloc_func(SwigClassMax.klass, _wrap_max_allocate);
  rb_define_method(SwigClassMax.klass, "initialize", VALUEFUNC(_wrap_new_max), -1);
  SwigClassMax.mark = 0;
  SwigClassMax.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_max;
  SwigClassMax.trackObjects = 0;
  
  SwigClassRecordset.klass = rb_define_class_under(mTransactd, "Recordset", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__recordset, (void *) &SwigClassRecordset);
  rb_define_alloc_func(SwigClassRecordset.klass, _wrap_Recordset_allocate);
  rb_define_method(SwigClassRecordset.klass, "initialize", VALUEFUNC(_wrap_new_Recordset), -1);
  rb_define_method(SwigClassRecordset.klass, "clone", VALUEFUNC(_wrap_Recordset_clone), -1);
  rb_define_method(SwigClassRecordset.klass, "[]", VALUEFUNC(_wrap_Recordset___getitem__), -1);
  rb_define_method(SwigClassRecordset.klass, "first", VALUEFUNC(_wrap_Recordset_first), -1);
  rb_define_method(SwigClassRecordset.klass, "last", VALUEFUNC(_wrap_Recordset_last), -1);
  rb_define_method(SwigClassRecordset.klass, "size", VALUEFUNC(_wrap_Recordset_size), -1);
  rb_define_method(SwigClassRecordset.klass, "count", VALUEFUNC(_wrap_Recordset_count), -1);
  rb_define_method(SwigClassRecordset.klass, "clearRecords", VALUEFUNC(_wrap_Recordset_clearRecords), -1);
  rb_define_method(SwigClassRecordset.klass, "fieldDefs", VALUEFUNC(_wrap_Recordset_fieldDefs), -1);
  rb_define_method(SwigClassRecordset.klass, "clear", VALUEFUNC(_wrap_Recordset_clear), -1);
  rb_define_method(SwigClassRecordset.klass, "top", VALUEFUNC(_wrap_Recordset_top), -1);
  rb_define_method(SwigClassRecordset.klass, "begin", VALUEFUNC(_wrap_Recordset_begin), -1);
  rb_define_method(SwigClassRecordset.klass, "end", VALUEFUNC(_wrap_Recordset_end), -1);
  rb_define_method(SwigClassRecordset.klass, "erase", VALUEFUNC(_wrap_Recordset_erase), -1);
  rb_define_method(SwigClassRecordset.klass, "removeField", VALUEFUNC(_wrap_Recordset_removeField), -1);
  rb_define_method(SwigClassRecordset.klass, "matchBy", VALUEFUNC(_wrap_Recordset_matchBy), -1);
  rb_define_method(SwigClassRecordset.klass, "groupBy", VALUEFUNC(_wrap_Recordset_groupBy), -1);
  rb_define_method(SwigClassRecordset.klass, "orderBy", VALUEFUNC(_wrap_Recordset_orderBy), -1);
  rb_define_method(SwigClassRecordset.klass, "reverse", VALUEFUNC(_wrap_Recordset_reverse), -1);
  rb_define_method(SwigClassRecordset.klass, "appendField", VALUEFUNC(_wrap_Recordset_appendField), -1);
  rb_define_method(SwigClassRecordset.klass, "unionRecordset", VALUEFUNC(_wrap_Recordset_unionRecordset), -1);
  rb_define_method(SwigClassRecordset.klass, "getRow", VALUEFUNC(_wrap_Recordset_getRow), -1);
  SwigClassRecordset.mark = 0;
  SwigClassRecordset.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_recordset;
  SwigClassRecordset.trackObjects = 0;
  
  SwigClassPreparedQuery.klass = rb_define_class_under(mTransactd, "PreparedQuery", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__preparedQuery, (void *) &SwigClassPreparedQuery);
  rb_define_alloc_func(SwigClassPreparedQuery.klass, _wrap_preparedQuery_allocate);
  rb_define_method(SwigClassPreparedQuery.klass, "initialize", VALUEFUNC(_wrap_new_preparedQuery), -1);
  rb_define_method(SwigClassPreparedQuery.klass, "supplyValue", VALUEFUNC(_wrap_preparedQuery_supplyValue), -1);
  rb_define_method(SwigClassPreparedQuery.klass, "addValue", VALUEFUNC(_wrap_preparedQuery_addValue), -1);
  rb_define_method(SwigClassPreparedQuery.klass, "resetAddIndex", VALUEFUNC(_wrap_preparedQuery_resetAddIndex), -1);
  SwigClassPreparedQuery.mark = 0;
  SwigClassPreparedQuery.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_preparedQuery;
  SwigClassPreparedQuery.trackObjects = 0;
  
  SwigClassActiveTable.klass = rb_define_class_under(mTransactd, "ActiveTable", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__activeTable, (void *) &SwigClassActiveTable);
  rb_define_alloc_func(SwigClassActiveTable.klass, _wrap_activeTable_allocate);
  rb_define_method(SwigClassActiveTable.klass, "initialize", VALUEFUNC(_wrap_new_activeTable), -1);
  rb_define_method(SwigClassActiveTable.klass, "alias", VALUEFUNC(_wrap_activeTable_alias), -1);
  rb_define_method(SwigClassActiveTable.klass, "resetAlias", VALUEFUNC(_wrap_activeTable_resetAlias), -1);
  rb_define_method(SwigClassActiveTable.klass, "getWritableRecord", VALUEFUNC(_wrap_activeTable_getWritableRecord), -1);
  rb_define_method(SwigClassActiveTable.klass, "index", VALUEFUNC(_wrap_activeTable_index), -1);
  rb_define_method(SwigClassActiveTable.klass, "option", VALUEFUNC(_wrap_activeTable_option), -1);
  rb_define_method(SwigClassActiveTable.klass, "read", VALUEFUNC(_wrap_activeTable_read), -1);
  rb_define_method(SwigClassActiveTable.klass, "readMore", VALUEFUNC(_wrap_activeTable_readMore), -1);
  rb_define_method(SwigClassActiveTable.klass, "prepare", VALUEFUNC(_wrap_activeTable_prepare), -1);
  rb_define_method(SwigClassActiveTable.klass, "join", VALUEFUNC(_wrap_activeTable_join), -1);
  rb_define_method(SwigClassActiveTable.klass, "outerJoin", VALUEFUNC(_wrap_activeTable_outerJoin), -1);
  rb_define_method(SwigClassActiveTable.klass, "release", VALUEFUNC(_wrap_activeTable_release), -1);
  rb_define_method(SwigClassActiveTable.klass, "table", VALUEFUNC(_wrap_activeTable_table), -1);
  rb_define_method(SwigClassActiveTable.klass, "keyValue", VALUEFUNC(_wrap_activeTable_keyValue), -1);
  SwigClassActiveTable.mark = (void (*)(void *)) mark_activeTable;
  SwigClassActiveTable.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_activeTable;
  SwigClassActiveTable.trackObjects = 1;
  
  SwigClassPooledDbManager.klass = rb_define_class_under(mTransactd, "PooledDbManager", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_bzs__db__protocol__tdap__client__pooledDbManager, (void *) &SwigClassPooledDbManager);
  rb_define_alloc_func(SwigClassPooledDbManager.klass, _wrap_pooledDbManager_allocate);
  rb_define_method(SwigClassPooledDbManager.klass, "initialize", VALUEFUNC(_wrap_new_pooledDbManager), -1);
  rb_define_method(SwigClassPooledDbManager.klass, "use", VALUEFUNC(_wrap_pooledDbManager_use), -1);
  rb_define_method(SwigClassPooledDbManager.klass, "unUse", VALUEFUNC(_wrap_pooledDbManager_unUse), -1);
  rb_define_method(SwigClassPooledDbManager.klass, "reset", VALUEFUNC(_wrap_pooledDbManager_reset), -1);
  rb_define_method(SwigClassPooledDbManager.klass, "db", VALUEFUNC(_wrap_pooledDbManager_db), -1);
  rb_define_method(SwigClassPooledDbManager.klass, "uri", VALUEFUNC(_wrap_pooledDbManager_uri), -1);
  rb_define_method(SwigClassPooledDbManager.klass, "mode", VALUEFUNC(_wrap_pooledDbManager_mode), -1);
  rb_define_method(SwigClassPooledDbManager.klass, "isOpened", VALUEFUNC(_wrap_pooledDbManager_isOpened), -1);
  rb_define_method(SwigClassPooledDbManager.klass, "setOption", VALUEFUNC(_wrap_pooledDbManager_setOption), -1);
  rb_define_method(SwigClassPooledDbManager.klass, "option", VALUEFUNC(_wrap_pooledDbManager_option), -1);
  rb_define_method(SwigClassPooledDbManager.klass, "beginTrn", VALUEFUNC(_wrap_pooledDbManager_beginTrn), -1);
  rb_define_method(SwigClassPooledDbManager.klass, "endTrn", VALUEFUNC(_wrap_pooledDbManager_endTrn), -1);
  rb_define_method(SwigClassPooledDbManager.klass, "abortTrn", VALUEFUNC(_wrap_pooledDbManager_abortTrn), -1);
  rb_define_method(SwigClassPooledDbManager.klass, "enableTrn", VALUEFUNC(_wrap_pooledDbManager_enableTrn), -1);
  rb_define_method(SwigClassPooledDbManager.klass, "beginSnapshot", VALUEFUNC(_wrap_pooledDbManager_beginSnapshot), -1);
  rb_define_method(SwigClassPooledDbManager.klass, "endSnapshot", VALUEFUNC(_wrap_pooledDbManager_endSnapshot), -1);
  rb_define_method(SwigClassPooledDbManager.klass, "stat", VALUEFUNC(_wrap_pooledDbManager_stat), -1);
  rb_define_method(SwigClassPooledDbManager.klass, "clientID", VALUEFUNC(_wrap_pooledDbManager_clientID), -1);
  rb_define_singleton_method(SwigClassPooledDbManager.klass, "setMaxConnections", VALUEFUNC(_wrap_pooledDbManager_setMaxConnections), -1);
  rb_define_singleton_method(SwigClassPooledDbManager.klass, "maxConnections", VALUEFUNC(_wrap_pooledDbManager_maxConnections), -1);
  rb_define_singleton_method(SwigClassPooledDbManager.klass, "reserve", VALUEFUNC(_wrap_pooledDbManager_reserve), -1);
  rb_define_method(SwigClassPooledDbManager.klass, "usingCount", VALUEFUNC(_wrap_pooledDbManager_usingCount), -1);
  rb_define_method(SwigClassPooledDbManager.klass, "table", VALUEFUNC(_wrap_pooledDbManager_table), -1);
  SwigClassPooledDbManager.mark = 0;
  SwigClassPooledDbManager.destroy = (void (*)(void *)) free_bzs_db_protocol_tdap_client_pooledDbManager;
  SwigClassPooledDbManager.trackObjects = 0;
}