← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sys_var.cc

  • Committer: Mark Atwood
  • Date: 2011-11-08 19:06:32 UTC
  • mfrom: (2445.1.22 rf)
  • Revision ID: me@mark.atwood.name-20111108190632-7pfvz4ggbolmlnnu
merge lp:~olafvdspek/drizzle/refactor10

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sys_var.cc
404
404
static void fix_tx_isolation(Session *session, sql_var_t type)
405
405
{
406
406
  if (type == OPT_SESSION)
407
 
    session->session_tx_isolation= ((enum_tx_isolation)
408
 
                                    session->variables.tx_isolation);
 
407
    session->session_tx_isolation= (enum_tx_isolation) session->variables.tx_isolation;
409
408
}
410
409
 
411
410
static void fix_completion_type(Session *, sql_var_t) {}
628
627
 }
629
628
 
630
629
 
631
 
unsigned char *sys_var_session_uint32_t::value_ptr(Session *session,
632
 
                                                sql_var_t type,
633
 
                                                const lex_string_t *)
 
630
unsigned char *sys_var_session_uint32_t::value_ptr(Session *session, sql_var_t type)
634
631
{
635
 
  if (type == OPT_GLOBAL)
636
 
    return (unsigned char*) &(global_system_variables.*offset);
637
 
  return (unsigned char*) &(session->variables.*offset);
 
632
  return type == OPT_GLOBAL
 
633
    ? (unsigned char*) &(global_system_variables.*offset)
 
634
    : (unsigned char*) &(session->variables.*offset);
638
635
}
639
636
 
640
637
 
680
677
}
681
678
 
682
679
 
683
 
unsigned char *sys_var_session_ha_rows::value_ptr(Session *session,
684
 
                                                  sql_var_t type,
685
 
                                                  const lex_string_t *)
 
680
unsigned char *sys_var_session_ha_rows::value_ptr(Session *session, sql_var_t type)
686
681
{
687
 
  if (type == OPT_GLOBAL)
688
 
    return (unsigned char*) &(global_system_variables.*offset);
689
 
  return (unsigned char*) &(session->variables.*offset);
 
682
  return type == OPT_GLOBAL
 
683
    ? (unsigned char*) &(global_system_variables.*offset)
 
684
    : (unsigned char*) &(session->variables.*offset);
690
685
}
691
686
 
692
687
bool sys_var_session_uint64_t::check(Session *session, set_var *var)
738
733
}
739
734
 
740
735
 
741
 
unsigned char *sys_var_session_uint64_t::value_ptr(Session *session,
742
 
                                                   sql_var_t type,
743
 
                                                   const lex_string_t *)
 
736
unsigned char *sys_var_session_uint64_t::value_ptr(Session *session, sql_var_t type)
744
737
{
745
 
  if (type == OPT_GLOBAL)
746
 
    return (unsigned char*) &(global_system_variables.*offset);
747
 
  return (unsigned char*) &(session->variables.*offset);
 
738
  return type == OPT_GLOBAL
 
739
    ? (unsigned char*) &(global_system_variables.*offset)
 
740
    : (unsigned char*) &(session->variables.*offset);
748
741
}
749
742
 
750
743
bool sys_var_session_size_t::check(Session *session, set_var *var)
793
786
}
794
787
 
795
788
 
796
 
unsigned char *sys_var_session_size_t::value_ptr(Session *session,
797
 
                                                 sql_var_t type,
798
 
                                                 const lex_string_t *)
 
789
unsigned char *sys_var_session_size_t::value_ptr(Session *session, sql_var_t type)
799
790
{
800
 
  if (type == OPT_GLOBAL)
801
 
    return (unsigned char*) &(global_system_variables.*offset);
802
 
  return (unsigned char*) &(session->variables.*offset);
 
791
  return type == OPT_GLOBAL
 
792
    ? (unsigned char*) &(global_system_variables.*offset) 
 
793
    : (unsigned char*) &(session->variables.*offset);
803
794
}
804
795
 
805
796
bool sys_var_session_bool::check(Session *session, set_var *var)
827
818
}
828
819
 
829
820
 
830
 
unsigned char *sys_var_session_bool::value_ptr(Session *session,
831
 
                                               sql_var_t type,
832
 
                                               const lex_string_t *)
 
821
unsigned char *sys_var_session_bool::value_ptr(Session *session, sql_var_t type)
833
822
{
834
 
  if (type == OPT_GLOBAL)
835
 
    return (unsigned char*) &(global_system_variables.*offset);
836
 
  return (unsigned char*) &(session->variables.*offset);
 
823
  return type == OPT_GLOBAL
 
824
    ? (unsigned char*) &(global_system_variables.*offset)
 
825
    : (unsigned char*) &(session->variables.*offset);
837
826
}
838
827
 
839
828
 
840
 
bool sys_var::check_enum(Session *,
841
 
                         set_var *var, const TYPELIB *enum_names)
 
829
bool sys_var::check_enum(Session *, set_var *var, const TYPELIB *enum_names)
842
830
{
843
831
  char buff[STRING_BUFFER_USUAL_SIZE];
844
832
  const char *value;
888
876
  If type is not given, return local value if exists, else global.
889
877
*/
890
878
 
891
 
Item *sys_var::item(Session *session, sql_var_t var_type, const lex_string_t *base)
 
879
Item *sys_var::item(Session *session, sql_var_t var_type)
892
880
{
893
881
  if (check_type(var_type))
894
882
  {
895
883
    if (var_type != OPT_DEFAULT)
896
884
    {
897
 
      my_error(ER_INCORRECT_GLOBAL_LOCAL_VAR, MYF(0),
898
 
               name.c_str(), var_type == OPT_GLOBAL ? "SESSION" : "GLOBAL");
 
885
      my_error(ER_INCORRECT_GLOBAL_LOCAL_VAR, MYF(0), name.c_str(), var_type == OPT_GLOBAL ? "SESSION" : "GLOBAL");
899
886
      return 0;
900
887
    }
901
888
    /* As there was no local variable, return the global value */
902
889
    var_type= OPT_GLOBAL;
903
890
  }
904
 
  switch (show_type()) {
 
891
  boost::mutex::scoped_lock lock(session->catalog().systemVariableLock());
 
892
  switch (show_type()) 
 
893
  {
905
894
  case SHOW_LONG:
906
895
  case SHOW_INT:
907
896
  {
908
 
    uint32_t value;
909
 
    boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
910
 
    value= *(uint*) value_ptr(session, var_type, base);
911
 
 
 
897
    uint32_t value= *(uint*) value_ptr(session, var_type);
912
898
    return new Item_uint((uint64_t) value);
913
899
  }
914
900
  case SHOW_LONGLONG:
915
901
  {
916
 
    int64_t value;
917
 
    boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
918
 
    value= *(int64_t*) value_ptr(session, var_type, base);
919
 
 
 
902
    int64_t value= *(int64_t*) value_ptr(session, var_type);
920
903
    return new Item_int(value);
921
904
  }
922
905
  case SHOW_DOUBLE:
923
906
  {
924
 
    double value;
925
 
    {
926
 
      boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
927
 
      value= *(double*) value_ptr(session, var_type, base);
928
 
    }
929
 
 
 
907
    double value= *(double*) value_ptr(session, var_type);
930
908
    /* 6, as this is for now only used with microseconds */
931
909
    return new Item_float(value, 6);
932
910
  }
933
911
  case SHOW_HA_ROWS:
934
912
  {
935
 
    ha_rows value;
936
 
    boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
937
 
    value= *(ha_rows*) value_ptr(session, var_type, base);
938
 
 
 
913
    ha_rows value= *(ha_rows*) value_ptr(session, var_type);
939
914
    return new Item_int((uint64_t) value);
940
915
  }
941
916
  case SHOW_SIZE:
942
917
  {
943
 
    size_t value;
944
 
    boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
945
 
    value= *(size_t*) value_ptr(session, var_type, base);
946
 
 
 
918
    size_t value= *(size_t*) value_ptr(session, var_type);
947
919
    return new Item_int((uint64_t) value);
948
920
  }
949
921
  case SHOW_MY_BOOL:
950
922
  {
951
 
    int32_t value;
952
 
    boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
953
 
    value= *(bool*) value_ptr(session, var_type, base);
954
 
    return new Item_int(value,1);
 
923
    int32_t value= *(bool*) value_ptr(session, var_type);
 
924
    return new Item_int(value, 1);
955
925
  }
956
926
  case SHOW_CHAR_PTR:
957
927
  {
958
 
    Item *tmp;
959
 
    boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
960
 
    char *str= *(char**) value_ptr(session, var_type, base);
961
 
    if (str)
 
928
    if (const char *str= *(char**) value_ptr(session, var_type))
962
929
    {
963
930
      uint32_t length= strlen(str);
964
 
      tmp= new Item_string(session->mem.strdup(str, length), length, system_charset_info, DERIVATION_SYSCONST);
965
 
    }
966
 
    else
967
 
    {
968
 
      tmp= new Item_null();
969
 
      tmp->collation.set(system_charset_info, DERIVATION_SYSCONST);
970
 
    }
971
 
 
 
931
      return new Item_string(session->mem.strdup(str, length), length, system_charset_info, DERIVATION_SYSCONST);
 
932
    }
 
933
    Item* tmp= new Item_null();
 
934
    tmp->collation.set(system_charset_info, DERIVATION_SYSCONST);
972
935
    return tmp;
973
936
  }
974
937
  case SHOW_CHAR:
975
938
  {
976
 
    boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
977
 
    if (const char* str= (char*) value_ptr(session, var_type, base))
 
939
    if (const char* str= (char*) value_ptr(session, var_type))
978
940
      return new Item_string(str_ref(str), system_charset_info, DERIVATION_SYSCONST);
979
941
    Item* tmp= new Item_null();
980
942
    tmp->collation.set(system_charset_info, DERIVATION_SYSCONST);
1006
968
}
1007
969
 
1008
970
 
1009
 
unsigned char *sys_var_session_enum::value_ptr(Session *session,
1010
 
                                               sql_var_t type,
1011
 
                                               const lex_string_t *)
 
971
unsigned char *sys_var_session_enum::value_ptr(Session *session, sql_var_t type)
1012
972
{
1013
 
  uint32_t tmp= ((type == OPT_GLOBAL) ?
1014
 
              global_system_variables.*offset :
1015
 
              session->variables.*offset);
 
973
  uint32_t tmp= type == OPT_GLOBAL ? global_system_variables.*offset : session->variables.*offset;
1016
974
  return (unsigned char*) enum_names->type_names[tmp];
1017
975
}
1018
976
 
1019
977
bool sys_var_session_bit::check(Session *session, set_var *var)
1020
978
{
1021
 
  return (check_enum(session, var, &bool_typelib) ||
1022
 
          (check_func && (*check_func)(session, var)));
 
979
  return check_enum(session, var, &bool_typelib) || (check_func && (*check_func)(session, var));
1023
980
}
1024
981
 
1025
982
bool sys_var_session_bit::update(Session *session, set_var *var)
1026
983
{
1027
 
  int res= (*update_func)(session, var);
1028
 
  return res;
 
984
  return (*update_func)(session, var);
1029
985
}
1030
986
 
1031
987
 
1032
 
unsigned char *sys_var_session_bit::value_ptr(Session *session, sql_var_t,
1033
 
                                              const lex_string_t *)
 
988
unsigned char *sys_var_session_bit::value_ptr(Session *session, sql_var_t)
1034
989
{
1035
990
  /*
1036
991
    If reverse is 0 (default) return 1 if bit is set.
1037
992
    If reverse is 1, return 0 if bit is set
1038
993
  */
1039
 
  session->sys_var_tmp.bool_value= ((session->options & bit_flag) ?
1040
 
                                   !reverse : reverse);
 
994
  session->sys_var_tmp.bool_value= (session->options & bit_flag) ? !reverse : reverse;
1041
995
  return (unsigned char*) &session->sys_var_tmp.bool_value;
1042
996
}
1043
997
 
1094
1048
}
1095
1049
 
1096
1050
 
1097
 
unsigned char *sys_var_collation_sv::value_ptr(Session *session,
1098
 
                                               sql_var_t type,
1099
 
                                               const lex_string_t *)
 
1051
unsigned char *sys_var_collation_sv::value_ptr(Session *session, sql_var_t type)
1100
1052
{
1101
 
  const charset_info_st *cs= ((type == OPT_GLOBAL) ?
1102
 
                           global_system_variables.*offset :
1103
 
                           session->variables.*offset);
 
1053
  const charset_info_st *cs= type == OPT_GLOBAL ? global_system_variables.*offset : session->variables.*offset;
1104
1054
  return cs ? (unsigned char*) cs->name : (unsigned char*) "NULL";
1105
1055
}
1106
1056
 
1119
1069
}
1120
1070
 
1121
1071
 
1122
 
unsigned char *sys_var_timestamp::value_ptr(Session *session, sql_var_t,
1123
 
                                            const lex_string_t *)
 
1072
unsigned char *sys_var_timestamp::value_ptr(Session *session, sql_var_t)
1124
1073
{
1125
1074
  session->sys_var_tmp.int32_t_value= (int32_t) session->times.getCurrentTimestampEpoch();
1126
1075
  return (unsigned char*) &session->sys_var_tmp.int32_t_value;
1134
1083
}
1135
1084
 
1136
1085
 
1137
 
unsigned char *sys_var_last_insert_id::value_ptr(Session *session,
1138
 
                                                 sql_var_t,
1139
 
                                                 const lex_string_t *)
 
1086
unsigned char *sys_var_last_insert_id::value_ptr(Session *session, sql_var_t)
1140
1087
{
1141
1088
  /*
1142
1089
    this tmp var makes it robust againt change of type of
1187
1134
}
1188
1135
 
1189
1136
 
1190
 
unsigned char *sys_var_session_lc_time_names::value_ptr(Session *session,
1191
 
                                                        sql_var_t type,
1192
 
                                                        const lex_string_t *)
 
1137
unsigned char *sys_var_session_lc_time_names::value_ptr(Session *session, sql_var_t type)
1193
1138
{
1194
 
  return type == OPT_GLOBAL ?
1195
 
                 (unsigned char *) global_system_variables.lc_time_names->name :
1196
 
                 (unsigned char *) session->variables.lc_time_names->name;
 
1139
  return type == OPT_GLOBAL 
 
1140
    ? (unsigned char *) global_system_variables.lc_time_names->name 
 
1141
    : (unsigned char *) session->variables.lc_time_names->name;
1197
1142
}
1198
1143
 
1199
1144
 
1294
1239
  else
1295
1240
    session->options|= ((sys_var_session_bit*) var->var)->bit_flag;
1296
1241
 
1297
 
  if (not success)
1298
 
    return true;
1299
 
 
1300
 
  return 0;
 
1242
  return not success;
1301
1243
}
1302
1244
 
1303
1245
static int check_pseudo_thread_id(Session *, set_var *var)
1560
1502
 Functions to handle table_type
1561
1503
****************************************************************************/
1562
1504
 
1563
 
unsigned char *sys_var_session_storage_engine::value_ptr(Session *session,
1564
 
                                                         sql_var_t type,
1565
 
                                                         const lex_string_t *)
 
1505
unsigned char *sys_var_session_storage_engine::value_ptr(Session *session, sql_var_t type)
1566
1506
{
1567
 
  plugin::StorageEngine *engine= session->variables.*offset;
1568
 
  if (type == OPT_GLOBAL)
1569
 
    engine= global_system_variables.*offset;
1570
 
  string engine_name= engine->getName();
1571
 
  return (unsigned char *) session->mem.strdup(engine_name);
 
1507
  plugin::StorageEngine *engine= type == OPT_GLOBAL
 
1508
    ? global_system_variables.*offset
 
1509
    : session->variables.*offset;
 
1510
  return (unsigned char *) session->mem.strdup(engine->getName());
1572
1511
}
1573
1512
 
1574
1513