← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/create.cc

  • Committer: Stewart Smith
  • Date: 2010-11-03 03:27:09 UTC
  • mto: (1902.1.1 build) (1910.1.2 build)
  • mto: This revision was merged to the branch mainline in revision 1903.
  • Revision ID: stewart@flamingspork.com-20101103032709-oyvfrc6eb8fzj0mr
fix docs warning: docs/unlock.rst:2: (WARNING/2) Title underline too short.

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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
14
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  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
 
28
30
#include <drizzled/function/str/binary.h>
29
31
#include <drizzled/function/str/concat.h>
30
32
#include <drizzled/function/str/conv.h>
31
 
#include <drizzled/function/str/elt.h>
32
33
#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>
66
64
#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>
72
65
#include <drizzled/function/math/dec.h>
73
66
#include <drizzled/function/math/decimal_typecast.h>
74
 
#include <drizzled/function/math/exp.h>
75
67
#include <drizzled/function/field.h>
76
68
#include <drizzled/function/find_in_set.h>
77
 
#include <drizzled/function/math/floor.h>
78
69
#include <drizzled/function/found_rows.h>
79
70
#include <drizzled/function/get_system_var.h>
80
71
#include <drizzled/function/math/int_val.h>
81
72
#include <drizzled/function/math/integer.h>
82
73
#include <drizzled/function/last_insert.h>
83
 
#include <drizzled/function/math/ln.h>
84
74
#include <drizzled/function/locate.h>
85
 
#include <drizzled/function/math/log.h>
86
75
#include <drizzled/function/min_max.h>
87
76
#include <drizzled/function/num1.h>
88
77
#include <drizzled/function/num_op.h>
89
78
#include <drizzled/function/numhybrid.h>
90
 
#include <drizzled/function/math/ord.h>
91
 
#include <drizzled/function/math/pow.h>
92
 
#include <drizzled/function/math/rand.h>
93
79
#include <drizzled/function/math/real.h>
94
80
#include <drizzled/function/row_count.h>
95
81
#include <drizzled/function/set_user_var.h>
96
82
#include <drizzled/function/sign.h>
97
 
#include <drizzled/function/math/sin.h>
98
 
#include <drizzled/function/math/sqrt.h>
99
 
#include <drizzled/function/str/quote.h>
100
83
#include <drizzled/function/math/tan.h>
101
84
#include <drizzled/function/units.h>
102
85
 
103
 
#include <map>
104
 
 
105
86
using namespace std;
106
87
 
107
88
namespace drizzled
259
240
  it helps to compare code between versions, and helps with merges conflicts.
260
241
*/
261
242
 
262
 
class Create_func_abs : public Create_func_arg1
263
 
{
264
 
public:
265
 
  using Create_func_arg1::create;
266
 
 
267
 
  virtual Item *create(Session *session, Item *arg1);
268
 
 
269
 
  static Create_func_abs s_singleton;
270
 
 
271
 
protected:
272
 
  Create_func_abs() {}
273
 
  virtual ~Create_func_abs() {}
274
 
};
275
 
 
276
 
 
277
 
class Create_func_acos : public Create_func_arg1
278
 
{
279
 
public:
280
 
  using Create_func_arg1::create;
281
 
 
282
 
  virtual Item *create(Session *session, Item *arg1);
283
 
 
284
 
  static Create_func_acos s_singleton;
285
 
 
286
 
protected:
287
 
  Create_func_acos() {}
288
 
  virtual ~Create_func_acos() {}
289
 
};
290
 
 
291
 
class Create_func_asin : public Create_func_arg1
292
 
{
293
 
public:
294
 
  using Create_func_arg1::create;
295
 
 
296
 
  virtual Item *create(Session *session, Item *arg1);
297
 
 
298
 
  static Create_func_asin s_singleton;
299
 
 
300
 
protected:
301
 
  Create_func_asin() {}
302
 
  virtual ~Create_func_asin() {}
303
 
};
304
 
 
305
 
 
306
 
class Create_func_atan : public Create_native_func
307
 
{
308
 
public:
309
 
  virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
310
 
 
311
 
  static Create_func_atan s_singleton;
312
 
 
313
 
protected:
314
 
  Create_func_atan() {}
315
 
  virtual ~Create_func_atan() {}
316
 
};
317
243
 
318
244
class Create_func_bin : public Create_func_arg1
319
245
{
329
255
  virtual ~Create_func_bin() {}
330
256
};
331
257
 
332
 
 
333
 
class Create_func_ceiling : public Create_func_arg1
334
 
{
335
 
public:
336
 
  using Create_func_arg1::create;
337
 
 
338
 
  virtual Item *create(Session *session, Item *arg1);
339
 
 
340
 
  static Create_func_ceiling s_singleton;
341
 
 
342
 
protected:
343
 
  Create_func_ceiling() {}
344
 
  virtual ~Create_func_ceiling() {}
345
 
};
346
 
 
347
 
 
348
 
class Create_func_coercibility : public Create_func_arg1
349
 
{
350
 
public:
351
 
  using Create_func_arg1::create;
352
 
 
353
 
  virtual Item *create(Session *session, Item *arg1);
354
 
 
355
 
  static Create_func_coercibility s_singleton;
356
 
 
357
 
protected:
358
 
  Create_func_coercibility() {}
359
 
  virtual ~Create_func_coercibility() {}
360
 
};
361
 
 
362
 
 
363
258
class Create_func_concat : public Create_native_func
364
259
{
365
260
public:
400
295
  virtual ~Create_func_conv() {}
401
296
};
402
297
 
403
 
 
404
 
class Create_func_cos : public Create_func_arg1
405
 
{
406
 
public:
407
 
  using Create_func_arg1::create;
408
 
 
409
 
  virtual Item *create(Session *session, Item *arg1);
410
 
 
411
 
  static Create_func_cos s_singleton;
412
 
 
413
 
protected:
414
 
  Create_func_cos() {}
415
 
  virtual ~Create_func_cos() {}
416
 
};
417
 
 
418
 
 
419
298
class Create_func_cot : public Create_func_arg1
420
299
{
421
300
public:
549
428
  virtual ~Create_func_degrees() {}
550
429
};
551
430
 
552
 
 
553
 
class Create_func_elt : public Create_native_func
554
 
{
555
 
public:
556
 
  virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
557
 
 
558
 
  static Create_func_elt s_singleton;
559
 
 
560
 
protected:
561
 
  Create_func_elt() {}
562
 
  virtual ~Create_func_elt() {}
563
 
};
564
 
 
565
 
 
566
 
class Create_func_exp : public Create_func_arg1
567
 
{
568
 
public:
569
 
  using Create_func_arg1::create;
570
 
 
571
 
  virtual Item *create(Session *session, Item *arg1);
572
 
 
573
 
  static Create_func_exp s_singleton;
574
 
 
575
 
protected:
576
 
  Create_func_exp() {}
577
 
  virtual ~Create_func_exp() {}
578
 
};
579
 
 
580
 
 
581
431
class Create_func_export_set : public Create_native_func
582
432
{
 
433
 
583
434
public:
584
435
  virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
585
436
 
618
469
  virtual ~Create_func_find_in_set() {}
619
470
};
620
471
 
621
 
 
622
 
class Create_func_floor : public Create_func_arg1
623
 
{
624
 
public:
625
 
  using Create_func_arg1::create;
626
 
 
627
 
  virtual Item *create(Session *session, Item *arg1);
628
 
 
629
 
  static Create_func_floor s_singleton;
630
 
 
631
 
protected:
632
 
  Create_func_floor() {}
633
 
  virtual ~Create_func_floor() {}
634
 
};
635
 
 
636
 
 
637
 
class Create_func_format : public Create_func_arg2
638
 
{
639
 
public:
640
 
  using Create_func_arg2::create;
641
 
 
642
 
  virtual Item *create(Session *session, Item *arg1, Item *arg2);
643
 
 
644
 
  static Create_func_format s_singleton;
645
 
 
646
 
protected:
647
 
  Create_func_format() {}
648
 
  virtual ~Create_func_format() {}
649
 
};
650
 
 
651
 
 
652
472
class Create_func_found_rows : public Create_func_arg0
653
473
{
654
474
public:
805
625
  virtual ~Create_func_least() {}
806
626
};
807
627
 
808
 
 
809
 
class Create_func_ln : public Create_func_arg1
810
 
{
811
 
public:
812
 
  using Create_func_arg1::create;
813
 
 
814
 
  virtual Item *create(Session *session, Item *arg1);
815
 
 
816
 
  static Create_func_ln s_singleton;
817
 
 
818
 
protected:
819
 
  Create_func_ln() {}
820
 
  virtual ~Create_func_ln() {}
821
 
};
822
 
 
823
 
 
824
628
class Create_func_load_file : public Create_func_arg1
825
629
{
826
630
public:
849
653
};
850
654
 
851
655
 
852
 
class Create_func_log : public Create_native_func
853
 
{
854
 
public:
855
 
  virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
856
 
 
857
 
  static Create_func_log s_singleton;
858
 
 
859
 
protected:
860
 
  Create_func_log() {}
861
 
  virtual ~Create_func_log() {}
862
 
};
863
 
 
864
 
 
865
 
class Create_func_log10 : public Create_func_arg1
866
 
{
867
 
public:
868
 
  using Create_func_arg1::create;
869
 
 
870
 
  virtual Item *create(Session *session, Item *arg1);
871
 
 
872
 
  static Create_func_log10 s_singleton;
873
 
 
874
 
protected:
875
 
  Create_func_log10() {}
876
 
  virtual ~Create_func_log10() {}
877
 
};
878
 
 
879
 
 
880
 
class Create_func_log2 : public Create_func_arg1
881
 
{
882
 
public:
883
 
  using Create_func_arg1::create;
884
 
 
885
 
  virtual Item *create(Session *session, Item *arg1);
886
 
 
887
 
  static Create_func_log2 s_singleton;
888
 
 
889
 
protected:
890
 
  Create_func_log2() {}
891
 
  virtual ~Create_func_log2() {}
892
 
};
893
 
 
894
 
 
895
656
class Create_func_lpad : public Create_func_arg3
896
657
{
897
658
public:
1008
769
  virtual ~Create_func_oct() {}
1009
770
};
1010
771
 
1011
 
 
1012
 
class Create_func_ord : public Create_func_arg1
1013
 
{
1014
 
public:
1015
 
  using Create_func_arg1::create;
1016
 
 
1017
 
  virtual Item *create(Session *session, Item *arg1);
1018
 
 
1019
 
  static Create_func_ord s_singleton;
1020
 
 
1021
 
protected:
1022
 
  Create_func_ord() {}
1023
 
  virtual ~Create_func_ord() {}
1024
 
};
1025
 
 
1026
 
 
1027
772
class Create_func_period_add : public Create_func_arg2
1028
773
{
1029
774
public:
1068
813
  virtual ~Create_func_pi() {}
1069
814
};
1070
815
 
1071
 
 
1072
 
class Create_func_pow : public Create_func_arg2
1073
 
{
1074
 
public:
1075
 
  using Create_func_arg2::create;
1076
 
 
1077
 
  virtual Item *create(Session *session, Item *arg1, Item *arg2);
1078
 
 
1079
 
  static Create_func_pow s_singleton;
1080
 
 
1081
 
protected:
1082
 
  Create_func_pow() {}
1083
 
  virtual ~Create_func_pow() {}
1084
 
};
1085
 
 
1086
 
 
1087
 
class Create_func_quote : public Create_func_arg1
1088
 
{
1089
 
public:
1090
 
  using Create_func_arg1::create;
1091
 
 
1092
 
  virtual Item *create(Session *session, Item *arg1);
1093
 
 
1094
 
  static Create_func_quote s_singleton;
1095
 
 
1096
 
protected:
1097
 
  Create_func_quote() {}
1098
 
  virtual ~Create_func_quote() {}
1099
 
};
1100
 
 
1101
 
 
1102
816
class Create_func_radians : public Create_func_arg1
1103
817
{
1104
818
public:
1114
828
};
1115
829
 
1116
830
 
1117
 
class Create_func_rand : public Create_native_func
1118
 
{
1119
 
public:
1120
 
  virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
1121
 
 
1122
 
  static Create_func_rand s_singleton;
1123
 
 
1124
 
protected:
1125
 
  Create_func_rand() {}
1126
 
  virtual ~Create_func_rand() {}
1127
 
};
1128
 
 
1129
 
 
1130
831
class Create_func_round : public Create_native_func
1131
832
{
1132
833
public:
1198
899
  virtual ~Create_func_sign() {}
1199
900
};
1200
901
 
1201
 
 
1202
 
class Create_func_sin : public Create_func_arg1
1203
 
{
1204
 
public:
1205
 
  using Create_func_arg1::create;
1206
 
 
1207
 
  virtual Item *create(Session *session, Item *arg1);
1208
 
 
1209
 
  static Create_func_sin s_singleton;
1210
 
 
1211
 
protected:
1212
 
  Create_func_sin() {}
1213
 
  virtual ~Create_func_sin() {}
1214
 
};
1215
 
 
1216
 
 
1217
902
class Create_func_space : public Create_func_arg1
1218
903
{
1219
904
public:
1228
913
  virtual ~Create_func_space() {}
1229
914
};
1230
915
 
1231
 
 
1232
 
class Create_func_sqrt : public Create_func_arg1
1233
 
{
1234
 
public:
1235
 
  using Create_func_arg1::create;
1236
 
 
1237
 
  virtual Item *create(Session *session, Item *arg1);
1238
 
 
1239
 
  static Create_func_sqrt s_singleton;
1240
 
 
1241
 
protected:
1242
 
  Create_func_sqrt() {}
1243
 
  virtual ~Create_func_sqrt() {}
1244
 
};
1245
 
 
1246
 
 
1247
916
class Create_func_strcmp : public Create_func_arg2
1248
917
{
1249
918
public:
1541
1210
  return create(session, param_1, param_2, param_3);
1542
1211
}
1543
1212
 
1544
 
 
1545
 
Create_func_abs Create_func_abs::s_singleton;
1546
 
 
1547
 
Item*
1548
 
Create_func_abs::create(Session *session, Item *arg1)
1549
 
{
1550
 
  return new (session->mem_root) Item_func_abs(arg1);
1551
 
}
1552
 
 
1553
 
 
1554
 
Create_func_acos Create_func_acos::s_singleton;
1555
 
 
1556
 
Item*
1557
 
Create_func_acos::create(Session *session, Item *arg1)
1558
 
{
1559
 
  return new (session->mem_root) Item_func_acos(arg1);
1560
 
}
1561
 
 
1562
 
Create_func_asin Create_func_asin::s_singleton;
1563
 
 
1564
 
Item*
1565
 
Create_func_asin::create(Session *session, Item *arg1)
1566
 
{
1567
 
  return new (session->mem_root) Item_func_asin(arg1);
1568
 
}
1569
 
 
1570
 
 
1571
 
Create_func_atan Create_func_atan::s_singleton;
1572
 
 
1573
 
Item*
1574
 
Create_func_atan::create_native(Session *session, LEX_STRING name,
1575
 
                                List<Item> *item_list)
1576
 
{
1577
 
  Item* func= NULL;
1578
 
  int arg_count= 0;
1579
 
 
1580
 
  if (item_list != NULL)
1581
 
    arg_count= item_list->elements;
1582
 
 
1583
 
  switch (arg_count) {
1584
 
  case 1:
1585
 
  {
1586
 
    Item *param_1= item_list->pop();
1587
 
    func= new (session->mem_root) Item_func_atan(param_1);
1588
 
    break;
1589
 
  }
1590
 
  case 2:
1591
 
  {
1592
 
    Item *param_1= item_list->pop();
1593
 
    Item *param_2= item_list->pop();
1594
 
    func= new (session->mem_root) Item_func_atan(param_1, param_2);
1595
 
    break;
1596
 
  }
1597
 
  default:
1598
 
  {
1599
 
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1600
 
    break;
1601
 
  }
1602
 
  }
1603
 
 
1604
 
  return func;
1605
 
}
1606
 
 
1607
1213
Create_func_bin Create_func_bin::s_singleton;
1608
1214
 
1609
1215
Item*
1614
1220
  return new (session->mem_root) Item_func_conv(arg1, i10, i2);
1615
1221
}
1616
1222
 
1617
 
 
1618
 
Create_func_ceiling Create_func_ceiling::s_singleton;
1619
 
 
1620
 
Item*
1621
 
Create_func_ceiling::create(Session *session, Item *arg1)
1622
 
{
1623
 
  return new (session->mem_root) Item_func_ceiling(arg1);
1624
 
}
1625
 
 
1626
 
 
1627
 
Create_func_coercibility Create_func_coercibility::s_singleton;
1628
 
 
1629
 
Item*
1630
 
Create_func_coercibility::create(Session *session, Item *arg1)
1631
 
{
1632
 
  return new (session->mem_root) Item_func_coercibility(arg1);
1633
 
}
1634
 
 
1635
 
 
1636
1223
Create_func_concat Create_func_concat::s_singleton;
1637
1224
 
1638
1225
Item*
1650
1237
    return NULL;
1651
1238
  }
1652
1239
 
1653
 
  return new (session->mem_root) Item_func_concat(*item_list);
 
1240
  return new (session->mem_root) Item_func_concat(*session, *item_list);
1654
1241
}
1655
1242
 
1656
1243
 
1672
1259
    return NULL;
1673
1260
  }
1674
1261
 
1675
 
  return new (session->mem_root) Item_func_concat_ws(*item_list);
 
1262
  return new (session->mem_root) Item_func_concat_ws(*session, *item_list);
1676
1263
}
1677
1264
 
1678
1265
 
1684
1271
  return new (session->mem_root) Item_func_conv(arg1, arg2, arg3);
1685
1272
}
1686
1273
 
1687
 
 
1688
 
Create_func_cos Create_func_cos::s_singleton;
1689
 
 
1690
 
Item*
1691
 
Create_func_cos::create(Session *session, Item *arg1)
1692
 
{
1693
 
  return new (session->mem_root) Item_func_cos(arg1);
1694
 
}
1695
 
 
1696
 
 
1697
1274
Create_func_cot Create_func_cot::s_singleton;
1698
1275
 
1699
1276
Item*
1701
1278
{
1702
1279
  Item *i1= new (session->mem_root) Item_int((char*) "1", 1, 1);
1703
1280
  Item *i2= new (session->mem_root) Item_func_tan(arg1);
1704
 
  return new (session->mem_root) Item_func_div(i1, i2);
 
1281
  return new (session->mem_root) Item_func_div(session, i1, i2);
1705
1282
}
1706
1283
 
1707
1284
Create_func_date_format Create_func_date_format::s_singleton;
1770
1347
                                             180/M_PI, 0.0);
1771
1348
}
1772
1349
 
1773
 
 
1774
 
Create_func_elt Create_func_elt::s_singleton;
1775
 
 
1776
 
Item*
1777
 
Create_func_elt::create_native(Session *session, LEX_STRING name,
1778
 
                               List<Item> *item_list)
1779
 
{
1780
 
  int arg_count= 0;
1781
 
 
1782
 
  if (item_list != NULL)
1783
 
    arg_count= item_list->elements;
1784
 
 
1785
 
  if (arg_count < 2)
1786
 
  {
1787
 
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1788
 
    return NULL;
1789
 
  }
1790
 
 
1791
 
  return new (session->mem_root) Item_func_elt(*item_list);
1792
 
}
1793
 
 
1794
 
 
1795
 
Create_func_exp Create_func_exp::s_singleton;
1796
 
 
1797
 
Item*
1798
 
Create_func_exp::create(Session *session, Item *arg1)
1799
 
{
1800
 
  return new (session->mem_root) Item_func_exp(arg1);
1801
 
}
1802
 
 
1803
 
 
1804
1350
Create_func_export_set Create_func_export_set::s_singleton;
1805
1351
 
1806
1352
Item*
1883
1429
  return new (session->mem_root) Item_func_find_in_set(arg1, arg2);
1884
1430
}
1885
1431
 
1886
 
 
1887
 
Create_func_floor Create_func_floor::s_singleton;
1888
 
 
1889
 
Item*
1890
 
Create_func_floor::create(Session *session, Item *arg1)
1891
 
{
1892
 
  return new (session->mem_root) Item_func_floor(arg1);
1893
 
}
1894
 
 
1895
 
 
1896
 
Create_func_format Create_func_format::s_singleton;
1897
 
 
1898
 
Item*
1899
 
Create_func_format::create(Session *session, Item *arg1, Item *arg2)
1900
 
{
1901
 
  return new (session->mem_root) Item_func_format(arg1, arg2);
1902
 
}
1903
 
 
1904
 
 
1905
1432
Create_func_found_rows Create_func_found_rows::s_singleton;
1906
1433
 
1907
1434
Item*
2078
1605
  return new (session->mem_root) Item_func_min(*item_list);
2079
1606
}
2080
1607
 
2081
 
 
2082
 
Create_func_ln Create_func_ln::s_singleton;
2083
 
 
2084
 
Item*
2085
 
Create_func_ln::create(Session *session, Item *arg1)
2086
 
{
2087
 
  return new (session->mem_root) Item_func_ln(arg1);
2088
 
}
2089
 
 
2090
 
 
2091
1608
Create_func_load_file Create_func_load_file::s_singleton;
2092
1609
 
2093
1610
Item*
2094
1611
Create_func_load_file::create(Session *session, Item *arg1)
2095
1612
{
2096
 
  return new (session->mem_root) Item_load_file(arg1);
 
1613
  return new (session->mem_root) Item_load_file(*session, arg1);
2097
1614
}
2098
1615
 
2099
1616
 
2137
1654
  return func;
2138
1655
}
2139
1656
 
2140
 
 
2141
 
Create_func_log Create_func_log::s_singleton;
2142
 
 
2143
 
Item*
2144
 
Create_func_log::create_native(Session *session, LEX_STRING name,
2145
 
                               List<Item> *item_list)
2146
 
{
2147
 
  Item *func= NULL;
2148
 
  int arg_count= 0;
2149
 
 
2150
 
  if (item_list != NULL)
2151
 
    arg_count= item_list->elements;
2152
 
 
2153
 
  switch (arg_count) {
2154
 
  case 1:
2155
 
  {
2156
 
    Item *param_1= item_list->pop();
2157
 
    func= new (session->mem_root) Item_func_log(param_1);
2158
 
    break;
2159
 
  }
2160
 
  case 2:
2161
 
  {
2162
 
    Item *param_1= item_list->pop();
2163
 
    Item *param_2= item_list->pop();
2164
 
    func= new (session->mem_root) Item_func_log(param_1, param_2);
2165
 
    break;
2166
 
  }
2167
 
  default:
2168
 
  {
2169
 
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
2170
 
    break;
2171
 
  }
2172
 
  }
2173
 
 
2174
 
  return func;
2175
 
}
2176
 
 
2177
 
 
2178
 
Create_func_log10 Create_func_log10::s_singleton;
2179
 
 
2180
 
Item*
2181
 
Create_func_log10::create(Session *session, Item *arg1)
2182
 
{
2183
 
  return new (session->mem_root) Item_func_log10(arg1);
2184
 
}
2185
 
 
2186
 
 
2187
 
Create_func_log2 Create_func_log2::s_singleton;
2188
 
 
2189
 
Item*
2190
 
Create_func_log2::create(Session *session, Item *arg1)
2191
 
{
2192
 
  return new (session->mem_root) Item_func_log2(arg1);
2193
 
}
2194
 
 
2195
 
 
2196
1657
Create_func_lpad Create_func_lpad::s_singleton;
2197
1658
 
2198
1659
Item*
2199
1660
Create_func_lpad::create(Session *session, Item *arg1, Item *arg2, Item *arg3)
2200
1661
{
2201
 
  return new (session->mem_root) Item_func_lpad(arg1, arg2, arg3);
 
1662
  return new (session->mem_root) Item_func_lpad(*session, arg1, arg2, arg3);
2202
1663
}
2203
1664
 
2204
1665
 
2223
1684
Create_func_make_set Create_func_make_set::s_singleton;
2224
1685
 
2225
1686
Item*
2226
 
Create_func_make_set::create_native(Session *session, LEX_STRING name,
 
1687
Create_func_make_set::create_native(Session *session_arg, LEX_STRING name,
2227
1688
                                    List<Item> *item_list)
2228
1689
{
2229
1690
  int arg_count= 0;
2238
1699
  }
2239
1700
 
2240
1701
  Item *param_1= item_list->pop();
2241
 
  return new (session->mem_root) Item_func_make_set(param_1, *item_list);
 
1702
  return new (session_arg->mem_root) Item_func_make_set(*session_arg, param_1, *item_list);
2242
1703
}
2243
1704
 
2244
1705
 
2270
1731
  return new (session->mem_root) Item_func_conv(arg1, i10, i8);
2271
1732
}
2272
1733
 
2273
 
 
2274
 
Create_func_ord Create_func_ord::s_singleton;
2275
 
 
2276
 
Item*
2277
 
Create_func_ord::create(Session *session, Item *arg1)
2278
 
{
2279
 
  return new (session->mem_root) Item_func_ord(arg1);
2280
 
}
2281
 
 
2282
 
 
2283
1734
Create_func_period_add Create_func_period_add::s_singleton;
2284
1735
 
2285
1736
Item*
2306
1757
  return new (session->mem_root) Item_static_float_func("pi()", M_PI, 6, 8);
2307
1758
}
2308
1759
 
2309
 
 
2310
 
Create_func_pow Create_func_pow::s_singleton;
2311
 
 
2312
 
Item*
2313
 
Create_func_pow::create(Session *session, Item *arg1, Item *arg2)
2314
 
{
2315
 
  return new (session->mem_root) Item_func_pow(arg1, arg2);
2316
 
}
2317
 
 
2318
 
 
2319
 
Create_func_quote Create_func_quote::s_singleton;
2320
 
 
2321
 
Item*
2322
 
Create_func_quote::create(Session *session, Item *arg1)
2323
 
{
2324
 
  return new (session->mem_root) Item_func_quote(arg1);
2325
 
}
2326
 
 
2327
 
 
2328
1760
Create_func_radians Create_func_radians::s_singleton;
2329
1761
 
2330
1762
Item*
2334
1766
                                             M_PI/180, 0.0);
2335
1767
}
2336
1768
 
2337
 
 
2338
 
Create_func_rand Create_func_rand::s_singleton;
2339
 
 
2340
 
Item*
2341
 
Create_func_rand::create_native(Session *session, LEX_STRING name,
2342
 
                                List<Item> *item_list)
2343
 
{
2344
 
  Item *func= NULL;
2345
 
  int arg_count= 0;
2346
 
 
2347
 
  if (item_list != NULL)
2348
 
    arg_count= item_list->elements;
2349
 
 
2350
 
  switch (arg_count) {
2351
 
  case 0:
2352
 
  {
2353
 
    func= new (session->mem_root) Item_func_rand();
2354
 
    break;
2355
 
  }
2356
 
  case 1:
2357
 
  {
2358
 
    Item *param_1= item_list->pop();
2359
 
    func= new (session->mem_root) Item_func_rand(param_1);
2360
 
    break;
2361
 
  }
2362
 
  default:
2363
 
  {
2364
 
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
2365
 
    break;
2366
 
  }
2367
 
  }
2368
 
 
2369
 
  return func;
2370
 
}
2371
 
 
2372
 
 
2373
1769
Create_func_round Create_func_round::s_singleton;
2374
1770
 
2375
1771
Item*
2422
1818
Item*
2423
1819
Create_func_rpad::create(Session *session, Item *arg1, Item *arg2, Item *arg3)
2424
1820
{
2425
 
  return new (session->mem_root) Item_func_rpad(arg1, arg2, arg3);
 
1821
  return new (session->mem_root) Item_func_rpad(*session, arg1, arg2, arg3);
2426
1822
}
2427
1823
 
2428
1824
 
2443
1839
  return new (session->mem_root) Item_func_sign(arg1);
2444
1840
}
2445
1841
 
2446
 
 
2447
 
Create_func_sin Create_func_sin::s_singleton;
2448
 
 
2449
 
Item*
2450
 
Create_func_sin::create(Session *session, Item *arg1)
2451
 
{
2452
 
  return new (session->mem_root) Item_func_sin(arg1);
2453
 
}
2454
 
 
2455
 
 
2456
1842
Create_func_space Create_func_space::s_singleton;
2457
1843
 
2458
1844
Item*
2468
1854
 
2469
1855
  if (cs->mbminlen > 1)
2470
1856
  {
2471
 
    uint32_t dummy_errors;
 
1857
    size_t dummy_errors;
2472
1858
    sp= new (session->mem_root) Item_string("", 0, cs, DERIVATION_COERCIBLE);
2473
1859
    sp->str_value.copy(" ", 1, &my_charset_utf8_general_ci, cs, &dummy_errors);
2474
1860
  }
2477
1863
    sp= new (session->mem_root) Item_string(" ", 1, cs, DERIVATION_COERCIBLE);
2478
1864
  }
2479
1865
 
2480
 
  return new (session->mem_root) Item_func_repeat(sp, arg1);
2481
 
}
2482
 
 
2483
 
 
2484
 
Create_func_sqrt Create_func_sqrt::s_singleton;
2485
 
 
2486
 
Item*
2487
 
Create_func_sqrt::create(Session *session, Item *arg1)
2488
 
{
2489
 
  return new (session->mem_root) Item_func_sqrt(arg1);
2490
 
}
2491
 
 
 
1866
  return new (session->mem_root) Item_func_repeat(*session, sp, arg1);
 
1867
}
2492
1868
 
2493
1869
Create_func_strcmp Create_func_strcmp::s_singleton;
2494
1870
 
2593
1969
 
2594
1970
static Native_func_registry func_array[] =
2595
1971
{
2596
 
  { { C_STRING_WITH_LEN("ABS") }, BUILDER(Create_func_abs)},
2597
 
  { { C_STRING_WITH_LEN("ACOS") }, BUILDER(Create_func_acos)},
2598
 
  { { C_STRING_WITH_LEN("ASIN") }, BUILDER(Create_func_asin)},
2599
 
  { { C_STRING_WITH_LEN("ATAN") }, BUILDER(Create_func_atan)},
2600
 
  { { C_STRING_WITH_LEN("ATAN2") }, BUILDER(Create_func_atan)},
2601
1972
  { { C_STRING_WITH_LEN("BIN") }, BUILDER(Create_func_bin)},
2602
 
  { { C_STRING_WITH_LEN("CEIL") }, BUILDER(Create_func_ceiling)},
2603
 
  { { C_STRING_WITH_LEN("CEILING") }, BUILDER(Create_func_ceiling)},
2604
 
  { { C_STRING_WITH_LEN("COERCIBILITY") }, BUILDER(Create_func_coercibility)},
2605
1973
  { { C_STRING_WITH_LEN("CONCAT") }, BUILDER(Create_func_concat)},
2606
1974
  { { C_STRING_WITH_LEN("CONCAT_WS") }, BUILDER(Create_func_concat_ws)},
2607
1975
  { { C_STRING_WITH_LEN("CONV") }, BUILDER(Create_func_conv)},
2608
 
  { { C_STRING_WITH_LEN("COS") }, BUILDER(Create_func_cos)},
2609
1976
  { { C_STRING_WITH_LEN("COT") }, BUILDER(Create_func_cot)},
2610
1977
  { { C_STRING_WITH_LEN("DATEDIFF") }, BUILDER(Create_func_datediff)},
2611
1978
  { { C_STRING_WITH_LEN("DATE_FORMAT") }, BUILDER(Create_func_date_format)},
2614
1981
  { { C_STRING_WITH_LEN("DAYOFWEEK") }, BUILDER(Create_func_dayofweek)},
2615
1982
  { { C_STRING_WITH_LEN("DAYOFYEAR") }, BUILDER(Create_func_dayofyear)},
2616
1983
  { { C_STRING_WITH_LEN("DEGREES") }, BUILDER(Create_func_degrees)},
2617
 
  { { C_STRING_WITH_LEN("ELT") }, BUILDER(Create_func_elt)},
2618
 
  { { C_STRING_WITH_LEN("EXP") }, BUILDER(Create_func_exp)},
2619
1984
  { { C_STRING_WITH_LEN("EXPORT_SET") }, BUILDER(Create_func_export_set)},
2620
1985
  { { C_STRING_WITH_LEN("FIELD") }, BUILDER(Create_func_field)},
2621
1986
  { { C_STRING_WITH_LEN("FIND_IN_SET") }, BUILDER(Create_func_find_in_set)},
2622
 
  { { C_STRING_WITH_LEN("FLOOR") }, BUILDER(Create_func_floor)},
2623
 
  { { C_STRING_WITH_LEN("FORMAT") }, BUILDER(Create_func_format)},
2624
1987
  { { C_STRING_WITH_LEN("FOUND_ROWS") }, BUILDER(Create_func_found_rows)},
2625
1988
  { { C_STRING_WITH_LEN("FROM_DAYS") }, BUILDER(Create_func_from_days)},
2626
1989
  { { C_STRING_WITH_LEN("FROM_UNIXTIME") }, BUILDER(Create_func_from_unixtime)},
2632
1995
  { { C_STRING_WITH_LEN("LAST_INSERT_ID") }, BUILDER(Create_func_last_insert_id)},
2633
1996
  { { C_STRING_WITH_LEN("LCASE") }, BUILDER(Create_func_lcase)},
2634
1997
  { { C_STRING_WITH_LEN("LEAST") }, BUILDER(Create_func_least)},
2635
 
  { { C_STRING_WITH_LEN("LN") }, BUILDER(Create_func_ln)},
2636
1998
  { { C_STRING_WITH_LEN("LOAD_FILE") }, BUILDER(Create_func_load_file)},
2637
1999
  { { C_STRING_WITH_LEN("LOCATE") }, BUILDER(Create_func_locate)},
2638
 
  { { C_STRING_WITH_LEN("LOG") }, BUILDER(Create_func_log)},
2639
 
  { { C_STRING_WITH_LEN("LOG10") }, BUILDER(Create_func_log10)},
2640
 
  { { C_STRING_WITH_LEN("LOG2") }, BUILDER(Create_func_log2)},
2641
2000
  { { C_STRING_WITH_LEN("LOWER") }, BUILDER(Create_func_lcase)},
2642
2001
  { { C_STRING_WITH_LEN("LPAD") }, BUILDER(Create_func_lpad)},
2643
2002
  { { C_STRING_WITH_LEN("LTRIM") }, BUILDER(Create_func_ltrim)},
2646
2005
  { { C_STRING_WITH_LEN("MONTHNAME") }, BUILDER(Create_func_monthname)},
2647
2006
  { { C_STRING_WITH_LEN("NULLIF") }, BUILDER(Create_func_nullif)},
2648
2007
  { { C_STRING_WITH_LEN("OCT") }, BUILDER(Create_func_oct)},
2649
 
  { { C_STRING_WITH_LEN("ORD") }, BUILDER(Create_func_ord)},
2650
2008
  { { C_STRING_WITH_LEN("PERIOD_ADD") }, BUILDER(Create_func_period_add)},
2651
2009
  { { C_STRING_WITH_LEN("PERIOD_DIFF") }, BUILDER(Create_func_period_diff)},
2652
2010
  { { C_STRING_WITH_LEN("PI") }, BUILDER(Create_func_pi)},
2653
 
  { { C_STRING_WITH_LEN("POW") }, BUILDER(Create_func_pow)},
2654
 
  { { C_STRING_WITH_LEN("POWER") }, BUILDER(Create_func_pow)},
2655
 
  { { C_STRING_WITH_LEN("QUOTE") }, BUILDER(Create_func_quote)},
2656
2011
  { { C_STRING_WITH_LEN("RADIANS") }, BUILDER(Create_func_radians)},
2657
 
  { { C_STRING_WITH_LEN("RAND") }, BUILDER(Create_func_rand)},
2658
2012
  { { C_STRING_WITH_LEN("ROUND") }, BUILDER(Create_func_round)},
2659
2013
  { { C_STRING_WITH_LEN("ROW_COUNT") }, BUILDER(Create_func_row_count)},
2660
2014
  { { C_STRING_WITH_LEN("RPAD") }, BUILDER(Create_func_rpad)},
2661
2015
  { { C_STRING_WITH_LEN("RTRIM") }, BUILDER(Create_func_rtrim)},
2662
2016
  { { C_STRING_WITH_LEN("SIGN") }, BUILDER(Create_func_sign)},
2663
 
  { { C_STRING_WITH_LEN("SIN") }, BUILDER(Create_func_sin)},
2664
2017
  { { C_STRING_WITH_LEN("SPACE") }, BUILDER(Create_func_space)},
2665
 
  { { C_STRING_WITH_LEN("SQRT") }, BUILDER(Create_func_sqrt)},
2666
2018
  { { C_STRING_WITH_LEN("STRCMP") }, BUILDER(Create_func_strcmp)},
2667
2019
  { { C_STRING_WITH_LEN("TAN") }, BUILDER(Create_func_tan)},
2668
2020
  { { C_STRING_WITH_LEN("TIME_FORMAT") }, BUILDER(Create_func_time_format)},
2675
2027
  { {0, 0}, NULL}
2676
2028
};
2677
2029
 
2678
 
static map<string, Native_func_registry *> native_functions_map;
2679
 
 
2680
2030
/*
2681
2031
  Load the hash table for native functions.
2682
2032
  Note: this code is not thread safe, and is intended to be used at server
2691
2041
  for (func= func_array; func->builder != NULL; func++)
2692
2042
  {
2693
2043
    func_name.assign(func->name.str, func->name.length);
2694
 
    transform(func_name.begin(), func_name.end(), func_name.begin(), ::tolower);
2695
2044
 
2696
 
    native_functions_map[func_name]= func;
 
2045
    FunctionContainer::getMap()[func_name]= func;
2697
2046
  }
2698
2047
 
2699
2048
  return 0;
2707
2056
  Create_func *builder= NULL;
2708
2057
 
2709
2058
  string func_name(name.str, name.length);
2710
 
  transform(func_name.begin(), func_name.end(), func_name.begin(), ::tolower);
2711
 
 
2712
 
  map<string, Native_func_registry *>::iterator func_iter=
2713
 
    native_functions_map.find(func_name);
2714
 
 
2715
 
  if (func_iter != native_functions_map.end())
 
2059
 
 
2060
  NativeFunctionsMap::iterator func_iter=
 
2061
    FunctionContainer::getMap().find(func_name);
 
2062
 
 
2063
  if (func_iter != FunctionContainer::getMap().end())
2716
2064
  {
2717
2065
    func= (*func_iter).second;
2718
2066
    builder= func->builder;