drizzle
C++ MySQL-protocol-compatible database server
Loading...
Searching...
No Matches
session.h
1/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3 *
4 * Copyright (C) 2008 Sun Microsystems, Inc.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; version 2 of the License.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18 */
19
20#pragma once
21
22#include <algorithm>
23#include <bitset>
24#include <memory>
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>
30#include <map>
31#include <netdb.h>
32#include <string>
33#include <sys/resource.h>
34#include <sys/time.h>
35
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>
43#include <drizzled/visibility.h>
44#include <drizzled/util/find_ptr.h>
45#include <drizzled/util/string.h>
46#include <drizzled/type/time.h>
47
48namespace drizzled {
49
50extern uint32_t server_id;
51extern std::string server_uuid;
52
53#define TC_HEURISTIC_RECOVER_COMMIT 1
54#define TC_HEURISTIC_RECOVER_ROLLBACK 2
55extern uint32_t tc_heuristic_recover;
56
57extern DRIZZLED_API struct drizzle_system_variables global_system_variables;
58
78
80
81class DRIZZLED_API Session
82{
83private:
84 class impl_c;
85
86 boost::scoped_ptr<impl_c> impl_;
87public:
88 typedef std::shared_ptr<Session> shared_ptr;
89
90 static shared_ptr make_shared(plugin::Client *client, std::shared_ptr<catalog::Instance> instance_arg);
91
92 /*
93 MARK_COLUMNS_NONE: Means mark_used_colums is not set and no indicator to
94 handler of fields used is set
95 MARK_COLUMNS_READ: Means a bit in read set is set to inform handler
96 that the field is to be read. If field list contains
97 duplicates, then session->dup_field is set to point
98 to the last found duplicate.
99 MARK_COLUMNS_WRITE: Means a bit is set in write set to inform handler
100 that it needs to update this field in write_row
101 and update_row.
102 */
103 enum_mark_columns mark_used_columns;
104
106 void free_items();
107
113 memory::Root& mem;
115
116 uint64_t getXaId() const
117 {
118 return xa_id;
119 }
120
121 void setXaId(uint64_t in_xa_id)
122 {
123 xa_id= in_xa_id;
124 }
125
126public:
127 Diagnostics_area& main_da();
128 const LEX& lex() const;
129 LEX& lex();
130 enum_sql_command getSqlCommand() const;
131
133 typedef std::shared_ptr<const std::string> QueryString;
134
135private:
136 std::shared_ptr<std::string> query;
137
138 // Never allow for a modification of this outside of the class. c_str()
139 // requires under some setup non const, you must copy the QueryString in
140 // order to use it.
141public:
142 void resetQueryString();
143 const std::shared_ptr<session::State>& state();
144
145 QueryString getQueryString() const
146 {
147 return query;
148 }
149
150 const char* getQueryStringCopy(size_t &length)
151 {
152 QueryString tmp_string(getQueryString());
153 if (not tmp_string)
154 {
155 length= 0;
156 return NULL;
157 }
158 length= tmp_string->length();
159 return mem.strdup(*tmp_string);
160 }
161
162 util::string::ptr schema() const;
163
170 static const char* const DEFAULT_WHERE;
171
173public:
174 void setClient(plugin::Client *client_arg);
175
176 plugin::Client *getClient() const
177 {
178 return client;
179 }
180
182
183 typedef std::unordered_map<std::string, user_var_entry*, util::insensitive_hash, util::insensitive_equal_to> UserVars;
184
185private:
186 typedef std::pair< UserVars::iterator, UserVars::iterator > UserVarsRange;
187 UserVars user_vars;
188
189public:
190 const UserVars &getUserVariables() const
191 {
192 return user_vars;
193 }
194
196 enum_tx_isolation getTxIsolation() const;
197 system_status_var& status_var;
198
202
208
209 identifier::user::ptr user() const
210 {
211 return security_ctx;
212 }
213
214 void setUser(identifier::user::mptr arg)
215 {
216 security_ctx= arg;
217 }
218
219 int32_t getScoreboardIndex() const
220 {
221 return scoreboard_index;
222 }
223
224 void setScoreboardIndex(int32_t in_scoreboard_index)
225 {
226 scoreboard_index= in_scoreboard_index;
227 }
228
229 bool isOriginatingServerUUIDSet() const
230 {
231 return originating_server_uuid_set;
232 }
233
234 void setOriginatingServerUUID(std::string in_originating_server_uuid)
235 {
236 originating_server_uuid= in_originating_server_uuid;
237 originating_server_uuid_set= true;
238 }
239
240 const std::string &getOriginatingServerUUID() const
241 {
242 return originating_server_uuid;
243 }
244
245 void setOriginatingCommitID(uint64_t in_originating_commit_id)
246 {
247 originating_commit_id= in_originating_commit_id;
248 }
249
250 uint64_t getOriginatingCommitID() const
251 {
252 return originating_commit_id;
253 }
254
258 bool isViewable(const identifier::User&) const;
259
260private:
266 const char *_where;
267
268public:
269 const char *where() const
270 {
271 return _where;
272 }
273
274 void setWhere(const char *arg)
275 {
276 _where= arg;
277 }
278
279 /*
280 One thread can hold up to one named user-level lock. This variable
281 points to a lock object if the lock is present. See item_func.cc and
282 chapter 'Miscellaneous functions', for functions GET_LOCK, RELEASE_LOCK.
283 */
284
285private:
286 boost::thread::id boost_thread_id;
287 thread_ptr _thread;
288 boost::this_thread::disable_interruption *interrupt;
289
290 internal::st_my_thread_var *mysys_var;
291
292public:
293 thread_ptr &getThread()
294 {
295 return _thread;
296 }
297
298 void pushInterrupt(boost::this_thread::disable_interruption *interrupt_arg)
299 {
300 interrupt= interrupt_arg;
301 }
302
303 boost::this_thread::disable_interruption &getThreadInterupt()
304 {
305 assert(interrupt);
306 return *interrupt;
307 }
308
309 internal::st_my_thread_var *getThreadVar()
310 {
311 return mysys_var;
312 }
313
318 enum_server_command command;
319
320 thr_lock_type update_lock_default;
321
322 /*
323 Both of the following container points in session will be converted to an API.
324 */
325
326private:
327 /* container for handler's private per-connection data */
328 std::vector<Ha_data> ha_data;
329 /*
330 Id of current query. Statement can be reused to execute several queries
331 query_id is global in context of the whole MySQL server.
332 ID is automatically generated from an atomic counter.
333 It's used in Cursor code for various purposes: to check which columns
334 from table are necessary for this select, to check if it's necessary to
335 update auto-updatable fields (like auto_increment and timestamp).
336 */
337 query_id_t query_id;
338 query_id_t warn_query_id;
339
340public:
341 void **getEngineData(const plugin::MonitoredInTransaction *monitored);
342 ResourceContext& getResourceContext(const plugin::MonitoredInTransaction&, size_t index= 0);
343
344 session::Transactions& transaction;
345 Open_tables_state& open_tables;
346 session::Times& times;
347
348 Field *dup_field;
349 sigset_t signals;
350
351public:
352 // As of right now we do not allow a concurrent execute to launch itself
353 void setConcurrentExecute(bool arg)
354 {
355 concurrent_execute_allowed= arg;
356 }
357
358 bool isConcurrentExecuteAllowed() const
359 {
360 return concurrent_execute_allowed;
361 }
362
363 /*
364 ALL OVER THIS FILE, "insert_id" means "*automatically generated* value for
365 insertion into an auto_increment column".
366 */
394
396 uint64_t options;
398
399 int64_t rowCount() const
400 {
401 return row_count_func;
402 }
403
404 ha_rows cuted_fields;
405
411
416
426 table_map used_tables;
427
436 uint32_t warn_count[(uint32_t) DRIZZLE_ERROR::WARN_LEVEL_END];
437 uint32_t total_warn_count;
438
443 uint32_t row_count;
444
445 session_id_t thread_id;
446 uint32_t tmp_table;
447 enum global_read_lock_t
448 {
449 NONE= 0,
450 GOT_GLOBAL_READ_LOCK= 1,
451 MADE_GLOBAL_READ_LOCK_BLOCK_COMMIT= 2
452 };
453private:
454 global_read_lock_t _global_read_lock;
455
456public:
457
458 global_read_lock_t isGlobalReadLock() const
459 {
460 return _global_read_lock;
461 }
462
463 void setGlobalReadLock(global_read_lock_t arg)
464 {
465 _global_read_lock= arg;
466 }
467
468 DrizzleLock *lockTables(Table **tables, uint32_t count, uint32_t flags);
469 bool lockGlobalReadLock();
470 bool lock_table_names(TableList *table_list);
471 bool lock_table_names_exclusively(TableList *table_list);
472 bool makeGlobalReadLockBlockCommit();
473 bool abortLockForThread(Table *table);
474 bool wait_if_global_read_lock(bool abort_on_refresh, bool is_not_commit);
475 int lock_table_name(TableList *table_list);
476 void abortLock(Table *table);
477 void removeLock(Table *table);
478 void unlockReadTables(DrizzleLock *sql_lock);
479 void unlockSomeTables(Table **table, uint32_t count);
480 void unlockTables(DrizzleLock *sql_lock);
481 void startWaitingGlobalReadLock();
482 void unlockGlobalReadLock();
483
484private:
485 int unlock_external(Table **table, uint32_t count);
486 int lock_external(Table **tables, uint32_t count);
487 bool wait_for_locked_table_names(TableList *table_list);
488 DrizzleLock *get_lock_data(Table **table_ptr, uint32_t count,
489 bool should_lock, Table **write_lock_used);
490public:
491
492 uint32_t server_status;
493 uint32_t open_options;
494 uint32_t select_number;
495 /* variables.transaction_isolation is reset to this after each commit */
496 enum_tx_isolation session_tx_isolation;
497 enum_check_fields count_cuted_fields;
498
499 enum killed_state_t
500 {
501 NOT_KILLED,
502 KILL_BAD_DATA,
503 KILL_CONNECTION,
504 KILL_QUERY,
505 KILLED_NO_VALUE /* means none of the above states apply */
506 };
507private:
508 killed_state_t volatile _killed;
509
510public:
511
512 void setKilled(killed_state_t arg)
513 {
514 _killed= arg;
515 }
516
517 killed_state_t getKilled() const
518 {
519 return _killed;
520 }
521
522 volatile killed_state_t *getKilledPtr() // Do not use this method, it is here for historical convience.
523 {
524 return &_killed;
525 }
526
527 bool is_admin_connection;
528 bool no_errors;
557 bool cleanup_done;
558
559public:
564
565 bool doing_tablespace_operation() const
566 {
567 return tablespace_op;
568 }
569
570 void setDoingTablespaceOperation(bool doing)
571 {
572 tablespace_op= doing;
573 }
574
575
577 union
578 {
579 bool bool_value;
580 uint32_t uint32_t_value;
581 int32_t int32_t_value;
582 uint64_t uint64_t_value;
583 } sys_var_tmp;
584
593
596
605 inline void set_proc_info(const char *info)
606 {
607 proc_info= info;
608 }
609 inline const char* get_proc_info() const
610 {
611 return proc_info;
612 }
613
615 inline void setQueryId(query_id_t in_query_id)
616 {
617 query_id= in_query_id;
618 }
619
621 query_id_t getQueryId() const
622 {
623 return query_id;
624 }
625
626
628 inline void setWarningQueryId(query_id_t in_query_id)
629 {
630 warn_query_id= in_query_id;
631 }
632
634 inline query_id_t getWarningQueryId() const
635 {
636 return warn_query_id;
637 }
638
640 inline session_id_t getSessionId() const
641 {
642 return thread_id;
643 }
644
646 inline uint32_t getServerId() const
647 {
648 /* We return the global server ID. */
649 return server_id;
650 }
651
652 inline std::string &getServerUUID() const
653 {
654 return server_uuid;
655 }
656
657 inline void record_first_successful_insert_id_in_cur_stmt(uint64_t id_arg)
658 {
659 if (first_successful_insert_id_in_cur_stmt == 0)
660 first_successful_insert_id_in_cur_stmt= id_arg;
661 }
662 inline uint64_t read_first_successful_insert_id_in_prev_stmt() const
663 {
664 return first_successful_insert_id_in_prev_stmt;
665 }
666
667 Session(plugin::Client*, std::shared_ptr<catalog::Instance>);
668 ~Session();
669
670 void cleanup();
683 void cleanup_after_query();
684 void storeGlobals();
685 void awake(Session::killed_state_t state_to_set);
686
693 void prepareForQueries();
694
709 bool executeStatement();
710
727 void readAndStoreQuery(str_ref);
728
737 bool endTransaction(enum enum_mysql_completiontype completion);
738 bool endActiveTransaction();
739 bool startTransaction(start_transaction_option_t opt= START_TRANS_NO_OPTIONS);
740 void markTransactionForRollback(bool all);
741
747 bool authenticate();
748 void run();
749 static bool schedule(const Session::shared_ptr&);
750 static void unlink(session_id_t&);
751 static void unlink(const Session::shared_ptr&);
752
753 /*
754 For enter_cond() / exit_cond() to work the mutex must be got before
755 enter_cond(); this mutex is then released by exit_cond().
756 Usage must be: lock mutex; enter_cond(); your code; exit_cond().
757 */
758 const char* enter_cond(boost::condition_variable_any &cond, boost::mutex &mutex, const char* msg);
759 void exit_cond(const char* old_msg);
760
761 uint64_t found_rows() const
762 {
763 return limit_found_rows;
764 }
765
767 bool inTransaction() const
768 {
769 return server_status & SERVER_STATUS_IN_TRANS;
770 }
771
772 lex_string_t* make_lex_string(lex_string_t*, str_ref);
773
774 void send_explain_fields(select_result*);
775
776 void clear_error(bool full= false);
777 void clearDiagnostics();
778 bool is_error() const;
779
780 static const charset_info_st *charset() { return default_charset_info; }
781
790 void end_statement();
791 inline int killed_errno() const
792 {
793 killed_state_t killed_val; /* to cache the volatile 'killed' */
794 return (killed_val= _killed) != KILL_BAD_DATA ? killed_val : 0;
795 }
796 void send_kill_message() const;
797 /* return true if we will abort query if we make a warning now */
798 inline bool abortOnWarning()
799 {
800 return abort_on_warning;
801 }
802
803 inline void setAbortOnWarning(bool arg)
804 {
805 abort_on_warning= arg;
806 }
807
808 void setAbort(bool arg);
809 void lockOnSys();
810 void set_status_var_init();
828 void set_schema(const std::string&);
829
830 /*
831 Copy the current database to the argument. Use the current arena to
832 allocate memory for a deep copy: current database may be freed after
833 a statement is parsed but before it's executed.
834 */
835 str_ref copy_db_to() const;
836
837public:
838
852 void reset_for_next_command();
853
862 void disconnect(enum error_t errcode= EE_OK);
863
876 bool checkUser(const std::string &passwd, const std::string &db);
877
883 message::Transaction *getTransactionMessage() const
884 {
885 return transaction_message;
886 }
887
892 message::Statement *getStatementMessage() const
893 {
894 return statement_message;
895 }
896
901 message::Resultset *getResultsetMessage() const
902 {
903 return resultset;
904 }
905
911 void setTransactionMessage(message::Transaction *in_message)
912 {
913 transaction_message= in_message;
914 }
915
922 void setStatementMessage(message::Statement *in_message)
923 {
924 statement_message= in_message;
925 }
926
933 void setResultsetMessage(message::Resultset *in_message)
934 {
935 resultset= in_message;
936 }
937
941
943 {
944 resultset= NULL;
945 }
946
947 plugin::EventObserverList *getSessionObservers()
948 {
949 return session_event_observers;
950 }
951
952 void setSessionObservers(plugin::EventObserverList *observers)
953 {
954 session_event_observers= observers;
955 }
956
957 plugin::EventObserverList* getSchemaObservers(const std::string& schema);
958 plugin::EventObserverList* setSchemaObservers(const std::string& schema, plugin::EventObserverList*);
959
960public:
961 void my_ok(ha_rows affected_rows= 0, ha_rows found_rows_arg= 0, uint64_t passed_id= 0, const char *message= NULL);
962 void my_eof();
963 void add_item_to_list(Item *item);
964 void add_value_to_list(Item *value);
965 void add_order_to_list(Item *item, bool asc);
966 void add_group_to_list(Item *item, bool asc);
967
968 void refresh_status();
969 user_var_entry* getVariable(str_ref name, bool create_if_not_exists);
970 void setVariable(const std::string& name, const std::string& value);
971
976 void close_thread_tables();
977 void close_old_data_files(bool morph_locks= false, bool send_refresh= false);
978 void close_data_files_and_morph_locks(const identifier::Table&);
979
986 void close_tables_for_reopen(TableList **tables);
987
988
1003 bool openTablesLock(TableList*);
1004 Table *open_temporary_table(const identifier::Table &identifier, bool link_in_list= true);
1005
1006 int open_tables_from_list(TableList **start, uint32_t *counter, uint32_t flags= 0);
1007
1008 Table *openTableLock(TableList *table_list, thr_lock_type lock_type);
1009 Table *openTable(TableList *table_list, bool *refresh, uint32_t flags= 0);
1010
1011 void unlink_open_table(Table *find);
1012 void drop_open_table(Table *table, const identifier::Table &identifier);
1013 void close_cached_table(Table *table);
1014
1015 /* Create a lock in the cache */
1016 table::Placeholder& table_cache_insert_placeholder(const identifier::Table&);
1017 Table* lock_table_name_if_not_cached(const identifier::Table&);
1018
1019 session::TableMessages &getMessageCache();
1020
1021 /* Reopen operations */
1022 bool reopen_tables();
1023 bool close_cached_tables(TableList *tables, bool wait_for_refresh, bool wait_for_placeholders);
1024
1025 void wait_for_condition(boost::mutex &mutex, boost::condition_variable_any &cond);
1026 int setup_conds(TableList *leaves, COND **conds);
1027 int lock_tables(TableList *tables, uint32_t count, bool *need_reopen);
1028
1029 template <class T>
1030 T* getProperty(const std::string& name)
1031 {
1032 return static_cast<T*>(getProperty0(name));
1033 }
1034
1035 template <class T>
1036 T setProperty(const std::string& name, T value)
1037 {
1038 setProperty0(name, value);
1039 return value;
1040 }
1041
1050 plugin::StorageEngine *getDefaultStorageEngine();
1051 void get_xid(DrizzleXid *xid) const; // Innodb only
1052
1053 table::Singular& getInstanceTable();
1054 table::Singular& getInstanceTable(std::list<CreateField>&);
1055
1056 void setUsage(bool arg)
1057 {
1058 use_usage= arg;
1059 }
1060
1061 const rusage &getUsage()
1062 {
1063 return usage;
1064 }
1065
1066 const catalog::Instance& catalog() const
1067 {
1068 return *_catalog;
1069 }
1070
1071 catalog::Instance& catalog()
1072 {
1073 return *_catalog;
1074 }
1075
1076 bool arg_of_last_insert_id_function; // Tells if LAST_INSERT_ID(#) was called for the current statement
1077private:
1078 drizzled::util::Storable* getProperty0(const std::string&);
1079 void setProperty0(const std::string&, drizzled::util::Storable*);
1080
1081 bool resetUsage()
1082 {
1083 return not getrusage(RUSAGE_THREAD, &usage);
1084 }
1085
1086 std::shared_ptr<catalog::Instance> _catalog;
1087
1089 message::Transaction *transaction_message;
1090 message::Statement *statement_message;
1091 /* Pointer to the current resultset of Select query */
1092 message::Resultset *resultset;
1093 plugin::EventObserverList *session_event_observers;
1094
1095 uint64_t xa_id;
1096 const char *proc_info;
1097 bool abort_on_warning;
1098 bool concurrent_execute_allowed;
1100 bool use_usage;
1101 rusage usage;
1102 identifier::user::mptr security_ctx;
1103 int32_t scoreboard_index;
1104 bool originating_server_uuid_set;
1105 std::string originating_server_uuid;
1106 uint64_t originating_commit_id;
1107 plugin::Client *client;
1108};
1109
1110#define ESCAPE_CHARS "ntrb0ZN" // keep synchronous with READ_INFO::unescape
1111
1112/* Bits in sql_command_flags */
1113
1114enum sql_command_flag_bits
1115{
1116 CF_BIT_CHANGES_DATA,
1117 CF_BIT_HAS_ROW_COUNT,
1118 CF_BIT_STATUS_COMMAND,
1119 CF_BIT_SHOW_TABLE_COMMAND,
1120 CF_BIT_WRITE_LOGS_COMMAND,
1121 CF_BIT_SIZE
1122};
1123
1124static const std::bitset<CF_BIT_SIZE> CF_CHANGES_DATA(1 << CF_BIT_CHANGES_DATA);
1125static const std::bitset<CF_BIT_SIZE> CF_HAS_ROW_COUNT(1 << CF_BIT_HAS_ROW_COUNT);
1126static const std::bitset<CF_BIT_SIZE> CF_STATUS_COMMAND(1 << CF_BIT_STATUS_COMMAND);
1127static const std::bitset<CF_BIT_SIZE> CF_SHOW_TABLE_COMMAND(1 << CF_BIT_SHOW_TABLE_COMMAND);
1128static const std::bitset<CF_BIT_SIZE> CF_WRITE_LOGS_COMMAND(1 << CF_BIT_WRITE_LOGS_COMMAND);
1129
1130namespace display
1131{
1132 const std::string &type(Session::global_read_lock_t);
1133 size_t max_string_length(Session::global_read_lock_t);
1134} /* namespace display */
1135
1136} /* namespace drizzled */
1137
int64_t row_count_func
Definition session.h:397
uint32_t row_count
Definition session.h:443
void * session_marker
Definition session.h:595
bool transaction_rollback_request
Definition session.h:542
void set_proc_info(const char *info)
Definition session.h:605
message::Statement * getStatementMessage() const
Definition session.h:892
const char * _where
Definition session.h:266
drizzle_system_variables & variables
Definition session.h:195
query_id_t getQueryId() const
Definition session.h:621
enum_server_command command
Definition session.h:318
THR_LOCK_OWNER * lock_id
Definition session.h:201
uint64_t limit_found_rows
Definition session.h:395
Lex_input_stream * m_lip
Definition session.h:592
uint32_t getServerId() const
Definition session.h:646
void setStatementMessage(message::Statement *in_message)
Definition session.h:922
memory::Root warn_root
Definition session.h:172
std::shared_ptr< const std::string > QueryString
Definition session.h:133
bool no_warnings_for_error
Definition session.h:561
message::Resultset * getResultsetMessage() const
Definition session.h:901
bool substitute_null_with_insert_id
Definition session.h:556
uint64_t options
Definition session.h:396
memory::Root * mem_root
Definition session.h:114
void setQueryId(query_id_t in_query_id)
Definition session.h:615
bool is_fatal_sub_stmt_error
Definition session.h:554
table_map used_tables
Definition session.h:426
THR_LOCK_INFO lock_info
Definition session.h:199
THR_LOCK_OWNER main_lock_id
Definition session.h:200
bool derived_tables_processing
Definition session.h:563
uint64_t first_successful_insert_id_in_cur_stmt
Definition session.h:381
void setTransactionMessage(message::Transaction *in_message)
Definition session.h:911
query_id_t getWarningQueryId() const
Definition session.h:634
session_id_t getSessionId() const
Definition session.h:640
message::Transaction * transaction_message
Definition session.h:1089
void resetResultsetMessage()
Definition session.h:942
void setWarningQueryId(query_id_t in_query_id)
Definition session.h:628
uint64_t first_successful_insert_id_in_prev_stmt
Definition session.h:375
plugin::Scheduler * scheduler
Definition session.h:181
uint32_t select_number
Definition session.h:494
uint32_t warn_count[(uint32_t) DRIZZLE_ERROR::WARN_LEVEL_END]
Definition session.h:436
void setResultsetMessage(message::Resultset *in_message)
Definition session.h:933
char * thread_stack
Definition session.h:207
static const char *const DEFAULT_WHERE
Definition session.h:170
ha_rows examined_row_count
Definition session.h:415
ha_rows cuted_fields
Definition session.h:404
UserVars user_vars
Definition session.h:187
bool inTransaction() const
Definition session.h:767
message::Transaction * getTransactionMessage() const
Definition session.h:883
ha_rows sent_row_count
Definition session.h:410
char * strdup(const char *)
Duplicate a null-terminated string into memory allocated from within the specified Root.
Definition root.cc:327
TODO: Rename this file - func.h is stupid.
Visibility Control Macros.
#define DRIZZLED_API
Definition visibility.h:38