xkdict.h

简单数据库管理系统

// xkDict.h: interface for the xkDict class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_XKDICT_H__94E4F392_C87E_4B9B_8D12_27BDD3188DDE__INCLUDED_)
#define AFX_XKDICT_H__94E4F392_C87E_4B9B_8D12_27BDD3188DDE__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <NEW.H>
#include "Vector.h"
#include "xktype.h"
#include <ASSERT.H>

//概念模式--用于记录数据库中所有表的信息
typedef enum
{
	t_int,          //4 bytes
	t_float,        //4 bytes
	t_string,       //256 bytes
	t_char,         //1 bytes
}xkAttributeType;

class xkAttribute
{
public:
	friend class xkDict;
	xkAttribute()
		:type_((xkAttributeType)0), size_(0), name_(0), isKey_(0), selected_(0)
	{}
	xkAttribute(xkAttributeType type_, char* name_, size_t size_, bool isKey_ = 0, bool selected_ =0)
	{
		this->type_ = type_;
		this->name_ = name_;
		this->size_ = size_;
		this->isKey_ = isKey_;
		this->selected_ = selected_;
	} 
	virtual ~xkAttribute()
	{
		if(name_)
			delete[] name_;
	}
    xkAttributeType GetType() const {return type_;}
	void    SetType(xkAttributeType a) {type_ = a;}
	size_t 	GetSize() const {return size_;}
	void    SetSize(size_t c) {size_ = c;}
	char* 	GetName() const {return name_;}
	void    SetName(char *n)
	{
		if(name_)
			delete[] name_;
		name_ = n;
	}
	bool	IsKey() const {return isKey_;}
	void	SetKey()   { isKey_ = true;}
	bool	GetSelected() const {return selected_;}
	void 	SetSelected(bool b) {selected_ = b;}
	size_t   GetLength() const
	{
			switch(type_) 
			{
				case 0:
					return 4;
				case 1:
					return 4;
				case 2:
					return 256;
				case 3:
					return 1;
				default:
					return 0;
			}
	}
private: 
	xkAttributeType type_;
	size_t  size_;//strlen(name)
	char* 	name_;
	bool   isKey_;//是否是关键字
	bool selected_;//是否被选中
};

class xkTuple
{
public:
	friend class xkDict;
	xkTuple():pAttr_(0), attr_count_(0), size_(0), relationID_(0){}
	xkTuple(xkAttribute *pa_, size_t ac_, size_t s_, size_t id_ = 0)
	{
		pAttr_ = pa_;
		attr_count_ = ac_;
		size_ = s_;
		relationID_ = id_;
	}
	virtual ~xkTuple()
	{ 
		if(pAttr_)
		{
		//	if(attr_count_ > 0)
		//	{
		//		for(size_t i = 0; i < attr_count_; i++)
		//			pAttr_[i].~xkAttribute();
		//	}
		//	::operator delete ((void*)pAttr_);
		//不要把问题想得太复杂了!:)
			delete[] pAttr_;
		}
	}
	xkAttribute* GetAttributes() const {return pAttr_;}
	xkAttribute* GetAttributes() {return pAttr_;}
	void   SetAttributes(xkAttribute * pa_) 
	{
		if(pAttr_)
		{
			if(attr_count_ > 0)
			{
				for(size_t i = 0; i < attr_count_; i++)
					pAttr_[i].~xkAttribute();
			}
			::operator delete ((void*)pAttr_);
		}
		pAttr_ = pa_;
	}

	size_t GetAttrCount() const {return attr_count_;}
	size_t GetAttrCount() {return attr_count_;}
	void   SetAttrCount(size_t c) { attr_count_ = c;}
	size_t GetTupleSize() const {return size_;}
	void   SetTupleSize(size_t c) { size_ = c;}
	size_t GetRelationID() const {return relationID_;}
	void   SetRelationID(size_t c) {relationID_ = c;}
private:
	xkAttribute *pAttr_;
	size_t	attr_count_;
	size_t	size_;
	size_t	relationID_;
};

class xkRelation
{
public:
	friend class xkDict;
	xkRelation()
		:name_(0), tuple_(0) ,tuple_count_(0), size_(0), RID_(0), isOpened_(0)
	{}
	xkRelation(size_t id_, xkTuple * t_, char* n_)
		:RID_(id_), tuple_(t_), name_(n_), tuple_count_(0), size_(0),isOpened_(0)
	{
	}
	virtual ~xkRelation()
	{
		if(tuple_)
		{
	           delete tuple_;
				tuple_ = 0;
		}
		if(name_)
		{
	           delete[] name_;
			   name_ = 0; 
		}
	}
	xkTuple* GetTuple() const {return tuple_;}
	void SetTuple(xkTuple *pt_)
	{
		if(tuple_)
		{
	          delete tuple_;
			  tuple_ = 0;
		}
		tuple_ = pt_;
	}

	size_t 	GetTupleCount() const {return tuple_count_;}
	void	SetTupleCount(size_t c_) {tuple_count_ = c_;}   
	
	unsigned long	GetRelationSize() const {return size_;}
	void    SetRelationSize(unsigned long i) {size_ = i;}

	char* GetRelationName() const {return name_;}
	void  SetRelationName(char* p) 
	{
		if(name_)
		{
	          delete[] name_;
			  name_ = 0; 
		}
		name_ = p;
	}

	size_t GetRelationID() const {return RID_;}
	void   SetRelationID(size_t i) {RID_ = i;}

	bool isOpen() const {return isOpened_;}
	void SetOpened(bool b) {isOpened_ = b;}
	
	bool UpdateTuple(const xkAttribute & attr_, const void* originalval_, const void* value_);
	bool InsertTuple(const void* source_, const size_t size_);
	bool GetSelectedTuple(const xkAttribute & attr_, const void* value_,void* desired_);
	bool DeleteTuple(const xkAttribute & attr_, const void* originalval_);//delete selected tuples
private:
	xkTuple *tuple_;
	size_t  tuple_count_;
	unsigned long	size_;//TOTAL TABLE SIZE
	char *name_;
	size_t RID_;//UNIQUE IDENTIFIER
	bool    isOpened_;//表示该表是否加载到内存中
};

typedef struct __AttriStruct
{
	__AttriStruct()
		:pa_(0), attrcount_(0)
	{
	}
	xkAttribute* pa_;
	size_t     attrcount_;
}xkAttriStruct, *LPxkAttriStruct;

class xkDict
{
public:
	xkDict()
	{
		relationID_ = 0;
	}
	virtual ~xkDict()
	{
		if(relations_.size() != 0)//防止字典没打开又保存导致数据丢失
			SavexkDict();//保存数据字典到外存
		for(size_t i = 0; i < relations_.size(); i++)
			if(relations_[i])
				delete relations_[i];
	}
	size_t GetAllocRID() {return relationID_++;}
	bool CreateRelation(xkAttribute *pa_, size_t ac_, char* tname_);//创建表就是在数据字典中登记该表的各种信息。并不为它分配内存
	bool DropRelation(const size_t RID_);//在数组中找RID_的关系删除。删除表不仅要从数据字典中删除该表项，同时将它所拥有的内存页设为空闲页。
	void LoadxkDict();
	void SavexkDict();
	void GetAllTablename(Vector<char*>&);
	xkRelation* GetRelation(const size_t id_);
	size_t GetRelationCount() {return relations_.size();}
	int		FindTable(const char* tablename_);
	void GetTableAttributename(const size_t id_, Vector<char*>& vec_);
	void GetTableAttribute(const size_t id_, xkAttriStruct& pas_);
private:
	void SetAllocRID(size_t c_){ relationID_ = c_;}
	Vector<xkRelation*> relations_;
	size_t relationID_;
};
size_t CalcTupleSize(xkTuple* t_, size_t ac_);


#endif // !defined(AFX_XKDICT_H__94E4F392_C87E_4B9B_8D12_27BDD3188DDE__INCLUDED_)