← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_base.cc

  • Committer: Brian Aker
  • Date: 2011-02-22 06:12:02 UTC
  • mfrom: (2190.1.6 drizzle-build)
  • Revision ID: brian@tangent.org-20110222061202-k03czxykqy4x9hjs
List update, header fixes, multiple symbols, and David deletes some code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_base.cc
1930
1930
                           bool, TableList **actual_table)
1931
1931
{
1932
1932
  List<Natural_join_column>::iterator
1933
 
    field_it(*(table_ref->join_columns));
 
1933
    field_it(table_ref->join_columns->begin());
1934
1934
  Natural_join_column *nj_col, *curr_nj_col;
1935
1935
  Field *found_field;
1936
1936
 
2145
2145
    */
2146
2146
    if (table_name && table_name[0])
2147
2147
    {
2148
 
      List<TableList>::iterator it(table_list->getNestedJoin()->join_list);
 
2148
      List<TableList>::iterator it(table_list->getNestedJoin()->join_list.begin());
2149
2149
      TableList *table;
2150
2150
      while ((table= it++))
2151
2151
      {
2444
2444
                  find_item_error_report_type report_error,
2445
2445
                  enum_resolution_type *resolution)
2446
2446
{
2447
 
  List<Item>::iterator li(items);
 
2447
  List<Item>::iterator li(items.begin());
2448
2448
  Item **found=0, **found_unaliased= 0, *item;
2449
2449
  const char *db_name=0;
2450
2450
  const char *field_name=0;
2647
2647
static bool
2648
2648
test_if_string_in_list(const char *find, List<String> *str_list)
2649
2649
{
2650
 
  List<String>::iterator str_list_it(*str_list);
 
2650
  List<String>::iterator str_list_it(str_list->begin());
2651
2651
  String *curr_str;
2652
2652
  size_t find_length= strlen(find);
2653
2653
  while ((curr_str= str_list_it++))
2981
2981
  if (using_fields && found_using_fields < using_fields->elements)
2982
2982
  {
2983
2983
    String *using_field_name;
2984
 
    List<String>::iterator using_fields_it(*using_fields);
 
2984
    List<String>::iterator using_fields_it(using_fields->begin());
2985
2985
    while ((using_field_name= using_fields_it++))
2986
2986
    {
2987
2987
      const char *using_field_name_ptr= using_field_name->c_ptr();
2988
2988
      List<Natural_join_column>::iterator
2989
 
        it(*(natural_using_join->join_columns));
 
2989
        it(natural_using_join->join_columns->begin());
2990
2990
      Natural_join_column *common_field;
2991
2991
 
2992
2992
      for (;;)
3068
3068
  /* Call the procedure recursively for each nested table reference. */
3069
3069
  if (table_ref->getNestedJoin())
3070
3070
  {
3071
 
    List<TableList>::iterator nested_it(table_ref->getNestedJoin()->join_list);
 
3071
    List<TableList>::iterator nested_it(table_ref->getNestedJoin()->join_list.begin());
3072
3072
    TableList *same_level_left_neighbor= nested_it++;
3073
3073
    TableList *same_level_right_neighbor= NULL;
3074
3074
    /* Left/right-most neighbors, possibly at higher levels in the join tree. */
3122
3122
  {
3123
3123
    assert(table_ref->getNestedJoin() &&
3124
3124
           table_ref->getNestedJoin()->join_list.elements == 2);
3125
 
    List<TableList>::iterator operand_it(table_ref->getNestedJoin()->join_list);
 
3125
    List<TableList>::iterator operand_it(table_ref->getNestedJoin()->join_list.begin());
3126
3126
    /*
3127
3127
      Notice that the order of join operands depends on whether table_ref
3128
3128
      represents a LEFT or a RIGHT join. In a RIGHT join, the operands are
3222
3222
  if (from_clause->elements == 0)
3223
3223
    return false; /* We come here in the case of UNIONs. */
3224
3224
 
3225
 
  List<TableList>::iterator table_ref_it(*from_clause);
 
3225
  List<TableList>::iterator table_ref_it(from_clause->begin());
3226
3226
  TableList *table_ref; /* Current table reference. */
3227
3227
  /* Table reference to the left of the current. */
3228
3228
  TableList *left_neighbor;
3272
3272
    return 0;
3273
3273
 
3274
3274
  Item *item;
3275
 
  List<Item>::iterator it(fields);
 
3275
  List<Item>::iterator it(fields.begin());
3276
3276
 
3277
3277
  session->getLex()->current_select->cur_pos_in_select_list= 0;
3278
3278
  while (wild_num && (item= it++))
3333
3333
  register Item *item;
3334
3334
  enum_mark_columns save_mark_used_columns= session->mark_used_columns;
3335
3335
  nesting_map save_allow_sum_func= session->getLex()->allow_sum_func;
3336
 
  List<Item>::iterator it(fields);
 
3336
  List<Item>::iterator it(fields.begin());
3337
3337
  bool save_is_item_list_lookup;
3338
3338
 
3339
3339
  session->mark_used_columns= mark_used_columns;
3805
3805
bool
3806
3806
fill_record(Session *session, List<Item> &fields, List<Item> &values, bool ignore_errors)
3807
3807
{
3808
 
  List<Item>::iterator f(fields),v(values);
 
3808
  List<Item>::iterator f(fields.begin());
 
3809
  List<Item>::iterator v(values.begin());
3809
3810
  Item *value;
3810
3811
  Item_field *field;
3811
3812
  Table *table;
3870
3871
 
3871
3872
bool fill_record(Session *session, Field **ptr, List<Item> &values, bool)
3872
3873
{
3873
 
  List<Item>::iterator v(values);
 
3874
  List<Item>::iterator v(values.begin());
3874
3875
  Item *value;
3875
3876
  Table *table= 0;
3876
3877
  Field *field;