← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/set_var.h

  • Committer: Brian Aker
  • Date: 2008-10-20 04:28:21 UTC
  • mto: (492.3.21 drizzle-clean-code)
  • mto: This revision was merged to the branch mainline in revision 530.
  • Revision ID: brian@tangent.org-20081020042821-rqqdrccuu8195k3y
Second pass of thd cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/set_var.h
38
38
typedef bool (*sys_update_func)(Session *, set_var *);
39
39
typedef void (*sys_after_update_func)(Session *,enum_var_type);
40
40
typedef void (*sys_set_default_func)(Session *, enum_var_type);
41
 
typedef unsigned char *(*sys_value_ptr_func)(Session *thd);
 
41
typedef unsigned char *(*sys_value_ptr_func)(Session *session);
42
42
 
43
43
struct sys_var_chain
44
44
{
87
87
      chain_arg->first= this;
88
88
    chain_arg->last= this;
89
89
  }
90
 
  virtual bool check(Session *thd, set_var *var);
91
 
  bool check_enum(Session *thd, set_var *var, const TYPELIB *enum_names);
92
 
  bool check_set(Session *thd, set_var *var, TYPELIB *enum_names);
 
90
  virtual bool check(Session *session, set_var *var);
 
91
  bool check_enum(Session *session, set_var *var, const TYPELIB *enum_names);
 
92
  bool check_set(Session *session, set_var *var, TYPELIB *enum_names);
93
93
  bool is_written_to_binlog(enum_var_type type)
94
94
  {
95
95
    return (type == OPT_SESSION || type == OPT_DEFAULT) &&
96
96
      (binlog_status == SESSION_VARIABLE_IN_BINLOG);
97
97
  }
98
 
  virtual bool update(Session *thd, set_var *var)=0;
99
 
  virtual void set_default(Session *thd_arg __attribute__((unused)),
 
98
  virtual bool update(Session *session, set_var *var)=0;
 
99
  virtual void set_default(Session *session_arg __attribute__((unused)),
100
100
                           enum_var_type type __attribute__((unused)))
101
101
  {}
102
102
  virtual SHOW_TYPE show_type() { return SHOW_UNDEF; }
103
 
  virtual unsigned char *value_ptr(Session *thd __attribute__((unused)),
 
103
  virtual unsigned char *value_ptr(Session *session __attribute__((unused)),
104
104
                           enum_var_type type __attribute__((unused)),
105
105
                           LEX_STRING *base __attribute__((unused)))
106
106
  { return 0; }
110
110
  { return type != INT_RESULT; }                /* Assume INT */
111
111
  virtual bool check_default(enum_var_type type __attribute__((unused)))
112
112
  { return option_limits == 0; }
113
 
  Item *item(Session *thd, enum_var_type type, LEX_STRING *base);
 
113
  Item *item(Session *session, enum_var_type type, LEX_STRING *base);
114
114
  virtual bool is_struct() { return 0; }
115
115
  virtual bool is_readonly() const { return 0; }
116
116
  virtual sys_var_pluginvar *cast_pluginvar() { return 0; }
160
160
    :sys_var_global(name_arg, after_update_arg, guard_arg),
161
161
    value(value_ptr_arg)
162
162
  { chain_sys_var(chain); }
163
 
  bool check(Session *thd, set_var *var);
164
 
  bool update(Session *thd, set_var *var);
165
 
  void set_default(Session *thd, enum_var_type type);
 
163
  bool check(Session *session, set_var *var);
 
164
  bool update(Session *session, set_var *var);
 
165
  void set_default(Session *session, enum_var_type type);
166
166
  SHOW_TYPE show_type() { return SHOW_LONG; }
167
 
  unsigned char *value_ptr(Session *thd __attribute__((unused)),
 
167
  unsigned char *value_ptr(Session *session __attribute__((unused)),
168
168
                   enum_var_type type __attribute__((unused)),
169
169
                   LEX_STRING *base __attribute__((unused)))
170
170
  { return (unsigned char*) value; }
194
194
                       sys_after_update_func func)
195
195
    :sys_var(name_arg,func), value(value_ptr_arg)
196
196
  { chain_sys_var(chain); }
197
 
  bool update(Session *thd, set_var *var);
198
 
  void set_default(Session *thd, enum_var_type type);
 
197
  bool update(Session *session, set_var *var);
 
198
  void set_default(Session *session, enum_var_type type);
199
199
  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
200
 
  unsigned char *value_ptr(Session *thd __attribute__((unused)),
 
200
  unsigned char *value_ptr(Session *session __attribute__((unused)),
201
201
                   enum_var_type type __attribute__((unused)),
202
202
                   LEX_STRING *base __attribute__((unused)))
203
203
  { return (unsigned char*) value; }
211
211
  sys_var_bool_ptr(sys_var_chain *chain, const char *name_arg, bool *value_arg)
212
212
    :sys_var(name_arg),value(value_arg)
213
213
  { chain_sys_var(chain); }
214
 
  bool check(Session *thd, set_var *var)
 
214
  bool check(Session *session, set_var *var)
215
215
  {
216
 
    return check_enum(thd, var, &bool_typelib);
 
216
    return check_enum(session, var, &bool_typelib);
217
217
  }
218
 
  bool update(Session *thd, set_var *var);
219
 
  void set_default(Session *thd, enum_var_type type);
 
218
  bool update(Session *session, set_var *var);
 
219
  void set_default(Session *session, enum_var_type type);
220
220
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
221
 
  unsigned char *value_ptr(Session *thd __attribute__((unused)),
 
221
  unsigned char *value_ptr(Session *session __attribute__((unused)),
222
222
                   enum_var_type type __attribute__((unused)),
223
223
                   LEX_STRING *base __attribute__((unused)))
224
224
  { return (unsigned char*) value; }
253
253
    :sys_var(name_arg), value(value_arg), check_func(check_func_arg),
254
254
    update_func(update_func_arg),set_default_func(set_default_func_arg)
255
255
  { chain_sys_var(chain); }
256
 
  bool check(Session *thd, set_var *var);
257
 
  bool update(Session *thd, set_var *var)
 
256
  bool check(Session *session, set_var *var);
 
257
  bool update(Session *session, set_var *var)
258
258
  {
259
 
    return (*update_func)(thd, var);
 
259
    return (*update_func)(session, var);
260
260
  }
261
 
  void set_default(Session *thd, enum_var_type type)
 
261
  void set_default(Session *session, enum_var_type type)
262
262
  {
263
 
    (*set_default_func)(thd, type);
 
263
    (*set_default_func)(session, type);
264
264
  }
265
265
  SHOW_TYPE show_type() { return SHOW_CHAR; }
266
 
  unsigned char *value_ptr(Session *thd __attribute__((unused)),
 
266
  unsigned char *value_ptr(Session *session __attribute__((unused)),
267
267
                   enum_var_type type __attribute__((unused)),
268
268
                   LEX_STRING *base __attribute__((unused)))
269
269
  { return (unsigned char*) value; }
288
288
  {
289
289
    value= new_value;
290
290
  }
291
 
  bool check(Session *thd __attribute__((unused)),
 
291
  bool check(Session *session __attribute__((unused)),
292
292
             set_var *var __attribute__((unused)))
293
293
  {
294
294
    return 1;
295
295
  }
296
 
  bool update(Session *thd __attribute__((unused)),
 
296
  bool update(Session *session __attribute__((unused)),
297
297
              set_var *var __attribute__((unused)))
298
298
  {
299
299
    return 1;
300
300
  }
301
301
  SHOW_TYPE show_type() { return SHOW_CHAR; }
302
 
  unsigned char *value_ptr(Session *thd __attribute__((unused)),
 
302
  unsigned char *value_ptr(Session *session __attribute__((unused)),
303
303
                   enum_var_type type __attribute__((unused)),
304
304
                   LEX_STRING *base __attribute__((unused)))
305
305
  {
322
322
  sys_var_const_str_ptr(sys_var_chain *chain, const char *name_arg, char **value_arg)
323
323
    :sys_var(name_arg),value(value_arg)
324
324
  { chain_sys_var(chain); }
325
 
  bool check(Session *thd __attribute__((unused)),
 
325
  bool check(Session *session __attribute__((unused)),
326
326
             set_var *var __attribute__((unused)))
327
327
  {
328
328
    return 1;
329
329
  }
330
 
  bool update(Session *thd __attribute__((unused)),
 
330
  bool update(Session *session __attribute__((unused)),
331
331
              set_var *var __attribute__((unused)))
332
332
  {
333
333
    return 1;
334
334
  }
335
335
  SHOW_TYPE show_type() { return SHOW_CHAR; }
336
 
  unsigned char *value_ptr(Session *thd __attribute__((unused)),
 
336
  unsigned char *value_ptr(Session *session __attribute__((unused)),
337
337
                   enum_var_type type __attribute__((unused)),
338
338
                   LEX_STRING *base __attribute__((unused)))
339
339
  {
358
358
               TYPELIB *typelib, sys_after_update_func func)
359
359
    :sys_var(name_arg,func), value(value_arg), enum_names(typelib)
360
360
  { chain_sys_var(chain); }
361
 
  bool check(Session *thd, set_var *var)
 
361
  bool check(Session *session, set_var *var)
362
362
  {
363
 
    return check_enum(thd, var, enum_names);
 
363
    return check_enum(session, var, enum_names);
364
364
  }
365
 
  bool update(Session *thd, set_var *var);
 
365
  bool update(Session *session, set_var *var);
366
366
  SHOW_TYPE show_type() { return SHOW_CHAR; }
367
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
 
367
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
368
368
  bool check_update_type(Item_result type __attribute__((unused)))
369
369
  { return 0; }
370
370
};
379
379
      TYPELIB *typelib, sys_after_update_func func)
380
380
    :sys_var(name_arg,func), offset(offset_arg), enum_names(typelib)
381
381
  { chain_sys_var(chain); }
382
 
  bool check(Session *thd __attribute__((unused)),
 
382
  bool check(Session *session __attribute__((unused)),
383
383
             set_var *var __attribute__((unused)))
384
384
  { return 1; }
385
 
  bool update(Session *thd __attribute__((unused)),
 
385
  bool update(Session *session __attribute__((unused)),
386
386
              set_var *var __attribute__((unused)))
387
387
  { return 1; }
388
388
  SHOW_TYPE show_type() { return SHOW_CHAR; }
389
389
  bool check_update_type(Item_result type __attribute__((unused)))
390
390
  { return 1; }
391
391
  bool is_readonly() const { return 1; }
392
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
 
392
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
393
393
};
394
394
 
395
395
 
396
 
class sys_var_thd :public sys_var
 
396
class sys_var_session :public sys_var
397
397
{
398
398
public:
399
 
  sys_var_thd(const char *name_arg, 
 
399
  sys_var_session(const char *name_arg, 
400
400
              sys_after_update_func func= NULL,
401
401
              Binlog_status_enum binlog_status= NOT_IN_BINLOG)
402
402
    :sys_var(name_arg, func, binlog_status)
410
410
};
411
411
 
412
412
 
413
 
class sys_var_thd_ulong :public sys_var_thd
 
413
class sys_var_session_ulong :public sys_var_session
414
414
{
415
415
  sys_check_func check_func;
416
416
public:
417
417
  ulong SV::*offset;
418
 
  sys_var_thd_ulong(sys_var_chain *chain, const char *name_arg,
 
418
  sys_var_session_ulong(sys_var_chain *chain, const char *name_arg,
419
419
                    ulong SV::*offset_arg,
420
420
                    sys_check_func c_func= NULL,
421
421
                    sys_after_update_func au_func= NULL,
422
422
                    Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
423
 
    :sys_var_thd(name_arg, au_func, binlog_status_arg), check_func(c_func),
 
423
    :sys_var_session(name_arg, au_func, binlog_status_arg), check_func(c_func),
424
424
    offset(offset_arg)
425
425
  { chain_sys_var(chain); }
426
 
  bool check(Session *thd, set_var *var);
427
 
  bool update(Session *thd, set_var *var);
428
 
  void set_default(Session *thd, enum_var_type type);
 
426
  bool check(Session *session, set_var *var);
 
427
  bool update(Session *session, set_var *var);
 
428
  void set_default(Session *session, enum_var_type type);
429
429
  SHOW_TYPE show_type() { return SHOW_LONG; }
430
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
 
430
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
431
431
};
432
432
 
433
433
 
434
 
class sys_var_thd_ha_rows :public sys_var_thd
 
434
class sys_var_session_ha_rows :public sys_var_session
435
435
{
436
436
public:
437
437
  ha_rows SV::*offset;
438
 
  sys_var_thd_ha_rows(sys_var_chain *chain, const char *name_arg, 
 
438
  sys_var_session_ha_rows(sys_var_chain *chain, const char *name_arg, 
439
439
                      ha_rows SV::*offset_arg)
440
 
    :sys_var_thd(name_arg), offset(offset_arg)
 
440
    :sys_var_session(name_arg), offset(offset_arg)
441
441
  { chain_sys_var(chain); }
442
 
  sys_var_thd_ha_rows(sys_var_chain *chain, const char *name_arg, 
 
442
  sys_var_session_ha_rows(sys_var_chain *chain, const char *name_arg, 
443
443
                      ha_rows SV::*offset_arg,
444
444
                      sys_after_update_func func)
445
 
    :sys_var_thd(name_arg,func), offset(offset_arg)
 
445
    :sys_var_session(name_arg,func), offset(offset_arg)
446
446
  { chain_sys_var(chain); }
447
 
  bool update(Session *thd, set_var *var);
448
 
  void set_default(Session *thd, enum_var_type type);
 
447
  bool update(Session *session, set_var *var);
 
448
  void set_default(Session *session, enum_var_type type);
449
449
  SHOW_TYPE show_type() { return SHOW_HA_ROWS; }
450
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
 
450
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
451
451
};
452
452
 
453
453
 
454
 
class sys_var_thd_uint64_t :public sys_var_thd
 
454
class sys_var_session_uint64_t :public sys_var_session
455
455
{
456
456
public:
457
457
  uint64_t SV::*offset;
458
458
  bool only_global;
459
 
  sys_var_thd_uint64_t(sys_var_chain *chain, const char *name_arg, 
 
459
  sys_var_session_uint64_t(sys_var_chain *chain, const char *name_arg, 
460
460
                        uint64_t SV::*offset_arg)
461
 
    :sys_var_thd(name_arg), offset(offset_arg)
 
461
    :sys_var_session(name_arg), offset(offset_arg)
462
462
  { chain_sys_var(chain); }
463
 
  sys_var_thd_uint64_t(sys_var_chain *chain, const char *name_arg, 
 
463
  sys_var_session_uint64_t(sys_var_chain *chain, const char *name_arg, 
464
464
                        uint64_t SV::*offset_arg,
465
465
                        sys_after_update_func func, bool only_global_arg)
466
 
    :sys_var_thd(name_arg, func), offset(offset_arg),
 
466
    :sys_var_session(name_arg, func), offset(offset_arg),
467
467
    only_global(only_global_arg)
468
468
  { chain_sys_var(chain); }
469
 
  bool update(Session *thd, set_var *var);
470
 
  void set_default(Session *thd, enum_var_type type);
 
469
  bool update(Session *session, set_var *var);
 
470
  void set_default(Session *session, enum_var_type type);
471
471
  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
472
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
473
 
  bool check(Session *thd, set_var *var);
 
472
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
 
473
  bool check(Session *session, set_var *var);
474
474
  bool check_default(enum_var_type type)
475
475
  {
476
476
    return type == OPT_GLOBAL && !option_limits;
482
482
};
483
483
 
484
484
 
485
 
class sys_var_thd_bool :public sys_var_thd
 
485
class sys_var_session_bool :public sys_var_session
486
486
{
487
487
public:
488
488
  bool SV::*offset;
489
 
  sys_var_thd_bool(sys_var_chain *chain, const char *name_arg, bool SV::*offset_arg)
490
 
    :sys_var_thd(name_arg), offset(offset_arg)
 
489
  sys_var_session_bool(sys_var_chain *chain, const char *name_arg, bool SV::*offset_arg)
 
490
    :sys_var_session(name_arg), offset(offset_arg)
491
491
  { chain_sys_var(chain); }
492
 
  sys_var_thd_bool(sys_var_chain *chain, const char *name_arg, bool SV::*offset_arg,
 
492
  sys_var_session_bool(sys_var_chain *chain, const char *name_arg, bool SV::*offset_arg,
493
493
                   sys_after_update_func func)
494
 
    :sys_var_thd(name_arg,func), offset(offset_arg)
 
494
    :sys_var_session(name_arg,func), offset(offset_arg)
495
495
  { chain_sys_var(chain); }
496
 
  bool update(Session *thd, set_var *var);
497
 
  void set_default(Session *thd, enum_var_type type);
 
496
  bool update(Session *session, set_var *var);
 
497
  void set_default(Session *session, enum_var_type type);
498
498
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
499
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
500
 
  bool check(Session *thd, set_var *var)
 
499
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
 
500
  bool check(Session *session, set_var *var)
501
501
  {
502
 
    return check_enum(thd, var, &bool_typelib);
 
502
    return check_enum(session, var, &bool_typelib);
503
503
  }
504
504
  bool check_update_type(Item_result type __attribute__((unused)))
505
505
  { return 0; }
506
506
};
507
507
 
508
508
 
509
 
class sys_var_thd_enum :public sys_var_thd
 
509
class sys_var_session_enum :public sys_var_session
510
510
{
511
511
protected:
512
512
  ulong SV::*offset;
513
513
  TYPELIB *enum_names;
514
514
  sys_check_func check_func;
515
515
public:
516
 
  sys_var_thd_enum(sys_var_chain *chain, const char *name_arg,
 
516
  sys_var_session_enum(sys_var_chain *chain, const char *name_arg,
517
517
                   ulong SV::*offset_arg, TYPELIB *typelib,
518
518
                   sys_after_update_func func= NULL,
519
519
                   sys_check_func check= NULL)
520
 
    :sys_var_thd(name_arg, func), offset(offset_arg),
 
520
    :sys_var_session(name_arg, func), offset(offset_arg),
521
521
    enum_names(typelib), check_func(check)
522
522
  { chain_sys_var(chain); }
523
 
  bool check(Session *thd, set_var *var)
 
523
  bool check(Session *session, set_var *var)
524
524
  {
525
525
    int ret= 0;
526
526
    if (check_func)
527
 
      ret= (*check_func)(thd, var);
528
 
    return ret ? ret : check_enum(thd, var, enum_names);
 
527
      ret= (*check_func)(session, var);
 
528
    return ret ? ret : check_enum(session, var, enum_names);
529
529
  }
530
 
  bool update(Session *thd, set_var *var);
531
 
  void set_default(Session *thd, enum_var_type type);
 
530
  bool update(Session *session, set_var *var);
 
531
  void set_default(Session *session, enum_var_type type);
532
532
  SHOW_TYPE show_type() { return SHOW_CHAR; }
533
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
 
533
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
534
534
  bool check_update_type(Item_result type __attribute__((unused)))
535
535
  { return 0; }
536
536
};
537
537
 
538
538
 
539
539
 
540
 
class sys_var_thd_optimizer_switch :public sys_var_thd_enum
 
540
class sys_var_session_optimizer_switch :public sys_var_session_enum
541
541
{
542
542
public:
543
 
  sys_var_thd_optimizer_switch(sys_var_chain *chain, const char *name_arg, 
 
543
  sys_var_session_optimizer_switch(sys_var_chain *chain, const char *name_arg, 
544
544
                               ulong SV::*offset_arg)
545
 
    :sys_var_thd_enum(chain, name_arg, offset_arg, &optimizer_switch_typelib)
 
545
    :sys_var_session_enum(chain, name_arg, offset_arg, &optimizer_switch_typelib)
546
546
  {}
547
 
  bool check(Session *thd, set_var *var)
 
547
  bool check(Session *session, set_var *var)
548
548
  {
549
 
    return check_set(thd, var, enum_names);
 
549
    return check_set(session, var, enum_names);
550
550
  }
551
 
  void set_default(Session *thd, enum_var_type type);
552
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
553
 
  static bool symbolic_mode_representation(Session *thd, uint64_t sql_mode,
 
551
  void set_default(Session *session, enum_var_type type);
 
552
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
 
553
  static bool symbolic_mode_representation(Session *session, uint64_t sql_mode,
554
554
                                           LEX_STRING *rep);
555
555
};
556
556
 
557
557
 
558
 
class sys_var_thd_storage_engine :public sys_var_thd
 
558
class sys_var_session_storage_engine :public sys_var_session
559
559
{
560
560
protected:
561
561
  plugin_ref SV::*offset;
562
562
public:
563
 
  sys_var_thd_storage_engine(sys_var_chain *chain, const char *name_arg, 
 
563
  sys_var_session_storage_engine(sys_var_chain *chain, const char *name_arg, 
564
564
                             plugin_ref SV::*offset_arg)
565
 
    :sys_var_thd(name_arg), offset(offset_arg)
 
565
    :sys_var_session(name_arg), offset(offset_arg)
566
566
  { chain_sys_var(chain); }
567
 
  bool check(Session *thd, set_var *var);
 
567
  bool check(Session *session, set_var *var);
568
568
  SHOW_TYPE show_type() { return SHOW_CHAR; }
569
569
  bool check_update_type(Item_result type)
570
570
  {
571
571
    return type != STRING_RESULT;               /* Only accept strings */
572
572
  }
573
 
  void set_default(Session *thd, enum_var_type type);
574
 
  bool update(Session *thd, set_var *var);
575
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
 
573
  void set_default(Session *session, enum_var_type type);
 
574
  bool update(Session *session, set_var *var);
 
575
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
576
576
};
577
577
 
578
 
class sys_var_thd_bit :public sys_var_thd
 
578
class sys_var_session_bit :public sys_var_session
579
579
{
580
580
  sys_check_func check_func;
581
581
  sys_update_func update_func;
582
582
public:
583
583
  uint64_t bit_flag;
584
584
  bool reverse;
585
 
  sys_var_thd_bit(sys_var_chain *chain, const char *name_arg,
 
585
  sys_var_session_bit(sys_var_chain *chain, const char *name_arg,
586
586
                  sys_check_func c_func, sys_update_func u_func,
587
587
                  uint64_t bit, bool reverse_arg=0,
588
588
                  Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
589
 
    :sys_var_thd(name_arg, NULL, binlog_status_arg), check_func(c_func),
 
589
    :sys_var_session(name_arg, NULL, binlog_status_arg), check_func(c_func),
590
590
    update_func(u_func), bit_flag(bit), reverse(reverse_arg)
591
591
  { chain_sys_var(chain); }
592
 
  bool check(Session *thd, set_var *var);
593
 
  bool update(Session *thd, set_var *var);
 
592
  bool check(Session *session, set_var *var);
 
593
  bool update(Session *session, set_var *var);
594
594
  bool check_update_type(Item_result type __attribute__((unused)))
595
595
  { return 0; }
596
596
  bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
597
597
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
598
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
 
598
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
599
599
};
600
600
 
601
601
/* some variables that require special handling */
607
607
                    Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
608
608
    :sys_var(name_arg, NULL, binlog_status_arg)
609
609
  { chain_sys_var(chain); }
610
 
  bool update(Session *thd, set_var *var);
611
 
  void set_default(Session *thd, enum_var_type type);
 
610
  bool update(Session *session, set_var *var);
 
611
  void set_default(Session *session, enum_var_type type);
612
612
  bool check_type(enum_var_type type)    { return type == OPT_GLOBAL; }
613
613
  bool check_default(enum_var_type type __attribute__((unused)))
614
614
  { return 0; }
615
615
  SHOW_TYPE show_type(void) { return SHOW_LONG; }
616
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
 
616
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
617
617
};
618
618
 
619
619
 
624
624
                         Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
625
625
    :sys_var(name_arg, NULL, binlog_status_arg)
626
626
  { chain_sys_var(chain); }
627
 
  bool update(Session *thd, set_var *var);
 
627
  bool update(Session *session, set_var *var);
628
628
  bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
629
629
  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
630
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
 
630
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
631
631
};
632
632
 
633
633
 
637
637
  sys_var_insert_id(sys_var_chain *chain, const char *name_arg)
638
638
    :sys_var(name_arg)
639
639
  { chain_sys_var(chain); }
640
 
  bool update(Session *thd, set_var *var);
 
640
  bool update(Session *session, set_var *var);
641
641
  bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
642
642
  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
643
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
 
643
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
644
644
};
645
645
 
646
646
 
651
651
                     Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
652
652
    :sys_var(name_arg, NULL, binlog_status_arg)
653
653
  { chain_sys_var(chain); }
654
 
  bool update(Session *thd, set_var *var);
 
654
  bool update(Session *session, set_var *var);
655
655
  bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
656
656
};
657
657
 
662
662
                     Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
663
663
    :sys_var(name_arg, NULL, binlog_status_arg)
664
664
  { chain_sys_var(chain); }
665
 
  bool update(Session *thd, set_var *var);
 
665
  bool update(Session *session, set_var *var);
666
666
  bool check_type(enum_var_type type) { return type == OPT_GLOBAL; }
667
667
};
668
668
 
669
669
 
670
 
class sys_var_collation :public sys_var_thd
 
670
class sys_var_collation :public sys_var_session
671
671
{
672
672
public:
673
673
  sys_var_collation(const char *name_arg,
674
674
                    Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
675
 
    :sys_var_thd(name_arg, NULL, binlog_status_arg)
 
675
    :sys_var_session(name_arg, NULL, binlog_status_arg)
676
676
  {
677
677
    no_support_one_shot= 0;
678
678
  }
679
 
  bool check(Session *thd, set_var *var);
 
679
  bool check(Session *session, set_var *var);
680
680
  SHOW_TYPE show_type() { return SHOW_CHAR; }
681
681
  bool check_update_type(Item_result type)
682
682
  {
683
683
    return ((type != STRING_RESULT) && (type != INT_RESULT));
684
684
  }
685
685
  bool check_default(enum_var_type type __attribute__((unused))) { return 0; }
686
 
  virtual void set_default(Session *thd, enum_var_type type)= 0;
 
686
  virtual void set_default(Session *session, enum_var_type type)= 0;
687
687
};
688
688
 
689
 
class sys_var_character_set :public sys_var_thd
 
689
class sys_var_character_set :public sys_var_session
690
690
{
691
691
public:
692
692
  bool nullable;
693
693
  sys_var_character_set(const char *name_arg, bool is_nullable= 0,
694
694
                        Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
695
 
    :sys_var_thd(name_arg, NULL, binlog_status_arg), nullable(is_nullable)
 
695
    :sys_var_session(name_arg, NULL, binlog_status_arg), nullable(is_nullable)
696
696
  {
697
697
    /*
698
698
      In fact only almost all variables derived from sys_var_character_set
700
700
    */
701
701
    no_support_one_shot= 0;
702
702
  }
703
 
  bool check(Session *thd, set_var *var);
 
703
  bool check(Session *session, set_var *var);
704
704
  SHOW_TYPE show_type() { return SHOW_CHAR; }
705
705
  bool check_update_type(Item_result type)
706
706
  {
708
708
  }
709
709
  bool check_default(enum_var_type type __attribute__((unused)))
710
710
  { return 0; }
711
 
  bool update(Session *thd, set_var *var);
712
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
713
 
  virtual void set_default(Session *thd, enum_var_type type)= 0;
714
 
  virtual const CHARSET_INFO **ci_ptr(Session *thd, enum_var_type type)= 0;
 
711
  bool update(Session *session, set_var *var);
 
712
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
 
713
  virtual void set_default(Session *session, enum_var_type type)= 0;
 
714
  virtual const CHARSET_INFO **ci_ptr(Session *session, enum_var_type type)= 0;
715
715
};
716
716
 
717
717
class sys_var_collation_sv :public sys_var_collation
728
728
  {
729
729
    chain_sys_var(chain);
730
730
  }
731
 
  bool update(Session *thd, set_var *var);
732
 
  void set_default(Session *thd, enum_var_type type);
733
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
 
731
  bool update(Session *session, set_var *var);
 
732
  void set_default(Session *session, enum_var_type type);
 
733
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
734
734
};
735
735
 
736
736
 
743
743
                          size_t offset_arg)
744
744
    :sys_var(name_arg), offset(offset_arg)
745
745
  { chain_sys_var(chain); }
746
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
 
746
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
747
747
  bool check_default(enum_var_type type __attribute__((unused)))
748
748
  { return 1; }
749
749
  bool is_struct() { return 1; }
757
757
    :sys_var_key_cache_param(chain, name_arg,
758
758
                             offsetof(KEY_CACHE, param_buff_size))
759
759
  {}
760
 
  bool update(Session *thd, set_var *var);
 
760
  bool update(Session *session, set_var *var);
761
761
  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
762
762
};
763
763
 
768
768
  sys_var_key_cache_long(sys_var_chain *chain, const char *name_arg, size_t offset_arg)
769
769
    :sys_var_key_cache_param(chain, name_arg, offset_arg)
770
770
  {}
771
 
  bool update(Session *thd, set_var *var);
 
771
  bool update(Session *session, set_var *var);
772
772
  SHOW_TYPE show_type() { return SHOW_LONG; }
773
773
};
774
774
 
775
775
 
776
 
class sys_var_thd_date_time_format :public sys_var_thd
 
776
class sys_var_session_date_time_format :public sys_var_session
777
777
{
778
778
  DATE_TIME_FORMAT *SV::*offset;
779
779
  enum enum_drizzle_timestamp_type date_time_type;
780
780
public:
781
 
  sys_var_thd_date_time_format(sys_var_chain *chain, const char *name_arg,
 
781
  sys_var_session_date_time_format(sys_var_chain *chain, const char *name_arg,
782
782
                               DATE_TIME_FORMAT *SV::*offset_arg,
783
783
                               enum enum_drizzle_timestamp_type date_time_type_arg)
784
 
    :sys_var_thd(name_arg), offset(offset_arg),
 
784
    :sys_var_session(name_arg), offset(offset_arg),
785
785
    date_time_type(date_time_type_arg)
786
786
  { chain_sys_var(chain); }
787
787
  SHOW_TYPE show_type() { return SHOW_CHAR; }
791
791
  }
792
792
  bool check_default(enum_var_type type __attribute__((unused)))
793
793
  { return 0; }
794
 
  bool check(Session *thd, set_var *var);
795
 
  bool update(Session *thd, set_var *var);
796
 
  void update2(Session *thd, enum_var_type type, DATE_TIME_FORMAT *new_value);
797
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
798
 
  void set_default(Session *thd, enum_var_type type);
 
794
  bool check(Session *session, set_var *var);
 
795
  bool update(Session *session, set_var *var);
 
796
  void update2(Session *session, enum_var_type type, DATE_TIME_FORMAT *new_value);
 
797
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
 
798
  void set_default(Session *session, enum_var_type type);
799
799
};
800
800
 
801
801
 
806
806
  sys_var_log_state(sys_var_chain *chain, const char *name_arg, bool *value_arg, 
807
807
                    uint32_t log_type_arg)
808
808
    :sys_var_bool_ptr(chain, name_arg, value_arg), log_type(log_type_arg) {}
809
 
  bool update(Session *thd, set_var *var);
810
 
  void set_default(Session *thd, enum_var_type type);
 
809
  bool update(Session *session, set_var *var);
 
810
  void set_default(Session *session, enum_var_type type);
811
811
};
812
812
 
813
813
 
821
821
              TYPELIB *typelib, sys_after_update_func func)
822
822
    :sys_var(name_arg, func), value(value_arg), enum_names(typelib)
823
823
  { chain_sys_var(chain); }
824
 
  virtual bool check(Session *thd, set_var *var)
 
824
  virtual bool check(Session *session, set_var *var)
825
825
  {
826
 
    return check_set(thd, var, enum_names);
 
826
    return check_set(session, var, enum_names);
827
827
  }
828
 
  virtual void set_default(Session *thd __attribute__((unused)),
 
828
  virtual void set_default(Session *session __attribute__((unused)),
829
829
                           enum_var_type type __attribute__((unused)))
830
830
  {
831
831
    *value= 0;
832
832
  }
833
 
  bool update(Session *thd, set_var *var);
834
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
 
833
  bool update(Session *session, set_var *var);
 
834
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
835
835
  bool check_update_type(Item_result type __attribute__((unused)))
836
836
  { return 0; }
837
837
  SHOW_TYPE show_type() { return SHOW_CHAR; }
844
844
                         ulong *value_arg,
845
845
                         TYPELIB *typelib, sys_after_update_func func) :
846
846
    sys_var_set(chain, name_arg, value_arg, typelib, func) {}
847
 
  void set_default(Session *thd, enum_var_type type);
848
 
  bool check(Session *thd, set_var *var);
849
 
  bool update(Session *thd, set_var *var);
 
847
  void set_default(Session *session, enum_var_type type);
 
848
  bool check(Session *session, set_var *var);
 
849
  bool update(Session *session, set_var *var);
850
850
};
851
851
 
852
852
class sys_var_log_output :public sys_var
861
861
    chain_sys_var(chain);
862
862
    set_allow_empty_value(false);
863
863
  }
864
 
  virtual bool check(Session *thd, set_var *var)
 
864
  virtual bool check(Session *session, set_var *var)
865
865
  {
866
 
    return check_set(thd, var, enum_names);
 
866
    return check_set(session, var, enum_names);
867
867
  }
868
 
  bool update(Session *thd, set_var *var);
869
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
 
868
  bool update(Session *session, set_var *var);
 
869
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
870
870
  bool check_update_type(Item_result type __attribute__((unused)))
871
871
  { return 0; }
872
 
  void set_default(Session *thd, enum_var_type type);
 
872
  void set_default(Session *session, enum_var_type type);
873
873
  SHOW_TYPE show_type() { return SHOW_CHAR; }
874
874
};
875
875
 
888
888
    :sys_var(name_arg), var_type(type), 
889
889
       show_type_value(show_type_arg), value_ptr_func(value_ptr_func_arg)
890
890
  { chain_sys_var(chain); }
891
 
  bool update(Session *thd __attribute__((unused)),
 
891
  bool update(Session *session __attribute__((unused)),
892
892
              set_var *var __attribute__((unused)))
893
893
  { return 1; }
894
894
  bool check_default(enum_var_type type __attribute__((unused)))
896
896
  bool check_type(enum_var_type type) { return type != var_type; }
897
897
  bool check_update_type(Item_result type __attribute__((unused)))
898
898
  { return 1; }
899
 
  unsigned char *value_ptr(Session *thd, enum_var_type type __attribute__((unused)),
 
899
  unsigned char *value_ptr(Session *session, enum_var_type type __attribute__((unused)),
900
900
                   LEX_STRING *base __attribute__((unused)))
901
901
  {
902
 
    return (*value_ptr_func)(thd);
 
902
    return (*value_ptr_func)(session);
903
903
  }
904
904
  SHOW_TYPE show_type(void) { return show_type_value; }
905
905
  bool is_readonly(void) const { return 1; }
914
914
  sys_var_have_option(sys_var_chain *chain, const char *variable_name):
915
915
    sys_var(variable_name)
916
916
  { chain_sys_var(chain); }
917
 
  unsigned char *value_ptr(Session *thd __attribute__((unused)),
 
917
  unsigned char *value_ptr(Session *session __attribute__((unused)),
918
918
                   enum_var_type type __attribute__((unused)),
919
919
                   LEX_STRING *base __attribute__((unused)))
920
920
  {
921
921
    return (unsigned char*) show_comp_option_name[get_option()];
922
922
  }
923
 
  bool update(Session *thd __attribute__((unused)),
 
923
  bool update(Session *session __attribute__((unused)),
924
924
              set_var *var __attribute__((unused))) { return 1; }
925
925
  bool check_default(enum_var_type type __attribute__((unused)))
926
926
  { return 1; }
965
965
};
966
966
 
967
967
 
968
 
class sys_var_thd_time_zone :public sys_var_thd
 
968
class sys_var_session_time_zone :public sys_var_session
969
969
{
970
970
public:
971
 
  sys_var_thd_time_zone(sys_var_chain *chain, const char *name_arg,
 
971
  sys_var_session_time_zone(sys_var_chain *chain, const char *name_arg,
972
972
                        Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
973
 
    :sys_var_thd(name_arg, NULL, binlog_status_arg)
 
973
    :sys_var_session(name_arg, NULL, binlog_status_arg)
974
974
  {
975
975
    no_support_one_shot= 0;
976
976
    chain_sys_var(chain);
977
977
  }
978
 
  bool check(Session *thd, set_var *var);
 
978
  bool check(Session *session, set_var *var);
979
979
  SHOW_TYPE show_type() { return SHOW_CHAR; }
980
980
  bool check_update_type(Item_result type)
981
981
  {
983
983
  }
984
984
  bool check_default(enum_var_type type __attribute__((unused)))
985
985
  { return 0; }
986
 
  bool update(Session *thd, set_var *var);
987
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
988
 
  virtual void set_default(Session *thd, enum_var_type type);
 
986
  bool update(Session *session, set_var *var);
 
987
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
 
988
  virtual void set_default(Session *session, enum_var_type type);
989
989
};
990
990
 
991
991
 
992
 
class sys_var_max_user_conn : public sys_var_thd
 
992
class sys_var_max_user_conn : public sys_var_session
993
993
{
994
994
public:
995
995
  sys_var_max_user_conn(sys_var_chain *chain, const char *name_arg):
996
 
    sys_var_thd(name_arg)
 
996
    sys_var_session(name_arg)
997
997
  { chain_sys_var(chain); }
998
 
  bool check(Session *thd, set_var *var);
999
 
  bool update(Session *thd, set_var *var);
 
998
  bool check(Session *session, set_var *var);
 
999
  bool update(Session *session, set_var *var);
1000
1000
  bool check_default(enum_var_type type)
1001
1001
  {
1002
1002
    return type != OPT_GLOBAL || !option_limits;
1003
1003
  }
1004
 
  void set_default(Session *thd, enum_var_type type);
 
1004
  void set_default(Session *session, enum_var_type type);
1005
1005
  SHOW_TYPE show_type() { return SHOW_INT; }
1006
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
 
1006
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
1007
1007
};
1008
1008
 
1009
1009
 
1010
 
class sys_var_microseconds :public sys_var_thd
 
1010
class sys_var_microseconds :public sys_var_session
1011
1011
{
1012
1012
  uint64_t SV::*offset;
1013
1013
public:
1014
1014
  sys_var_microseconds(sys_var_chain *chain, const char *name_arg,
1015
1015
                       uint64_t SV::*offset_arg):
1016
 
    sys_var_thd(name_arg), offset(offset_arg)
 
1016
    sys_var_session(name_arg), offset(offset_arg)
1017
1017
  { chain_sys_var(chain); }
1018
 
  bool check(Session *thd __attribute__((unused)),
 
1018
  bool check(Session *session __attribute__((unused)),
1019
1019
             set_var *var __attribute__((unused))) {return 0;}
1020
 
  bool update(Session *thd, set_var *var);
1021
 
  void set_default(Session *thd, enum_var_type type);
 
1020
  bool update(Session *session, set_var *var);
 
1021
  void set_default(Session *session, enum_var_type type);
1022
1022
  SHOW_TYPE show_type() { return SHOW_DOUBLE; }
1023
1023
  bool check_update_type(Item_result type)
1024
1024
  {
1025
1025
    return (type != INT_RESULT && type != REAL_RESULT && type != DECIMAL_RESULT);
1026
1026
  }
1027
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
 
1027
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
1028
1028
};
1029
1029
 
1030
1030
/**
1038
1038
                       bool *value_arg) :
1039
1039
    sys_var_bool_ptr(chain, name_arg, value_arg) {};
1040
1040
  ~sys_var_opt_readonly() {};
1041
 
  bool update(Session *thd, set_var *var);
 
1041
  bool update(Session *session, set_var *var);
1042
1042
};
1043
1043
 
1044
1044
 
1045
 
class sys_var_thd_lc_time_names :public sys_var_thd
 
1045
class sys_var_session_lc_time_names :public sys_var_session
1046
1046
{
1047
1047
public:
1048
 
  sys_var_thd_lc_time_names(sys_var_chain *chain, const char *name_arg,
 
1048
  sys_var_session_lc_time_names(sys_var_chain *chain, const char *name_arg,
1049
1049
                            Binlog_status_enum binlog_status_arg= NOT_IN_BINLOG)
1050
 
    : sys_var_thd(name_arg, NULL, binlog_status_arg)
 
1050
    : sys_var_session(name_arg, NULL, binlog_status_arg)
1051
1051
  {
1052
1052
#if DRIZZLE_VERSION_ID < 50000
1053
1053
    no_support_one_shot= 0;
1054
1054
#endif
1055
1055
    chain_sys_var(chain);
1056
1056
  }
1057
 
  bool check(Session *thd, set_var *var);
 
1057
  bool check(Session *session, set_var *var);
1058
1058
  SHOW_TYPE show_type() { return SHOW_CHAR; }
1059
1059
  bool check_update_type(Item_result type)
1060
1060
  {
1062
1062
  }
1063
1063
  bool check_default(enum_var_type type __attribute__((unused)))
1064
1064
  { return 0; }
1065
 
  bool update(Session *thd, set_var *var);
1066
 
  unsigned char *value_ptr(Session *thd, enum_var_type type, LEX_STRING *base);
1067
 
  virtual void set_default(Session *thd, enum_var_type type);
 
1065
  bool update(Session *session, set_var *var);
 
1066
  unsigned char *value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
 
1067
  virtual void set_default(Session *session, enum_var_type type);
1068
1068
};
1069
1069
 
1070
1070
 
1071
 
extern void fix_binlog_format_after_update(Session *thd, enum_var_type type);
 
1071
extern void fix_binlog_format_after_update(Session *session, enum_var_type type);
1072
1072
 
1073
 
class sys_var_thd_binlog_format :public sys_var_thd_enum
 
1073
class sys_var_session_binlog_format :public sys_var_session_enum
1074
1074
{
1075
1075
public:
1076
 
  sys_var_thd_binlog_format(sys_var_chain *chain, const char *name_arg, 
 
1076
  sys_var_session_binlog_format(sys_var_chain *chain, const char *name_arg, 
1077
1077
                            ulong SV::*offset_arg)
1078
 
    :sys_var_thd_enum(chain, name_arg, offset_arg,
 
1078
    :sys_var_session_enum(chain, name_arg, offset_arg,
1079
1079
                      &binlog_format_typelib,
1080
1080
                      fix_binlog_format_after_update)
1081
1081
  {};
1091
1091
public:
1092
1092
  set_var_base() {}
1093
1093
  virtual ~set_var_base() {}
1094
 
  virtual int check(Session *thd)=0;    /* To check privileges etc. */
1095
 
  virtual int update(Session *thd)=0;   /* To set the value */
 
1094
  virtual int check(Session *session)=0;        /* To check privileges etc. */
 
1095
  virtual int update(Session *session)=0;       /* To set the value */
1096
1096
  /* light check for PS */
1097
1097
  virtual bool no_support_one_shot() { return 1; }
1098
1098
};
1137
1137
    else
1138
1138
      value=value_arg;
1139
1139
  }
1140
 
  int check(Session *thd);
1141
 
  int update(Session *thd);
 
1140
  int check(Session *session);
 
1141
  int update(Session *session);
1142
1142
  bool no_support_one_shot() { return var->no_support_one_shot; }
1143
1143
};
1144
1144
 
1152
1152
  set_var_user(Item_func_set_user_var *item)
1153
1153
    :user_var_item(item)
1154
1154
  {}
1155
 
  int check(Session *thd);
1156
 
  int update(Session *thd);
 
1155
  int check(Session *session);
 
1156
  int update(Session *session);
1157
1157
};
1158
1158
 
1159
1159
/* For SET NAMES and SET CHARACTER SET */
1171
1171
     character_set_results(result_coll_arg),
1172
1172
     collation_connection(connection_coll_arg)
1173
1173
  {}
1174
 
  int check(Session *thd);
1175
 
  int update(Session *thd);
 
1174
  int check(Session *session);
 
1175
  int update(Session *session);
1176
1176
};
1177
1177
 
1178
1178
 
1212
1212
 
1213
1213
/* updated in sql_acl.cc */
1214
1214
 
1215
 
extern sys_var_thd_bool sys_old_alter_table;
 
1215
extern sys_var_session_bool sys_old_alter_table;
1216
1216
extern LEX_STRING default_key_cache_base;
1217
1217
 
1218
1218
/* For sql_yacc */
1229
1229
int set_var_init();
1230
1230
void set_var_free();
1231
1231
int mysql_append_static_vars(const SHOW_VAR *show_vars, uint32_t count);
1232
 
SHOW_VAR* enumerate_sys_vars(Session *thd, bool sorted);
 
1232
SHOW_VAR* enumerate_sys_vars(Session *session, bool sorted);
1233
1233
int mysql_add_sys_var_chain(sys_var *chain, struct my_option *long_options);
1234
1234
int mysql_del_sys_var_chain(sys_var *chain);
1235
 
sys_var *find_sys_var(Session *thd, const char *str, uint32_t length=0);
1236
 
int sql_set_variables(Session *thd, List<set_var_base> *var_list);
 
1235
sys_var *find_sys_var(Session *session, const char *str, uint32_t length=0);
 
1236
int sql_set_variables(Session *session, List<set_var_base> *var_list);
1237
1237
bool not_all_support_one_shot(List<set_var_base> *var_list);
1238
 
void fix_delay_key_write(Session *thd, enum_var_type type);
 
1238
void fix_delay_key_write(Session *session, enum_var_type type);
1239
1239
void fix_slave_exec_mode(enum_var_type type);
1240
1240
extern sys_var_str sys_init_connect;
1241
1241
extern sys_var_str sys_init_slave;
1242
 
extern sys_var_thd_time_zone sys_time_zone;
1243
 
extern sys_var_thd_bit sys_autocommit;
 
1242
extern sys_var_session_time_zone sys_time_zone;
 
1243
extern sys_var_session_bit sys_autocommit;
1244
1244
const CHARSET_INFO *get_old_charset_by_name(const char *old_name);
1245
1245
unsigned char* find_named(I_List<NAMED_LIST> *list, const char *name, uint32_t length,
1246
1246
                NAMED_LIST **found);