// easy_odbc.h
// defines C++ wrappers for win32 ODBC function calls
// Author: Vijay Mathew Pandyalakal
// 27-MAY-2003

#if !defined _EASY_ODBC_H_ 
#define _EASY_ODBC_H_ 5000

#include <windows.h>
#include <sql.h>
#include <sqlext.h>

#include <string.h>

#include <vector>
using namespace std;

namespace easyodbc {
	// classes decalred here
	class Database;
	class EasyODBCException;
	class ResultSet;
	class ResultSetMetaData;
	struct Column;

	// @class Database
	// wraps a connection with an 
	// ODBC datasource
	class Database {
	private:
		SQLHENV m_hEnv; // environment handle
		SQLHDBC m_hDbc; // database handle
		SQLHSTMT m_hStmt; // statement handle

		int m_nConnTimeOut; // connection timeout
		bool m_bOpened;

		// Error handling 
		SQLSMALLINT m_iRec;
		SQLTCHAR m_cState[6];
		SQLTCHAR m_cMsg[SQL_MAX_MESSAGE_LENGTH];
		SQLINTEGER m_nErr;
		SQLSMALLINT m_nMsg;

	public:
		// cursor types
		static int db_dynamic;
		static int db_static;
		static int db_keysetdriven;
		static int db_forwardonly;

	public:
		Database() {
			this->m_hEnv = NULL;
			this->m_hDbc = NULL;
			this->m_hStmt = NULL;
			this->m_nConnTimeOut = 10;
			this->m_bOpened = false;
			this->m_iRec = 1;
		}
		/** ODBC related functions **/
		bool Open(const char* dsn,char* user = NULL,
					char* pw = NULL); // opens a database connection	
		long Execute(const char* sql);
		ResultSet ExecuteQuery(const char* sql);
		ResultSet ExecuteQuery(const char* sql,int cursor_type,bool scrollable);

		bool Commit();
		bool Rollback();

		void Close() {
			if(m_bOpened) {
				SQLFreeStmt(this->m_hStmt,SQL_CLOSE);
				SQLDisconnect(this->m_hDbc);
				SQLFreeConnect(this->m_hDbc);
				SQLFreeEnv(this->m_hEnv);
				this->m_bOpened = false;
			}
		}
		~Database() { Close(); }

		/**		**/

		void SetTimeout(int n) {
			this->m_nConnTimeOut = n;
		}
		int GetTimeout() { return this->m_nConnTimeOut; }
		bool IsOpened() { return m_bOpened; }

	private:
		void HandleError(const char* type);
	};

	// @struct Column
	// to be used by ResultSetMetaData
	struct Column {
		char title[51];
		int type;
		unsigned int size;
		int decim_size;
		int nullable; // 0: NOT-NULL,1: NULL,2: NOT-KNOWN
	};

	// @class ResultSet
	// handles data returned by a SELECT
	class ResultSet {
	private:
		SQLHSTMT *m_hStmt;	
		SQLUINTEGER  m_lNumRows;
		SQLUSMALLINT   m_nRowStatusArray[10]; 

		// Error handling 
		SQLSMALLINT m_iRec;
		SQLTCHAR m_cState[6];
		SQLTCHAR m_cMsg[SQL_MAX_MESSAGE_LENGTH];
		SQLINTEGER m_nErr;
		SQLSMALLINT m_nMsg;

	public:
		ResultSet(SQLHSTMT *stmt) {
			this->m_hStmt = stmt;		
			this->m_lNumRows = 0;
			SQLRETURN rc = SQLSetStmtAttr(*this->m_hStmt, SQL_ATTR_ROW_STATUS_PTR, 
				m_nRowStatusArray, 0);
			rc = SQLSetStmtAttr(*this->m_hStmt,SQL_ATTR_ROWS_FETCHED_PTR, 
				&m_lNumRows, 0);
			this->m_iRec = 1;
		}
		ResultSetMetaData GetMetaData();
		bool MoveNext();
		bool MovePrevious();
		bool MoveFirst();
		bool MoveLast();
		bool Bind(int col_no,char* buff,int buff_len);

		SQLUINTEGER  GetNumRows() { return m_lNumRows; }

	private:
		void HandleError();
	};

	// @class ResultSetMetaData
	// contains data about a ResultSet
	class ResultSetMetaData {
	private:
		int m_nNumCols; // number of columns in the ResultSet
		vector<Column> m_vctCols;
	public:
		ResultSetMetaData() { m_nNumCols = 0; }
		void SetNumCols(int n) { m_nNumCols = n; }
		int GetColumnCount() { return m_nNumCols; }
		void AddColumn(Column col) { 

			m_vctCols.push_back(col); 
		}
		bool GetColumn(int n,Column *ret) { 
			if(m_vctCols.size() <= 0) return false;
			int i = n;
			i--;
			if(i<0) i = 0;
			*ret = m_vctCols[i]; 
			return true;
		}
		bool GetColumn(const char* title,Column* ret) {
			int sz = m_vctCols.size();
			Column c;
			for(int i=0;i<sz;i++) {
				c = m_vctCols[i];
				if(strcmpi(c.title,title) == 0) {
					*ret = c;
					return true;
				}
			}
			return false;
		}
		void TypeToString(int type,char* ret) {
			try {
				switch(type) {
				case SQL_CHAR:
					strcpy(ret,"CHAR");
					break;
				case SQL_VARCHAR:
					strcpy(ret,"VARCHAR");
					break;
				case SQL_LONGVARCHAR:
					strcpy(ret,"LONG VARCHAR");
					break;
				case SQL_WCHAR:
					strcpy(ret,"UNICODE CHAR");
					break;
				case SQL_WVARCHAR:
					strcpy(ret,"UNICODE VARCHAR");
					break;
				case SQL_WLONGVARCHAR:
					strcpy(ret,"UNICODE LONG VARCHAR");
					break;
				case SQL_DECIMAL:
					strcpy(ret,"DECIMAL");
					break;
				case SQL_NUMERIC:
					strcpy(ret,"NUMERIC");
					break;
				case SQL_SMALLINT:
					strcpy(ret,"SMALLINT");
					break;
				case SQL_INTEGER:
					strcpy(ret,"INTEGER");
					break;
				case SQL_REAL:
					strcpy(ret,"REAL");
					break;
				case SQL_FLOAT:
					strcpy(ret,"FLOAT");
					break;
				case SQL_DOUBLE:
					strcpy(ret,"DOUBLE");
					break;
				case SQL_BIT:
					strcpy(ret,"BIT");
					break;
				case SQL_TINYINT:
					strcpy(ret,"TINYINT");
					break;
				case SQL_BIGINT:
					strcpy(ret,"BIGINT");
					break;
				case SQL_BINARY:
					strcpy(ret,"BINARY");
					break;
				case SQL_VARBINARY:
					strcpy(ret,"VARBINARY");
					break;
				case SQL_LONGVARBINARY:
					strcpy(ret,"LONG VARBINARY");
					break;
				case SQL_TYPE_DATE:
				case SQL_DATE:
					strcpy(ret,"DATE");
					break;
				case SQL_TYPE_TIME:
				case SQL_TIME:
					strcpy(ret,"TIME");
					break;
				case SQL_TYPE_TIMESTAMP:
				case SQL_TIMESTAMP:
					strcpy(ret,"TIMESTAMP");
					break;
				case SQL_INTERVAL_MONTH:
					strcpy(ret,"INTERVAL MONTH");
					break;
				case SQL_INTERVAL_YEAR:
					strcpy(ret,"INTERVAL YEAR");
					break;
				case SQL_INTERVAL_YEAR_TO_MONTH:
					strcpy(ret,"INTERVAL YEAR TO MONTH");
					break;
				case SQL_INTERVAL_DAY:
					strcpy(ret,"INTERVAL DAY");
					break;
				case SQL_INTERVAL_HOUR:
					strcpy(ret,"INTERVAL HOUR");
					break;
				case SQL_INTERVAL_MINUTE:
					strcpy(ret,"INTERVAL MINUTE");
					break;
				case SQL_INTERVAL_SECOND:
					strcpy(ret,"INTERVAL SECOND");
					break;
				case SQL_INTERVAL_DAY_TO_HOUR:
					strcpy(ret,"INTERVAL DAY TO HOUR");
					break;
				case SQL_INTERVAL_DAY_TO_MINUTE:
					strcpy(ret,"INTERVAL DAY TO MINUTE");
					break;
				case SQL_INTERVAL_DAY_TO_SECOND:
					strcpy(ret,"INTERVAL DAY TO SECOND");
					break;
				case SQL_INTERVAL_HOUR_TO_MINUTE:
					strcpy(ret,"INTERVAL HOUR TO MINUTE");
					break;
				case SQL_INTERVAL_HOUR_TO_SECOND:
					strcpy(ret,"INTERVAL HOUR TO SECOND");
					break;
				case SQL_INTERVAL_MINUTE_TO_SECOND:
					strcpy(ret,"INTERVAL MINUTE TO SECOND");
					break;
				case SQL_GUID:
					strcpy(ret,"GUID");
					break;
				default:
					strcpy(ret,"UNKNOWN");
				}
			}catch(...) {
				strcpy(ret,"-1");
			}
		}
		void NullableToString(int nullable,char* ret) {
			try {
				switch(nullable) {
				case 1:
					strcpy(ret,"NULL");
					break;
				case 0:
					strcpy(ret,"NOT NULL");
					break;
				default:
					strcpy(ret,"UNKNOWN");
				}
			}catch(...) {
				strcpy(ret,"-1");
			}
		}
		~ResultSetMetaData() {
			try {
				m_vctCols.clear();
			}catch(...) { }
		}

	};


	// @class EasyODBCException
	// simple exception handling
	class EasyODBCException {
	private:
		char m_strErrMsg[81];
		int m_nErrCode;
	public:
		EasyODBCException(const char* msg,int code) {
			strcpy(this->m_strErrMsg,msg);
			this->m_nErrCode = code;
		}
		void GetMessage(char* buff) {
			strcpy(buff,this->m_strErrMsg);
		}
		int GetCode() {
			return this->m_nErrCode;
		}
	};
}


#endif