← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/create.cc

Merge Joe, plus I updated the tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item/create.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
/**
17
17
  @file
25
25
#include <drizzled/item/func.h>
26
26
#include <drizzled/error.h>
27
27
 
28
 
#include "drizzled/function_container.h"
29
 
 
30
28
#include <drizzled/function/str/binary.h>
31
29
#include <drizzled/function/str/concat.h>
32
30
#include <drizzled/function/str/conv.h>
 
31
#include <drizzled/function/str/elt.h>
33
32
#include <drizzled/function/str/export_set.h>
 
33
#include <drizzled/function/str/format.h>
34
34
#include <drizzled/function/str/load_file.h>
35
35
#include <drizzled/function/str/make_set.h>
36
36
#include <drizzled/function/str/pad.h>
61
61
/* Function declarations */
62
62
 
63
63
#include <drizzled/function/func.h>
 
64
#include <drizzled/function/math/abs.h>
 
65
#include <drizzled/function/math/acos.h>
64
66
#include <drizzled/function/additive_op.h>
 
67
#include <drizzled/function/math/asin.h>
 
68
#include <drizzled/function/math/atan.h>
 
69
#include <drizzled/function/math/ceiling.h>
 
70
#include <drizzled/function/coercibility.h>
 
71
#include <drizzled/function/math/cos.h>
65
72
#include <drizzled/function/math/dec.h>
66
73
#include <drizzled/function/math/decimal_typecast.h>
 
74
#include <drizzled/function/math/exp.h>
67
75
#include <drizzled/function/field.h>
68
76
#include <drizzled/function/find_in_set.h>
 
77
#include <drizzled/function/math/floor.h>
69
78
#include <drizzled/function/found_rows.h>
70
79
#include <drizzled/function/get_system_var.h>
71
80
#include <drizzled/function/math/int_val.h>
72
81
#include <drizzled/function/math/integer.h>
73
82
#include <drizzled/function/last_insert.h>
 
83
#include <drizzled/function/math/ln.h>
74
84
#include <drizzled/function/locate.h>
 
85
#include <drizzled/function/math/log.h>
75
86
#include <drizzled/function/min_max.h>
76
87
#include <drizzled/function/num1.h>
77
88
#include <drizzled/function/num_op.h>
78
89
#include <drizzled/function/numhybrid.h>
 
90
#include <drizzled/function/math/ord.h>
 
91
#include <drizzled/function/math/pow.h>
79
92
#include <drizzled/function/math/real.h>
80
93
#include <drizzled/function/row_count.h>
81
94
#include <drizzled/function/set_user_var.h>
82
95
#include <drizzled/function/sign.h>
 
96
#include <drizzled/function/math/sin.h>
 
97
#include <drizzled/function/math/sqrt.h>
 
98
#include <drizzled/function/str/quote.h>
83
99
#include <drizzled/function/math/tan.h>
84
100
#include <drizzled/function/units.h>
85
101
 
86
 
#include "drizzled/function/cast/boolean.h"
87
 
#include "drizzled/function/cast/signed.h"
88
 
#include "drizzled/function/cast/time.h"
89
 
#include "drizzled/function/cast/unsigned.h"
 
102
#include <map>
90
103
 
91
104
using namespace std;
92
105
 
245
258
  it helps to compare code between versions, and helps with merges conflicts.
246
259
*/
247
260
 
 
261
class Create_func_abs : public Create_func_arg1
 
262
{
 
263
public:
 
264
  using Create_func_arg1::create;
 
265
 
 
266
  virtual Item *create(Session *session, Item *arg1);
 
267
 
 
268
  static Create_func_abs s_singleton;
 
269
 
 
270
protected:
 
271
  Create_func_abs() {}
 
272
  virtual ~Create_func_abs() {}
 
273
};
 
274
 
 
275
 
 
276
class Create_func_acos : public Create_func_arg1
 
277
{
 
278
public:
 
279
  using Create_func_arg1::create;
 
280
 
 
281
  virtual Item *create(Session *session, Item *arg1);
 
282
 
 
283
  static Create_func_acos s_singleton;
 
284
 
 
285
protected:
 
286
  Create_func_acos() {}
 
287
  virtual ~Create_func_acos() {}
 
288
};
 
289
 
 
290
class Create_func_asin : public Create_func_arg1
 
291
{
 
292
public:
 
293
  using Create_func_arg1::create;
 
294
 
 
295
  virtual Item *create(Session *session, Item *arg1);
 
296
 
 
297
  static Create_func_asin s_singleton;
 
298
 
 
299
protected:
 
300
  Create_func_asin() {}
 
301
  virtual ~Create_func_asin() {}
 
302
};
 
303
 
 
304
 
 
305
class Create_func_atan : public Create_native_func
 
306
{
 
307
public:
 
308
  virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
 
309
 
 
310
  static Create_func_atan s_singleton;
 
311
 
 
312
protected:
 
313
  Create_func_atan() {}
 
314
  virtual ~Create_func_atan() {}
 
315
};
248
316
 
249
317
class Create_func_bin : public Create_func_arg1
250
318
{
260
328
  virtual ~Create_func_bin() {}
261
329
};
262
330
 
 
331
 
 
332
class Create_func_ceiling : public Create_func_arg1
 
333
{
 
334
public:
 
335
  using Create_func_arg1::create;
 
336
 
 
337
  virtual Item *create(Session *session, Item *arg1);
 
338
 
 
339
  static Create_func_ceiling s_singleton;
 
340
 
 
341
protected:
 
342
  Create_func_ceiling() {}
 
343
  virtual ~Create_func_ceiling() {}
 
344
};
 
345
 
 
346
 
 
347
class Create_func_coercibility : public Create_func_arg1
 
348
{
 
349
public:
 
350
  using Create_func_arg1::create;
 
351
 
 
352
  virtual Item *create(Session *session, Item *arg1);
 
353
 
 
354
  static Create_func_coercibility s_singleton;
 
355
 
 
356
protected:
 
357
  Create_func_coercibility() {}
 
358
  virtual ~Create_func_coercibility() {}
 
359
};
 
360
 
 
361
 
263
362
class Create_func_concat : public Create_native_func
264
363
{
265
364
public:
300
399
  virtual ~Create_func_conv() {}
301
400
};
302
401
 
 
402
 
 
403
class Create_func_cos : public Create_func_arg1
 
404
{
 
405
public:
 
406
  using Create_func_arg1::create;
 
407
 
 
408
  virtual Item *create(Session *session, Item *arg1);
 
409
 
 
410
  static Create_func_cos s_singleton;
 
411
 
 
412
protected:
 
413
  Create_func_cos() {}
 
414
  virtual ~Create_func_cos() {}
 
415
};
 
416
 
 
417
 
303
418
class Create_func_cot : public Create_func_arg1
304
419
{
305
420
public:
433
548
  virtual ~Create_func_degrees() {}
434
549
};
435
550
 
 
551
 
 
552
class Create_func_elt : public Create_native_func
 
553
{
 
554
public:
 
555
  virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
 
556
 
 
557
  static Create_func_elt s_singleton;
 
558
 
 
559
protected:
 
560
  Create_func_elt() {}
 
561
  virtual ~Create_func_elt() {}
 
562
};
 
563
 
 
564
 
 
565
class Create_func_exp : public Create_func_arg1
 
566
{
 
567
public:
 
568
  using Create_func_arg1::create;
 
569
 
 
570
  virtual Item *create(Session *session, Item *arg1);
 
571
 
 
572
  static Create_func_exp s_singleton;
 
573
 
 
574
protected:
 
575
  Create_func_exp() {}
 
576
  virtual ~Create_func_exp() {}
 
577
};
 
578
 
 
579
 
436
580
class Create_func_export_set : public Create_native_func
437
581
{
438
 
 
439
582
public:
440
583
  virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
441
584
 
474
617
  virtual ~Create_func_find_in_set() {}
475
618
};
476
619
 
 
620
 
 
621
class Create_func_floor : public Create_func_arg1
 
622
{
 
623
public:
 
624
  using Create_func_arg1::create;
 
625
 
 
626
  virtual Item *create(Session *session, Item *arg1);
 
627
 
 
628
  static Create_func_floor s_singleton;
 
629
 
 
630
protected:
 
631
  Create_func_floor() {}
 
632
  virtual ~Create_func_floor() {}
 
633
};
 
634
 
 
635
 
 
636
class Create_func_format : public Create_func_arg2
 
637
{
 
638
public:
 
639
  using Create_func_arg2::create;
 
640
 
 
641
  virtual Item *create(Session *session, Item *arg1, Item *arg2);
 
642
 
 
643
  static Create_func_format s_singleton;
 
644
 
 
645
protected:
 
646
  Create_func_format() {}
 
647
  virtual ~Create_func_format() {}
 
648
};
 
649
 
 
650
 
477
651
class Create_func_found_rows : public Create_func_arg0
478
652
{
479
653
public:
630
804
  virtual ~Create_func_least() {}
631
805
};
632
806
 
 
807
 
 
808
class Create_func_ln : public Create_func_arg1
 
809
{
 
810
public:
 
811
  using Create_func_arg1::create;
 
812
 
 
813
  virtual Item *create(Session *session, Item *arg1);
 
814
 
 
815
  static Create_func_ln s_singleton;
 
816
 
 
817
protected:
 
818
  Create_func_ln() {}
 
819
  virtual ~Create_func_ln() {}
 
820
};
 
821
 
 
822
 
633
823
class Create_func_load_file : public Create_func_arg1
634
824
{
635
825
public:
658
848
};
659
849
 
660
850
 
 
851
class Create_func_log : public Create_native_func
 
852
{
 
853
public:
 
854
  virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
 
855
 
 
856
  static Create_func_log s_singleton;
 
857
 
 
858
protected:
 
859
  Create_func_log() {}
 
860
  virtual ~Create_func_log() {}
 
861
};
 
862
 
 
863
 
 
864
class Create_func_log10 : public Create_func_arg1
 
865
{
 
866
public:
 
867
  using Create_func_arg1::create;
 
868
 
 
869
  virtual Item *create(Session *session, Item *arg1);
 
870
 
 
871
  static Create_func_log10 s_singleton;
 
872
 
 
873
protected:
 
874
  Create_func_log10() {}
 
875
  virtual ~Create_func_log10() {}
 
876
};
 
877
 
 
878
 
 
879
class Create_func_log2 : public Create_func_arg1
 
880
{
 
881
public:
 
882
  using Create_func_arg1::create;
 
883
 
 
884
  virtual Item *create(Session *session, Item *arg1);
 
885
 
 
886
  static Create_func_log2 s_singleton;
 
887
 
 
888
protected:
 
889
  Create_func_log2() {}
 
890
  virtual ~Create_func_log2() {}
 
891
};
 
892
 
 
893
 
661
894
class Create_func_lpad : public Create_func_arg3
662
895
{
663
896
public:
774
1007
  virtual ~Create_func_oct() {}
775
1008
};
776
1009
 
 
1010
 
 
1011
class Create_func_ord : public Create_func_arg1
 
1012
{
 
1013
public:
 
1014
  using Create_func_arg1::create;
 
1015
 
 
1016
  virtual Item *create(Session *session, Item *arg1);
 
1017
 
 
1018
  static Create_func_ord s_singleton;
 
1019
 
 
1020
protected:
 
1021
  Create_func_ord() {}
 
1022
  virtual ~Create_func_ord() {}
 
1023
};
 
1024
 
 
1025
 
777
1026
class Create_func_period_add : public Create_func_arg2
778
1027
{
779
1028
public:
818
1067
  virtual ~Create_func_pi() {}
819
1068
};
820
1069
 
 
1070
 
 
1071
class Create_func_pow : public Create_func_arg2
 
1072
{
 
1073
public:
 
1074
  using Create_func_arg2::create;
 
1075
 
 
1076
  virtual Item *create(Session *session, Item *arg1, Item *arg2);
 
1077
 
 
1078
  static Create_func_pow s_singleton;
 
1079
 
 
1080
protected:
 
1081
  Create_func_pow() {}
 
1082
  virtual ~Create_func_pow() {}
 
1083
};
 
1084
 
 
1085
 
 
1086
class Create_func_quote : public Create_func_arg1
 
1087
{
 
1088
public:
 
1089
  using Create_func_arg1::create;
 
1090
 
 
1091
  virtual Item *create(Session *session, Item *arg1);
 
1092
 
 
1093
  static Create_func_quote s_singleton;
 
1094
 
 
1095
protected:
 
1096
  Create_func_quote() {}
 
1097
  virtual ~Create_func_quote() {}
 
1098
};
 
1099
 
 
1100
 
821
1101
class Create_func_radians : public Create_func_arg1
822
1102
{
823
1103
public:
904
1184
  virtual ~Create_func_sign() {}
905
1185
};
906
1186
 
 
1187
 
 
1188
class Create_func_sin : public Create_func_arg1
 
1189
{
 
1190
public:
 
1191
  using Create_func_arg1::create;
 
1192
 
 
1193
  virtual Item *create(Session *session, Item *arg1);
 
1194
 
 
1195
  static Create_func_sin s_singleton;
 
1196
 
 
1197
protected:
 
1198
  Create_func_sin() {}
 
1199
  virtual ~Create_func_sin() {}
 
1200
};
 
1201
 
 
1202
 
907
1203
class Create_func_space : public Create_func_arg1
908
1204
{
909
1205
public:
918
1214
  virtual ~Create_func_space() {}
919
1215
};
920
1216
 
 
1217
 
 
1218
class Create_func_sqrt : public Create_func_arg1
 
1219
{
 
1220
public:
 
1221
  using Create_func_arg1::create;
 
1222
 
 
1223
  virtual Item *create(Session *session, Item *arg1);
 
1224
 
 
1225
  static Create_func_sqrt s_singleton;
 
1226
 
 
1227
protected:
 
1228
  Create_func_sqrt() {}
 
1229
  virtual ~Create_func_sqrt() {}
 
1230
};
 
1231
 
 
1232
 
921
1233
class Create_func_strcmp : public Create_func_arg2
922
1234
{
923
1235
public:
1215
1527
  return create(session, param_1, param_2, param_3);
1216
1528
}
1217
1529
 
 
1530
 
 
1531
Create_func_abs Create_func_abs::s_singleton;
 
1532
 
 
1533
Item*
 
1534
Create_func_abs::create(Session *session, Item *arg1)
 
1535
{
 
1536
  return new (session->mem_root) Item_func_abs(arg1);
 
1537
}
 
1538
 
 
1539
 
 
1540
Create_func_acos Create_func_acos::s_singleton;
 
1541
 
 
1542
Item*
 
1543
Create_func_acos::create(Session *session, Item *arg1)
 
1544
{
 
1545
  return new (session->mem_root) Item_func_acos(arg1);
 
1546
}
 
1547
 
 
1548
Create_func_asin Create_func_asin::s_singleton;
 
1549
 
 
1550
Item*
 
1551
Create_func_asin::create(Session *session, Item *arg1)
 
1552
{
 
1553
  return new (session->mem_root) Item_func_asin(arg1);
 
1554
}
 
1555
 
 
1556
 
 
1557
Create_func_atan Create_func_atan::s_singleton;
 
1558
 
 
1559
Item*
 
1560
Create_func_atan::create_native(Session *session, LEX_STRING name,
 
1561
                                List<Item> *item_list)
 
1562
{
 
1563
  Item* func= NULL;
 
1564
  int arg_count= 0;
 
1565
 
 
1566
  if (item_list != NULL)
 
1567
    arg_count= item_list->elements;
 
1568
 
 
1569
  switch (arg_count) {
 
1570
  case 1:
 
1571
  {
 
1572
    Item *param_1= item_list->pop();
 
1573
    func= new (session->mem_root) Item_func_atan(param_1);
 
1574
    break;
 
1575
  }
 
1576
  case 2:
 
1577
  {
 
1578
    Item *param_1= item_list->pop();
 
1579
    Item *param_2= item_list->pop();
 
1580
    func= new (session->mem_root) Item_func_atan(param_1, param_2);
 
1581
    break;
 
1582
  }
 
1583
  default:
 
1584
  {
 
1585
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
 
1586
    break;
 
1587
  }
 
1588
  }
 
1589
 
 
1590
  return func;
 
1591
}
 
1592
 
1218
1593
Create_func_bin Create_func_bin::s_singleton;
1219
1594
 
1220
1595
Item*
1225
1600
  return new (session->mem_root) Item_func_conv(arg1, i10, i2);
1226
1601
}
1227
1602
 
 
1603
 
 
1604
Create_func_ceiling Create_func_ceiling::s_singleton;
 
1605
 
 
1606
Item*
 
1607
Create_func_ceiling::create(Session *session, Item *arg1)
 
1608
{
 
1609
  return new (session->mem_root) Item_func_ceiling(arg1);
 
1610
}
 
1611
 
 
1612
 
 
1613
Create_func_coercibility Create_func_coercibility::s_singleton;
 
1614
 
 
1615
Item*
 
1616
Create_func_coercibility::create(Session *session, Item *arg1)
 
1617
{
 
1618
  return new (session->mem_root) Item_func_coercibility(arg1);
 
1619
}
 
1620
 
 
1621
 
1228
1622
Create_func_concat Create_func_concat::s_singleton;
1229
1623
 
1230
1624
Item*
1276
1670
  return new (session->mem_root) Item_func_conv(arg1, arg2, arg3);
1277
1671
}
1278
1672
 
 
1673
 
 
1674
Create_func_cos Create_func_cos::s_singleton;
 
1675
 
 
1676
Item*
 
1677
Create_func_cos::create(Session *session, Item *arg1)
 
1678
{
 
1679
  return new (session->mem_root) Item_func_cos(arg1);
 
1680
}
 
1681
 
 
1682
 
1279
1683
Create_func_cot Create_func_cot::s_singleton;
1280
1684
 
1281
1685
Item*
1352
1756
                                             180/M_PI, 0.0);
1353
1757
}
1354
1758
 
 
1759
 
 
1760
Create_func_elt Create_func_elt::s_singleton;
 
1761
 
 
1762
Item*
 
1763
Create_func_elt::create_native(Session *session, LEX_STRING name,
 
1764
                               List<Item> *item_list)
 
1765
{
 
1766
  int arg_count= 0;
 
1767
 
 
1768
  if (item_list != NULL)
 
1769
    arg_count= item_list->elements;
 
1770
 
 
1771
  if (arg_count < 2)
 
1772
  {
 
1773
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
 
1774
    return NULL;
 
1775
  }
 
1776
 
 
1777
  return new (session->mem_root) Item_func_elt(*item_list);
 
1778
}
 
1779
 
 
1780
 
 
1781
Create_func_exp Create_func_exp::s_singleton;
 
1782
 
 
1783
Item*
 
1784
Create_func_exp::create(Session *session, Item *arg1)
 
1785
{
 
1786
  return new (session->mem_root) Item_func_exp(arg1);
 
1787
}
 
1788
 
 
1789
 
1355
1790
Create_func_export_set Create_func_export_set::s_singleton;
1356
1791
 
1357
1792
Item*
1434
1869
  return new (session->mem_root) Item_func_find_in_set(arg1, arg2);
1435
1870
}
1436
1871
 
 
1872
 
 
1873
Create_func_floor Create_func_floor::s_singleton;
 
1874
 
 
1875
Item*
 
1876
Create_func_floor::create(Session *session, Item *arg1)
 
1877
{
 
1878
  return new (session->mem_root) Item_func_floor(arg1);
 
1879
}
 
1880
 
 
1881
 
 
1882
Create_func_format Create_func_format::s_singleton;
 
1883
 
 
1884
Item*
 
1885
Create_func_format::create(Session *session, Item *arg1, Item *arg2)
 
1886
{
 
1887
  return new (session->mem_root) Item_func_format(arg1, arg2);
 
1888
}
 
1889
 
 
1890
 
1437
1891
Create_func_found_rows Create_func_found_rows::s_singleton;
1438
1892
 
1439
1893
Item*
1610
2064
  return new (session->mem_root) Item_func_min(*item_list);
1611
2065
}
1612
2066
 
 
2067
 
 
2068
Create_func_ln Create_func_ln::s_singleton;
 
2069
 
 
2070
Item*
 
2071
Create_func_ln::create(Session *session, Item *arg1)
 
2072
{
 
2073
  return new (session->mem_root) Item_func_ln(arg1);
 
2074
}
 
2075
 
 
2076
 
1613
2077
Create_func_load_file Create_func_load_file::s_singleton;
1614
2078
 
1615
2079
Item*
1659
2123
  return func;
1660
2124
}
1661
2125
 
 
2126
 
 
2127
Create_func_log Create_func_log::s_singleton;
 
2128
 
 
2129
Item*
 
2130
Create_func_log::create_native(Session *session, LEX_STRING name,
 
2131
                               List<Item> *item_list)
 
2132
{
 
2133
  Item *func= NULL;
 
2134
  int arg_count= 0;
 
2135
 
 
2136
  if (item_list != NULL)
 
2137
    arg_count= item_list->elements;
 
2138
 
 
2139
  switch (arg_count) {
 
2140
  case 1:
 
2141
  {
 
2142
    Item *param_1= item_list->pop();
 
2143
    func= new (session->mem_root) Item_func_log(param_1);
 
2144
    break;
 
2145
  }
 
2146
  case 2:
 
2147
  {
 
2148
    Item *param_1= item_list->pop();
 
2149
    Item *param_2= item_list->pop();
 
2150
    func= new (session->mem_root) Item_func_log(param_1, param_2);
 
2151
    break;
 
2152
  }
 
2153
  default:
 
2154
  {
 
2155
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
 
2156
    break;
 
2157
  }
 
2158
  }
 
2159
 
 
2160
  return func;
 
2161
}
 
2162
 
 
2163
 
 
2164
Create_func_log10 Create_func_log10::s_singleton;
 
2165
 
 
2166
Item*
 
2167
Create_func_log10::create(Session *session, Item *arg1)
 
2168
{
 
2169
  return new (session->mem_root) Item_func_log10(arg1);
 
2170
}
 
2171
 
 
2172
 
 
2173
Create_func_log2 Create_func_log2::s_singleton;
 
2174
 
 
2175
Item*
 
2176
Create_func_log2::create(Session *session, Item *arg1)
 
2177
{
 
2178
  return new (session->mem_root) Item_func_log2(arg1);
 
2179
}
 
2180
 
 
2181
 
1662
2182
Create_func_lpad Create_func_lpad::s_singleton;
1663
2183
 
1664
2184
Item*
1736
2256
  return new (session->mem_root) Item_func_conv(arg1, i10, i8);
1737
2257
}
1738
2258
 
 
2259
 
 
2260
Create_func_ord Create_func_ord::s_singleton;
 
2261
 
 
2262
Item*
 
2263
Create_func_ord::create(Session *session, Item *arg1)
 
2264
{
 
2265
  return new (session->mem_root) Item_func_ord(arg1);
 
2266
}
 
2267
 
 
2268
 
1739
2269
Create_func_period_add Create_func_period_add::s_singleton;
1740
2270
 
1741
2271
Item*
1762
2292
  return new (session->mem_root) Item_static_float_func("pi()", M_PI, 6, 8);
1763
2293
}
1764
2294
 
 
2295
 
 
2296
Create_func_pow Create_func_pow::s_singleton;
 
2297
 
 
2298
Item*
 
2299
Create_func_pow::create(Session *session, Item *arg1, Item *arg2)
 
2300
{
 
2301
  return new (session->mem_root) Item_func_pow(arg1, arg2);
 
2302
}
 
2303
 
 
2304
 
 
2305
Create_func_quote Create_func_quote::s_singleton;
 
2306
 
 
2307
Item*
 
2308
Create_func_quote::create(Session *session, Item *arg1)
 
2309
{
 
2310
  return new (session->mem_root) Item_func_quote(arg1);
 
2311
}
 
2312
 
 
2313
 
1765
2314
Create_func_radians Create_func_radians::s_singleton;
1766
2315
 
1767
2316
Item*
1844
2393
  return new (session->mem_root) Item_func_sign(arg1);
1845
2394
}
1846
2395
 
 
2396
 
 
2397
Create_func_sin Create_func_sin::s_singleton;
 
2398
 
 
2399
Item*
 
2400
Create_func_sin::create(Session *session, Item *arg1)
 
2401
{
 
2402
  return new (session->mem_root) Item_func_sin(arg1);
 
2403
}
 
2404
 
 
2405
 
1847
2406
Create_func_space Create_func_space::s_singleton;
1848
2407
 
1849
2408
Item*
1859
2418
 
1860
2419
  if (cs->mbminlen > 1)
1861
2420
  {
1862
 
    size_t dummy_errors;
 
2421
    uint32_t dummy_errors;
1863
2422
    sp= new (session->mem_root) Item_string("", 0, cs, DERIVATION_COERCIBLE);
1864
2423
    sp->str_value.copy(" ", 1, &my_charset_utf8_general_ci, cs, &dummy_errors);
1865
2424
  }
1871
2430
  return new (session->mem_root) Item_func_repeat(*session, sp, arg1);
1872
2431
}
1873
2432
 
 
2433
 
 
2434
Create_func_sqrt Create_func_sqrt::s_singleton;
 
2435
 
 
2436
Item*
 
2437
Create_func_sqrt::create(Session *session, Item *arg1)
 
2438
{
 
2439
  return new (session->mem_root) Item_func_sqrt(arg1);
 
2440
}
 
2441
 
 
2442
 
1874
2443
Create_func_strcmp Create_func_strcmp::s_singleton;
1875
2444
 
1876
2445
Item*
1974
2543
 
1975
2544
static Native_func_registry func_array[] =
1976
2545
{
 
2546
  { { C_STRING_WITH_LEN("ABS") }, BUILDER(Create_func_abs)},
 
2547
  { { C_STRING_WITH_LEN("ACOS") }, BUILDER(Create_func_acos)},
 
2548
  { { C_STRING_WITH_LEN("ASIN") }, BUILDER(Create_func_asin)},
 
2549
  { { C_STRING_WITH_LEN("ATAN") }, BUILDER(Create_func_atan)},
 
2550
  { { C_STRING_WITH_LEN("ATAN2") }, BUILDER(Create_func_atan)},
1977
2551
  { { C_STRING_WITH_LEN("BIN") }, BUILDER(Create_func_bin)},
 
2552
  { { C_STRING_WITH_LEN("CEIL") }, BUILDER(Create_func_ceiling)},
 
2553
  { { C_STRING_WITH_LEN("CEILING") }, BUILDER(Create_func_ceiling)},
 
2554
  { { C_STRING_WITH_LEN("COERCIBILITY") }, BUILDER(Create_func_coercibility)},
1978
2555
  { { C_STRING_WITH_LEN("CONCAT") }, BUILDER(Create_func_concat)},
1979
2556
  { { C_STRING_WITH_LEN("CONCAT_WS") }, BUILDER(Create_func_concat_ws)},
1980
2557
  { { C_STRING_WITH_LEN("CONV") }, BUILDER(Create_func_conv)},
 
2558
  { { C_STRING_WITH_LEN("COS") }, BUILDER(Create_func_cos)},
1981
2559
  { { C_STRING_WITH_LEN("COT") }, BUILDER(Create_func_cot)},
1982
2560
  { { C_STRING_WITH_LEN("DATEDIFF") }, BUILDER(Create_func_datediff)},
1983
2561
  { { C_STRING_WITH_LEN("DATE_FORMAT") }, BUILDER(Create_func_date_format)},
1986
2564
  { { C_STRING_WITH_LEN("DAYOFWEEK") }, BUILDER(Create_func_dayofweek)},
1987
2565
  { { C_STRING_WITH_LEN("DAYOFYEAR") }, BUILDER(Create_func_dayofyear)},
1988
2566
  { { C_STRING_WITH_LEN("DEGREES") }, BUILDER(Create_func_degrees)},
 
2567
  { { C_STRING_WITH_LEN("ELT") }, BUILDER(Create_func_elt)},
 
2568
  { { C_STRING_WITH_LEN("EXP") }, BUILDER(Create_func_exp)},
1989
2569
  { { C_STRING_WITH_LEN("EXPORT_SET") }, BUILDER(Create_func_export_set)},
1990
2570
  { { C_STRING_WITH_LEN("FIELD") }, BUILDER(Create_func_field)},
1991
2571
  { { C_STRING_WITH_LEN("FIND_IN_SET") }, BUILDER(Create_func_find_in_set)},
 
2572
  { { C_STRING_WITH_LEN("FLOOR") }, BUILDER(Create_func_floor)},
 
2573
  { { C_STRING_WITH_LEN("FORMAT") }, BUILDER(Create_func_format)},
1992
2574
  { { C_STRING_WITH_LEN("FOUND_ROWS") }, BUILDER(Create_func_found_rows)},
1993
2575
  { { C_STRING_WITH_LEN("FROM_DAYS") }, BUILDER(Create_func_from_days)},
1994
2576
  { { C_STRING_WITH_LEN("FROM_UNIXTIME") }, BUILDER(Create_func_from_unixtime)},
2000
2582
  { { C_STRING_WITH_LEN("LAST_INSERT_ID") }, BUILDER(Create_func_last_insert_id)},
2001
2583
  { { C_STRING_WITH_LEN("LCASE") }, BUILDER(Create_func_lcase)},
2002
2584
  { { C_STRING_WITH_LEN("LEAST") }, BUILDER(Create_func_least)},
 
2585
  { { C_STRING_WITH_LEN("LN") }, BUILDER(Create_func_ln)},
2003
2586
  { { C_STRING_WITH_LEN("LOAD_FILE") }, BUILDER(Create_func_load_file)},
2004
2587
  { { C_STRING_WITH_LEN("LOCATE") }, BUILDER(Create_func_locate)},
 
2588
  { { C_STRING_WITH_LEN("LOG") }, BUILDER(Create_func_log)},
 
2589
  { { C_STRING_WITH_LEN("LOG10") }, BUILDER(Create_func_log10)},
 
2590
  { { C_STRING_WITH_LEN("LOG2") }, BUILDER(Create_func_log2)},
2005
2591
  { { C_STRING_WITH_LEN("LOWER") }, BUILDER(Create_func_lcase)},
2006
2592
  { { C_STRING_WITH_LEN("LPAD") }, BUILDER(Create_func_lpad)},
2007
2593
  { { C_STRING_WITH_LEN("LTRIM") }, BUILDER(Create_func_ltrim)},
2010
2596
  { { C_STRING_WITH_LEN("MONTHNAME") }, BUILDER(Create_func_monthname)},
2011
2597
  { { C_STRING_WITH_LEN("NULLIF") }, BUILDER(Create_func_nullif)},
2012
2598
  { { C_STRING_WITH_LEN("OCT") }, BUILDER(Create_func_oct)},
 
2599
  { { C_STRING_WITH_LEN("ORD") }, BUILDER(Create_func_ord)},
2013
2600
  { { C_STRING_WITH_LEN("PERIOD_ADD") }, BUILDER(Create_func_period_add)},
2014
2601
  { { C_STRING_WITH_LEN("PERIOD_DIFF") }, BUILDER(Create_func_period_diff)},
2015
2602
  { { C_STRING_WITH_LEN("PI") }, BUILDER(Create_func_pi)},
 
2603
  { { C_STRING_WITH_LEN("POW") }, BUILDER(Create_func_pow)},
 
2604
  { { C_STRING_WITH_LEN("POWER") }, BUILDER(Create_func_pow)},
 
2605
  { { C_STRING_WITH_LEN("QUOTE") }, BUILDER(Create_func_quote)},
2016
2606
  { { C_STRING_WITH_LEN("RADIANS") }, BUILDER(Create_func_radians)},
2017
2607
  { { C_STRING_WITH_LEN("ROUND") }, BUILDER(Create_func_round)},
2018
2608
  { { C_STRING_WITH_LEN("ROW_COUNT") }, BUILDER(Create_func_row_count)},
2019
2609
  { { C_STRING_WITH_LEN("RPAD") }, BUILDER(Create_func_rpad)},
2020
2610
  { { C_STRING_WITH_LEN("RTRIM") }, BUILDER(Create_func_rtrim)},
2021
2611
  { { C_STRING_WITH_LEN("SIGN") }, BUILDER(Create_func_sign)},
 
2612
  { { C_STRING_WITH_LEN("SIN") }, BUILDER(Create_func_sin)},
2022
2613
  { { C_STRING_WITH_LEN("SPACE") }, BUILDER(Create_func_space)},
 
2614
  { { C_STRING_WITH_LEN("SQRT") }, BUILDER(Create_func_sqrt)},
2023
2615
  { { C_STRING_WITH_LEN("STRCMP") }, BUILDER(Create_func_strcmp)},
2024
2616
  { { C_STRING_WITH_LEN("TAN") }, BUILDER(Create_func_tan)},
2025
2617
  { { C_STRING_WITH_LEN("TIME_FORMAT") }, BUILDER(Create_func_time_format)},
2032
2624
  { {0, 0}, NULL}
2033
2625
};
2034
2626
 
 
2627
static map<string, Native_func_registry *> native_functions_map;
 
2628
 
2035
2629
/*
2036
2630
  Load the hash table for native functions.
2037
2631
  Note: this code is not thread safe, and is intended to be used at server
2046
2640
  for (func= func_array; func->builder != NULL; func++)
2047
2641
  {
2048
2642
    func_name.assign(func->name.str, func->name.length);
 
2643
    transform(func_name.begin(), func_name.end(), func_name.begin(), ::tolower);
2049
2644
 
2050
 
    FunctionContainer::getMap()[func_name]= func->builder;
 
2645
    native_functions_map[func_name]= func;
2051
2646
  }
2052
2647
 
2053
2648
  return 0;
2057
2652
Create_func *
2058
2653
find_native_function_builder(LEX_STRING name)
2059
2654
{
 
2655
  Native_func_registry *func;
2060
2656
  Create_func *builder= NULL;
2061
2657
 
2062
2658
  string func_name(name.str, name.length);
2063
 
 
2064
 
  FunctionContainer::Map::iterator func_iter=
2065
 
    FunctionContainer::getMap().find(func_name);
2066
 
 
2067
 
  if (func_iter != FunctionContainer::getMap().end())
 
2659
  transform(func_name.begin(), func_name.end(), func_name.begin(), ::tolower);
 
2660
 
 
2661
  map<string, Native_func_registry *>::iterator func_iter=
 
2662
    native_functions_map.find(func_name);
 
2663
 
 
2664
  if (func_iter != native_functions_map.end())
2068
2665
  {
2069
 
    builder= (*func_iter).second;
 
2666
    func= (*func_iter).second;
 
2667
    builder= func->builder;
2070
2668
  }
2071
2669
 
2072
2670
  return builder;
2086
2684
                 const char *c_len, const char *c_dec,
2087
2685
                 const CHARSET_INFO * const cs)
2088
2686
{
2089
 
  Item *res= NULL;
 
2687
  Item *res;
2090
2688
  uint32_t len;
2091
2689
  uint32_t dec;
2092
2690
 
2093
2691
  switch (cast_type) {
2094
 
  case ITEM_CAST_SIGNED:
2095
 
    res= new (session->mem_root) function::cast::Signed(a);
2096
 
    break;
2097
 
 
2098
 
  case ITEM_CAST_UNSIGNED:
2099
 
    res= new (session->mem_root) function::cast::Unsigned(a);
2100
 
    break;
2101
 
 
2102
2692
  case ITEM_CAST_BINARY:
2103
2693
    res= new (session->mem_root) Item_func_binary(a);
2104
2694
    break;
2105
 
 
2106
 
  case ITEM_CAST_BOOLEAN:
2107
 
    res= new (session->mem_root) function::cast::Boolean(a);
2108
 
    break;
2109
 
 
2110
 
  case ITEM_CAST_TIME:
2111
 
    res= new (session->mem_root) function::cast::Time(a);
2112
 
    break;
2113
 
 
2114
2695
  case ITEM_CAST_DATE:
2115
2696
    res= new (session->mem_root) Item_date_typecast(a);
2116
2697
    break;
2117
 
 
2118
2698
  case ITEM_CAST_DATETIME:
2119
2699
    res= new (session->mem_root) Item_datetime_typecast(a);
2120
2700
    break;
2121
 
 
2122
2701
  case ITEM_CAST_DECIMAL:
2123
 
    {
2124
 
      len= c_len ? atoi(c_len) : 0;
2125
 
      dec= c_dec ? atoi(c_dec) : 0;
2126
 
      class_decimal_trim(&len, &dec);
2127
 
      if (len < dec)
2128
 
      {
2129
 
        my_error(ER_M_BIGGER_THAN_D, MYF(0), "");
2130
 
        return 0;
2131
 
      }
2132
 
      if (len > DECIMAL_MAX_PRECISION)
2133
 
      {
2134
 
        my_error(ER_TOO_BIG_PRECISION, MYF(0), len, a->name,
2135
 
                 DECIMAL_MAX_PRECISION);
2136
 
        return 0;
2137
 
      }
2138
 
      if (dec > DECIMAL_MAX_SCALE)
2139
 
      {
2140
 
        my_error(ER_TOO_BIG_SCALE, MYF(0), dec, a->name,
2141
 
                 DECIMAL_MAX_SCALE);
2142
 
        return 0;
2143
 
      }
2144
 
      res= new (session->mem_root) Item_decimal_typecast(a, len, dec);
2145
 
      break;
2146
 
    }
 
2702
  {
 
2703
    len= c_len ? atoi(c_len) : 0;
 
2704
    dec= c_dec ? atoi(c_dec) : 0;
 
2705
    my_decimal_trim(&len, &dec);
 
2706
    if (len < dec)
 
2707
    {
 
2708
      my_error(ER_M_BIGGER_THAN_D, MYF(0), "");
 
2709
      return 0;
 
2710
    }
 
2711
    if (len > DECIMAL_MAX_PRECISION)
 
2712
    {
 
2713
      my_error(ER_TOO_BIG_PRECISION, MYF(0), len, a->name,
 
2714
               DECIMAL_MAX_PRECISION);
 
2715
      return 0;
 
2716
    }
 
2717
    if (dec > DECIMAL_MAX_SCALE)
 
2718
    {
 
2719
      my_error(ER_TOO_BIG_SCALE, MYF(0), dec, a->name,
 
2720
               DECIMAL_MAX_SCALE);
 
2721
      return 0;
 
2722
    }
 
2723
    res= new (session->mem_root) Item_decimal_typecast(a, len, dec);
 
2724
    break;
 
2725
  }
2147
2726
  case ITEM_CAST_CHAR:
2148
 
    {
2149
 
      len= c_len ? atoi(c_len) : -1;
2150
 
      res= create_func_char_cast(session, a, len, cs);
2151
 
      break;
2152
 
    }
2153
 
  }
2154
 
 
 
2727
  {
 
2728
    len= c_len ? atoi(c_len) : -1;
 
2729
    res= create_func_char_cast(session, a, len, cs);
 
2730
    break;
 
2731
  }
 
2732
  default:
 
2733
  {
 
2734
    assert(0);
 
2735
    res= 0;
 
2736
    break;
 
2737
  }
 
2738
  }
2155
2739
  return res;
2156
2740
}
2157
2741