← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/session.cc

  • Committer: Brian Aker
  • Date: 2010-02-07 01:33:54 UTC
  • Revision ID: brian@gaz-20100207013354-d2pg1n68u5c09pgo
Remove giant include header to its own file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/session.cc
1
 
/* Copyright (C) 2000-2006 MySQL AB
2
 
 
3
 
   This program is free software; you can redistribute it and/or modify
4
 
   it under the terms of the GNU General Public License as published by
5
 
   the Free Software Foundation; version 2 of the License.
6
 
 
7
 
   This program is distributed in the hope that it will be useful,
8
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
9
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10
 
   GNU General Public License for more details.
11
 
 
12
 
   You should have received a copy of the GNU General Public License
13
 
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
 
 
16
 
 
17
 
/*****************************************************************************
18
 
**
19
 
** This file implements classes defined in sql_class.h
20
 
** Especially the classes to handle a result from a select
21
 
**
22
 
*****************************************************************************/
23
 
#include <drizzled/server_includes.h>
24
 
#include "rpl_rli.h"
25
 
#include "rpl_record.h"
26
 
#include "log_event.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
 
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
/**
 
21
 * @file Implementation of the Session class and API
 
22
 */
 
23
 
 
24
#include "config.h"
 
25
#include <drizzled/session.h>
 
26
#include "drizzled/session_list.h"
27
27
#include <sys/stat.h>
28
 
#include <mysys/thr_alarm.h>
29
 
#include <mysys/mysys_err.h>
30
 
#include <drizzled/drizzled_error_messages.h>
 
28
#include "drizzled/my_error.h"
 
29
#include <drizzled/error.h>
 
30
#include <drizzled/gettext.h>
 
31
#include <drizzled/query_id.h>
 
32
#include <drizzled/data_home.h>
 
33
#include <drizzled/sql_base.h>
 
34
#include <drizzled/lock.h>
 
35
#include <drizzled/item/cache.h>
 
36
#include <drizzled/item/float.h>
 
37
#include <drizzled/item/return_int.h>
 
38
#include <drizzled/item/empty_string.h>
 
39
#include <drizzled/show.h>
 
40
#include <drizzled/plugin/client.h>
 
41
#include "drizzled/plugin/scheduler.h"
 
42
#include "drizzled/plugin/authentication.h"
 
43
#include "drizzled/probes.h"
 
44
#include "drizzled/table_proto.h"
 
45
#include "drizzled/db.h"
 
46
#include "drizzled/pthread_globals.h"
 
47
#include "drizzled/transaction_services.h"
 
48
 
 
49
#include "plugin/myisam/myisam.h"
 
50
#include "drizzled/internal/iocache.h"
 
51
 
 
52
#include <fcntl.h>
 
53
#include <algorithm>
 
54
#include <climits>
 
55
 
 
56
using namespace std;
 
57
namespace drizzled
 
58
{
 
59
 
 
60
extern "C"
 
61
{
 
62
  unsigned char *get_var_key(user_var_entry *entry, size_t *length, bool );
 
63
  void free_user_var(user_var_entry *entry);
 
64
}
31
65
 
32
66
/*
33
67
  The following is used to initialise Table_ident with a internal
36
70
char internal_table_name[2]= "*";
37
71
char empty_c_string[1]= {0};    /* used for not defined db */
38
72
 
39
 
const char * const THD::DEFAULT_WHERE= "field list";
40
 
 
41
 
 
42
 
/*****************************************************************************
43
 
** Instansiate templates
44
 
*****************************************************************************/
45
 
 
46
 
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
47
 
/* Used templates */
48
 
template class List<Key>;
49
 
template class List_iterator<Key>;
50
 
template class List<Key_part_spec>;
51
 
template class List_iterator<Key_part_spec>;
52
 
template class List<Alter_drop>;
53
 
template class List_iterator<Alter_drop>;
54
 
template class List<Alter_column>;
55
 
template class List_iterator<Alter_column>;
56
 
#endif
 
73
const char * const Session::DEFAULT_WHERE= "field list";
 
74
extern pthread_key_t THR_Session;
 
75
extern pthread_key_t THR_Mem_root;
 
76
extern uint32_t max_used_connections;
 
77
extern atomic<uint32_t> connection_count;
 
78
 
57
79
 
58
80
/****************************************************************************
59
81
** User variables
60
82
****************************************************************************/
61
 
 
62
 
extern "C" uchar *get_var_key(user_var_entry *entry, size_t *length,
63
 
                              bool not_used __attribute__((unused)))
 
83
unsigned char *get_var_key(user_var_entry *entry, size_t *length, bool )
64
84
{
65
85
  *length= entry->name.length;
66
 
  return (uchar*) entry->name.str;
 
86
  return (unsigned char*) entry->name.str;
67
87
}
68
88
 
69
 
extern "C" void free_user_var(user_var_entry *entry)
 
89
void free_user_var(user_var_entry *entry)
70
90
{
71
 
  char *pos= (char*) entry+ALIGN_SIZE(sizeof(*entry));
72
 
  if (entry->value && entry->value != pos)
73
 
    my_free(entry->value, MYF(0));
74
 
  my_free((char*) entry,MYF(0));
 
91
  delete entry;
75
92
}
76
93
 
77
94
bool Key_part_spec::operator==(const Key_part_spec& other) const
81
98
         !strcmp(field_name.str, other.field_name.str);
82
99
}
83
100
 
84
 
/**
85
 
  Construct an (almost) deep copy of this key. Only those
86
 
  elements that are known to never change are not copied.
87
 
  If out of memory, a partial copy is returned and an error is set
88
 
  in THD.
89
 
*/
90
 
 
91
 
Key::Key(const Key &rhs, MEM_ROOT *mem_root)
92
 
  :type(rhs.type),
93
 
  key_create_info(rhs.key_create_info),
94
 
  columns(rhs.columns, mem_root),
95
 
  name(rhs.name),
96
 
  generated(rhs.generated)
97
 
{
98
 
  list_copy_and_replace_each_value(columns, mem_root);
99
 
}
100
 
 
101
 
/**
102
 
  Construct an (almost) deep copy of this foreign key. Only those
103
 
  elements that are known to never change are not copied.
104
 
  If out of memory, a partial copy is returned and an error is set
105
 
  in THD.
106
 
*/
107
 
 
108
 
Foreign_key::Foreign_key(const Foreign_key &rhs, MEM_ROOT *mem_root)
109
 
  :Key(rhs),
110
 
  ref_table(rhs.ref_table),
111
 
  ref_columns(rhs.ref_columns),
112
 
  delete_opt(rhs.delete_opt),
113
 
  update_opt(rhs.update_opt),
114
 
  match_opt(rhs.match_opt)
115
 
{
116
 
  list_copy_and_replace_each_value(ref_columns, mem_root);
117
 
}
118
 
 
119
 
/*
120
 
  Test if a foreign key (= generated key) is a prefix of the given key
121
 
  (ignoring key name, key type and order of columns)
122
 
 
123
 
  NOTES:
124
 
    This is only used to test if an index for a FOREIGN KEY exists
125
 
 
126
 
  IMPLEMENTATION
127
 
    We only compare field names
128
 
 
129
 
  RETURN
130
 
    0   Generated key is a prefix of other key
131
 
    1   Not equal
132
 
*/
133
 
 
134
 
bool foreign_key_prefix(Key *a, Key *b)
135
 
{
136
 
  /* Ensure that 'a' is the generated key */
137
 
  if (a->generated)
138
 
  {
139
 
    if (b->generated && a->columns.elements > b->columns.elements)
140
 
      swap_variables(Key*, a, b);               // Put shorter key in 'a'
141
 
  }
142
 
  else
143
 
  {
144
 
    if (!b->generated)
145
 
      return true;                              // No foreign key
146
 
    swap_variables(Key*, a, b);                 // Put generated key in 'a'
147
 
  }
148
 
 
149
 
  /* Test if 'a' is a prefix of 'b' */
150
 
  if (a->columns.elements > b->columns.elements)
151
 
    return true;                                // Can't be prefix
152
 
 
153
 
  List_iterator<Key_part_spec> col_it1(a->columns);
154
 
  List_iterator<Key_part_spec> col_it2(b->columns);
155
 
  const Key_part_spec *col1, *col2;
156
 
 
157
 
#ifdef ENABLE_WHEN_INNODB_CAN_HANDLE_SWAPED_FOREIGN_KEY_COLUMNS
158
 
  while ((col1= col_it1++))
159
 
  {
160
 
    bool found= 0;
161
 
    col_it2.rewind();
162
 
    while ((col2= col_it2++))
163
 
    {
164
 
      if (*col1 == *col2)
165
 
      {
166
 
        found= true;
167
 
        break;
168
 
      }
169
 
    }
170
 
    if (!found)
171
 
      return true;                              // Error
172
 
  }
173
 
  return false;                                 // Is prefix
174
 
#else
175
 
  while ((col1= col_it1++))
176
 
  {
177
 
    col2= col_it2++;
178
 
    if (!(*col1 == *col2))
179
 
      return true;
180
 
  }
181
 
  return false;                                 // Is prefix
182
 
#endif
183
 
}
184
 
 
185
 
 
186
 
/****************************************************************************
187
 
** Thread specific functions
188
 
****************************************************************************/
189
 
 
190
 
Open_tables_state::Open_tables_state(ulong version_arg)
191
 
  :version(version_arg), state_flags(0U)
 
101
Open_tables_state::Open_tables_state(uint64_t version_arg)
 
102
  :version(version_arg), backups_available(false)
192
103
{
193
104
  reset_open_tables_state();
194
105
}
196
107
/*
197
108
  The following functions form part of the C plugin API
198
109
*/
199
 
 
200
110
extern "C" int mysql_tmpfile(const char *prefix)
201
111
{
202
112
  char filename[FN_REFLEN];
203
 
  File fd = create_temp_file(filename, mysql_tmpdir, prefix,
204
 
                             O_CREAT | O_EXCL | O_RDWR | O_TEMPORARY,
205
 
                             MYF(MY_WME));
 
113
  int fd = internal::create_temp_file(filename, drizzle_tmpdir, prefix, MYF(MY_WME));
206
114
  if (fd >= 0) {
207
 
    /*
208
 
      This can be removed once the following bug is fixed:
209
 
      Bug #28903  create_temp_file() doesn't honor O_TEMPORARY option
210
 
                  (file not removed) (Unix)
211
 
    */
212
115
    unlink(filename);
213
116
  }
214
117
 
215
118
  return fd;
216
119
}
217
120
 
218
 
 
219
 
extern "C"
220
 
int thd_in_lock_tables(const THD *thd)
221
 
{
222
 
  return test(thd->in_lock_tables);
223
 
}
224
 
 
225
 
 
226
 
extern "C"
227
 
int thd_tablespace_op(const THD *thd)
228
 
{
229
 
  return test(thd->tablespace_op);
230
 
}
231
 
 
232
 
 
233
 
extern "C"
234
 
const char *set_thd_proc_info(THD *thd, const char *info,
235
 
                              const char *calling_function __attribute__((unused)),
236
 
                              const char *calling_file __attribute__((unused)),
237
 
                              const unsigned int calling_line __attribute__((unused)))
238
 
{
239
 
  const char *old_info= thd->proc_info;
240
 
  thd->proc_info= info;
241
 
  return old_info;
242
 
}
243
 
 
244
 
extern "C"
245
 
void **thd_ha_data(const THD *thd, const struct handlerton *hton)
246
 
{
247
 
  return (void **) &thd->ha_data[hton->slot].ha_ptr;
248
 
}
249
 
 
250
 
extern "C"
251
 
int64_t thd_test_options(const THD *thd, int64_t test_options)
252
 
{
253
 
  return thd->options & test_options;
254
 
}
255
 
 
256
 
extern "C"
257
 
int thd_sql_command(const THD *thd)
258
 
{
259
 
  return (int) thd->lex->sql_command;
260
 
}
261
 
 
262
 
extern "C"
263
 
int thd_tx_isolation(const THD *thd)
264
 
{
265
 
  return (int) thd->variables.tx_isolation;
266
 
}
267
 
 
268
 
extern "C"
269
 
void thd_inc_row_count(THD *thd)
270
 
{
271
 
  thd->row_count++;
272
 
}
273
 
 
274
 
/**
275
 
  Clear this diagnostics area. 
276
 
 
277
 
  Normally called at the end of a statement.
278
 
*/
279
 
 
280
 
void
281
 
Diagnostics_area::reset_diagnostics_area()
282
 
{
283
 
  can_overwrite_status= false;
284
 
  /** Don't take chances in production */
285
 
  m_message[0]= '\0';
286
 
  m_sql_errno= 0;
287
 
  m_server_status= 0;
288
 
  m_affected_rows= 0;
289
 
  m_last_insert_id= 0;
290
 
  m_total_warn_count= 0;
291
 
  is_sent= false;
292
 
  /** Tiny reset in debug mode to see garbage right away */
293
 
  m_status= DA_EMPTY;
294
 
}
295
 
 
296
 
 
297
 
/**
298
 
  Set OK status -- ends commands that do not return a
299
 
  result set, e.g. INSERT/UPDATE/DELETE.
300
 
*/
301
 
 
302
 
void
303
 
Diagnostics_area::set_ok_status(THD *thd, ha_rows affected_rows_arg,
304
 
                                uint64_t last_insert_id_arg,
305
 
                                const char *message_arg)
306
 
{
307
 
  assert(! is_set());
308
 
  /*
309
 
    In production, refuse to overwrite an error or a custom response
310
 
    with an OK packet.
311
 
  */
312
 
  if (is_error() || is_disabled())
313
 
    return;
314
 
  /** Only allowed to report success if has not yet reported an error */
315
 
 
316
 
  m_server_status= thd->server_status;
317
 
  m_total_warn_count= thd->total_warn_count;
318
 
  m_affected_rows= affected_rows_arg;
319
 
  m_last_insert_id= last_insert_id_arg;
320
 
  if (message_arg)
321
 
    strmake(m_message, message_arg, sizeof(m_message) - 1);
322
 
  else
323
 
    m_message[0]= '\0';
324
 
  m_status= DA_OK;
325
 
}
326
 
 
327
 
 
328
 
/**
329
 
  Set EOF status.
330
 
*/
331
 
 
332
 
void
333
 
Diagnostics_area::set_eof_status(THD *thd)
334
 
{
335
 
  /** Only allowed to report eof if has not yet reported an error */
336
 
 
337
 
  assert(! is_set());
338
 
  /*
339
 
    In production, refuse to overwrite an error or a custom response
340
 
    with an EOF packet.
341
 
  */
342
 
  if (is_error() || is_disabled())
343
 
    return;
344
 
 
345
 
  m_server_status= thd->server_status;
346
 
  /*
347
 
    If inside a stored procedure, do not return the total
348
 
    number of warnings, since they are not available to the client
349
 
    anyway.
350
 
  */
351
 
  m_total_warn_count= thd->total_warn_count;
352
 
 
353
 
  m_status= DA_EOF;
354
 
}
355
 
 
356
 
/**
357
 
  Set ERROR status.
358
 
*/
359
 
 
360
 
void
361
 
Diagnostics_area::set_error_status(THD *thd __attribute__((unused)),
362
 
                                   uint sql_errno_arg,
363
 
                                   const char *message_arg)
364
 
{
365
 
  /*
366
 
    Only allowed to report error if has not yet reported a success
367
 
    The only exception is when we flush the message to the client,
368
 
    an error can happen during the flush.
369
 
  */
370
 
  assert(! is_set() || can_overwrite_status);
371
 
  /*
372
 
    In production, refuse to overwrite a custom response with an
373
 
    ERROR packet.
374
 
  */
375
 
  if (is_disabled())
376
 
    return;
377
 
 
378
 
  m_sql_errno= sql_errno_arg;
379
 
  strmake(m_message, message_arg, sizeof(m_message) - 1);
380
 
 
381
 
  m_status= DA_ERROR;
382
 
}
383
 
 
384
 
 
385
 
/**
386
 
  Mark the diagnostics area as 'DISABLED'.
387
 
 
388
 
  This is used in rare cases when the COM_ command at hand sends a response
389
 
  in a custom format. One example is the query cache, another is
390
 
  COM_STMT_PREPARE.
391
 
*/
392
 
 
393
 
void
394
 
Diagnostics_area::disable_status()
395
 
{
396
 
  assert(! is_set());
397
 
  m_status= DA_DISABLED;
398
 
}
399
 
 
400
 
 
401
 
THD::THD()
402
 
   :Statement(&main_lex, &main_mem_root, CONVENTIONAL_EXECUTION,
403
 
              /* statement id */ 0),
404
 
   Open_tables_state(refresh_version), rli_fake(0),
405
 
   lock_id(&main_lock_id),
406
 
   user_time(0), in_sub_stmt(0),
407
 
   binlog_table_maps(0), binlog_flags(0UL),
408
 
   arg_of_last_insert_id_function(false),
409
 
   first_successful_insert_id_in_prev_stmt(0),
410
 
   first_successful_insert_id_in_prev_stmt_for_binlog(0),
411
 
   first_successful_insert_id_in_cur_stmt(0),
412
 
   stmt_depends_on_first_successful_insert_id_in_prev_stmt(false),
413
 
   global_read_lock(0),
414
 
   is_fatal_error(0),
415
 
   transaction_rollback_request(0),
416
 
   is_fatal_sub_stmt_error(0),
417
 
   rand_used(0),
418
 
   time_zone_used(0),
419
 
   in_lock_tables(0),
420
 
   bootstrap(0),
421
 
   derived_tables_processing(false),
422
 
   m_lip(NULL)
423
 
{
424
 
  ulong tmp;
 
121
extern "C"
 
122
int session_tablespace_op(const Session *session)
 
123
{
 
124
  return test(session->tablespace_op);
 
125
}
 
126
 
 
127
/**
 
128
   Set the process info field of the Session structure.
 
129
 
 
130
   This function is used by plug-ins. Internally, the
 
131
   Session::set_proc_info() function should be used.
 
132
 
 
133
   @see Session::set_proc_info
 
134
 */
 
135
extern "C" void
 
136
set_session_proc_info(Session *session, const char *info)
 
137
{
 
138
  session->set_proc_info(info);
 
139
}
 
140
 
 
141
extern "C"
 
142
const char *get_session_proc_info(Session *session)
 
143
{
 
144
  return session->get_proc_info();
 
145
}
 
146
 
 
147
void **Session::getEngineData(const plugin::StorageEngine *engine)
 
148
{
 
149
  return static_cast<void **>(&ha_data[engine->slot].ha_ptr);
 
150
}
 
151
 
 
152
Ha_trx_info *Session::getEngineInfo(const plugin::StorageEngine *engine,
 
153
                                    size_t index)
 
154
{
 
155
  return &ha_data[engine->getSlot()].ha_info[index];
 
156
}
 
157
 
 
158
extern "C"
 
159
int64_t session_test_options(const Session *session, int64_t test_options)
 
160
{
 
161
  return session->options & test_options;
 
162
}
 
163
 
 
164
extern "C"
 
165
int session_sql_command(const Session *session)
 
166
{
 
167
  return (int) session->lex->sql_command;
 
168
}
 
169
 
 
170
extern "C"
 
171
int session_tx_isolation(const Session *session)
 
172
{
 
173
  return (int) session->variables.tx_isolation;
 
174
}
 
175
 
 
176
Session::Session(plugin::Client *client_arg)
 
177
  :
 
178
  Open_tables_state(refresh_version),
 
179
  mem_root(&main_mem_root),
 
180
  lex(&main_lex),
 
181
  client(client_arg),
 
182
  scheduler(NULL),
 
183
  scheduler_arg(NULL),
 
184
  lock_id(&main_lock_id),
 
185
  user_time(0),
 
186
  arg_of_last_insert_id_function(false),
 
187
  first_successful_insert_id_in_prev_stmt(0),
 
188
  first_successful_insert_id_in_cur_stmt(0),
 
189
  limit_found_rows(0),
 
190
  global_read_lock(0),
 
191
  some_tables_deleted(false),
 
192
  no_errors(false),
 
193
  password(false),
 
194
  is_fatal_error(false),
 
195
  transaction_rollback_request(false),
 
196
  is_fatal_sub_stmt_error(0),
 
197
  derived_tables_processing(false),
 
198
  tablespace_op(false),
 
199
  m_lip(NULL),
 
200
  cached_table(0),
 
201
  transaction_message(NULL),
 
202
  statement_message(NULL)
 
203
{
 
204
  memset(process_list_info, 0, PROCESS_LIST_WIDTH);
 
205
  client->setSession(this);
425
206
 
426
207
  /*
427
208
    Pass nominal parameters to init_alloc_root only to ensure that
428
209
    the destructor works OK in case of an error. The main_mem_root
429
210
    will be re-initialized in init_for_queries().
430
211
  */
431
 
  init_sql_alloc(&main_mem_root, ALLOC_ROOT_MIN_BLOCK_SIZE, 0);
432
 
  stmt_arena= this;
433
 
  thread_stack= 0;
434
 
  catalog= (char*)"std"; // the only catalog we have for now
435
 
  main_security_ctx.init();
436
 
  security_ctx= &main_security_ctx;
437
 
  some_tables_deleted=no_errors=password= 0;
438
 
  query_start_used= 0;
 
212
  memory::init_sql_alloc(&main_mem_root, memory::ROOT_MIN_BLOCK_SIZE, 0);
 
213
  thread_stack= NULL;
439
214
  count_cuted_fields= CHECK_FIELD_IGNORE;
440
215
  killed= NOT_KILLED;
441
 
  col_access=0;
442
 
  is_slave_error= thread_specific_used= false;
443
 
  hash_clear(&handler_tables_hash);
444
 
  tmp_table=0;
445
 
  used_tables=0;
 
216
  col_access= 0;
 
217
  tmp_table= 0;
 
218
  used_tables= 0;
446
219
  cuted_fields= sent_row_count= row_count= 0L;
447
 
  limit_found_rows= 0;
448
220
  row_count_func= -1;
449
221
  statement_id_counter= 0UL;
450
 
  // Must be reset to handle error with THD's created for init of mysqld
 
222
  // Must be reset to handle error with Session's created for init of mysqld
451
223
  lex->current_select= 0;
452
224
  start_time=(time_t) 0;
453
225
  start_utime= 0L;
454
226
  utime_after_lock= 0L;
455
 
  current_linfo =  0;
456
 
  slave_thread = 0;
457
227
  memset(&variables, 0, sizeof(variables));
458
228
  thread_id= 0;
459
 
  one_shot_set= 0;
460
229
  file_id = 0;
461
230
  query_id= 0;
462
 
  warn_id= 0;
463
 
  db_charset= global_system_variables.collation_database;
 
231
  query= NULL;
 
232
  query_length= 0;
 
233
  warn_query_id= 0;
464
234
  memset(ha_data, 0, sizeof(ha_data));
465
 
  mysys_var=0;
466
 
  binlog_evt_union.do_union= false;
467
 
  enable_slow_log= 0;
468
 
  dbug_sentry=THD_SENTRY_MAGIC;
469
 
  net.vio=0;
470
 
  client_capabilities= 0;                       // minimalistic client
471
 
  system_thread= NON_SYSTEM_THREAD;
472
 
  cleanup_done= abort_on_warning= no_warnings_for_error= 0;
473
 
  peer_port= 0;                                 // For SHOW PROCESSLIST
474
 
  transaction.m_pending_rows_event= 0;
475
 
  transaction.on= 1;
476
 
#ifdef SIGNAL_WITH_VIO_CLOSE
477
 
  active_vio = 0;
478
 
#endif
 
235
  mysys_var= 0;
 
236
  dbug_sentry=Session_SENTRY_MAGIC;
 
237
  cleanup_done= abort_on_warning= no_warnings_for_error= false;
479
238
  pthread_mutex_init(&LOCK_delete, MY_MUTEX_INIT_FAST);
480
239
 
481
240
  /* Variables with default values */
482
241
  proc_info="login";
483
 
  where= THD::DEFAULT_WHERE;
484
 
  server_id = ::server_id;
485
 
  slave_net = 0;
486
 
  command=COM_CONNECT;
487
 
  *scramble= '\0';
488
 
 
489
 
  init();
 
242
  where= Session::DEFAULT_WHERE;
 
243
  command= COM_CONNECT;
 
244
 
 
245
  plugin_sessionvar_init(this);
 
246
  /*
 
247
    variables= global_system_variables above has reset
 
248
    variables.pseudo_thread_id to 0. We need to correct it here to
 
249
    avoid temporary tables replication failure.
 
250
  */
 
251
  variables.pseudo_thread_id= thread_id;
 
252
  server_status= SERVER_STATUS_AUTOCOMMIT;
 
253
  options= session_startup_options;
 
254
 
 
255
  if (variables.max_join_size == HA_POS_ERROR)
 
256
    options |= OPTION_BIG_SELECTS;
 
257
  else
 
258
    options &= ~OPTION_BIG_SELECTS;
 
259
 
 
260
  transaction.all.modified_non_trans_table= transaction.stmt.modified_non_trans_table= false;
 
261
  open_options=ha_open_options;
 
262
  update_lock_default= TL_WRITE;
 
263
  session_tx_isolation= (enum_tx_isolation) variables.tx_isolation;
 
264
  warn_list.empty();
 
265
  memset(warn_count, 0, sizeof(warn_count));
 
266
  total_warn_count= 0;
 
267
  memset(&status_var, 0, sizeof(status_var));
 
268
 
490
269
  /* Initialize sub structures */
491
 
  init_sql_alloc(&warn_root, WARN_ALLOC_BLOCK_SIZE, WARN_ALLOC_PREALLOC_SIZE);
492
 
  user_connect=(USER_CONN *)0;
 
270
  memory::init_sql_alloc(&warn_root, WARN_ALLOC_BLOCK_SIZE, WARN_ALLOC_PREALLOC_SIZE);
493
271
  hash_init(&user_vars, system_charset_info, USER_VARS_HASH_SIZE, 0, 0,
494
272
            (hash_get_key) get_var_key,
495
273
            (hash_free_key) free_user_var, 0);
496
274
 
497
 
  /* For user vars replication*/
498
 
  if (opt_bin_log)
499
 
    my_init_dynamic_array(&user_var_events,
500
 
                          sizeof(BINLOG_USER_VAR_EVENT *), 16, 16);
501
 
  else
502
 
    memset(&user_var_events, 0, sizeof(user_var_events));
503
 
 
504
 
  /* Protocol */
505
 
  protocol= &protocol_text;                     // Default protocol
506
 
  protocol_text.init(this);
507
 
 
508
 
  tablespace_op= false;
509
 
  tmp= sql_rnd();
510
 
  randominit(&rand, tmp + (ulong) &rand, tmp + (ulong) ::global_query_id);
511
275
  substitute_null_with_insert_id = false;
512
276
  thr_lock_info_init(&lock_info); /* safety: will be reset after start */
513
277
  thr_lock_owner_init(&main_lock_id, &lock_info);
515
279
  m_internal_handler= NULL;
516
280
}
517
281
 
 
282
void Session::free_items()
 
283
{
 
284
  Item *next;
 
285
  /* This works because items are allocated with memory::sql_alloc() */
 
286
  for (; free_list; free_list= next)
 
287
  {
 
288
    next= free_list->next;
 
289
    free_list->delete_self();
 
290
  }
 
291
}
518
292
 
519
 
void THD::push_internal_handler(Internal_error_handler *handler)
 
293
void Session::push_internal_handler(Internal_error_handler *handler)
520
294
{
521
295
  /*
522
296
    TODO: The current implementation is limited to 1 handler at a time only.
523
 
    THD and sp_rcontext need to be modified to use a common handler stack.
 
297
    Session and sp_rcontext need to be modified to use a common handler stack.
524
298
  */
525
299
  assert(m_internal_handler == NULL);
526
300
  m_internal_handler= handler;
527
301
}
528
302
 
529
 
 
530
 
bool THD::handle_error(uint sql_errno, const char *message,
 
303
bool Session::handle_error(uint32_t sql_errno, const char *message,
531
304
                       DRIZZLE_ERROR::enum_warning_level level)
532
305
{
533
306
  if (m_internal_handler)
538
311
  return false;                                 // 'false', as per coding style
539
312
}
540
313
 
541
 
 
542
 
void THD::pop_internal_handler()
 
314
void Session::pop_internal_handler()
543
315
{
544
316
  assert(m_internal_handler != NULL);
545
317
  m_internal_handler= NULL;
546
318
}
547
319
 
548
 
extern "C"
549
 
void *thd_alloc(DRIZZLE_THD thd, unsigned int size)
550
 
{
551
 
  return thd->alloc(size);
552
 
}
553
 
 
554
 
extern "C"
555
 
void *thd_calloc(DRIZZLE_THD thd, unsigned int size)
556
 
{
557
 
  return thd->calloc(size);
558
 
}
559
 
 
560
 
extern "C"
561
 
char *thd_strdup(DRIZZLE_THD thd, const char *str)
562
 
{
563
 
  return thd->strdup(str);
564
 
}
565
 
 
566
 
extern "C"
567
 
char *thd_strmake(DRIZZLE_THD thd, const char *str, unsigned int size)
568
 
{
569
 
  return thd->strmake(str, size);
570
 
}
571
 
 
572
 
extern "C"
573
 
LEX_STRING *thd_make_lex_string(THD *thd, LEX_STRING *lex_str,
574
 
                                const char *str, unsigned int size,
575
 
                                int allocate_lex_string)
576
 
{
577
 
  return thd->make_lex_string(lex_str, str, size,
578
 
                              (bool) allocate_lex_string);
579
 
}
580
 
 
581
 
extern "C"
582
 
void *thd_memdup(DRIZZLE_THD thd, const void* str, unsigned int size)
583
 
{
584
 
  return thd->memdup(str, size);
585
 
}
586
 
 
587
 
extern "C"
588
 
void thd_get_xid(const DRIZZLE_THD thd, DRIZZLE_XID *xid)
589
 
{
590
 
  *xid = *(DRIZZLE_XID *) &thd->transaction.xid_state.xid;
591
 
}
592
 
 
593
 
/*
594
 
  Init common variables that has to be reset on start and on change_user
595
 
*/
596
 
 
597
 
void THD::init(void)
598
 
{
599
 
  pthread_mutex_lock(&LOCK_global_system_variables);
600
 
  plugin_thdvar_init(this);
601
 
  variables.time_format= date_time_format_copy((THD*) 0,
602
 
                                               variables.time_format);
603
 
  variables.date_format= date_time_format_copy((THD*) 0,
604
 
                                               variables.date_format);
605
 
  variables.datetime_format= date_time_format_copy((THD*) 0,
606
 
                                                   variables.datetime_format);
607
 
  /*
608
 
    variables= global_system_variables above has reset
609
 
    variables.pseudo_thread_id to 0. We need to correct it here to
610
 
    avoid temporary tables replication failure.
611
 
  */
612
 
  variables.pseudo_thread_id= thread_id;
613
 
  pthread_mutex_unlock(&LOCK_global_system_variables);
614
 
  server_status= SERVER_STATUS_AUTOCOMMIT;
615
 
  options= thd_startup_options;
616
 
 
617
 
  if (variables.max_join_size == HA_POS_ERROR)
618
 
    options |= OPTION_BIG_SELECTS;
619
 
  else
620
 
    options &= ~OPTION_BIG_SELECTS;
621
 
 
622
 
  transaction.all.modified_non_trans_table= transaction.stmt.modified_non_trans_table= false;
623
 
  open_options=ha_open_options;
624
 
  update_lock_default= (variables.low_priority_updates ?
625
 
                        TL_WRITE_LOW_PRIORITY :
626
 
                        TL_WRITE);
627
 
  session_tx_isolation= (enum_tx_isolation) variables.tx_isolation;
628
 
  warn_list.empty();
629
 
  memset(warn_count, 0, sizeof(warn_count));
630
 
  total_warn_count= 0;
631
 
  update_charset();
632
 
  reset_current_stmt_binlog_row_based();
633
 
  memset(&status_var, 0, sizeof(status_var));
634
 
}
635
 
 
636
 
 
637
 
/*
638
 
  Init THD for query processing.
639
 
  This has to be called once before we call mysql_parse.
640
 
  See also comments in sql_class.h.
641
 
*/
642
 
 
643
 
void THD::init_for_queries()
644
 
{
645
 
  set_time(); 
646
 
  ha_enable_transaction(this,true);
647
 
 
648
 
  reset_root_defaults(mem_root, variables.query_alloc_block_size,
649
 
                      variables.query_prealloc_size);
650
 
  reset_root_defaults(&transaction.mem_root,
651
 
                      variables.trans_alloc_block_size,
652
 
                      variables.trans_prealloc_size);
653
 
  transaction.xid_state.xid.null();
654
 
  transaction.xid_state.in_thd=1;
655
 
}
656
 
 
 
320
#if defined(__cplusplus)
 
321
extern "C" {
 
322
#endif
 
323
 
 
324
void *session_alloc(Session *session, unsigned int size)
 
325
{
 
326
  return session->alloc(size);
 
327
}
 
328
 
 
329
void *session_calloc(Session *session, unsigned int size)
 
330
{
 
331
  return session->calloc(size);
 
332
}
 
333
 
 
334
char *session_strdup(Session *session, const char *str)
 
335
{
 
336
  return session->strdup(str);
 
337
}
 
338
 
 
339
char *session_strmake(Session *session, const char *str, unsigned int size)
 
340
{
 
341
  return session->strmake(str, size);
 
342
}
 
343
 
 
344
void *session_memdup(Session *session, const void* str, unsigned int size)
 
345
{
 
346
  return session->memdup(str, size);
 
347
}
 
348
 
 
349
void session_get_xid(const Session *session, DRIZZLE_XID *xid)
 
350
{
 
351
  *xid = *(DRIZZLE_XID *) &session->transaction.xid_state.xid;
 
352
}
 
353
 
 
354
#if defined(__cplusplus)
 
355
}
 
356
#endif
657
357
 
658
358
/* Do operations that may take a long time */
659
359
 
660
 
void THD::cleanup(void)
 
360
void Session::cleanup(void)
661
361
{
662
 
  assert(cleanup_done == 0);
 
362
  assert(cleanup_done == false);
663
363
 
664
364
  killed= KILL_CONNECTION;
665
365
#ifdef ENABLE_WHEN_BINLOG_WILL_BE_ABLE_TO_PREPARE
669
369
  }
670
370
#endif
671
371
  {
672
 
    ha_rollback(this);
 
372
    TransactionServices &transaction_services= TransactionServices::singleton();
 
373
    transaction_services.ha_rollback_trans(this, true);
673
374
    xid_cache_delete(&transaction.xid_state);
674
375
  }
675
 
  if (locked_tables)
676
 
  {
677
 
    lock=locked_tables; locked_tables=0;
678
 
    close_thread_tables(this);
679
 
  }
680
 
  mysql_ha_cleanup(this);
681
 
  delete_dynamic(&user_var_events);
682
376
  hash_free(&user_vars);
683
 
  close_temporary_tables(this);
684
 
  my_free((char*) variables.time_format, MYF(MY_ALLOW_ZERO_PTR));
685
 
  my_free((char*) variables.date_format, MYF(MY_ALLOW_ZERO_PTR));
686
 
  my_free((char*) variables.datetime_format, MYF(MY_ALLOW_ZERO_PTR));
687
 
  
 
377
  close_temporary_tables();
 
378
 
688
379
  if (global_read_lock)
689
380
    unlock_global_read_lock(this);
690
381
 
691
 
  cleanup_done=1;
692
 
  return;
 
382
  cleanup_done= true;
693
383
}
694
384
 
695
 
THD::~THD()
 
385
Session::~Session()
696
386
{
697
 
  THD_CHECK_SENTRY(this);
698
 
  /* Ensure that no one is using THD */
699
 
  pthread_mutex_lock(&LOCK_delete);
700
 
  pthread_mutex_unlock(&LOCK_delete);
 
387
  Session_CHECK_SENTRY(this);
701
388
  add_to_status(&global_status_var, &status_var);
702
389
 
 
390
  if (client->isConnected())
 
391
  {
 
392
    if (global_system_variables.log_warnings)
 
393
        errmsg_printf(ERRMSG_LVL_WARN, ER(ER_FORCING_CLOSE),internal::my_progname,
 
394
                      thread_id,
 
395
                      (security_ctx.user.c_str() ?
 
396
                       security_ctx.user.c_str() : ""));
 
397
    disconnect(0, false);
 
398
  }
 
399
 
703
400
  /* Close connection */
704
 
  if (net.vio)
705
 
  {
706
 
    vio_delete(net.vio);
707
 
    net_end(&net);
708
 
  }
709
 
  if (!cleanup_done)
 
401
  client->close();
 
402
  delete client;
 
403
 
 
404
  if (cleanup_done == false)
710
405
    cleanup();
711
406
 
712
 
  ha_close_connection(this);
713
 
  plugin_thdvar_cleanup(this);
 
407
  plugin::StorageEngine::closeConnection(this);
 
408
  plugin_sessionvar_cleanup(this);
714
409
 
715
 
  main_security_ctx.destroy();
716
 
  safeFree(db);
717
410
  free_root(&warn_root,MYF(0));
718
 
  free_root(&transaction.mem_root,MYF(0));
719
411
  mysys_var=0;                                  // Safety (shouldn't be needed)
 
412
  dbug_sentry= Session_SENTRY_GONE;
 
413
 
 
414
  free_root(&main_mem_root, MYF(0));
 
415
  pthread_setspecific(THR_Session,  0);
 
416
 
 
417
 
 
418
  /* Ensure that no one is using Session */
 
419
  pthread_mutex_unlock(&LOCK_delete);
720
420
  pthread_mutex_destroy(&LOCK_delete);
721
 
  dbug_sentry= THD_SENTRY_GONE;
722
 
  if (rli_fake)
723
 
  {
724
 
    delete rli_fake;
725
 
    rli_fake= NULL;
726
 
  }
727
 
  
728
 
  free_root(&main_mem_root, MYF(0));
729
 
  return;
730
421
}
731
422
 
732
 
 
733
423
/*
734
424
  Add all status variables to another status variable array
735
425
 
743
433
    If this assumption will change, then we have to explictely add
744
434
    the other variables after the while loop
745
435
*/
746
 
 
747
436
void add_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var)
748
437
{
749
 
  ulong *end= (ulong*) ((uchar*) to_var +
 
438
  ulong *end= (ulong*) ((unsigned char*) to_var +
750
439
                        offsetof(STATUS_VAR, last_system_status_var) +
751
440
                        sizeof(ulong));
752
441
  ulong *to= (ulong*) to_var, *from= (ulong*) from_var;
763
452
    to_var       add to this array
764
453
    from_var     from this array
765
454
    dec_var      minus this array
766
 
  
 
455
 
767
456
  NOTE
768
457
    This function assumes that all variables are long/ulong.
769
458
*/
770
 
 
771
459
void add_diff_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var,
772
460
                        STATUS_VAR *dec_var)
773
461
{
774
 
  ulong *end= (ulong*) ((uchar*) to_var + offsetof(STATUS_VAR,
 
462
  ulong *end= (ulong*) ((unsigned char*) to_var + offsetof(STATUS_VAR,
775
463
                                                  last_system_status_var) +
776
464
                        sizeof(ulong));
777
465
  ulong *to= (ulong*) to_var, *from= (ulong*) from_var, *dec= (ulong*) dec_var;
780
468
    *(to++)+= *(from++) - *(dec++);
781
469
}
782
470
 
783
 
 
784
 
void THD::awake(THD::killed_state state_to_set)
 
471
void Session::awake(Session::killed_state state_to_set)
785
472
{
786
 
  THD_CHECK_SENTRY(this);
787
 
  safe_mutex_assert_owner(&LOCK_delete); 
 
473
  Session_CHECK_SENTRY(this);
 
474
  safe_mutex_assert_owner(&LOCK_delete);
788
475
 
789
476
  killed= state_to_set;
790
 
  if (state_to_set != THD::KILL_QUERY)
 
477
  if (state_to_set != Session::KILL_QUERY)
791
478
  {
792
 
    thr_alarm_kill(thread_id);
793
 
    if (!slave_thread)
794
 
      thread_scheduler.post_kill_notification(this);
795
 
#ifdef SIGNAL_WITH_VIO_CLOSE
796
 
    if (this != current_thd)
797
 
    {
798
 
      /*
799
 
        In addition to a signal, let's close the socket of the thread that
800
 
        is being killed. This is to make sure it does not block if the
801
 
        signal is lost. This needs to be done only on platforms where
802
 
        signals are not a reliable interruption mechanism.
803
 
 
804
 
        If we're killing ourselves, we know that we're not blocked, so this
805
 
        hack is not used.
806
 
      */
807
 
 
808
 
      close_active_vio();
809
 
    }
810
 
#endif    
 
479
    scheduler->killSession(this);
 
480
    DRIZZLE_CONNECTION_DONE(thread_id);
811
481
  }
812
482
  if (mysys_var)
813
483
  {
814
484
    pthread_mutex_lock(&mysys_var->mutex);
815
 
    if (!system_thread)         // Don't abort locks
816
 
      mysys_var->abort=1;
817
485
    /*
818
486
      This broadcast could be up in the air if the victim thread
819
487
      exits the cond in the time between read and broadcast, but that is
830
498
      current_cond and current_mutex are 0), then the victim will not get
831
499
      a signal and it may wait "forever" on the cond (until
832
500
      we issue a second KILL or the status it's waiting for happens).
833
 
      It's true that we have set its thd->killed but it may not
 
501
      It's true that we have set its session->killed but it may not
834
502
      see it immediately and so may have time to reach the cond_wait().
835
503
    */
836
504
    if (mysys_var->current_cond && mysys_var->current_mutex)
841
509
    }
842
510
    pthread_mutex_unlock(&mysys_var->mutex);
843
511
  }
844
 
  return;
845
512
}
846
513
 
847
514
/*
848
515
  Remember the location of thread info, the structure needed for
849
 
  sql_alloc() and the structure for the net buffer
 
516
  memory::sql_alloc() and the structure for the net buffer
850
517
*/
851
 
 
852
 
bool THD::store_globals()
 
518
bool Session::storeGlobals()
853
519
{
854
520
  /*
855
521
    Assert that thread_stack is initialized: it's necessary to be able
857
523
  */
858
524
  assert(thread_stack);
859
525
 
860
 
  if (my_pthread_setspecific_ptr(THR_THD,  this) ||
861
 
      my_pthread_setspecific_ptr(THR_MALLOC, &mem_root))
862
 
    return 1;
 
526
  if (pthread_setspecific(THR_Session,  this) ||
 
527
      pthread_setspecific(THR_Mem_root, &mem_root))
 
528
    return true;
 
529
 
863
530
  mysys_var=my_thread_var;
 
531
 
864
532
  /*
865
533
    Let mysqld define the thread id (not mysys)
866
 
    This allows us to move THD to different threads if needed.
 
534
    This allows us to move Session to different threads if needed.
867
535
  */
868
536
  mysys_var->id= thread_id;
869
537
  real_id= pthread_self();                      // For debugging
870
538
 
871
539
  /*
872
 
    We have to call thr_lock_info_init() again here as THD may have been
 
540
    We have to call thr_lock_info_init() again here as Session may have been
873
541
    created in another thread
874
542
  */
875
543
  thr_lock_info_init(&lock_info);
876
 
  return 0;
 
544
  return false;
877
545
}
878
546
 
879
 
 
880
547
/*
881
 
  Cleanup after query.
882
 
 
883
 
  SYNOPSIS
884
 
    THD::cleanup_after_query()
885
 
 
886
 
  DESCRIPTION
887
 
    This function is used to reset thread data to its default state.
888
 
 
889
 
  NOTE
890
 
    This function is not suitable for setting thread data to some
891
 
    non-default values, as there is only one replication thread, so
892
 
    different master threads may overwrite data of each other on
893
 
    slave.
 
548
  Init Session for query processing.
 
549
  This has to be called once before we call mysql_parse.
 
550
  See also comments in session.h.
894
551
*/
895
552
 
896
 
void THD::cleanup_after_query()
897
 
{
898
 
  /*
899
 
    Reset rand_used so that detection of calls to rand() will save random 
 
553
void Session::prepareForQueries()
 
554
{
 
555
  if (variables.max_join_size == HA_POS_ERROR)
 
556
    options |= OPTION_BIG_SELECTS;
 
557
 
 
558
  version= refresh_version;
 
559
  set_proc_info(NULL);
 
560
  command= COM_SLEEP;
 
561
  set_time();
 
562
 
 
563
  reset_root_defaults(mem_root, variables.query_alloc_block_size,
 
564
                      variables.query_prealloc_size);
 
565
  transaction.xid_state.xid.null();
 
566
  transaction.xid_state.in_session=1;
 
567
}
 
568
 
 
569
bool Session::initGlobals()
 
570
{
 
571
  if (storeGlobals())
 
572
  {
 
573
    disconnect(ER_OUT_OF_RESOURCES, true);
 
574
    statistic_increment(aborted_connects, &LOCK_status);
 
575
    return true;
 
576
  }
 
577
  return false;
 
578
}
 
579
 
 
580
void Session::run()
 
581
{
 
582
  if (initGlobals() || authenticate())
 
583
  {
 
584
    disconnect(0, true);
 
585
    return;
 
586
  }
 
587
 
 
588
  prepareForQueries();
 
589
 
 
590
  while (! client->haveError() && killed != KILL_CONNECTION)
 
591
  {
 
592
    if (! executeStatement())
 
593
      break;
 
594
  }
 
595
 
 
596
  disconnect(0, true);
 
597
}
 
598
 
 
599
bool Session::schedule()
 
600
{
 
601
  scheduler= plugin::Scheduler::getScheduler();
 
602
  assert(scheduler);
 
603
 
 
604
  connection_count.increment();
 
605
 
 
606
  if (connection_count > max_used_connections)
 
607
    max_used_connections= connection_count;
 
608
 
 
609
  thread_id= variables.pseudo_thread_id= global_thread_id++;
 
610
 
 
611
  pthread_mutex_lock(&LOCK_thread_count);
 
612
  getSessionList().push_back(this);
 
613
  pthread_mutex_unlock(&LOCK_thread_count);
 
614
 
 
615
  if (scheduler->addSession(this))
 
616
  {
 
617
    DRIZZLE_CONNECTION_START(thread_id);
 
618
    char error_message_buff[DRIZZLE_ERRMSG_SIZE];
 
619
 
 
620
    killed= Session::KILL_CONNECTION;
 
621
 
 
622
    statistic_increment(aborted_connects, &LOCK_status);
 
623
 
 
624
    /* Can't use my_error() since store_globals has not been called. */
 
625
    /* TODO replace will better error message */
 
626
    snprintf(error_message_buff, sizeof(error_message_buff),
 
627
             ER(ER_CANT_CREATE_THREAD), 1);
 
628
    client->sendError(ER_CANT_CREATE_THREAD, error_message_buff);
 
629
    return true;
 
630
  }
 
631
 
 
632
  return false;
 
633
}
 
634
 
 
635
 
 
636
const char* Session::enter_cond(pthread_cond_t *cond,
 
637
                                pthread_mutex_t* mutex,
 
638
                                const char* msg)
 
639
{
 
640
  const char* old_msg = get_proc_info();
 
641
  safe_mutex_assert_owner(mutex);
 
642
  mysys_var->current_mutex = mutex;
 
643
  mysys_var->current_cond = cond;
 
644
  this->set_proc_info(msg);
 
645
  return old_msg;
 
646
}
 
647
 
 
648
void Session::exit_cond(const char* old_msg)
 
649
{
 
650
  /*
 
651
    Putting the mutex unlock in exit_cond() ensures that
 
652
    mysys_var->current_mutex is always unlocked _before_ mysys_var->mutex is
 
653
    locked (if that would not be the case, you'll get a deadlock if someone
 
654
    does a Session::awake() on you).
 
655
  */
 
656
  pthread_mutex_unlock(mysys_var->current_mutex);
 
657
  pthread_mutex_lock(&mysys_var->mutex);
 
658
  mysys_var->current_mutex = 0;
 
659
  mysys_var->current_cond = 0;
 
660
  this->set_proc_info(old_msg);
 
661
  pthread_mutex_unlock(&mysys_var->mutex);
 
662
}
 
663
 
 
664
bool Session::authenticate()
 
665
{
 
666
  lex_start(this);
 
667
  if (client->authenticate())
 
668
    return false;
 
669
 
 
670
  statistic_increment(aborted_connects, &LOCK_status);
 
671
  return true;
 
672
}
 
673
 
 
674
bool Session::checkUser(const char *passwd, uint32_t passwd_len, const char *in_db)
 
675
{
 
676
  LEX_STRING db_str= { (char *) in_db, in_db ? strlen(in_db) : 0 };
 
677
  bool is_authenticated;
 
678
 
 
679
  if (passwd_len != 0 && passwd_len != SCRAMBLE_LENGTH)
 
680
  {
 
681
    my_error(ER_HANDSHAKE_ERROR, MYF(0), security_ctx.ip.c_str());
 
682
    return false;
 
683
  }
 
684
 
 
685
  is_authenticated= plugin::Authentication::isAuthenticated(this, passwd);
 
686
 
 
687
  if (is_authenticated != true)
 
688
  {
 
689
    my_error(ER_ACCESS_DENIED_ERROR, MYF(0),
 
690
             security_ctx.user.c_str(),
 
691
             security_ctx.ip.c_str(),
 
692
             passwd_len ? ER(ER_YES) : ER(ER_NO));
 
693
 
 
694
    return false;
 
695
  }
 
696
 
 
697
  security_ctx.skip_grants();
 
698
 
 
699
  /* Change database if necessary */
 
700
  if (in_db && in_db[0])
 
701
  {
 
702
    if (mysql_change_db(this, &db_str, false))
 
703
    {
 
704
      /* mysql_change_db() has pushed the error message. */
 
705
      return false;
 
706
    }
 
707
  }
 
708
  my_ok();
 
709
  password= test(passwd_len);          // remember for error messages
 
710
 
 
711
  /* Ready to handle queries */
 
712
  return true;
 
713
}
 
714
 
 
715
bool Session::executeStatement()
 
716
{
 
717
  char *l_packet= 0;
 
718
  uint32_t packet_length;
 
719
 
 
720
  enum enum_server_command l_command;
 
721
 
 
722
  /*
 
723
    indicator of uninitialized lex => normal flow of errors handling
 
724
    (see my_message_sql)
 
725
  */
 
726
  lex->current_select= 0;
 
727
  clear_error();
 
728
  main_da.reset_diagnostics_area();
 
729
 
 
730
  if (client->readCommand(&l_packet, &packet_length) == false)
 
731
    return false;
 
732
 
 
733
  if (packet_length == 0)
 
734
    return true;
 
735
 
 
736
  l_command= (enum enum_server_command) (unsigned char) l_packet[0];
 
737
 
 
738
  if (command >= COM_END)
 
739
    command= COM_END;                           // Wrong command
 
740
 
 
741
  assert(packet_length);
 
742
  return ! dispatch_command(l_command, this, l_packet+1, (uint32_t) (packet_length-1));
 
743
}
 
744
 
 
745
bool Session::readAndStoreQuery(const char *in_packet, uint32_t in_packet_length)
 
746
{
 
747
  /* Remove garbage at start and end of query */
 
748
  while (in_packet_length > 0 && my_isspace(charset(), in_packet[0]))
 
749
  {
 
750
    in_packet++;
 
751
    in_packet_length--;
 
752
  }
 
753
  const char *pos= in_packet + in_packet_length; /* Point at end null */
 
754
  while (in_packet_length > 0 &&
 
755
         (pos[-1] == ';' || my_isspace(charset() ,pos[-1])))
 
756
  {
 
757
    pos--;
 
758
    in_packet_length--;
 
759
  }
 
760
 
 
761
  /* We must allocate some extra memory for the cached query string */
 
762
  query_length= 0; /* Extra safety: Avoid races */
 
763
  query= (char*) memdup_w_gap((unsigned char*) in_packet, in_packet_length, db.length() + 1);
 
764
  if (! query)
 
765
    return false;
 
766
 
 
767
  query[in_packet_length]=0;
 
768
  query_length= in_packet_length;
 
769
 
 
770
  return true;
 
771
}
 
772
 
 
773
bool Session::endTransaction(enum enum_mysql_completiontype completion)
 
774
{
 
775
  bool do_release= 0;
 
776
  bool result= true;
 
777
  TransactionServices &transaction_services= TransactionServices::singleton();
 
778
 
 
779
  if (transaction.xid_state.xa_state != XA_NOTR)
 
780
  {
 
781
    my_error(ER_XAER_RMFAIL, MYF(0), xa_state_names[transaction.xid_state.xa_state]);
 
782
    return false;
 
783
  }
 
784
  switch (completion)
 
785
  {
 
786
    case COMMIT:
 
787
      /*
 
788
       * We don't use endActiveTransaction() here to ensure that this works
 
789
       * even if there is a problem with the OPTION_AUTO_COMMIT flag
 
790
       * (Which of course should never happen...)
 
791
       */
 
792
      server_status&= ~SERVER_STATUS_IN_TRANS;
 
793
      if (transaction_services.ha_commit_trans(this, true))
 
794
        result= false;
 
795
      options&= ~(OPTION_BEGIN);
 
796
      transaction.all.modified_non_trans_table= false;
 
797
      break;
 
798
    case COMMIT_RELEASE:
 
799
      do_release= 1; /* fall through */
 
800
    case COMMIT_AND_CHAIN:
 
801
      result= endActiveTransaction();
 
802
      if (result == true && completion == COMMIT_AND_CHAIN)
 
803
        result= startTransaction();
 
804
      break;
 
805
    case ROLLBACK_RELEASE:
 
806
      do_release= 1; /* fall through */
 
807
    case ROLLBACK:
 
808
    case ROLLBACK_AND_CHAIN:
 
809
    {
 
810
      server_status&= ~SERVER_STATUS_IN_TRANS;
 
811
      if (transaction_services.ha_rollback_trans(this, true))
 
812
        result= false;
 
813
      options&= ~(OPTION_BEGIN);
 
814
      transaction.all.modified_non_trans_table= false;
 
815
      if (result == true && (completion == ROLLBACK_AND_CHAIN))
 
816
        result= startTransaction();
 
817
      break;
 
818
    }
 
819
    default:
 
820
      my_error(ER_UNKNOWN_COM_ERROR, MYF(0));
 
821
      return false;
 
822
  }
 
823
 
 
824
  if (result == false)
 
825
    my_error(killed_errno(), MYF(0));
 
826
  else if ((result == true) && do_release)
 
827
    killed= Session::KILL_CONNECTION;
 
828
 
 
829
  return result;
 
830
}
 
831
 
 
832
bool Session::endActiveTransaction()
 
833
{
 
834
  bool result= true;
 
835
  TransactionServices &transaction_services= TransactionServices::singleton();
 
836
 
 
837
  if (transaction.xid_state.xa_state != XA_NOTR)
 
838
  {
 
839
    my_error(ER_XAER_RMFAIL, MYF(0), xa_state_names[transaction.xid_state.xa_state]);
 
840
    return false;
 
841
  }
 
842
  if (options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))
 
843
  {
 
844
    server_status&= ~SERVER_STATUS_IN_TRANS;
 
845
    if (transaction_services.ha_commit_trans(this, true))
 
846
      result= false;
 
847
  }
 
848
  options&= ~(OPTION_BEGIN);
 
849
  transaction.all.modified_non_trans_table= false;
 
850
  return result;
 
851
}
 
852
 
 
853
bool Session::startTransaction(start_transaction_option_t opt)
 
854
{
 
855
  bool result= true;
 
856
 
 
857
  if (! endActiveTransaction())
 
858
  {
 
859
    result= false;
 
860
  }
 
861
  else
 
862
  {
 
863
    options|= OPTION_BEGIN;
 
864
    server_status|= SERVER_STATUS_IN_TRANS;
 
865
 
 
866
    if (opt == START_TRANS_OPT_WITH_CONS_SNAPSHOT)
 
867
    {
 
868
      // TODO make this a loop for all engines, not just this one (Inno only
 
869
      // right now)
 
870
      if (plugin::StorageEngine::startConsistentSnapshot(this))
 
871
      {
 
872
        result= false;
 
873
      }
 
874
    }
 
875
  }
 
876
 
 
877
  return result;
 
878
}
 
879
 
 
880
void Session::cleanup_after_query()
 
881
{
 
882
  /*
 
883
    Reset rand_used so that detection of calls to rand() will save random
900
884
    seeds if needed by the slave.
901
 
 
902
 
    Do not reset rand_used if inside a stored function or trigger because 
903
 
    only the call to these operations is logged. Thus only the calling 
904
 
    statement needs to detect rand() calls made by its substatements. These
905
 
    substatements must not set rand_used to 0 because it would remove the
906
 
    detection of rand() by the calling statement. 
907
885
  */
908
 
  if (!in_sub_stmt) /* stored functions and triggers are a special case */
909
886
  {
910
887
    /* Forget those values, for next binlogger: */
911
 
    stmt_depends_on_first_successful_insert_id_in_prev_stmt= 0;
912
888
    auto_inc_intervals_in_cur_stmt_for_binlog.empty();
913
 
    rand_used= 0;
914
889
  }
915
890
  if (first_successful_insert_id_in_cur_stmt > 0)
916
891
  {
917
892
    /* set what LAST_INSERT_ID() will return */
918
 
    first_successful_insert_id_in_prev_stmt= 
919
 
      first_successful_insert_id_in_cur_stmt;
 
893
    first_successful_insert_id_in_prev_stmt= first_successful_insert_id_in_cur_stmt;
920
894
    first_successful_insert_id_in_cur_stmt= 0;
921
895
    substitute_null_with_insert_id= true;
922
896
  }
923
 
  arg_of_last_insert_id_function= 0;
 
897
  arg_of_last_insert_id_function= false;
924
898
  /* Free Items that were created during this execution */
925
899
  free_items();
926
900
  /* Reset where. */
927
 
  where= THD::DEFAULT_WHERE;
 
901
  where= Session::DEFAULT_WHERE;
928
902
}
929
903
 
930
 
 
931
904
/**
932
905
  Create a LEX_STRING in this connection.
933
906
 
938
911
                              instead of using lex_str value
939
912
  @return  NULL on failure, or pointer to the LEX_STRING object
940
913
*/
941
 
LEX_STRING *THD::make_lex_string(LEX_STRING *lex_str,
942
 
                                 const char* str, uint length,
 
914
LEX_STRING *Session::make_lex_string(LEX_STRING *lex_str,
 
915
                                 const char* str, uint32_t length,
943
916
                                 bool allocate_lex_string)
944
917
{
945
918
  if (allocate_lex_string)
951
924
  return lex_str;
952
925
}
953
926
 
954
 
 
955
 
/*
956
 
  Convert a string to another character set
957
 
 
958
 
  SYNOPSIS
959
 
    convert_string()
960
 
    to                          Store new allocated string here
961
 
    to_cs                       New character set for allocated string
962
 
    from                        String to convert
963
 
    from_length                 Length of string to convert
964
 
    from_cs                     Original character set
965
 
 
966
 
  NOTES
967
 
    to will be 0-terminated to make it easy to pass to system funcs
968
 
 
969
 
  RETURN
970
 
    0   ok
971
 
    1   End of memory.
972
 
        In this case to->str will point to 0 and to->length will be 0.
973
 
*/
974
 
 
975
 
bool THD::convert_string(LEX_STRING *to, const CHARSET_INFO * const to_cs,
976
 
                         const char *from, uint from_length,
977
 
                         const CHARSET_INFO * const from_cs)
978
 
{
979
 
  size_t new_length= to_cs->mbmaxlen * from_length;
980
 
  uint dummy_errors;
981
 
  if (!(to->str= (char*) alloc(new_length+1)))
982
 
  {
983
 
    to->length= 0;                              // Safety fix
984
 
    return(1);                          // EOM
985
 
  }
986
 
  to->length= copy_and_convert((char*) to->str, new_length, to_cs,
987
 
                               from, from_length, from_cs, &dummy_errors);
988
 
  to->str[to->length]=0;                        // Safety
989
 
  return(0);
990
 
}
991
 
 
992
 
 
993
 
/*
994
 
  Convert string from source character set to target character set inplace.
995
 
 
996
 
  SYNOPSIS
997
 
    THD::convert_string
998
 
 
999
 
  DESCRIPTION
1000
 
    Convert string using convert_buffer - buffer for character set 
1001
 
    conversion shared between all protocols.
1002
 
 
1003
 
  RETURN
1004
 
    0   ok
1005
 
   !0   out of memory
1006
 
*/
1007
 
 
1008
 
bool THD::convert_string(String *s, const CHARSET_INFO * const from_cs,
1009
 
                         const CHARSET_INFO * const to_cs)
1010
 
{
1011
 
  uint dummy_errors;
1012
 
  if (convert_buffer.copy(s->ptr(), s->length(), from_cs, to_cs, &dummy_errors))
1013
 
    return true;
1014
 
  /* If convert_buffer >> s copying is more efficient long term */
1015
 
  if (convert_buffer.alloced_length() >= convert_buffer.length() * 2 ||
1016
 
      !s->is_alloced())
1017
 
  {
1018
 
    return s->copy(convert_buffer);
1019
 
  }
1020
 
  s->swap(convert_buffer);
1021
 
  return false;
1022
 
}
1023
 
 
1024
 
 
1025
 
/*
1026
 
  Update some cache variables when character set changes
1027
 
*/
1028
 
 
1029
 
void THD::update_charset()
1030
 
{
1031
 
  uint32_t not_used;
1032
 
  charset_is_system_charset= !String::needs_conversion(0,charset(),
1033
 
                                                       system_charset_info,
1034
 
                                                       &not_used);
1035
 
  charset_is_collation_connection= 
1036
 
    !String::needs_conversion(0,charset(),variables.collation_connection,
1037
 
                              &not_used);
1038
 
  charset_is_character_set_filesystem= 
1039
 
    !String::needs_conversion(0, charset(),
1040
 
                              variables.character_set_filesystem, &not_used);
1041
 
}
1042
 
 
1043
 
 
1044
 
/* routings to adding tables to list of changed in transaction tables */
1045
 
 
1046
 
inline static void list_include(CHANGED_TABLE_LIST** prev,
1047
 
                                CHANGED_TABLE_LIST* curr,
1048
 
                                CHANGED_TABLE_LIST* new_table)
1049
 
{
1050
 
  if (new_table)
1051
 
  {
1052
 
    *prev = new_table;
1053
 
    (*prev)->next = curr;
1054
 
  }
1055
 
}
1056
 
 
1057
 
/* add table to list of changed in transaction tables */
1058
 
 
1059
 
void THD::add_changed_table(TABLE *table)
1060
 
{
1061
 
  assert((options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) &&
1062
 
              table->file->has_transactions());
1063
 
  add_changed_table(table->s->table_cache_key.str,
1064
 
                    (long) table->s->table_cache_key.length);
1065
 
  return;
1066
 
}
1067
 
 
1068
 
 
1069
 
void THD::add_changed_table(const char *key, long key_length)
1070
 
{
1071
 
  CHANGED_TABLE_LIST **prev_changed = &transaction.changed_tables;
1072
 
  CHANGED_TABLE_LIST *curr = transaction.changed_tables;
1073
 
 
1074
 
  for (; curr; prev_changed = &(curr->next), curr = curr->next)
1075
 
  {
1076
 
    int cmp =  (long)curr->key_length - (long)key_length;
1077
 
    if (cmp < 0)
1078
 
    {
1079
 
      list_include(prev_changed, curr, changed_table_dup(key, key_length));
1080
 
      return;
1081
 
    }
1082
 
    else if (cmp == 0)
1083
 
    {
1084
 
      cmp = memcmp(curr->key, key, curr->key_length);
1085
 
      if (cmp < 0)
1086
 
      {
1087
 
        list_include(prev_changed, curr, changed_table_dup(key, key_length));
1088
 
        return;
1089
 
      }
1090
 
      else if (cmp == 0)
1091
 
      {
1092
 
        return;
1093
 
      }
1094
 
    }
1095
 
  }
1096
 
  *prev_changed = changed_table_dup(key, key_length);
1097
 
  return;
1098
 
}
1099
 
 
1100
 
 
1101
 
CHANGED_TABLE_LIST* THD::changed_table_dup(const char *key, long key_length)
1102
 
{
1103
 
  CHANGED_TABLE_LIST* new_table = 
1104
 
    (CHANGED_TABLE_LIST*) trans_alloc(ALIGN_SIZE(sizeof(CHANGED_TABLE_LIST))+
1105
 
                                      key_length + 1);
1106
 
  if (!new_table)
1107
 
  {
1108
 
    my_error(EE_OUTOFMEMORY, MYF(ME_BELL),
1109
 
             ALIGN_SIZE(sizeof(TABLE_LIST)) + key_length + 1);
1110
 
    killed= KILL_CONNECTION;
1111
 
    return 0;
1112
 
  }
1113
 
 
1114
 
  new_table->key= ((char*)new_table)+ ALIGN_SIZE(sizeof(CHANGED_TABLE_LIST));
1115
 
  new_table->next = 0;
1116
 
  new_table->key_length = key_length;
1117
 
  ::memcpy(new_table->key, key, key_length);
1118
 
  return new_table;
1119
 
}
1120
 
 
1121
 
 
1122
 
int THD::send_explain_fields(select_result *result)
 
927
int Session::send_explain_fields(select_result *result)
1123
928
{
1124
929
  List<Item> field_list;
1125
930
  Item *item;
1154
959
  }
1155
960
  item->maybe_null= 1;
1156
961
  field_list.push_back(new Item_empty_string("Extra", 255, cs));
1157
 
  return (result->send_fields(field_list,
1158
 
                              Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF));
1159
 
}
1160
 
 
1161
 
#ifdef SIGNAL_WITH_VIO_CLOSE
1162
 
void THD::close_active_vio()
1163
 
{
1164
 
  safe_mutex_assert_owner(&LOCK_delete); 
1165
 
  if (active_vio)
1166
 
  {
1167
 
    vio_close(active_vio);
1168
 
    active_vio = 0;
1169
 
  }
1170
 
  return;
1171
 
}
1172
 
#endif
1173
 
 
1174
 
 
1175
 
struct Item_change_record: public ilink
1176
 
{
1177
 
  Item **place;
1178
 
  Item *old_value;
1179
 
  /* Placement new was hidden by `new' in ilink (TODO: check): */
1180
 
  static void *operator new(size_t size __attribute__((unused)),
1181
 
                            void *mem)
1182
 
    { return mem; }
1183
 
  static void operator delete(void *ptr __attribute__((unused)),
1184
 
                              size_t size __attribute__((unused)))
1185
 
    {}
1186
 
  static void operator delete(void *ptr __attribute__((unused)),
1187
 
                              void *mem __attribute__((unused)))
1188
 
    { /* never called */ }
1189
 
};
1190
 
 
1191
 
 
1192
 
/*
1193
 
  Register an item tree tree transformation, performed by the query
1194
 
  optimizer. We need a pointer to runtime_memroot because it may be !=
1195
 
  thd->mem_root (due to possible set_n_backup_active_arena called for thd).
1196
 
*/
1197
 
 
1198
 
void THD::nocheck_register_item_tree_change(Item **place, Item *old_value,
1199
 
                                            MEM_ROOT *runtime_memroot)
1200
 
{
1201
 
  Item_change_record *change;
1202
 
  /*
1203
 
    Now we use one node per change, which adds some memory overhead,
1204
 
    but still is rather fast as we use alloc_root for allocations.
1205
 
    A list of item tree changes of an average query should be short.
1206
 
  */
1207
 
  void *change_mem= alloc_root(runtime_memroot, sizeof(*change));
1208
 
  if (change_mem == 0)
1209
 
  {
1210
 
    /*
1211
 
      OOM, thd->fatal_error() is called by the error handler of the
1212
 
      memroot. Just return.
1213
 
    */
1214
 
    return;
1215
 
  }
1216
 
  change= new (change_mem) Item_change_record;
1217
 
  change->place= place;
1218
 
  change->old_value= old_value;
1219
 
  change_list.append(change);
1220
 
}
1221
 
 
1222
 
 
1223
 
void THD::rollback_item_tree_changes()
1224
 
{
1225
 
  I_List_iterator<Item_change_record> it(change_list);
1226
 
  Item_change_record *change;
1227
 
 
1228
 
  while ((change= it++))
1229
 
    *change->place= change->old_value;
1230
 
  /* We can forget about changes memory: it's allocated in runtime memroot */
1231
 
  change_list.empty();
1232
 
  return;
1233
 
}
1234
 
 
1235
 
 
1236
 
/**
1237
 
  Check that the endpoint is still available.
1238
 
*/
1239
 
 
1240
 
bool THD::vio_is_connected()
1241
 
{
1242
 
  uint bytes= 0;
1243
 
 
1244
 
  /* End of input is signaled by poll if the socket is aborted. */
1245
 
  if (vio_poll_read(net.vio, 0))
1246
 
    return true;
1247
 
 
1248
 
  /* Socket is aborted if signaled but no data is available. */
1249
 
  if (vio_peek_read(net.vio, &bytes))
1250
 
    return true;
1251
 
 
1252
 
  return bytes ? true : false;
1253
 
}
1254
 
 
1255
 
 
1256
 
/*****************************************************************************
1257
 
** Functions to provide a interface to select results
1258
 
*****************************************************************************/
1259
 
 
1260
 
select_result::select_result()
1261
 
{
1262
 
  thd=current_thd;
1263
 
}
1264
 
 
1265
 
void select_result::send_error(uint errcode,const char *err)
 
962
  return (result->send_fields(field_list));
 
963
}
 
964
 
 
965
void select_result::send_error(uint32_t errcode, const char *err)
1266
966
{
1267
967
  my_message(errcode, err, MYF(0));
1268
968
}
1269
969
 
1270
 
 
1271
 
void select_result::cleanup()
1272
 
{
1273
 
  /* do nothing */
1274
 
}
1275
 
 
1276
 
bool select_result::check_simple_select() const
1277
 
{
1278
 
  my_error(ER_SP_BAD_CURSOR_QUERY, MYF(0));
1279
 
  return true;
1280
 
}
1281
 
 
1282
 
 
1283
 
static String default_line_term("\n",default_charset_info);
1284
 
static String default_escaped("\\",default_charset_info);
1285
 
static String default_field_term("\t",default_charset_info);
1286
 
 
1287
 
sql_exchange::sql_exchange(char *name, bool flag,
1288
 
                           enum enum_filetype filetype_arg)
1289
 
  :file_name(name), opt_enclosed(0), dumpfile(flag), skip_lines(0)
1290
 
{
1291
 
  filetype= filetype_arg;
1292
 
  field_term= &default_field_term;
1293
 
  enclosed=   line_start= &my_empty_string;
1294
 
  line_term=  &default_line_term;
1295
 
  escaped=    &default_escaped;
1296
 
  cs= NULL;
1297
 
}
1298
 
 
1299
 
bool select_send::send_fields(List<Item> &list, uint flags)
1300
 
{
1301
 
  bool res;
1302
 
  if (!(res= thd->protocol->send_fields(&list, flags)))
1303
 
    is_result_set_started= 1;
1304
 
  return res;
1305
 
}
1306
 
 
1307
 
void select_send::abort()
1308
 
{
1309
 
  return;
1310
 
}
1311
 
 
1312
 
 
1313
 
/** 
1314
 
  Cleanup an instance of this class for re-use
1315
 
  at next execution of a prepared statement/
1316
 
  stored procedure statement.
1317
 
*/
1318
 
 
1319
 
void select_send::cleanup()
1320
 
{
1321
 
  is_result_set_started= false;
1322
 
}
1323
 
 
1324
 
/* Send data to client. Returns 0 if ok */
1325
 
 
1326
 
bool select_send::send_data(List<Item> &items)
1327
 
{
1328
 
  if (unit->offset_limit_cnt)
1329
 
  {                                             // using limit offset,count
1330
 
    unit->offset_limit_cnt--;
1331
 
    return 0;
1332
 
  }
1333
 
 
1334
 
  /*
1335
 
    We may be passing the control from mysqld to the client: release the
1336
 
    InnoDB adaptive hash S-latch to avoid thread deadlocks if it was reserved
1337
 
    by thd
1338
 
  */
1339
 
  ha_release_temporary_latches(thd);
1340
 
 
1341
 
  List_iterator_fast<Item> li(items);
1342
 
  Protocol *protocol= thd->protocol;
1343
 
  char buff[MAX_FIELD_WIDTH];
1344
 
  String buffer(buff, sizeof(buff), &my_charset_bin);
1345
 
 
1346
 
  protocol->prepare_for_resend();
1347
 
  Item *item;
1348
 
  while ((item=li++))
1349
 
  {
1350
 
    if (item->send(protocol, &buffer))
1351
 
    {
1352
 
      protocol->free();                         // Free used buffer
1353
 
      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
1354
 
      break;
1355
 
    }
1356
 
  }
1357
 
  thd->sent_row_count++;
1358
 
  if (thd->is_error())
1359
 
  {
1360
 
    protocol->remove_last_row();
1361
 
    return(1);
1362
 
  }
1363
 
  if (thd->vio_ok())
1364
 
    return(protocol->write());
1365
 
  return(0);
1366
 
}
1367
 
 
1368
 
bool select_send::send_eof()
1369
 
{
1370
 
  /* 
1371
 
    We may be passing the control from mysqld to the client: release the
1372
 
    InnoDB adaptive hash S-latch to avoid thread deadlocks if it was reserved
1373
 
    by thd 
1374
 
  */
1375
 
  ha_release_temporary_latches(thd);
1376
 
 
1377
 
  /* Unlock tables before sending packet to gain some speed */
1378
 
  if (thd->lock)
1379
 
  {
1380
 
    mysql_unlock_tables(thd, thd->lock);
1381
 
    thd->lock=0;
1382
 
  }
1383
 
  ::my_eof(thd);
1384
 
  is_result_set_started= 0;
1385
 
  return false;
1386
 
}
1387
 
 
1388
 
 
1389
970
/************************************************************************
1390
971
  Handling writing to file
1391
972
************************************************************************/
1392
973
 
1393
 
void select_to_file::send_error(uint errcode,const char *err)
 
974
void select_to_file::send_error(uint32_t errcode,const char *err)
1394
975
{
1395
976
  my_message(errcode, err, MYF(0));
1396
977
  if (file > 0)
1397
978
  {
1398
 
    (void) end_io_cache(&cache);
1399
 
    (void) my_close(file,MYF(0));
1400
 
    (void) my_delete(path,MYF(0));              // Delete file on error
 
979
    (void) end_io_cache(cache);
 
980
    (void) internal::my_close(file, MYF(0));
 
981
    (void) internal::my_delete(path, MYF(0));           // Delete file on error
1401
982
    file= -1;
1402
983
  }
1403
984
}
1405
986
 
1406
987
bool select_to_file::send_eof()
1407
988
{
1408
 
  int error= test(end_io_cache(&cache));
1409
 
  if (my_close(file,MYF(MY_WME)))
 
989
  int error= test(end_io_cache(cache));
 
990
  if (internal::my_close(file, MYF(MY_WME)))
1410
991
    error= 1;
1411
992
  if (!error)
1412
993
  {
1415
996
      function, SELECT INTO has to have an own SQLCOM.
1416
997
      TODO: split from SQLCOM_SELECT
1417
998
    */
1418
 
    ::my_ok(thd,row_count);
 
999
    session->my_ok(row_count);
1419
1000
  }
1420
1001
  file= -1;
1421
1002
  return error;
1427
1008
  /* In case of error send_eof() may be not called: close the file here. */
1428
1009
  if (file >= 0)
1429
1010
  {
1430
 
    (void) end_io_cache(&cache);
1431
 
    (void) my_close(file,MYF(0));
 
1011
    (void) end_io_cache(cache);
 
1012
    (void) internal::my_close(file, MYF(0));
1432
1013
    file= -1;
1433
1014
  }
1434
1015
  path[0]= '\0';
1435
1016
  row_count= 0;
1436
1017
}
1437
1018
 
 
1019
select_to_file::select_to_file(file_exchange *ex)
 
1020
  : exchange(ex),
 
1021
    file(-1),
 
1022
    cache(static_cast<internal::IO_CACHE *>(memory::sql_calloc(sizeof(internal::IO_CACHE)))),
 
1023
    row_count(0L)
 
1024
{
 
1025
  path[0]=0;
 
1026
}
1438
1027
 
1439
1028
select_to_file::~select_to_file()
1440
1029
{
1441
 
  if (file >= 0)
1442
 
  {                                     // This only happens in case of error
1443
 
    (void) end_io_cache(&cache);
1444
 
    (void) my_close(file,MYF(0));
1445
 
    file= -1;
1446
 
  }
 
1030
  cleanup();
1447
1031
}
1448
1032
 
1449
1033
/***************************************************************************
1452
1036
 
1453
1037
select_export::~select_export()
1454
1038
{
1455
 
  thd->sent_row_count=row_count;
 
1039
  session->sent_row_count=row_count;
1456
1040
}
1457
1041
 
1458
1042
 
1461
1045
 
1462
1046
  SYNOPSIS
1463
1047
    create_file()
1464
 
    thd                 Thread handle
 
1048
    session                     Thread handle
1465
1049
    path                File name
1466
1050
    exchange            Excange class
1467
1051
    cache               IO cache
1472
1056
*/
1473
1057
 
1474
1058
 
1475
 
static File create_file(THD *thd, char *path, sql_exchange *exchange,
1476
 
                        IO_CACHE *cache)
 
1059
static int create_file(Session *session, char *path, file_exchange *exchange, internal::IO_CACHE *cache)
1477
1060
{
1478
 
  File file;
1479
 
  uint option= MY_UNPACK_FILENAME | MY_RELATIVE_PATH;
 
1061
  int file;
 
1062
  uint32_t option= MY_UNPACK_FILENAME | MY_RELATIVE_PATH;
1480
1063
 
1481
1064
#ifdef DONT_ALLOW_FULL_LOAD_DATA_PATHS
1482
1065
  option|= MY_REPLACE_DIR;                      // Force use of db directory
1483
1066
#endif
1484
1067
 
1485
 
  if (!dirname_length(exchange->file_name))
 
1068
  if (!internal::dirname_length(exchange->file_name))
1486
1069
  {
1487
 
    strxnmov(path, FN_REFLEN-1, mysql_real_data_home, thd->db ? thd->db : "",
1488
 
             NullS);
1489
 
    (void) fn_format(path, exchange->file_name, path, "", option);
 
1070
    strcpy(path, drizzle_real_data_home);
 
1071
    if (! session->db.empty())
 
1072
      strncat(path, session->db.c_str(), FN_REFLEN-strlen(drizzle_real_data_home)-1);
 
1073
    (void) internal::fn_format(path, exchange->file_name, path, "", option);
1490
1074
  }
1491
1075
  else
1492
 
    (void) fn_format(path, exchange->file_name, mysql_real_data_home, "", option);
 
1076
    (void) internal::fn_format(path, exchange->file_name, drizzle_real_data_home, "", option);
1493
1077
 
1494
1078
  if (opt_secure_file_priv &&
1495
1079
      strncmp(opt_secure_file_priv, path, strlen(opt_secure_file_priv)))
1505
1089
    return -1;
1506
1090
  }
1507
1091
  /* Create the file world readable */
1508
 
  if ((file= my_create(path, 0666, O_WRONLY|O_EXCL, MYF(MY_WME))) < 0)
 
1092
  if ((file= internal::my_create(path, 0666, O_WRONLY|O_EXCL, MYF(MY_WME))) < 0)
1509
1093
    return file;
1510
 
#ifdef HAVE_FCHMOD
1511
1094
  (void) fchmod(file, 0666);                    // Because of umask()
1512
 
#else
1513
 
  (void) chmod(path, 0666);
1514
 
#endif
1515
 
  if (init_io_cache(cache, file, 0L, WRITE_CACHE, 0L, 1, MYF(MY_WME)))
 
1095
  if (init_io_cache(cache, file, 0L, internal::WRITE_CACHE, 0L, 1, MYF(MY_WME)))
1516
1096
  {
1517
 
    my_close(file, MYF(0));
1518
 
    my_delete(path, MYF(0));  // Delete file on error, it was just created 
 
1097
    internal::my_close(file, MYF(0));
 
1098
    internal::my_delete(path, MYF(0));  // Delete file on error, it was just created
1519
1099
    return -1;
1520
1100
  }
1521
1101
  return file;
1523
1103
 
1524
1104
 
1525
1105
int
1526
 
select_export::prepare(List<Item> &list, SELECT_LEX_UNIT *u)
 
1106
select_export::prepare(List<Item> &list, Select_Lex_Unit *u)
1527
1107
{
1528
1108
  bool blob_flag=0;
1529
1109
  bool string_results= false, non_string_results= false;
1530
1110
  unit= u;
1531
 
  if ((uint) strlen(exchange->file_name) + NAME_LEN >= FN_REFLEN)
1532
 
    strmake(path,exchange->file_name,FN_REFLEN-1);
 
1111
  if ((uint32_t) strlen(exchange->file_name) + NAME_LEN >= FN_REFLEN)
 
1112
    strncpy(path,exchange->file_name,FN_REFLEN-1);
1533
1113
 
1534
 
  if ((file= create_file(thd, path, exchange, &cache)) < 0)
1535
 
    return 1;
1536
1114
  /* Check if there is any blobs in data */
1537
1115
  {
1538
1116
    List_iterator_fast<Item> li(list);
1552
1130
  }
1553
1131
  field_term_length=exchange->field_term->length();
1554
1132
  field_term_char= field_term_length ?
1555
 
                   (int) (uchar) (*exchange->field_term)[0] : INT_MAX;
 
1133
                   (int) (unsigned char) (*exchange->field_term)[0] : INT_MAX;
1556
1134
  if (!exchange->line_term->length())
1557
1135
    exchange->line_term=exchange->field_term;   // Use this if it exists
1558
1136
  field_sep_char= (exchange->enclosed->length() ?
1559
 
                  (int) (uchar) (*exchange->enclosed)[0] : field_term_char);
 
1137
                  (int) (unsigned char) (*exchange->enclosed)[0] : field_term_char);
1560
1138
  escape_char=  (exchange->escaped->length() ?
1561
 
                (int) (uchar) (*exchange->escaped)[0] : -1);
 
1139
                (int) (unsigned char) (*exchange->escaped)[0] : -1);
1562
1140
  is_ambiguous_field_sep= test(strchr(ESCAPE_CHARS, field_sep_char));
1563
1141
  is_unsafe_field_sep= test(strchr(NUMERIC_CHARS, field_sep_char));
1564
1142
  line_sep_char= (exchange->line_term->length() ?
1565
 
                 (int) (uchar) (*exchange->line_term)[0] : INT_MAX);
 
1143
                 (int) (unsigned char) (*exchange->line_term)[0] : INT_MAX);
1566
1144
  if (!field_term_length)
1567
1145
    exchange->opt_enclosed=0;
1568
1146
  if (!exchange->enclosed->length())
1574
1152
      (exchange->opt_enclosed && non_string_results &&
1575
1153
       field_term_length && strchr(NUMERIC_CHARS, field_term_char)))
1576
1154
  {
1577
 
    push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
1578
 
                 ER_AMBIGUOUS_FIELD_TERM, ER(ER_AMBIGUOUS_FIELD_TERM));
1579
 
    is_ambiguous_field_term= true;
 
1155
    my_error(ER_AMBIGUOUS_FIELD_TERM, MYF(0));
 
1156
    return 1;
1580
1157
  }
1581
 
  else
1582
 
    is_ambiguous_field_term= false;
 
1158
 
 
1159
  if ((file= create_file(session, path, exchange, cache)) < 0)
 
1160
    return 1;
1583
1161
 
1584
1162
  return 0;
1585
1163
}
1586
1164
 
1587
1165
 
1588
 
#define NEED_ESCAPING(x) ((int) (uchar) (x) == escape_char    || \
1589
 
                          (enclosed ? (int) (uchar) (x) == field_sep_char      \
1590
 
                                    : (int) (uchar) (x) == field_term_char) || \
1591
 
                          (int) (uchar) (x) == line_sep_char  || \
 
1166
#define NEED_ESCAPING(x) ((int) (unsigned char) (x) == escape_char    || \
 
1167
                          (enclosed ? (int) (unsigned char) (x) == field_sep_char      \
 
1168
                                    : (int) (unsigned char) (x) == field_term_char) || \
 
1169
                          (int) (unsigned char) (x) == line_sep_char  || \
1592
1170
                          !(x))
1593
1171
 
1594
1172
bool select_export::send_data(List<Item> &items)
1605
1183
  }
1606
1184
  row_count++;
1607
1185
  Item *item;
1608
 
  uint used_length=0,items_left=items.elements;
 
1186
  uint32_t used_length=0,items_left=items.elements;
1609
1187
  List_iterator_fast<Item> li(items);
1610
1188
 
1611
 
  if (my_b_write(&cache,(uchar*) exchange->line_start->ptr(),
1612
 
                 exchange->line_start->length()))
 
1189
  if (my_b_write(cache,(unsigned char*) exchange->line_start->ptr(),
 
1190
                 exchange->line_start->length()))
1613
1191
    goto err;
1614
1192
  while ((item=li++))
1615
1193
  {
1619
1197
    res=item->str_result(&tmp);
1620
1198
    if (res && enclosed)
1621
1199
    {
1622
 
      if (my_b_write(&cache,(uchar*) exchange->enclosed->ptr(),
1623
 
                     exchange->enclosed->length()))
1624
 
        goto err;
 
1200
      if (my_b_write(cache,(unsigned char*) exchange->enclosed->ptr(),
 
1201
                     exchange->enclosed->length()))
 
1202
        goto err;
1625
1203
    }
1626
1204
    if (!res)
1627
1205
    {                                           // NULL
1628
1206
      if (!fixed_row_size)
1629
1207
      {
1630
 
        if (escape_char != -1)                  // Use \N syntax
1631
 
        {
1632
 
          null_buff[0]=escape_char;
1633
 
          null_buff[1]='N';
1634
 
          if (my_b_write(&cache,(uchar*) null_buff,2))
1635
 
            goto err;
1636
 
        }
1637
 
        else if (my_b_write(&cache,(uchar*) "NULL",4))
1638
 
          goto err;
 
1208
        if (escape_char != -1)                  // Use \N syntax
 
1209
        {
 
1210
          null_buff[0]=escape_char;
 
1211
          null_buff[1]='N';
 
1212
          if (my_b_write(cache,(unsigned char*) null_buff,2))
 
1213
            goto err;
 
1214
        }
 
1215
        else if (my_b_write(cache,(unsigned char*) "NULL",4))
 
1216
          goto err;
1639
1217
      }
1640
1218
      else
1641
1219
      {
1642
 
        used_length=0;                          // Fill with space
 
1220
        used_length=0;                          // Fill with space
1643
1221
      }
1644
1222
    }
1645
1223
    else
1646
1224
    {
1647
1225
      if (fixed_row_size)
1648
 
        used_length=min(res->length(),item->max_length);
 
1226
        used_length= min(res->length(),item->max_length);
1649
1227
      else
1650
 
        used_length=res->length();
 
1228
        used_length= res->length();
 
1229
 
1651
1230
      if ((result_type == STRING_RESULT || is_unsafe_field_sep) &&
1652
 
           escape_char != -1)
 
1231
          escape_char != -1)
1653
1232
      {
1654
1233
        char *pos, *start, *end;
1655
1234
        const CHARSET_INFO * const res_charset= res->charset();
1656
 
        const CHARSET_INFO * const character_set_client= thd->variables.
1657
 
                                                            character_set_client;
 
1235
        const CHARSET_INFO * const character_set_client= default_charset_info;
 
1236
 
1658
1237
        bool check_second_byte= (res_charset == &my_charset_bin) &&
1659
 
                                 character_set_client->
1660
 
                                 escape_with_backslash_is_dangerous;
 
1238
          character_set_client->
 
1239
          escape_with_backslash_is_dangerous;
1661
1240
        assert(character_set_client->mbmaxlen == 2 ||
1662
 
                    !character_set_client->escape_with_backslash_is_dangerous);
1663
 
        for (start=pos=(char*) res->ptr(),end=pos+used_length ;
1664
 
             pos != end ;
1665
 
             pos++)
1666
 
        {
1667
 
#ifdef USE_MB
1668
 
          if (use_mb(res_charset))
1669
 
          {
1670
 
            int l;
1671
 
            if ((l=my_ismbchar(res_charset, pos, end)))
1672
 
            {
1673
 
              pos += l-1;
1674
 
              continue;
1675
 
            }
1676
 
          }
1677
 
#endif
 
1241
               !character_set_client->escape_with_backslash_is_dangerous);
 
1242
        for (start=pos=(char*) res->ptr(),end=pos+used_length ;
 
1243
             pos != end ;
 
1244
             pos++)
 
1245
        {
 
1246
          if (use_mb(res_charset))
 
1247
          {
 
1248
            int l;
 
1249
            if ((l=my_ismbchar(res_charset, pos, end)))
 
1250
            {
 
1251
              pos += l-1;
 
1252
              continue;
 
1253
            }
 
1254
          }
1678
1255
 
1679
1256
          /*
1680
1257
            Special case when dumping BINARY/VARBINARY/BLOB values
1681
1258
            for the clients with character sets big5, cp932, gbk and sjis,
1682
1259
            which can have the escape character (0x5C "\" by default)
1683
1260
            as the second byte of a multi-byte sequence.
1684
 
            
 
1261
 
1685
1262
            If
1686
1263
            - pos[0] is a valid multi-byte head (e.g 0xEE) and
1687
1264
            - pos[1] is 0x00, which will be escaped as "\0",
1688
 
            
 
1265
 
1689
1266
            then we'll get "0xEE + 0x5C + 0x30" in the output file.
1690
 
            
 
1267
 
1691
1268
            If this file is later loaded using this sequence of commands:
1692
 
            
 
1269
 
1693
1270
            mysql> create table t1 (a varchar(128)) character set big5;
1694
 
            mysql> LOAD DATA INFILE 'dump.txt' INTO TABLE t1;
1695
 
            
 
1271
            mysql> LOAD DATA INFILE 'dump.txt' INTO Table t1;
 
1272
 
1696
1273
            then 0x5C will be misinterpreted as the second byte
1697
1274
            of a multi-byte character "0xEE + 0x5C", instead of
1698
1275
            escape character for 0x00.
1699
 
            
 
1276
 
1700
1277
            To avoid this confusion, we'll escape the multi-byte
1701
1278
            head character too, so the sequence "0xEE + 0x00" will be
1702
1279
            dumped as "0x5C + 0xEE + 0x5C + 0x30".
1703
 
            
 
1280
 
1704
1281
            Note, in the condition below we only check if
1705
1282
            mbcharlen is equal to 2, because there are no
1706
1283
            character sets with mbmaxlen longer than 2
1710
1287
 
1711
1288
          if ((NEED_ESCAPING(*pos) ||
1712
1289
               (check_second_byte &&
1713
 
                my_mbcharlen(character_set_client, (uchar) *pos) == 2 &&
 
1290
                my_mbcharlen(character_set_client, (unsigned char) *pos) == 2 &&
1714
1291
                pos + 1 < end &&
1715
1292
                NEED_ESCAPING(pos[1]))) &&
1716
1293
              /*
1717
 
               Don't escape field_term_char by doubling - doubling is only
1718
 
               valid for ENCLOSED BY characters:
 
1294
                Don't escape field_term_char by doubling - doubling is only
 
1295
                valid for ENCLOSED BY characters:
1719
1296
              */
1720
1297
              (enclosed || !is_ambiguous_field_term ||
1721
 
               (int) (uchar) *pos != field_term_char))
 
1298
               (int) (unsigned char) *pos != field_term_char))
1722
1299
          {
1723
 
            char tmp_buff[2];
1724
 
            tmp_buff[0]= ((int) (uchar) *pos == field_sep_char &&
 
1300
            char tmp_buff[2];
 
1301
            tmp_buff[0]= ((int) (unsigned char) *pos == field_sep_char &&
1725
1302
                          is_ambiguous_field_sep) ?
1726
 
                          field_sep_char : escape_char;
1727
 
            tmp_buff[1]= *pos ? *pos : '0';
1728
 
            if (my_b_write(&cache,(uchar*) start,(uint) (pos-start)) ||
1729
 
                my_b_write(&cache,(uchar*) tmp_buff,2))
1730
 
              goto err;
1731
 
            start=pos+1;
1732
 
          }
1733
 
        }
1734
 
        if (my_b_write(&cache,(uchar*) start,(uint) (pos-start)))
1735
 
          goto err;
 
1303
              field_sep_char : escape_char;
 
1304
            tmp_buff[1]= *pos ? *pos : '0';
 
1305
            if (my_b_write(cache,(unsigned char*) start,(uint32_t) (pos-start)) ||
 
1306
                my_b_write(cache,(unsigned char*) tmp_buff,2))
 
1307
              goto err;
 
1308
            start=pos+1;
 
1309
          }
 
1310
        }
 
1311
        if (my_b_write(cache,(unsigned char*) start,(uint32_t) (pos-start)))
 
1312
          goto err;
1736
1313
      }
1737
 
      else if (my_b_write(&cache,(uchar*) res->ptr(),used_length))
1738
 
        goto err;
 
1314
      else if (my_b_write(cache,(unsigned char*) res->ptr(),used_length))
 
1315
        goto err;
1739
1316
    }
1740
1317
    if (fixed_row_size)
1741
1318
    {                                           // Fill with space
1742
1319
      if (item->max_length > used_length)
1743
1320
      {
1744
 
        /* QQ:  Fix by adding a my_b_fill() function */
1745
 
        if (!space_inited)
1746
 
        {
1747
 
          space_inited=1;
1748
 
          memset(space, ' ', sizeof(space));
1749
 
        }
1750
 
        uint length=item->max_length-used_length;
1751
 
        for (; length > sizeof(space) ; length-=sizeof(space))
1752
 
        {
1753
 
          if (my_b_write(&cache,(uchar*) space,sizeof(space)))
1754
 
            goto err;
1755
 
        }
1756
 
        if (my_b_write(&cache,(uchar*) space,length))
1757
 
          goto err;
 
1321
        /* QQ:  Fix by adding a my_b_fill() function */
 
1322
        if (!space_inited)
 
1323
        {
 
1324
          space_inited=1;
 
1325
          memset(space, ' ', sizeof(space));
 
1326
        }
 
1327
        uint32_t length=item->max_length-used_length;
 
1328
        for (; length > sizeof(space) ; length-=sizeof(space))
 
1329
        {
 
1330
          if (my_b_write(cache,(unsigned char*) space,sizeof(space)))
 
1331
            goto err;
 
1332
        }
 
1333
        if (my_b_write(cache,(unsigned char*) space,length))
 
1334
          goto err;
1758
1335
      }
1759
1336
    }
1760
1337
    if (res && enclosed)
1761
1338
    {
1762
 
      if (my_b_write(&cache, (uchar*) exchange->enclosed->ptr(),
 
1339
      if (my_b_write(cache, (unsigned char*) exchange->enclosed->ptr(),
1763
1340
                     exchange->enclosed->length()))
1764
1341
        goto err;
1765
1342
    }
1766
1343
    if (--items_left)
1767
1344
    {
1768
 
      if (my_b_write(&cache, (uchar*) exchange->field_term->ptr(),
 
1345
      if (my_b_write(cache, (unsigned char*) exchange->field_term->ptr(),
1769
1346
                     field_term_length))
1770
1347
        goto err;
1771
1348
    }
1772
1349
  }
1773
 
  if (my_b_write(&cache,(uchar*) exchange->line_term->ptr(),
1774
 
                 exchange->line_term->length()))
 
1350
  if (my_b_write(cache,(unsigned char*) exchange->line_term->ptr(),
 
1351
                 exchange->line_term->length()))
1775
1352
    goto err;
1776
1353
  return(0);
1777
1354
err:
1785
1362
 
1786
1363
 
1787
1364
int
1788
 
select_dump::prepare(List<Item> &list __attribute__((unused)),
1789
 
                     SELECT_LEX_UNIT *u)
 
1365
select_dump::prepare(List<Item> &, Select_Lex_Unit *u)
1790
1366
{
1791
1367
  unit= u;
1792
 
  return (int) ((file= create_file(thd, path, exchange, &cache)) < 0);
 
1368
  return (int) ((file= create_file(session, path, exchange, cache)) < 0);
1793
1369
}
1794
1370
 
1795
1371
 
1806
1382
    unit->offset_limit_cnt--;
1807
1383
    return(0);
1808
1384
  }
1809
 
  if (row_count++ > 1) 
 
1385
  if (row_count++ > 1)
1810
1386
  {
1811
1387
    my_message(ER_TOO_MANY_ROWS, ER(ER_TOO_MANY_ROWS), MYF(0));
1812
1388
    goto err;
1816
1392
    res=item->str_result(&tmp);
1817
1393
    if (!res)                                   // If NULL
1818
1394
    {
1819
 
      if (my_b_write(&cache,(uchar*) "",1))
 
1395
      if (my_b_write(cache,(unsigned char*) "",1))
1820
1396
        goto err;
1821
1397
    }
1822
 
    else if (my_b_write(&cache,(uchar*) res->ptr(),res->length()))
 
1398
    else if (my_b_write(cache,(unsigned char*) res->ptr(),res->length()))
1823
1399
    {
1824
 
      my_error(ER_ERROR_ON_WRITE, MYF(0), path, my_errno);
 
1400
      my_error(ER_ERROR_ON_WRITE, MYF(0), path, errno);
1825
1401
      goto err;
1826
1402
    }
1827
1403
  }
1852
1428
  }
1853
1429
  List_iterator_fast<Item> li(items);
1854
1430
  Item *val_item;
1855
 
  for (uint i= 0; (val_item= li++); i++)
 
1431
  for (uint32_t i= 0; (val_item= li++); i++)
1856
1432
    it->store(i, val_item);
1857
1433
  it->assigned(1);
1858
1434
  return(0);
1862
1438
void select_max_min_finder_subselect::cleanup()
1863
1439
{
1864
1440
  cache= 0;
1865
 
  return;
1866
1441
}
1867
1442
 
1868
1443
 
1969
1544
     sortcmp(val1, val2, cache->collation.collation) < 0);
1970
1545
}
1971
1546
 
1972
 
bool select_exists_subselect::send_data(List<Item> &items __attribute__((unused)))
 
1547
bool select_exists_subselect::send_data(List<Item> &)
1973
1548
{
1974
1549
  Item_exists_subselect *it= (Item_exists_subselect *)item;
1975
1550
  if (unit->offset_limit_cnt)
1982
1557
  return(0);
1983
1558
}
1984
1559
 
1985
 
 
1986
 
/***************************************************************************
1987
 
  Dump of select to variables
1988
 
***************************************************************************/
1989
 
 
1990
 
int select_dumpvar::prepare(List<Item> &list, SELECT_LEX_UNIT *u)
1991
 
{
1992
 
  unit= u;
1993
 
  
1994
 
  if (var_list.elements != list.elements)
1995
 
  {
1996
 
    my_message(ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT,
1997
 
               ER(ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT), MYF(0));
1998
 
    return 1;
1999
 
  }               
2000
 
  return 0;
2001
 
}
2002
 
 
2003
 
 
2004
 
bool select_dumpvar::check_simple_select() const
2005
 
{
2006
 
  my_error(ER_SP_BAD_CURSOR_SELECT, MYF(0));
2007
 
  return true;
2008
 
}
2009
 
 
2010
 
 
2011
 
void select_dumpvar::cleanup()
2012
 
{
2013
 
  row_count= 0;
2014
 
}
2015
 
 
2016
 
 
2017
 
void Query_arena::free_items()
2018
 
{
2019
 
  Item *next;
2020
 
  /* This works because items are allocated with sql_alloc() */
2021
 
  for (; free_list; free_list= next)
2022
 
  {
2023
 
    next= free_list->next;
2024
 
    free_list->delete_self();
2025
 
  }
2026
 
  /* Postcondition: free_list is 0 */
2027
 
  return;
2028
 
}
2029
 
 
2030
 
 
2031
 
void Query_arena::set_query_arena(Query_arena *set)
2032
 
{
2033
 
  mem_root= set->mem_root;
2034
 
  free_list= set->free_list;
2035
 
  state= set->state;
2036
 
}
2037
 
 
2038
 
 
2039
 
void Query_arena::cleanup_stmt()
2040
 
{
2041
 
  assert("not implemented");
2042
 
}
2043
 
 
2044
1560
/*
2045
 
  Statement functions
 
1561
  Don't free mem_root, as mem_root is freed in the end of dispatch_command
 
1562
  (once for any command).
2046
1563
*/
2047
 
 
2048
 
Statement::Statement(LEX *lex_arg, MEM_ROOT *mem_root_arg,
2049
 
                     enum enum_state state_arg, ulong id_arg)
2050
 
  :Query_arena(mem_root_arg, state_arg),
2051
 
  id(id_arg),
2052
 
  mark_used_columns(MARK_COLUMNS_READ),
2053
 
  lex(lex_arg),
2054
 
  query(0),
2055
 
  query_length(0),
2056
 
  db(NULL),
2057
 
  db_length(0)
2058
 
{
2059
 
  name.str= NULL;
2060
 
}
2061
 
 
2062
 
 
2063
 
void Statement::set_statement(Statement *stmt)
2064
 
{
2065
 
  id=             stmt->id;
2066
 
  mark_used_columns=   stmt->mark_used_columns;
2067
 
  lex=            stmt->lex;
2068
 
  query=          stmt->query;
2069
 
  query_length=   stmt->query_length;
2070
 
}
2071
 
 
2072
 
 
2073
 
void
2074
 
Statement::set_n_backup_statement(Statement *stmt, Statement *backup)
2075
 
{
2076
 
  backup->set_statement(this);
2077
 
  set_statement(stmt);
2078
 
  return;
2079
 
}
2080
 
 
2081
 
 
2082
 
void Statement::restore_backup_statement(Statement *stmt, Statement *backup)
2083
 
{
2084
 
  stmt->set_statement(this);
2085
 
  set_statement(backup);
2086
 
  return;
2087
 
}
2088
 
 
2089
 
 
2090
 
void THD::end_statement()
 
1564
void Session::end_statement()
2091
1565
{
2092
1566
  /* Cleanup SQL processing state to reuse this statement in next query. */
2093
1567
  lex_end(lex);
2094
 
  delete lex->result;
2095
 
  lex->result= 0;
2096
 
  /* Note that free_list is freed in cleanup_after_query() */
2097
 
 
2098
 
  /*
2099
 
    Don't free mem_root, as mem_root is freed in the end of dispatch_command
2100
 
    (once for any command).
2101
 
  */
2102
 
}
2103
 
 
2104
 
 
2105
 
void THD::set_n_backup_active_arena(Query_arena *set, Query_arena *backup)
2106
 
{
2107
 
  assert(backup->is_backup_arena == false);
2108
 
 
2109
 
  backup->set_query_arena(this);
2110
 
  set_query_arena(set);
2111
 
  backup->is_backup_arena= true;
2112
 
  return;
2113
 
}
2114
 
 
2115
 
 
2116
 
void THD::restore_active_arena(Query_arena *set, Query_arena *backup)
2117
 
{
2118
 
  assert(backup->is_backup_arena);
2119
 
  set->set_query_arena(this);
2120
 
  set_query_arena(backup);
2121
 
  backup->is_backup_arena= false;
2122
 
  return;
2123
 
}
2124
 
 
2125
 
 
2126
 
bool THD::copy_db_to(char **p_db, size_t *p_db_length)
2127
 
{
2128
 
  if (db == NULL)
 
1568
}
 
1569
 
 
1570
bool Session::copy_db_to(char **p_db, size_t *p_db_length)
 
1571
{
 
1572
  if (db.empty())
2129
1573
  {
2130
1574
    my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
2131
1575
    return true;
2132
1576
  }
2133
 
  *p_db= strmake(db, db_length);
2134
 
  *p_db_length= db_length;
 
1577
  *p_db= strmake(db.c_str(), db.length());
 
1578
  *p_db_length= db.length();
2135
1579
  return false;
2136
1580
}
2137
1581
 
2138
 
 
2139
 
bool select_dumpvar::send_data(List<Item> &items)
2140
 
{
2141
 
  List_iterator_fast<my_var> var_li(var_list);
2142
 
  List_iterator<Item> it(items);
2143
 
  Item *item;
2144
 
  my_var *mv;
2145
 
 
2146
 
  if (unit->offset_limit_cnt)
2147
 
  {                                             // using limit offset,count
2148
 
    unit->offset_limit_cnt--;
2149
 
    return(0);
2150
 
  }
2151
 
  if (row_count++) 
2152
 
  {
2153
 
    my_message(ER_TOO_MANY_ROWS, ER(ER_TOO_MANY_ROWS), MYF(0));
2154
 
    return(1);
2155
 
  }
2156
 
  while ((mv= var_li++) && (item= it++))
2157
 
  {
2158
 
    if (mv->local == 0)
2159
 
    {
2160
 
      Item_func_set_user_var *suv= new Item_func_set_user_var(mv->s, item);
2161
 
      suv->fix_fields(thd, 0);
2162
 
      suv->check(0);
2163
 
      suv->update();
2164
 
    }
2165
 
  }
2166
 
  return(thd->is_error());
2167
 
}
2168
 
 
2169
 
bool select_dumpvar::send_eof()
2170
 
{
2171
 
  if (! row_count)
2172
 
    push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
2173
 
                 ER_SP_FETCH_NO_DATA, ER(ER_SP_FETCH_NO_DATA));
2174
 
  /*
2175
 
    In order to remember the value of affected rows for ROW_COUNT()
2176
 
    function, SELECT INTO has to have an own SQLCOM.
2177
 
    TODO: split from SQLCOM_SELECT
2178
 
  */
2179
 
  ::my_ok(thd,row_count);
2180
 
  return 0;
2181
 
}
2182
 
 
2183
1582
/****************************************************************************
2184
 
  TMP_TABLE_PARAM
 
1583
  Tmp_Table_Param
2185
1584
****************************************************************************/
2186
1585
 
2187
 
void TMP_TABLE_PARAM::init()
 
1586
void Tmp_Table_Param::init()
2188
1587
{
2189
1588
  field_count= sum_func_count= func_count= hidden_field_count= 0;
2190
1589
  group_parts= group_length= group_null_parts= 0;
2192
1591
  table_charset= 0;
2193
1592
  precomputed_group_by= 0;
2194
1593
  bit_fields_as_long= 0;
2195
 
  return;
2196
1594
}
2197
1595
 
2198
 
 
2199
 
void thd_increment_bytes_sent(ulong length)
 
1596
void Tmp_Table_Param::cleanup(void)
2200
1597
{
2201
 
  THD *thd=current_thd;
2202
 
  if (likely(thd != 0))
2203
 
  { /* current_thd==0 when close_connection() calls net_send_error() */
2204
 
    thd->status_var.bytes_sent+= length;
 
1598
  /* Fix for Intel compiler */
 
1599
  if (copy_field)
 
1600
  {
 
1601
    delete [] copy_field;
 
1602
    save_copy_field= copy_field= 0;
2205
1603
  }
2206
1604
}
2207
1605
 
2208
 
 
2209
 
void thd_increment_bytes_received(ulong length)
2210
 
{
2211
 
  current_thd->status_var.bytes_received+= length;
2212
 
}
2213
 
 
2214
 
 
2215
 
void thd_increment_net_big_packet_count(ulong length)
2216
 
{
2217
 
  current_thd->status_var.net_big_packet_count+= length;
2218
 
}
2219
 
 
2220
 
void THD::send_kill_message() const
 
1606
void Session::send_kill_message() const
2221
1607
{
2222
1608
  int err= killed_errno();
2223
1609
  if (err)
2224
1610
    my_message(err, ER(err), MYF(0));
2225
1611
}
2226
1612
 
2227
 
void THD::set_status_var_init()
 
1613
void Session::set_status_var_init()
2228
1614
{
2229
1615
  memset(&status_var, 0, sizeof(status_var));
2230
1616
}
2231
1617
 
2232
 
 
2233
 
void Security_context::init()
2234
 
{
2235
 
  user= ip= 0;
2236
 
}
2237
 
 
2238
 
 
2239
 
void Security_context::destroy()
2240
 
{
2241
 
  // If not pointer to constant
2242
 
  safeFree(user);
2243
 
  safeFree(ip);
2244
 
}
2245
 
 
2246
 
 
2247
1618
void Security_context::skip_grants()
2248
1619
{
2249
1620
  /* privileges for the user are unknown everything is allowed */
2258
1629
  access to mysql.proc table to find definitions of stored routines.
2259
1630
****************************************************************************/
2260
1631
 
2261
 
void THD::reset_n_backup_open_tables_state(Open_tables_state *backup)
 
1632
void Session::reset_n_backup_open_tables_state(Open_tables_state *backup)
2262
1633
{
2263
1634
  backup->set_open_tables_state(this);
2264
1635
  reset_open_tables_state();
2265
 
  state_flags|= Open_tables_state::BACKUPS_AVAIL;
2266
 
  return;
 
1636
  backups_available= false;
2267
1637
}
2268
1638
 
2269
1639
 
2270
 
void THD::restore_backup_open_tables_state(Open_tables_state *backup)
 
1640
void Session::restore_backup_open_tables_state(Open_tables_state *backup)
2271
1641
{
2272
1642
  /*
2273
1643
    Before we will throw away current open tables state we want
2274
1644
    to be sure that it was properly cleaned up.
2275
1645
  */
2276
1646
  assert(open_tables == 0 && temporary_tables == 0 &&
2277
 
              handler_tables == 0 && derived_tables == 0 &&
2278
 
              lock == 0 && locked_tables == 0);
 
1647
              derived_tables == 0 &&
 
1648
              lock == 0);
2279
1649
  set_open_tables_state(backup);
2280
 
  return;
2281
 
}
 
1650
}
 
1651
 
 
1652
bool Session::set_db(const char *new_db, size_t length)
 
1653
{
 
1654
  /* Do not reallocate memory if current chunk is big enough. */
 
1655
  if (length)
 
1656
    db= new_db;
 
1657
  else
 
1658
    db.clear();
 
1659
 
 
1660
  return false;
 
1661
}
 
1662
 
 
1663
 
 
1664
 
2282
1665
 
2283
1666
/**
2284
1667
  Check the killed state of a user thread
2285
 
  @param thd  user thread
 
1668
  @param session  user thread
2286
1669
  @retval 0 the user thread is active
2287
1670
  @retval 1 the user thread has been killed
2288
1671
*/
2289
 
extern "C" int thd_killed(const DRIZZLE_THD thd)
 
1672
extern "C" int session_killed(const Session *session)
2290
1673
{
2291
 
  return(thd->killed);
 
1674
  return(session->killed);
2292
1675
}
2293
1676
 
2294
1677
/**
2295
 
  Return the thread id of a user thread
2296
 
  @param thd user thread
2297
 
  @return thread id
 
1678
  Return the session id of a user session
 
1679
  @param pointer to Session object
 
1680
  @return session's id
2298
1681
*/
2299
 
extern "C" unsigned long thd_get_thread_id(const DRIZZLE_THD thd)
2300
 
{
2301
 
  return((unsigned long)thd->thread_id);
2302
 
}
2303
 
 
2304
 
 
2305
 
#ifdef INNODB_COMPATIBILITY_HOOKS
2306
 
extern "C" const struct charset_info_st *thd_charset(DRIZZLE_THD thd)
2307
 
{
2308
 
  return(thd->charset());
2309
 
}
2310
 
 
2311
 
extern "C" char **thd_query(DRIZZLE_THD thd)
2312
 
{
2313
 
  return(&thd->query);
2314
 
}
2315
 
 
2316
 
extern "C" int thd_slave_thread(const DRIZZLE_THD thd)
2317
 
{
2318
 
  return(thd->slave_thread);
2319
 
}
2320
 
 
2321
 
extern "C" int thd_non_transactional_update(const DRIZZLE_THD thd)
2322
 
{
2323
 
  return(thd->transaction.all.modified_non_trans_table);
2324
 
}
2325
 
 
2326
 
extern "C" int thd_binlog_format(const DRIZZLE_THD thd)
2327
 
{
2328
 
  return (int) thd->variables.binlog_format;
2329
 
}
2330
 
 
2331
 
extern "C" void thd_mark_transaction_to_rollback(DRIZZLE_THD thd, bool all)
2332
 
{
2333
 
  mark_transaction_to_rollback(thd, all);
2334
 
}
2335
 
#endif // INNODB_COMPATIBILITY_HOOKS */
2336
 
 
 
1682
extern "C" unsigned long session_get_thread_id(const Session *session)
 
1683
{
 
1684
  return (unsigned long) session->getSessionId();
 
1685
}
 
1686
 
 
1687
 
 
1688
const struct charset_info_st *session_charset(Session *session)
 
1689
{
 
1690
  return(session->charset());
 
1691
}
 
1692
 
 
1693
char **session_query(Session *session)
 
1694
{
 
1695
  return(&session->query);
 
1696
}
 
1697
 
 
1698
int session_non_transactional_update(const Session *session)
 
1699
{
 
1700
  return(session->transaction.all.modified_non_trans_table);
 
1701
}
 
1702
 
 
1703
void session_mark_transaction_to_rollback(Session *session, bool all)
 
1704
{
 
1705
  mark_transaction_to_rollback(session, all);
 
1706
}
2337
1707
 
2338
1708
/**
2339
1709
  Mark transaction to rollback and mark error as fatal to a sub-statement.
2340
1710
 
2341
 
  @param  thd   Thread handle
 
1711
  @param  session   Thread handle
2342
1712
  @param  all   true <=> rollback main transaction.
2343
1713
*/
2344
 
 
2345
 
void mark_transaction_to_rollback(THD *thd, bool all)
2346
 
{
2347
 
  if (thd)
2348
 
  {
2349
 
    thd->is_fatal_sub_stmt_error= true;
2350
 
    thd->transaction_rollback_request= all;
2351
 
  }
2352
 
}
2353
 
/***************************************************************************
2354
 
  Handling of XA id cacheing
2355
 
***************************************************************************/
2356
 
 
2357
 
pthread_mutex_t LOCK_xid_cache;
2358
 
HASH xid_cache;
2359
 
 
2360
 
extern "C" uchar *xid_get_hash_key(const uchar *, size_t *, bool);
2361
 
extern "C" void xid_free_hash(void *);
2362
 
 
2363
 
uchar *xid_get_hash_key(const uchar *ptr, size_t *length,
2364
 
                        bool not_used __attribute__((unused)))
2365
 
{
2366
 
  *length=((XID_STATE*)ptr)->xid.key_length();
2367
 
  return ((XID_STATE*)ptr)->xid.key();
2368
 
}
2369
 
 
2370
 
void xid_free_hash(void *ptr)
2371
 
{
2372
 
  if (!((XID_STATE*)ptr)->in_thd)
2373
 
    my_free((uchar*)ptr, MYF(0));
2374
 
}
2375
 
 
2376
 
bool xid_cache_init()
2377
 
{
2378
 
  pthread_mutex_init(&LOCK_xid_cache, MY_MUTEX_INIT_FAST);
2379
 
  return hash_init(&xid_cache, &my_charset_bin, 100, 0, 0,
2380
 
                   xid_get_hash_key, xid_free_hash, 0) != 0;
2381
 
}
2382
 
 
2383
 
void xid_cache_free()
2384
 
{
2385
 
  if (hash_inited(&xid_cache))
2386
 
  {
2387
 
    hash_free(&xid_cache);
2388
 
    pthread_mutex_destroy(&LOCK_xid_cache);
2389
 
  }
2390
 
}
2391
 
 
2392
 
XID_STATE *xid_cache_search(XID *xid)
2393
 
{
2394
 
  pthread_mutex_lock(&LOCK_xid_cache);
2395
 
  XID_STATE *res=(XID_STATE *)hash_search(&xid_cache, xid->key(), xid->key_length());
2396
 
  pthread_mutex_unlock(&LOCK_xid_cache);
2397
 
  return res;
2398
 
}
2399
 
 
2400
 
 
2401
 
bool xid_cache_insert(XID *xid, enum xa_states xa_state)
2402
 
{
2403
 
  XID_STATE *xs;
2404
 
  bool res;
2405
 
  pthread_mutex_lock(&LOCK_xid_cache);
2406
 
  if (hash_search(&xid_cache, xid->key(), xid->key_length()))
2407
 
    res=0;
2408
 
  else if (!(xs=(XID_STATE *)my_malloc(sizeof(*xs), MYF(MY_WME))))
2409
 
    res=1;
2410
 
  else
2411
 
  {
2412
 
    xs->xa_state=xa_state;
2413
 
    xs->xid.set(xid);
2414
 
    xs->in_thd=0;
2415
 
    res=my_hash_insert(&xid_cache, (uchar*)xs);
2416
 
  }
2417
 
  pthread_mutex_unlock(&LOCK_xid_cache);
2418
 
  return res;
2419
 
}
2420
 
 
2421
 
 
2422
 
bool xid_cache_insert(XID_STATE *xid_state)
2423
 
{
2424
 
  pthread_mutex_lock(&LOCK_xid_cache);
2425
 
  assert(hash_search(&xid_cache, xid_state->xid.key(),
2426
 
                          xid_state->xid.key_length())==0);
2427
 
  bool res=my_hash_insert(&xid_cache, (uchar*)xid_state);
2428
 
  pthread_mutex_unlock(&LOCK_xid_cache);
2429
 
  return res;
2430
 
}
2431
 
 
2432
 
 
2433
 
void xid_cache_delete(XID_STATE *xid_state)
2434
 
{
2435
 
  pthread_mutex_lock(&LOCK_xid_cache);
2436
 
  hash_delete(&xid_cache, (uchar *)xid_state);
2437
 
  pthread_mutex_unlock(&LOCK_xid_cache);
2438
 
}
2439
 
 
2440
 
/*
2441
 
  Implementation of interface to write rows to the binary log through the
2442
 
  thread.  The thread is responsible for writing the rows it has
2443
 
  inserted/updated/deleted.
2444
 
*/
2445
 
 
2446
 
#ifndef DRIZZLE_CLIENT
2447
 
 
2448
 
/*
2449
 
  Template member function for ensuring that there is an rows log
2450
 
  event of the apropriate type before proceeding.
2451
 
 
2452
 
  PRE CONDITION:
2453
 
    - Events of type 'RowEventT' have the type code 'type_code'.
2454
 
    
2455
 
  POST CONDITION:
2456
 
    If a non-NULL pointer is returned, the pending event for thread 'thd' will
2457
 
    be an event of type 'RowEventT' (which have the type code 'type_code')
2458
 
    will either empty or have enough space to hold 'needed' bytes.  In
2459
 
    addition, the columns bitmap will be correct for the row, meaning that
2460
 
    the pending event will be flushed if the columns in the event differ from
2461
 
    the columns suppled to the function.
2462
 
 
2463
 
  RETURNS
2464
 
    If no error, a non-NULL pending event (either one which already existed or
2465
 
    the newly created one).
2466
 
    If error, NULL.
2467
 
 */
2468
 
 
2469
 
template <class RowsEventT> Rows_log_event* 
2470
 
THD::binlog_prepare_pending_rows_event(TABLE* table, uint32_t serv_id,
2471
 
                                       size_t needed,
2472
 
                                       bool is_transactional,
2473
 
                                       RowsEventT *hint __attribute__((unused)))
2474
 
{
2475
 
  /* Pre-conditions */
2476
 
  assert(table->s->table_map_id != ~0UL);
2477
 
 
2478
 
  /* Fetch the type code for the RowsEventT template parameter */
2479
 
  int const type_code= RowsEventT::TYPE_CODE;
2480
 
 
2481
 
  /*
2482
 
    There is no good place to set up the transactional data, so we
2483
 
    have to do it here.
2484
 
  */
2485
 
  if (binlog_setup_trx_data())
2486
 
    return(NULL);
2487
 
 
2488
 
  Rows_log_event* pending= binlog_get_pending_rows_event();
2489
 
 
2490
 
  if (unlikely(pending && !pending->is_valid()))
2491
 
    return(NULL);
2492
 
 
2493
 
  /*
2494
 
    Check if the current event is non-NULL and a write-rows
2495
 
    event. Also check if the table provided is mapped: if it is not,
2496
 
    then we have switched to writing to a new table.
2497
 
    If there is no pending event, we need to create one. If there is a pending
2498
 
    event, but it's not about the same table id, or not of the same type
2499
 
    (between Write, Update and Delete), or not the same affected columns, or
2500
 
    going to be too big, flush this event to disk and create a new pending
2501
 
    event.
2502
 
 
2503
 
    The last test is necessary for the Cluster injector to work
2504
 
    correctly. The reason is that the Cluster can inject two write
2505
 
    rows with different column bitmaps if there is an insert followed
2506
 
    by an update in the same transaction, and these are grouped into a
2507
 
    single epoch/transaction when fed to the injector.
2508
 
 
2509
 
    TODO: Fix the code so that the last test can be removed.
2510
 
  */
2511
 
  if (!pending ||
2512
 
      pending->server_id != serv_id || 
2513
 
      pending->get_table_id() != table->s->table_map_id ||
2514
 
      pending->get_type_code() != type_code || 
2515
 
      pending->get_data_size() + needed > opt_binlog_rows_event_max_size ||
2516
 
      !bitmap_cmp(pending->get_cols(), table->write_set))
2517
 
    {
2518
 
    /* Create a new RowsEventT... */
2519
 
    Rows_log_event* const
2520
 
        ev= new RowsEventT(this, table, table->s->table_map_id,
2521
 
                           is_transactional);
2522
 
    if (unlikely(!ev))
2523
 
      return(NULL);
2524
 
    ev->server_id= serv_id; // I don't like this, it's too easy to forget.
2525
 
    /*
2526
 
      flush the pending event and replace it with the newly created
2527
 
      event...
2528
 
    */
2529
 
    if (unlikely(mysql_bin_log.flush_and_set_pending_rows_event(this, ev)))
2530
 
    {
2531
 
      delete ev;
2532
 
      return(NULL);
2533
 
    }
2534
 
 
2535
 
    return(ev);               /* This is the new pending event */
2536
 
  }
2537
 
  return(pending);        /* This is the current pending event */
2538
 
}
2539
 
 
2540
 
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
2541
 
/*
2542
 
  Instantiate the versions we need, we have -fno-implicit-template as
2543
 
  compiling option.
2544
 
*/
2545
 
template Rows_log_event*
2546
 
THD::binlog_prepare_pending_rows_event(TABLE*, uint32_t, size_t, bool,
2547
 
                                       Write_rows_log_event*);
2548
 
 
2549
 
template Rows_log_event*
2550
 
THD::binlog_prepare_pending_rows_event(TABLE*, uint32_t, size_t, bool,
2551
 
                                       Delete_rows_log_event *);
2552
 
 
2553
 
template Rows_log_event* 
2554
 
THD::binlog_prepare_pending_rows_event(TABLE*, uint32_t, size_t, bool,
2555
 
                                       Update_rows_log_event *);
2556
 
#endif
2557
 
 
2558
 
namespace {
2559
 
  /**
2560
 
     Class to handle temporary allocation of memory for row data.
2561
 
 
2562
 
     The responsibilities of the class is to provide memory for
2563
 
     packing one or two rows of packed data (depending on what
2564
 
     constructor is called).
2565
 
 
2566
 
     In order to make the allocation more efficient for "simple" rows,
2567
 
     i.e., rows that do not contain any blobs, a pointer to the
2568
 
     allocated memory is of memory is stored in the table structure
2569
 
     for simple rows.  If memory for a table containing a blob field
2570
 
     is requested, only memory for that is allocated, and subsequently
2571
 
     released when the object is destroyed.
2572
 
 
2573
 
   */
2574
 
  class Row_data_memory {
2575
 
  public:
2576
 
    /**
2577
 
      Build an object to keep track of a block-local piece of memory
2578
 
      for storing a row of data.
2579
 
 
2580
 
      @param table
2581
 
      Table where the pre-allocated memory is stored.
2582
 
 
2583
 
      @param length
2584
 
      Length of data that is needed, if the record contain blobs.
2585
 
     */
2586
 
    Row_data_memory(TABLE *table, size_t const len1)
2587
 
      : m_memory(0)
2588
 
    {
2589
 
      m_alloc_checked= false;
2590
 
      allocate_memory(table, len1);
2591
 
      m_ptr[0]= has_memory() ? m_memory : 0;
2592
 
      m_ptr[1]= 0;
2593
 
    }
2594
 
 
2595
 
    Row_data_memory(TABLE *table, size_t const len1, size_t const len2)
2596
 
      : m_memory(0)
2597
 
    {
2598
 
      m_alloc_checked= false;
2599
 
      allocate_memory(table, len1 + len2);
2600
 
      m_ptr[0]= has_memory() ? m_memory        : 0;
2601
 
      m_ptr[1]= has_memory() ? m_memory + len1 : 0;
2602
 
    }
2603
 
 
2604
 
    ~Row_data_memory()
2605
 
    {
2606
 
      if (m_memory != 0 && m_release_memory_on_destruction)
2607
 
        my_free((uchar*) m_memory, MYF(MY_WME));
2608
 
    }
2609
 
 
2610
 
    /**
2611
 
       Is there memory allocated?
2612
 
 
2613
 
       @retval true There is memory allocated
2614
 
       @retval false Memory allocation failed
2615
 
     */
2616
 
    bool has_memory() const {
2617
 
      m_alloc_checked= true;
2618
 
      return m_memory != 0;
2619
 
    }
2620
 
 
2621
 
    uchar *slot(uint s)
2622
 
    {
2623
 
      assert(s < sizeof(m_ptr)/sizeof(*m_ptr));
2624
 
      assert(m_ptr[s] != 0);
2625
 
      assert(m_alloc_checked == true);
2626
 
      return m_ptr[s];
2627
 
    }
2628
 
 
2629
 
  private:
2630
 
    void allocate_memory(TABLE *const table, size_t const total_length)
2631
 
    {
2632
 
      if (table->s->blob_fields == 0)
2633
 
      {
2634
 
        /*
2635
 
          The maximum length of a packed record is less than this
2636
 
          length. We use this value instead of the supplied length
2637
 
          when allocating memory for records, since we don't know how
2638
 
          the memory will be used in future allocations.
2639
 
 
2640
 
          Since table->s->reclength is for unpacked records, we have
2641
 
          to add two bytes for each field, which can potentially be
2642
 
          added to hold the length of a packed field.
2643
 
        */
2644
 
        size_t const maxlen= table->s->reclength + 2 * table->s->fields;
2645
 
 
2646
 
        /*
2647
 
          Allocate memory for two records if memory hasn't been
2648
 
          allocated. We allocate memory for two records so that it can
2649
 
          be used when processing update rows as well.
2650
 
        */
2651
 
        if (table->write_row_record == 0)
2652
 
          table->write_row_record=
2653
 
            (uchar *) alloc_root(&table->mem_root, 2 * maxlen);
2654
 
        m_memory= table->write_row_record;
2655
 
        m_release_memory_on_destruction= false;
2656
 
      }
2657
 
      else
2658
 
      {
2659
 
        m_memory= (uchar *) my_malloc(total_length, MYF(MY_WME));
2660
 
        m_release_memory_on_destruction= true;
2661
 
      }
2662
 
    }
2663
 
 
2664
 
    mutable bool m_alloc_checked;
2665
 
    bool m_release_memory_on_destruction;
2666
 
    uchar *m_memory;
2667
 
    uchar *m_ptr[2];
2668
 
  };
2669
 
}
2670
 
 
2671
 
 
2672
 
int THD::binlog_write_row(TABLE* table, bool is_trans, 
2673
 
                          uchar const *record) 
2674
 
{ 
2675
 
  assert(current_stmt_binlog_row_based && mysql_bin_log.is_open());
2676
 
 
2677
 
  /*
2678
 
    Pack records into format for transfer. We are allocating more
2679
 
    memory than needed, but that doesn't matter.
2680
 
  */
2681
 
  Row_data_memory memory(table, max_row_length(table, record));
2682
 
  if (!memory.has_memory())
2683
 
    return HA_ERR_OUT_OF_MEM;
2684
 
 
2685
 
  uchar *row_data= memory.slot(0);
2686
 
 
2687
 
  size_t const len= pack_row(table, table->write_set, row_data, record);
2688
 
 
2689
 
  Rows_log_event* const ev=
2690
 
    binlog_prepare_pending_rows_event(table, server_id, len, is_trans,
2691
 
                                      static_cast<Write_rows_log_event*>(0));
2692
 
 
2693
 
  if (unlikely(ev == 0))
2694
 
    return HA_ERR_OUT_OF_MEM;
2695
 
 
2696
 
  return ev->add_row_data(row_data, len);
2697
 
}
2698
 
 
2699
 
int THD::binlog_update_row(TABLE* table, bool is_trans,
2700
 
                           const uchar *before_record,
2701
 
                           const uchar *after_record)
2702
 
{ 
2703
 
  assert(current_stmt_binlog_row_based && mysql_bin_log.is_open());
2704
 
 
2705
 
  size_t const before_maxlen = max_row_length(table, before_record);
2706
 
  size_t const after_maxlen  = max_row_length(table, after_record);
2707
 
 
2708
 
  Row_data_memory row_data(table, before_maxlen, after_maxlen);
2709
 
  if (!row_data.has_memory())
2710
 
    return HA_ERR_OUT_OF_MEM;
2711
 
 
2712
 
  uchar *before_row= row_data.slot(0);
2713
 
  uchar *after_row= row_data.slot(1);
2714
 
 
2715
 
  size_t const before_size= pack_row(table, table->read_set, before_row,
2716
 
                                        before_record);
2717
 
  size_t const after_size= pack_row(table, table->write_set, after_row,
2718
 
                                       after_record);
2719
 
 
2720
 
  Rows_log_event* const ev=
2721
 
    binlog_prepare_pending_rows_event(table, server_id,
2722
 
                                      before_size + after_size, is_trans,
2723
 
                                      static_cast<Update_rows_log_event*>(0));
2724
 
 
2725
 
  if (unlikely(ev == 0))
2726
 
    return HA_ERR_OUT_OF_MEM;
2727
 
 
2728
 
  return
2729
 
    ev->add_row_data(before_row, before_size) ||
2730
 
    ev->add_row_data(after_row, after_size);
2731
 
}
2732
 
 
2733
 
int THD::binlog_delete_row(TABLE* table, bool is_trans, 
2734
 
                           uchar const *record)
2735
 
{ 
2736
 
  assert(current_stmt_binlog_row_based && mysql_bin_log.is_open());
2737
 
 
2738
 
  /* 
2739
 
     Pack records into format for transfer. We are allocating more
2740
 
     memory than needed, but that doesn't matter.
2741
 
  */
2742
 
  Row_data_memory memory(table, max_row_length(table, record));
2743
 
  if (unlikely(!memory.has_memory()))
2744
 
    return HA_ERR_OUT_OF_MEM;
2745
 
 
2746
 
  uchar *row_data= memory.slot(0);
2747
 
 
2748
 
  size_t const len= pack_row(table, table->read_set, row_data, record);
2749
 
 
2750
 
  Rows_log_event* const ev=
2751
 
    binlog_prepare_pending_rows_event(table, server_id, len, is_trans,
2752
 
                                      static_cast<Delete_rows_log_event*>(0));
2753
 
 
2754
 
  if (unlikely(ev == 0))
2755
 
    return HA_ERR_OUT_OF_MEM;
2756
 
 
2757
 
  return ev->add_row_data(row_data, len);
2758
 
}
2759
 
 
2760
 
 
2761
 
int THD::binlog_flush_pending_rows_event(bool stmt_end)
2762
 
{
2763
 
  /*
2764
 
    We shall flush the pending event even if we are not in row-based
2765
 
    mode: it might be the case that we left row-based mode before
2766
 
    flushing anything (e.g., if we have explicitly locked tables).
2767
 
   */
2768
 
  if (!mysql_bin_log.is_open())
2769
 
    return(0);
2770
 
 
2771
 
  /*
2772
 
    Mark the event as the last event of a statement if the stmt_end
2773
 
    flag is set.
2774
 
  */
2775
 
  int error= 0;
2776
 
  if (Rows_log_event *pending= binlog_get_pending_rows_event())
2777
 
  {
2778
 
    if (stmt_end)
2779
 
    {
2780
 
      pending->set_flags(Rows_log_event::STMT_END_F);
2781
 
      pending->flags|= LOG_EVENT_UPDATE_TABLE_MAP_VERSION_F;
2782
 
      binlog_table_maps= 0;
2783
 
    }
2784
 
 
2785
 
    error= mysql_bin_log.flush_and_set_pending_rows_event(this, 0);
2786
 
  }
2787
 
 
2788
 
  return(error);
2789
 
}
2790
 
 
2791
 
 
2792
 
/*
2793
 
  Member function that will log query, either row-based or
2794
 
  statement-based depending on the value of the 'current_stmt_binlog_row_based'
2795
 
  the value of the 'qtype' flag.
2796
 
 
2797
 
  This function should be called after the all calls to ha_*_row()
2798
 
  functions have been issued, but before tables are unlocked and
2799
 
  closed.
2800
 
 
2801
 
  OBSERVE
2802
 
    There shall be no writes to any system table after calling
2803
 
    binlog_query(), so these writes has to be moved to before the call
2804
 
    of binlog_query() for correct functioning.
2805
 
 
2806
 
    This is necessesary not only for RBR, but the master might crash
2807
 
    after binlogging the query but before changing the system tables.
2808
 
    This means that the slave and the master are not in the same state
2809
 
    (after the master has restarted), so therefore we have to
2810
 
    eliminate this problem.
2811
 
 
2812
 
  RETURN VALUE
2813
 
    Error code, or 0 if no error.
2814
 
*/
2815
 
int THD::binlog_query(THD::enum_binlog_query_type qtype, char const *query_arg,
2816
 
                      ulong query_len, bool is_trans, bool suppress_use,
2817
 
                      THD::killed_state killed_status_arg)
2818
 
{
2819
 
  assert(query_arg && mysql_bin_log.is_open());
2820
 
 
2821
 
  if (int error= binlog_flush_pending_rows_event(true))
2822
 
    return(error);
2823
 
 
2824
 
  /*
2825
 
    If we are in statement mode and trying to log an unsafe statement,
2826
 
    we should print a warning.
2827
 
  */
2828
 
  if (lex->is_stmt_unsafe() &&
2829
 
      variables.binlog_format == BINLOG_FORMAT_STMT)
2830
 
  {
2831
 
    assert(this->query != NULL);
2832
 
    push_warning(this, DRIZZLE_ERROR::WARN_LEVEL_WARN,
2833
 
                 ER_BINLOG_UNSAFE_STATEMENT,
2834
 
                 ER(ER_BINLOG_UNSAFE_STATEMENT));
2835
 
    if (!(binlog_flags & BINLOG_FLAG_UNSAFE_STMT_PRINTED))
2836
 
    {
2837
 
      char warn_buf[DRIZZLE_ERRMSG_SIZE];
2838
 
      snprintf(warn_buf, DRIZZLE_ERRMSG_SIZE, "%s Statement: %s",
2839
 
               ER(ER_BINLOG_UNSAFE_STATEMENT), this->query);
2840
 
      sql_print_warning(warn_buf);
2841
 
      binlog_flags|= BINLOG_FLAG_UNSAFE_STMT_PRINTED;
2842
 
    }
2843
 
  }
2844
 
 
2845
 
  switch (qtype) {
2846
 
  case THD::ROW_QUERY_TYPE:
2847
 
    if (current_stmt_binlog_row_based)
2848
 
      return(0);
2849
 
    /* Otherwise, we fall through */
2850
 
  case THD::DRIZZLE_QUERY_TYPE:
2851
 
    /*
2852
 
      Using this query type is a conveniece hack, since we have been
2853
 
      moving back and forth between using RBR for replication of
2854
 
      system tables and not using it.
2855
 
 
2856
 
      Make sure to change in check_table_binlog_row_based() according
2857
 
      to how you treat this.
2858
 
    */
2859
 
  case THD::STMT_QUERY_TYPE:
2860
 
    /*
2861
 
      The DRIZZLE_LOG::write() function will set the STMT_END_F flag and
2862
 
      flush the pending rows event if necessary.
2863
 
     */
2864
 
    {
2865
 
      Query_log_event qinfo(this, query_arg, query_len, is_trans, suppress_use,
2866
 
                            killed_status_arg);
2867
 
      qinfo.flags|= LOG_EVENT_UPDATE_TABLE_MAP_VERSION_F;
2868
 
      /*
2869
 
        Binlog table maps will be irrelevant after a Query_log_event
2870
 
        (they are just removed on the slave side) so after the query
2871
 
        log event is written to the binary log, we pretend that no
2872
 
        table maps were written.
2873
 
       */
2874
 
      int error= mysql_bin_log.write(&qinfo);
2875
 
      binlog_table_maps= 0;
2876
 
      return(error);
2877
 
    }
2878
 
    break;
2879
 
 
2880
 
  case THD::QUERY_TYPE_COUNT:
2881
 
  default:
2882
 
    assert(0 <= qtype && qtype < QUERY_TYPE_COUNT);
2883
 
  }
2884
 
  return(0);
2885
 
}
2886
 
 
2887
 
bool Discrete_intervals_list::append(uint64_t start, uint64_t val,
2888
 
                                 uint64_t incr)
2889
 
{
2890
 
  /* first, see if this can be merged with previous */
2891
 
  if ((head == NULL) || tail->merge_if_contiguous(start, val, incr))
2892
 
  {
2893
 
    /* it cannot, so need to add a new interval */
2894
 
    Discrete_interval *new_interval= new Discrete_interval(start, val, incr);
2895
 
    return(append(new_interval));
2896
 
  }
2897
 
  return(0);
2898
 
}
2899
 
 
2900
 
bool Discrete_intervals_list::append(Discrete_interval *new_interval)
2901
 
{
2902
 
  if (unlikely(new_interval == NULL))
2903
 
    return(1);
2904
 
  if (head == NULL)
2905
 
    head= current= new_interval;
2906
 
  else
2907
 
    tail->next= new_interval;
2908
 
  tail= new_interval;
2909
 
  elements++;
2910
 
  return(0);
2911
 
}
2912
 
 
2913
 
#endif /* !defined(DRIZZLE_CLIENT) */
 
1714
void mark_transaction_to_rollback(Session *session, bool all)
 
1715
{
 
1716
  if (session)
 
1717
  {
 
1718
    session->is_fatal_sub_stmt_error= true;
 
1719
    session->transaction_rollback_request= all;
 
1720
  }
 
1721
}
 
1722
 
 
1723
void Session::disconnect(uint32_t errcode, bool should_lock)
 
1724
{
 
1725
  /* Allow any plugins to cleanup their session variables */
 
1726
  plugin_sessionvar_cleanup(this);
 
1727
 
 
1728
  /* If necessary, log any aborted or unauthorized connections */
 
1729
  if (killed || client->wasAborted())
 
1730
    statistic_increment(aborted_threads, &LOCK_status);
 
1731
 
 
1732
  if (client->wasAborted())
 
1733
  {
 
1734
    if (! killed && variables.log_warnings > 1)
 
1735
    {
 
1736
      Security_context *sctx= &security_ctx;
 
1737
 
 
1738
      errmsg_printf(ERRMSG_LVL_WARN, ER(ER_NEW_ABORTING_CONNECTION)
 
1739
                  , thread_id
 
1740
                  , (db.empty() ? "unconnected" : db.c_str())
 
1741
                  , sctx->user.empty() == false ? sctx->user.c_str() : "unauthenticated"
 
1742
                  , sctx->ip.c_str()
 
1743
                  , (main_da.is_error() ? main_da.message() : ER(ER_UNKNOWN_ERROR)));
 
1744
    }
 
1745
  }
 
1746
 
 
1747
  /* Close out our connection to the client */
 
1748
  if (should_lock)
 
1749
    (void) pthread_mutex_lock(&LOCK_thread_count);
 
1750
  killed= Session::KILL_CONNECTION;
 
1751
  if (client->isConnected())
 
1752
  {
 
1753
    if (errcode)
 
1754
    {
 
1755
      /*my_error(errcode, ER(errcode));*/
 
1756
      client->sendError(errcode, ER(errcode));
 
1757
    }
 
1758
    client->close();
 
1759
  }
 
1760
  if (should_lock)
 
1761
    (void) pthread_mutex_unlock(&LOCK_thread_count);
 
1762
}
 
1763
 
 
1764
void Session::reset_for_next_command()
 
1765
{
 
1766
  free_list= 0;
 
1767
  select_number= 1;
 
1768
  /*
 
1769
    Those two lines below are theoretically unneeded as
 
1770
    Session::cleanup_after_query() should take care of this already.
 
1771
  */
 
1772
  auto_inc_intervals_in_cur_stmt_for_binlog.empty();
 
1773
 
 
1774
  is_fatal_error= false;
 
1775
  server_status&= ~ (SERVER_MORE_RESULTS_EXISTS |
 
1776
                          SERVER_QUERY_NO_INDEX_USED |
 
1777
                          SERVER_QUERY_NO_GOOD_INDEX_USED);
 
1778
  /*
 
1779
    If in autocommit mode and not in a transaction, reset
 
1780
    OPTION_STATUS_NO_TRANS_UPDATE to not get warnings
 
1781
    in ha_rollback_trans() about some tables couldn't be rolled back.
 
1782
  */
 
1783
  if (!(options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)))
 
1784
  {
 
1785
    transaction.all.modified_non_trans_table= false;
 
1786
  }
 
1787
 
 
1788
  clear_error();
 
1789
  main_da.reset_diagnostics_area();
 
1790
  total_warn_count=0;                   // Warnings for this query
 
1791
  sent_row_count= examined_row_count= 0;
 
1792
}
 
1793
 
 
1794
/*
 
1795
  Close all temporary tables created by 'CREATE TEMPORARY TABLE' for thread
 
1796
*/
 
1797
 
 
1798
void Session::close_temporary_tables()
 
1799
{
 
1800
  Table *table;
 
1801
  Table *tmp_next;
 
1802
 
 
1803
  if (!temporary_tables)
 
1804
    return;
 
1805
 
 
1806
  for (table= temporary_tables; table; table= tmp_next)
 
1807
  {
 
1808
    tmp_next= table->next;
 
1809
    close_temporary(table);
 
1810
  }
 
1811
  temporary_tables= NULL;
 
1812
}
 
1813
 
 
1814
/*
 
1815
  unlink from session->temporary tables and close temporary table
 
1816
*/
 
1817
 
 
1818
void Session::close_temporary_table(Table *table)
 
1819
{
 
1820
  if (table->prev)
 
1821
  {
 
1822
    table->prev->next= table->next;
 
1823
    if (table->prev->next)
 
1824
      table->next->prev= table->prev;
 
1825
  }
 
1826
  else
 
1827
  {
 
1828
    /* removing the item from the list */
 
1829
    assert(table == temporary_tables);
 
1830
    /*
 
1831
      slave must reset its temporary list pointer to zero to exclude
 
1832
      passing non-zero value to end_slave via rli->save_temporary_tables
 
1833
      when no temp tables opened, see an invariant below.
 
1834
    */
 
1835
    temporary_tables= table->next;
 
1836
    if (temporary_tables)
 
1837
      table->next->prev= NULL;
 
1838
  }
 
1839
  close_temporary(table);
 
1840
}
 
1841
 
 
1842
/*
 
1843
  Close and delete a temporary table
 
1844
 
 
1845
  NOTE
 
1846
  This dosn't unlink table from session->temporary
 
1847
  If this is needed, use close_temporary_table()
 
1848
*/
 
1849
 
 
1850
void Session::close_temporary(Table *table)
 
1851
{
 
1852
  plugin::StorageEngine *table_type= table->s->db_type();
 
1853
 
 
1854
  table->free_io_cache();
 
1855
  table->closefrm(false);
 
1856
 
 
1857
  rm_temporary_table(table_type, table->s->path.str);
 
1858
 
 
1859
  table->s->free_table_share();
 
1860
 
 
1861
  /* This makes me sad, but we're allocating it via malloc */
 
1862
  free(table);
 
1863
}
 
1864
 
 
1865
/** Clear most status variables. */
 
1866
extern time_t flush_status_time;
 
1867
extern uint32_t max_used_connections;
 
1868
 
 
1869
void Session::refresh_status()
 
1870
{
 
1871
  pthread_mutex_lock(&LOCK_status);
 
1872
 
 
1873
  /* Add thread's status variabes to global status */
 
1874
  add_to_status(&global_status_var, &status_var);
 
1875
 
 
1876
  /* Reset thread's status variables */
 
1877
  memset(&status_var, 0, sizeof(status_var));
 
1878
 
 
1879
  /* Reset some global variables */
 
1880
  reset_status_vars();
 
1881
 
 
1882
  /* Reset the counters of all key caches (default and named). */
 
1883
  reset_key_cache_counters();
 
1884
  flush_status_time= time((time_t*) 0);
 
1885
  max_used_connections= 1; /* We set it to one, because we know we exist */
 
1886
  pthread_mutex_unlock(&LOCK_status);
 
1887
}
 
1888
 
 
1889
user_var_entry *Session::getVariable(LEX_STRING &name, bool create_if_not_exists)
 
1890
{
 
1891
  user_var_entry *entry= NULL;
 
1892
 
 
1893
  entry= (user_var_entry*) hash_search(&user_vars, (unsigned char*) name.str, name.length);
 
1894
 
 
1895
  if ((entry == NULL) && create_if_not_exists)
 
1896
  {
 
1897
    if (!hash_inited(&user_vars))
 
1898
      return NULL;
 
1899
    entry= new (nothrow) user_var_entry(name.str, query_id);
 
1900
 
 
1901
    if (entry == NULL)
 
1902
      return NULL;
 
1903
 
 
1904
    if (my_hash_insert(&user_vars, (unsigned char*) entry))
 
1905
    {
 
1906
      assert(1);
 
1907
      free((char*) entry);
 
1908
      return 0;
 
1909
    }
 
1910
 
 
1911
  }
 
1912
 
 
1913
  return entry;
 
1914
}
 
1915
 
 
1916
void Session::mark_temp_tables_as_free_for_reuse()
 
1917
{
 
1918
  for (Table *table= temporary_tables ; table ; table= table->next)
 
1919
  {
 
1920
    if (table->query_id == query_id)
 
1921
    {
 
1922
      table->query_id= 0;
 
1923
      table->cursor->ha_reset();
 
1924
    }
 
1925
  }
 
1926
}
 
1927
 
 
1928
void Session::mark_used_tables_as_free_for_reuse(Table *table)
 
1929
{
 
1930
  for (; table ; table= table->next)
 
1931
  {
 
1932
    if (table->query_id == query_id)
 
1933
    {
 
1934
      table->query_id= 0;
 
1935
      table->cursor->ha_reset();
 
1936
    }
 
1937
  }
 
1938
}
 
1939
 
 
1940
/*
 
1941
  Unlocks tables and frees derived tables.
 
1942
  Put all normal tables used by thread in free list.
 
1943
 
 
1944
  It will only close/mark as free for reuse tables opened by this
 
1945
  substatement, it will also check if we are closing tables after
 
1946
  execution of complete query (i.e. we are on upper level) and will
 
1947
  leave prelocked mode if needed.
 
1948
*/
 
1949
void Session::close_thread_tables()
 
1950
{
 
1951
  Table *table;
 
1952
 
 
1953
  /*
 
1954
    We are assuming here that session->derived_tables contains ONLY derived
 
1955
    tables for this substatement. i.e. instead of approach which uses
 
1956
    query_id matching for determining which of the derived tables belong
 
1957
    to this substatement we rely on the ability of substatements to
 
1958
    save/restore session->derived_tables during their execution.
 
1959
 
 
1960
    TODO: Probably even better approach is to simply associate list of
 
1961
          derived tables with (sub-)statement instead of thread and destroy
 
1962
          them at the end of its execution.
 
1963
  */
 
1964
  if (derived_tables)
 
1965
  {
 
1966
    Table *next;
 
1967
    /*
 
1968
      Close all derived tables generated in queries like
 
1969
      SELECT * FROM (SELECT * FROM t1)
 
1970
    */
 
1971
    for (table= derived_tables ; table ; table= next)
 
1972
    {
 
1973
      next= table->next;
 
1974
      table->free_tmp_table(this);
 
1975
    }
 
1976
    derived_tables= 0;
 
1977
  }
 
1978
 
 
1979
  /*
 
1980
    Mark all temporary tables used by this statement as free for reuse.
 
1981
  */
 
1982
  mark_temp_tables_as_free_for_reuse();
 
1983
  /*
 
1984
    Let us commit transaction for statement. Since in 5.0 we only have
 
1985
    one statement transaction and don't allow several nested statement
 
1986
    transactions this call will do nothing if we are inside of stored
 
1987
    function or trigger (i.e. statement transaction is already active and
 
1988
    does not belong to statement for which we do close_thread_tables()).
 
1989
    TODO: This should be fixed in later releases.
 
1990
   */
 
1991
  if (backups_available == false)
 
1992
  {
 
1993
    TransactionServices &transaction_services= TransactionServices::singleton();
 
1994
    main_da.can_overwrite_status= true;
 
1995
    transaction_services.ha_autocommit_or_rollback(this, is_error());
 
1996
    main_da.can_overwrite_status= false;
 
1997
    transaction.stmt.reset();
 
1998
  }
 
1999
 
 
2000
  if (lock)
 
2001
  {
 
2002
    /*
 
2003
      For RBR we flush the pending event just before we unlock all the
 
2004
      tables.  This means that we are at the end of a topmost
 
2005
      statement, so we ensure that the STMT_END_F flag is set on the
 
2006
      pending event.  For statements that are *inside* stored
 
2007
      functions, the pending event will not be flushed: that will be
 
2008
      handled either before writing a query log event (inside
 
2009
      binlog_query()) or when preparing a pending event.
 
2010
     */
 
2011
    mysql_unlock_tables(this, lock);
 
2012
    lock= 0;
 
2013
  }
 
2014
  /*
 
2015
    Note that we need to hold LOCK_open while changing the
 
2016
    open_tables list. Another thread may work on it.
 
2017
    (See: remove_table_from_cache(), mysql_wait_completed_table())
 
2018
    Closing a MERGE child before the parent would be fatal if the
 
2019
    other thread tries to abort the MERGE lock in between.
 
2020
  */
 
2021
  if (open_tables)
 
2022
    close_open_tables();
 
2023
}
 
2024
 
 
2025
void Session::close_tables_for_reopen(TableList **tables)
 
2026
{
 
2027
  /*
 
2028
    If table list consists only from tables from prelocking set, table list
 
2029
    for new attempt should be empty, so we have to update list's root pointer.
 
2030
  */
 
2031
  if (lex->first_not_own_table() == *tables)
 
2032
    *tables= 0;
 
2033
  lex->chop_off_not_own_tables();
 
2034
  for (TableList *tmp= *tables; tmp; tmp= tmp->next_global)
 
2035
    tmp->table= 0;
 
2036
  close_thread_tables();
 
2037
}
 
2038
 
 
2039
bool Session::openTablesLock(TableList *tables)
 
2040
{
 
2041
  uint32_t counter;
 
2042
  bool need_reopen;
 
2043
 
 
2044
  for ( ; ; )
 
2045
  {
 
2046
    if (open_tables_from_list(&tables, &counter))
 
2047
      return true;
 
2048
 
 
2049
    if (!lock_tables(tables, counter, &need_reopen))
 
2050
      break;
 
2051
    if (!need_reopen)
 
2052
      return true;
 
2053
    close_tables_for_reopen(&tables);
 
2054
  }
 
2055
  if ((mysql_handle_derived(lex, &mysql_derived_prepare) ||
 
2056
       (fill_derived_tables() &&
 
2057
        mysql_handle_derived(lex, &mysql_derived_filling))))
 
2058
    return true;
 
2059
 
 
2060
  return false;
 
2061
}
 
2062
 
 
2063
bool Session::openTables(TableList *tables, uint32_t flags)
 
2064
{
 
2065
  uint32_t counter;
 
2066
  bool ret= fill_derived_tables();
 
2067
  assert(ret == false);
 
2068
  if (open_tables_from_list(&tables, &counter, flags) ||
 
2069
      mysql_handle_derived(lex, &mysql_derived_prepare))
 
2070
    return true;
 
2071
  return false;
 
2072
}
 
2073
 
 
2074
bool Session::rm_temporary_table(plugin::StorageEngine *base, TableIdentifier &identifier)
 
2075
{
 
2076
  bool error= false;
 
2077
 
 
2078
  assert(base);
 
2079
 
 
2080
  if (plugin::StorageEngine::deleteDefinitionFromPath(identifier))
 
2081
    error= true;
 
2082
 
 
2083
  if (base->doDropTable(*this, identifier.getPath()))
 
2084
  {
 
2085
    error= true;
 
2086
    errmsg_printf(ERRMSG_LVL_WARN, _("Could not remove temporary table: '%s', error: %d"),
 
2087
                  identifier.getPath(), errno);
 
2088
  }
 
2089
  return error;
 
2090
}
 
2091
 
 
2092
bool Session::rm_temporary_table(plugin::StorageEngine *base, const char *path)
 
2093
{
 
2094
  bool error= false;
 
2095
 
 
2096
  assert(base);
 
2097
 
 
2098
  if (delete_table_proto_file(path))
 
2099
    error= true;
 
2100
 
 
2101
  if (base->doDropTable(*this, path))
 
2102
  {
 
2103
    error= true;
 
2104
    errmsg_printf(ERRMSG_LVL_WARN, _("Could not remove temporary table: '%s', error: %d"),
 
2105
                  path, errno);
 
2106
  }
 
2107
  return error;
 
2108
}
 
2109
 
 
2110
} /* namespace drizzled */