← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/create.cc

  • Committer: Jay Pipes
  • Date: 2009-11-16 22:00:02 UTC
  • mto: (1234.1.1 push) (1237.2.10 push)
  • mto: This revision was merged to the branch mainline in revision 1229.
  • Revision ID: jpipes@serialcoder-20091116220002-rdsha64utt41i8w8
Adds INFORMATION_SCHEMA views for the transaction log:

TRANSACTION_LOG
TRANSACTION_LOG_ENTRIES
TRANSACTION_LOG_TRANSACTIONS

Adds a new user-defined function:

PRINT_TRANSACTION_MESSAGE(filename, offset)

Adds tests for all of the above

Implementation notes:

An indexer now runs when transaction messages are applied
to the transaction log.  It creates a simple index of the
transaction log entries.  This index is used when the
information schema views' fillTable() method is called.

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 */