← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_base.cc

  • Committer: Andrew Hutchings
  • Date: 2011-02-02 12:51:57 UTC
  • mto: (2157.1.1 build)
  • mto: This revision was merged to the branch mainline in revision 2158.
  • Revision ID: andrew@linuxjedi.co.uk-20110202125157-r6thh7ox4g9l90ec
https://launchpad.net/bugs/711068
Make transaction_message_threshold a read-only global variable instead of a per-session variable
Make replication_dictionary column lengths use transation_message_threshold

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_base.cc
15
15
 
16
16
 
17
17
/* Basic functions needed by many modules */
18
 
#include <config.h>
 
18
#include "config.h"
19
19
#include <assert.h>
20
20
 
21
21
#include <signal.h>
30
30
#  include <time.h>
31
31
# endif
32
32
#endif
33
 
#include <drizzled/internal/my_pthread.h>
34
 
#include <drizzled/internal/thread_var.h>
 
33
#include "drizzled/internal/my_pthread.h"
 
34
#include "drizzled/internal/thread_var.h"
35
35
 
36
36
#include <drizzled/sql_select.h>
37
37
#include <drizzled/error.h>
44
44
#include <drizzled/check_stack_overrun.h>
45
45
#include <drizzled/lock.h>
46
46
#include <drizzled/plugin/listen.h>
47
 
#include <drizzled/cached_directory.h>
 
47
#include "drizzled/cached_directory.h"
48
48
#include <drizzled/field/epoch.h>
49
49
#include <drizzled/field/null.h>
50
 
#include <drizzled/sql_table.h>
51
 
#include <drizzled/global_charset_info.h>
52
 
#include <drizzled/pthread_globals.h>
53
 
#include <drizzled/internal/iocache.h>
54
 
#include <drizzled/drizzled.h>
55
 
#include <drizzled/plugin/authorization.h>
56
 
#include <drizzled/table/temporary.h>
57
 
#include <drizzled/table/placeholder.h>
58
 
#include <drizzled/table/unused.h>
59
 
#include <drizzled/plugin/storage_engine.h>
60
 
#include <drizzled/session.h>
61
 
 
62
 
#include <drizzled/refresh_version.h>
 
50
#include "drizzled/sql_table.h"
 
51
#include "drizzled/global_charset_info.h"
 
52
#include "drizzled/pthread_globals.h"
 
53
#include "drizzled/internal/iocache.h"
 
54
#include "drizzled/drizzled.h"
 
55
#include "drizzled/plugin/authorization.h"
 
56
#include "drizzled/table/temporary.h"
 
57
#include "drizzled/table/placeholder.h"
 
58
#include "drizzled/table/unused.h"
63
59
 
64
60
using namespace std;
65
61
 
148
144
  if (sort.io_cache)
149
145
  {
150
146
    sort.io_cache->close_cached_file();
151
 
    safe_delete(sort.io_cache);
 
147
    delete sort.io_cache;
 
148
    sort.io_cache= 0;
152
149
  }
153
150
}
154
151
 
578
575
}
579
576
 
580
577
int Open_tables_state::doGetTableDefinition(const identifier::Table &identifier,
581
 
                                            message::Table &table_proto)
 
578
                                  message::Table &table_proto)
582
579
{
583
580
  for (Table *table= getTemporaryTables() ; table ; table= table->getNext())
584
581
  {
586
583
    {
587
584
      if (identifier.getKey() == table->getShare()->getCacheKey())
588
585
      {
589
 
        table_proto.CopyFrom(*(table->getShare()->getTableMessage()));
 
586
        table_proto.CopyFrom(*(table->getShare()->getTableProto()));
590
587
 
591
588
        return EEXIST;
592
589
      }
807
804
 
808
805
  if (not table::Cache::singleton().insert(table))
809
806
  {
810
 
    safe_delete(table);
 
807
    delete table;
811
808
 
812
809
    return NULL;
813
810
  }
953
950
  {
954
951
    if (flags & DRIZZLE_OPEN_TEMPORARY_ONLY)
955
952
    {
956
 
      my_error(ER_TABLE_UNKNOWN, identifier);
 
953
      my_error(ER_NO_SUCH_TABLE, MYF(0), table_list->getSchemaName(), table_list->getTableName());
957
954
      return NULL;
958
955
    }
959
956
 
1004
1001
    */
1005
1002
 
1006
1003
    {
1007
 
      boost::mutex::scoped_lock scopedLock(table::Cache::singleton().mutex());
 
1004
      table::Cache::singleton().mutex().lock(); /* Lock for FLUSH TABLES for open table */
1008
1005
 
1009
1006
      /*
1010
1007
        Actually try to find the table in the open_cache.
1056
1053
          /* Avoid self-deadlocks by detecting self-dependencies. */
1057
1054
          if (table->open_placeholder && table->in_use == this)
1058
1055
          {
 
1056
            table::Cache::singleton().mutex().unlock();
1059
1057
            my_error(ER_UPDATE_TABLE_USED, MYF(0), table->getShare()->getTableName());
1060
1058
            return NULL;
1061
1059
          }
1090
1088
          {
1091
1089
            /* wait_for_conditionwill unlock table::Cache::singleton().mutex() for us */
1092
1090
            wait_for_condition(table::Cache::singleton().mutex(), COND_refresh);
1093
 
            scopedLock.release();
1094
1091
          }
1095
1092
          else
1096
1093
          {
1097
 
            scopedLock.unlock();
 
1094
            table::Cache::singleton().mutex().unlock();
1098
1095
          }
1099
 
 
1100
1096
          /*
1101
1097
            There is a refresh in progress for this table.
1102
1098
            Signal the caller that it has to try again.
1103
1099
          */
1104
1100
          if (refresh)
1105
1101
            *refresh= true;
1106
 
 
1107
1102
          return NULL;
1108
1103
        }
1109
1104
      }
1110
 
 
1111
1105
      if (table)
1112
1106
      {
1113
1107
        table::getUnused().unlink(static_cast<table::Concurrent *>(table));
1131
1125
            */
1132
1126
            if (!(table= table_cache_insert_placeholder(lock_table_identifier)))
1133
1127
            {
 
1128
              table::Cache::singleton().mutex().unlock();
1134
1129
              return NULL;
1135
1130
            }
1136
1131
            /*
1141
1136
            table->open_placeholder= true;
1142
1137
            table->setNext(open_tables);
1143
1138
            open_tables= table;
 
1139
            table::Cache::singleton().mutex().unlock();
1144
1140
 
1145
1141
            return table ;
1146
1142
          }
1153
1149
          table= new_table;
1154
1150
          if (new_table == NULL)
1155
1151
          {
 
1152
            table::Cache::singleton().mutex().unlock();
1156
1153
            return NULL;
1157
1154
          }
1158
1155
 
1160
1157
          if (error != 0)
1161
1158
          {
1162
1159
            delete new_table;
 
1160
            table::Cache::singleton().mutex().unlock();
1163
1161
            return NULL;
1164
1162
          }
1165
1163
          (void)table::Cache::singleton().insert(new_table);
1166
1164
        }
1167
1165
      }
 
1166
 
 
1167
      table::Cache::singleton().mutex().unlock();
1168
1168
    }
1169
 
 
1170
1169
    if (refresh)
1171
1170
    {
1172
1171
      table->setNext(open_tables); /* Link into simple list */
1598
1597
     * table/schema information via error messages
1599
1598
     */
1600
1599
    identifier::Table the_table(tables->getSchemaName(), tables->getTableName());
1601
 
    if (not plugin::Authorization::isAuthorized(*user(), the_table))
 
1600
    if (not plugin::Authorization::isAuthorized(user(), the_table))
1602
1601
    {
1603
1602
      result= -1;                               // Fatal error
1604
1603
      break;
1761
1760
  Table **start,**ptr;
1762
1761
  uint32_t lock_flag= DRIZZLE_LOCK_NOTIFY_IF_NEED_REOPEN;
1763
1762
 
1764
 
  if (!(ptr=start=(Table**) session->getMemRoot()->allocate(sizeof(Table*)*count)))
 
1763
  if (!(ptr=start=(Table**) session->alloc(sizeof(Table*)*count)))
1765
1764
    return -1;
1766
1765
 
1767
1766
  for (table= tables; table; table= table->next_global)
1929
1928
                           const char *name, uint32_t , Item **,
1930
1929
                           bool, TableList **actual_table)
1931
1930
{
1932
 
  List<Natural_join_column>::iterator
1933
 
    field_it(table_ref->join_columns->begin());
 
1931
  List_iterator_fast<Natural_join_column>
 
1932
    field_it(*(table_ref->join_columns));
1934
1933
  Natural_join_column *nj_col, *curr_nj_col;
1935
1934
  Field *found_field;
1936
1935
 
2145
2144
    */
2146
2145
    if (table_name && table_name[0])
2147
2146
    {
2148
 
      List<TableList>::iterator it(table_list->getNestedJoin()->join_list.begin());
 
2147
      List_iterator<TableList> it(table_list->getNestedJoin()->join_list);
2149
2148
      TableList *table;
2150
2149
      while ((table= it++))
2151
2150
      {
2295
2294
        fields.
2296
2295
      */
2297
2296
      {
2298
 
        Select_Lex *current_sel= session->getLex()->current_select;
 
2297
        Select_Lex *current_sel= session->lex->current_select;
2299
2298
        Select_Lex *last_select= table_ref->select_lex;
2300
2299
        /*
2301
2300
          If the field was an outer referencee, mark all selects using this
2444
2443
                  find_item_error_report_type report_error,
2445
2444
                  enum_resolution_type *resolution)
2446
2445
{
2447
 
  List<Item>::iterator li(items.begin());
 
2446
  List_iterator<Item> li(items);
2448
2447
  Item **found=0, **found_unaliased= 0, *item;
2449
2448
  const char *db_name=0;
2450
2449
  const char *field_name=0;
2647
2646
static bool
2648
2647
test_if_string_in_list(const char *find, List<String> *str_list)
2649
2648
{
2650
 
  List<String>::iterator str_list_it(str_list->begin());
 
2649
  List_iterator<String> str_list_it(*str_list);
2651
2650
  String *curr_str;
2652
2651
  size_t find_length= strlen(find);
2653
2652
  while ((curr_str= str_list_it++))
2981
2980
  if (using_fields && found_using_fields < using_fields->elements)
2982
2981
  {
2983
2982
    String *using_field_name;
2984
 
    List<String>::iterator using_fields_it(using_fields->begin());
 
2983
    List_iterator_fast<String> using_fields_it(*using_fields);
2985
2984
    while ((using_field_name= using_fields_it++))
2986
2985
    {
2987
2986
      const char *using_field_name_ptr= using_field_name->c_ptr();
2988
 
      List<Natural_join_column>::iterator
2989
 
        it(natural_using_join->join_columns->begin());
 
2987
      List_iterator_fast<Natural_join_column>
 
2988
        it(*(natural_using_join->join_columns));
2990
2989
      Natural_join_column *common_field;
2991
2990
 
2992
2991
      for (;;)
3068
3067
  /* Call the procedure recursively for each nested table reference. */
3069
3068
  if (table_ref->getNestedJoin())
3070
3069
  {
3071
 
    List<TableList>::iterator nested_it(table_ref->getNestedJoin()->join_list.begin());
 
3070
    List_iterator_fast<TableList> nested_it(table_ref->getNestedJoin()->join_list);
3072
3071
    TableList *same_level_left_neighbor= nested_it++;
3073
3072
    TableList *same_level_right_neighbor= NULL;
3074
3073
    /* Left/right-most neighbors, possibly at higher levels in the join tree. */
3122
3121
  {
3123
3122
    assert(table_ref->getNestedJoin() &&
3124
3123
           table_ref->getNestedJoin()->join_list.elements == 2);
3125
 
    List<TableList>::iterator operand_it(table_ref->getNestedJoin()->join_list.begin());
 
3124
    List_iterator_fast<TableList> operand_it(table_ref->getNestedJoin()->join_list);
3126
3125
    /*
3127
3126
      Notice that the order of join operands depends on whether table_ref
3128
3127
      represents a LEFT or a RIGHT join. In a RIGHT join, the operands are
3222
3221
  if (from_clause->elements == 0)
3223
3222
    return false; /* We come here in the case of UNIONs. */
3224
3223
 
3225
 
  List<TableList>::iterator table_ref_it(from_clause->begin());
 
3224
  List_iterator_fast<TableList> table_ref_it(*from_clause);
3226
3225
  TableList *table_ref; /* Current table reference. */
3227
3226
  /* Table reference to the left of the current. */
3228
3227
  TableList *left_neighbor;
3272
3271
    return 0;
3273
3272
 
3274
3273
  Item *item;
3275
 
  List<Item>::iterator it(fields.begin());
 
3274
  List_iterator<Item> it(fields);
3276
3275
 
3277
 
  session->getLex()->current_select->cur_pos_in_select_list= 0;
 
3276
  session->lex->current_select->cur_pos_in_select_list= 0;
3278
3277
  while (wild_num && (item= it++))
3279
3278
  {
3280
3279
    if (item->type() == Item::FIELD_ITEM &&
3284
3283
    {
3285
3284
      uint32_t elem= fields.elements;
3286
3285
      bool any_privileges= ((Item_field *) item)->any_privileges;
3287
 
      Item_subselect *subsel= session->getLex()->current_select->master_unit()->item;
 
3286
      Item_subselect *subsel= session->lex->current_select->master_unit()->item;
3288
3287
      if (subsel &&
3289
3288
          subsel->substype() == Item_subselect::EXISTS_SUBS)
3290
3289
      {
3315
3314
      wild_num--;
3316
3315
    }
3317
3316
    else
3318
 
      session->getLex()->current_select->cur_pos_in_select_list++;
 
3317
      session->lex->current_select->cur_pos_in_select_list++;
3319
3318
  }
3320
 
  session->getLex()->current_select->cur_pos_in_select_list= UNDEF_POS;
 
3319
  session->lex->current_select->cur_pos_in_select_list= UNDEF_POS;
3321
3320
 
3322
3321
  return 0;
3323
3322
}
3332
3331
{
3333
3332
  register Item *item;
3334
3333
  enum_mark_columns save_mark_used_columns= session->mark_used_columns;
3335
 
  nesting_map save_allow_sum_func= session->getLex()->allow_sum_func;
3336
 
  List<Item>::iterator it(fields.begin());
 
3334
  nesting_map save_allow_sum_func= session->lex->allow_sum_func;
 
3335
  List_iterator<Item> it(fields);
3337
3336
  bool save_is_item_list_lookup;
3338
3337
 
3339
3338
  session->mark_used_columns= mark_used_columns;
3340
3339
  if (allow_sum_func)
3341
 
    session->getLex()->allow_sum_func|= 1 << session->getLex()->current_select->nest_level;
 
3340
    session->lex->allow_sum_func|= 1 << session->lex->current_select->nest_level;
3342
3341
  session->setWhere(Session::DEFAULT_WHERE);
3343
 
  save_is_item_list_lookup= session->getLex()->current_select->is_item_list_lookup;
3344
 
  session->getLex()->current_select->is_item_list_lookup= 0;
 
3342
  save_is_item_list_lookup= session->lex->current_select->is_item_list_lookup;
 
3343
  session->lex->current_select->is_item_list_lookup= 0;
3345
3344
 
3346
3345
  /*
3347
3346
    To prevent fail on forward lookup we fill it with zerows,
3359
3358
  }
3360
3359
 
3361
3360
  Item **ref= ref_pointer_array;
3362
 
  session->getLex()->current_select->cur_pos_in_select_list= 0;
 
3361
  session->lex->current_select->cur_pos_in_select_list= 0;
3363
3362
  while ((item= it++))
3364
3363
  {
3365
3364
    if ((!item->fixed && item->fix_fields(session, it.ref())) || (item= *(it.ref()))->check_cols(1))
3366
3365
    {
3367
 
      session->getLex()->current_select->is_item_list_lookup= save_is_item_list_lookup;
3368
 
      session->getLex()->allow_sum_func= save_allow_sum_func;
 
3366
      session->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
 
3367
      session->lex->allow_sum_func= save_allow_sum_func;
3369
3368
      session->mark_used_columns= save_mark_used_columns;
3370
3369
      return true;
3371
3370
    }
3375
3374
        sum_func_list)
3376
3375
      item->split_sum_func(session, ref_pointer_array, *sum_func_list);
3377
3376
    session->used_tables|= item->used_tables();
3378
 
    session->getLex()->current_select->cur_pos_in_select_list++;
 
3377
    session->lex->current_select->cur_pos_in_select_list++;
3379
3378
  }
3380
 
  session->getLex()->current_select->is_item_list_lookup= save_is_item_list_lookup;
3381
 
  session->getLex()->current_select->cur_pos_in_select_list= UNDEF_POS;
 
3379
  session->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
 
3380
  session->lex->current_select->cur_pos_in_select_list= UNDEF_POS;
3382
3381
 
3383
 
  session->getLex()->allow_sum_func= save_allow_sum_func;
 
3382
  session->lex->allow_sum_func= save_allow_sum_func;
3384
3383
  session->mark_used_columns= save_mark_used_columns;
3385
3384
  return(test(session->is_error()));
3386
3385
}
3549
3548
 
3550
3549
bool
3551
3550
insert_fields(Session *session, Name_resolution_context *context, const char *db_name,
3552
 
              const char *table_name, List<Item>::iterator *it,
 
3551
              const char *table_name, List_iterator<Item> *it,
3553
3552
              bool )
3554
3553
{
3555
3554
  Field_iterator_table_ref field_iterator;
3656
3655
        session->used_tables|= item->used_tables();
3657
3656
      }
3658
3657
 
3659
 
      session->getLex()->current_select->cur_pos_in_select_list++;
 
3658
      session->lex->current_select->cur_pos_in_select_list++;
3660
3659
    }
3661
3660
    /*
3662
3661
      In case of stored tables, all fields are considered as used,
3709
3708
int Session::setup_conds(TableList *leaves, COND **conds)
3710
3709
{
3711
3710
  Session *session= this;
3712
 
  Select_Lex *select_lex= session->getLex()->current_select;
 
3711
  Select_Lex *select_lex= session->lex->current_select;
3713
3712
  TableList *table= NULL;       // For HP compilers
3714
3713
  void *save_session_marker= session->session_marker;
3715
3714
  /*
3767
3766
  }
3768
3767
  session->session_marker= save_session_marker;
3769
3768
 
3770
 
  session->getLex()->current_select->is_item_list_lookup= save_is_item_list_lookup;
 
3769
  session->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
3771
3770
  return(test(session->is_error()));
3772
3771
 
3773
3772
err_no_arena:
3805
3804
bool
3806
3805
fill_record(Session *session, List<Item> &fields, List<Item> &values, bool ignore_errors)
3807
3806
{
3808
 
  List<Item>::iterator f(fields.begin());
3809
 
  List<Item>::iterator v(values.begin());
 
3807
  List_iterator_fast<Item> f(fields),v(values);
3810
3808
  Item *value;
3811
3809
  Item_field *field;
3812
3810
  Table *table;
3824
3822
    field= static_cast<Item_field *>(f++);
3825
3823
    table= field->field->getTable();
3826
3824
    table->auto_increment_field_not_null= false;
3827
 
    f= fields.begin();
 
3825
    f.rewind();
3828
3826
  }
3829
3827
 
3830
3828
  while ((field= static_cast<Item_field *>(f++)))
3871
3869
 
3872
3870
bool fill_record(Session *session, Field **ptr, List<Item> &values, bool)
3873
3871
{
3874
 
  List<Item>::iterator v(values.begin());
 
3872
  List_iterator_fast<Item> v(values);
3875
3873
  Item *value;
3876
3874
  Table *table= 0;
3877
3875
  Field *field;