24 #include <boost/make_shared.hpp>
25 #include <boost/scoped_ptr.hpp>
26 #include <boost/thread/condition_variable.hpp>
27 #include <boost/thread/mutex.hpp>
28 #include <boost/thread/shared_mutex.hpp>
29 #include <boost/thread/thread.hpp>
33 #include <sys/resource.h>
36 #include <drizzled/charset.h>
37 #include <drizzled/base.h>
38 #include <drizzled/error.h>
39 #include <drizzled/lock.h>
40 #include <drizzled/pthread_globals.h>
41 #include <drizzled/sql_error.h>
42 #include <drizzled/sql_locale.h>
44 #include <drizzled/util/find_ptr.h>
45 #include <drizzled/util/string.h>
46 #include <drizzled/type/time.h>
50 extern uint32_t server_id;
51 extern std::string server_uuid;
53 #define TC_HEURISTIC_RECOVER_COMMIT 1
54 #define TC_HEURISTIC_RECOVER_ROLLBACK 2
55 extern uint32_t tc_heuristic_recover;
57 extern DRIZZLED_API struct drizzle_system_variables global_system_variables;
79 class Open_tables_state;
86 boost::scoped_ptr<impl_c> impl_;
88 typedef boost::shared_ptr<Session> shared_ptr;
90 static shared_ptr make_shared(
plugin::Client *client, boost::shared_ptr<catalog::Instance> instance_arg)
93 return boost::make_shared<Session>(client, instance_arg);
107 enum_mark_columns mark_used_columns;
120 uint64_t getXaId()
const
125 void setXaId(uint64_t in_xa_id)
131 Diagnostics_area& main_da();
132 const LEX& lex()
const;
134 enum_sql_command getSqlCommand()
const;
140 boost::shared_ptr<std::string> query;
146 void resetQueryString();
147 const boost::shared_ptr<session::State>& state();
154 const char* getQueryStringCopy(
size_t &length)
156 QueryString tmp_string(getQueryString());
162 length= tmp_string->length();
163 return mem.strdup(*tmp_string);
166 util::string::ptr schema()
const;
187 typedef boost::unordered_map<std::string, user_var_entry*, util::insensitive_hash, util::insensitive_equal_to> UserVars;
190 typedef std::pair< UserVars::iterator, UserVars::iterator > UserVarsRange;
194 const UserVars &getUserVariables()
const
200 enum_tx_isolation getTxIsolation()
const;
213 identifier::user::ptr user()
const
218 void setUser(identifier::user::mptr arg)
223 int32_t getScoreboardIndex()
const
225 return scoreboard_index;
228 void setScoreboardIndex(int32_t in_scoreboard_index)
230 scoreboard_index= in_scoreboard_index;
233 bool isOriginatingServerUUIDSet()
const
235 return originating_server_uuid_set;
238 void setOriginatingServerUUID(std::string in_originating_server_uuid)
240 originating_server_uuid= in_originating_server_uuid;
241 originating_server_uuid_set=
true;
244 const std::string &getOriginatingServerUUID()
const
246 return originating_server_uuid;
249 void setOriginatingCommitID(uint64_t in_originating_commit_id)
251 originating_commit_id= in_originating_commit_id;
254 uint64_t getOriginatingCommitID()
const
256 return originating_commit_id;
262 bool isViewable(
const identifier::User&)
const;
273 const char *where()
const
278 void setWhere(
const char *arg)
290 boost::thread::id boost_thread_id;
292 boost::this_thread::disable_interruption *interrupt;
294 internal::st_my_thread_var *mysys_var;
297 thread_ptr &getThread()
302 void pushInterrupt(boost::this_thread::disable_interruption *interrupt_arg)
304 interrupt= interrupt_arg;
307 boost::this_thread::disable_interruption &getThreadInterupt()
313 internal::st_my_thread_var *getThreadVar()
324 thr_lock_type update_lock_default;
332 std::vector<Ha_data> ha_data;
342 query_id_t warn_query_id;
357 void setConcurrentExecute(
bool arg)
359 concurrent_execute_allowed= arg;
362 bool isConcurrentExecuteAllowed()
const
364 return concurrent_execute_allowed;
403 int64_t rowCount()
const
405 return row_count_func;
440 uint32_t warn_count[(uint32_t) DRIZZLE_ERROR::WARN_LEVEL_END];
441 uint32_t total_warn_count;
449 session_id_t thread_id;
451 enum global_read_lock_t
454 GOT_GLOBAL_READ_LOCK= 1,
455 MADE_GLOBAL_READ_LOCK_BLOCK_COMMIT= 2
458 global_read_lock_t _global_read_lock;
462 global_read_lock_t isGlobalReadLock()
const
464 return _global_read_lock;
467 void setGlobalReadLock(global_read_lock_t arg)
469 _global_read_lock= arg;
472 DrizzleLock *lockTables(Table **tables, uint32_t count, uint32_t flags);
473 bool lockGlobalReadLock();
474 bool lock_table_names(TableList *table_list);
475 bool lock_table_names_exclusively(TableList *table_list);
476 bool makeGlobalReadLockBlockCommit();
477 bool abortLockForThread(Table *table);
478 bool wait_if_global_read_lock(
bool abort_on_refresh,
bool is_not_commit);
479 int lock_table_name(TableList *table_list);
480 void abortLock(Table *table);
481 void removeLock(Table *table);
482 void unlockReadTables(DrizzleLock *sql_lock);
483 void unlockSomeTables(Table **table, uint32_t count);
484 void unlockTables(DrizzleLock *sql_lock);
485 void startWaitingGlobalReadLock();
486 void unlockGlobalReadLock();
489 int unlock_external(Table **table, uint32_t count);
490 int lock_external(Table **tables, uint32_t count);
491 bool wait_for_locked_table_names(TableList *table_list);
492 DrizzleLock *get_lock_data(Table **table_ptr, uint32_t count,
493 bool should_lock, Table **write_lock_used);
496 uint32_t server_status;
497 uint32_t open_options;
500 enum_tx_isolation session_tx_isolation;
501 enum_check_fields count_cuted_fields;
512 killed_state_t
volatile _killed;
516 void setKilled(killed_state_t arg)
521 killed_state_t getKilled()
const
526 volatile killed_state_t *getKilledPtr()
531 bool is_admin_connection;
569 bool doing_tablespace_operation()
const
571 return tablespace_op;
574 void setDoingTablespaceOperation(
bool doing)
576 tablespace_op= doing;
584 uint32_t uint32_t_value;
585 int32_t int32_t_value;
586 uint64_t uint64_t_value;
613 inline const char* get_proc_info()
const
621 query_id= in_query_id;
634 warn_query_id= in_query_id;
640 return warn_query_id;
656 inline std::string &getServerUUID()
const
661 inline void record_first_successful_insert_id_in_cur_stmt(uint64_t id_arg)
663 if (first_successful_insert_id_in_cur_stmt == 0)
664 first_successful_insert_id_in_cur_stmt= id_arg;
666 inline uint64_t read_first_successful_insert_id_in_prev_stmt()
const
668 return first_successful_insert_id_in_prev_stmt;
671 Session(plugin::Client*, boost::shared_ptr<catalog::Instance>);
687 void cleanup_after_query();
689 void awake(Session::killed_state_t state_to_set);
697 void prepareForQueries();
713 bool executeStatement();
731 void readAndStoreQuery(
str_ref);
741 bool endTransaction(
enum enum_mysql_completiontype completion);
742 bool endActiveTransaction();
743 bool startTransaction(start_transaction_option_t opt= START_TRANS_NO_OPTIONS);
744 void markTransactionForRollback(
bool all);
753 static bool schedule(
const Session::shared_ptr&);
754 static void unlink(session_id_t&);
755 static void unlink(
const Session::shared_ptr&);
762 const char* enter_cond(boost::condition_variable_any &cond, boost::mutex &mutex,
const char* msg);
763 void exit_cond(
const char* old_msg);
765 uint64_t found_rows()
const
767 return limit_found_rows;
773 return server_status & SERVER_STATUS_IN_TRANS;
780 void clear_error(
bool full=
false);
781 void clearDiagnostics();
782 bool is_error()
const;
784 static const charset_info_st *charset() {
return default_charset_info; }
794 void end_statement();
795 inline int killed_errno()
const
797 killed_state_t killed_val;
798 return (killed_val= _killed) != KILL_BAD_DATA ? killed_val : 0;
800 void send_kill_message()
const;
802 inline bool abortOnWarning()
804 return abort_on_warning;
807 inline void setAbortOnWarning(
bool arg)
809 abort_on_warning= arg;
812 void setAbort(
bool arg);
814 void set_status_var_init();
832 void set_schema(
const std::string&);
856 void reset_for_next_command();
866 void disconnect(
enum error_t errcode= EE_OK);
880 bool checkUser(
const std::string &passwd,
const std::string &db);
889 return transaction_message;
898 return statement_message;
917 transaction_message= in_message;
928 statement_message= in_message;
939 resultset= in_message;
953 return session_event_observers;
956 void setSessionObservers(plugin::EventObserverList *observers)
958 session_event_observers= observers;
961 plugin::EventObserverList* getSchemaObservers(
const std::string& schema);
962 plugin::EventObserverList* setSchemaObservers(
const std::string& schema, plugin::EventObserverList*);
965 void my_ok(ha_rows affected_rows= 0, ha_rows found_rows_arg= 0, uint64_t passed_id= 0,
const char *message= NULL);
967 void add_item_to_list(Item *item);
968 void add_value_to_list(Item *value);
969 void add_order_to_list(Item *item,
bool asc);
970 void add_group_to_list(Item *item,
bool asc);
972 void refresh_status();
973 user_var_entry* getVariable(
str_ref name,
bool create_if_not_exists);
974 void setVariable(
const std::string& name,
const std::string& value);
980 void close_thread_tables();
981 void close_old_data_files(
bool morph_locks=
false,
bool send_refresh=
false);
982 void close_data_files_and_morph_locks(
const identifier::Table&);
990 void close_tables_for_reopen(TableList **tables);
1007 bool openTablesLock(TableList*);
1008 Table *open_temporary_table(
const identifier::Table &identifier,
bool link_in_list=
true);
1010 int open_tables_from_list(TableList **start, uint32_t *counter, uint32_t flags= 0);
1012 Table *openTableLock(TableList *table_list, thr_lock_type lock_type);
1013 Table *openTable(TableList *table_list,
bool *refresh, uint32_t flags= 0);
1015 void unlink_open_table(Table *find);
1016 void drop_open_table(Table *table,
const identifier::Table &identifier);
1017 void close_cached_table(Table *table);
1020 table::Placeholder& table_cache_insert_placeholder(
const identifier::Table&);
1021 Table* lock_table_name_if_not_cached(
const identifier::Table&);
1023 session::TableMessages &getMessageCache();
1026 bool reopen_tables();
1027 bool close_cached_tables(TableList *tables,
bool wait_for_refresh,
bool wait_for_placeholders);
1029 void wait_for_condition(boost::mutex &mutex, boost::condition_variable_any &cond);
1030 int setup_conds(TableList *leaves, COND **conds);
1031 int lock_tables(TableList *tables, uint32_t count,
bool *need_reopen);
1034 T* getProperty(
const std::string& name)
1036 return static_cast<T*
>(getProperty0(name));
1040 T setProperty(
const std::string& name, T value)
1042 setProperty0(name, value);
1054 plugin::StorageEngine *getDefaultStorageEngine();
1055 void get_xid(DrizzleXid *xid)
const;
1057 table::Singular& getInstanceTable();
1058 table::Singular& getInstanceTable(std::list<CreateField>&);
1060 void setUsage(
bool arg)
1065 const rusage &getUsage()
1070 const catalog::Instance& catalog()
const
1075 catalog::Instance& catalog()
1080 bool arg_of_last_insert_id_function;
1087 return not getrusage(RUSAGE_THREAD, &usage);
1090 boost::shared_ptr<catalog::Instance> _catalog;
1100 const char *proc_info;
1101 bool abort_on_warning;
1102 bool concurrent_execute_allowed;
1106 identifier::user::mptr security_ctx;
1107 int32_t scoreboard_index;
1108 bool originating_server_uuid_set;
1109 std::string originating_server_uuid;
1110 uint64_t originating_commit_id;
1114 #define ESCAPE_CHARS "ntrb0ZN" // keep synchronous with READ_INFO::unescape
1118 enum sql_command_flag_bits
1120 CF_BIT_CHANGES_DATA,
1121 CF_BIT_HAS_ROW_COUNT,
1122 CF_BIT_STATUS_COMMAND,
1123 CF_BIT_SHOW_TABLE_COMMAND,
1124 CF_BIT_WRITE_LOGS_COMMAND,
1128 static const std::bitset<CF_BIT_SIZE> CF_CHANGES_DATA(1 << CF_BIT_CHANGES_DATA);
1129 static const std::bitset<CF_BIT_SIZE> CF_HAS_ROW_COUNT(1 << CF_BIT_HAS_ROW_COUNT);
1130 static const std::bitset<CF_BIT_SIZE> CF_STATUS_COMMAND(1 << CF_BIT_STATUS_COMMAND);
1131 static const std::bitset<CF_BIT_SIZE> CF_SHOW_TABLE_COMMAND(1 << CF_BIT_SHOW_TABLE_COMMAND);
1132 static const std::bitset<CF_BIT_SIZE> CF_WRITE_LOGS_COMMAND(1 << CF_BIT_WRITE_LOGS_COMMAND);
1136 const std::string &type(Session::global_read_lock_t);
1137 size_t max_string_length(Session::global_read_lock_t);
bool derived_tables_processing
message::Statement * getStatementMessage() const
plugin::Scheduler * scheduler
bool substitute_null_with_insert_id
void set_proc_info(const char *info)
bool transaction_rollback_request
ha_rows examined_row_count
message::Transaction * getTransactionMessage() const
session_id_t getSessionId() const
message::Resultset * getResultsetMessage() const
void setQueryId(query_id_t in_query_id)
boost::shared_ptr< const std::string > QueryString
uint64_t first_successful_insert_id_in_prev_stmt
uint64_t first_successful_insert_id_in_cur_stmt
void resetResultsetMessage()
uint64_t limit_found_rows
Visibility Control Macros.
message::Transaction * transaction_message
void setTransactionMessage(message::Transaction *in_message)
query_id_t getQueryId() const
void setWarningQueryId(query_id_t in_query_id)
bool is_fatal_sub_stmt_error
static const char *const DEFAULT_WHERE
query_id_t getWarningQueryId() const
bool no_warnings_for_error
enum_server_command command
uint32_t getServerId() const
THR_LOCK_OWNER main_lock_id
drizzle_system_variables & variables
bool inTransaction() const
void setStatementMessage(message::Statement *in_message)
void setResultsetMessage(message::Resultset *in_message)