~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/item.h

• browse files at revision 77.1.66
• compare with another revision
• compare with revision 77.3.19
• download diff
• download tarball
• view history from revision 77.1.66

Show diffs side-by-side

added

removed

server/item.h

586

586

  */

587

587

  virtual longlong val_int_endpoint(bool left_endp __attribute__((__unused__)),

588

588

                                    bool *incl_endp __attribute__((__unused__)))

589

 

  { DBUG_ASSERT(0); return 0; }

 

589

  { assert(0); return 0; }

590

590

 

591

591

 

592

592

  /* valXXX methods must return NULL or 0 or 0.0 if null_value is set. */

1173

1173

  virtual Item *update_value_transformer(uchar *select_arg);

1174

1174

  virtual void print(String *str, enum_query_type query_type);

1175

1175

 

1176

 

#ifndef DBUG_OFF

1177

 

  void dbug_print()

1178

 

  {

1179

 

  }

1180

 

#endif

1181

 

 

1182

1176

  friend class Item_default_value;

1183

1177

  friend class Item_insert_value;

1184

1178

  friend class st_select_lex_unit;

1347

1341

  { return state != NO_VALUE ? (table_map)0 : PARAM_TABLE_BIT; }

1348

1342

  virtual void print(String *str, enum_query_type query_type);

1349

1343

  bool is_null()

1350

 

  { DBUG_ASSERT(state != NO_VALUE); return state == NULL_VALUE; }

 

1344

  { assert(state != NO_VALUE); return state == NULL_VALUE; }

1351

1345

  bool basic_const_item() const;

1352

1346

  /*

1353

1347

    This method is used to make a copy of a basic constant item when

1391

1385

  enum Type type() const { return INT_ITEM; }

1392

1386

  enum Item_result result_type () const { return INT_RESULT; }

1393

1387

  enum_field_types field_type() const { return MYSQL_TYPE_LONGLONG; }

1394

 

  longlong val_int() { DBUG_ASSERT(fixed == 1); return value; }

1395

 

  double val_real() { DBUG_ASSERT(fixed == 1); return (double) value; }

 

1388

  longlong val_int() { assert(fixed == 1); return value; }

 

1389

  double val_real() { assert(fixed == 1); return (double) value; }

1396

1390

  my_decimal *val_decimal(my_decimal *);

1397

1391

  String *val_str(String*);

1398

1392

  int save_in_field(Field *field, bool no_conversions);

1413

1407

  Item_uint(ulonglong i) :Item_int((ulonglong) i, 10) {}

1414

1408

  Item_uint(const char *str_arg, longlong i, uint length);

1415

1409

  double val_real()

1416

 

    { DBUG_ASSERT(fixed == 1); return ulonglong2double((ulonglong)value); }

 

1410

    { assert(fixed == 1); return ulonglong2double((ulonglong)value); }

1417

1411

  String *val_str(String*);

1418

1412

  Item *clone_item() { return new Item_uint(name, value, max_length); }

1419

1413

  int save_in_field(Field *field, bool no_conversions);

1487

1481

  int save_in_field(Field *field, bool no_conversions);

1488

1482

  enum Type type() const { return REAL_ITEM; }

1489

1483

  enum_field_types field_type() const { return MYSQL_TYPE_DOUBLE; }

1490

 

  double val_real() { DBUG_ASSERT(fixed == 1); return value; }

 

1484

  double val_real() { assert(fixed == 1); return value; }

1491

1485

  longlong val_int()

1492

1486

  {

1493

 

    DBUG_ASSERT(fixed == 1);

 

1487

    assert(fixed == 1);

1494

1488

    if (value <= (double) LONGLONG_MIN)

1495

1489

    {

1496

1490

       return LONGLONG_MIN;

1597

1591

  longlong val_int();

1598

1592

  String *val_str(String*)

1599

1593

  {

1600

 

    DBUG_ASSERT(fixed == 1);

 

1594

    assert(fixed == 1);

1601

1595

    return (String*) &str_value;

1602

1596

  }

1603

1597

  my_decimal *val_decimal(my_decimal *);

1744

1738

  enum Type type() const { return VARBIN_ITEM; }

1745

1739

  double val_real()

1746

1740

  { 

1747

 

    DBUG_ASSERT(fixed == 1); 

 

1741

    assert(fixed == 1); 

1748

1742

    return (double) (ulonglong) Item_hex_string::val_int();

1749

1743

  }

1750

1744

  longlong val_int();

1751

1745

  bool basic_const_item() const { return 1; }

1752

 

  String *val_str(String*) { DBUG_ASSERT(fixed == 1); return &str_value; }

 

1746

  String *val_str(String*) { assert(fixed == 1); return &str_value; }

1753

1747

  my_decimal *val_decimal(my_decimal *);

1754

1748

  int save_in_field(Field *field, bool no_conversions);

1755

1749

  enum Item_result result_type () const { return STRING_RESULT; }

2203

2197

  uint length;

2204

2198

 

2205

2199

public:

2206

 

#ifndef DBUG_OFF

2207

 

  void dbug_print()

2208

 

  {

2209

 

    uchar *org_ptr;

2210

 

    org_ptr= field->ptr;

2211

 

    fprintf(DBUG_FILE, "new: ");

2212

 

    field->dbug_print();

2213

 

    field->ptr= buff;

2214

 

    fprintf(DBUG_FILE, ", old: ");

2215

 

    field->dbug_print();

2216

 

    field->ptr= org_ptr;

2217

 

    fprintf(DBUG_FILE, "\n");

2218

 

  }

2219

 

#endif

2220

2200

  Cached_item_field(Field *arg_field) : field(arg_field)

2221

2201

  {

2222

2202

    field= arg_field;

2365

2345

 

2366

2346

  void store(Item *item);

2367

2347

  void store(Item *item, longlong val_arg);

2368

 

  double val_real() { DBUG_ASSERT(fixed == 1); return (double) value; }

2369

 

  longlong val_int() { DBUG_ASSERT(fixed == 1); return value; }

 

2348

  double val_real() { assert(fixed == 1); return (double) value; }

 

2349

  longlong val_int() { assert(fixed == 1); return value; }

2370

2350

  String* val_str(String *str);

2371

2351

  my_decimal *val_decimal(my_decimal *);

2372

2352

  enum Item_result result_type() const { return INT_RESULT; }

2381

2361

  Item_cache_real(): Item_cache(), value(0) {}

2382

2362

 

2383

2363

  void store(Item *item);

2384

 

  double val_real() { DBUG_ASSERT(fixed == 1); return value; }

 

2364

  double val_real() { assert(fixed == 1); return value; }

2385

2365

  longlong val_int();

2386

2366

  String* val_str(String *str);

2387

2367

  my_decimal *val_decimal(my_decimal *);

2422

2402

  void store(Item *item);

2423

2403

  double val_real();

2424

2404

  longlong val_int();

2425

 

  String* val_str(String *) { DBUG_ASSERT(fixed == 1); return value; }

 

2405

  String* val_str(String *) { assert(fixed == 1); return value; }

2426

2406

  my_decimal *val_decimal(my_decimal *);

2427

2407

  enum Item_result result_type() const { return STRING_RESULT; }

2428

2408

  CHARSET_INFO *charset() const { return value->charset(); };

2486

2466

  void keep_array() { save_array= 1; }

2487

2467

  void cleanup()

2488

2468

  {

2489

 

    DBUG_ENTER("Item_cache_row::cleanup");

2490

2469

    Item_cache::cleanup();

2491

2470

    if (save_array)

2492

2471

      bzero(values, item_count*sizeof(Item**));

2493

2472

    else

2494

2473

      values= 0;

2495

 

    DBUG_VOID_RETURN;

 

2474

    return;

2496

2475

  }

2497

2476

};

2498

2477

 

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1