Thread portable class Gate portable class Timer class Pool class Terimber 2.0 About C++

Downloads Products & Services Support Clients Open Source About Home / Open source / Terimber 2.0 db.h Go to the documentation of this file. /* * The Software License * ================================================================================= * Copyright (c) 2003-.The Terimber Corporation. All rights reserved. * ================================================================================= * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * The end-user documentation included with the redistribution, if any, * must include the following acknowledgment: * "This product includes software developed by the Terimber Corporation." * ================================================================================= * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE TERIMBER CORPORATION OR ITS CONTRIBUTORS BE LIABLE FOR * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ================================================================================ */ #ifndef _terimber_db_h_ #define _terimber_db_h_ #include "allinc.h" #include "threadpool/thread.h" #include "base/common.h" #include "base/vector.h" #include "base/list.h" #include "base/except.h" #include "db/dbaccess.h" #include "dbvalue.h" BEGIN_TERIMBER_NAMESPACE #pragma pack(4) inline bool is_param_in( db_param_type x ) { switch (x) { case db_param_in: case db_param_in_out: return true; default: return false; } } inline bool is_param_out( db_param_type x ) { switch (x) { case db_param_out: case db_param_in_out: return true; default: return false; } } enum module_state { STATE_OK, STATE_WORKING, STATE_INTERRUPTED }; #define DB_TRY try { #define DB_CATCH return true; } \ catch( exception& x ) { _code = x.get_code(); _error = x.what(); _set_action(ACTION_NONE); _set_state(STATE_OK); } \ catch(...) { _error = "Unknown Exception"; } return false; #define DB_CATCH_DB return true; } \ catch( exception& x ) { _code = x.get_code(); _error = x.what(); } \ catch(...) { _error = "Unknown Exception"; } return false; #define DB_CATCH_EX } catch( exception& x ) { _code = x.get_code(); _error = x.what(); } \ catch(...) { _error = "Unknown Exception"; } const size_t ex_custom = 0; const size_t ex_invalid = 1; const size_t ex_not_init = 2; const size_t ex_already_init = 3; const size_t ex_not_connect = 4; const size_t ex_already_connect = 5; const size_t ex_not_transaction = 6; const size_t ex_already_transaction = 7; const size_t ex_not_sql_open = 8; const size_t ex_already_sql_open = 9; const size_t ex_sql_in_action = 10; const size_t ex_bad_pointer = 11; const size_t ex_invalid_param_count = 12; const size_t ex_timeout = 13; const size_t ex_unknown_server_type = 14; const size_t ex_out_of_bounders = 15; extern exception_table dbMsgTable; class binder { public: ~binder(); binder(); binder(const binder& x); binder& operator=(const binder&x); void set_name( byte_allocator* data_allocator, const char* x ); inline bool set_as_null( db_param_type in_out, dbtypes type ); inline bool set_as_bool( db_param_type in_out, bool val ); inline bool set_as_char( db_param_type in_out, sb1_t val ); inline bool set_as_byte( db_param_type in_out, ub1_t val ); inline bool set_as_short( db_param_type in_out, sb2_t val ); inline bool set_as_word( db_param_type in_out, ub2_t val ); inline bool set_as_long( db_param_type in_out, sb4_t val ); inline bool set_as_dword( db_param_type in_out, ub4_t val ); inline bool set_as_float( db_param_type in_out, float val ); inline bool set_as_double( db_param_type in_out, double val ); inline bool set_as_long64( db_param_type in_out, sb8_t val ); inline bool set_as_dword64( db_param_type in_out, ub8_t val ); inline bool set_as_guid( db_param_type in_out, const guid_t& val ); inline bool set_as_numeric( db_param_type in_out, const char* val, char delimeter ); inline bool set_as_decimal( db_param_type in_out, const char* val, char delimeter ); inline bool set_as_date( db_param_type in_out, ub4_t year, ub1_t month, ub1_t day, ub1_t hour, ub1_t minute, ub1_t second, ub2_t millisec ); inline bool set_as_string( db_param_type in_out, const char* val, size_t len ); inline bool set_as_string_ptr(const char* val ); inline bool set_as_wstring( db_param_type in_out, const wchar_t* val, size_t len ); inline bool set_as_wstring_ptr(const wchar_t* val ); inline bool set_as_binary( db_param_type in_out, const ub1_t* val, size_t len ); inline bool set_as_binary_ptr(const ub1_t* val ); public: void* allocate_value( size_t n ); void deallocate_value(); void clone( binder& out ) const; public: db_param_type _in_out; dbtypes _type; const char* _name; size_t _scale; size_t _precision; size_t _max_length; size_t _bind_type; size_t _native_type; size_t _real_length; mutable void* _bind_buffer; void* _user_code; terimber_db_value _value; bool _responsible; }; typedef vector< binder > params_t; typedef _vector< binder > binders_t; typedef list< binders_t > bulk_params_t; typedef _list< _vector< terimber_db_value > > recordset_list_t; class dbserver_impl : public dbserver, public terimber_thread_employer { typedef list< async_db_notify* > async_db_notify_list_t; class callback_finder { public: callback_finder(const async_db_notify* obj ); inline bool operator()( const async_db_notify* obj ) const { return obj == _obj; } private: const async_db_notify* _obj; }; class callback_fire { public: callback_fire(bool noerrors, size_t ident ); inline void operator()( async_db_notify* obj ) { if (obj) obj->notify_async(_noerrors, _ident); } private: bool _noerrors; size_t _ident; }; protected: enum action { ACTION_NONE = 0, ACTION_OPEN_SQL, ACTION_OPEN_PROC, ACTION_EXEC_SQL, ACTION_EXEC_PROC, ACTION_FETCH, ACTION_OPEN_SQL_ASYNC, ACTION_OPEN_PROC_ASYNC, ACTION_EXEC_SQL_ASYNC, ACTION_EXEC_PROC_ASYNC, ACTION_FETCH_ASYNC }; dbserver_impl( size_t ident ); virtual ~dbserver_impl(); public: virtual size_t get_ident() const; virtual bool is_ready() const; virtual size_t get_code() const; virtual const char* get_error() const; virtual bool connect( bool trusted_connection, const char* connect_string ); virtual bool disconnect(); virtual bool start_transaction(); virtual bool commit(); virtual bool rollback(); virtual bool is_connect() const; virtual bool is_in_transaction() const; virtual bool is_connect_alive(); virtual bool resize_params( size_t size ); virtual size_t get_param_count() const; virtual dbtypes get_param_type( size_t index ) const; virtual db_param_type get_param_in_out(size_t index ) const ; virtual bool get_param_is_null(size_t index ) const; virtual bool get_param_as_bool(size_t index ) const; virtual sb1_t get_param_as_char(size_t index ) const; virtual ub1_t get_param_as_byte(size_t index ) const; virtual sb2_t get_param_as_short(size_t index ) const; virtual ub2_t get_param_as_word(size_t index ) const; virtual sb4_t get_param_as_long(size_t index ) const; virtual ub4_t get_param_as_dword(size_t index ) const; virtual float get_param_as_float(size_t index ) const; virtual double get_param_as_double(size_t index ) const; virtual sb8_t get_param_as_long64(size_t index ) const; virtual ub8_t get_param_as_dword64(size_t index ) const; virtual bool get_param_as_guid(size_t index, guid_t& val ) const; virtual const char* get_param_as_numeric(size_t index, char delimeter ) const; virtual const char* get_param_as_decimal(size_t index, char delimeter ) const; virtual bool get_param_as_date(size_t index, ub4_t& year, ub1_t& month, ub1_t& day, ub1_t& hour, ub1_t& minute, ub1_t& second, ub2_t& millisec, ub1_t& wday, ub2_t& yday ) const; virtual const char* get_param_as_string(size_t index ) const; virtual const wchar_t* get_param_as_wstring(size_t index ) const; virtual const ub1_t* get_param_as_binary(size_t index, size_t& len ) const; virtual const ub1_t* get_param_as_binary_ptr(size_t index ) const; virtual bool set_param_as_null(size_t index, db_param_type in_out, dbtypes type ); virtual bool set_param_as_bool(size_t index, db_param_type in_out, bool val ); virtual bool set_param_as_char(size_t index, db_param_type in_out, sb1_t val ); virtual bool set_param_as_byte(size_t index, db_param_type in_out, ub1_t val ); virtual bool set_param_as_short(size_t index, db_param_type in_out, sb2_t val ); virtual bool set_param_as_word(size_t index, db_param_type in_out, ub2_t val ); virtual bool set_param_as_long(size_t index, db_param_type in_out, sb4_t val ); virtual bool set_param_as_dword(size_t index, db_param_type in_out, ub4_t val ); virtual bool set_param_as_float(size_t index, db_param_type in_out, float val ); virtual bool set_param_as_double(size_t index, db_param_type in_out, double val ); virtual bool set_param_as_long64(size_t index, db_param_type in_out, sb8_t val ); virtual bool set_param_as_dword64(size_t index, db_param_type in_out, ub8_t val ); virtual bool set_param_as_guid(size_t index, db_param_type in_out, const guid_t& val ); virtual bool set_param_as_numeric(size_t index, db_param_type in_out, const char* val, char delimeter ); virtual bool set_param_as_decimal(size_t index, db_param_type in_out, const char* val, char delimeter ); virtual bool set_param_as_date(size_t index, db_param_type in_out, ub4_t year, ub1_t month, ub1_t day, ub1_t hour, ub1_t minute, ub1_t second, ub2_t millisec ); virtual bool set_param_as_string(size_t index, db_param_type in_out, const char* val, size_t len, size_t max_len = 0 ); virtual bool set_param_as_string_ptr(size_t index, const char* val ); virtual bool set_param_as_wstring(size_t index, db_param_type in_out, const wchar_t* val, size_t len, size_t max_len = 0 ); virtual bool set_param_as_wstring_ptr(size_t index, const wchar_t* val ); virtual bool set_param_as_binary(size_t index, db_param_type in_out, const ub1_t* val, size_t len, size_t max_len = 0 ); virtual bool set_param_as_binary_ptr(size_t index, const ub1_t* val ); virtual size_t get_column_count() const; virtual dbtypes get_column_type(size_t index ) const; virtual const char* get_column_name(size_t index ) const; virtual bool get_column_nullable(size_t index ) const; virtual size_t get_column_scale(size_t index ) const; virtual size_t get_column_precision(size_t index ) const; virtual size_t get_column_max_length(size_t index ) const; virtual size_t get_row_count() const; virtual void reset() const; virtual bool next() const; virtual bool prev() const; virtual bool get_value_is_null(size_t index ) const; virtual bool get_value_as_bool(size_t index ) const; virtual sb1_t get_value_as_char(size_t index ) const; virtual ub1_t get_value_as_byte(size_t index ) const; virtual sb2_t get_value_as_short(size_t index ) const; virtual ub2_t get_value_as_word(size_t index ) const; virtual sb4_t get_value_as_long(size_t index ) const; virtual ub4_t get_value_as_dword(size_t index ) const; virtual float get_value_as_float(size_t index ) const; virtual double get_value_as_double(size_t index ) const; virtual sb8_t get_value_as_long64(size_t index ) const; virtual ub8_t get_value_as_dword64(size_t index ) const; virtual bool get_value_as_guid(size_t index, guid_t& val ) const; virtual const char* get_value_as_numeric(size_t index, char delimeter ) const; virtual const char* get_value_as_decimal(size_t index, char delimeter ) const; virtual bool get_value_as_date(size_t index, ub4_t& year, ub1_t& month, ub1_t& day, ub1_t& hour, ub1_t& minute, ub1_t& second, ub2_t& millisec, ub1_t& wday, ub2_t& yday ) const; virtual const char* get_value_as_string(size_t index ) const; virtual const wchar_t* get_value_as_wstring(size_t index ) const; virtual const ub1_t* get_value_as_binary(size_t index, size_t& len ) const; virtual const ub1_t* get_value_as_binary_ptr(size_t index ) const; virtual bool is_open_sql() const; virtual bool open_sql( bool async, const char* sql ); virtual bool exec_sql( bool async, const char* sql ); virtual bool open_proc( bool async, const char* name ); virtual bool exec_proc( bool async, const char* name ); virtual bool fetch_data( bool async, size_t start_row, size_t num_rows, bool forward ); virtual bool close_sql(); virtual bool interrupt_request(); virtual bool set_quote( char quote ); virtual void set_callback( async_db_notify* target ); virtual void remove_callback(async_db_notify* target ); virtual bool param_bulk_store(); virtual bool param_bulk_remove(); virtual bool param_bulk_remove_all(); static inline vt_types convert_types( dbtypes type ); // common part protected: mem_pool_t _manager; byte_allocator* _temp_allocator; mutex _mtx; size_t _ident; size_t _code; string_t _error; // connection part protected: virtual void v_connect( bool trusted_connection, const char* connection_string ) = 0; virtual void v_disconnect() = 0; virtual void v_start_transaction() = 0; virtual void v_commit() = 0; virtual void v_rollback() = 0; virtual bool v_is_connect_alive() = 0; protected: inline bool _is_connect() const { mutex_keeper keeper(_mtx); return _connection; } inline bool _is_in_transaction() const { mutex_keeper keeper(_mtx); return _transaction; } inline bool _is_open_sql() const { mutex_keeper keeper(_mtx); return _is_open; } private: inline void _set_connect() { mutex_keeper keeper(_mtx); _connection = true; } inline void _set_disconnect() { mutex_keeper keeper(_mtx); _connection = false; } inline void _set_in_transaction() { mutex_keeper keeper(_mtx); _transaction = true; } inline void _set_out_transaction() { mutex_keeper keeper(_mtx); _transaction = false; } inline void _set_open() { mutex_keeper keeper(_mtx); _is_open = true; } inline void _set_close() { mutex_keeper keeper(_mtx); _is_open = false; } inline void _set_action( action action_ ) { mutex_keeper keeper(_mtx); _action = action_; } inline void _set_state( module_state state ) { mutex_keeper keeper(_mtx); _state = state; } private: bool _connection; bool _transaction; bool _trusted; string_t _connect_string; // query part protected: void _get_number_params(); void _rebind_params(); void _bind_params(); void _bind_columns(); void _get_columns_info(); protected: virtual void v_before_execute() = 0; virtual void v_after_execute() = 0; virtual void v_execute() = 0; virtual void v_close() = 0; virtual void v_fetch() = 0; virtual void v_replace_quote() = 0; virtual void v_bind_one_param(size_t index ) = 0; virtual void v_before_bind_columns() = 0; virtual void v_bind_one_column(size_t index ) = 0; virtual size_t v_get_number_columns() = 0; virtual void v_convert_one_value(size_t row, size_t col, terimber_db_value& val ) = 0; virtual void v_get_one_column_info(size_t index ) = 0; virtual void v_form_sql_string() = 0; virtual void v_rebind_one_param(size_t index ) = 0; virtual void v_interrupt_async() = 0; virtual dbtypes v_native_type_to_client_type(size_t native_type ) = 0; protected: bool v_has_job( size_t ident, void* user_data ); void v_do_job( size_t ident, void* user_data ); virtual void _notify_async( bool noerrors, size_t ident ); protected: inline action get_action() const { mutex_keeper keeper(_mtx); return _action; } inline module_state get_state() const { mutex_keeper keeper(_mtx); return _state; } private: inline void _check_connect() { if (!_is_connect()) exception::_throw(ex_not_connect, &dbMsgTable); } inline void _check_disconnect() { if (_is_connect()) exception::_throw(ex_already_connect, &dbMsgTable); } inline void _check_in_transaction() { if (!_is_in_transaction()) exception::_throw(ex_not_transaction, &dbMsgTable); } inline void _check_out_transaction() { if (_is_in_transaction()) exception::_throw(ex_already_transaction, &dbMsgTable); } inline void _check_state() { if (get_state() != STATE_OK) exception::_throw(ex_invalid, &dbMsgTable); } inline void _check_open() const { if (!_is_open_sql()) exception::_throw(ex_not_sql_open, &dbMsgTable); } inline void _check_close() const { if (_is_open_sql()) exception::_throw(ex_already_sql_open, &dbMsgTable); } inline void _check_action() const { if (ACTION_NONE != get_action()) exception::_throw(ex_sql_in_action, &dbMsgTable); } bool _is_asynchronous_action() const; void _process_sql( const char* sql ); void _start_thread(); inline terimber_xml_value get_param_as_value(size_t index, vt_types type ) const; inline terimber_xml_value get_value_as_value(size_t index, vt_types type ) const; protected: byte_allocator* _columns_allocator; byte_allocator* _data_allocator; byte_allocator* _bulk_allocator; byte_allocator _sql_allocator; string_t _sql; char _quote; params_t _params; bulk_params_t _bulk_params; binders_t _cols; recordset_list_t _data; size_t _start_row; size_t _requested_rows; size_t _fetched_rows; bool _forward; size_t _bulk_rows; private: volatile module_state _state; volatile action _action; volatile bool _is_open; thread _thread; async_db_notify_list_t _list_callback; private: mutable recordset_list_t::iterator _iter; inline recordset_list_t::iterator get_iter_end() const { return const_cast< recordset_list_t& >(_data).end(); } inline recordset_list_t::iterator get_iter_begin() const { return const_cast< recordset_list_t& >(_data).begin(); } }; // pool support class db_arg { public: db_arg( size_t ident = 0, bool trusted = false, const char* login_string = 0 ); inline bool operator<(const db_arg& x) const { return _trusted != x._trusted ? _trusted < x._trusted : _login_string < x._login_string; } inline bool operator==(const db_arg& x) const { return _trusted == x._trusted && _login_string == x._login_string; } public: size_t _ident; bool _trusted; string_t _login_string; }; class db_entry : public db_arg { public: db_entry( size_t ident = 0, bool trusted = false, const char* login_string = 0 ); public: dbserver* _obj; }; template < class T > class db_creator : public proto_creator< T, db_entry, db_arg > { public: static void activate( db_entry* obj, const db_arg& arg ); static bool find( db_entry* obj, const db_arg& arg ); static void back( db_entry* obj, const db_arg& arg ); static void destroy( db_entry* obj, const db_arg& arg ); static void deactivate( db_entry* obj, const db_arg& arg ); }; #pragma pack() END_TERIMBER_NAMESPACE #endif // _terimber_db_h_

© Copyright Terimber 2003-.