query.h

一个不错的fastdb使用例子

    return append(dbQueryElement::qVarInt4, &value);
  }

  dbQuery& add
    (db_int8 const& value)
  {
    return append(dbQueryElement::qVarInt8, &value);
  }

  dbQuery& add
    (nat1 const& value)
  {
    return append(dbQueryElement::qVarInt1, &value);
  }

  dbQuery& add
    (nat2 const& value)
  {
    return append(dbQueryElement::qVarInt2, &value);
  }

  dbQuery& add
    (nat4 const& value)
  {
    return append(dbQueryElement::qVarInt4, &value);
  }

  dbQuery& add
    (db_nat8 const& value)
  {
    return append(dbQueryElement::qVarInt8, &value);
  }

#if SIZEOF_LONG != 8
  dbQuery& add
    (long const& value)
  {
    return append(dbQueryElement::qVarInt4, &value);
  }

  dbQuery& add
    (unsigned long const& value)
  {
    return append(dbQueryElement::qVarInt4, &value);
  }

#endif
  dbQuery& add
    (real4 const& value)
  {
    return append(dbQueryElement::qVarReal4, &value);
  }

  dbQuery& add
    (real8 const& value)
  {
    return append(dbQueryElement::qVarReal8, &value);
  }

  dbQuery& add
    (bool const& value)
  {
    return append(dbQueryElement::qVarBool, &value);
  }

  dbQuery& add
    (void const* value)
  {
    return append(dbQueryElement::qVarRawData, value);
  }

  dbQuery& operator,(char const*  value)
  {

    return add
             (value);
  }

  dbQuery& operator,(char const** value)
  {

    return add
             (value);
  }

  dbQuery& operator,(char** value)
  {

    return add
             (value);
  }

  dbQuery& operator,(int1 const&  value)
  {

    return add
             (value);
  }

  dbQuery& operator,(int2 const&  value)
  {

    return add
             (value);
  }

  dbQuery& operator,(int4 const&  value)
  {

    return add
             (value);
  }

  dbQuery& operator,(db_int8 const&  value)
  {

    return add
             (value);
  }

  dbQuery& operator,(nat1 const&  value)
  {

    return add
             (value);
  }

  dbQuery& operator,(nat2 const&  value)
  {

    return add
             (value);
  }

  dbQuery& operator,(nat4 const&  value)
  {

    return add
             (value);
  }

  dbQuery& operator,(db_nat8 const&  value)
  {

    return add
             (value);
  }

#if SIZEOF_LONG != 8
  dbQuery& operator,(long const&  value)
  {

    return add
             (value);
  }

  dbQuery& operator,(unsigned long const&  value)
  {

    return add
             (value);
  }

#endif
  dbQuery& operator,(real4 const& value)
  {

    return add
             (value);
  }

  dbQuery& operator,(real8 const& value)
  {

    return add
             (value);
  }

  dbQuery& operator,(bool const&  value)
  {

    return add
             (value);
  }

  dbQuery& operator,(void const*  value)
  {

    return add
             (value);
  }

  dbQuery& operator,(dbQueryExpression const& expr)
  {

    return add
             (expr);
  }

  dbQuery& operator = (const char* str)
  {
    return reset().append(dbQueryElement::qExpression, str);
  }

#ifndef NO_MEMBER_TEMPLATES

  template<class T>
  dbQuery& operator,(dbReference<T> const& value)
  {
    return append(dbQueryElement::qVarReference, &value, &T::dbDescriptor);
  }

  template<class T>
  inline dbQuery& operator,(dbArray< dbReference<T> > const& value)
  {
    return append(dbQueryElement::qVarArrayOfRef, &value,
                  &T::dbDescriptor);
  }

  template<class T>
  inline dbQuery& operator,(dbArray< dbReference<T> >const* const& value)
  {
    return append(dbQueryElement::qVarArrayOfRefPtr, &value, &T::dbDescriptor);
  }

  template<class T>
  dbQuery& add
    (dbReference<T> const& value)
  {
    return append(dbQueryElement::qVarReference, &value, &T::dbDescriptor);
  }

  template<class T>
  dbQuery& add
    (dbArray< dbReference<T> > const& value)
  {
    return append(dbQueryElement::qVarArrayOfRef, &value,
                  &T::dbDescriptor);
  }

  template<class T>
  dbQuery& add
    (dbArray< dbReference<T> >const* const& value)
  {
    return append(dbQueryElement::qVarArrayOfRefPtr, &value, &T::dbDescriptor);
  }

  template<class T>
  dbQuery& operator = (T const& value)
  {
    return reset().add(value);
  }

#else
  dbQuery& operator = (dbQueryExpression const& expr)
  {
    return reset().add(expr);
  }

#endif


  dbQueryElement* getElements() const
  {
    return elements;
  }

  dbQuery()
  {
    elements = NULL;
    nextElement = &elements;
    operand = false;
    pos = 0;
  }

  dbQuery(char const* str)
  {
    elements = new dbQueryElement(dbQueryElement::qExpression, str);
    nextElement = &elements->next;
    operand = true;
    pos = 0;
  }

  ~dbQuery()
  {
    reset();
  }
};

#ifdef NO_MEMBER_TEMPLATES

template<class T>
inline dbQueryExpression& operator,(dbQueryExpression& expr, dbReference<T> const& value)
{
  return expr.add(dbQueryElement::qVarReference, &value, &T::dbDescriptor);
}

template<class T>
inline dbQueryExpression& operator,(dbQueryExpression& expr, dbArray< dbReference<T> > const& value)
{
  return expr.add(dbQueryElement::qVarArrayOfRef, &value,
                  &T::dbDescriptor);
}

template<class T>
inline dbQueryExpression& operator,(dbQueryExpression& expr, dbArray< dbReference<T> >const* const& value)
{
  return expr.add(dbQueryElement::qVarArrayOfRefPtr, &value, &T::dbDescriptor);
}

template<class T>
inline dbQuery& operator,(dbQuery& query, dbReference<T> const& value)
{
  return query.append(dbQueryElement::qVarReference, &value,
                      &T::dbDescriptor);
}

template<class T>
inline dbQuery& operator,(dbQuery& query,
                          dbArray< dbReference<T> > const& value)
{
  return query.append(dbQueryElement::qVarArrayOfRef, &value,
                      &T::dbDescriptor);
}

template<class T>
inline dbQuery& operator,(dbQuery& query,
                          dbArray< dbReference<T> >const* const& value)
{
  return query.append(dbQueryElement::qVarArrayOfRefPtr, &value,
                      &T::dbDescriptor);
}

template<class T>
inline dbQuery& add
  (dbQuery& query, dbReference<T> const& value)
{
  return query.append(dbQueryElement::qVarReference, &value, &T::dbDescriptor);
}

template<class T>
inline dbQuery& add
  (dbQuery& query, dbArray< dbReference<T> > const& value)
{
  return query.append(dbQueryElement::qVarArrayOfRef, &value,
                      &T::dbDescriptor);
}

template<class T>
inline dbQuery& add
  (dbQuery& query, dbArray< dbReference<T> >const* const& value)
{
  return query.append(dbQueryElement::qVarArrayOfRefPtr, &value, &T::dbDescriptor);
}

#endif

#define USER_FUNC(f) static dbUserFunction f##_descriptor(&f, #f)

struct dbInheritedAttribute;

union  dbSynthesizedAttribute;

/**
 * This class represent argument of user defined funtion. 
 * @see dbUserFunction class.
 */

class FASTDB_DLL_ENTRY  dbUserFunctionArgument
{

public:
  enum dbArgumentType {
    atInteger,
    atBoolean,
    atString,
    atReal,
    atReference,
    atRawBinary
  };
  dbArgumentType type;
  union {
    real8       realValue;
    db_int8     intValue;
    bool        boolValue;
    char const* strValue;
    oid_t       oidValue;
    void*       rawValue;
  } u;

private:

  friend class dbDatabase;
  dbUserFunctionArgument(dbExprNode*             expr,
                         dbInheritedAttribute&   iattr,
                         dbSynthesizedAttribute& sattr,
                         int                     i);
};

/**
 * dbUserFunction class is used to bind user defined functions to the database.
 * This class contains list of all user functions declared by application and provides method
 * for locating function by name and adding new user defined functions.
 * User defined functions can have fro 0 till 3 parameters (of <code>dbUserFunctionArgument</code> type)
 * and should return integer, boolean, real or string value. Type of the function is detected by overloaded 
 * constructors. User defined function descriptor is cerated by <code>USER_FUNC</code> macro.
 */

class FASTDB_DLL_ENTRY dbUserFunction
{

  friend class dbDatabase;

  friend class dbCompiler;

  void* fptr;
  char* name;

  dbUserFunction* next;
  static dbUserFunction* list;

  enum funcType {
    fInt2Bool,
    fReal2Bool,
    fStr2Bool,
    fInt2Int,
    fReal2Int,
    fStr2Int,
    fInt2Real,
    fReal2Real,
    fStr2Real,
    fInt2Str,
    fReal2Str,
    fStr2Str,
    fArg2Bool,
    fArg2Int,
    fArg2Real,
    fArg2Str,
    fArgArg2Bool,
    fArgArg2Int,
    fArgArg2Real,
    fArgArg2Str,
    fArgArgArg2Bool,
    fArgArgArg2Int,
    fArgArgArg2Real,
    fArgArgArg2Str
  };
  int type;

  void bind(char* name, void* f, funcType ftype);

public:

  static dbUserFunction* find(char const* name)
  {
    for (dbUserFunction* func = list; func != NULL; func = func->next)
    {
      if (name == func->name)
      {
        return func;
      }
    }

    return NULL;
  }

  int getParameterType();

  int getNumberOfParameters();

  dbUserFunction(bool (*f)(db_int8), char* name)
  {
    bind(name, (void*)f, fInt2Bool);
  }

  dbUserFunction(bool (*f)(real8), char* name)
  {
    bind(name, (void*)f, fReal2Bool);
  }

  dbUserFunction(bool (*f)(char const*), char* name)
  {
    bind(name, (void*)f, fStr2Bool);
  }

  dbUserFunction(db_int8 (*f)(db_int8), char* name)
  {
    bind(name, (void*)f, fInt2Int);
  }

  dbUserFunction(db_int8 (*f)(real8), char* name)
  {
    bind(name, (void*)f, fReal2Int);
  }

  dbUserFunction(db_int8 (*f)(char const*), char* name)
  {
    bind(name, (void*)f, fStr2Int);
  }

  dbUserFunction(real8 (*f)(db_int8), char* name)
  {
    bind(name, (void*)f, fInt2Real);
  }

  dbUserFunction(real8 (*f)(real8), char* name)
  {
    bind(name, (void*)f, fReal2Real);
  }

  dbUserFunction(real8 (*f)(char const*), char* name)
  {
    bind(name, (void*)f, fStr2Real);
  }

  dbUserFunction(char* (*f)(db_int8), char* name)
  {
    bind(name, (void*)f, fInt2Str);
  }

  dbUserFunction(char* (*f)(real8), char* name)
  {
    bind(name, (void*)f, fReal2Str);
  }

  dbUserFunction(char* (*f)(char const*), char* name)
  {
    bind(name, (void*)f, fStr2Str);
  }


  dbUserFunction(bool (*f)(dbUserFunctionArgument&), char* name)
  {
    bind(name, (void*)f, fArg2Bool);
  }

  dbUserFunction(char* (*f)(dbUserFunctionArgument&), char* name)
  {
    bind(name, (void*)f, fArg2Str);
  }

  dbUserFunction(db_int8 (*f)(dbUserFunctionArgument&), char* name)
  {
    bind(name, (void*)f, fArg2Int);
  }

  dbUserFunction(real8 (*f)(dbUserFunctionArgument&), char* name)
  {
    bind(name, (void*)f, fArg2Real);
  }

  dbUserFunction(bool (*f)(dbUserFunctionArgument&, dbUserFunctionArgument&), char* name)
  {
    bind(name, (void*)f, fArgArg2Bool);
  }

  dbUserFunction(char* (*f)(dbUserFunctionArgument&, dbUserFunctionArgument&), char* name)
  {
    bind(name, (void*)f, fArgArg2Str);
  }

  dbUserFunction(db_int8 (*f)(dbUserFunctionArgument&, dbUserFunctionArgument&), char* name)
  {
    bind(name, (void*)f, fArgArg2Int);
  }

  dbUserFunction(real8 (*f)(dbUserFunctionArgument&, dbUserFunctionArgument&), char* name)
  {
    bind(name, (void*)f, fArgArg2Real);
  }


  dbUserFunction(bool (*f)(dbUserFunctionArgument&, dbUserFunctionArgument&, dbUserFunctionArgument&), char* name)
  {
    bind(name, (void*)f, fArgArgArg2Bool);
  }

  dbUserFunction(char* (*f)(dbUserFunctionArgument&, dbUserFunctionArgument&, dbUserFunctionArgument&), char* name)
  {
    bind(name, (void*)f, fArgArgArg2Str);
  }

  dbUserFunction(db_int8 (*f)(dbUserFunctionArgument&, dbUserFunctionArgument&, dbUserFunctionArgument&), char* name)
  {
    bind(name, (void*)f, fArgArgArg2Int);
  }

  dbUserFunction(real8 (*f)(dbUserFunctionArgument&, dbUserFunctionArgument&, dbUserFunctionArgument&), char* name)
  {
    bind(name, (void*)f, fArgArgArg2Real);
  }
};

#endif