← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item.cc

  • Committer: Brian Aker
  • Date: 2008-10-20 03:40:03 UTC
  • mto: (492.3.21 drizzle-clean-code)
  • mto: This revision was merged to the branch mainline in revision 530.
  • Revision ID: brian@tangent.org-20081020034003-t2dcnl0ayr2ymm8k
THD -> Session rename

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item.cc
382
382
  cmp_context= (Item_result)-1;
383
383
 
384
384
  /* Put item in free list so that we can free all items at end */
385
 
  THD *thd= current_thd;
 
385
  Session *thd= current_thd;
386
386
  next= thd->free_list;
387
387
  thd->free_list= this;
388
388
  /*
407
407
  Used for duplicating lists in processing queries with temporary
408
408
  tables.
409
409
*/
410
 
Item::Item(THD *thd, Item *item):
 
410
Item::Item(Session *thd, Item *item):
411
411
  is_expensive_cache(-1),
412
412
  rsize(0),
413
413
  str_value(item->str_value),
446
446
 
447
447
  if (name)
448
448
  {
449
 
    THD *thd= current_thd;
 
449
    Session *thd= current_thd;
450
450
    str->append(STRING_WITH_LEN(" AS "));
451
451
    append_identifier(thd, str, name, (uint) strlen(name));
452
452
  }
500
500
 
501
501
  This function is designed to ease transformation of Item trees.
502
502
  Re-execution note: every such transformation is registered for
503
 
  rollback by THD::change_item_tree() and is rolled back at the end
504
 
  of execution by THD::rollback_item_tree_changes().
 
503
  rollback by Session::change_item_tree() and is rolled back at the end
 
504
  of execution by Session::rollback_item_tree_changes().
505
505
 
506
506
  Therefore:
507
507
  - this function can not be used at prepared statement prepare
519
519
  @param arg            opaque argument passed to the functor
520
520
 
521
521
  @return
522
 
    Returns pointer to the new subtree root.  THD::change_item_tree()
 
522
    Returns pointer to the new subtree root.  Session::change_item_tree()
523
523
    should be called for it if transformation took place, i.e. if a
524
524
    pointer to newly allocated item is returned.
525
525
*/
548
548
  Constructor used by Item_field & Item_*_ref (see Item comment)
549
549
*/
550
550
 
551
 
Item_ident::Item_ident(THD *thd, Item_ident *item)
 
551
Item_ident::Item_ident(Session *thd, Item_ident *item)
552
552
  :Item(thd, item),
553
553
   orig_db_name(item->orig_db_name),
554
554
   orig_table_name(item->orig_table_name), 
970
970
{
971
971
  int res;
972
972
  Table *table= field->table;
973
 
  THD *thd= table->in_use;
 
973
  Session *thd= table->in_use;
974
974
  enum_check_fields tmp= thd->count_cuted_fields;
975
975
  ulong sql_mode= thd->variables.sql_mode;
976
976
  thd->variables.sql_mode&= ~(MODE_NO_ZERO_DATE);
1023
1023
    thd->fatal_error() may be called if we are out of memory
1024
1024
*/
1025
1025
 
1026
 
void Item::split_sum_func2(THD *thd, Item **ref_pointer_array,
 
1026
void Item::split_sum_func2(Session *thd, Item **ref_pointer_array,
1027
1027
                           List<Item> &fields, Item **ref, 
1028
1028
                           bool skip_registered)
1029
1029
{
1311
1311
  @code
1312
1312
    collect(A,B,C) ::= collect(collect(A,B),C)
1313
1313
  @endcode
1314
 
  Since this function calls THD::change_item_tree() on the passed Item **
 
1314
  Since this function calls Session::change_item_tree() on the passed Item **
1315
1315
  pointers, it is necessary to pass the original Item **'s, not copies.
1316
1316
  Otherwise their values will not be properly restored (see BUG#20769).
1317
1317
  If the items are not consecutive (eg. args[2] and args[5]), use the
1344
1344
    safe_args[1]= args[item_sep];
1345
1345
  }
1346
1346
 
1347
 
  THD *thd= current_thd;
 
1347
  Session *thd= current_thd;
1348
1348
  bool res= false;
1349
1349
  uint32_t i;
1350
1350
 
1433
1433
  Item_field (this is important in prepared statements).
1434
1434
*/
1435
1435
 
1436
 
Item_field::Item_field(THD *thd __attribute__((unused)),
 
1436
Item_field::Item_field(Session *thd __attribute__((unused)),
1437
1437
                       Name_resolution_context *context_arg,
1438
1438
                       Field *f)
1439
1439
  :Item_ident(context_arg, f->table->s->db.str, *f->table_name, f->field_name),
1461
1461
  Constructor need to process subselect with temporary tables (see Item)
1462
1462
*/
1463
1463
 
1464
 
Item_field::Item_field(THD *thd, Item_field *item)
 
1464
Item_field::Item_field(Session *thd, Item_field *item)
1465
1465
  :Item_ident(thd, item),
1466
1466
   field(item->field),
1467
1467
   result_field(item->result_field),
1532
1532
void Item_ident::print(String *str,
1533
1533
                       enum_query_type query_type __attribute__((unused)))
1534
1534
{
1535
 
  THD *thd= current_thd;
 
1535
  Session *thd= current_thd;
1536
1536
  char d_name_buff[MAX_ALIAS_NAME], t_name_buff[MAX_ALIAS_NAME];
1537
1537
  const char *d_name= db_name, *t_name= table_name;
1538
1538
  if (lower_case_table_names== 1 ||
1760
1760
}
1761
1761
 
1762
1762
 
1763
 
Item *Item_field::get_tmp_table_item(THD *thd)
 
1763
Item *Item_field::get_tmp_table_item(Session *thd)
1764
1764
{
1765
1765
  Item_field *new_item= new Item_field(thd, this);
1766
1766
  if (new_item)
2005
2005
  }
2006
2006
  else
2007
2007
  {
2008
 
    THD *thd= current_thd;
 
2008
    Session *thd= current_thd;
2009
2009
    LEX_STRING utf8_lex_str;
2010
2010
 
2011
2011
    thd->convert_string(&utf8_lex_str,
2320
2320
    1 Out of memory
2321
2321
*/
2322
2322
 
2323
 
bool Item_param::set_from_user_var(THD *thd, const user_var_entry *entry)
 
2323
bool Item_param::set_from_user_var(Session *thd, const user_var_entry *entry)
2324
2324
{
2325
2325
  if (entry && entry->value)
2326
2326
  {
2678
2678
  connection.
2679
2679
*/
2680
2680
 
2681
 
bool Item_param::convert_str_value(THD *thd)
 
2681
bool Item_param::convert_str_value(Session *thd)
2682
2682
{
2683
2683
  bool rc= false;
2684
2684
  if (state == STRING_VALUE || state == LONG_DATA_VALUE)
2838
2838
*/
2839
2839
 
2840
2840
/* ARGSUSED */
2841
 
bool Item::fix_fields(THD *thd __attribute__((unused)),
 
2841
bool Item::fix_fields(Session *thd __attribute__((unused)),
2842
2842
                      Item **ref __attribute__((unused)))
2843
2843
{
2844
2844
 
2911
2911
                         substitution)
2912
2912
*/
2913
2913
 
2914
 
static void mark_as_dependent(THD *thd, SELECT_LEX *last, SELECT_LEX *current,
 
2914
static void mark_as_dependent(Session *thd, SELECT_LEX *last, SELECT_LEX *current,
2915
2915
                              Item_ident *resolved_item,
2916
2916
                              Item_ident *mark_item)
2917
2917
{
2957
2957
    resolved identifier.
2958
2958
*/
2959
2959
 
2960
 
void mark_select_range_as_dependent(THD *thd,
 
2960
void mark_select_range_as_dependent(Session *thd,
2961
2961
                                    SELECT_LEX *last_select,
2962
2962
                                    SELECT_LEX *current_sel,
2963
2963
                                    Field *found_field, Item *found_item,
3144
3144
*/
3145
3145
 
3146
3146
static Item**
3147
 
resolve_ref_in_select_and_group(THD *thd, Item_ident *ref, SELECT_LEX *select)
 
3147
resolve_ref_in_select_and_group(Session *thd, Item_ident *ref, SELECT_LEX *select)
3148
3148
{
3149
3149
  Item **group_by_ref= NULL;
3150
3150
  Item **select_ref= NULL;
3245
3245
*/
3246
3246
 
3247
3247
int
3248
 
Item_field::fix_outer_field(THD *thd, Field **from_field, Item **reference)
 
3248
Item_field::fix_outer_field(Session *thd, Field **from_field, Item **reference)
3249
3249
{
3250
3250
  enum_parsing_place place= NO_MATTER;
3251
3251
  bool field_found= (*from_field != not_found_field);
3539
3539
    false on success
3540
3540
*/
3541
3541
 
3542
 
bool Item_field::fix_fields(THD *thd, Item **reference)
 
3542
bool Item_field::fix_fields(Session *thd, Item **reference)
3543
3543
{
3544
3544
  assert(fixed == 0);
3545
3545
  Field *from_field= (Field *)not_found_field;
3982
3982
                                       str->length(), &well_formed_error);
3983
3983
  if (wlen < str->length())
3984
3984
  {
3985
 
    THD *thd= current_thd;
 
3985
    Session *thd= current_thd;
3986
3986
    char hexbuf[7];
3987
3987
    enum DRIZZLE_ERROR::enum_warning_level level;
3988
3988
    uint32_t diff= str->length() - wlen;
4732
4732
    need to set no_errors to prevent warnings about type conversion
4733
4733
    popping up.
4734
4734
  */
4735
 
  THD *thd= field->table->in_use;
 
4735
  Session *thd= field->table->in_use;
4736
4736
  int no_errors;
4737
4737
 
4738
4738
  no_errors= thd->no_errors;
4882
4882
    false on success
4883
4883
*/
4884
4884
 
4885
 
bool Item_ref::fix_fields(THD *thd, Item **reference)
 
4885
bool Item_ref::fix_fields(Session *thd, Item **reference)
4886
4886
{
4887
4887
  enum_parsing_place place= NO_MATTER;
4888
4888
  assert(fixed == 0);
5147
5147
    if ((*ref)->type() != Item::CACHE_ITEM && ref_type() != VIEW_REF &&
5148
5148
        !table_name && name && alias_name_used)
5149
5149
    {
5150
 
      THD *thd= current_thd;
 
5150
      Session *thd= current_thd;
5151
5151
      append_identifier(thd, str, name, (uint) strlen(name));
5152
5152
    }
5153
5153
    else
5329
5329
}
5330
5330
 
5331
5331
 
5332
 
Item *Item_ref::get_tmp_table_item(THD *thd)
 
5332
Item *Item_ref::get_tmp_table_item(Session *thd)
5333
5333
{
5334
5334
  if (!result_field)
5335
5335
    return (*ref)->get_tmp_table_item(thd);
5419
5419
    true    Error
5420
5420
*/
5421
5421
 
5422
 
bool Item_direct_view_ref::fix_fields(THD *thd, Item **reference)
 
5422
bool Item_direct_view_ref::fix_fields(Session *thd, Item **reference)
5423
5423
{
5424
5424
  /* view fild reference must be defined */
5425
5425
  assert(*ref);
5443
5443
    true    Error
5444
5444
*/
5445
5445
 
5446
 
bool Item_outer_ref::fix_fields(THD *thd, Item **reference)
 
5446
bool Item_outer_ref::fix_fields(Session *thd, Item **reference)
5447
5447
{
5448
5448
  bool err;
5449
5449
  /* outer_ref->check_cols() will be made in Item_direct_ref::fix_fields */
5515
5515
}
5516
5516
 
5517
5517
 
5518
 
bool Item_default_value::fix_fields(THD *thd,
 
5518
bool Item_default_value::fix_fields(Session *thd,
5519
5519
                                    Item **items __attribute__((unused)))
5520
5520
{
5521
5521
  Item *real_arg;
5614
5614
    return 0;
5615
5615
 
5616
5616
  /*
5617
 
    THD::change_item_tree() should be called only if the tree was
 
5617
    Session::change_item_tree() should be called only if the tree was
5618
5618
    really transformed, i.e. when a new item has been created.
5619
5619
    Otherwise we'll be allocating a lot of unnecessary memory for
5620
5620
    change records at each execution.
5632
5632
}
5633
5633
 
5634
5634
 
5635
 
bool Item_insert_value::fix_fields(THD *thd,
 
5635
bool Item_insert_value::fix_fields(Session *thd,
5636
5636
                                   Item **items __attribute__((unused)))
5637
5637
{
5638
5638
  assert(fixed == 0);
5715
5715
}
5716
5716
 
5717
5717
 
5718
 
void resolve_const_item(THD *thd, Item **ref, Item *comp_item)
 
5718
void resolve_const_item(Session *thd, Item **ref, Item *comp_item)
5719
5719
{
5720
5720
  Item *item= *ref;
5721
5721
  Item *new_item= NULL;
6049
6049
bool Item_cache_row::allocate(uint32_t num)
6050
6050
{
6051
6051
  item_count= num;
6052
 
  THD *thd= current_thd;
 
6052
  Session *thd= current_thd;
6053
6053
  return (!(values= 
6054
6054
            (Item_cache **) thd->calloc(sizeof(Item_cache *)*item_count)));
6055
6055
}
6131
6131
}
6132
6132
 
6133
6133
 
6134
 
Item_type_holder::Item_type_holder(THD *thd, Item *item)
 
6134
Item_type_holder::Item_type_holder(Session *thd, Item *item)
6135
6135
  :Item(thd, item), enum_set_typelib(0), fld_type(get_real_type(item))
6136
6136
{
6137
6137
  assert(item->fixed);
6236
6236
    false  OK
6237
6237
*/
6238
6238
 
6239
 
bool Item_type_holder::join_types(THD *thd __attribute__((unused)),
 
6239
bool Item_type_holder::join_types(Session *thd __attribute__((unused)),
6240
6240
                                  Item *item)
6241
6241
{
6242
6242
  uint32_t max_length_orig= max_length;
6468
6468
    do nothing
6469
6469
*/
6470
6470
 
6471
 
void dummy_error_processor(THD *thd __attribute__((unused)),
 
6471
void dummy_error_processor(Session *thd __attribute__((unused)),
6472
6472
                           void *data __attribute__((unused)))
6473
6473
{}
6474
6474