← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/create.cc

  • Committer: Brian Aker
  • Date: 2010-08-03 19:24:14 UTC
  • mto: This revision was merged to the branch mainline in revision 1683.
  • Revision ID: brian@gaz-20100803192414-jk20j0u6cnze3ja6
Do comparison via non-case.

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
 
 
102
#include <map>
 
103
 
86
104
using namespace std;
87
105
 
88
106
namespace drizzled
240
258
  it helps to compare code between versions, and helps with merges conflicts.
241
259
*/
242
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
};
243
316
 
244
317
class Create_func_bin : public Create_func_arg1
245
318
{
255
328
  virtual ~Create_func_bin() {}
256
329
};
257
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
 
258
362
class Create_func_concat : public Create_native_func
259
363
{
260
364
public:
295
399
  virtual ~Create_func_conv() {}
296
400
};
297
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
 
298
418
class Create_func_cot : public Create_func_arg1
299
419
{
300
420
public:
428
548
  virtual ~Create_func_degrees() {}
429
549
};
430
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
 
431
580
class Create_func_export_set : public Create_native_func
432
581
{
433
 
 
434
582
public:
435
583
  virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
436
584
 
469
617
  virtual ~Create_func_find_in_set() {}
470
618
};
471
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
 
472
651
class Create_func_found_rows : public Create_func_arg0
473
652
{
474
653
public:
625
804
  virtual ~Create_func_least() {}
626
805
};
627
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
 
628
823
class Create_func_load_file : public Create_func_arg1
629
824
{
630
825
public:
653
848
};
654
849
 
655
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
 
656
894
class Create_func_lpad : public Create_func_arg3
657
895
{
658
896
public:
769
1007
  virtual ~Create_func_oct() {}
770
1008
};
771
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
 
772
1026
class Create_func_period_add : public Create_func_arg2
773
1027
{
774
1028
public:
813
1067
  virtual ~Create_func_pi() {}
814
1068
};
815
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
 
816
1101
class Create_func_radians : public Create_func_arg1
817
1102
{
818
1103
public:
899
1184
  virtual ~Create_func_sign() {}
900
1185
};
901
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
 
902
1203
class Create_func_space : public Create_func_arg1
903
1204
{
904
1205
public:
913
1214
  virtual ~Create_func_space() {}
914
1215
};
915
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
 
916
1233
class Create_func_strcmp : public Create_func_arg2
917
1234
{
918
1235
public:
1210
1527
  return create(session, param_1, param_2, param_3);
1211
1528
}
1212
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
 
1213
1593
Create_func_bin Create_func_bin::s_singleton;
1214
1594
 
1215
1595
Item*
1220
1600
  return new (session->mem_root) Item_func_conv(arg1, i10, i2);
1221
1601
}
1222
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
 
1223
1622
Create_func_concat Create_func_concat::s_singleton;
1224
1623
 
1225
1624
Item*
1271
1670
  return new (session->mem_root) Item_func_conv(arg1, arg2, arg3);
1272
1671
}
1273
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
 
1274
1683
Create_func_cot Create_func_cot::s_singleton;
1275
1684
 
1276
1685
Item*
1347
1756
                                             180/M_PI, 0.0);
1348
1757
}
1349
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
 
1350
1790
Create_func_export_set Create_func_export_set::s_singleton;
1351
1791
 
1352
1792
Item*
1429
1869
  return new (session->mem_root) Item_func_find_in_set(arg1, arg2);
1430
1870
}
1431
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
 
1432
1891
Create_func_found_rows Create_func_found_rows::s_singleton;
1433
1892
 
1434
1893
Item*
1605
2064
  return new (session->mem_root) Item_func_min(*item_list);
1606
2065
}
1607
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
 
1608
2077
Create_func_load_file Create_func_load_file::s_singleton;
1609
2078
 
1610
2079
Item*
1654
2123
  return func;
1655
2124
}
1656
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
 
1657
2182
Create_func_lpad Create_func_lpad::s_singleton;
1658
2183
 
1659
2184
Item*
1731
2256
  return new (session->mem_root) Item_func_conv(arg1, i10, i8);
1732
2257
}
1733
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
 
1734
2269
Create_func_period_add Create_func_period_add::s_singleton;
1735
2270
 
1736
2271
Item*
1757
2292
  return new (session->mem_root) Item_static_float_func("pi()", M_PI, 6, 8);
1758
2293
}
1759
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
 
1760
2314
Create_func_radians Create_func_radians::s_singleton;
1761
2315
 
1762
2316
Item*
1839
2393
  return new (session->mem_root) Item_func_sign(arg1);
1840
2394
}
1841
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
 
1842
2406
Create_func_space Create_func_space::s_singleton;
1843
2407
 
1844
2408
Item*
1854
2418
 
1855
2419
  if (cs->mbminlen > 1)
1856
2420
  {
1857
 
    size_t dummy_errors;
 
2421
    uint32_t dummy_errors;
1858
2422
    sp= new (session->mem_root) Item_string("", 0, cs, DERIVATION_COERCIBLE);
1859
2423
    sp->str_value.copy(" ", 1, &my_charset_utf8_general_ci, cs, &dummy_errors);
1860
2424
  }
1866
2430
  return new (session->mem_root) Item_func_repeat(*session, sp, arg1);
1867
2431
}
1868
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
 
1869
2443
Create_func_strcmp Create_func_strcmp::s_singleton;
1870
2444
 
1871
2445
Item*
1969
2543
 
1970
2544
static Native_func_registry func_array[] =
1971
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)},
1972
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)},
1973
2555
  { { C_STRING_WITH_LEN("CONCAT") }, BUILDER(Create_func_concat)},
1974
2556
  { { C_STRING_WITH_LEN("CONCAT_WS") }, BUILDER(Create_func_concat_ws)},
1975
2557
  { { C_STRING_WITH_LEN("CONV") }, BUILDER(Create_func_conv)},
 
2558
  { { C_STRING_WITH_LEN("COS") }, BUILDER(Create_func_cos)},
1976
2559
  { { C_STRING_WITH_LEN("COT") }, BUILDER(Create_func_cot)},
1977
2560
  { { C_STRING_WITH_LEN("DATEDIFF") }, BUILDER(Create_func_datediff)},
1978
2561
  { { C_STRING_WITH_LEN("DATE_FORMAT") }, BUILDER(Create_func_date_format)},
1981
2564
  { { C_STRING_WITH_LEN("DAYOFWEEK") }, BUILDER(Create_func_dayofweek)},
1982
2565
  { { C_STRING_WITH_LEN("DAYOFYEAR") }, BUILDER(Create_func_dayofyear)},
1983
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)},
1984
2569
  { { C_STRING_WITH_LEN("EXPORT_SET") }, BUILDER(Create_func_export_set)},
1985
2570
  { { C_STRING_WITH_LEN("FIELD") }, BUILDER(Create_func_field)},
1986
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)},
1987
2574
  { { C_STRING_WITH_LEN("FOUND_ROWS") }, BUILDER(Create_func_found_rows)},
1988
2575
  { { C_STRING_WITH_LEN("FROM_DAYS") }, BUILDER(Create_func_from_days)},
1989
2576
  { { C_STRING_WITH_LEN("FROM_UNIXTIME") }, BUILDER(Create_func_from_unixtime)},
1995
2582
  { { C_STRING_WITH_LEN("LAST_INSERT_ID") }, BUILDER(Create_func_last_insert_id)},
1996
2583
  { { C_STRING_WITH_LEN("LCASE") }, BUILDER(Create_func_lcase)},
1997
2584
  { { C_STRING_WITH_LEN("LEAST") }, BUILDER(Create_func_least)},
 
2585
  { { C_STRING_WITH_LEN("LN") }, BUILDER(Create_func_ln)},
1998
2586
  { { C_STRING_WITH_LEN("LOAD_FILE") }, BUILDER(Create_func_load_file)},
1999
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)},
2000
2591
  { { C_STRING_WITH_LEN("LOWER") }, BUILDER(Create_func_lcase)},
2001
2592
  { { C_STRING_WITH_LEN("LPAD") }, BUILDER(Create_func_lpad)},
2002
2593
  { { C_STRING_WITH_LEN("LTRIM") }, BUILDER(Create_func_ltrim)},
2005
2596
  { { C_STRING_WITH_LEN("MONTHNAME") }, BUILDER(Create_func_monthname)},
2006
2597
  { { C_STRING_WITH_LEN("NULLIF") }, BUILDER(Create_func_nullif)},
2007
2598
  { { C_STRING_WITH_LEN("OCT") }, BUILDER(Create_func_oct)},
 
2599
  { { C_STRING_WITH_LEN("ORD") }, BUILDER(Create_func_ord)},
2008
2600
  { { C_STRING_WITH_LEN("PERIOD_ADD") }, BUILDER(Create_func_period_add)},
2009
2601
  { { C_STRING_WITH_LEN("PERIOD_DIFF") }, BUILDER(Create_func_period_diff)},
2010
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)},
2011
2606
  { { C_STRING_WITH_LEN("RADIANS") }, BUILDER(Create_func_radians)},
2012
2607
  { { C_STRING_WITH_LEN("ROUND") }, BUILDER(Create_func_round)},
2013
2608
  { { C_STRING_WITH_LEN("ROW_COUNT") }, BUILDER(Create_func_row_count)},
2014
2609
  { { C_STRING_WITH_LEN("RPAD") }, BUILDER(Create_func_rpad)},
2015
2610
  { { C_STRING_WITH_LEN("RTRIM") }, BUILDER(Create_func_rtrim)},
2016
2611
  { { C_STRING_WITH_LEN("SIGN") }, BUILDER(Create_func_sign)},
 
2612
  { { C_STRING_WITH_LEN("SIN") }, BUILDER(Create_func_sin)},
2017
2613
  { { C_STRING_WITH_LEN("SPACE") }, BUILDER(Create_func_space)},
 
2614
  { { C_STRING_WITH_LEN("SQRT") }, BUILDER(Create_func_sqrt)},
2018
2615
  { { C_STRING_WITH_LEN("STRCMP") }, BUILDER(Create_func_strcmp)},
2019
2616
  { { C_STRING_WITH_LEN("TAN") }, BUILDER(Create_func_tan)},
2020
2617
  { { C_STRING_WITH_LEN("TIME_FORMAT") }, BUILDER(Create_func_time_format)},
2027
2624
  { {0, 0}, NULL}
2028
2625
};
2029
2626
 
 
2627
static map<string, Native_func_registry *> native_functions_map;
 
2628
 
2030
2629
/*
2031
2630
  Load the hash table for native functions.
2032
2631
  Note: this code is not thread safe, and is intended to be used at server
2041
2640
  for (func= func_array; func->builder != NULL; func++)
2042
2641
  {
2043
2642
    func_name.assign(func->name.str, func->name.length);
 
2643
    transform(func_name.begin(), func_name.end(), func_name.begin(), ::tolower);
2044
2644
 
2045
 
    FunctionContainer::getMap()[func_name]= func;
 
2645
    native_functions_map[func_name]= func;
2046
2646
  }
2047
2647
 
2048
2648
  return 0;
2056
2656
  Create_func *builder= NULL;
2057
2657
 
2058
2658
  string func_name(name.str, name.length);
2059
 
 
2060
 
  NativeFunctionsMap::iterator func_iter=
2061
 
    FunctionContainer::getMap().find(func_name);
2062
 
 
2063
 
  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())
2064
2665
  {
2065
2666
    func= (*func_iter).second;
2066
2667
    builder= func->builder;