query.h

最新版本！fastdb是高效的内存数据库系统

        return append(dbQueryElement::qVarStringPtr, str);
    }
    dbQuery& add(rectangle const& rect) {
        return append(dbQueryElement::qVarRectangle, &rect);
    }
#ifdef USE_STD_STRING
    dbQuery& add(std::string const& str) { 
        return append(dbQueryElement::qVarStdString, &str);
    }
    dbQuery& operator,(std::string const& str) { return add(str); }
#endif
    dbQuery& add(char** str) { 
        return append(dbQueryElement::qVarStringPtr, str);
    }
    dbQuery& add(int1 const& value) { 
        return append(dbQueryElement::qVarInt1, &value);
    }
    dbQuery& add (int2 const& value) { 
        return append(dbQueryElement::qVarInt2, &value);
    }
    dbQuery& add (int4 const& value) { 
        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(sizeof(long) == 4 ? dbQueryElement::qVarInt4 : dbQueryElement::qVarInt8, &value);
    }
    dbQuery& add (unsigned long const& value) {
        return append(sizeof(long) == 4 ? dbQueryElement::qVarInt4 : dbQueryElement::qVarInt8, &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,(rectangle const& rect) { return add(rect); }

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

#if !defined(_MSC_VER) || _MSC_VER+0 >= 1300
    inline dbQuery& operator,(dbArray<db_int4> const& value) { 
        return append(dbQueryElement::qVarArrayOfInt4, &value);
    }

    inline dbQuery& operator,(dbArray<db_int4>const* const& value) { 
        return append(dbQueryElement::qVarArrayOfInt4Ptr, &value);
    }

    inline dbQuery& operator,(dbArray<db_int8> const& value) { 
        return append(dbQueryElement::qVarArrayOfInt8, &value);
    }

    inline dbQuery& operator,(dbArray<db_int8>const* const& value) { 
        return append(dbQueryElement::qVarArrayOfInt8Ptr, &value);
    }

    inline dbQuery& add(dbArray<db_int4> const& value) { 
        return append(dbQueryElement::qVarArrayOfInt4, &value);
    }

    inline dbQuery& add(dbArray<db_int4>const* const& value) { 
        return append(dbQueryElement::qVarArrayOfInt4Ptr, &value);
    }

    inline dbQuery& add(dbArray<db_int8> const& value) { 
        return append(dbQueryElement::qVarArrayOfInt8, &value);
    }

    inline dbQuery& add(dbArray<db_int8>const* const& value) { 
        return append(dbQueryElement::qVarArrayOfInt8Ptr, &value);
    }
#endif

#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);
    }    
    dbQuery& operator = (rectangle const& expr) {
        return reset().add(expr);
    }    
#endif


    dbQueryElement* getElements() const { 
        return elements;
    }

    bool isEmpty() { 
        return elements == NULL 
            || (elements->next == NULL && elements->type == dbQueryElement::qExpression && *(char*)elements->ptr == 0);
    }

    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, (char*)#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* fname;
    
    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->fname) { 
                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); 
    }

    ~dbUserFunction();
};

END_FASTDB_NAMESPACE

#endif