← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/session.h

  • Committer: Lee Bieber
  • Date: 2011-02-11 20:30:05 UTC
  • mfrom: (2157.1.3 build)
  • Revision ID: kalebral@gmail.com-20110211203005-757o1y2yf78dxzqr
Merge Stewart - 716848: drizzleimport displays wrong program_name
Merge Stewart - update README file
Merge Andrew and Joe - Exposes the InnoDB SYS_REPLICATION_LOG to data_dictionary so that it is fast and fixes many issues we have been having

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/session.h
17
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
18
 */
19
19
 
 
20
 
 
21
 
20
22
#ifndef DRIZZLED_SESSION_H
21
23
#define DRIZZLED_SESSION_H
22
24
 
 
25
#include "drizzled/plugin.h"
 
26
#include "drizzled/sql_locale.h"
 
27
#include "drizzled/resource_context.h"
 
28
#include "drizzled/cursor.h"
 
29
#include "drizzled/current_session.h"
 
30
#include "drizzled/sql_error.h"
 
31
#include "drizzled/file_exchange.h"
 
32
#include "drizzled/select_result_interceptor.h"
 
33
#include "drizzled/statistics_variables.h"
 
34
#include "drizzled/xid.h"
 
35
#include "drizzled/query_id.h"
 
36
#include "drizzled/named_savepoint.h"
 
37
#include "drizzled/transaction_context.h"
 
38
#include "drizzled/util/storable.h"
 
39
#include "drizzled/my_hash.h"
 
40
#include "drizzled/pthread_globals.h"
 
41
#include <netdb.h>
 
42
#include <sys/time.h>
 
43
#include <sys/resource.h>
 
44
 
23
45
#include <algorithm>
24
46
#include <bitset>
25
 
#include <boost/make_shared.hpp>
26
 
#include <boost/thread/condition_variable.hpp>
 
47
#include <deque>
 
48
#include <map>
 
49
#include <string>
 
50
 
 
51
#include "drizzled/identifier.h"
 
52
#include "drizzled/open_tables_state.h"
 
53
#include "drizzled/internal_error_handler.h"
 
54
#include "drizzled/diagnostics_area.h"
 
55
#include "drizzled/plugin/authorization.h"
 
56
 
 
57
#include "drizzled/catalog/instance.h"
 
58
#include "drizzled/catalog/local.h"
 
59
 
 
60
#include <boost/unordered_map.hpp>
 
61
 
 
62
#include <boost/thread/thread.hpp>
27
63
#include <boost/thread/mutex.hpp>
28
64
#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>
 
65
#include <boost/thread/condition_variable.hpp>
 
66
#include <boost/make_shared.hpp>
35
67
 
36
 
#include <drizzled/catalog/instance.h>
37
 
#include <drizzled/catalog/local.h>
38
 
#include <drizzled/copy_info.h>
39
 
#include <drizzled/cursor.h>
40
 
#include <drizzled/diagnostics_area.h>
41
 
#include <drizzled/file_exchange.h>
42
 
#include <drizzled/ha_data.h>
43
 
#include <drizzled/identifier.h>
44
 
#include <drizzled/lex_column.h>
45
 
#include <drizzled/my_hash.h>
46
 
#include <drizzled/named_savepoint.h>
47
 
#include <drizzled/open_tables_state.h>
48
 
#include <drizzled/plugin.h>
49
 
#include <drizzled/plugin/authorization.h>
50
 
#include <drizzled/pthread_globals.h>
51
 
#include <drizzled/query_id.h>
52
 
#include <drizzled/resource_context.h>
53
 
#include <drizzled/session/property_map.h>
54
 
#include <drizzled/session/state.h>
55
 
#include <drizzled/session/table_messages.h>
56
 
#include <drizzled/session/transactions.h>
57
 
#include <drizzled/sql_error.h>
58
 
#include <drizzled/sql_lex.h>
59
 
#include <drizzled/sql_locale.h>
60
 
#include <drizzled/statistics_variables.h>
61
 
#include <drizzled/system_variables.h>
62
 
#include <drizzled/system_variables.h>
63
 
#include <drizzled/table_ident.h>
64
 
#include <drizzled/transaction_context.h>
65
 
#include <drizzled/util/storable.h>
66
 
#include <drizzled/var.h>
67
 
#include <drizzled/visibility.h>
 
68
#include "drizzled/visibility.h"
68
69
 
69
70
#define MIN_HANDSHAKE_SIZE      6
70
71
 
85
86
class Resultset;
86
87
}
87
88
 
88
 
namespace internal { struct st_my_thread_var; }
89
 
namespace table { class Placeholder; }
90
 
 
 
89
namespace internal
 
90
{
 
91
struct st_my_thread_var;
 
92
}
 
93
 
 
94
namespace table
 
95
{
 
96
class Placeholder;
 
97
}
 
98
 
 
99
class Lex_input_stream;
 
100
class user_var_entry;
91
101
class CopyField;
92
 
class DrizzleXid;
93
 
class Internal_error_handler;
94
 
class Lex_input_stream;
 
102
class Table_ident;
 
103
 
95
104
class TableShareInstance;
96
 
class Table_ident;
97
 
class Time_zone;
98
 
class select_result;
99
 
class user_var_entry;
100
105
 
101
106
extern char internal_table_name[2];
102
107
extern char empty_c_string[1];
106
111
#define TC_HEURISTIC_RECOVER_ROLLBACK 2
107
112
extern uint32_t tc_heuristic_recover;
108
113
 
 
114
/**
 
115
  @brief
 
116
  Local storage for proto that are tmp table. This should be enlarged
 
117
  to hande the entire table-share for a local table. Once Hash is done,
 
118
  we should consider exchanging the map for it.
 
119
*/
 
120
typedef std::map <std::string, message::Table> ProtoCache;
 
121
 
 
122
/**
 
123
  The COPY_INFO structure is used by INSERT/REPLACE code.
 
124
  The schema of the row counting by the INSERT/INSERT ... ON DUPLICATE KEY
 
125
  UPDATE code:
 
126
    If a row is inserted then the copied variable is incremented.
 
127
    If a row is updated by the INSERT ... ON DUPLICATE KEY UPDATE and the
 
128
      new data differs from the old one then the copied and the updated
 
129
      variables are incremented.
 
130
    The touched variable is incremented if a row was touched by the update part
 
131
      of the INSERT ... ON DUPLICATE KEY UPDATE no matter whether the row
 
132
      was actually changed or not.
 
133
*/
 
134
class CopyInfo 
 
135
{
 
136
public:
 
137
  ha_rows records; /**< Number of processed records */
 
138
  ha_rows deleted; /**< Number of deleted records */
 
139
  ha_rows updated; /**< Number of updated records */
 
140
  ha_rows copied;  /**< Number of copied records */
 
141
  ha_rows error_count;
 
142
  ha_rows touched; /* Number of touched records */
 
143
  enum enum_duplicates handle_duplicates;
 
144
  int escape_char, last_errno;
 
145
  bool ignore;
 
146
  /* for INSERT ... UPDATE */
 
147
  List<Item> *update_fields;
 
148
  List<Item> *update_values;
 
149
  /* for VIEW ... WITH CHECK OPTION */
 
150
 
 
151
  CopyInfo() :
 
152
    records(0),
 
153
    deleted(0),
 
154
    updated(0),
 
155
    copied(0),
 
156
    error_count(0),
 
157
    touched(0),
 
158
    escape_char(0),
 
159
    last_errno(0),
 
160
    ignore(0),
 
161
    update_fields(0),
 
162
    update_values(0)
 
163
  { }
 
164
 
 
165
};
 
166
 
 
167
} /* namespace drizzled */
 
168
 
 
169
/** @TODO why is this in the middle of the file */
 
170
#include <drizzled/lex_column.h>
 
171
 
 
172
namespace drizzled
 
173
{
 
174
 
 
175
class select_result;
 
176
class Time_zone;
 
177
 
109
178
#define Session_SENTRY_MAGIC 0xfeedd1ff
110
179
#define Session_SENTRY_GONE  0xdeadbeef
111
180
 
 
181
struct drizzle_system_variables
 
182
{
 
183
  drizzle_system_variables()
 
184
  {}
 
185
  /*
 
186
    How dynamically allocated system variables are handled:
 
187
 
 
188
    The global_system_variables and max_system_variables are "authoritative"
 
189
    They both should have the same 'version' and 'size'.
 
190
    When attempting to access a dynamic variable, if the session version
 
191
    is out of date, then the session version is updated and realloced if
 
192
    neccessary and bytes copied from global to make up for missing data.
 
193
  */
 
194
  ulong dynamic_variables_version;
 
195
  char * dynamic_variables_ptr;
 
196
  uint32_t dynamic_variables_head;  /* largest valid variable offset */
 
197
  uint32_t dynamic_variables_size;  /* how many bytes are in use */
 
198
 
 
199
  uint64_t myisam_max_extra_sort_file_size;
 
200
  uint64_t max_heap_table_size;
 
201
  uint64_t tmp_table_size;
 
202
  ha_rows select_limit;
 
203
  ha_rows max_join_size;
 
204
  uint64_t auto_increment_increment;
 
205
  uint64_t auto_increment_offset;
 
206
  uint64_t bulk_insert_buff_size;
 
207
  uint64_t join_buff_size;
 
208
  uint32_t max_allowed_packet;
 
209
  uint64_t max_error_count;
 
210
  uint64_t max_length_for_sort_data;
 
211
  size_t max_sort_length;
 
212
  uint64_t min_examined_row_limit;
 
213
  bool optimizer_prune_level;
 
214
  bool log_warnings;
 
215
 
 
216
  uint32_t optimizer_search_depth;
 
217
  uint32_t div_precincrement;
 
218
  uint64_t preload_buff_size;
 
219
  uint32_t read_buff_size;
 
220
  uint32_t read_rnd_buff_size;
 
221
  bool replicate_query;
 
222
  size_t sortbuff_size;
 
223
  uint32_t thread_handling;
 
224
  uint32_t tx_isolation;
 
225
  uint32_t completion_type;
 
226
  /* Determines which non-standard SQL behaviour should be enabled */
 
227
  uint32_t sql_mode;
 
228
  uint64_t max_seeks_for_key;
 
229
  size_t range_alloc_block_size;
 
230
  uint32_t query_alloc_block_size;
 
231
  uint32_t query_prealloc_size;
 
232
  uint64_t group_concat_max_len;
 
233
  uint64_t pseudo_thread_id;
 
234
 
 
235
  plugin::StorageEngine *storage_engine;
 
236
 
 
237
  /* Only charset part of these variables is sensible */
 
238
  const CHARSET_INFO  *character_set_filesystem;
 
239
 
 
240
  /* Both charset and collation parts of these variables are important */
 
241
  const CHARSET_INFO    *collation_server;
 
242
 
 
243
  inline const CHARSET_INFO  *getCollation(void) 
 
244
  {
 
245
    return collation_server;
 
246
  }
 
247
 
 
248
  /* Locale Support */
 
249
  MY_LOCALE *lc_time_names;
 
250
 
 
251
  Time_zone *time_zone;
 
252
};
 
253
 
112
254
extern DRIZZLED_API struct drizzle_system_variables global_system_variables;
113
255
 
 
256
} /* namespace drizzled */
 
257
 
 
258
#include "drizzled/sql_lex.h"
 
259
 
 
260
namespace drizzled
 
261
{
 
262
 
 
263
/**
 
264
  Storage engine specific thread local data.
 
265
*/
 
266
struct Ha_data
 
267
{
 
268
  /**
 
269
    Storage engine specific thread local data.
 
270
    Lifetime: one user connection.
 
271
  */
 
272
  void *ha_ptr;
 
273
  /**
 
274
   * Resource contexts for both the "statement" and "normal"
 
275
   * transactions.
 
276
   *
 
277
   * Resource context at index 0:
 
278
   *
 
279
   * Life time: one statement within a transaction. If @@autocommit is
 
280
   * on, also represents the entire transaction.
 
281
   *
 
282
   * Resource context at index 1:
 
283
   *
 
284
   * Life time: one transaction within a connection. 
 
285
   *
 
286
   * @note
 
287
   *
 
288
   * If the storage engine does not participate in a transaction, 
 
289
   * there will not be a resource context.
 
290
   */
 
291
  drizzled::ResourceContext resource_context[2];
 
292
 
 
293
  Ha_data() :ha_ptr(NULL) {}
 
294
};
 
295
 
114
296
/**
115
297
 * Represents a client connection to the database server.
116
298
 *
131
313
 * session object.
132
314
 */
133
315
 
134
 
class DRIZZLED_API Session : public Open_tables_state
 
316
class DRIZZLED_API Session :
 
317
  public Open_tables_state
135
318
{
136
319
public:
137
320
  // Plugin storage in Session.
 
321
  typedef boost::unordered_map<std::string, util::Storable *, util::insensitive_hash, util::insensitive_equal_to> PropertyMap;
 
322
  typedef Session* Ptr;
138
323
  typedef boost::shared_ptr<Session> shared_ptr;
139
324
  typedef Session& reference;
140
325
  typedef const Session& const_reference;
159
344
                        and update_row.
160
345
  */
161
346
  enum enum_mark_columns mark_used_columns;
 
347
  inline void* alloc(size_t size)
 
348
  {
 
349
    return mem_root->alloc_root(size);
 
350
  }
162
351
  inline void* calloc(size_t size)
163
352
  {
164
353
    void *ptr;
166
355
      memset(ptr, 0, size);
167
356
    return ptr;
168
357
  }
 
358
  inline char *strdup(const char *str)
 
359
  {
 
360
    return mem_root->strdup_root(str);
 
361
  }
169
362
  inline char *strmake(const char *str, size_t size)
170
363
  {
171
364
    return mem_root->strmake_root(str,size);
172
365
  }
173
 
 
 
366
  inline void *memdup(const void *str, size_t size)
 
367
  {
 
368
    return mem_root->memdup_root(str, size);
 
369
  }
174
370
  inline void *memdup_w_gap(const void *str, size_t size, uint32_t gap)
175
371
  {
176
372
    void *ptr;
180
376
  }
181
377
  /** Frees all items attached to this Statement */
182
378
  void free_items();
183
 
 
184
379
  /**
185
380
   * List of items created in the parser for this query. Every item puts
186
381
   * itself to the list on creation (see Item::Item() for details))
213
408
   * @todo should be const
214
409
   */
215
410
  uint32_t id;
216
 
private:
217
411
  LEX *lex; /**< parse tree descriptor */
218
412
 
219
 
public:
220
413
  LEX *getLex() 
221
414
  {
222
415
    return lex;
229
422
 
230
423
  /** query associated with this statement */
231
424
  typedef boost::shared_ptr<const std::string> QueryString;
232
 
 
233
425
private:
234
426
  boost::shared_ptr<std::string> query;
235
427
 
268
460
    return to_return;
269
461
  }
270
462
 
 
463
  class State {
 
464
    std::vector <char> _query;
 
465
 
 
466
  public:
 
467
    typedef boost::shared_ptr<State> const_shared_ptr;
 
468
 
 
469
    State(const char *in_packet, size_t in_packet_length)
 
470
    {
 
471
      if (in_packet_length)
 
472
      {
 
473
        size_t minimum= std::min(in_packet_length, static_cast<size_t>(PROCESS_LIST_WIDTH));
 
474
        _query.resize(minimum + 1);
 
475
        memcpy(&_query[0], in_packet, minimum);
 
476
      }
 
477
      else
 
478
      {
 
479
        _query.resize(0);
 
480
      }
 
481
    }
 
482
 
 
483
    const char *query() const
 
484
    {
 
485
      if (_query.size())
 
486
        return &_query[0];
 
487
 
 
488
      return "";
 
489
    }
 
490
 
 
491
    const char *query(size_t &size) const
 
492
    {
 
493
      if (_query.size())
 
494
      {
 
495
        size= _query.size() -1;
 
496
        return &_query[0];
 
497
      }
 
498
 
 
499
      size= 0;
 
500
      return "";
 
501
    }
 
502
  protected:
 
503
    friend class Session;
 
504
    typedef boost::shared_ptr<State> shared_ptr;
 
505
  };
271
506
private:
272
 
  session::State::shared_ptr  _state; 
273
 
 
 
507
  State::shared_ptr  _state; 
274
508
public:
275
509
 
276
 
  session::State::const_shared_ptr state()
 
510
  State::const_shared_ptr state()
277
511
  {
278
512
    return _state;
279
513
  }
292
526
  */
293
527
private:
294
528
  util::string::shared_ptr _schema;
295
 
 
296
529
public:
297
530
 
298
531
  util::string::const_shared_ptr schema() const
335
568
  void *scheduler_arg; /**< Pointer to the optional scheduler argument */
336
569
 
337
570
  typedef boost::unordered_map< std::string, user_var_entry *, util::insensitive_hash, util::insensitive_equal_to> UserVars;
338
 
 
339
571
private:
340
572
  typedef std::pair< UserVars::iterator, UserVars::iterator > UserVarsRange;
341
573
  UserVars user_vars; /**< Hash of user variables defined during the session's lifetime */
342
574
 
343
575
public:
 
576
 
344
577
  const UserVars &getUserVariables() const
345
578
  {
346
579
    return user_vars;
373
606
  {
374
607
    assert(this->dbug_sentry == Session_SENTRY_MAGIC);
375
608
  }
376
 
 
377
609
public:
378
610
  identifier::User::const_shared_ptr user() const
379
611
  {
435
667
  boost::this_thread::disable_interruption *interrupt;
436
668
 
437
669
  internal::st_my_thread_var *mysys_var;
 
670
public:
438
671
 
439
 
public:
440
672
  boost_thread_shared_ptr &getThread()
441
673
  {
442
674
    return _thread;
517
749
  ResourceContext *getResourceContext(const plugin::MonitoredInTransaction *monitored,
518
750
                                      size_t index= 0);
519
751
 
520
 
  session::Transactions transaction;
 
752
  /**
 
753
   * Structure used to manage "statement transactions" and
 
754
   * "normal transactions". In autocommit mode, the normal transaction is
 
755
   * equivalent to the statement transaction.
 
756
   *
 
757
   * Storage engines will be registered here when they participate in
 
758
   * a transaction. No engine is registered more than once.
 
759
   */
 
760
  struct st_transactions {
 
761
    std::deque<NamedSavepoint> savepoints;
 
762
 
 
763
    /**
 
764
     * The normal transaction (since BEGIN WORK).
 
765
     *
 
766
     * Contains a list of all engines that have participated in any of the
 
767
     * statement transactions started within the context of the normal
 
768
     * transaction.
 
769
     *
 
770
     * @note In autocommit mode, this is empty.
 
771
     */
 
772
    TransactionContext all;
 
773
 
 
774
    /**
 
775
     * The statment transaction.
 
776
     *
 
777
     * Contains a list of all engines participating in the given statement.
 
778
     *
 
779
     * @note In autocommit mode, this will be used to commit/rollback the
 
780
     * normal transaction.
 
781
     */
 
782
    TransactionContext stmt;
 
783
 
 
784
    XID_STATE xid_state;
 
785
 
 
786
    void cleanup()
 
787
    {
 
788
      savepoints.clear();
 
789
    }
 
790
    st_transactions() :
 
791
      savepoints(),
 
792
      all(),
 
793
      stmt(),
 
794
      xid_state()
 
795
    { }
 
796
  } transaction;
521
797
 
522
798
  Field *dup_field;
523
799
  sigset_t signals;
525
801
  // As of right now we do not allow a concurrent execute to launch itself
526
802
private:
527
803
  bool concurrent_execute_allowed;
528
 
 
529
804
public:
530
805
 
531
806
  void setConcurrentExecute(bool arg)
1579
1854
  table::Placeholder *table_cache_insert_placeholder(const identifier::Table &identifier);
1580
1855
  bool lock_table_name_if_not_cached(const identifier::Table &identifier, Table **table);
1581
1856
 
 
1857
  typedef boost::unordered_map<std::string, message::Table, util::insensitive_hash, util::insensitive_equal_to> TableMessageCache;
 
1858
 
 
1859
  class TableMessages
 
1860
  {
 
1861
    TableMessageCache table_message_cache;
 
1862
 
 
1863
  public:
 
1864
    bool storeTableMessage(const identifier::Table &identifier, message::Table &table_message);
 
1865
    bool removeTableMessage(const identifier::Table &identifier);
 
1866
    bool getTableMessage(const identifier::Table &identifier, message::Table &table_message);
 
1867
    bool doesTableMessageExist(const identifier::Table &identifier);
 
1868
    bool renameTableMessage(const identifier::Table &from, const identifier::Table &to);
 
1869
  };
 
1870
 
1582
1871
private:
1583
 
  session::TableMessages _table_message_cache;
 
1872
  TableMessages _table_message_cache;
1584
1873
 
1585
1874
public:
1586
 
  session::TableMessages &getMessageCache()
 
1875
  TableMessages &getMessageCache()
1587
1876
  {
1588
1877
    return _table_message_cache;
1589
1878
  }
1598
1887
 
1599
1888
  drizzled::util::Storable *getProperty(const std::string &arg)
1600
1889
  {
1601
 
    return life_properties.getProperty(arg);
 
1890
    return life_properties[arg];
1602
1891
  }
1603
1892
 
1604
1893
  template<class T>
1605
1894
  bool setProperty(const std::string &arg, T *value)
1606
1895
  {
1607
 
    life_properties.setProperty(arg, value);
 
1896
    life_properties[arg]= value;
1608
1897
 
1609
1898
    return true;
1610
1899
  }
1624
1913
    return global_system_variables.storage_engine;
1625
1914
  }
1626
1915
 
1627
 
  void get_xid(DrizzleXid *xid); // Innodb only
 
1916
  void get_xid(DRIZZLE_XID *xid); // Innodb only
1628
1917
 
1629
1918
  table::Singular *getInstanceTable();
1630
1919
  table::Singular *getInstanceTable(List<CreateField> &field_list);
1639
1928
 
1640
1929
    return true;
1641
1930
  }
1642
 
 
1643
1931
public:
1644
1932
 
1645
1933
  void setUsage(bool arg)
1667
1955
 
1668
1956
  // This lives throughout the life of Session
1669
1957
  bool use_usage;
1670
 
  session::PropertyMap life_properties;
 
1958
  PropertyMap life_properties;
1671
1959
  std::vector<table::Singular *> temporary_shares;
1672
1960
  struct rusage usage;
1673
1961
};
1674
1962
 
 
1963
class Join;
 
1964
 
1675
1965
#define ESCAPE_CHARS "ntrb0ZN" // keep synchronous with READ_INFO::unescape
1676
1966
 
 
1967
} /* namespace drizzled */
 
1968
 
 
1969
/** @TODO why is this in the middle of the file */
 
1970
#include <drizzled/select_to_file.h>
 
1971
#include <drizzled/select_export.h>
 
1972
#include <drizzled/select_dump.h>
 
1973
#include <drizzled/select_insert.h>
 
1974
#include <drizzled/select_create.h>
 
1975
#include <drizzled/tmp_table_param.h>
 
1976
#include <drizzled/select_union.h>
 
1977
#include <drizzled/select_subselect.h>
 
1978
#include <drizzled/select_singlerow_subselect.h>
 
1979
#include <drizzled/select_max_min_finder_subselect.h>
 
1980
#include <drizzled/select_exists_subselect.h>
 
1981
 
 
1982
namespace drizzled
 
1983
{
 
1984
 
 
1985
/**
 
1986
 * A structure used to describe sort information
 
1987
 * for a field or item used in ORDER BY.
 
1988
 */
 
1989
class SortField 
 
1990
{
 
1991
public:
 
1992
  Field *field; /**< Field to sort */
 
1993
  Item  *item; /**< Item if not sorting fields */
 
1994
  size_t length; /**< Length of sort field */
 
1995
  uint32_t suffix_length; /**< Length suffix (0-4) */
 
1996
  Item_result result_type; /**< Type of item */
 
1997
  bool reverse; /**< if descending sort */
 
1998
  bool need_strxnfrm;   /**< If we have to use strxnfrm() */
 
1999
 
 
2000
  SortField() :
 
2001
    field(0),
 
2002
    item(0),
 
2003
    length(0),
 
2004
    suffix_length(0),
 
2005
    result_type(STRING_RESULT),
 
2006
    reverse(0),
 
2007
    need_strxnfrm(0)
 
2008
  { }
 
2009
 
 
2010
};
 
2011
 
 
2012
} /* namespace drizzled */
 
2013
 
 
2014
/** @TODO why is this in the middle of the file */
 
2015
 
 
2016
#include <drizzled/table_ident.h>
 
2017
#include <drizzled/user_var_entry.h>
 
2018
#include <drizzled/unique.h>
 
2019
#include <drizzled/var.h>
 
2020
#include <drizzled/select_dumpvar.h>
 
2021
 
 
2022
namespace drizzled
 
2023
{
 
2024
 
1677
2025
/* Bits in sql_command_flags */
1678
2026
 
1679
2027
enum sql_command_flag_bits 
1695
2043
namespace display  {
1696
2044
const std::string &type(drizzled::Session::global_read_lock_t type);
1697
2045
size_t max_string_length(drizzled::Session::global_read_lock_t type);
1698
 
 
1699
2046
} /* namespace display */
1700
2047
 
1701
2048
} /* namespace drizzled */