← 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: 2009-10-15 00:22:33 UTC
  • mto: (1183.1.11 merge)
  • mto: This revision was merged to the branch mainline in revision 1198.
  • Revision ID: brian@gaz-20091015002233-fa4ao2mbc67wls91
First pass of information engine. OMG, ponies... is it so much easier to
deal with creating and engine.

The list table iterator though... its ass, needs to go. We should also
abstract out share. Very few engines need a custom one. Just say'in

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
20
20
  Functions to create an item. Used by sql_yac.yy
21
21
*/
22
22
 
23
 
#include "config.h"
 
23
#include <drizzled/server_includes.h>
24
24
#include <drizzled/item/create.h>
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
#include <drizzled/function/str/hex.h>
34
35
#include <drizzled/function/str/load_file.h>
35
36
#include <drizzled/function/str/make_set.h>
36
37
#include <drizzled/function/str/pad.h>
37
38
#include <drizzled/function/str/repeat.h>
38
39
#include <drizzled/function/str/str_conv.h>
 
40
#include <drizzled/function/str/substr.h>
39
41
#include <drizzled/function/str/trim.h>
 
42
#include <drizzled/function/str/uuid.h>
40
43
 
41
44
#include <drizzled/function/time/date_format.h>
42
45
#include <drizzled/function/time/dayname.h>
61
64
/* Function declarations */
62
65
 
63
66
#include <drizzled/function/func.h>
 
67
#include <drizzled/function/math/abs.h>
 
68
#include <drizzled/function/math/acos.h>
64
69
#include <drizzled/function/additive_op.h>
 
70
#include <drizzled/function/math/asin.h>
 
71
#include <drizzled/function/math/atan.h>
 
72
#include <drizzled/function/math/ceiling.h>
 
73
#include <drizzled/function/coercibility.h>
 
74
#include <drizzled/function/math/cos.h>
65
75
#include <drizzled/function/math/dec.h>
66
76
#include <drizzled/function/math/decimal_typecast.h>
 
77
#include <drizzled/function/math//exp.h>
67
78
#include <drizzled/function/field.h>
68
79
#include <drizzled/function/find_in_set.h>
 
80
#include <drizzled/function/math/floor.h>
69
81
#include <drizzled/function/found_rows.h>
70
82
#include <drizzled/function/get_system_var.h>
71
83
#include <drizzled/function/math/int_val.h>
72
84
#include <drizzled/function/math/integer.h>
73
85
#include <drizzled/function/last_insert.h>
 
86
#include <drizzled/function/math/ln.h>
74
87
#include <drizzled/function/locate.h>
 
88
#include <drizzled/function/math/log.h>
75
89
#include <drizzled/function/min_max.h>
76
90
#include <drizzled/function/num1.h>
77
91
#include <drizzled/function/num_op.h>
78
92
#include <drizzled/function/numhybrid.h>
 
93
#include <drizzled/function/math/ord.h>
 
94
#include <drizzled/function/math/pow.h>
 
95
#include <drizzled/function/math/rand.h>
79
96
#include <drizzled/function/math/real.h>
80
97
#include <drizzled/function/row_count.h>
81
98
#include <drizzled/function/set_user_var.h>
82
99
#include <drizzled/function/sign.h>
 
100
#include <drizzled/function/signed.h>
 
101
#include <drizzled/function/math/sin.h>
 
102
#include <drizzled/function/math/sqrt.h>
 
103
#include <drizzled/function/str/quote.h>
83
104
#include <drizzled/function/math/tan.h>
84
105
#include <drizzled/function/units.h>
 
106
#include <drizzled/function/unsigned.h>
 
107
 
 
108
#include <map>
85
109
 
86
110
using namespace std;
87
 
 
88
 
namespace drizzled
89
 
{
 
111
using namespace drizzled;
90
112
 
91
113
class Item;
92
114
 
240
262
  it helps to compare code between versions, and helps with merges conflicts.
241
263
*/
242
264
 
 
265
class Create_func_abs : public Create_func_arg1
 
266
{
 
267
public:
 
268
  using Create_func_arg1::create;
 
269
 
 
270
  virtual Item *create(Session *session, Item *arg1);
 
271
 
 
272
  static Create_func_abs s_singleton;
 
273
 
 
274
protected:
 
275
  Create_func_abs() {}
 
276
  virtual ~Create_func_abs() {}
 
277
};
 
278
 
 
279
 
 
280
class Create_func_acos : public Create_func_arg1
 
281
{
 
282
public:
 
283
  using Create_func_arg1::create;
 
284
 
 
285
  virtual Item *create(Session *session, Item *arg1);
 
286
 
 
287
  static Create_func_acos s_singleton;
 
288
 
 
289
protected:
 
290
  Create_func_acos() {}
 
291
  virtual ~Create_func_acos() {}
 
292
};
 
293
 
 
294
class Create_func_asin : public Create_func_arg1
 
295
{
 
296
public:
 
297
  using Create_func_arg1::create;
 
298
 
 
299
  virtual Item *create(Session *session, Item *arg1);
 
300
 
 
301
  static Create_func_asin s_singleton;
 
302
 
 
303
protected:
 
304
  Create_func_asin() {}
 
305
  virtual ~Create_func_asin() {}
 
306
};
 
307
 
 
308
 
 
309
class Create_func_atan : public Create_native_func
 
310
{
 
311
public:
 
312
  virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
 
313
 
 
314
  static Create_func_atan s_singleton;
 
315
 
 
316
protected:
 
317
  Create_func_atan() {}
 
318
  virtual ~Create_func_atan() {}
 
319
};
243
320
 
244
321
class Create_func_bin : public Create_func_arg1
245
322
{
255
332
  virtual ~Create_func_bin() {}
256
333
};
257
334
 
 
335
 
 
336
class Create_func_ceiling : public Create_func_arg1
 
337
{
 
338
public:
 
339
  using Create_func_arg1::create;
 
340
 
 
341
  virtual Item *create(Session *session, Item *arg1);
 
342
 
 
343
  static Create_func_ceiling s_singleton;
 
344
 
 
345
protected:
 
346
  Create_func_ceiling() {}
 
347
  virtual ~Create_func_ceiling() {}
 
348
};
 
349
 
 
350
 
 
351
class Create_func_coercibility : public Create_func_arg1
 
352
{
 
353
public:
 
354
  using Create_func_arg1::create;
 
355
 
 
356
  virtual Item *create(Session *session, Item *arg1);
 
357
 
 
358
  static Create_func_coercibility s_singleton;
 
359
 
 
360
protected:
 
361
  Create_func_coercibility() {}
 
362
  virtual ~Create_func_coercibility() {}
 
363
};
 
364
 
 
365
 
258
366
class Create_func_concat : public Create_native_func
259
367
{
260
368
public:
295
403
  virtual ~Create_func_conv() {}
296
404
};
297
405
 
 
406
 
 
407
class Create_func_cos : public Create_func_arg1
 
408
{
 
409
public:
 
410
  using Create_func_arg1::create;
 
411
 
 
412
  virtual Item *create(Session *session, Item *arg1);
 
413
 
 
414
  static Create_func_cos s_singleton;
 
415
 
 
416
protected:
 
417
  Create_func_cos() {}
 
418
  virtual ~Create_func_cos() {}
 
419
};
 
420
 
 
421
 
298
422
class Create_func_cot : public Create_func_arg1
299
423
{
300
424
public:
428
552
  virtual ~Create_func_degrees() {}
429
553
};
430
554
 
 
555
 
 
556
class Create_func_elt : public Create_native_func
 
557
{
 
558
public:
 
559
  virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
 
560
 
 
561
  static Create_func_elt s_singleton;
 
562
 
 
563
protected:
 
564
  Create_func_elt() {}
 
565
  virtual ~Create_func_elt() {}
 
566
};
 
567
 
 
568
 
 
569
class Create_func_exp : public Create_func_arg1
 
570
{
 
571
public:
 
572
  using Create_func_arg1::create;
 
573
 
 
574
  virtual Item *create(Session *session, Item *arg1);
 
575
 
 
576
  static Create_func_exp s_singleton;
 
577
 
 
578
protected:
 
579
  Create_func_exp() {}
 
580
  virtual ~Create_func_exp() {}
 
581
};
 
582
 
 
583
 
431
584
class Create_func_export_set : public Create_native_func
432
585
{
433
 
 
434
586
public:
435
587
  virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
436
588
 
469
621
  virtual ~Create_func_find_in_set() {}
470
622
};
471
623
 
 
624
 
 
625
class Create_func_floor : public Create_func_arg1
 
626
{
 
627
public:
 
628
  using Create_func_arg1::create;
 
629
 
 
630
  virtual Item *create(Session *session, Item *arg1);
 
631
 
 
632
  static Create_func_floor s_singleton;
 
633
 
 
634
protected:
 
635
  Create_func_floor() {}
 
636
  virtual ~Create_func_floor() {}
 
637
};
 
638
 
 
639
 
 
640
class Create_func_format : public Create_func_arg2
 
641
{
 
642
public:
 
643
  using Create_func_arg2::create;
 
644
 
 
645
  virtual Item *create(Session *session, Item *arg1, Item *arg2);
 
646
 
 
647
  static Create_func_format s_singleton;
 
648
 
 
649
protected:
 
650
  Create_func_format() {}
 
651
  virtual ~Create_func_format() {}
 
652
};
 
653
 
 
654
 
472
655
class Create_func_found_rows : public Create_func_arg0
473
656
{
474
657
public:
525
708
};
526
709
 
527
710
 
 
711
class Create_func_hex : public Create_func_arg1
 
712
{
 
713
public:
 
714
  using Create_func_arg1::create;
 
715
 
 
716
  virtual Item *create(Session *session, Item *arg1);
 
717
 
 
718
  static Create_func_hex s_singleton;
 
719
 
 
720
protected:
 
721
  Create_func_hex() {}
 
722
  virtual ~Create_func_hex() {}
 
723
};
 
724
 
 
725
 
528
726
class Create_func_ifnull : public Create_func_arg2
529
727
{
530
728
public:
625
823
  virtual ~Create_func_least() {}
626
824
};
627
825
 
 
826
 
 
827
class Create_func_ln : public Create_func_arg1
 
828
{
 
829
public:
 
830
  using Create_func_arg1::create;
 
831
 
 
832
  virtual Item *create(Session *session, Item *arg1);
 
833
 
 
834
  static Create_func_ln s_singleton;
 
835
 
 
836
protected:
 
837
  Create_func_ln() {}
 
838
  virtual ~Create_func_ln() {}
 
839
};
 
840
 
 
841
 
628
842
class Create_func_load_file : public Create_func_arg1
629
843
{
630
844
public:
653
867
};
654
868
 
655
869
 
 
870
class Create_func_log : public Create_native_func
 
871
{
 
872
public:
 
873
  virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
 
874
 
 
875
  static Create_func_log s_singleton;
 
876
 
 
877
protected:
 
878
  Create_func_log() {}
 
879
  virtual ~Create_func_log() {}
 
880
};
 
881
 
 
882
 
 
883
class Create_func_log10 : public Create_func_arg1
 
884
{
 
885
public:
 
886
  using Create_func_arg1::create;
 
887
 
 
888
  virtual Item *create(Session *session, Item *arg1);
 
889
 
 
890
  static Create_func_log10 s_singleton;
 
891
 
 
892
protected:
 
893
  Create_func_log10() {}
 
894
  virtual ~Create_func_log10() {}
 
895
};
 
896
 
 
897
 
 
898
class Create_func_log2 : public Create_func_arg1
 
899
{
 
900
public:
 
901
  using Create_func_arg1::create;
 
902
 
 
903
  virtual Item *create(Session *session, Item *arg1);
 
904
 
 
905
  static Create_func_log2 s_singleton;
 
906
 
 
907
protected:
 
908
  Create_func_log2() {}
 
909
  virtual ~Create_func_log2() {}
 
910
};
 
911
 
 
912
 
656
913
class Create_func_lpad : public Create_func_arg3
657
914
{
658
915
public:
769
1026
  virtual ~Create_func_oct() {}
770
1027
};
771
1028
 
 
1029
 
 
1030
class Create_func_ord : public Create_func_arg1
 
1031
{
 
1032
public:
 
1033
  using Create_func_arg1::create;
 
1034
 
 
1035
  virtual Item *create(Session *session, Item *arg1);
 
1036
 
 
1037
  static Create_func_ord s_singleton;
 
1038
 
 
1039
protected:
 
1040
  Create_func_ord() {}
 
1041
  virtual ~Create_func_ord() {}
 
1042
};
 
1043
 
 
1044
 
772
1045
class Create_func_period_add : public Create_func_arg2
773
1046
{
774
1047
public:
813
1086
  virtual ~Create_func_pi() {}
814
1087
};
815
1088
 
 
1089
 
 
1090
class Create_func_pow : public Create_func_arg2
 
1091
{
 
1092
public:
 
1093
  using Create_func_arg2::create;
 
1094
 
 
1095
  virtual Item *create(Session *session, Item *arg1, Item *arg2);
 
1096
 
 
1097
  static Create_func_pow s_singleton;
 
1098
 
 
1099
protected:
 
1100
  Create_func_pow() {}
 
1101
  virtual ~Create_func_pow() {}
 
1102
};
 
1103
 
 
1104
 
 
1105
class Create_func_quote : public Create_func_arg1
 
1106
{
 
1107
public:
 
1108
  using Create_func_arg1::create;
 
1109
 
 
1110
  virtual Item *create(Session *session, Item *arg1);
 
1111
 
 
1112
  static Create_func_quote s_singleton;
 
1113
 
 
1114
protected:
 
1115
  Create_func_quote() {}
 
1116
  virtual ~Create_func_quote() {}
 
1117
};
 
1118
 
 
1119
 
816
1120
class Create_func_radians : public Create_func_arg1
817
1121
{
818
1122
public:
828
1132
};
829
1133
 
830
1134
 
 
1135
class Create_func_rand : public Create_native_func
 
1136
{
 
1137
public:
 
1138
  virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
 
1139
 
 
1140
  static Create_func_rand s_singleton;
 
1141
 
 
1142
protected:
 
1143
  Create_func_rand() {}
 
1144
  virtual ~Create_func_rand() {}
 
1145
};
 
1146
 
 
1147
 
831
1148
class Create_func_round : public Create_native_func
832
1149
{
833
1150
public:
899
1216
  virtual ~Create_func_sign() {}
900
1217
};
901
1218
 
 
1219
 
 
1220
class Create_func_sin : public Create_func_arg1
 
1221
{
 
1222
public:
 
1223
  using Create_func_arg1::create;
 
1224
 
 
1225
  virtual Item *create(Session *session, Item *arg1);
 
1226
 
 
1227
  static Create_func_sin s_singleton;
 
1228
 
 
1229
protected:
 
1230
  Create_func_sin() {}
 
1231
  virtual ~Create_func_sin() {}
 
1232
};
 
1233
 
 
1234
 
902
1235
class Create_func_space : public Create_func_arg1
903
1236
{
904
1237
public:
913
1246
  virtual ~Create_func_space() {}
914
1247
};
915
1248
 
 
1249
 
 
1250
class Create_func_sqrt : public Create_func_arg1
 
1251
{
 
1252
public:
 
1253
  using Create_func_arg1::create;
 
1254
 
 
1255
  virtual Item *create(Session *session, Item *arg1);
 
1256
 
 
1257
  static Create_func_sqrt s_singleton;
 
1258
 
 
1259
protected:
 
1260
  Create_func_sqrt() {}
 
1261
  virtual ~Create_func_sqrt() {}
 
1262
};
 
1263
 
 
1264
 
916
1265
class Create_func_strcmp : public Create_func_arg2
917
1266
{
918
1267
public:
928
1277
};
929
1278
 
930
1279
 
 
1280
class Create_func_substr_index : public Create_func_arg3
 
1281
{
 
1282
public:
 
1283
  using Create_func_arg3::create;
 
1284
 
 
1285
  virtual Item *create(Session *session, Item *arg1, Item *arg2, Item *arg3);
 
1286
 
 
1287
  static Create_func_substr_index s_singleton;
 
1288
 
 
1289
protected:
 
1290
  Create_func_substr_index() {}
 
1291
  virtual ~Create_func_substr_index() {}
 
1292
};
 
1293
 
 
1294
 
931
1295
class Create_func_tan : public Create_func_arg1
932
1296
{
933
1297
public:
1003
1367
};
1004
1368
 
1005
1369
 
 
1370
class Create_func_unhex : public Create_func_arg1
 
1371
{
 
1372
public:
 
1373
  using Create_func_arg1::create;
 
1374
 
 
1375
  virtual Item *create(Session *session, Item *arg1);
 
1376
 
 
1377
  static Create_func_unhex s_singleton;
 
1378
 
 
1379
protected:
 
1380
  Create_func_unhex() {}
 
1381
  virtual ~Create_func_unhex() {}
 
1382
};
 
1383
 
 
1384
 
1006
1385
class Create_func_unix_timestamp : public Create_native_func
1007
1386
{
1008
1387
public:
1016
1395
};
1017
1396
 
1018
1397
 
 
1398
class Create_func_uuid : public Create_func_arg0
 
1399
{
 
1400
public:
 
1401
  using Create_func_arg0::create;
 
1402
 
 
1403
  virtual Item *create(Session *session);
 
1404
 
 
1405
  static Create_func_uuid s_singleton;
 
1406
 
 
1407
protected:
 
1408
  Create_func_uuid() {}
 
1409
  virtual ~Create_func_uuid() {}
 
1410
};
 
1411
 
 
1412
 
1019
1413
class Create_func_weekday : public Create_func_arg1
1020
1414
{
1021
1415
public:
1210
1604
  return create(session, param_1, param_2, param_3);
1211
1605
}
1212
1606
 
 
1607
 
 
1608
Create_func_abs Create_func_abs::s_singleton;
 
1609
 
 
1610
Item*
 
1611
Create_func_abs::create(Session *session, Item *arg1)
 
1612
{
 
1613
  return new (session->mem_root) Item_func_abs(arg1);
 
1614
}
 
1615
 
 
1616
 
 
1617
Create_func_acos Create_func_acos::s_singleton;
 
1618
 
 
1619
Item*
 
1620
Create_func_acos::create(Session *session, Item *arg1)
 
1621
{
 
1622
  return new (session->mem_root) Item_func_acos(arg1);
 
1623
}
 
1624
 
 
1625
Create_func_asin Create_func_asin::s_singleton;
 
1626
 
 
1627
Item*
 
1628
Create_func_asin::create(Session *session, Item *arg1)
 
1629
{
 
1630
  return new (session->mem_root) Item_func_asin(arg1);
 
1631
}
 
1632
 
 
1633
 
 
1634
Create_func_atan Create_func_atan::s_singleton;
 
1635
 
 
1636
Item*
 
1637
Create_func_atan::create_native(Session *session, LEX_STRING name,
 
1638
                                List<Item> *item_list)
 
1639
{
 
1640
  Item* func= NULL;
 
1641
  int arg_count= 0;
 
1642
 
 
1643
  if (item_list != NULL)
 
1644
    arg_count= item_list->elements;
 
1645
 
 
1646
  switch (arg_count) {
 
1647
  case 1:
 
1648
  {
 
1649
    Item *param_1= item_list->pop();
 
1650
    func= new (session->mem_root) Item_func_atan(param_1);
 
1651
    break;
 
1652
  }
 
1653
  case 2:
 
1654
  {
 
1655
    Item *param_1= item_list->pop();
 
1656
    Item *param_2= item_list->pop();
 
1657
    func= new (session->mem_root) Item_func_atan(param_1, param_2);
 
1658
    break;
 
1659
  }
 
1660
  default:
 
1661
  {
 
1662
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
 
1663
    break;
 
1664
  }
 
1665
  }
 
1666
 
 
1667
  return func;
 
1668
}
 
1669
 
1213
1670
Create_func_bin Create_func_bin::s_singleton;
1214
1671
 
1215
1672
Item*
1220
1677
  return new (session->mem_root) Item_func_conv(arg1, i10, i2);
1221
1678
}
1222
1679
 
 
1680
 
 
1681
Create_func_ceiling Create_func_ceiling::s_singleton;
 
1682
 
 
1683
Item*
 
1684
Create_func_ceiling::create(Session *session, Item *arg1)
 
1685
{
 
1686
  return new (session->mem_root) Item_func_ceiling(arg1);
 
1687
}
 
1688
 
 
1689
 
 
1690
Create_func_coercibility Create_func_coercibility::s_singleton;
 
1691
 
 
1692
Item*
 
1693
Create_func_coercibility::create(Session *session, Item *arg1)
 
1694
{
 
1695
  return new (session->mem_root) Item_func_coercibility(arg1);
 
1696
}
 
1697
 
 
1698
 
1223
1699
Create_func_concat Create_func_concat::s_singleton;
1224
1700
 
1225
1701
Item*
1237
1713
    return NULL;
1238
1714
  }
1239
1715
 
1240
 
  return new (session->mem_root) Item_func_concat(*session, *item_list);
 
1716
  return new (session->mem_root) Item_func_concat(*item_list);
1241
1717
}
1242
1718
 
1243
1719
 
1259
1735
    return NULL;
1260
1736
  }
1261
1737
 
1262
 
  return new (session->mem_root) Item_func_concat_ws(*session, *item_list);
 
1738
  return new (session->mem_root) Item_func_concat_ws(*item_list);
1263
1739
}
1264
1740
 
1265
1741
 
1271
1747
  return new (session->mem_root) Item_func_conv(arg1, arg2, arg3);
1272
1748
}
1273
1749
 
 
1750
 
 
1751
Create_func_cos Create_func_cos::s_singleton;
 
1752
 
 
1753
Item*
 
1754
Create_func_cos::create(Session *session, Item *arg1)
 
1755
{
 
1756
  return new (session->mem_root) Item_func_cos(arg1);
 
1757
}
 
1758
 
 
1759
 
1274
1760
Create_func_cot Create_func_cot::s_singleton;
1275
1761
 
1276
1762
Item*
1278
1764
{
1279
1765
  Item *i1= new (session->mem_root) Item_int((char*) "1", 1, 1);
1280
1766
  Item *i2= new (session->mem_root) Item_func_tan(arg1);
1281
 
  return new (session->mem_root) Item_func_div(session, i1, i2);
 
1767
  return new (session->mem_root) Item_func_div(i1, i2);
1282
1768
}
1283
1769
 
1284
1770
Create_func_date_format Create_func_date_format::s_singleton;
1347
1833
                                             180/M_PI, 0.0);
1348
1834
}
1349
1835
 
 
1836
 
 
1837
Create_func_elt Create_func_elt::s_singleton;
 
1838
 
 
1839
Item*
 
1840
Create_func_elt::create_native(Session *session, LEX_STRING name,
 
1841
                               List<Item> *item_list)
 
1842
{
 
1843
  int arg_count= 0;
 
1844
 
 
1845
  if (item_list != NULL)
 
1846
    arg_count= item_list->elements;
 
1847
 
 
1848
  if (arg_count < 2)
 
1849
  {
 
1850
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
 
1851
    return NULL;
 
1852
  }
 
1853
 
 
1854
  return new (session->mem_root) Item_func_elt(*item_list);
 
1855
}
 
1856
 
 
1857
 
 
1858
Create_func_exp Create_func_exp::s_singleton;
 
1859
 
 
1860
Item*
 
1861
Create_func_exp::create(Session *session, Item *arg1)
 
1862
{
 
1863
  return new (session->mem_root) Item_func_exp(arg1);
 
1864
}
 
1865
 
 
1866
 
1350
1867
Create_func_export_set Create_func_export_set::s_singleton;
1351
1868
 
1352
1869
Item*
1429
1946
  return new (session->mem_root) Item_func_find_in_set(arg1, arg2);
1430
1947
}
1431
1948
 
 
1949
 
 
1950
Create_func_floor Create_func_floor::s_singleton;
 
1951
 
 
1952
Item*
 
1953
Create_func_floor::create(Session *session, Item *arg1)
 
1954
{
 
1955
  return new (session->mem_root) Item_func_floor(arg1);
 
1956
}
 
1957
 
 
1958
 
 
1959
Create_func_format Create_func_format::s_singleton;
 
1960
 
 
1961
Item*
 
1962
Create_func_format::create(Session *session, Item *arg1, Item *arg2)
 
1963
{
 
1964
  return new (session->mem_root) Item_func_format(arg1, arg2);
 
1965
}
 
1966
 
 
1967
 
1432
1968
Create_func_found_rows Create_func_found_rows::s_singleton;
1433
1969
 
1434
1970
Item*
1505
2041
  return new (session->mem_root) Item_func_max(*item_list);
1506
2042
}
1507
2043
 
 
2044
 
 
2045
Create_func_hex Create_func_hex::s_singleton;
 
2046
 
 
2047
Item*
 
2048
Create_func_hex::create(Session *session, Item *arg1)
 
2049
{
 
2050
  return new (session->mem_root) Item_func_hex(arg1);
 
2051
}
 
2052
 
 
2053
 
1508
2054
Create_func_ifnull Create_func_ifnull::s_singleton;
1509
2055
 
1510
2056
Item*
1605
2151
  return new (session->mem_root) Item_func_min(*item_list);
1606
2152
}
1607
2153
 
 
2154
 
 
2155
Create_func_ln Create_func_ln::s_singleton;
 
2156
 
 
2157
Item*
 
2158
Create_func_ln::create(Session *session, Item *arg1)
 
2159
{
 
2160
  return new (session->mem_root) Item_func_ln(arg1);
 
2161
}
 
2162
 
 
2163
 
1608
2164
Create_func_load_file Create_func_load_file::s_singleton;
1609
2165
 
1610
2166
Item*
1611
2167
Create_func_load_file::create(Session *session, Item *arg1)
1612
2168
{
1613
 
  return new (session->mem_root) Item_load_file(*session, arg1);
 
2169
  return new (session->mem_root) Item_load_file(arg1);
1614
2170
}
1615
2171
 
1616
2172
 
1654
2210
  return func;
1655
2211
}
1656
2212
 
 
2213
 
 
2214
Create_func_log Create_func_log::s_singleton;
 
2215
 
 
2216
Item*
 
2217
Create_func_log::create_native(Session *session, LEX_STRING name,
 
2218
                               List<Item> *item_list)
 
2219
{
 
2220
  Item *func= NULL;
 
2221
  int arg_count= 0;
 
2222
 
 
2223
  if (item_list != NULL)
 
2224
    arg_count= item_list->elements;
 
2225
 
 
2226
  switch (arg_count) {
 
2227
  case 1:
 
2228
  {
 
2229
    Item *param_1= item_list->pop();
 
2230
    func= new (session->mem_root) Item_func_log(param_1);
 
2231
    break;
 
2232
  }
 
2233
  case 2:
 
2234
  {
 
2235
    Item *param_1= item_list->pop();
 
2236
    Item *param_2= item_list->pop();
 
2237
    func= new (session->mem_root) Item_func_log(param_1, param_2);
 
2238
    break;
 
2239
  }
 
2240
  default:
 
2241
  {
 
2242
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
 
2243
    break;
 
2244
  }
 
2245
  }
 
2246
 
 
2247
  return func;
 
2248
}
 
2249
 
 
2250
 
 
2251
Create_func_log10 Create_func_log10::s_singleton;
 
2252
 
 
2253
Item*
 
2254
Create_func_log10::create(Session *session, Item *arg1)
 
2255
{
 
2256
  return new (session->mem_root) Item_func_log10(arg1);
 
2257
}
 
2258
 
 
2259
 
 
2260
Create_func_log2 Create_func_log2::s_singleton;
 
2261
 
 
2262
Item*
 
2263
Create_func_log2::create(Session *session, Item *arg1)
 
2264
{
 
2265
  return new (session->mem_root) Item_func_log2(arg1);
 
2266
}
 
2267
 
 
2268
 
1657
2269
Create_func_lpad Create_func_lpad::s_singleton;
1658
2270
 
1659
2271
Item*
1660
2272
Create_func_lpad::create(Session *session, Item *arg1, Item *arg2, Item *arg3)
1661
2273
{
1662
 
  return new (session->mem_root) Item_func_lpad(*session, arg1, arg2, arg3);
 
2274
  return new (session->mem_root) Item_func_lpad(arg1, arg2, arg3);
1663
2275
}
1664
2276
 
1665
2277
 
1684
2296
Create_func_make_set Create_func_make_set::s_singleton;
1685
2297
 
1686
2298
Item*
1687
 
Create_func_make_set::create_native(Session *session_arg, LEX_STRING name,
 
2299
Create_func_make_set::create_native(Session *session, LEX_STRING name,
1688
2300
                                    List<Item> *item_list)
1689
2301
{
1690
2302
  int arg_count= 0;
1699
2311
  }
1700
2312
 
1701
2313
  Item *param_1= item_list->pop();
1702
 
  return new (session_arg->mem_root) Item_func_make_set(*session_arg, param_1, *item_list);
 
2314
  return new (session->mem_root) Item_func_make_set(param_1, *item_list);
1703
2315
}
1704
2316
 
1705
2317
 
1731
2343
  return new (session->mem_root) Item_func_conv(arg1, i10, i8);
1732
2344
}
1733
2345
 
 
2346
 
 
2347
Create_func_ord Create_func_ord::s_singleton;
 
2348
 
 
2349
Item*
 
2350
Create_func_ord::create(Session *session, Item *arg1)
 
2351
{
 
2352
  return new (session->mem_root) Item_func_ord(arg1);
 
2353
}
 
2354
 
 
2355
 
1734
2356
Create_func_period_add Create_func_period_add::s_singleton;
1735
2357
 
1736
2358
Item*
1757
2379
  return new (session->mem_root) Item_static_float_func("pi()", M_PI, 6, 8);
1758
2380
}
1759
2381
 
 
2382
 
 
2383
Create_func_pow Create_func_pow::s_singleton;
 
2384
 
 
2385
Item*
 
2386
Create_func_pow::create(Session *session, Item *arg1, Item *arg2)
 
2387
{
 
2388
  return new (session->mem_root) Item_func_pow(arg1, arg2);
 
2389
}
 
2390
 
 
2391
 
 
2392
Create_func_quote Create_func_quote::s_singleton;
 
2393
 
 
2394
Item*
 
2395
Create_func_quote::create(Session *session, Item *arg1)
 
2396
{
 
2397
  return new (session->mem_root) Item_func_quote(arg1);
 
2398
}
 
2399
 
 
2400
 
1760
2401
Create_func_radians Create_func_radians::s_singleton;
1761
2402
 
1762
2403
Item*
1766
2407
                                             M_PI/180, 0.0);
1767
2408
}
1768
2409
 
 
2410
 
 
2411
Create_func_rand Create_func_rand::s_singleton;
 
2412
 
 
2413
Item*
 
2414
Create_func_rand::create_native(Session *session, LEX_STRING name,
 
2415
                                List<Item> *item_list)
 
2416
{
 
2417
  Item *func= NULL;
 
2418
  int arg_count= 0;
 
2419
 
 
2420
  if (item_list != NULL)
 
2421
    arg_count= item_list->elements;
 
2422
 
 
2423
  switch (arg_count) {
 
2424
  case 0:
 
2425
  {
 
2426
    func= new (session->mem_root) Item_func_rand();
 
2427
    break;
 
2428
  }
 
2429
  case 1:
 
2430
  {
 
2431
    Item *param_1= item_list->pop();
 
2432
    func= new (session->mem_root) Item_func_rand(param_1);
 
2433
    break;
 
2434
  }
 
2435
  default:
 
2436
  {
 
2437
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
 
2438
    break;
 
2439
  }
 
2440
  }
 
2441
 
 
2442
  return func;
 
2443
}
 
2444
 
 
2445
 
1769
2446
Create_func_round Create_func_round::s_singleton;
1770
2447
 
1771
2448
Item*
1818
2495
Item*
1819
2496
Create_func_rpad::create(Session *session, Item *arg1, Item *arg2, Item *arg3)
1820
2497
{
1821
 
  return new (session->mem_root) Item_func_rpad(*session, arg1, arg2, arg3);
 
2498
  return new (session->mem_root) Item_func_rpad(arg1, arg2, arg3);
1822
2499
}
1823
2500
 
1824
2501
 
1839
2516
  return new (session->mem_root) Item_func_sign(arg1);
1840
2517
}
1841
2518
 
 
2519
 
 
2520
Create_func_sin Create_func_sin::s_singleton;
 
2521
 
 
2522
Item*
 
2523
Create_func_sin::create(Session *session, Item *arg1)
 
2524
{
 
2525
  return new (session->mem_root) Item_func_sin(arg1);
 
2526
}
 
2527
 
 
2528
 
1842
2529
Create_func_space Create_func_space::s_singleton;
1843
2530
 
1844
2531
Item*
1854
2541
 
1855
2542
  if (cs->mbminlen > 1)
1856
2543
  {
1857
 
    size_t dummy_errors;
 
2544
    uint32_t dummy_errors;
1858
2545
    sp= new (session->mem_root) Item_string("", 0, cs, DERIVATION_COERCIBLE);
1859
2546
    sp->str_value.copy(" ", 1, &my_charset_utf8_general_ci, cs, &dummy_errors);
1860
2547
  }
1863
2550
    sp= new (session->mem_root) Item_string(" ", 1, cs, DERIVATION_COERCIBLE);
1864
2551
  }
1865
2552
 
1866
 
  return new (session->mem_root) Item_func_repeat(*session, sp, arg1);
1867
 
}
 
2553
  return new (session->mem_root) Item_func_repeat(sp, arg1);
 
2554
}
 
2555
 
 
2556
 
 
2557
Create_func_sqrt Create_func_sqrt::s_singleton;
 
2558
 
 
2559
Item*
 
2560
Create_func_sqrt::create(Session *session, Item *arg1)
 
2561
{
 
2562
  return new (session->mem_root) Item_func_sqrt(arg1);
 
2563
}
 
2564
 
1868
2565
 
1869
2566
Create_func_strcmp Create_func_strcmp::s_singleton;
1870
2567
 
1875
2572
}
1876
2573
 
1877
2574
 
 
2575
Create_func_substr_index Create_func_substr_index::s_singleton;
 
2576
 
 
2577
Item*
 
2578
Create_func_substr_index::create(Session *session, Item *arg1, Item *arg2, Item *arg3)
 
2579
{
 
2580
  return new (session->mem_root) Item_func_substr_index(arg1, arg2, arg3);
 
2581
}
 
2582
 
1878
2583
Create_func_tan Create_func_tan::s_singleton;
1879
2584
 
1880
2585
Item*
1909
2614
  return new (session->mem_root) Item_func_ucase(arg1);
1910
2615
}
1911
2616
 
 
2617
 
 
2618
Create_func_unhex Create_func_unhex::s_singleton;
 
2619
 
 
2620
Item*
 
2621
Create_func_unhex::create(Session *session, Item *arg1)
 
2622
{
 
2623
  return new (session->mem_root) Item_func_unhex(arg1);
 
2624
}
 
2625
 
 
2626
 
1912
2627
Create_func_unix_timestamp Create_func_unix_timestamp::s_singleton;
1913
2628
 
1914
2629
Item*
1944
2659
}
1945
2660
 
1946
2661
 
 
2662
Create_func_uuid Create_func_uuid::s_singleton;
 
2663
 
 
2664
Item*
 
2665
Create_func_uuid::create(Session *session)
 
2666
{
 
2667
  return new (session->mem_root) Item_func_uuid();
 
2668
}
 
2669
 
 
2670
 
1947
2671
Create_func_weekday Create_func_weekday::s_singleton;
1948
2672
 
1949
2673
Item*
1969
2693
 
1970
2694
static Native_func_registry func_array[] =
1971
2695
{
 
2696
  { { C_STRING_WITH_LEN("ABS") }, BUILDER(Create_func_abs)},
 
2697
  { { C_STRING_WITH_LEN("ACOS") }, BUILDER(Create_func_acos)},
 
2698
  { { C_STRING_WITH_LEN("ASIN") }, BUILDER(Create_func_asin)},
 
2699
  { { C_STRING_WITH_LEN("ATAN") }, BUILDER(Create_func_atan)},
 
2700
  { { C_STRING_WITH_LEN("ATAN2") }, BUILDER(Create_func_atan)},
1972
2701
  { { C_STRING_WITH_LEN("BIN") }, BUILDER(Create_func_bin)},
 
2702
  { { C_STRING_WITH_LEN("CEIL") }, BUILDER(Create_func_ceiling)},
 
2703
  { { C_STRING_WITH_LEN("CEILING") }, BUILDER(Create_func_ceiling)},
 
2704
  { { C_STRING_WITH_LEN("COERCIBILITY") }, BUILDER(Create_func_coercibility)},
1973
2705
  { { C_STRING_WITH_LEN("CONCAT") }, BUILDER(Create_func_concat)},
1974
2706
  { { C_STRING_WITH_LEN("CONCAT_WS") }, BUILDER(Create_func_concat_ws)},
1975
2707
  { { C_STRING_WITH_LEN("CONV") }, BUILDER(Create_func_conv)},
 
2708
  { { C_STRING_WITH_LEN("COS") }, BUILDER(Create_func_cos)},
1976
2709
  { { C_STRING_WITH_LEN("COT") }, BUILDER(Create_func_cot)},
1977
2710
  { { C_STRING_WITH_LEN("DATEDIFF") }, BUILDER(Create_func_datediff)},
1978
2711
  { { C_STRING_WITH_LEN("DATE_FORMAT") }, BUILDER(Create_func_date_format)},
1981
2714
  { { C_STRING_WITH_LEN("DAYOFWEEK") }, BUILDER(Create_func_dayofweek)},
1982
2715
  { { C_STRING_WITH_LEN("DAYOFYEAR") }, BUILDER(Create_func_dayofyear)},
1983
2716
  { { C_STRING_WITH_LEN("DEGREES") }, BUILDER(Create_func_degrees)},
 
2717
  { { C_STRING_WITH_LEN("ELT") }, BUILDER(Create_func_elt)},
 
2718
  { { C_STRING_WITH_LEN("EXP") }, BUILDER(Create_func_exp)},
1984
2719
  { { C_STRING_WITH_LEN("EXPORT_SET") }, BUILDER(Create_func_export_set)},
1985
2720
  { { C_STRING_WITH_LEN("FIELD") }, BUILDER(Create_func_field)},
1986
2721
  { { C_STRING_WITH_LEN("FIND_IN_SET") }, BUILDER(Create_func_find_in_set)},
 
2722
  { { C_STRING_WITH_LEN("FLOOR") }, BUILDER(Create_func_floor)},
 
2723
  { { C_STRING_WITH_LEN("FORMAT") }, BUILDER(Create_func_format)},
1987
2724
  { { C_STRING_WITH_LEN("FOUND_ROWS") }, BUILDER(Create_func_found_rows)},
1988
2725
  { { C_STRING_WITH_LEN("FROM_DAYS") }, BUILDER(Create_func_from_days)},
1989
2726
  { { C_STRING_WITH_LEN("FROM_UNIXTIME") }, BUILDER(Create_func_from_unixtime)},
1990
2727
  { { C_STRING_WITH_LEN("GREATEST") }, BUILDER(Create_func_greatest)},
 
2728
  { { C_STRING_WITH_LEN("HEX") }, BUILDER(Create_func_hex)},
1991
2729
  { { C_STRING_WITH_LEN("IFNULL") }, BUILDER(Create_func_ifnull)},
1992
2730
  { { C_STRING_WITH_LEN("INSTR") }, BUILDER(Create_func_instr)},
1993
2731
  { { C_STRING_WITH_LEN("ISNULL") }, BUILDER(Create_func_isnull)},
1995
2733
  { { C_STRING_WITH_LEN("LAST_INSERT_ID") }, BUILDER(Create_func_last_insert_id)},
1996
2734
  { { C_STRING_WITH_LEN("LCASE") }, BUILDER(Create_func_lcase)},
1997
2735
  { { C_STRING_WITH_LEN("LEAST") }, BUILDER(Create_func_least)},
 
2736
  { { C_STRING_WITH_LEN("LN") }, BUILDER(Create_func_ln)},
1998
2737
  { { C_STRING_WITH_LEN("LOAD_FILE") }, BUILDER(Create_func_load_file)},
1999
2738
  { { C_STRING_WITH_LEN("LOCATE") }, BUILDER(Create_func_locate)},
 
2739
  { { C_STRING_WITH_LEN("LOG") }, BUILDER(Create_func_log)},
 
2740
  { { C_STRING_WITH_LEN("LOG10") }, BUILDER(Create_func_log10)},
 
2741
  { { C_STRING_WITH_LEN("LOG2") }, BUILDER(Create_func_log2)},
2000
2742
  { { C_STRING_WITH_LEN("LOWER") }, BUILDER(Create_func_lcase)},
2001
2743
  { { C_STRING_WITH_LEN("LPAD") }, BUILDER(Create_func_lpad)},
2002
2744
  { { C_STRING_WITH_LEN("LTRIM") }, BUILDER(Create_func_ltrim)},
2005
2747
  { { C_STRING_WITH_LEN("MONTHNAME") }, BUILDER(Create_func_monthname)},
2006
2748
  { { C_STRING_WITH_LEN("NULLIF") }, BUILDER(Create_func_nullif)},
2007
2749
  { { C_STRING_WITH_LEN("OCT") }, BUILDER(Create_func_oct)},
 
2750
  { { C_STRING_WITH_LEN("ORD") }, BUILDER(Create_func_ord)},
2008
2751
  { { C_STRING_WITH_LEN("PERIOD_ADD") }, BUILDER(Create_func_period_add)},
2009
2752
  { { C_STRING_WITH_LEN("PERIOD_DIFF") }, BUILDER(Create_func_period_diff)},
2010
2753
  { { C_STRING_WITH_LEN("PI") }, BUILDER(Create_func_pi)},
 
2754
  { { C_STRING_WITH_LEN("POW") }, BUILDER(Create_func_pow)},
 
2755
  { { C_STRING_WITH_LEN("POWER") }, BUILDER(Create_func_pow)},
 
2756
  { { C_STRING_WITH_LEN("QUOTE") }, BUILDER(Create_func_quote)},
2011
2757
  { { C_STRING_WITH_LEN("RADIANS") }, BUILDER(Create_func_radians)},
 
2758
  { { C_STRING_WITH_LEN("RAND") }, BUILDER(Create_func_rand)},
2012
2759
  { { C_STRING_WITH_LEN("ROUND") }, BUILDER(Create_func_round)},
2013
2760
  { { C_STRING_WITH_LEN("ROW_COUNT") }, BUILDER(Create_func_row_count)},
2014
2761
  { { C_STRING_WITH_LEN("RPAD") }, BUILDER(Create_func_rpad)},
2015
2762
  { { C_STRING_WITH_LEN("RTRIM") }, BUILDER(Create_func_rtrim)},
2016
2763
  { { C_STRING_WITH_LEN("SIGN") }, BUILDER(Create_func_sign)},
 
2764
  { { C_STRING_WITH_LEN("SIN") }, BUILDER(Create_func_sin)},
2017
2765
  { { C_STRING_WITH_LEN("SPACE") }, BUILDER(Create_func_space)},
 
2766
  { { C_STRING_WITH_LEN("SQRT") }, BUILDER(Create_func_sqrt)},
2018
2767
  { { C_STRING_WITH_LEN("STRCMP") }, BUILDER(Create_func_strcmp)},
 
2768
  { { C_STRING_WITH_LEN("SUBSTRING_INDEX") }, BUILDER(Create_func_substr_index)},
2019
2769
  { { C_STRING_WITH_LEN("TAN") }, BUILDER(Create_func_tan)},
2020
2770
  { { C_STRING_WITH_LEN("TIME_FORMAT") }, BUILDER(Create_func_time_format)},
2021
2771
  { { C_STRING_WITH_LEN("TO_DAYS") }, BUILDER(Create_func_to_days)},
2022
2772
  { { C_STRING_WITH_LEN("UCASE") }, BUILDER(Create_func_ucase)},
 
2773
  { { C_STRING_WITH_LEN("UNHEX") }, BUILDER(Create_func_unhex)},
2023
2774
  { { C_STRING_WITH_LEN("UNIX_TIMESTAMP") }, BUILDER(Create_func_unix_timestamp)},
2024
2775
  { { C_STRING_WITH_LEN("UPPER") }, BUILDER(Create_func_ucase)},
 
2776
  { { C_STRING_WITH_LEN("UUID") }, BUILDER(Create_func_uuid)},
2025
2777
  { { C_STRING_WITH_LEN("WEEKDAY") }, BUILDER(Create_func_weekday)},
2026
2778
 
2027
2779
  { {0, 0}, NULL}
2028
2780
};
2029
2781
 
 
2782
static map<string, Native_func_registry *> native_functions_map;
 
2783
 
2030
2784
/*
2031
2785
  Load the hash table for native functions.
2032
2786
  Note: this code is not thread safe, and is intended to be used at server
2041
2795
  for (func= func_array; func->builder != NULL; func++)
2042
2796
  {
2043
2797
    func_name.assign(func->name.str, func->name.length);
 
2798
    transform(func_name.begin(), func_name.end(), func_name.begin(), ::tolower);
2044
2799
 
2045
 
    FunctionContainer::getMap()[func_name]= func;
 
2800
    native_functions_map[func_name]= func;
2046
2801
  }
2047
2802
 
2048
2803
  return 0;
2056
2811
  Create_func *builder= NULL;
2057
2812
 
2058
2813
  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())
 
2814
  transform(func_name.begin(), func_name.end(), func_name.begin(), ::tolower);
 
2815
 
 
2816
  map<string, Native_func_registry *>::iterator func_iter=
 
2817
    native_functions_map.find(func_name);
 
2818
 
 
2819
  if (func_iter != native_functions_map.end())
2064
2820
  {
2065
2821
    func= (*func_iter).second;
2066
2822
    builder= func->builder;
2091
2847
  case ITEM_CAST_BINARY:
2092
2848
    res= new (session->mem_root) Item_func_binary(a);
2093
2849
    break;
 
2850
  case ITEM_CAST_SIGNED_INT:
 
2851
    res= new (session->mem_root) Item_func_signed(a);
 
2852
    break;
 
2853
  case ITEM_CAST_UNSIGNED_INT:
 
2854
    res= new (session->mem_root) Item_func_unsigned(a);
 
2855
    break;
2094
2856
  case ITEM_CAST_DATE:
2095
2857
    res= new (session->mem_root) Item_date_typecast(a);
2096
2858
    break;
2137
2899
  }
2138
2900
  return res;
2139
2901
}
2140
 
 
2141
 
} /* namespace drizzled */