query.h

实现内存数据库的源代码

    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 (int8 const& value) { 
	return append(dbQueryElement::qVarInt8, &value);
    }
    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,(int8 const&  value) { return add(value); }
    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


    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 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;

class FASTDB_DLL_ENTRY  dbUserFunctionArgument { 
  public:
    enum dbArgumentType { 
	atInteger, 
	atBoolean, 
	atString, 
	atReal, 
	atReference, 
	atRawBinary
    };	
    dbArgumentType type; 
    union {
	real8       realValue;
	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);
};


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)(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(int8 (*f)(int8), char* name) { 
	bind(name, (void*)f, fInt2Int); 
    }
    dbUserFunction(int8 (*f)(real8), char* name) { 
	bind(name, (void*)f, fReal2Int); 
    }
    dbUserFunction(int8 (*f)(char const*), char* name) { 
	bind(name, (void*)f, fStr2Int); 
    }
    dbUserFunction(real8 (*f)(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)(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(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(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(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