← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item.cc

  • Committer: Eric Herman
  • Date: 2008-12-06 19:42:46 UTC
  • mto: (656.1.6 devel)
  • mto: This revision was merged to the branch mainline in revision 665.
  • Revision ID: eric@mysql.com-20081206194246-5cdexuu81i366eek
removed trailing whitespace with simple script:

for file in $(find . -name "*.c") $(find . -name "*.cc") $(find . -name "*.h"); do ruby -pe 'gsub(/\s+$/, $/)' < $file > $file.out; mv $file.out $file; done;

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item.cc
315
315
  null_value= false;
316
316
  with_sum_func= false;
317
317
  unsigned_flag= false;
318
 
  decimals= 0; 
 
318
  decimals= 0;
319
319
  max_length= 0;
320
320
  with_subselect= 0;
321
321
  cmp_context= (Item_result)-1;
331
331
  */
332
332
  if (session->lex->current_select)
333
333
  {
334
 
    enum_parsing_place place= 
 
334
    enum_parsing_place place=
335
335
      session->lex->current_select->parsing_place;
336
336
    if (place == SELECT_LIST ||
337
337
        place == IN_HAVING)
505
505
Item_ident::Item_ident(Session *session, Item_ident *item)
506
506
  :Item(session, item),
507
507
   orig_db_name(item->orig_db_name),
508
 
   orig_table_name(item->orig_table_name), 
 
508
   orig_table_name(item->orig_table_name),
509
509
   orig_field_name(item->orig_field_name),
510
510
   context(item->context),
511
511
   db_name(item->db_name),
528
528
                       orig_field_name ? orig_field_name : "(null)"));
529
529
#endif
530
530
  Item::cleanup();
531
 
  db_name= orig_db_name; 
 
531
  db_name= orig_db_name;
532
532
  table_name= orig_table_name;
533
533
  field_name= orig_field_name;
534
534
  depended_from= 0;
621
621
  if (field->table == table || !table)
622
622
    bitmap_set_bit(field->table->read_set, field->field_index);
623
623
  if (field->vcol_info && field->vcol_info->expr_item)
624
 
    return field->vcol_info->expr_item->walk(&Item::register_field_in_read_map, 
 
624
    return field->vcol_info->expr_item->walk(&Item::register_field_in_read_map,
625
625
                                             1, arg);
626
626
  return 0;
627
627
}
1173
1173
 
1174
1174
 
1175
1175
/*
1176
 
 need a special class to adjust printing : references to aggregate functions 
 
1176
 need a special class to adjust printing : references to aggregate functions
1177
1177
 must not be printed as refs because the aggregate functions that are added to
1178
1178
 the front of select list are not printed as well.
1179
1179
*/
1252
1252
                                           ref_pointer_array + el, 0, name)))
1253
1253
      return;                                   // fatal_error is set
1254
1254
    if (type() == SUM_FUNC_ITEM)
1255
 
      item_ref->depended_from= ((Item_sum *) this)->depended_from(); 
 
1255
      item_ref->depended_from= ((Item_sum *) this)->depended_from();
1256
1256
    fields.push_front(real_itm);
1257
1257
    session->change_item_tree(ref, item_ref);
1258
1258
  }
1267
1267
  tmp_field->charsetnr= field->charset()->number;
1268
1268
  tmp_field->length=field->field_length;
1269
1269
  tmp_field->type=field->type();
1270
 
  tmp_field->flags= field->table->maybe_null ? 
 
1270
  tmp_field->flags= field->table->maybe_null ?
1271
1271
    (field->flags & ~NOT_NULL_FLAG) : field->flags;
1272
1272
  tmp_field->decimals= field->decimals();
1273
1273
}
2043
2043
 
2044
2044
/*********************** Item_param related ******************************/
2045
2045
 
2046
 
/** 
 
2046
/**
2047
2047
  Default function of Item_param::set_param_func, so in case
2048
2048
  of malformed packet the server won't SIGSEGV.
2049
2049
*/
2066
2066
  limit_clause_param(false)
2067
2067
{
2068
2068
  name= (char*) "?";
2069
 
  /* 
 
2069
  /*
2070
2070
    Since we can't say whenever this item can be NULL or cannot be NULL
2071
2071
    before mysql_stmt_execute(), so we assuming that it can be NULL until
2072
2072
    value is set.
2081
2081
{
2082
2082
  /* These are cleared after each execution by reset() method */
2083
2083
  null_value= 1;
2084
 
  /* 
 
2084
  /*
2085
2085
    Because of NULL and string values we need to set max_length for each new
2086
 
    placeholder value: user can submit NULL for any placeholder type, and 
 
2086
    placeholder value: user can submit NULL for any placeholder type, and
2087
2087
    string length can be different in each execution.
2088
2088
  */
2089
2089
  max_length= 0;
2157
2157
void Item_param::set_time(DRIZZLE_TIME *tm,
2158
2158
                          enum enum_drizzle_timestamp_type time_type,
2159
2159
                          uint32_t max_length_arg)
2160
 
{ 
 
2160
{
2161
2161
  value.time= *tm;
2162
2162
  value.time.time_type= time_type;
2163
2163
 
2260
2260
      const CHARSET_INFO * const tocs= session->variables.collation_connection;
2261
2261
      uint32_t dummy_offset;
2262
2262
 
2263
 
      value.cs_info.character_set_of_placeholder= 
 
2263
      value.cs_info.character_set_of_placeholder=
2264
2264
        value.cs_info.character_set_client= fromcs;
2265
2265
      /*
2266
2266
        Setup source and destination character sets so that they
2427
2427
    assert(0);
2428
2428
  }
2429
2429
  return 0.0;
2430
 
} 
2431
 
 
2432
 
 
2433
 
int64_t Item_param::val_int() 
2434
 
{ 
 
2430
}
 
2431
 
 
2432
 
 
2433
int64_t Item_param::val_int()
 
2434
{
2435
2435
  switch (state) {
2436
2436
  case REAL_VALUE:
2437
2437
    return (int64_t) rint(value.real);
2453
2453
  case TIME_VALUE:
2454
2454
    return (int64_t) TIME_to_uint64_t(&value.time);
2455
2455
  case NULL_VALUE:
2456
 
    return 0; 
 
2456
    return 0;
2457
2457
  default:
2458
2458
    assert(0);
2459
2459
  }
2483
2483
    return dec;
2484
2484
  }
2485
2485
  case NULL_VALUE:
2486
 
    return 0; 
 
2486
    return 0;
2487
2487
  default:
2488
2488
    assert(0);
2489
2489
  }
2491
2491
}
2492
2492
 
2493
2493
 
2494
 
String *Item_param::val_str(String* str) 
2495
 
{ 
 
2494
String *Item_param::val_str(String* str)
 
2495
{
2496
2496
  switch (state) {
2497
2497
  case STRING_VALUE:
2498
2498
  case LONG_DATA_VALUE:
2517
2517
    return str;
2518
2518
  }
2519
2519
  case NULL_VALUE:
2520
 
    return NULL; 
 
2520
    return NULL;
2521
2521
  default:
2522
2522
    assert(0);
2523
2523
  }
2525
2525
}
2526
2526
 
2527
2527
/**
2528
 
  Return Param item values in string format, for generating the dynamic 
 
2528
  Return Param item values in string format, for generating the dynamic
2529
2529
  query used in update/binary logs.
2530
2530
 
2531
2531
  @todo
2532
2532
    - Change interface and implementation to fill log data in place
2533
2533
    and avoid one more memcpy/alloc between str and log string.
2534
2534
    - In case of error we need to notify replication
2535
 
    that binary log contains wrong statement 
 
2535
    that binary log contains wrong statement
2536
2536
*/
2537
2537
 
2538
2538
const String *Item_param::query_val_str(String* str) const
2555
2555
      str->length(0);
2556
2556
      /*
2557
2557
        TODO: in case of error we need to notify replication
2558
 
        that binary log contains wrong statement 
 
2558
        that binary log contains wrong statement
2559
2559
      */
2560
2560
      if (str->reserve(MAX_DATE_STRING_REP_LENGTH+3))
2561
 
        break; 
 
2561
        break;
2562
2562
 
2563
2563
      /* Create date string inplace */
2564
2564
      buf= str->c_ptr_quick();
2804
2804
 
2805
2805
 
2806
2806
bool Item_ref_null_helper::get_date(DRIZZLE_TIME *ltime, uint32_t fuzzydate)
2807
 
{  
 
2807
{
2808
2808
  return (owner->was_null|= null_value= (*ref)->get_date(ltime, fuzzydate));
2809
2809
}
2810
2810
 
2963
2963
    {
2964
2964
      cur_field= (Item_ident*) *cur_group->item;
2965
2965
      cur_match_degree= 0;
2966
 
      
 
2966
 
2967
2967
      assert(cur_field->field_name != 0);
2968
2968
 
2969
2969
      if (!my_strcasecmp(system_charset_info,
3078
3078
  if (select->having_fix_field && !ref->with_sum_func && group_list)
3079
3079
  {
3080
3080
    group_by_ref= find_field_in_group_list(ref, group_list);
3081
 
    
 
3081
 
3082
3082
    /* Check if the fields found in SELECT and GROUP BY are the same field. */
3083
3083
    if (group_by_ref && (select_ref != not_found_item) &&
3084
3084
        !((*group_by_ref)->eq(*select_ref, 0)))
3340
3340
    /*
3341
3341
      Here, a subset of actions performed by Item_ref::set_properties
3342
3342
      is not enough. So we pass ptr to NULL into Item_[direct]_ref
3343
 
      constructor, so no initialization is performed, and call 
 
3343
      constructor, so no initialization is performed, and call
3344
3344
      fix_fields() below.
3345
3345
    */
3346
3346
    save= *ref;
3467
3467
                                          context->last_name_resolution_table,
3468
3468
                                          reference,
3469
3469
                                          session->lex->use_only_table_context ?
3470
 
                                            REPORT_ALL_ERRORS : 
 
3470
                                            REPORT_ALL_ERRORS :
3471
3471
                                            IGNORE_EXCEPT_NON_UNIQUE,
3472
3472
                                          !any_privileges,
3473
3473
                                          true)) ==
3502
3502
            if (new_field == NULL)
3503
3503
            {
3504
3504
              /* The column to which we link isn't valid. */
3505
 
              my_error(ER_BAD_FIELD_ERROR, MYF(0), (*res)->name, 
 
3505
              my_error(ER_BAD_FIELD_ERROR, MYF(0), (*res)->name,
3506
3506
                       current_session->where);
3507
3507
              return(1);
3508
3508
            }
3522
3522
              return 1;
3523
3523
            session->change_item_tree(reference, rf);
3524
3524
            /*
3525
 
              Because Item_ref never substitutes itself with other items 
3526
 
              in Item_ref::fix_fields(), we can safely use the original 
 
3525
              Because Item_ref never substitutes itself with other items
 
3526
              in Item_ref::fix_fields(), we can safely use the original
3527
3527
              pointer to it even after fix_fields()
3528
3528
             */
3529
3529
            return rf->fix_fields(session, reference) ||  rf->check_cols(1);
3568
3568
 
3569
3569
    set_field(from_field);
3570
3570
    if (session->lex->in_sum_func &&
3571
 
        session->lex->in_sum_func->nest_level == 
 
3571
        session->lex->in_sum_func->nest_level ==
3572
3572
        session->lex->current_select->nest_level)
3573
3573
      set_if_bigger(session->lex->in_sum_func->max_arg_level,
3574
3574
                    session->lex->current_select->nest_level);
3642
3642
  of the current level (in the cond_equal->current_level list).
3643
3643
  If it fails, it continues searching in upper levels accessed
3644
3644
  through a pointer cond_equal->upper_levels.
3645
 
  The search terminates as soon as a multiple equality containing 
3646
 
  the field is found. 
 
3645
  The search terminates as soon as a multiple equality containing
 
3646
  the field is found.
3647
3647
 
3648
3648
  @param cond_equal   reference to list of multiple equalities where
3649
3649
                      the field (this object) is to be looked for
3664
3664
      if (item->contains(field))
3665
3665
        return item;
3666
3666
    }
3667
 
    /* 
 
3667
    /*
3668
3668
      The field is not found in any of the multiple equalities
3669
3669
      of the current level. Look for it in upper levels
3670
3670
    */
3748
3748
    the same as (Item_hex_string->val_str() in BINARY column)->val_int().
3749
3749
    We cannot simply disable the replacement in a particular context (
3750
3750
    e.g. <bin_col> = <int_col> AND <bin_col> = <hex_string>) since
3751
 
    Items don't know the context they are in and there are functions like 
 
3751
    Items don't know the context they are in and there are functions like
3752
3752
    IF (<hex_string>, 'yes', 'no').
3753
3753
    The same problem occurs when comparing a DATE/TIME field with a
3754
3754
    DATE/TIME represented as an int and as a string.
3782
3782
  The function returns a pointer to an item that is taken from
3783
3783
  the very beginning of the item_equal list which the Item_field
3784
3784
  object refers to (belongs to) unless item_equal contains  a constant
3785
 
  item. In this case the function returns this constant item, 
3786
 
  (if the substitution does not require conversion).   
 
3785
  item. In this case the function returns this constant item,
 
3786
  (if the substitution does not require conversion).
3787
3787
  If the Item_field object does not refer any Item_equal object
3788
3788
  'this' is returned .
3789
3789
 
3836
3836
  tmp_field->table_name=        empty_name;
3837
3837
  tmp_field->col_name=          name;
3838
3838
  tmp_field->charsetnr=         collation.collation->number;
3839
 
  tmp_field->flags=             (maybe_null ? 0 : NOT_NULL_FLAG) | 
 
3839
  tmp_field->flags=             (maybe_null ? 0 : NOT_NULL_FLAG) |
3840
3840
                                (my_binary_compare(collation.collation) ?
3841
3841
                                 BINARY_FLAG : 0);
3842
3842
  tmp_field->type=              field_type_arg;
3930
3930
 
3931
3931
/*
3932
3932
  Compare two items using a given collation
3933
 
  
 
3933
 
3934
3934
  SYNOPSIS
3935
3935
    eq_by_collation()
3936
3936
    item               item to compare with
3945
3945
    restored.
3946
3946
 
3947
3947
  RETURN
3948
 
    1    compared items has been detected as equal   
 
3948
    1    compared items has been detected as equal
3949
3949
    0    otherwise
3950
3950
*/
3951
3951
 
3969
3969
  if (save_item_cs)
3970
3970
    item->collation.collation= save_item_cs;
3971
3971
  return res;
3972
 
}  
 
3972
}
3973
3973
 
3974
3974
 
3975
3975
/**
3977
3977
 
3978
3978
  If max_length > CONVERT_IF_BIGGER_TO_BLOB create a blob @n
3979
3979
  If max_length > 0 create a varchar @n
3980
 
  If max_length == 0 create a CHAR(0) 
 
3980
  If max_length == 0 create a CHAR(0)
3981
3981
 
3982
3982
  @param table          Table for which the field is created
3983
3983
*/
4306
4306
    if (str == end)
4307
4307
      return 0;
4308
4308
    if (*str == 'e' || *str == 'E')
4309
 
      return NOT_FIXED_DEC;    
 
4309
      return NOT_FIXED_DEC;
4310
4310
    if (*str++ == '.')
4311
4311
      break;
4312
4312
  }
4517
4517
  In string context this is a binary string.
4518
4518
  In number context this is a int64_t value.
4519
4519
*/
4520
 
  
 
4520
 
4521
4521
Item_bin_string::Item_bin_string(const char *str, uint32_t str_length)
4522
4522
{
4523
4523
  const char *end= str + str_length - 1;
4537
4537
    {
4538
4538
      power= 1;
4539
4539
      *ptr--= bits;
4540
 
      bits= 0;     
 
4540
      bits= 0;
4541
4541
    }
4542
4542
    if (*end == '1')
4543
 
      bits|= power; 
 
4543
      bits|= power;
4544
4544
    power<<= 1;
4545
4545
  }
4546
4546
  *ptr= (char) bits;
4960
4960
          max_arg_level for the function if it's needed.
4961
4961
        */
4962
4962
        if (session->lex->in_sum_func &&
4963
 
            session->lex->in_sum_func->nest_level >= 
 
4963
            session->lex->in_sum_func->nest_level >=
4964
4964
            last_checked_context->select_lex->nest_level)
4965
4965
          set_if_bigger(session->lex->in_sum_func->max_arg_level,
4966
4966
                        last_checked_context->select_lex->nest_level);
4983
4983
        max_arg_level for the function if it's needed.
4984
4984
      */
4985
4985
      if (session->lex->in_sum_func &&
4986
 
          session->lex->in_sum_func->nest_level >= 
 
4986
          session->lex->in_sum_func->nest_level >=
4987
4987
          last_checked_context->select_lex->nest_level)
4988
4988
        set_if_bigger(session->lex->in_sum_func->max_arg_level,
4989
4989
                      last_checked_context->select_lex->nest_level);
5460
5460
/**
5461
5461
  This method like the walk method traverses the item tree, but at the
5462
5462
  same time it can replace some nodes in the tree.
5463
 
*/ 
 
5463
*/
5464
5464
 
5465
5465
Item *Item_default_value::transform(Item_transformer transformer, unsigned char *args)
5466
5466
{
5862
5862
    /*
5863
5863
      We copy string value to avoid changing value if 'item' is table field
5864
5864
      in queries like following (where t1.c is varchar):
5865
 
      select a, 
 
5865
      select a,
5866
5866
             (select a,b,c from t1 where t1.a=t2.a) = ROW(a,2,'a'),
5867
5867
             (select c from t1 where a=t2.a)
5868
5868
        from t2;
5962
5962
                                item->name, item->decimals, true);
5963
5963
    break;
5964
5964
  case INT_RESULT:
5965
 
    /* 
 
5965
    /*
5966
5966
      Select an integer type with the minimal fit precision.
5967
5967
      MY_INT32_NUM_DECIMAL_DIGITS is sign inclusive, don't consider the sign.
5968
 
      Values with MY_INT32_NUM_DECIMAL_DIGITS digits may or may not fit into 
5969
 
      Field_long : make them Field_int64_t.  
 
5968
      Values with MY_INT32_NUM_DECIMAL_DIGITS digits may or may not fit into
 
5969
      Field_long : make them Field_int64_t.
5970
5970
    */
5971
5971
    if (item->max_length >= (MY_INT32_NUM_DECIMAL_DIGITS - 1))
5972
5972
      new_field=new Field_int64_t(item->max_length, maybe_null,
5977
5977
    break;
5978
5978
  case STRING_RESULT:
5979
5979
    assert(item->collation.collation);
5980
 
  
 
5980
 
5981
5981
    enum enum_field_types type;
5982
5982
    /*
5983
 
      DATE/TIME fields have STRING_RESULT result type. 
 
5983
      DATE/TIME fields have STRING_RESULT result type.
5984
5984
      To preserve type they needed to be handled separately.
5985
5985
    */
5986
5986
    if ((type= item->field_type()) == DRIZZLE_TYPE_DATETIME ||
5987
5987
        type == DRIZZLE_TYPE_TIME || type == DRIZZLE_TYPE_DATE ||
5988
5988
        type == DRIZZLE_TYPE_TIMESTAMP)
5989
5989
      new_field= item->tmp_table_field_from_field_type(table, 1);
5990
 
    /* 
5991
 
      Make sure that the blob fits into a Field_varstring which has 
5992
 
      2-byte lenght. 
 
5990
    /*
 
5991
      Make sure that the blob fits into a Field_varstring which has
 
5992
      2-byte lenght.
5993
5993
    */
5994
5994
    else if (item->max_length/item->collation.collation->mbmaxlen > 255 &&
5995
 
             convert_blob_length <= Field_varstring::MAX_SIZE && 
 
5995
             convert_blob_length <= Field_varstring::MAX_SIZE &&
5996
5996
             convert_blob_length)
5997
5997
      new_field= new Field_varstring(convert_blob_length, maybe_null,
5998
5998
                                     item->name, table->s,
6048
6048
  }
6049
6049
  if (new_field)
6050
6050
    new_field->init(table);
6051
 
    
 
6051
 
6052
6052
  if (copy_func && item->is_result_field())
6053
6053
    *((*copy_func)++) = item;                   // Save for copy_funcs
6054
6054
  if (modify_item)
6103
6103
      *from_field= field->field;
6104
6104
      if (result && modify_item)
6105
6105
        field->result_field= result;
6106
 
    } 
 
6106
    }
6107
6107
    else
6108
6108
      result= create_tmp_field_from_field(session, (*from_field= field->field),
6109
6109
                                          orig_item ? orig_item->name :
6142
6142
    return create_tmp_field_from_item(session, item, table,
6143
6143
                                      (make_copy_field ? 0 : copy_func),
6144
6144
                                       modify_item, convert_blob_length);
6145
 
  case Item::TYPE_HOLDER:  
 
6145
  case Item::TYPE_HOLDER:
6146
6146
    result= ((Item_type_holder *)item)->make_field_by_type(table);
6147
6147
    result->set_derivation(item->collation.derivation);
6148
6148
    return result;