~drizzle-trunk/drizzle/development : revision 51.1.23

61

62

my_decimal *Item_str_func::val_decimal(my_decimal *decimal_value)

63

{

64

DBUG_ASSERT(fixed == 1);

64

assert(fixed == 1);

65

char buff[64];

66

String *res, tmp(buff,sizeof(buff), &my_charset_bin);

67

res= val_str(&tmp);

75

76

double Item_str_func::val_real()

77

{

78

DBUG_ASSERT(fixed == 1);

78

assert(fixed == 1);

79

int err_not_used;

80

char *end_not_used, buff[64];

81

String *res, tmp(buff,sizeof(buff), &my_charset_bin);

87

88

longlong Item_str_func::val_int()

89

{

90

DBUG_ASSERT(fixed == 1);

90

assert(fixed == 1);

91

int err;

92

char buff[22];

93

String *res, tmp(buff,sizeof(buff), &my_charset_bin);

101

102

String *Item_func_md5::val_str(String *str)

103

{

104

DBUG_ASSERT(fixed == 1);

104

assert(fixed == 1);

105

String * sptr= args[0]->val_str(str);

106

str->set_charset(&my_charset_bin);

107

if (sptr)

153

154

String *Item_func_concat::val_str(String *str)

155

{

156

DBUG_ASSERT(fixed == 1);

156

assert(fixed == 1);

157

String *res,*res2,*use_as_buff;

158

uint i;

159

bool is_const= 0;

311

312

String *Item_func_concat_ws::val_str(String *str)

313

{

314

DBUG_ASSERT(fixed == 1);

314

assert(fixed == 1);

315

char tmp_str_buff[10];

316

String tmp_sep_str(tmp_str_buff, sizeof(tmp_str_buff),default_charset_info),

317

*sep_str, *res, *res2,*use_as_buff;

474

475

String *Item_func_reverse::val_str(String *str)

476

{

477

DBUG_ASSERT(fixed == 1);

477

assert(fixed == 1);

478

String *res = args[0]->val_str(str);

479

char *ptr, *end, *tmp;

480

537

538

String *Item_func_replace::val_str(String *str)

539

{

540

DBUG_ASSERT(fixed == 1);

540

assert(fixed == 1);

541

String *res,*res2,*res3;

542

int offset;

543

uint from_length,to_length;

673

674

String *Item_func_insert::val_str(String *str)

675

{

676

DBUG_ASSERT(fixed == 1);

676

assert(fixed == 1);

677

String *res,*res2;

678

longlong start, length; /* must be longlong to avoid truncation */

679

740

741

String *Item_str_conv::val_str(String *str)

742

{

743

DBUG_ASSERT(fixed == 1);

743

assert(fixed == 1);

744

String *res;

745

if (!(res=args[0]->val_str(str)))

746

{

754

res= copy_if_not_alloced(str,res,res->length());

755

len= converter(collation.collation, (char*) res->ptr(), res->length(),

756

(char*) res->ptr(), res->length());

757

DBUG_ASSERT(len <= res->length());

757

assert(len <= res->length());

758

res->length(len);

759

}

760

else

790

791

String *Item_func_left::val_str(String *str)

792

{

793

DBUG_ASSERT(fixed == 1);

793

assert(fixed == 1);

794

String *res= args[0]->val_str(str);

795

796

/* must be longlong to avoid truncation */

836

837

String *Item_func_right::val_str(String *str)

838

{

839

DBUG_ASSERT(fixed == 1);

839

assert(fixed == 1);

840

String *res= args[0]->val_str(str);

841

/* must be longlong to avoid truncation */

842

longlong length= args[1]->val_int();

869

870

String *Item_func_substr::val_str(String *str)

871

{

872

DBUG_ASSERT(fixed == 1);

872

assert(fixed == 1);

873

String *res = args[0]->val_str(str);

874

/* must be longlong to avoid truncation */

875

longlong start= args[1]->val_int();

950

951

String *Item_func_substr_index::val_str(String *str)

952

{

953

DBUG_ASSERT(fixed == 1);

953

assert(fixed == 1);

954

String *res= args[0]->val_str(str);

955

String *delimiter= args[1]->val_str(&tmp_value);

956

int32 count= (int32) args[2]->val_int();

1080

1081

String *Item_func_ltrim::val_str(String *str)

1082

{

1083

DBUG_ASSERT(fixed == 1);

1083

assert(fixed == 1);

1084

char buff[MAX_FIELD_WIDTH], *ptr, *end;

1085

String tmp(buff,sizeof(buff),system_charset_info);

1086

String *res, *remove_str;

1126

1127

String *Item_func_rtrim::val_str(String *str)

1128

{

1129

DBUG_ASSERT(fixed == 1);

1129

assert(fixed == 1);

1130

char buff[MAX_FIELD_WIDTH], *ptr, *end;

1131

String tmp(buff, sizeof(buff), system_charset_info);

1132

String *res, *remove_str;

1206

1207

String *Item_func_trim::val_str(String *str)

1208

{

1209

DBUG_ASSERT(fixed == 1);

1209

assert(fixed == 1);

1210

char buff[MAX_FIELD_WIDTH], *ptr, *end;

1211

const char *r_ptr;

1212

String tmp(buff, sizeof(buff), system_charset_info);

1305

1306

String *Item_func_password::val_str(String *str)

1307

{

1308

DBUG_ASSERT(fixed == 1);

1308

assert(fixed == 1);

1309

String *res= args[0]->val_str(str);

1310

if ((null_value=args[0]->null_value))

1311

return 0;

1328

1329

String *Item_func_old_password::val_str(String *str)

1330

{

1331

DBUG_ASSERT(fixed == 1);

1331

assert(fixed == 1);

1332

String *res= args[0]->val_str(str);

1333

if ((null_value=args[0]->null_value))

1334

return 0;

1352

1353

String *Item_func_encrypt::val_str(String *str)

1354

{

1355

DBUG_ASSERT(fixed == 1);

1355

assert(fixed == 1);

1356

String *res =args[0]->val_str(str);

1357

1358

#ifdef HAVE_CRYPT

1408

char pw_buff[80];

1409

String tmp_pw_value(pw_buff, sizeof(pw_buff), system_charset_info);

1410

String *password;

1411

DBUG_ASSERT(fixed == 1);

1411

assert(fixed == 1);

1412

1413

if (!(res=args[0]->val_str(str)))

1414

{

1437

char pw_buff[80];

1438

String tmp_pw_value(pw_buff, sizeof(pw_buff), system_charset_info);

1439

String *password;

1440

DBUG_ASSERT(fixed == 1);

1440

assert(fixed == 1);

1441

1442

if (!(res=args[0]->val_str(str)))

1443

{

1482

1483

String *Item_func_database::val_str(String *str)

1484

{

1485

DBUG_ASSERT(fixed == 1);

1485

assert(fixed == 1);

1486

THD *thd= current_thd;

1487

if (thd->db == NULL)

1488

{

1501

*/

1502

bool Item_func_user::init(const char *user, const char *host)

1503

{

1504

DBUG_ASSERT(fixed == 1);

1504

assert(fixed == 1);

1505

1506

// For system threads (e.g. replication SQL thread) user may be empty

1507

if (user)

1512

if (str_value.alloc(res_length))

1513

{

1514

null_value=1;

1515

return TRUE;

1515

return true;

1516

}

1517

1518

res_length=cs->cset->snprintf(cs, (char*)str_value.ptr(), res_length,

1520

str_value.length(res_length);

1521

str_value.mark_as_const();

1522

}

1523

return FALSE;

1523

return false;

1524

}

1525

1526

1535

bool Item_func_current_user::fix_fields(THD *thd, Item **ref)

1536

{

1537

if (Item_func_sysconst::fix_fields(thd, ref))

1538

return TRUE;

1538

return true;

1539

1540

Security_context *ctx=

1541

thd->security_ctx;

1580

/* Number of characters used to represent the decimals, including '.' */

1581

uint32 dec_length;

1582

int diff;

1583

DBUG_ASSERT(fixed == 1);

1583

assert(fixed == 1);

1584

1585

dec= (int) args[1]->val_int();

1586

if (args[1]->null_value)

1611

double nr= args[0]->val_real();

1612

if ((null_value=args[0]->null_value))

1613

return 0; /* purecov: inspected */

1614

nr= my_double_round(nr, (longlong) dec, FALSE, FALSE);

1614

nr= my_double_round(nr, (longlong) dec, false, false);

1615

/* Here default_charset() is right as this is not an automatic conversion */

1616

str->set_real(nr, dec, default_charset());

1617

if (isnan(nr))

1675

1676

double Item_func_elt::val_real()

1677

{

1678

DBUG_ASSERT(fixed == 1);

1678

assert(fixed == 1);

1679

uint tmp;

1680

null_value=1;

1681

if ((tmp=(uint) args[0]->val_int()) == 0 || tmp >= arg_count)

1688

1689

longlong Item_func_elt::val_int()

1690

{

1691

DBUG_ASSERT(fixed == 1);

1691

assert(fixed == 1);

1692

uint tmp;

1693

null_value=1;

1694

if ((tmp=(uint) args[0]->val_int()) == 0 || tmp >= arg_count)

1702

1703

String *Item_func_elt::val_str(String *str)

1704

{

1705

DBUG_ASSERT(fixed == 1);

1705

assert(fixed == 1);

1706

uint tmp;

1707

null_value=1;

1708

if ((tmp=(uint) args[0]->val_int()) == 0 || tmp >= arg_count)

1719

void Item_func_make_set::split_sum_func(THD *thd, Item **ref_pointer_array,

1720

List<Item> &fields)

1721

{

1722

item->split_sum_func2(thd, ref_pointer_array, fields, &item, TRUE);

1722

item->split_sum_func2(thd, ref_pointer_array, fields, &item, true);

1723

Item_str_func::split_sum_func(thd, ref_pointer_array, fields);

1724

}

1725

1752

1753

String *Item_func_make_set::val_str(String *str)

1754

{

1755

DBUG_ASSERT(fixed == 1);

1755

assert(fixed == 1);

1756

ulonglong bits;

1757

bool first_found=0;

1758

Item **ptr=args;

1836

1837

String *Item_func_char::val_str(String *str)

1838

{

1839

DBUG_ASSERT(fixed == 1);

1839

assert(fixed == 1);

1840

str->length(0);

1841

str->set_charset(collation.collation);

1842

for (uint i=0 ; i < arg_count ; i++)

1919

1920

String *Item_func_repeat::val_str(String *str)

1921

{

1922

DBUG_ASSERT(fixed == 1);

1922

assert(fixed == 1);

1923

uint length,tot_length;

1924

char *to;

1925

/* must be longlong to avoid truncation */

2005

2006

String *Item_func_rpad::val_str(String *str)

2007

{

2008

DBUG_ASSERT(fixed == 1);

2008

assert(fixed == 1);

2009

uint32 res_byte_length,res_char_length,pad_char_length,pad_byte_length;

2010

char *to;

2011

const char *ptr_pad;

2108

2109

String *Item_func_lpad::val_str(String *str)

2110

{

2111

DBUG_ASSERT(fixed == 1);

2111

assert(fixed == 1);

2112

uint32 res_char_length,pad_char_length;

2113

/* must be longlong to avoid truncation */

2114

longlong count= args[1]->val_int();

2172

2173

String *Item_func_conv::val_str(String *str)

2174

{

2175

DBUG_ASSERT(fixed == 1);

2175

assert(fixed == 1);

2176

String *res= args[0]->val_str(str);

2177

char *endptr,ans[65],*ptr;

2178

longlong dec;

2206

2207

String *Item_func_conv_charset::val_str(String *str)

2208

{

2209

DBUG_ASSERT(fixed == 1);

2209

assert(fixed == 1);

2210

if (use_cached_value)

2211

return null_value ? 0 : &str_value;

2212

String *arg= args[0]->val_str(str);

2238

2239

String *Item_func_set_collation::val_str(String *str)

2240

{

2241

DBUG_ASSERT(fixed == 1);

2241

assert(fixed == 1);

2242

str=args[0]->val_str(str);

2243

if ((null_value=args[0]->null_value))

2244

return 0;

2303

str->append('(');

2304

args[0]->print(str, query_type);

2305

str->append(STRING_WITH_LEN(" collate "));

2306

DBUG_ASSERT(args[1]->basic_const_item() &&

2306

assert(args[1]->basic_const_item() &&

2307

args[1]->type() == Item::STRING_ITEM);

2308

args[1]->str_value.print(str);

2309

str->append(')');

2311

2312

String *Item_func_charset::val_str(String *str)

2313

{

2314

DBUG_ASSERT(fixed == 1);

2314

assert(fixed == 1);

2315

uint dummy_errors;

2316

2317

CHARSET_INFO *cs= args[0]->collation.collation;

2323

2324

String *Item_func_collation::val_str(String *str)

2325

{

2326

DBUG_ASSERT(fixed == 1);

2326

assert(fixed == 1);

2327

uint dummy_errors;

2328

CHARSET_INFO *cs= args[0]->collation.collation;

2329

2350

String *res;

2351

CHARSET_INFO *cs= args[0]->collation.collation;

2352

uint tmp_length, frm_length;

2353

DBUG_ASSERT(fixed == 1);

2353

assert(fixed == 1);

2354

2355

if (args[0]->result_type() != STRING_RESULT ||

2356

!(res= args[0]->val_str(str)))

2380

String *Item_func_hex::val_str(String *str)

2381

{

2382

String *res;

2383

DBUG_ASSERT(fixed == 1);

2383

assert(fixed == 1);

2384

if (args[0]->result_type() != STRING_RESULT)

2385

{

2386

ulonglong dec;

2429

char *to;

2430

String *res;

2431

uint length;

2432

DBUG_ASSERT(fixed == 1);

2432

assert(fixed == 1);

2433

2434

res= args[0]->val_str(str);

2435

if (!res || tmp_value.alloc(length= (1+res->length())/2))

2475

2476

String *Item_load_file::val_str(String *str)

2477

{

2478

DBUG_ASSERT(fixed == 1);

2478

assert(fixed == 1);

2479

String *file_name;

2480

File file;

2481

struct stat stat_info;

2482

char path[FN_REFLEN];

2483

DBUG_ENTER("load_file");

2484

2483

2485

2484

if (!(file_name= args[0]->val_str(str)))

2486

2485

goto err;

2521

2520

tmp_value.length(stat_info.st_size);

2522

2521

my_close(file, MYF(0));

2523

2522

null_value = 0;

2524

DBUG_RETURN(&tmp_value);

2523

return(&tmp_value);

2525

2524

2526

2525

err:

2527

2526

null_value = 1;

2528

DBUG_RETURN(0);

2527

return(0);

2529

2528

}

2530

2529

2531

2530

2532

2531

String* Item_func_export_set::val_str(String* str)

2533

2532

{

2534

DBUG_ASSERT(fixed == 1);

2533

assert(fixed == 1);

2535

2534

ulonglong the_set = (ulonglong) args[0]->val_int();

2536

2535

String yes_buf, *yes;

2537

2536

yes = args[1]->val_str(&yes_buf);

2581

2580

}

2582

2581

break;

2583

2582

default:

2584

DBUG_ASSERT(0); // cannot happen

2583

assert(0); // cannot happen

2585

2584

}

2586

2585

null_value=0;

2587

2586

2632

2631

2633

2632

String *Item_func_quote::val_str(String *str)

2634

2633

{

2635

DBUG_ASSERT(fixed == 1);

2634

assert(fixed == 1);

2636

2635

/*

2637

2636

Bit mask that has 1 for set for the position of the following characters:

2638

2637

0, \, ' and ^Z

2709

2708

2710

2709

longlong Item_func_uncompressed_length::val_int()

2711

2710

{

2712

DBUG_ASSERT(fixed == 1);

2711

assert(fixed == 1);

2713

2712

String *res= args[0]->val_str(&value);

2714

2713

if (!res)

2715

2714

{

2731

2730

2732

2731

longlong Item_func_crc32::val_int()

2733

2732

{

2734

DBUG_ASSERT(fixed == 1);

2733

assert(fixed == 1);

2735

2734

String *res=args[0]->val_str(&value);

2736

2735

if (!res)

2737

2736

{

2752

2751

String *res;

2753

2752

Byte *body;

2754

2753

char *tmp, *last_char;

2755

DBUG_ASSERT(fixed == 1);

2754

assert(fixed == 1);

2756

2755

2757

2756

if (!(res= args[0]->val_str(str)))

2758

2757

{

2811

2810

2812

2811

String *Item_func_uncompress::val_str(String *str)

2813

2812

{

2814

DBUG_ASSERT(fixed == 1);

2813

assert(fixed == 1);

2815

2814

String *res= args[0]->val_str(str);

2816

2815

ulong new_size;

2817

2816

int err;

2903

2902

2904

2903

String *Item_func_uuid::val_str(String *str)

2905

2904

{

2906

DBUG_ASSERT(fixed == 1);

2905

assert(fixed == 1);

2907

2906

char *s;

2908

2907

THD *thd= current_thd;

2909

2908

2954

2953

tv-=nanoseq;

2955

2954

nanoseq=0;

2956

2955

}

2957

DBUG_ASSERT(tv > uuid_time);

2956

assert(tv > uuid_time);

2958

2957

}

2959

2958

uuid_time=tv;

2960

2959

pthread_mutex_unlock(&LOCK_uuid_generator);