transactd 1.0.1

data/source/bzs/db/engine/mysql/database.h

@@ -0,0 +1,465 @@
+#ifndef DATABASE_H
+#define DATABASE_H
+/*=================================================================
+   Copyright (C) 2012 2013 BizStation Corp All rights reserved.
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License
+   as published by the Free Software Foundation; either version 2
+   of the License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software 
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  
+   02111-1307, USA.
+=================================================================*/
+
+
+
+#include <boost/noncopyable.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/scoped_array.hpp>
+#include <boost/function.hpp>
+#include <boost/thread/mutex.hpp>
+#include <vector>
+#include <bzs/env/crosscompile.h>
+#include "fieldAccess.h"
+#include <bzs/db/IBlobBuffer.h>
+
+class THD;
+struct TABLE;
+
+#ifndef MAX_KEYLEN
+	#define MAX_KEYLEN 1023
+#endif
+namespace bzs
+{
+namespace db
+{
+namespace engine
+{
+namespace mysql
+{
+
+
+#define READ_RECORD_GETNEXT 1
+#define READ_RECORD_GETPREV 2
+#define READ_RECORD_STEPNEXT 3
+#define READ_RECORD_STEPPREV 4
+
+#define RF_FIXED_LEN				0
+#define	RF_FIXED_PLUS_VALIABLE_LEN	1
+#define	RF_VALIABLE_LEN				2
+#define	RF_INCLUDE_NIS				4
+
+#define TRN_RECORD_LOCK_SINGLE 0
+#define TRN_RECORD_LOCK_MUILTI 1
+
+
+/** bookmark size
+ *  btreive API is MAX 4 byte
+ */
+#define REF_SIZE_MAX 4
+class table;
+
+extern bool g_safe_share_mode;
+
+/** Control mysql table cahche
+ */
+class tableCacheCounter
+{
+	std::vector<int> m_tables;
+	std::vector<int> m_counts;
+
+	boost::mutex m_mutex;
+	int getHash(const std::string& dbname, const std::string& tbname);
+	size_t getCounterIndex(const std::string& dbname, const std::string& tbname);
+public:
+	tableCacheCounter();
+	void addref(const std::string& dbname, const std::string& tbname);
+	int count(const std::string& dbname, const std::string& tbname);
+	void release(const std::string& dbname, const std::string& tbname);
+
+};
+
+class database : private boost::noncopyable
+{
+	friend class table;
+	friend class smartDbReopen;
+	std::string m_dbname;
+	
+	mutable THD* m_thd;
+	short m_cid;
+	int m_inTransaction;
+	int m_inSnapshot;
+	int m_stat;
+	short m_trnType;
+	
+	std::vector<boost::shared_ptr<table> > m_tables;
+	TABLE* doOpenTable(const std::string& name, short mode);
+	
+	void unUseTable(table* tb);
+public:
+	database(const char* name, short cid);
+	~database();
+	int stat(){return m_stat;};
+	THD* thd()const{return m_thd;};
+	void use() const;
+	short clientID()const{return m_cid;}
+	table* openTable(const std::string& name, short mode);
+	const std::string& name()const{return m_dbname;};
+	table* useTable(int index, enum_sql_command cmd);
+	bool beginTrn(short type);
+	bool commitTrn();
+	bool abortTrn();
+	bool inTransaction()const{return (m_inTransaction!=0);}
+	short transactionType()const{return m_trnType;}
+	bool beginSnapshot();
+	bool endSnapshot();
+	bool inSnapshot()const{return m_inSnapshot!=0;}
+	bool existsTable(const std::string& name);
+	bool existsDatabase();
+	void closeTable(const std::string& name, bool drop);
+	void closeTable(table* tb);
+	void unUseTables(bool rollback);
+	void closeForReopen();
+	void reopen();
+	void cleanTable();
+	const std::vector<boost::shared_ptr<table> >& tables() const {return m_tables;};
+	static tableCacheCounter tableRef;
+};
+
+typedef std::vector<boost::shared_ptr<database> > databases;
+
+class IReadRecordsHandler;
+class bookmarks;
+
+/*
+ *	Since it differs from the key number which a client specifies
+ *   , and an internal key number, it changes.
+ *  As for the key name, it is a premise that it is keyNN. 
+ *  NN is  client specifies key number.
+ */
+class keynumConvert
+{
+	KEY* m_key;
+	int m_keyCount;
+	char m_keyNum;
+	char m_convNum;
+	
+public:
+	keynumConvert(KEY* key, int count):m_key(key),m_keyCount(count),m_keyNum(-1){}
+	void setKey(KEY* key){m_key=key;};
+	char keyNumByMakeOrder(char num)
+	{
+		if (m_keyNum==num)
+			return m_convNum;
+		
+		m_keyNum = num;
+		for (int i=0;i<m_keyCount;i++)
+			if (strstr(m_key[i].name, "key") && m_key[i].name[3] == num + '0')
+				return m_convNum = i;
+		return m_convNum = num;//If not found, a value as it is is returned.
+	}
+};
+
+class table : private boost::noncopyable
+{
+	friend class database;
+	
+
+	TABLE*	m_table;
+	std::string m_name;
+	const short m_mode;
+	int m_recordFormatType;
+	int m_id;
+	unsigned short m_nullFields;
+	uint m_recordLenCl;
+	uint m_lastVarLenBytes;
+
+	database& m_db;
+	table(TABLE* table, database& db, const std::string& name, short mode, int id);
+	char m_keyNum;
+	mutable boost::scoped_array<unsigned char> m_keybuf;
+	mutable boost::scoped_array<unsigned char> m_nonNccKeybuf;
+	bool m_nonNcc;
+	int m_stat;
+	bool m_validCursor;
+	bool m_cursor;
+	bool m_locked;
+	bool m_changed;
+	bool m_nounlock;
+	bool m_bulkInserting;
+	int m_percentResult;
+	boost::shared_ptr<bookmarks> m_bms;
+	String m_str;
+	keynumConvert m_keyconv;
+	IblobBuffer*  m_blobBuffer;
+	std::vector<Field*> m_nonKeySegNullFields;
+	
+	void moveKey(boost::function<int()> func);
+	void readRecords(IReadRecordsHandler* handler, bool includeCurrent, int type);
+	
+	bool keyCheckForPercent();
+	inline bool keynumCheck(char num);
+	void preBuildPercent(uchar* first, uchar* last);
+	inline key_part_map keymap(){return (1U << m_table->key_info[m_keyNum].user_defined_key_parts) -1;} 
+	void seekPos(const uchar* pos);
+	int setKeyNullFlags();
+	void setFiledNullFlags();
+	
+	bookmarks* bms();
+	int percentage(uchar* first, uchar* last, uchar* cur);
+	
+	bool setNonKey(bool scan=false);
+	void fillNull(uchar* ptr, int size);
+	inline void* keybuf()const{return &m_keybuf[0];}
+	inline uint  keylen()const{return m_table->key_info[m_keyNum].key_length;};
+	void setKeyValues(const uchar* ptr, int size);
+	void setBlobFieldPointer(const bzs::db::blobHeader* hd);
+	inline void unlockRow();
+
+#ifdef USE_HANDLERSOCKET
+	std::vector<int> m_useFields;
+	void checkFiledIndex(int index);
+	int fieldIndexByName(const char* name)const;
+	void addUseField(int index){m_useFields.push_back(index);};
+
+public:
+	std::vector<int>& useFields(){return m_useFields;};
+	void setUseFieldList(const std::string& csv);
+	void setKeyValues(const std::vector<std::string>& values
+							, int keypart, const std::string* inValue=NULL);
+	void setValue(int index, const std::string& v, int type);
+	void setUseValues(const std::vector<std::string>& values, int type);
+	
+	#define UPDATE_REPLACE	0
+	#define UPDATE_INC		1
+	#define UPDATE_DEC		2
+
+#endif
+public:
+	static bool noKeybufResult;
+
+	~table();
+
+	inline void setBlobBuffer(IblobBuffer*  blobBuffer){m_blobBuffer = blobBuffer;};
+	inline IblobBuffer* blobBuffer(IblobBuffer*  blobBuffer){return m_blobBuffer;};
+
+	inline short mode()const {return m_mode;};
+	inline bool islocked(){return m_locked;}
+	inline void setLocked(bool value){m_locked = value;}
+	inline bool isChanged(){return m_changed;}
+	int id(){return m_id;};
+	inline void unUse(){m_db.unUseTable(this);}
+	void resetTransctionInfo(THD* thd);
+	void resetInternalTable(TABLE* table);
+	inline const std::string& name()const{return m_name;};
+	inline int recordFormatType()const {return m_recordFormatType;};
+	inline int blobFields()const {return m_table->s->blob_fields;};
+
+	/** if call close then table is deleten.
+	 */
+	inline void close()
+	{
+		m_table->file->ha_index_or_rnd_end();
+		m_db.closeTable(this);
+	}
+	inline char keyNum()const {return m_keyNum;}
+	
+	/*
+	 *	Since it differs from the key number which a client specifies
+	 *   , and an internal key number, it changes.
+	 *  As for the key name, it is a premise that it is keyNN. 
+	 *  NN is  client specifies key number.
+	 */
+	inline char keyNumByMakeOrder(char num)
+	{
+		return m_keyconv.keyNumByMakeOrder(num);
+	}
+	
+	bool setKeyNum(char num);
+	inline void setKeyNum(const char* name){setKeyNum(keynumByName(name));};
+	bool isNisKey(char num)const;
+	void seekKey(enum ha_rkey_function find_flag);
+	void getNextSame();
+	void getLast();
+	void getFirst();
+	void getNext();
+	void getPrev();
+	void getByPercentage(unsigned short per);
+	void calcPercentage();
+	inline int* percentResult(){return &m_percentResult;};
+
+	void stepLast();
+	void stepFirst();
+	void stepNext();
+	void stepPrev();
+	void movePos(const uchar* pos, char keyNum, bool sureRawValue=false);
+
+	inline void getNextExt(IReadRecordsHandler* handler, bool includeCurrent)
+	{
+		readRecords(handler, includeCurrent, READ_RECORD_GETNEXT);
+	}
+
+	inline void getPrevExt(IReadRecordsHandler* handler, bool includeCurrent)
+	{
+		readRecords(handler, includeCurrent, READ_RECORD_GETPREV);
+	}
+
+	inline void stepNextExt(IReadRecordsHandler* handler, bool includeCurrent)
+	{
+		readRecords(handler, includeCurrent, READ_RECORD_GETNEXT);
+	}
+
+	inline void stepPrevExt(IReadRecordsHandler* handler, bool includeCurrent)
+	{
+		readRecords(handler, includeCurrent, READ_RECORD_GETPREV);
+	}
+
+	void clearBuffer();
+	void clearKeybuf(){memset(&m_keybuf[0], 0x00, MAX_KEYLEN);};
+	
+	__int64 insert(bool ncc);
+	void update(bool ncc);
+	void updateDirectkey();
+	void beginUpdate(char keyNum);
+	void del();
+	void beginDel();
+	
+	int keynumByName(const char* name)const;
+	int stat(){return m_stat;};
+	void setKeyValuesPacked(const uchar* ptr, int size);
+	void* record()const;
+	
+	uint  keyPackCopy(uchar* ptr);
+	
+	void setRecord(void* ptr, unsigned short size, int offset=0);
+	void setRecordFromPacked(const uchar* packedPtr, uint size, const bzs::db::blobHeader* hd);
+	uint recordPackCopy(char* buf, uint maxsize=0);
+
+	uint fieldSizeByte(int fieldNum){return var_bytes_if(m_table->field[fieldNum]);}
+	unsigned short fieldDataLen(int fieldNum)const;
+	
+	inline unsigned short fieldLen(int fieldNum)const
+	{
+		return m_table->field[fieldNum]->pack_length();
+	}
+
+	inline  unsigned short filedVarLenBytes(int fieldNum)const {return var_bytes_if(m_table->field[fieldNum]);}
+	inline char* fieldPos(int fieldNum)const{return (char*)m_table->field[fieldNum]->ptr;};
+	inline enum enum_field_types fieldType(int fieldNum) const {return m_table->field[fieldNum]->type();};
+	inline unsigned int  fieldFlags(int fieldNum) const {return m_table->field[fieldNum]->flags;};
+	inline unsigned short fields()const{return m_table->s->fields;};
+	inline unsigned int nisFields()const {return m_nullFields;}
+	inline const char* fieldName(int fieldNum)const {return m_table->s->field[fieldNum]->field_name;};
+	inline const CHARSET_INFO& fieldCharset(int fieldNum)const {return *m_table->s->field[fieldNum]->charset();}
+	inline uint lastVarFiledNum()const{return m_table->s->fields-1-nisFields();}
+	inline const Field* lastVarFiled ()const{return m_table->s->field[lastVarFiledNum()];}
+	unsigned short lastVarLenBytes()const{return m_lastVarLenBytes;};
+	unsigned short lastVarFieldPos()const;
+	inline unsigned short lastVarFieldDataLen()const{return fieldDataLen(lastVarFiledNum());}
+	/*number of key.*/
+	inline unsigned short keys()const{return m_table->s->keys;};
+	inline const KEY&  keyDef(char keyNum)const{return m_table->key_info[keyNum];};
+	inline Field*  field(int fieldNum)const{return m_table->field[fieldNum];};
+	inline char  primarykey()const{return m_table->s->primary_key;};
+	/** is this view. not table*/
+	inline bool isView()const{return m_table->s->is_view;}
+
+	/** char set of this table.*/
+	inline const CHARSET_INFO& charset()const {return *m_table->s->table_charset;}
+	
+	ha_rows recordCount(bool estimate);
+	inline ulong recordLen()const{return m_table->s->reclength;}
+
+	/** record length for client side. exclude null flag segmnet 
+	 *  ,lastVarLenBytes and NIS fields from recordLen()
+	 */
+	inline uint recordLenCl()const{return m_recordLenCl;}
+	inline uint nullBytes()const{return (uint)(m_table->s->null_fields>0);}
+	/** bookmark length*/
+	uint posPtrLen()const;
+
+	/** bookmark */
+	const uchar* position(bool raw=false);
+	const char* keyName(char keyNum);
+	inline void errorMessage(String *buf){m_table->file->get_error_message(m_stat, buf);}
+	
+	void startBulkInsert(ha_rows rows);
+	void endBulkInsert();
+
+	inline TABLE* internalTable(){return m_table;} ///for debuglog
+	const char* valStr(int index, int &size);			///for debuglog
+	
+	/** add blob field list.
+	 *  @param fieldNum field index if it is -1 then all fields of cureent row;
+	 *  @return field count of listed.
+	 */
+	uint makeBlobFieldList(int fieldNum);
+	
+	inline void addBlobBuffer(int fieldNum)
+	{
+		Field* fd = m_table->field[fieldNum];
+		m_blobBuffer->addBlob(blob_len(fd), fd->field_index, blobBodyPtr(fd));
+	}
+
+	inline void setBlobFieldCount(uint num){m_blobBuffer->setFieldCount(num);};
+
+};
+
+//smart wrapper for exception
+class smartBulkInsert
+{
+	table* m_tb;
+public:
+	smartBulkInsert(table* tb, ha_rows rows):m_tb(tb)
+	{
+		m_tb->startBulkInsert(rows);
+	}
+
+	~smartBulkInsert()
+	{
+		m_tb->endBulkInsert();
+	}
+};
+
+class smartTransction
+{
+	database* m_db;
+	short m_type;
+public:
+	smartTransction(database* db, short type=TRN_RECORD_LOCK_SINGLE):m_db(db)
+	{
+		m_db->beginTrn(type);	
+	}
+
+	void end()
+	{
+		m_db->commitTrn();
+		m_db=NULL;
+	}
+
+	~smartTransction()
+	{
+		if (m_db)
+			m_db->abortTrn();
+	}
+
+};
+
+#define BUILINSERT_SCOPE
+
+}//namespace mysql
+}//namespace engine
+}//namespace db
+}//namespace bzs
+
+#endif //DATABASE_H
+
+