← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/create.cc

  • Committer: lbieber
  • Date: 2010-09-17 01:47:05 UTC
  • mfrom: (1770.1.2 build)
  • Revision ID: lbieber@orisndriz08-20100917014705-zzqek5l4x962z5tg
Merge Stewart - remove the unbalanced my_end() call from drizzledump
Merge Stewart - move math functions into plugin

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item/create.cc
63
63
/* Function declarations */
64
64
 
65
65
#include <drizzled/function/func.h>
66
 
#include <drizzled/function/math/abs.h>
67
 
#include <drizzled/function/math/acos.h>
68
66
#include <drizzled/function/additive_op.h>
69
 
#include <drizzled/function/math/asin.h>
70
 
#include <drizzled/function/math/atan.h>
71
67
#include <drizzled/function/math/ceiling.h>
72
 
#include <drizzled/function/math/cos.h>
73
68
#include <drizzled/function/math/dec.h>
74
69
#include <drizzled/function/math/decimal_typecast.h>
75
70
#include <drizzled/function/math/exp.h>
83
78
#include <drizzled/function/last_insert.h>
84
79
#include <drizzled/function/math/ln.h>
85
80
#include <drizzled/function/locate.h>
86
 
#include <drizzled/function/math/log.h>
87
81
#include <drizzled/function/min_max.h>
88
82
#include <drizzled/function/num1.h>
89
83
#include <drizzled/function/num_op.h>
90
84
#include <drizzled/function/numhybrid.h>
91
85
#include <drizzled/function/math/ord.h>
92
 
#include <drizzled/function/math/pow.h>
93
86
#include <drizzled/function/math/real.h>
94
87
#include <drizzled/function/row_count.h>
95
88
#include <drizzled/function/set_user_var.h>
96
89
#include <drizzled/function/sign.h>
97
 
#include <drizzled/function/math/sin.h>
98
90
#include <drizzled/function/math/sqrt.h>
99
91
#include <drizzled/function/str/quote.h>
100
92
#include <drizzled/function/math/tan.h>
257
249
  it helps to compare code between versions, and helps with merges conflicts.
258
250
*/
259
251
 
260
 
class Create_func_abs : public Create_func_arg1
261
 
{
262
 
public:
263
 
  using Create_func_arg1::create;
264
 
 
265
 
  virtual Item *create(Session *session, Item *arg1);
266
 
 
267
 
  static Create_func_abs s_singleton;
268
 
 
269
 
protected:
270
 
  Create_func_abs() {}
271
 
  virtual ~Create_func_abs() {}
272
 
};
273
 
 
274
 
 
275
 
class Create_func_acos : public Create_func_arg1
276
 
{
277
 
public:
278
 
  using Create_func_arg1::create;
279
 
 
280
 
  virtual Item *create(Session *session, Item *arg1);
281
 
 
282
 
  static Create_func_acos s_singleton;
283
 
 
284
 
protected:
285
 
  Create_func_acos() {}
286
 
  virtual ~Create_func_acos() {}
287
 
};
288
 
 
289
 
class Create_func_asin : public Create_func_arg1
290
 
{
291
 
public:
292
 
  using Create_func_arg1::create;
293
 
 
294
 
  virtual Item *create(Session *session, Item *arg1);
295
 
 
296
 
  static Create_func_asin s_singleton;
297
 
 
298
 
protected:
299
 
  Create_func_asin() {}
300
 
  virtual ~Create_func_asin() {}
301
 
};
302
 
 
303
 
 
304
 
class Create_func_atan : public Create_native_func
305
 
{
306
 
public:
307
 
  virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
308
 
 
309
 
  static Create_func_atan s_singleton;
310
 
 
311
 
protected:
312
 
  Create_func_atan() {}
313
 
  virtual ~Create_func_atan() {}
314
 
};
315
252
 
316
253
class Create_func_bin : public Create_func_arg1
317
254
{
382
319
  virtual ~Create_func_conv() {}
383
320
};
384
321
 
385
 
 
386
 
class Create_func_cos : public Create_func_arg1
387
 
{
388
 
public:
389
 
  using Create_func_arg1::create;
390
 
 
391
 
  virtual Item *create(Session *session, Item *arg1);
392
 
 
393
 
  static Create_func_cos s_singleton;
394
 
 
395
 
protected:
396
 
  Create_func_cos() {}
397
 
  virtual ~Create_func_cos() {}
398
 
};
399
 
 
400
 
 
401
322
class Create_func_cot : public Create_func_arg1
402
323
{
403
324
public:
831
752
};
832
753
 
833
754
 
834
 
class Create_func_log : public Create_native_func
835
 
{
836
 
public:
837
 
  virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
838
 
 
839
 
  static Create_func_log s_singleton;
840
 
 
841
 
protected:
842
 
  Create_func_log() {}
843
 
  virtual ~Create_func_log() {}
844
 
};
845
 
 
846
 
 
847
 
class Create_func_log10 : public Create_func_arg1
848
 
{
849
 
public:
850
 
  using Create_func_arg1::create;
851
 
 
852
 
  virtual Item *create(Session *session, Item *arg1);
853
 
 
854
 
  static Create_func_log10 s_singleton;
855
 
 
856
 
protected:
857
 
  Create_func_log10() {}
858
 
  virtual ~Create_func_log10() {}
859
 
};
860
 
 
861
 
 
862
 
class Create_func_log2 : public Create_func_arg1
863
 
{
864
 
public:
865
 
  using Create_func_arg1::create;
866
 
 
867
 
  virtual Item *create(Session *session, Item *arg1);
868
 
 
869
 
  static Create_func_log2 s_singleton;
870
 
 
871
 
protected:
872
 
  Create_func_log2() {}
873
 
  virtual ~Create_func_log2() {}
874
 
};
875
 
 
876
 
 
877
755
class Create_func_lpad : public Create_func_arg3
878
756
{
879
757
public:
1050
928
  virtual ~Create_func_pi() {}
1051
929
};
1052
930
 
1053
 
 
1054
 
class Create_func_pow : public Create_func_arg2
1055
 
{
1056
 
public:
1057
 
  using Create_func_arg2::create;
1058
 
 
1059
 
  virtual Item *create(Session *session, Item *arg1, Item *arg2);
1060
 
 
1061
 
  static Create_func_pow s_singleton;
1062
 
 
1063
 
protected:
1064
 
  Create_func_pow() {}
1065
 
  virtual ~Create_func_pow() {}
1066
 
};
1067
 
 
1068
 
 
1069
931
class Create_func_quote : public Create_func_arg1
1070
932
{
1071
933
public:
1167
1029
  virtual ~Create_func_sign() {}
1168
1030
};
1169
1031
 
1170
 
 
1171
 
class Create_func_sin : public Create_func_arg1
1172
 
{
1173
 
public:
1174
 
  using Create_func_arg1::create;
1175
 
 
1176
 
  virtual Item *create(Session *session, Item *arg1);
1177
 
 
1178
 
  static Create_func_sin s_singleton;
1179
 
 
1180
 
protected:
1181
 
  Create_func_sin() {}
1182
 
  virtual ~Create_func_sin() {}
1183
 
};
1184
 
 
1185
 
 
1186
1032
class Create_func_space : public Create_func_arg1
1187
1033
{
1188
1034
public:
1510
1356
  return create(session, param_1, param_2, param_3);
1511
1357
}
1512
1358
 
1513
 
 
1514
 
Create_func_abs Create_func_abs::s_singleton;
1515
 
 
1516
 
Item*
1517
 
Create_func_abs::create(Session *session, Item *arg1)
1518
 
{
1519
 
  return new (session->mem_root) Item_func_abs(arg1);
1520
 
}
1521
 
 
1522
 
 
1523
 
Create_func_acos Create_func_acos::s_singleton;
1524
 
 
1525
 
Item*
1526
 
Create_func_acos::create(Session *session, Item *arg1)
1527
 
{
1528
 
  return new (session->mem_root) Item_func_acos(arg1);
1529
 
}
1530
 
 
1531
 
Create_func_asin Create_func_asin::s_singleton;
1532
 
 
1533
 
Item*
1534
 
Create_func_asin::create(Session *session, Item *arg1)
1535
 
{
1536
 
  return new (session->mem_root) Item_func_asin(arg1);
1537
 
}
1538
 
 
1539
 
 
1540
 
Create_func_atan Create_func_atan::s_singleton;
1541
 
 
1542
 
Item*
1543
 
Create_func_atan::create_native(Session *session, LEX_STRING name,
1544
 
                                List<Item> *item_list)
1545
 
{
1546
 
  Item* func= NULL;
1547
 
  int arg_count= 0;
1548
 
 
1549
 
  if (item_list != NULL)
1550
 
    arg_count= item_list->elements;
1551
 
 
1552
 
  switch (arg_count) {
1553
 
  case 1:
1554
 
  {
1555
 
    Item *param_1= item_list->pop();
1556
 
    func= new (session->mem_root) Item_func_atan(param_1);
1557
 
    break;
1558
 
  }
1559
 
  case 2:
1560
 
  {
1561
 
    Item *param_1= item_list->pop();
1562
 
    Item *param_2= item_list->pop();
1563
 
    func= new (session->mem_root) Item_func_atan(param_1, param_2);
1564
 
    break;
1565
 
  }
1566
 
  default:
1567
 
  {
1568
 
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1569
 
    break;
1570
 
  }
1571
 
  }
1572
 
 
1573
 
  return func;
1574
 
}
1575
 
 
1576
1359
Create_func_bin Create_func_bin::s_singleton;
1577
1360
 
1578
1361
Item*
1643
1426
  return new (session->mem_root) Item_func_conv(arg1, arg2, arg3);
1644
1427
}
1645
1428
 
1646
 
 
1647
 
Create_func_cos Create_func_cos::s_singleton;
1648
 
 
1649
 
Item*
1650
 
Create_func_cos::create(Session *session, Item *arg1)
1651
 
{
1652
 
  return new (session->mem_root) Item_func_cos(arg1);
1653
 
}
1654
 
 
1655
 
 
1656
1429
Create_func_cot Create_func_cot::s_singleton;
1657
1430
 
1658
1431
Item*
2096
1869
  return func;
2097
1870
}
2098
1871
 
2099
 
 
2100
 
Create_func_log Create_func_log::s_singleton;
2101
 
 
2102
 
Item*
2103
 
Create_func_log::create_native(Session *session, LEX_STRING name,
2104
 
                               List<Item> *item_list)
2105
 
{
2106
 
  Item *func= NULL;
2107
 
  int arg_count= 0;
2108
 
 
2109
 
  if (item_list != NULL)
2110
 
    arg_count= item_list->elements;
2111
 
 
2112
 
  switch (arg_count) {
2113
 
  case 1:
2114
 
  {
2115
 
    Item *param_1= item_list->pop();
2116
 
    func= new (session->mem_root) Item_func_log(param_1);
2117
 
    break;
2118
 
  }
2119
 
  case 2:
2120
 
  {
2121
 
    Item *param_1= item_list->pop();
2122
 
    Item *param_2= item_list->pop();
2123
 
    func= new (session->mem_root) Item_func_log(param_1, param_2);
2124
 
    break;
2125
 
  }
2126
 
  default:
2127
 
  {
2128
 
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
2129
 
    break;
2130
 
  }
2131
 
  }
2132
 
 
2133
 
  return func;
2134
 
}
2135
 
 
2136
 
 
2137
 
Create_func_log10 Create_func_log10::s_singleton;
2138
 
 
2139
 
Item*
2140
 
Create_func_log10::create(Session *session, Item *arg1)
2141
 
{
2142
 
  return new (session->mem_root) Item_func_log10(arg1);
2143
 
}
2144
 
 
2145
 
 
2146
 
Create_func_log2 Create_func_log2::s_singleton;
2147
 
 
2148
 
Item*
2149
 
Create_func_log2::create(Session *session, Item *arg1)
2150
 
{
2151
 
  return new (session->mem_root) Item_func_log2(arg1);
2152
 
}
2153
 
 
2154
 
 
2155
1872
Create_func_lpad Create_func_lpad::s_singleton;
2156
1873
 
2157
1874
Item*
2266
1983
}
2267
1984
 
2268
1985
 
2269
 
Create_func_pow Create_func_pow::s_singleton;
2270
 
 
2271
 
Item*
2272
 
Create_func_pow::create(Session *session, Item *arg1, Item *arg2)
2273
 
{
2274
 
  return new (session->mem_root) Item_func_pow(arg1, arg2);
2275
 
}
2276
 
 
2277
 
 
2278
1986
Create_func_quote Create_func_quote::s_singleton;
2279
1987
 
2280
1988
Item*
2366
2074
  return new (session->mem_root) Item_func_sign(arg1);
2367
2075
}
2368
2076
 
2369
 
 
2370
 
Create_func_sin Create_func_sin::s_singleton;
2371
 
 
2372
 
Item*
2373
 
Create_func_sin::create(Session *session, Item *arg1)
2374
 
{
2375
 
  return new (session->mem_root) Item_func_sin(arg1);
2376
 
}
2377
 
 
2378
 
 
2379
2077
Create_func_space Create_func_space::s_singleton;
2380
2078
 
2381
2079
Item*
2516
2214
 
2517
2215
static Native_func_registry func_array[] =
2518
2216
{
2519
 
  { { C_STRING_WITH_LEN("ABS") }, BUILDER(Create_func_abs)},
2520
 
  { { C_STRING_WITH_LEN("ACOS") }, BUILDER(Create_func_acos)},
2521
 
  { { C_STRING_WITH_LEN("ASIN") }, BUILDER(Create_func_asin)},
2522
 
  { { C_STRING_WITH_LEN("ATAN") }, BUILDER(Create_func_atan)},
2523
 
  { { C_STRING_WITH_LEN("ATAN2") }, BUILDER(Create_func_atan)},
2524
2217
  { { C_STRING_WITH_LEN("BIN") }, BUILDER(Create_func_bin)},
2525
2218
  { { C_STRING_WITH_LEN("CEIL") }, BUILDER(Create_func_ceiling)},
2526
2219
  { { C_STRING_WITH_LEN("CEILING") }, BUILDER(Create_func_ceiling)},
2527
2220
  { { C_STRING_WITH_LEN("CONCAT") }, BUILDER(Create_func_concat)},
2528
2221
  { { C_STRING_WITH_LEN("CONCAT_WS") }, BUILDER(Create_func_concat_ws)},
2529
2222
  { { C_STRING_WITH_LEN("CONV") }, BUILDER(Create_func_conv)},
2530
 
  { { C_STRING_WITH_LEN("COS") }, BUILDER(Create_func_cos)},
2531
2223
  { { C_STRING_WITH_LEN("COT") }, BUILDER(Create_func_cot)},
2532
2224
  { { C_STRING_WITH_LEN("DATEDIFF") }, BUILDER(Create_func_datediff)},
2533
2225
  { { C_STRING_WITH_LEN("DATE_FORMAT") }, BUILDER(Create_func_date_format)},
2557
2249
  { { C_STRING_WITH_LEN("LN") }, BUILDER(Create_func_ln)},
2558
2250
  { { C_STRING_WITH_LEN("LOAD_FILE") }, BUILDER(Create_func_load_file)},
2559
2251
  { { C_STRING_WITH_LEN("LOCATE") }, BUILDER(Create_func_locate)},
2560
 
  { { C_STRING_WITH_LEN("LOG") }, BUILDER(Create_func_log)},
2561
 
  { { C_STRING_WITH_LEN("LOG10") }, BUILDER(Create_func_log10)},
2562
 
  { { C_STRING_WITH_LEN("LOG2") }, BUILDER(Create_func_log2)},
2563
2252
  { { C_STRING_WITH_LEN("LOWER") }, BUILDER(Create_func_lcase)},
2564
2253
  { { C_STRING_WITH_LEN("LPAD") }, BUILDER(Create_func_lpad)},
2565
2254
  { { C_STRING_WITH_LEN("LTRIM") }, BUILDER(Create_func_ltrim)},
2572
2261
  { { C_STRING_WITH_LEN("PERIOD_ADD") }, BUILDER(Create_func_period_add)},
2573
2262
  { { C_STRING_WITH_LEN("PERIOD_DIFF") }, BUILDER(Create_func_period_diff)},
2574
2263
  { { C_STRING_WITH_LEN("PI") }, BUILDER(Create_func_pi)},
2575
 
  { { C_STRING_WITH_LEN("POW") }, BUILDER(Create_func_pow)},
2576
 
  { { C_STRING_WITH_LEN("POWER") }, BUILDER(Create_func_pow)},
2577
2264
  { { C_STRING_WITH_LEN("QUOTE") }, BUILDER(Create_func_quote)},
2578
2265
  { { C_STRING_WITH_LEN("RADIANS") }, BUILDER(Create_func_radians)},
2579
2266
  { { C_STRING_WITH_LEN("ROUND") }, BUILDER(Create_func_round)},
2581
2268
  { { C_STRING_WITH_LEN("RPAD") }, BUILDER(Create_func_rpad)},
2582
2269
  { { C_STRING_WITH_LEN("RTRIM") }, BUILDER(Create_func_rtrim)},
2583
2270
  { { C_STRING_WITH_LEN("SIGN") }, BUILDER(Create_func_sign)},
2584
 
  { { C_STRING_WITH_LEN("SIN") }, BUILDER(Create_func_sin)},
2585
2271
  { { C_STRING_WITH_LEN("SPACE") }, BUILDER(Create_func_space)},
2586
2272
  { { C_STRING_WITH_LEN("SQRT") }, BUILDER(Create_func_sqrt)},
2587
2273
  { { C_STRING_WITH_LEN("STRCMP") }, BUILDER(Create_func_strcmp)},