← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/set_var.cc

  • Committer: Brian Aker
  • Date: 2010-02-14 02:02:48 UTC
  • mfrom: (1273.13.64 fix_is)
  • Revision ID: brian@gaz-20100214020248-bhovaejhz9fmer3q
Merge in data_dictionary.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/set_var.cc
102
102
static bool set_option_autocommit(Session *session, set_var *var);
103
103
static int  check_pseudo_thread_id(Session *session, set_var *var);
104
104
static int check_tx_isolation(Session *session, set_var *var);
105
 
static void fix_tx_isolation(Session *session, enum_var_type type);
 
105
static void fix_tx_isolation(Session *session, sql_var_t type);
106
106
static int check_completion_type(Session *session, set_var *var);
107
 
static void fix_completion_type(Session *session, enum_var_type type);
108
 
static void fix_max_join_size(Session *session, enum_var_type type);
109
 
static void fix_session_mem_root(Session *session, enum_var_type type);
110
 
static void fix_server_id(Session *session, enum_var_type type);
 
107
static void fix_completion_type(Session *session, sql_var_t type);
 
108
static void fix_max_join_size(Session *session, sql_var_t type);
 
109
static void fix_session_mem_root(Session *session, sql_var_t type);
 
110
static void fix_server_id(Session *session, sql_var_t type);
111
111
static bool get_unsigned32(Session *session, set_var *var);
112
112
static bool get_unsigned64(Session *session, set_var *var);
113
113
bool throw_bounds_warning(Session *session, bool fixed, bool unsignd,
344
344
  Set the OPTION_BIG_SELECTS flag if max_join_size == HA_POS_ERROR.
345
345
*/
346
346
 
347
 
static void fix_max_join_size(Session *session, enum_var_type type)
 
347
static void fix_max_join_size(Session *session, sql_var_t type)
348
348
{
349
349
  if (type != OPT_GLOBAL)
350
350
  {
374
374
  If one doesn't use the SESSION modifier, the isolation level
375
375
  is only active for the next command.
376
376
*/
377
 
static void fix_tx_isolation(Session *session, enum_var_type type)
 
377
static void fix_tx_isolation(Session *session, sql_var_t type)
378
378
{
379
379
  if (type == OPT_SESSION)
380
380
    session->session_tx_isolation= ((enum_tx_isolation)
381
381
                                    session->variables.tx_isolation);
382
382
}
383
383
 
384
 
static void fix_completion_type(Session *, enum_var_type) {}
 
384
static void fix_completion_type(Session *, sql_var_t) {}
385
385
 
386
386
static int check_completion_type(Session *, set_var *var)
387
387
{
396
396
}
397
397
 
398
398
 
399
 
static void fix_session_mem_root(Session *session, enum_var_type type)
 
399
static void fix_session_mem_root(Session *session, sql_var_t type)
400
400
{
401
401
  if (type != OPT_GLOBAL)
402
402
    reset_root_defaults(session->mem_root,
404
404
                        session->variables.query_prealloc_size);
405
405
}
406
406
 
407
 
static void fix_server_id(Session *, enum_var_type)
 
407
 
 
408
static void fix_server_id(Session *, sql_var_t)
408
409
{
409
410
}
410
411
 
513
514
}
514
515
 
515
516
 
516
 
void sys_var_uint32_t_ptr::set_default(Session *, enum_var_type)
 
517
void sys_var_uint32_t_ptr::set_default(Session *, sql_var_t)
517
518
{
518
519
  bool not_used;
519
520
  pthread_mutex_lock(&LOCK_global_system_variables);
540
541
}
541
542
 
542
543
 
543
 
void sys_var_uint64_t_ptr::set_default(Session *, enum_var_type)
 
544
void sys_var_uint64_t_ptr::set_default(Session *, sql_var_t)
544
545
{
545
546
  bool not_used;
546
547
  pthread_mutex_lock(&LOCK_global_system_variables);
563
564
}
564
565
 
565
566
 
566
 
void sys_var_size_t_ptr::set_default(Session *, enum_var_type)
 
567
void sys_var_size_t_ptr::set_default(Session *, sql_var_t)
567
568
{
568
569
  bool not_used;
569
570
  pthread_mutex_lock(&LOCK_global_system_variables);
579
580
}
580
581
 
581
582
 
582
 
void sys_var_bool_ptr::set_default(Session *, enum_var_type)
 
583
void sys_var_bool_ptr::set_default(Session *, sql_var_t)
583
584
{
584
585
  *value= (bool) option_limits->def_value;
585
586
}
622
623
 }
623
624
 
624
625
 
625
 
 void sys_var_session_uint32_t::set_default(Session *session, enum_var_type type)
 
626
 void sys_var_session_uint32_t::set_default(Session *session, sql_var_t type)
626
627
 {
627
628
   if (type == OPT_GLOBAL)
628
629
   {
638
639
 
639
640
 
640
641
unsigned char *sys_var_session_uint32_t::value_ptr(Session *session,
641
 
                                                enum_var_type type,
 
642
                                                sql_var_t type,
642
643
                                                const LEX_STRING *)
643
644
{
644
645
  if (type == OPT_GLOBAL)
670
671
}
671
672
 
672
673
 
673
 
void sys_var_session_ha_rows::set_default(Session *session, enum_var_type type)
 
674
void sys_var_session_ha_rows::set_default(Session *session, sql_var_t type)
674
675
{
675
676
  if (type == OPT_GLOBAL)
676
677
  {
688
689
 
689
690
 
690
691
unsigned char *sys_var_session_ha_rows::value_ptr(Session *session,
691
 
                                                  enum_var_type type,
 
692
                                                  sql_var_t type,
692
693
                                                  const LEX_STRING *)
693
694
{
694
695
  if (type == OPT_GLOBAL)
727
728
}
728
729
 
729
730
 
730
 
void sys_var_session_uint64_t::set_default(Session *session, enum_var_type type)
 
731
void sys_var_session_uint64_t::set_default(Session *session, sql_var_t type)
731
732
{
732
733
  if (type == OPT_GLOBAL)
733
734
  {
744
745
 
745
746
 
746
747
unsigned char *sys_var_session_uint64_t::value_ptr(Session *session,
747
 
                                                   enum_var_type type,
 
748
                                                   sql_var_t type,
748
749
                                                   const LEX_STRING *)
749
750
{
750
751
  if (type == OPT_GLOBAL)
780
781
}
781
782
 
782
783
 
783
 
void sys_var_session_size_t::set_default(Session *session, enum_var_type type)
 
784
void sys_var_session_size_t::set_default(Session *session, sql_var_t type)
784
785
{
785
786
  if (type == OPT_GLOBAL)
786
787
  {
797
798
 
798
799
 
799
800
unsigned char *sys_var_session_size_t::value_ptr(Session *session,
800
 
                                                 enum_var_type type,
 
801
                                                 sql_var_t type,
801
802
                                                 const LEX_STRING *)
802
803
{
803
804
  if (type == OPT_GLOBAL)
816
817
}
817
818
 
818
819
 
819
 
void sys_var_session_bool::set_default(Session *session,  enum_var_type type)
 
820
void sys_var_session_bool::set_default(Session *session,  sql_var_t type)
820
821
{
821
822
  if (type == OPT_GLOBAL)
822
823
    global_system_variables.*offset= (bool) option_limits->def_value;
826
827
 
827
828
 
828
829
unsigned char *sys_var_session_bool::value_ptr(Session *session,
829
 
                                               enum_var_type type,
 
830
                                               sql_var_t type,
830
831
                                               const LEX_STRING *)
831
832
{
832
833
  if (type == OPT_GLOBAL)
881
882
  If type is not given, return local value if exists, else global.
882
883
*/
883
884
 
884
 
Item *sys_var::item(Session *session, enum_var_type var_type, const LEX_STRING *base)
 
885
Item *sys_var::item(Session *session, sql_var_t var_type, const LEX_STRING *base)
885
886
{
886
887
  if (check_type(var_type))
887
888
  {
997
998
}
998
999
 
999
1000
 
1000
 
void sys_var_session_enum::set_default(Session *session, enum_var_type type)
 
1001
void sys_var_session_enum::set_default(Session *session, sql_var_t type)
1001
1002
{
1002
1003
  if (type == OPT_GLOBAL)
1003
1004
    global_system_variables.*offset= (uint32_t) option_limits->def_value;
1007
1008
 
1008
1009
 
1009
1010
unsigned char *sys_var_session_enum::value_ptr(Session *session,
1010
 
                                               enum_var_type type,
 
1011
                                               sql_var_t type,
1011
1012
                                               const LEX_STRING *)
1012
1013
{
1013
1014
  uint32_t tmp= ((type == OPT_GLOBAL) ?
1029
1030
}
1030
1031
 
1031
1032
 
1032
 
unsigned char *sys_var_session_bit::value_ptr(Session *session, enum_var_type,
 
1033
unsigned char *sys_var_session_bit::value_ptr(Session *session, sql_var_t,
1033
1034
                                              const LEX_STRING *)
1034
1035
{
1035
1036
  /*
1094
1095
}
1095
1096
 
1096
1097
 
1097
 
void sys_var_collation_sv::set_default(Session *session, enum_var_type type)
 
1098
void sys_var_collation_sv::set_default(Session *session, sql_var_t type)
1098
1099
{
1099
1100
  if (type == OPT_GLOBAL)
1100
1101
    global_system_variables.*offset= *global_default;
1106
1107
 
1107
1108
 
1108
1109
unsigned char *sys_var_collation_sv::value_ptr(Session *session,
1109
 
                                               enum_var_type type,
 
1110
                                               sql_var_t type,
1110
1111
                                               const LEX_STRING *)
1111
1112
{
1112
1113
  const CHARSET_INFO *cs= ((type == OPT_GLOBAL) ?
1124
1125
}
1125
1126
 
1126
1127
 
1127
 
void sys_var_timestamp::set_default(Session *session, enum_var_type)
 
1128
void sys_var_timestamp::set_default(Session *session, sql_var_t)
1128
1129
{
1129
1130
  session->user_time=0;
1130
1131
}
1131
1132
 
1132
1133
 
1133
 
unsigned char *sys_var_timestamp::value_ptr(Session *session, enum_var_type,
 
1134
unsigned char *sys_var_timestamp::value_ptr(Session *session, sql_var_t,
1134
1135
                                            const LEX_STRING *)
1135
1136
{
1136
1137
  session->sys_var_tmp.int32_t_value= (int32_t) session->start_time;
1147
1148
 
1148
1149
 
1149
1150
unsigned char *sys_var_last_insert_id::value_ptr(Session *session,
1150
 
                                                 enum_var_type,
 
1151
                                                 sql_var_t,
1151
1152
                                                 const LEX_STRING *)
1152
1153
{
1153
1154
  /*
1191
1192
 
1192
1193
 
1193
1194
unsigned char *sys_var_session_time_zone::value_ptr(Session *session,
1194
 
                                                    enum_var_type type,
 
1195
                                                    sql_var_t type,
1195
1196
                                                    const LEX_STRING *)
1196
1197
{
1197
1198
  /*
1215
1216
}
1216
1217
 
1217
1218
 
1218
 
void sys_var_session_time_zone::set_default(Session *session, enum_var_type type)
 
1219
void sys_var_session_time_zone::set_default(Session *session, sql_var_t type)
1219
1220
{
1220
1221
 pthread_mutex_lock(&LOCK_global_system_variables);
1221
1222
 if (type == OPT_GLOBAL)
1286
1287
 
1287
1288
 
1288
1289
unsigned char *sys_var_session_lc_time_names::value_ptr(Session *session,
1289
 
                                                        enum_var_type type,
 
1290
                                                        sql_var_t type,
1290
1291
                                                        const LEX_STRING *)
1291
1292
{
1292
1293
  return type == OPT_GLOBAL ?
1295
1296
}
1296
1297
 
1297
1298
 
1298
 
void sys_var_session_lc_time_names::set_default(Session *session, enum_var_type type)
 
1299
void sys_var_session_lc_time_names::set_default(Session *session, sql_var_t type)
1299
1300
{
1300
1301
  if (type == OPT_GLOBAL)
1301
1302
    global_system_variables.lc_time_names= my_default_lc_time_names;
1333
1334
}
1334
1335
 
1335
1336
 
1336
 
void sys_var_microseconds::set_default(Session *session, enum_var_type type)
 
1337
void sys_var_microseconds::set_default(Session *session, sql_var_t type)
1337
1338
{
1338
1339
  int64_t microseconds= (int64_t) (option_limits->def_value * 1000000.0);
1339
1340
  if (type == OPT_GLOBAL)
1884
1885
 
1885
1886
 
1886
1887
unsigned char *sys_var_session_storage_engine::value_ptr(Session *session,
1887
 
                                                         enum_var_type type,
 
1888
                                                         sql_var_t type,
1888
1889
                                                         const LEX_STRING *)
1889
1890
{
1890
1891
  unsigned char* result;
1899
1900
}
1900
1901
 
1901
1902
 
1902
 
void sys_var_session_storage_engine::set_default(Session *session, enum_var_type type)
 
1903
void sys_var_session_storage_engine::set_default(Session *session, sql_var_t type)
1903
1904
{
1904
1905
  plugin::StorageEngine *old_value, *new_value, **value;
1905
1906
  if (type == OPT_GLOBAL)