DBRE - Руководство разработчика

Язык и кмопиляторы

Отношения классов

DB::Db

namespace DB
{
	class Db;
	typedef std::tr1::shared_ptr DbPtr;
	
	class Db
	{
	public:
		void SetServer(const std::string &value) { server = value; }
		std::string GetServer() { return server; }
		void SetDatabase(const std::string &value) { database = value; }
		std::string GetDatabase() { return database; }
		void SetUser(const std::string &value) { user = value; }
		std::string GetUser() { return user; }
		void SetPassword(const std::string &value) { password = value; }
		std::string GetPassword() { return password; }
		void SetRole(const std::string &value) { role = value; }
		std::string GetRole() { return role; }
		void SetCharset(const std::string &value) { charset = value; }
		std::string GetCharset() { return charset; }
		virtual bool Connected() = 0;
		virtual void Connect() = 0;
		virtual void Disconnect() = 0;
		
		static DbPtr make(const std::string &);
		
		virtual ~Db() {}
		
	protected:
		std::string server, database, user, password, role, charset;
		bool connectdue;
		
		typedef std::tr1::shared_ptr ImplPtr;
		ImplPtr pimpl;
		void MakeImpl();
		Db() {}
	
	public:
		ImplPtr GetImpl() { return pimpl; }
		typedef Tr* (*CreateTrCallback)(DbPtr);
		typedef Query* (*CreateQueryCallback)(DbPtr, TrPtr);
		CreateTrCallback CreateTr;
		CreateQueryCallback CreateQuery;
	};
}

namespace DB
{
	class DbImpl
	{
	public:

#ifdef USE_FB
		IBPP::Database fbdb;
#endif
#ifdef USE_MYSQL
		MYSQL *mysqldb;
#endif
		
		DbImpl() { ++guid; id = guid; }
		int GetId() { return id; }
	private:
		static int guid;
		int id;
	};
}

DB::Tr

namespace DB
{
	class Tr;
	std::tr1::shared_ptr TrPtr;
	
	class Tr
	{
	public:
		virtual void Start() = 0;
		virtual void Commit() = 0;
		virtual void Rollback() = 0;
		
		static TrPtr make(DbPtr);
		virtual ~Tr() {}
		
	protected:
		typedef std::tr1::shared_ptr ImplPtr;
		ImplPtr pimpl;
		void MakeImpl(const int&);
		Tr() {}
		
	public:
		ImplPtr GetImpl() { return pimpl; }
	};
}

using namespace DB;
void CheckDBConnected(DbPtr db)
{
	if (!db->Connected())
	{
		throw EXC::exception("Database instance not connected.");
	}
}

TrPtr Tr::make(DbPtr db)
{
	CheckDBConnected(db);
	
	return TrPtr(db->CreateTr(db));
}

DB::Query

namespace DB
{
	struct Date
	{
		int day, month, year;
	};
	
	struct Time
	{
		int sec, min, hour;
	};
	
	struct DateTime
	{
		int day, month, year, sec, min, hour;;
	};
	
	enum FieldType
	{
		int_,
		float_,
		double_,
		string_,
		date_,
		time_,
		timestamp_,
		blob_
	};

	class Query;
	typedef std::tr1::shared_ptr QueryPtr;
	
	class Query
	{
	public:
		virtual void SetSQL(const std::string &sql) = 0;
		virtual void SetParam(const size_t ord, const int value) = 0; //ord - param order, start from 0
		virtual void SetParam(const size_t ord, const float &value) = 0;
		virtual void SetParam(const size_t ord, const double &value) = 0;
		virtual void SetParam(const size_t ord, const std::string &value) = 0;
		virtual void SetParam(const size_t ord, const Date &value) = 0;
		virtual void SetParam(const size_t ord, const Time &value) = 0;
		virtual void SetParam(const size_t ord, const DateTime &value) = 0;
		virtual void SetBlobParam(const size_t ord, const std::string &value) = 0;
		virtual void ExecSQL() = 0;
		virtual void Open() = 0;
		virtual void Close() = 0;
		virtual size_t GetFieldsCount() = 0;
		virtual std::string GetFieldName(const size_t field_n) = 0;
		virtual FieldType GetFieldType(const size_t field_n) = 0;
		virtual bool Fetch() = 0;
		virtual int GetIntFieldValue(const size_t field_n) = 0;
		virtual float GetFloatFieldValue(const size_t field_n) = 0;
		virtual double GetDoubleFieldValue(const size_t field_n) = 0;
		virtual std::string GetStrFieldValue(const size_t field_n) = 0;
		virtual Date GetDateFieldValue(const size_t field_n) = 0;
		virtual Time GetTimeFieldValue(const size_t field_n) = 0;
		virtual DateTime GetDateTimeFieldValue(const size_t field_n) = 0;
		virtual std::string GetBlobFieldValue(const size_t field_n) = 0;
		
		static QueryPtr make(DbPtr, TrPtr);
		virtual ~Query() {}
	
	protected:
		Query() {}
	};
}

using namespace DB;
QueryPtr Query::make(DbPtr db, TrPtr tr)
{
	CheckDBConnected(db);
	
	if (db->GetImpl()->GetId() != tr->GetImpl()->GetDbId())
	{
		throw EXC::exception("Transaction belongs to another object Db.");
	}
	
	return QueryPtr(db->CreateQuery(db, tr));
}

Как добавить поддержку своей СУБД

namespace
{
        DB::Db* CreateMyDb()
        {
                return new myDb;
        }

        DB::Tr* CreateMyTr(DB::DbPtr db)
        {
                return new myTr(db);
	}
	
	DB::Query* CreateMyQuery(DB::DbPtr db, DB::TrPtr tr)
	{
	        return new myQuery(db, tr);
	}
	
	const bool registered = DB::DbFactory::Instance().RegisterDb("mydb",  &CreateMyDb);
};

myDb::myDb()
{
        MakeImpl();
	
        id_type = "mydb";
	CreateTr = &CreateMyTr;
	CreateQuery = &CreateMyQuery;
}

DF::Df

namespace DF
{
	class Df;
	struct DataBlock;
	typedef boost::shared_ptr DfPtr;
	typedef boost::shared_ptr DataBlockPtr;

	struct DataBlock
	{
	public:
		enum BlockType
		{
			t,
			f,
			d
		};
		BlockType type;
		std::string data;
		DataBlock() {}
	private:
		DataBlock(const DataBlock&) {}
		DataBlock& operator=(const DataBlock&) {}
	};
	
	enum IOMode
	{
		read,
		write
	};

	class Df
	{
	public:
		void WriteBlock(DataBlockPtr db);
		bool Fetch();
		DataBlockPtr ReadBlock();
		void Open(const IOMode &mode);
		void Close();
		
		static DfPtr make(const std::string &filename);
		virtual ~Df() {}
	};
}

PA::Params