~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/item_create.cc

  • Committer: Monty Taylor
  • Date: 2008-07-22 05:48:51 UTC
  • mto: (202.1.3 toru)
  • mto: This revision was merged to the branch mainline in revision 204.
  • Revision ID: monty@inaugust.com-20080722054851-airxt73370725p7x
Re-enabled optimizations for the normal build, and added back the --with-debug option to turn them off. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
20
20
  Functions to create an item. Used by sql_yac.yy
21
21
*/
22
22
 
23
 
#include <drizzled/server_includes.h>
 
23
#include "mysql_priv.h"
 
24
#include "item_create.h"
24
25
 
25
26
/*
26
27
=============================================================================
404
405
  virtual ~Create_func_cot() {}
405
406
};
406
407
 
 
408
 
 
409
class Create_func_crc32 : public Create_func_arg1
 
410
{
 
411
public:
 
412
  virtual Item *create(THD *thd, Item *arg1);
 
413
 
 
414
  static Create_func_crc32 s_singleton;
 
415
 
 
416
protected:
 
417
  Create_func_crc32() {}
 
418
  virtual ~Create_func_crc32() {}
 
419
};
 
420
 
 
421
 
407
422
class Create_func_date_format : public Create_func_arg2
408
423
{
409
424
public:
521
536
};
522
537
 
523
538
 
 
539
class Create_func_encode : public Create_func_arg2
 
540
{
 
541
public:
 
542
  virtual Item *create(THD *thd, Item *arg1, Item *arg2);
 
543
 
 
544
  static Create_func_encode s_singleton;
 
545
 
 
546
protected:
 
547
  Create_func_encode() {}
 
548
  virtual ~Create_func_encode() {}
 
549
};
 
550
 
 
551
 
 
552
class Create_func_encrypt : public Create_native_func
 
553
{
 
554
public:
 
555
  virtual Item *create_native(THD *thd, LEX_STRING name, List<Item> *item_list);
 
556
 
 
557
  static Create_func_encrypt s_singleton;
 
558
 
 
559
protected:
 
560
  Create_func_encrypt() {}
 
561
  virtual ~Create_func_encrypt() {}
 
562
};
 
563
 
 
564
 
524
565
class Create_func_exp : public Create_func_arg1
525
566
{
526
567
public:
923
964
  virtual ~Create_func_master_pos_wait() {}
924
965
};
925
966
 
 
967
 
 
968
class Create_func_md5 : public Create_func_arg1
 
969
{
 
970
public:
 
971
  virtual Item *create(THD *thd, Item *arg1);
 
972
 
 
973
  static Create_func_md5 s_singleton;
 
974
 
 
975
protected:
 
976
  Create_func_md5() {}
 
977
  virtual ~Create_func_md5() {}
 
978
};
 
979
 
 
980
 
926
981
class Create_func_monthname : public Create_func_arg1
927
982
{
928
983
public:
1461
1516
Item*
1462
1517
Create_udf_func::create(THD *thd, udf_func *udf, List<Item> *item_list)
1463
1518
{
1464
 
  Item_func *func= NULL;
 
1519
  Item *func= NULL;
1465
1520
  int arg_count= 0;
1466
1521
 
1467
1522
  if (item_list != NULL)
1469
1524
 
1470
1525
  thd->lex->set_stmt_unsafe();
1471
1526
 
1472
 
  func= udf->create_func(thd->mem_root);
1473
 
 
1474
 
  func->set_arguments(*item_list);
1475
 
 
 
1527
  assert(   (udf->type == UDFTYPE_FUNCTION)
 
1528
              || (udf->type == UDFTYPE_AGGREGATE));
 
1529
 
 
1530
  switch(udf->returns) {
 
1531
  case STRING_RESULT:
 
1532
  {
 
1533
    if (udf->type == UDFTYPE_FUNCTION)
 
1534
    {
 
1535
      if (arg_count)
 
1536
        func= new (thd->mem_root) Item_func_udf_str(udf, *item_list);
 
1537
      else
 
1538
        func= new (thd->mem_root) Item_func_udf_str(udf);
 
1539
    }
 
1540
    else
 
1541
    {
 
1542
      if (arg_count)
 
1543
        func= new (thd->mem_root) Item_sum_udf_str(udf, *item_list);
 
1544
      else
 
1545
        func= new (thd->mem_root) Item_sum_udf_str(udf);
 
1546
    }
 
1547
    break;
 
1548
  }
 
1549
  case REAL_RESULT:
 
1550
  {
 
1551
    if (udf->type == UDFTYPE_FUNCTION)
 
1552
    {
 
1553
      if (arg_count)
 
1554
        func= new (thd->mem_root) Item_func_udf_float(udf, *item_list);
 
1555
      else
 
1556
        func= new (thd->mem_root) Item_func_udf_float(udf);
 
1557
    }
 
1558
    else
 
1559
    {
 
1560
      if (arg_count)
 
1561
        func= new (thd->mem_root) Item_sum_udf_float(udf, *item_list);
 
1562
      else
 
1563
        func= new (thd->mem_root) Item_sum_udf_float(udf);
 
1564
    }
 
1565
    break;
 
1566
  }
 
1567
  case INT_RESULT:
 
1568
  {
 
1569
    if (udf->type == UDFTYPE_FUNCTION)
 
1570
    {
 
1571
      if (arg_count)
 
1572
        func= new (thd->mem_root) Item_func_udf_int(udf, *item_list);
 
1573
      else
 
1574
        func= new (thd->mem_root) Item_func_udf_int(udf);
 
1575
    }
 
1576
    else
 
1577
    {
 
1578
      if (arg_count)
 
1579
        func= new (thd->mem_root) Item_sum_udf_int(udf, *item_list);
 
1580
      else
 
1581
        func= new (thd->mem_root) Item_sum_udf_int(udf);
 
1582
    }
 
1583
    break;
 
1584
  }
 
1585
  case DECIMAL_RESULT:
 
1586
  {
 
1587
    if (udf->type == UDFTYPE_FUNCTION)
 
1588
    {
 
1589
      if (arg_count)
 
1590
        func= new (thd->mem_root) Item_func_udf_decimal(udf, *item_list);
 
1591
      else
 
1592
        func= new (thd->mem_root) Item_func_udf_decimal(udf);
 
1593
    }
 
1594
    else
 
1595
    {
 
1596
      if (arg_count)
 
1597
        func= new (thd->mem_root) Item_sum_udf_decimal(udf, *item_list);
 
1598
      else
 
1599
        func= new (thd->mem_root) Item_sum_udf_decimal(udf);
 
1600
    }
 
1601
    break;
 
1602
  }
 
1603
  default:
 
1604
  {
 
1605
    my_error(ER_NOT_SUPPORTED_YET, MYF(0), "UDF return type");
 
1606
  }
 
1607
  }
1476
1608
  return func;
1477
1609
}
1478
1610
 
1679
1811
Item*
1680
1812
Create_func_bin::create(THD *thd, Item *arg1)
1681
1813
{
1682
 
  Item *i10= new (thd->mem_root) Item_int((int32_t) 10,2);
1683
 
  Item *i2= new (thd->mem_root) Item_int((int32_t) 2,1);
 
1814
  Item *i10= new (thd->mem_root) Item_int((int32) 10,2);
 
1815
  Item *i2= new (thd->mem_root) Item_int((int32) 2,1);
1684
1816
  return new (thd->mem_root) Item_func_conv(arg1, i10, i2);
1685
1817
}
1686
1818
 
1810
1942
  return new (thd->mem_root) Item_func_div(i1, i2);
1811
1943
}
1812
1944
 
 
1945
 
 
1946
Create_func_crc32 Create_func_crc32::s_singleton;
 
1947
 
 
1948
Item*
 
1949
Create_func_crc32::create(THD *thd, Item *arg1)
 
1950
{
 
1951
  return new (thd->mem_root) Item_func_crc32(arg1);
 
1952
}
 
1953
 
 
1954
 
1813
1955
Create_func_date_format Create_func_date_format::s_singleton;
1814
1956
 
1815
1957
Item*
1867
2009
}
1868
2010
 
1869
2011
 
 
2012
Create_func_decode Create_func_decode::s_singleton;
 
2013
 
 
2014
Item*
 
2015
Create_func_decode::create(THD *thd, Item *arg1, Item *arg2)
 
2016
{
 
2017
  return new (thd->mem_root) Item_func_decode(arg1, arg2);
 
2018
}
 
2019
 
 
2020
 
1870
2021
Create_func_degrees Create_func_degrees::s_singleton;
1871
2022
 
1872
2023
Item*
1898
2049
}
1899
2050
 
1900
2051
 
 
2052
Create_func_encode Create_func_encode::s_singleton;
 
2053
 
 
2054
Item*
 
2055
Create_func_encode::create(THD *thd, Item *arg1, Item *arg2)
 
2056
{
 
2057
  return new (thd->mem_root) Item_func_encode(arg1, arg2);
 
2058
}
 
2059
 
 
2060
 
 
2061
Create_func_encrypt Create_func_encrypt::s_singleton;
 
2062
 
 
2063
Item*
 
2064
Create_func_encrypt::create_native(THD *thd, LEX_STRING name,
 
2065
                                   List<Item> *item_list)
 
2066
{
 
2067
  Item *func= NULL;
 
2068
  int arg_count= 0;
 
2069
 
 
2070
  if (item_list != NULL)
 
2071
    arg_count= item_list->elements;
 
2072
 
 
2073
  switch (arg_count) {
 
2074
  case 1:
 
2075
  {
 
2076
    Item *param_1= item_list->pop();
 
2077
    func= new (thd->mem_root) Item_func_encrypt(param_1);
 
2078
    break;
 
2079
  }
 
2080
  case 2:
 
2081
  {
 
2082
    Item *param_1= item_list->pop();
 
2083
    Item *param_2= item_list->pop();
 
2084
    func= new (thd->mem_root) Item_func_encrypt(param_1, param_2);
 
2085
    break;
 
2086
  }
 
2087
  default:
 
2088
  {
 
2089
    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
 
2090
    break;
 
2091
  }
 
2092
  }
 
2093
 
 
2094
  return func;
 
2095
}
 
2096
 
 
2097
 
1901
2098
Create_func_exp Create_func_exp::s_singleton;
1902
2099
 
1903
2100
Item*
2417
2614
}
2418
2615
 
2419
2616
 
 
2617
Create_func_md5 Create_func_md5::s_singleton;
 
2618
 
 
2619
Item*
 
2620
Create_func_md5::create(THD *thd, Item *arg1)
 
2621
{
 
2622
  return new (thd->mem_root) Item_func_md5(arg1);
 
2623
}
 
2624
 
 
2625
 
2420
2626
Create_func_monthname Create_func_monthname::s_singleton;
2421
2627
 
2422
2628
Item*
2440
2646
Item*
2441
2647
Create_func_oct::create(THD *thd, Item *arg1)
2442
2648
{
2443
 
  Item *i10= new (thd->mem_root) Item_int((int32_t) 10,2);
2444
 
  Item *i8= new (thd->mem_root) Item_int((int32_t) 8,1);
 
2649
  Item *i10= new (thd->mem_root) Item_int((int32) 10,2);
 
2650
  Item *i8= new (thd->mem_root) Item_int((int32) 8,1);
2445
2651
  return new (thd->mem_root) Item_func_conv(arg1, i10, i8);
2446
2652
}
2447
2653
 
2648
2854
    The parsed item tree should not depend on
2649
2855
    <code>thd->variables.collation_connection</code>.
2650
2856
  */
2651
 
  const CHARSET_INFO * const cs= thd->variables.collation_connection;
 
2857
  CHARSET_INFO *cs= thd->variables.collation_connection;
2652
2858
  Item *sp;
2653
2859
 
2654
2860
  if (cs->mbminlen > 1)
2655
2861
  {
2656
 
    uint32_t dummy_errors;
 
2862
    uint dummy_errors;
2657
2863
    sp= new (thd->mem_root) Item_string("", 0, cs, DERIVATION_COERCIBLE, MY_REPERTOIRE_ASCII);
2658
 
    sp->str_value.copy(" ", 1, &my_charset_utf8_general_ci, cs, &dummy_errors);
 
2864
    sp->str_value.copy(" ", 1, &my_charset_latin1, cs, &dummy_errors);
2659
2865
  }
2660
2866
  else
2661
2867
  {
2927
3133
  { { C_STRING_WITH_LEN("CONV") }, BUILDER(Create_func_conv)},
2928
3134
  { { C_STRING_WITH_LEN("COS") }, BUILDER(Create_func_cos)},
2929
3135
  { { C_STRING_WITH_LEN("COT") }, BUILDER(Create_func_cot)},
 
3136
  { { C_STRING_WITH_LEN("CRC32") }, BUILDER(Create_func_crc32)},
2930
3137
  { { C_STRING_WITH_LEN("DATEDIFF") }, BUILDER(Create_func_datediff)},
2931
3138
  { { C_STRING_WITH_LEN("DATE_FORMAT") }, BUILDER(Create_func_date_format)},
2932
3139
  { { C_STRING_WITH_LEN("DAYNAME") }, BUILDER(Create_func_dayname)},
2933
3140
  { { C_STRING_WITH_LEN("DAYOFMONTH") }, BUILDER(Create_func_dayofmonth)},
2934
3141
  { { C_STRING_WITH_LEN("DAYOFWEEK") }, BUILDER(Create_func_dayofweek)},
2935
3142
  { { C_STRING_WITH_LEN("DAYOFYEAR") }, BUILDER(Create_func_dayofyear)},
 
3143
  { { C_STRING_WITH_LEN("DECODE") }, BUILDER(Create_func_decode)},
2936
3144
  { { C_STRING_WITH_LEN("DEGREES") }, BUILDER(Create_func_degrees)},
2937
3145
  { { C_STRING_WITH_LEN("ELT") }, BUILDER(Create_func_elt)},
 
3146
  { { C_STRING_WITH_LEN("ENCODE") }, BUILDER(Create_func_encode)},
 
3147
  { { C_STRING_WITH_LEN("ENCRYPT") }, BUILDER(Create_func_encrypt)},
2938
3148
  { { C_STRING_WITH_LEN("EXP") }, BUILDER(Create_func_exp)},
2939
3149
  { { C_STRING_WITH_LEN("EXPORT_SET") }, BUILDER(Create_func_export_set)},
2940
3150
  { { C_STRING_WITH_LEN("FIELD") }, BUILDER(Create_func_field)},
2967
3177
  { { C_STRING_WITH_LEN("MAKETIME") }, BUILDER(Create_func_maketime)},
2968
3178
  { { C_STRING_WITH_LEN("MAKE_SET") }, BUILDER(Create_func_make_set)},
2969
3179
  { { C_STRING_WITH_LEN("MASTER_POS_WAIT") }, BUILDER(Create_func_master_pos_wait)},
 
3180
  { { C_STRING_WITH_LEN("MD5") }, BUILDER(Create_func_md5)},
2970
3181
  { { C_STRING_WITH_LEN("MONTHNAME") }, BUILDER(Create_func_monthname)},
2971
3182
  { { C_STRING_WITH_LEN("NULLIF") }, BUILDER(Create_func_nullif)},
2972
3183
  { { C_STRING_WITH_LEN("OCT") }, BUILDER(Create_func_oct)},
3013
3224
 
3014
3225
static HASH native_functions_hash;
3015
3226
 
3016
 
extern "C" unsigned char*
3017
 
get_native_fct_hash_key(const unsigned char *buff, size_t *length,
3018
 
                        bool /* unused */)
 
3227
extern "C" uchar*
 
3228
get_native_fct_hash_key(const uchar *buff, size_t *length,
 
3229
                        my_bool /* unused */)
3019
3230
{
3020
3231
  Native_func_registry *func= (Native_func_registry*) buff;
3021
3232
  *length= func->name.length;
3022
 
  return (unsigned char*) func->name.str;
 
3233
  return (uchar*) func->name.str;
3023
3234
}
3024
3235
 
3025
3236
/*
3044
3255
 
3045
3256
  for (func= func_array; func->builder != NULL; func++)
3046
3257
  {
3047
 
    if (my_hash_insert(& native_functions_hash, (unsigned char*) func))
 
3258
    if (my_hash_insert(& native_functions_hash, (uchar*) func))
3048
3259
      return(1);
3049
3260
  }
3050
3261
 
3064
3275
}
3065
3276
 
3066
3277
Create_func *
3067
 
find_native_function_builder(THD *thd __attribute__((unused)),
 
3278
find_native_function_builder(THD *thd __attribute__((__unused__)),
3068
3279
                             LEX_STRING name)
3069
3280
{
3070
3281
  Native_func_registry *func;
3072
3283
 
3073
3284
  /* Thread safe */
3074
3285
  func= (Native_func_registry*) hash_search(& native_functions_hash,
3075
 
                                            (unsigned char*) name.str,
 
3286
                                            (uchar*) name.str,
3076
3287
                                             name.length);
3077
3288
 
3078
3289
  if (func)
3085
3296
 
3086
3297
 
3087
3298
Item*
3088
 
create_func_char_cast(THD *thd, Item *a, int len, const CHARSET_INFO * const cs)
 
3299
create_func_char_cast(THD *thd, Item *a, int len, CHARSET_INFO *cs)
3089
3300
{
3090
 
  const CHARSET_INFO * const real_cs= (cs ? cs : thd->variables.collation_connection);
 
3301
  CHARSET_INFO *real_cs= (cs ? cs : thd->variables.collation_connection);
3091
3302
  return new (thd->mem_root) Item_char_typecast(a, len, real_cs);
3092
3303
}
3093
3304
 
3095
3306
Item *
3096
3307
create_func_cast(THD *thd, Item *a, Cast_target cast_type,
3097
3308
                 const char *c_len, const char *c_dec,
3098
 
                 const CHARSET_INFO * const cs)
 
3309
                 CHARSET_INFO *cs)
3099
3310
{
3100
3311
  Item *res;
3101
 
  uint32_t len;
3102
 
  uint32_t dec;
 
3312
  ulong len;
 
3313
  uint dec;
3103
3314
 
3104
3315
  switch (cast_type) {
3105
3316
  case ITEM_CAST_BINARY: