« back to all changes in this revision
Viewing changes to drizzled/item/create.cc
- browse files at revision 2350
- compare with another revision
- compare with revision 2324.2.4
- download diff
- download tarball
- view history from revision 2350
- Committer: Mark Atwood
- Date: 2011-06-27 19:01:37 UTC
- mfrom: (2318.6.90 refactor16)
- Revision ID: me@mark.atwood.name-20110627190137-iflt3vku0kw77l8a
merge lp:~olafvdspek/drizzle/refactor17
- files modified:
- client/drizzletest.cc
added
removed
drizzled/item/create.cc
107
107
but semantically invalid for native functions.
108
108
*/
109
109
110
/**
111
Checks if there are named parameters in a parameter list.
112
The syntax to name parameters in a function call is as follow:
113
<code>foo(expr AS named, expr named, expr AS "named", expr "named")</code>
114
@param params The parameter list, can be null
115
@return true if one or more parameter is named
116
*/
117
static bool has_named_parameters(List<Item>& params)
118
{
119
List<Item>::iterator it(params.begin());
120
while (Item* param= it++)
121
{
122
if (not param->is_autogenerated_name)
123
return true;
124
}
125
return false;
126
}
127
110
128
class Create_native_func : public Create_func
111
129
{
112
130
public:
113
virtual Item *create(Session *session, LEX_STRING name, List<Item> *item_list);
131
virtual Item* create(Session* session, LEX_STRING name, List<Item>* item_list)
132
{
133
if (item_list && has_named_parameters(*item_list))
134
{
135
my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), name.str);
136
return NULL;
137
}
138
return create_native(session, name, item_list);
139
}
114
140
115
141
/**
116
142
Builder method, with no arguments.
119
145
@param item_list The function parameters, none of which are named
120
146
@return An item representing the function call
121
147
*/
122
virtual Item *create_native(Session *session, LEX_STRING name,
123
List<Item> *item_list) = 0;
148
virtual Item* create_native(Session*, LEX_STRING name, List<Item>*) = 0;
124
149
125
150
protected:
126
151
/** Constructor. */
127
152
Create_native_func() {}
128
/** Destructor. */
129
virtual ~Create_native_func() {}
130
153
};
131
154
132
155
137
160
class Create_func_arg0 : public Create_func
138
161
{
139
162
public:
140
virtual Item *create(Session *session, LEX_STRING name, List<Item> *item_list);
163
virtual Item* create(Session *session, LEX_STRING name, List<Item> *item_list);
141
164
142
165
/**
143
166
Builder method, with no arguments.
144
167
@param session The current thread
145
168
@return An item representing the function call
146
169
*/
147
virtual Item *create(Session *session) = 0;
170
virtual Item* create(Session *session) = 0;
148
171
149
172
protected:
150
173
/** Constructor. */
151
174
Create_func_arg0() {}
152
/** Destructor. */
153
virtual ~Create_func_arg0() {}
154
175
};
155
176
156
177
161
182
class Create_func_arg1 : public Create_func
162
183
{
163
184
public:
164
virtual Item *create(Session *session, LEX_STRING name, List<Item> *item_list);
185
virtual Item* create(Session *session, LEX_STRING name, List<Item> *item_list);
165
186
166
187
/**
167
188
Builder method, with one argument.
169
190
@param arg1 The first argument of the function
170
191
@return An item representing the function call
171
192
*/
172
virtual Item *create(Session *session, Item *arg1) = 0;
193
virtual Item* create(Session *session, Item *arg1) = 0;
173
194
174
195
protected:
175
196
/** Constructor. */
176
197
Create_func_arg1() {}
177
/** Destructor. */
178
virtual ~Create_func_arg1() {}
179
198
};
180
199
181
200
186
205
class Create_func_arg2 : public Create_func
187
206
{
188
207
public:
189
virtual Item *create(Session *session, LEX_STRING name, List<Item> *item_list);
208
virtual Item* create(Session *session, LEX_STRING name, List<Item> *item_list);
190
209
191
210
/**
192
211
Builder method, with two arguments.
195
214
@param arg2 The second argument of the function
196
215
@return An item representing the function call
197
216
*/
198
virtual Item *create(Session *session, Item *arg1, Item *arg2) = 0;
217
virtual Item* create(Session *session, Item *arg1, Item *arg2) = 0;
199
218
200
219
protected:
201
220
/** Constructor. */
202
221
Create_func_arg2() {}
203
/** Destructor. */
204
virtual ~Create_func_arg2() {}
205
222
};
206
223
207
224
212
229
class Create_func_arg3 : public Create_func
213
230
{
214
231
public:
215
virtual Item *create(Session *session, LEX_STRING name, List<Item> *item_list);
232
virtual Item* create(Session *session, LEX_STRING name, List<Item> *item_list);
216
233
217
234
/**
218
235
Builder method, with three arguments.
222
239
@param arg3 The third argument of the function
223
240
@return An item representing the function call
224
241
*/
225
virtual Item *create(Session *session, Item *arg1, Item *arg2, Item *arg3) = 0;
242
virtual Item* create(Session *session, Item *arg1, Item *arg2, Item *arg3) = 0;
226
243
227
244
protected:
228
245
/** Constructor. */
229
246
Create_func_arg3() {}
230
/** Destructor. */
231
virtual ~Create_func_arg3() {}
232
247
};
233
248
234
249
248
263
public:
249
264
using Create_func_arg1::create;
250
265
251
virtual Item *create(Session *session, Item *arg1);
266
virtual Item* create(Session *session, Item *arg1);
252
267
253
268
static Create_func_bin s_singleton;
254
269
255
270
protected:
256
271
Create_func_bin() {}
257
virtual ~Create_func_bin() {}
258
272
};
259
273
260
274
class Create_func_concat : public Create_native_func
261
275
{
262
276
public:
263
virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
277
virtual Item* create_native(Session *session, LEX_STRING name, List<Item> *item_list);
264
278
265
279
static Create_func_concat s_singleton;
266
280
267
281
protected:
268
282
Create_func_concat() {}
269
virtual ~Create_func_concat() {}
270
283
};
271
284
272
285
273
286
class Create_func_concat_ws : public Create_native_func
274
287
{
275
288
public:
276
virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
289
virtual Item* create_native(Session *session, LEX_STRING name, List<Item> *item_list);
277
290
278
291
static Create_func_concat_ws s_singleton;
279
292
280
293
protected:
281
294
Create_func_concat_ws() {}
282
virtual ~Create_func_concat_ws() {}
283
295
};
284
296
285
297
288
300
public:
289
301
using Create_func_arg3::create;
290
302
291
virtual Item *create(Session *session, Item *arg1, Item *arg2, Item *arg3);
303
virtual Item* create(Session *session, Item *arg1, Item *arg2, Item *arg3)
304
{
305
return new (session->mem) Item_func_conv(arg1, arg2, arg3);
306
}
292
307
293
308
static Create_func_conv s_singleton;
294
295
309
protected:
296
310
Create_func_conv() {}
297
virtual ~Create_func_conv() {}
298
311
};
299
312
313
Create_func_conv Create_func_conv::s_singleton;
314
300
315
class Create_func_cot : public Create_func_arg1
301
316
{
302
317
public:
303
318
using Create_func_arg1::create;
304
319
305
virtual Item *create(Session *session, Item *arg1);
320
virtual Item* create(Session *session, Item *arg1);
306
321
307
322
static Create_func_cot s_singleton;
308
323
309
324
protected:
310
325
Create_func_cot() {}
311
virtual ~Create_func_cot() {}
312
326
};
313
327
314
328
class Create_func_date_format : public Create_func_arg2
316
330
public:
317
331
using Create_func_arg2::create;
318
332
319
virtual Item *create(Session *session, Item *arg1, Item *arg2);
333
virtual Item* create(Session *session, Item *arg1, Item *arg2)
334
{
335
return new (session->mem) Item_func_date_format(arg1, arg2, 0);
336
}
320
337
321
338
static Create_func_date_format s_singleton;
322
323
339
protected:
324
340
Create_func_date_format() {}
325
virtual ~Create_func_date_format() {}
326
341
};
327
342
343
Create_func_date_format Create_func_date_format::s_singleton;
328
344
329
345
class Create_func_datediff : public Create_func_arg2
330
346
{
331
347
public:
332
348
using Create_func_arg2::create;
333
349
334
virtual Item *create(Session *session, Item *arg1, Item *arg2);
350
virtual Item* create(Session *session, Item *arg1, Item *arg2);
335
351
336
352
static Create_func_datediff s_singleton;
337
353
338
354
protected:
339
355
Create_func_datediff() {}
340
virtual ~Create_func_datediff() {}
341
356
};
342
357
343
358
346
361
public:
347
362
using Create_func_arg1::create;
348
363
349
virtual Item *create(Session *session, Item *arg1);
364
virtual Item* create(Session *session, Item *arg1)
365
{
366
return new (session->mem) Item_func_dayname(arg1);
367
}
350
368
351
369
static Create_func_dayname s_singleton;
352
370
353
371
protected:
354
372
Create_func_dayname() {}
355
virtual ~Create_func_dayname() {}
356
373
};
357
374
375
Create_func_dayname Create_func_dayname::s_singleton;
358
376
359
377
class Create_func_dayofmonth : public Create_func_arg1
360
378
{
361
379
public:
362
380
using Create_func_arg1::create;
363
381
364
virtual Item *create(Session *session, Item *arg1);
382
virtual Item* create(Session *session, Item *arg1)
383
{
384
return new (session->mem) Item_func_dayofmonth(arg1);
385
}
365
386
366
387
static Create_func_dayofmonth s_singleton;
367
368
388
protected:
369
389
Create_func_dayofmonth() {}
370
virtual ~Create_func_dayofmonth() {}
371
390
};
372
391
392
Create_func_dayofmonth Create_func_dayofmonth::s_singleton;
373
393
374
394
class Create_func_dayofweek : public Create_func_arg1
375
395
{
376
396
public:
377
397
using Create_func_arg1::create;
378
398
379
virtual Item *create(Session *session, Item *arg1);
399
virtual Item* create(Session *session, Item *arg1)
400
{
401
return new (session->mem) Item_func_weekday(arg1, 1);
402
}
380
403
381
404
static Create_func_dayofweek s_singleton;
382
383
405
protected:
384
406
Create_func_dayofweek() {}
385
virtual ~Create_func_dayofweek() {}
386
407
};
387
408
409
Create_func_dayofweek Create_func_dayofweek::s_singleton;
388
410
389
411
class Create_func_dayofyear : public Create_func_arg1
390
412
{
391
413
public:
392
414
using Create_func_arg1::create;
393
415
394
virtual Item *create(Session *session, Item *arg1);
416
virtual Item* create(Session *session, Item *arg1)
417
{
418
return new (session->mem) Item_func_dayofyear(arg1);
419
}
395
420
396
421
static Create_func_dayofyear s_singleton;
397
398
422
protected:
399
423
Create_func_dayofyear() {}
400
virtual ~Create_func_dayofyear() {}
401
424
};
402
425
426
Create_func_dayofyear Create_func_dayofyear::s_singleton;
403
427
404
428
class Create_func_decode : public Create_func_arg2
405
429
{
406
430
public:
407
431
using Create_func_arg2::create;
408
432
409
virtual Item *create(Session *session, Item *arg1, Item *arg2);
433
virtual Item* create(Session *session, Item *arg1, Item *arg2);
410
434
411
435
static Create_func_decode s_singleton;
412
436
413
437
protected:
414
438
Create_func_decode() {}
415
virtual ~Create_func_decode() {}
416
439
};
417
440
418
441
421
444
public:
422
445
using Create_func_arg1::create;
423
446
424
virtual Item *create(Session *session, Item *arg1);
447
virtual Item* create(Session *session, Item *arg1)
448
{
449
return new (session->mem) Item_func_units("degrees", arg1, 180/M_PI, 0.0);
450
}
425
451
426
452
static Create_func_degrees s_singleton;
427
428
453
protected:
429
454
Create_func_degrees() {}
430
virtual ~Create_func_degrees() {}
431
455
};
432
456
457
Create_func_degrees Create_func_degrees::s_singleton;
458
433
459
class Create_func_export_set : public Create_native_func
434
460
{
435
461
436
462
public:
437
virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
463
virtual Item* create_native(Session *session, LEX_STRING name, List<Item> *item_list);
438
464
439
465
static Create_func_export_set s_singleton;
440
466
441
467
protected:
442
468
Create_func_export_set() {}
443
virtual ~Create_func_export_set() {}
444
469
};
445
470
446
471
447
472
class Create_func_field : public Create_native_func
448
473
{
449
474
public:
450
virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
475
virtual Item* create_native(Session *session, LEX_STRING name, List<Item> *item_list);
451
476
452
477
static Create_func_field s_singleton;
453
478
454
479
protected:
455
480
Create_func_field() {}
456
virtual ~Create_func_field() {}
457
481
};
458
482
459
483
462
486
public:
463
487
using Create_func_arg2::create;
464
488
465
virtual Item *create(Session *session, Item *arg1, Item *arg2);
489
virtual Item* create(Session *session, Item *arg1, Item *arg2);
466
490
467
491
static Create_func_find_in_set s_singleton;
468
492
469
493
protected:
470
494
Create_func_find_in_set() {}
471
virtual ~Create_func_find_in_set() {}
472
495
};
473
496
474
497
class Create_func_found_rows : public Create_func_arg0
476
499
public:
477
500
using Create_func_arg0::create;
478
501
479
virtual Item *create(Session *session);
502
virtual Item* create(Session *session);
480
503
481
504
static Create_func_found_rows s_singleton;
482
505
483
506
protected:
484
507
Create_func_found_rows() {}
485
virtual ~Create_func_found_rows() {}
486
508
};
487
509
488
510
491
513
public:
492
514
using Create_func_arg1::create;
493
515
494
virtual Item *create(Session *session, Item *arg1);
516
virtual Item* create(Session *session, Item *arg1);
495
517
496
518
static Create_func_from_days s_singleton;
497
519
498
520
protected:
499
521
Create_func_from_days() {}
500
virtual ~Create_func_from_days() {}
501
522
};
502
523
503
524
504
525
class Create_func_from_unixtime : public Create_native_func
505
526
{
506
527
public:
507
virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
528
virtual Item* create_native(Session *session, LEX_STRING name, List<Item> *item_list);
508
529
509
530
static Create_func_from_unixtime s_singleton;
510
531
511
532
protected:
512
533
Create_func_from_unixtime() {}
513
virtual ~Create_func_from_unixtime() {}
514
534
};
515
535
516
536
517
537
class Create_func_greatest : public Create_native_func
518
538
{
519
539
public:
520
virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
540
virtual Item* create_native(Session *session, LEX_STRING name, List<Item> *item_list);
521
541
522
542
static Create_func_greatest s_singleton;
523
543
524
544
protected:
525
545
Create_func_greatest() {}
526
virtual ~Create_func_greatest() {}
527
546
};
528
547
529
548
532
551
public:
533
552
using Create_func_arg2::create;
534
553
535
virtual Item *create(Session *session, Item *arg1, Item *arg2);
554
virtual Item* create(Session *session, Item *arg1, Item *arg2);
536
555
537
556
static Create_func_ifnull s_singleton;
538
557
539
558
protected:
540
559
Create_func_ifnull() {}
541
virtual ~Create_func_ifnull() {}
542
560
};
543
561
544
562
547
565
public:
548
566
using Create_func_arg2::create;
549
567
550
virtual Item *create(Session *session, Item *arg1, Item *arg2);
568
virtual Item* create(Session *session, Item *arg1, Item *arg2);
551
569
552
570
static Create_func_instr s_singleton;
553
571
554
572
protected:
555
573
Create_func_instr() {}
556
virtual ~Create_func_instr() {}
557
574
};
558
575
559
576
562
579
public:
563
580
using Create_func_arg1::create;
564
581
565
virtual Item *create(Session *session, Item *arg1);
582
virtual Item* create(Session *session, Item *arg1);
566
583
567
584
static Create_func_isnull s_singleton;
568
585
569
586
protected:
570
587
Create_func_isnull() {}
571
virtual ~Create_func_isnull() {}
572
588
};
573
589
574
590
577
593
public:
578
594
using Create_func_arg1::create;
579
595
580
virtual Item *create(Session *session, Item *arg1);
596
virtual Item* create(Session *session, Item *arg1);
581
597
582
598
static Create_func_last_day s_singleton;
583
599
584
600
protected:
585
601
Create_func_last_day() {}
586
virtual ~Create_func_last_day() {}
587
602
};
588
603
589
604
590
605
class Create_func_last_insert_id : public Create_native_func
591
606
{
592
607
public:
593
virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
608
virtual Item* create_native(Session *session, LEX_STRING name, List<Item> *item_list);
594
609
595
610
static Create_func_last_insert_id s_singleton;
596
611
597
612
protected:
598
613
Create_func_last_insert_id() {}
599
virtual ~Create_func_last_insert_id() {}
600
614
};
601
615
602
616
605
619
public:
606
620
using Create_func_arg1::create;
607
621
608
virtual Item *create(Session *session, Item *arg1);
622
virtual Item* create(Session *session, Item *arg1);
609
623
610
624
static Create_func_lcase s_singleton;
611
625
612
626
protected:
613
627
Create_func_lcase() {}
614
virtual ~Create_func_lcase() {}
615
628
};
616
629
617
630
618
631
class Create_func_least : public Create_native_func
619
632
{
620
633
public:
621
virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
634
virtual Item* create_native(Session *session, LEX_STRING name, List<Item> *item_list);
622
635
623
636
static Create_func_least s_singleton;
624
637
625
638
protected:
626
639
Create_func_least() {}
627
virtual ~Create_func_least() {}
628
640
};
629
641
630
642
class Create_func_load_file : public Create_func_arg1
632
644
public:
633
645
using Create_func_arg1::create;
634
646
635
virtual Item *create(Session *session, Item *arg1);
647
virtual Item* create(Session *session, Item *arg1);
636
648
637
649
static Create_func_load_file s_singleton;
638
650
639
651
protected:
640
652
Create_func_load_file() {}
641
virtual ~Create_func_load_file() {}
642
653
};
643
654
644
655
645
656
class Create_func_locate : public Create_native_func
646
657
{
647
658
public:
648
virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
659
virtual Item* create_native(Session *session, LEX_STRING name, List<Item> *item_list);
649
660
650
661
static Create_func_locate s_singleton;
651
662
652
663
protected:
653
664
Create_func_locate() {}
654
virtual ~Create_func_locate() {}
655
665
};
656
666
657
667
660
670
public:
661
671
using Create_func_arg3::create;
662
672
663
virtual Item *create(Session *session, Item *arg1, Item *arg2, Item *arg3);
673
virtual Item* create(Session *session, Item *arg1, Item *arg2, Item *arg3)
674
{
675
return new (session->mem) Item_func_lpad(*session, arg1, arg2, arg3);
676
}
664
677
665
678
static Create_func_lpad s_singleton;
666
667
679
protected:
668
680
Create_func_lpad() {}
669
virtual ~Create_func_lpad() {}
670
681
};
671
682
683
Create_func_lpad Create_func_lpad::s_singleton;
672
684
673
685
class Create_func_ltrim : public Create_func_arg1
674
686
{
675
687
public:
676
688
using Create_func_arg1::create;
677
689
678
virtual Item *create(Session *session, Item *arg1);
690
virtual Item* create(Session *session, Item *arg1)
691
{
692
return new (session->mem) Item_func_ltrim(arg1);
693
}
679
694
680
695
static Create_func_ltrim s_singleton;
681
682
696
protected:
683
697
Create_func_ltrim() {}
684
virtual ~Create_func_ltrim() {}
685
698
};
686
699
700
Create_func_ltrim Create_func_ltrim::s_singleton;
687
701
688
702
class Create_func_makedate : public Create_func_arg2
689
703
{
690
704
public:
691
705
using Create_func_arg2::create;
692
706
693
virtual Item *create(Session *session, Item *arg1, Item *arg2);
707
virtual Item* create(Session *session, Item *arg1, Item *arg2)
708
{
709
return new (session->mem) Item_func_makedate(arg1, arg2);
710
}
694
711
695
712
static Create_func_makedate s_singleton;
696
697
713
protected:
698
714
Create_func_makedate() {}
699
virtual ~Create_func_makedate() {}
700
715
};
701
716
717
Create_func_makedate Create_func_makedate::s_singleton;
718
702
719
class Create_func_make_set : public Create_native_func
703
720
{
704
721
public:
705
virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
722
virtual Item* create_native(Session *session, LEX_STRING name, List<Item> *item_list);
706
723
707
724
static Create_func_make_set s_singleton;
708
725
709
726
protected:
710
727
Create_func_make_set() {}
711
virtual ~Create_func_make_set() {}
712
728
};
713
729
714
730
717
733
public:
718
734
using Create_func_arg1::create;
719
735
720
virtual Item *create(Session *session, Item *arg1);
736
virtual Item* create(Session *session, Item *arg1)
737
{
738
return new (session->mem) Item_func_monthname(arg1);
739
}
721
740
722
741
static Create_func_monthname s_singleton;
723
724
742
protected:
725
743
Create_func_monthname() {}
726
virtual ~Create_func_monthname() {}
727
744
};
728
745
746
Create_func_monthname Create_func_monthname::s_singleton;
729
747
730
748
class Create_func_name_const : public Create_func_arg2
731
749
{
732
750
public:
733
751
using Create_func_arg2::create;
734
752
735
virtual Item *create(Session *session, Item *arg1, Item *arg2);
753
virtual Item* create(Session *session, Item *arg1, Item *arg2);
736
754
737
755
static Create_func_name_const s_singleton;
738
756
739
757
protected:
740
758
Create_func_name_const() {}
741
virtual ~Create_func_name_const() {}
742
759
};
743
760
744
761
747
764
public:
748
765
using Create_func_arg2::create;
749
766
750
virtual Item *create(Session *session, Item *arg1, Item *arg2);
767
virtual Item* create(Session *session, Item *arg1, Item *arg2)
768
{
769
return new (session->mem) Item_func_nullif(arg1, arg2);
770
}
751
771
752
772
static Create_func_nullif s_singleton;
753
754
773
protected:
755
774
Create_func_nullif() {}
756
virtual ~Create_func_nullif() {}
757
775
};
758
776
777
Create_func_nullif Create_func_nullif::s_singleton;
759
778
760
779
class Create_func_oct : public Create_func_arg1
761
780
{
762
781
public:
763
782
using Create_func_arg1::create;
764
783
765
virtual Item *create(Session *session, Item *arg1);
784
virtual Item* create(Session *session, Item *arg1);
766
785
767
786
static Create_func_oct s_singleton;
768
787
769
788
protected:
770
789
Create_func_oct() {}
771
virtual ~Create_func_oct() {}
772
790
};
773
791
774
792
class Create_func_period_add : public Create_func_arg2
776
794
public:
777
795
using Create_func_arg2::create;
778
796
779
virtual Item *create(Session *session, Item *arg1, Item *arg2);
797
virtual Item* create(Session *session, Item *arg1, Item *arg2);
780
798
781
799
static Create_func_period_add s_singleton;
782
800
783
801
protected:
784
802
Create_func_period_add() {}
785
virtual ~Create_func_period_add() {}
786
803
};
787
804
788
805
791
808
public:
792
809
using Create_func_arg2::create;
793
810
794
virtual Item *create(Session *session, Item *arg1, Item *arg2);
811
virtual Item* create(Session *session, Item *arg1, Item *arg2);
795
812
796
813
static Create_func_period_diff s_singleton;
797
814
798
815
protected:
799
816
Create_func_period_diff() {}
800
virtual ~Create_func_period_diff() {}
801
817
};
802
818
803
819
806
822
public:
807
823
using Create_func_arg0::create;
808
824
809
virtual Item *create(Session *session);
825
virtual Item* create(Session *session);
810
826
811
827
static Create_func_pi s_singleton;
812
828
813
829
protected:
814
830
Create_func_pi() {}
815
virtual ~Create_func_pi() {}
816
831
};
817
832
818
833
class Create_func_radians : public Create_func_arg1
820
835
public:
821
836
using Create_func_arg1::create;
822
837
823
virtual Item *create(Session *session, Item *arg1);
838
virtual Item* create(Session *session, Item *arg1);
824
839
825
840
static Create_func_radians s_singleton;
826
827
841
protected:
828
842
Create_func_radians() {}
829
virtual ~Create_func_radians() {}
830
843
};
831
844
832
845
833
846
class Create_func_round : public Create_native_func
834
847
{
835
848
public:
836
virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
849
virtual Item* create_native(Session *session, LEX_STRING name, List<Item> *item_list);
837
850
838
851
static Create_func_round s_singleton;
839
840
852
protected:
841
853
Create_func_round() {}
842
virtual ~Create_func_round() {}
843
854
};
844
855
845
856
848
859
public:
849
860
using Create_func_arg0::create;
850
861
851
virtual Item *create(Session *session);
862
virtual Item* create(Session *session)
863
{
864
return new (session->mem) Item_func_row_count();
865
}
852
866
853
867
static Create_func_row_count s_singleton;
854
855
868
protected:
856
869
Create_func_row_count() {}
857
virtual ~Create_func_row_count() {}
858
870
};
859
871
872
Create_func_row_count Create_func_row_count::s_singleton;
860
873
861
874
class Create_func_rpad : public Create_func_arg3
862
875
{
863
876
public:
864
877
using Create_func_arg3::create;
865
878
866
virtual Item *create(Session *session, Item *arg1, Item *arg2, Item *arg3);
879
virtual Item* create(Session *session, Item *arg1, Item *arg2, Item *arg3)
880
{
881
return new (session->mem) Item_func_rpad(*session, arg1, arg2, arg3);
882
}
867
883
868
884
static Create_func_rpad s_singleton;
869
870
885
protected:
871
886
Create_func_rpad() {}
872
virtual ~Create_func_rpad() {}
873
887
};
874
888
889
Create_func_rpad Create_func_rpad::s_singleton;
875
890
876
891
class Create_func_rtrim : public Create_func_arg1
877
892
{
878
893
public:
879
894
using Create_func_arg1::create;
880
895
881
virtual Item *create(Session *session, Item *arg1);
896
virtual Item* create(Session *session, Item *arg1)
897
{
898
return new (session->mem) Item_func_rtrim(arg1);
899
}
882
900
883
901
static Create_func_rtrim s_singleton;
884
902
885
903
protected:
886
904
Create_func_rtrim() {}
887
virtual ~Create_func_rtrim() {}
888
905
};
889
906
907
Create_func_rtrim Create_func_rtrim::s_singleton;
908
890
909
class Create_func_sign : public Create_func_arg1
891
910
{
892
911
public:
893
912
using Create_func_arg1::create;
894
913
895
virtual Item *create(Session *session, Item *arg1);
914
virtual Item* create(Session *session, Item *arg1)
915
{
916
return new (session->mem) Item_func_sign(arg1);
917
}
896
918
897
919
static Create_func_sign s_singleton;
898
899
920
protected:
900
921
Create_func_sign() {}
901
virtual ~Create_func_sign() {}
902
922
};
903
923
924
Create_func_sign Create_func_sign::s_singleton;
925
904
926
class Create_func_space : public Create_func_arg1
905
927
{
906
928
public:
907
929
using Create_func_arg1::create;
908
930
909
virtual Item *create(Session *session, Item *arg1);
931
virtual Item* create(Session *session, Item *arg1);
910
932
911
933
static Create_func_space s_singleton;
912
913
934
protected:
914
935
Create_func_space() {}
915
virtual ~Create_func_space() {}
916
936
};
917
937
918
938
class Create_func_strcmp : public Create_func_arg2
920
940
public:
921
941
using Create_func_arg2::create;
922
942
923
virtual Item *create(Session *session, Item *arg1, Item *arg2);
924
943
virtual Item* create(Session *session, Item *arg1, Item *arg2)
944
{
945
return new (session->mem) Item_func_strcmp(arg1, arg2);
946
}
947
925
948
static Create_func_strcmp s_singleton;
926
927
949
protected:
928
950
Create_func_strcmp() {}
929
virtual ~Create_func_strcmp() {}
930
951
};
931
952
953
Create_func_strcmp Create_func_strcmp::s_singleton;
932
954
933
955
class Create_func_tan : public Create_func_arg1
934
956
{
935
957
public:
936
958
using Create_func_arg1::create;
937
959
938
virtual Item *create(Session *session, Item *arg1);
960
virtual Item* create(Session *session, Item *arg1)
961
{
962
return new (session->mem) Item_func_tan(arg1);
963
}
939
964
940
965
static Create_func_tan s_singleton;
941
942
966
protected:
943
967
Create_func_tan() {}
944
virtual ~Create_func_tan() {}
945
968
};
946
969
970
Create_func_tan Create_func_tan::s_singleton;
947
971
948
972
class Create_func_time_format : public Create_func_arg2
949
973
{
950
974
public:
951
975
using Create_func_arg2::create;
952
976
953
virtual Item *create(Session *session, Item *arg1, Item *arg2);
977
virtual Item* create(Session *session, Item *arg1, Item *arg2)
978
{
979
return new (session->mem) Item_func_date_format(arg1, arg2, 1);
980
}
954
981
955
982
static Create_func_time_format s_singleton;
956
957
983
protected:
958
984
Create_func_time_format() {}
959
virtual ~Create_func_time_format() {}
960
};
961
962
963
class Create_func_time_to_sec : public Create_func_arg1
964
{
965
public:
966
using Create_func_arg1::create;
967
968
virtual Item *create(Session *session, Item *arg1);
969
970
static Create_func_time_to_sec s_singleton;
971
972
protected:
973
Create_func_time_to_sec() {}
974
virtual ~Create_func_time_to_sec() {}
975
};
976
985
};
986
987
Create_func_time_format Create_func_time_format::s_singleton;
977
988
978
989
class Create_func_to_days : public Create_func_arg1
979
990
{
980
991
public:
981
992
using Create_func_arg1::create;
982
993
983
virtual Item *create(Session *session, Item *arg1);
994
virtual Item* create(Session *session, Item *arg1)
995
{
996
return new (session->mem) Item_func_to_days(arg1);
997
}
984
998
985
999
static Create_func_to_days s_singleton;
986
987
1000
protected:
988
1001
Create_func_to_days() {}
989
virtual ~Create_func_to_days() {}
990
1002
};
991
1003
1004
Create_func_to_days Create_func_to_days::s_singleton;
992
1005
993
1006
class Create_func_ucase : public Create_func_arg1
994
1007
{
995
1008
public:
996
1009
using Create_func_arg1::create;
997
1010
998
virtual Item *create(Session *session, Item *arg1);
1011
virtual Item* create(Session *session, Item *arg1)
1012
{
1013
return new (session->mem) Item_func_ucase(arg1);
1014
}
999
1015
1000
1016
static Create_func_ucase s_singleton;
1001
1002
1017
protected:
1003
1018
Create_func_ucase() {}
1004
virtual ~Create_func_ucase() {}
1005
1019
};
1006
1020
1021
Create_func_ucase Create_func_ucase::s_singleton;
1007
1022
1008
1023
class Create_func_unix_timestamp : public Create_native_func
1009
1024
{
1010
1025
public:
1011
virtual Item *create_native(Session *session, LEX_STRING name, List<Item> *item_list);
1026
virtual Item* create_native(Session *session, LEX_STRING name, List<Item> *item_list);
1012
1027
1013
1028
static Create_func_unix_timestamp s_singleton;
1014
1015
1029
protected:
1016
1030
Create_func_unix_timestamp() {}
1017
virtual ~Create_func_unix_timestamp() {}
1018
1031
};
1019
1032
1020
1033
1023
1036
public:
1024
1037
using Create_func_arg1::create;
1025
1038
1026
virtual Item *create(Session *session, Item *arg1);
1039
virtual Item* create(Session *session, Item *arg1)
1040
{
1041
return new (session->mem) Item_func_weekday(arg1, 0);
1042
}
1027
1043
1028
1044
static Create_func_weekday s_singleton;
1029
1030
1045
protected:
1031
1046
Create_func_weekday() {}
1032
virtual ~Create_func_weekday() {}
1033
1047
};
1034
1048
1049
Create_func_weekday Create_func_weekday::s_singleton;
1050
1035
1051
/*
1036
1052
=============================================================================
1037
1053
IMPLEMENTATION
1038
1054
=============================================================================
1039
1055
*/
1040
1056
1041
/**
1042
Checks if there are named parameters in a parameter list.
1043
The syntax to name parameters in a function call is as follow:
1044
<code>foo(expr AS named, expr named, expr AS "named", expr "named")</code>
1045
@param params The parameter list, can be null
1046
@return true if one or more parameter is named
1047
*/
1048
static bool has_named_parameters(List<Item> *params)
1049
{
1050
if (params)
1051
{
1052
Item *param;
1053
List<Item>::iterator it(params->begin());
1054
while ((param= it++))
1055
{
1056
if (! param->is_autogenerated_name)
1057
return true;
1058
}
1059
}
1060
1061
return false;
1062
}
1063
1064
1065
1057
Create_udf_func Create_udf_func::s_singleton;
1066
1058
1067
Item*
1068
Create_udf_func::create(Session *session, LEX_STRING name, List<Item> *item_list)
1069
{
1070
const plugin::Function *udf= plugin::Function::get(std::string(name.str, name.length));
1059
Item* Create_udf_func::create(Session *session, LEX_STRING name, List<Item> *item_list)
1060
{
1061
return create(session, plugin::Function::get(std::string(name.str, name.length)), item_list);
1062
}
1063
1064
Item* Create_udf_func::create(Session *session, const plugin::Function *udf, List<Item> *item_list)
1065
{
1071
1066
assert(udf);
1072
return create(session, udf, item_list);
1073
}
1074
1075
1076
Item*
1077
Create_udf_func::create(Session *session, const plugin::Function *udf,
1078
List<Item> *item_list)
1079
{
1080
Item_func *func= NULL;
1081
int arg_count= 0;
1082
1083
if (item_list != NULL)
1084
arg_count= item_list->size();
1085
1086
func= (*udf)(session->mem_root);
1087
1088
if(!func->check_argument_count(arg_count))
1067
int arg_count= item_list ? item_list->size() : 0;
1068
Item_func* func= (*udf)(&session->mem);
1069
if (!func->check_argument_count(arg_count))
1089
1070
{
1090
1071
my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), func->func_name());
1091
1072
return NULL;
1092
1073
}
1093
1094
if(item_list)
1074
if (item_list)
1095
1075
func->set_arguments(*item_list);
1096
1097
1076
return func;
1098
1077
}
1099
1078
1100
1101
Item*
1102
Create_native_func::create(Session *session, LEX_STRING name, List<Item> *item_list)
1103
{
1104
if (has_named_parameters(item_list))
1105
{
1106
my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), name.str);
1107
return NULL;
1108
}
1109
1110
return create_native(session, name, item_list);
1111
}
1112
1113
1114
Item*
1115
Create_func_arg0::create(Session *session, LEX_STRING name, List<Item> *item_list)
1116
{
1117
int arg_count= 0;
1118
1119
if (item_list != NULL)
1120
arg_count= item_list->size();
1121
1122
if (arg_count != 0)
1079
Item* Create_func_arg0::create(Session *session, LEX_STRING name, List<Item> *item_list)
1080
{
1081
if (item_list && item_list->size())
1123
1082
{
1124
1083
my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1125
1084
return NULL;
1126
1085
}
1127
1128
1086
return create(session);
1129
1087
}
1130
1088
1131
1132
Item*
1133
Create_func_arg1::create(Session *session, LEX_STRING name, List<Item> *item_list)
1089
Item* Create_func_arg1::create(Session *session, LEX_STRING name, List<Item> *item_list)
1134
1090
{
1135
int arg_count= 0;
1136
1137
if (item_list)
1138
arg_count= item_list->size();
1139
1091
int arg_count= item_list ? item_list->size() : 0;
1140
1092
if (arg_count != 1)
1141
1093
{
1142
1094
my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1158
1110
Item*
1159
1111
Create_func_arg2::create(Session *session, LEX_STRING name, List<Item> *item_list)
1160
1112
{
1161
int arg_count= 0;
1162
1163
if (item_list)
1164
arg_count= item_list->size();
1165
1113
int arg_count= item_list ? item_list->size() : 0;
1166
1114
if (arg_count != 2)
1167
1115
{
1168
1116
my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1186
1134
Item*
1187
1135
Create_func_arg3::create(Session *session, LEX_STRING name, List<Item> *item_list)
1188
1136
{
1189
int arg_count= 0;
1190
1191
if (item_list)
1192
arg_count= item_list->size();
1193
1137
int arg_count= item_list ? item_list->size() : 0;
1194
1138
if (arg_count != 3)
1195
1139
{
1196
1140
my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1217
1161
Item*
1218
1162
Create_func_bin::create(Session *session, Item *arg1)
1219
1163
{
1220
Item *i10= new (session->mem_root) Item_int((int32_t) 10,2);
1221
Item *i2= new (session->mem_root) Item_int((int32_t) 2,1);
1222
return new (session->mem_root) Item_func_conv(arg1, i10, i2);
1164
Item *i10= new (session->mem) Item_int(10, 2);
1165
Item *i2= new (session->mem) Item_int(2, 1);
1166
return new (session->mem) Item_func_conv(arg1, i10, i2);
1223
1167
}
1224
1168
1225
1169
Create_func_concat Create_func_concat::s_singleton;
1226
1170
1227
1171
Item*
1228
Create_func_concat::create_native(Session *session, LEX_STRING name,
1229
List<Item> *item_list)
1172
Create_func_concat::create_native(Session *session, LEX_STRING name, List<Item> *item_list)
1230
1173
{
1231
int arg_count= 0;
1232
1233
if (item_list != NULL)
1234
arg_count= item_list->size();
1235
1174
int arg_count= item_list ? item_list->size() : 0;
1236
1175
if (arg_count < 1)
1237
1176
{
1238
1177
my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1239
1178
return NULL;
1240
1179
}
1241
1180
1242
return new (session->mem_root) Item_func_concat(*session, *item_list);
1181
return new (session->mem) Item_func_concat(*session, *item_list);
1243
1182
}
1244
1183
1245
1184
1249
1188
Create_func_concat_ws::create_native(Session *session, LEX_STRING name,
1250
1189
List<Item> *item_list)
1251
1190
{
1252
int arg_count= 0;
1253
1254
if (item_list != NULL)
1255
arg_count= item_list->size();
1256
1191
int arg_count= item_list ? item_list->size() : 0;
1257
1192
/* "WS" stands for "With Separator": this function takes 2+ arguments */
1258
1193
if (arg_count < 2)
1259
1194
{
1261
1196
return NULL;
1262
1197
}
1263
1198
1264
return new (session->mem_root) Item_func_concat_ws(*session, *item_list);
1265
}
1266
1267
1268
Create_func_conv Create_func_conv::s_singleton;
1269
1270
Item*
1271
Create_func_conv::create(Session *session, Item *arg1, Item *arg2, Item *arg3)
1272
{
1273
return new (session->mem_root) Item_func_conv(arg1, arg2, arg3);
1199
return new (session->mem) Item_func_concat_ws(*session, *item_list);
1274
1200
}
1275
1201
1276
1202
Create_func_cot Create_func_cot::s_singleton;
1278
1204
Item*
1279
1205
Create_func_cot::create(Session *session, Item *arg1)
1280
1206
{
1281
Item *i1= new (session->mem_root) Item_int((char*) "1", 1, 1);
1282
Item *i2= new (session->mem_root) Item_func_tan(arg1);
1283
return new (session->mem_root) Item_func_div(session, i1, i2);
1284
}
1285
1286
Create_func_date_format Create_func_date_format::s_singleton;
1287
1288
Item*
1289
Create_func_date_format::create(Session *session, Item *arg1, Item *arg2)
1290
{
1291
return new (session->mem_root) Item_func_date_format(arg1, arg2, 0);
1292
}
1293
1207
Item *i1= new (session->mem) Item_int("1", 1, 1);
1208
Item *i2= new (session->mem) Item_func_tan(arg1);
1209
return new (session->mem) Item_func_div(session, i1, i2);
1210
}
1294
1211
1295
1212
Create_func_datediff Create_func_datediff::s_singleton;
1296
1213
1297
1214
Item*
1298
1215
Create_func_datediff::create(Session *session, Item *arg1, Item *arg2)
1299
1216
{
1300
Item *i1= new (session->mem_root) Item_func_to_days(arg1);
1301
Item *i2= new (session->mem_root) Item_func_to_days(arg2);
1302
1303
return new (session->mem_root) Item_func_minus(i1, i2);
1304
}
1305
1306
1307
Create_func_dayname Create_func_dayname::s_singleton;
1308
1309
Item*
1310
Create_func_dayname::create(Session *session, Item *arg1)
1311
{
1312
return new (session->mem_root) Item_func_dayname(arg1);
1313
}
1314
1315
1316
Create_func_dayofmonth Create_func_dayofmonth::s_singleton;
1317
1318
Item*
1319
Create_func_dayofmonth::create(Session *session, Item *arg1)
1320
{
1321
return new (session->mem_root) Item_func_dayofmonth(arg1);
1322
}
1323
1324
1325
Create_func_dayofweek Create_func_dayofweek::s_singleton;
1326
1327
Item*
1328
Create_func_dayofweek::create(Session *session, Item *arg1)
1329
{
1330
return new (session->mem_root) Item_func_weekday(arg1, 1);
1331
}
1332
1333
1334
Create_func_dayofyear Create_func_dayofyear::s_singleton;
1335
1336
Item*
1337
Create_func_dayofyear::create(Session *session, Item *arg1)
1338
{
1339
return new (session->mem_root) Item_func_dayofyear(arg1);
1340
}
1341
1342
1343
Create_func_degrees Create_func_degrees::s_singleton;
1344
1345
Item*
1346
Create_func_degrees::create(Session *session, Item *arg1)
1347
{
1348
return new (session->mem_root) Item_func_units((char*) "degrees", arg1,
1349
180/M_PI, 0.0);
1217
Item *i1= new (session->mem) Item_func_to_days(arg1);
1218
Item *i2= new (session->mem) Item_func_to_days(arg2);
1219
return new (session->mem) Item_func_minus(i1, i2);
1350
1220
}
1351
1221
1352
1222
Create_func_export_set Create_func_export_set::s_singleton;
1353
1223
1354
1224
Item*
1355
Create_func_export_set::create_native(Session *session, LEX_STRING name,
1356
List<Item> *item_list)
1225
Create_func_export_set::create_native(Session *session, LEX_STRING name, List<Item> *item_list)
1357
1226
{
1358
Item *func= NULL;
1359
int arg_count= 0;
1360
1361
if (item_list != NULL)
1362
arg_count= item_list->size();
1363
1364
switch (arg_count) {
1227
switch (item_list ? item_list->size() : 0)
1228
{
1365
1229
case 3:
1366
{
1367
Item *param_1= item_list->pop();
1368
Item *param_2= item_list->pop();
1369
Item *param_3= item_list->pop();
1370
func= new (session->mem_root) Item_func_export_set(param_1, param_2, param_3);
1371
break;
1372
}
1230
{
1231
Item *param_1= item_list->pop();
1232
Item *param_2= item_list->pop();
1233
Item *param_3= item_list->pop();
1234
return new (session->mem) Item_func_export_set(param_1, param_2, param_3);
1235
}
1373
1236
case 4:
1374
{
1375
Item *param_1= item_list->pop();
1376
Item *param_2= item_list->pop();
1377
Item *param_3= item_list->pop();
1378
Item *param_4= item_list->pop();
1379
func= new (session->mem_root) Item_func_export_set(param_1, param_2, param_3,
1380
param_4);
1381
break;
1382
}
1237
{
1238
Item *param_1= item_list->pop();
1239
Item *param_2= item_list->pop();
1240
Item *param_3= item_list->pop();
1241
Item *param_4= item_list->pop();
1242
return new (session->mem) Item_func_export_set(param_1, param_2, param_3, param_4);
1243
}
1383
1244
case 5:
1384
{
1385
Item *param_1= item_list->pop();
1386
Item *param_2= item_list->pop();
1387
Item *param_3= item_list->pop();
1388
Item *param_4= item_list->pop();
1389
Item *param_5= item_list->pop();
1390
func= new (session->mem_root) Item_func_export_set(param_1, param_2, param_3,
1391
param_4, param_5);
1392
break;
1393
}
1245
{
1246
Item *param_1= item_list->pop();
1247
Item *param_2= item_list->pop();
1248
Item *param_3= item_list->pop();
1249
Item *param_4= item_list->pop();
1250
Item *param_5= item_list->pop();
1251
return new (session->mem) Item_func_export_set(param_1, param_2, param_3, param_4, param_5);
1252
}
1394
1253
default:
1395
{
1396
1254
my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1397
break;
1398
}
1399
}
1400
1401
return func;
1255
}
1256
return NULL;
1402
1257
}
1403
1258
1404
1259
1408
1263
Create_func_field::create_native(Session *session, LEX_STRING name,
1409
1264
List<Item> *item_list)
1410
1265
{
1411
int arg_count= 0;
1412
1413
if (item_list != NULL)
1414
arg_count= item_list->size();
1415
1266
int arg_count= item_list ? item_list->size() : 0;
1416
1267
if (arg_count < 2)
1417
1268
{
1418
1269
my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1419
1270
return NULL;
1420
1271
}
1421
1272
1422
return new (session->mem_root) Item_func_field(*item_list);
1273
return new (session->mem) Item_func_field(*item_list);
1423
1274
}
1424
1275
1425
1276
1428
1279
Item*
1429
1280
Create_func_find_in_set::create(Session *session, Item *arg1, Item *arg2)
1430
1281
{
1431
return new (session->mem_root) Item_func_find_in_set(arg1, arg2);
1282
return new (session->mem) Item_func_find_in_set(arg1, arg2);
1432
1283
}
1433
1284
1434
1285
Create_func_found_rows Create_func_found_rows::s_singleton;
1436
1287
Item*
1437
1288
Create_func_found_rows::create(Session *session)
1438
1289
{
1439
return new (session->mem_root) Item_func_found_rows();
1290
return new (session->mem) Item_func_found_rows();
1440
1291
}
1441
1292
1442
1293
1445
1296
Item*
1446
1297
Create_func_from_days::create(Session *session, Item *arg1)
1447
1298
{
1448
return new (session->mem_root) Item_func_from_days(arg1);
1299
return new (session->mem) Item_func_from_days(arg1);
1449
1300
}
1450
1301
1451
1302
1455
1306
Create_func_from_unixtime::create_native(Session *session, LEX_STRING name,
1456
1307
List<Item> *item_list)
1457
1308
{
1458
Item *func= NULL;
1459
int arg_count= 0;
1460
1461
if (item_list != NULL)
1462
arg_count= item_list->size();
1463
1464
switch (arg_count) {
1309
switch (item_list ? item_list->size() : 0)
1310
{
1465
1311
case 1:
1466
{
1467
Item *param_1= item_list->pop();
1468
func= new (session->mem_root) Item_func_from_unixtime(param_1);
1469
break;
1470
}
1312
{
1313
Item *param_1= item_list->pop();
1314
return new (session->mem) Item_func_from_unixtime(param_1);
1315
}
1471
1316
case 2:
1472
{
1473
Item *param_1= item_list->pop();
1474
Item *param_2= item_list->pop();
1475
Item *ut= new (session->mem_root) Item_func_from_unixtime(param_1);
1476
func= new (session->mem_root) Item_func_date_format(ut, param_2, 0);
1477
break;
1478
}
1317
{
1318
Item *param_1= item_list->pop();
1319
Item *param_2= item_list->pop();
1320
Item *ut= new (session->mem) Item_func_from_unixtime(param_1);
1321
return new (session->mem) Item_func_date_format(ut, param_2, 0);
1322
}
1479
1323
default:
1480
{
1481
1324
my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1482
break;
1483
}
1484
}
1485
1486
return func;
1325
}
1326
return NULL;
1487
1327
}
1488
1328
1489
1329
1493
1333
Create_func_greatest::create_native(Session *session, LEX_STRING name,
1494
1334
List<Item> *item_list)
1495
1335
{
1496
int arg_count= 0;
1497
1498
if (item_list != NULL)
1499
arg_count= item_list->size();
1500
1336
int arg_count= item_list ? item_list->size() : 0;
1501
1337
if (arg_count < 2)
1502
1338
{
1503
1339
my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1504
1340
return NULL;
1505
1341
}
1506
1342
1507
return new (session->mem_root) Item_func_max(*item_list);
1343
return new (session->mem) Item_func_max(*item_list);
1508
1344
}
1509
1345
1510
1346
Create_func_ifnull Create_func_ifnull::s_singleton;
1512
1348
Item*
1513
1349
Create_func_ifnull::create(Session *session, Item *arg1, Item *arg2)
1514
1350
{
1515
return new (session->mem_root) Item_func_ifnull(arg1, arg2);
1351
return new (session->mem) Item_func_ifnull(arg1, arg2);
1516
1352
}
1517
1353
1518
1354
1521
1357
Item*
1522
1358
Create_func_instr::create(Session *session, Item *arg1, Item *arg2)
1523
1359
{
1524
return new (session->mem_root) Item_func_locate(arg1, arg2);
1360
return new (session->mem) Item_func_locate(arg1, arg2);
1525
1361
}
1526
1362
1527
1363
1530
1366
Item*
1531
1367
Create_func_isnull::create(Session *session, Item *arg1)
1532
1368
{
1533
return new (session->mem_root) Item_func_isnull(arg1);
1369
return new (session->mem) Item_func_isnull(arg1);
1534
1370
}
1535
1371
1536
1372
1539
1375
Item*
1540
1376
Create_func_last_day::create(Session *session, Item *arg1)
1541
1377
{
1542
return new (session->mem_root) Item_func_last_day(arg1);
1378
return new (session->mem) Item_func_last_day(arg1);
1543
1379
}
1544
1380
1545
1381
1549
1385
Create_func_last_insert_id::create_native(Session *session, LEX_STRING name,
1550
1386
List<Item> *item_list)
1551
1387
{
1552
Item *func= NULL;
1553
int arg_count= 0;
1554
1555
if (item_list != NULL)
1556
arg_count= item_list->size();
1557
1388
int arg_count= item_list ? item_list->size() : 0;
1558
1389
switch (arg_count) {
1559
1390
case 0:
1560
{
1561
func= new (session->mem_root) Item_func_last_insert_id();
1562
break;
1563
}
1391
{
1392
return new (session->mem) Item_func_last_insert_id();
1393
}
1564
1394
case 1:
1565
{
1566
Item *param_1= item_list->pop();
1567
func= new (session->mem_root) Item_func_last_insert_id(param_1);
1568
break;
1569
}
1395
{
1396
Item *param_1= item_list->pop();
1397
return new (session->mem) Item_func_last_insert_id(param_1);
1398
}
1570
1399
default:
1571
{
1572
1400
my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1573
break;
1574
}
1575
}
1576
1577
return func;
1401
}
1402
return NULL;
1578
1403
}
1579
1404
1580
1405
1583
1408
Item*
1584
1409
Create_func_lcase::create(Session *session, Item *arg1)
1585
1410
{
1586
return new (session->mem_root) Item_func_lcase(arg1);
1411
return new (session->mem) Item_func_lcase(arg1);
1587
1412
}
1588
1413
1589
1414
1593
1418
Create_func_least::create_native(Session *session, LEX_STRING name,
1594
1419
List<Item> *item_list)
1595
1420
{
1596
int arg_count= 0;
1597
1598
if (item_list != NULL)
1599
arg_count= item_list->size();
1600
1421
int arg_count= item_list ? item_list->size() : 0;
1601
1422
if (arg_count < 2)
1602
1423
{
1603
1424
my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1604
1425
return NULL;
1605
1426
}
1606
1427
1607
return new (session->mem_root) Item_func_min(*item_list);
1428
return new (session->mem) Item_func_min(*item_list);
1608
1429
}
1609
1430
1610
1431
Create_func_load_file Create_func_load_file::s_singleton;
1612
1433
Item*
1613
1434
Create_func_load_file::create(Session *session, Item *arg1)
1614
1435
{
1615
return new (session->mem_root) Item_load_file(*session, arg1);
1436
return new (session->mem) Item_load_file(*session, arg1);
1616
1437
}
1617
1438
1618
1439
1622
1443
Create_func_locate::create_native(Session *session, LEX_STRING name,
1623
1444
List<Item> *item_list)
1624
1445
{
1625
Item *func= NULL;
1626
int arg_count= 0;
1627
1628
if (item_list != NULL)
1629
arg_count= item_list->size();
1630
1631
switch (arg_count) {
1446
int arg_count= item_list ? item_list->size() : 0;
1447
switch (arg_count)
1448
{
1632
1449
case 2:
1633
{
1634
Item *param_1= item_list->pop();
1635
Item *param_2= item_list->pop();
1636
/* Yes, parameters in that order : 2, 1 */
1637
func= new (session->mem_root) Item_func_locate(param_2, param_1);
1638
break;
1639
}
1450
{
1451
Item *param_1= item_list->pop();
1452
Item *param_2= item_list->pop();
1453
/* Yes, parameters in that order : 2, 1 */
1454
return new (session->mem) Item_func_locate(param_2, param_1);
1455
}
1640
1456
case 3:
1641
{
1642
Item *param_1= item_list->pop();
1643
Item *param_2= item_list->pop();
1644
Item *param_3= item_list->pop();
1645
/* Yes, parameters in that order : 2, 1, 3 */
1646
func= new (session->mem_root) Item_func_locate(param_2, param_1, param_3);
1647
break;
1648
}
1457
{
1458
Item *param_1= item_list->pop();
1459
Item *param_2= item_list->pop();
1460
Item *param_3= item_list->pop();
1461
/* Yes, parameters in that order : 2, 1, 3 */
1462
return new (session->mem) Item_func_locate(param_2, param_1, param_3);
1463
}
1649
1464
default:
1650
{
1651
1465
my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1652
break;
1653
}
1654
}
1655
1656
return func;
1657
}
1658
1659
Create_func_lpad Create_func_lpad::s_singleton;
1660
1661
Item*
1662
Create_func_lpad::create(Session *session, Item *arg1, Item *arg2, Item *arg3)
1663
{
1664
return new (session->mem_root) Item_func_lpad(*session, arg1, arg2, arg3);
1665
}
1666
1667
1668
Create_func_ltrim Create_func_ltrim::s_singleton;
1669
1670
Item*
1671
Create_func_ltrim::create(Session *session, Item *arg1)
1672
{
1673
return new (session->mem_root) Item_func_ltrim(arg1);
1674
}
1675
1676
1677
Create_func_makedate Create_func_makedate::s_singleton;
1678
1679
Item*
1680
Create_func_makedate::create(Session *session, Item *arg1, Item *arg2)
1681
{
1682
return new (session->mem_root) Item_func_makedate(arg1, arg2);
1683
}
1684
1466
}
1467
return NULL;
1468
}
1685
1469
1686
1470
Create_func_make_set Create_func_make_set::s_singleton;
1687
1471
1689
1473
Create_func_make_set::create_native(Session *session_arg, LEX_STRING name,
1690
1474
List<Item> *item_list)
1691
1475
{
1692
int arg_count= 0;
1693
1694
if (item_list != NULL)
1695
arg_count= item_list->size();
1696
1476
int arg_count= item_list ? item_list->size() : 0;
1697
1477
if (arg_count < 2)
1698
1478
{
1699
1479
my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1701
1481
}
1702
1482
1703
1483
Item *param_1= item_list->pop();
1704
return new (session_arg->mem_root) Item_func_make_set(*session_arg, param_1, *item_list);
1705
}
1706
1707
1708
Create_func_monthname Create_func_monthname::s_singleton;
1709
1710
Item*
1711
Create_func_monthname::create(Session *session, Item *arg1)
1712
{
1713
return new (session->mem_root) Item_func_monthname(arg1);
1714
}
1715
1716
1717
Create_func_nullif Create_func_nullif::s_singleton;
1718
1719
Item*
1720
Create_func_nullif::create(Session *session, Item *arg1, Item *arg2)
1721
{
1722
return new (session->mem_root) Item_func_nullif(arg1, arg2);
1723
}
1724
1484
return new (session_arg->mem) Item_func_make_set(*session_arg, param_1, *item_list);
1485
}
1725
1486
1726
1487
Create_func_oct Create_func_oct::s_singleton;
1727
1488
1728
1489
Item*
1729
1490
Create_func_oct::create(Session *session, Item *arg1)
1730
1491
{
1731
Item *i10= new (session->mem_root) Item_int((int32_t) 10,2);
1732
Item *i8= new (session->mem_root) Item_int((int32_t) 8,1);
1733
return new (session->mem_root) Item_func_conv(arg1, i10, i8);
1492
Item *i10= new (session->mem) Item_int((int32_t) 10,2);
1493
Item *i8= new (session->mem) Item_int((int32_t) 8,1);
1494
return new (session->mem) Item_func_conv(arg1, i10, i8);
1734
1495
}
1735
1496
1736
1497
Create_func_period_add Create_func_period_add::s_singleton;
1738
1499
Item*
1739
1500
Create_func_period_add::create(Session *session, Item *arg1, Item *arg2)
1740
1501
{
1741
return new (session->mem_root) Item_func_period_add(arg1, arg2);
1502
return new (session->mem) Item_func_period_add(arg1, arg2);
1742
1503
}
1743
1504
1744
1505
1747
1508
Item*
1748
1509
Create_func_period_diff::create(Session *session, Item *arg1, Item *arg2)
1749
1510
{
1750
return new (session->mem_root) Item_func_period_diff(arg1, arg2);
1511
return new (session->mem) Item_func_period_diff(arg1, arg2);
1751
1512
}
1752
1513
1753
1514
1756
1517
Item*
1757
1518
Create_func_pi::create(Session *session)
1758
1519
{
1759
return new (session->mem_root) Item_static_float_func("pi()", M_PI, 6, 8);
1520
return new (session->mem) Item_static_float_func("pi()", M_PI, 6, 8);
1760
1521
}
1761
1522
1762
1523
Create_func_radians Create_func_radians::s_singleton;
1764
1525
Item*
1765
1526
Create_func_radians::create(Session *session, Item *arg1)
1766
1527
{
1767
return new (session->mem_root) Item_func_units((char*) "radians", arg1,
1528
return new (session->mem) Item_func_units("radians", arg1,
1768
1529
M_PI/180, 0.0);
1769
1530
}
1770
1531
1771
1532
Create_func_round Create_func_round::s_singleton;
1772
1533
1773
Item*
1774
Create_func_round::create_native(Session *session, LEX_STRING name,
1775
List<Item> *item_list)
1534
Item* Create_func_round::create_native(Session *session, LEX_STRING name, List<Item> *item_list)
1776
1535
{
1777
Item *func= NULL;
1778
int arg_count= 0;
1779
1780
if (item_list != NULL)
1781
arg_count= item_list->size();
1782
1783
switch (arg_count) {
1536
switch (item_list ? item_list->size() : 0)
1537
{
1784
1538
case 1:
1785
1539
{
1786
1540
Item *param_1= item_list->pop();
1787
Item *i0 = new (session->mem_root) Item_int((char*)"0", 0, 1);
1788
func= new (session->mem_root) Item_func_round(param_1, i0, 0);
1789
break;
1541
Item *i0 = new (session->mem) Item_int("0", 0, 1);
1542
return new (session->mem) Item_func_round(param_1, i0, 0);
1790
1543
}
1791
1544
case 2:
1792
1545
{
1793
1546
Item *param_1= item_list->pop();
1794
1547
Item *param_2= item_list->pop();
1795
func= new (session->mem_root) Item_func_round(param_1, param_2, 0);
1796
break;
1548
return new (session->mem) Item_func_round(param_1, param_2, 0);
1797
1549
}
1798
1550
default:
1799
{
1800
1551
my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1801
break;
1802
}
1803
}
1804
1805
return func;
1806
}
1807
1808
1809
Create_func_row_count Create_func_row_count::s_singleton;
1810
1811
Item*
1812
Create_func_row_count::create(Session *session)
1813
{
1814
return new (session->mem_root) Item_func_row_count();
1815
}
1816
1817
1818
Create_func_rpad Create_func_rpad::s_singleton;
1819
1820
Item*
1821
Create_func_rpad::create(Session *session, Item *arg1, Item *arg2, Item *arg3)
1822
{
1823
return new (session->mem_root) Item_func_rpad(*session, arg1, arg2, arg3);
1824
}
1825
1826
1827
Create_func_rtrim Create_func_rtrim::s_singleton;
1828
1829
Item*
1830
Create_func_rtrim::create(Session *session, Item *arg1)
1831
{
1832
return new (session->mem_root) Item_func_rtrim(arg1);
1833
}
1834
1835
1836
Create_func_sign Create_func_sign::s_singleton;
1837
1838
Item*
1839
Create_func_sign::create(Session *session, Item *arg1)
1840
{
1841
return new (session->mem_root) Item_func_sign(arg1);
1552
}
1553
return NULL;
1842
1554
}
1843
1555
1844
1556
Create_func_space Create_func_space::s_singleton;
1856
1568
1857
1569
if (cs->mbminlen > 1)
1858
1570
{
1859
sp= new (session->mem_root) Item_string("", 0, cs, DERIVATION_COERCIBLE);
1571
sp= new (session->mem) Item_string("", 0, cs, DERIVATION_COERCIBLE);
1860
1572
sp->str_value.copy(" ", 1, cs);
1861
1573
}
1862
1574
else
1863
1575
{
1864
sp= new (session->mem_root) Item_string(" ", 1, cs, DERIVATION_COERCIBLE);
1576
sp= new (session->mem) Item_string(" ", 1, cs, DERIVATION_COERCIBLE);
1865
1577
}
1866
1578
1867
return new (session->mem_root) Item_func_repeat(*session, sp, arg1);
1868
}
1869
1870
Create_func_strcmp Create_func_strcmp::s_singleton;
1871
1872
Item*
1873
Create_func_strcmp::create(Session *session, Item *arg1, Item *arg2)
1874
{
1875
return new (session->mem_root) Item_func_strcmp(arg1, arg2);
1876
}
1877
1878
1879
Create_func_tan Create_func_tan::s_singleton;
1880
1881
Item*
1882
Create_func_tan::create(Session *session, Item *arg1)
1883
{
1884
return new (session->mem_root) Item_func_tan(arg1);
1885
}
1886
1887
1888
Create_func_time_format Create_func_time_format::s_singleton;
1889
1890
Item*
1891
Create_func_time_format::create(Session *session, Item *arg1, Item *arg2)
1892
{
1893
return new (session->mem_root) Item_func_date_format(arg1, arg2, 1);
1894
}
1895
1896
Create_func_to_days Create_func_to_days::s_singleton;
1897
1898
Item*
1899
Create_func_to_days::create(Session *session, Item *arg1)
1900
{
1901
return new (session->mem_root) Item_func_to_days(arg1);
1902
}
1903
1904
1905
Create_func_ucase Create_func_ucase::s_singleton;
1906
1907
Item*
1908
Create_func_ucase::create(Session *session, Item *arg1)
1909
{
1910
return new (session->mem_root) Item_func_ucase(arg1);
1579
return new (session->mem) Item_func_repeat(*session, sp, arg1);
1911
1580
}
1912
1581
1913
1582
Create_func_unix_timestamp Create_func_unix_timestamp::s_singleton;
1916
1585
Create_func_unix_timestamp::create_native(Session *session, LEX_STRING name,
1917
1586
List<Item> *item_list)
1918
1587
{
1919
Item *func= NULL;
1920
int arg_count= 0;
1921
1922
if (item_list != NULL)
1923
arg_count= item_list->size();
1924
1925
switch (arg_count) {
1588
switch (item_list ? item_list->size() : 0)
1589
{
1926
1590
case 0:
1927
{
1928
func= new (session->mem_root) Item_func_unix_timestamp();
1929
break;
1930
}
1591
return new (session->mem) Item_func_unix_timestamp();
1931
1592
case 1:
1932
{
1933
Item *param_1= item_list->pop();
1934
func= new (session->mem_root) Item_func_unix_timestamp(param_1);
1935
break;
1936
}
1593
return new (session->mem) Item_func_unix_timestamp(item_list->pop());
1937
1594
default:
1938
{
1939
1595
my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1940
break;
1941
}
1942
}
1943
1944
return func;
1945
}
1946
1947
1948
Create_func_weekday Create_func_weekday::s_singleton;
1949
1950
Item*
1951
Create_func_weekday::create(Session *session, Item *arg1)
1952
{
1953
return new (session->mem_root) Item_func_weekday(arg1, 0);
1954
}
1596
}
1597
return NULL;
1598
}
1599
1955
1600
1956
1601
struct Native_func_registry
1957
1602
{
2047
1692
2048
1693
Item* create_func_char_cast(Session *session, Item *a, int len, const charset_info_st * const cs)
2049
1694
{
2050
return new (session->mem_root) Item_char_typecast(a, len, cs ? cs : session->variables.getCollation());
1695
return new (session->mem) Item_char_typecast(a, len, cs ? cs : session->variables.getCollation());
2051
1696
}
2052
1697
2053
Item* create_func_cast(Session *session, Item *a, Cast_target cast_type,
2054
const char *c_len, const char *c_dec,
2055
const charset_info_st * const cs)
1698
Item* create_func_cast(Session *session, Item *a, Cast_target cast_type, const char *c_len, const char *c_dec, const charset_info_st * const cs)
2056
1699
{
2057
Item *res= NULL;
2058
uint32_t len;
2059
uint32_t dec;
2060
2061
switch (cast_type) {
1700
switch (cast_type)
1701
{
2062
1702
case ITEM_CAST_SIGNED:
2063
res= new (session->mem_root) function::cast::Signed(a);
2064
break;
2065
1703
return new (session->mem) function::cast::Signed(a);
2066
1704
case ITEM_CAST_UNSIGNED:
2067
res= new (session->mem_root) function::cast::Unsigned(a);
2068
break;
2069
1705
return new (session->mem) function::cast::Unsigned(a);
2070
1706
case ITEM_CAST_BINARY:
2071
res= new (session->mem_root) Item_func_binary(a);
2072
break;
2073
1707
return new (session->mem) Item_func_binary(a);
2074
1708
case ITEM_CAST_BOOLEAN:
2075
res= new (session->mem_root) function::cast::Boolean(a);
2076
break;
2077
1709
return new (session->mem) function::cast::Boolean(a);
2078
1710
case ITEM_CAST_TIME:
2079
res= new (session->mem_root) function::cast::Time(a);
2080
break;
2081
1711
return new (session->mem) function::cast::Time(a);
2082
1712
case ITEM_CAST_DATE:
2083
res= new (session->mem_root) Item_date_typecast(a);
2084
break;
2085
1713
return new (session->mem) Item_date_typecast(a);
2086
1714
case ITEM_CAST_DATETIME:
2087
res= new (session->mem_root) Item_datetime_typecast(a);
2088
break;
2089
1715
return new (session->mem) Item_datetime_typecast(a);
2090
1716
case ITEM_CAST_DECIMAL:
2091
1717
{
2092
len= c_len ? atoi(c_len) : 0;
2093
dec= c_dec ? atoi(c_dec) : 0;
1718
uint32_t len= c_len ? atoi(c_len) : 0;
1719
uint32_t dec= c_dec ? atoi(c_dec) : 0;
2094
1720
class_decimal_trim(&len, &dec);
2095
1721
if (len < dec)
2096
1722
{
2099
1725
}
2100
1726
if (len > DECIMAL_MAX_PRECISION)
2101
1727
{
2102
my_error(ER_TOO_BIG_PRECISION, MYF(0), len, a->name,
2103
DECIMAL_MAX_PRECISION);
1728
my_error(ER_TOO_BIG_PRECISION, MYF(0), len, a->name, DECIMAL_MAX_PRECISION);
2104
1729
return 0;
2105
1730
}
2106
1731
if (dec > DECIMAL_MAX_SCALE)
2107
1732
{
2108
my_error(ER_TOO_BIG_SCALE, MYF(0), dec, a->name,
2109
DECIMAL_MAX_SCALE);
1733
my_error(ER_TOO_BIG_SCALE, MYF(0), dec, a->name, DECIMAL_MAX_SCALE);
2110
1734
return 0;
2111
1735
}
2112
res= new (session->mem_root) Item_decimal_typecast(a, len, dec);
2113
break;
1736
return new (session->mem) Item_decimal_typecast(a, len, dec);
2114
1737
}
2115
1738
case ITEM_CAST_CHAR:
2116
{
2117
len= c_len ? atoi(c_len) : -1;
2118
res= create_func_char_cast(session, a, len, cs);
2119
break;
2120
}
1739
return create_func_char_cast(session, a, c_len ? atoi(c_len) : -1, cs);
2121
1740
}
2122
2123
return res;
1741
return NULL;
2124
1742
}
2125
1743
2126
1744
} /* namespace drizzled */
Loggerhead is a web-based interface for Breezy
Version: 2.0.1