~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/create.cc

  • Committer: Mark Atwood
  • Date: 2011-12-15 23:13:18 UTC
  • mfrom: (2465.3.1 rf3)
  • Revision ID: me@mark.atwood.name-20111215231318-mt2y2q4s5ydp79q3
mergeĀ lp:~olafvdspek/drizzle/refactor14

Show diffs side-by-side

added added

removed removed

Lines of Context:
128
128
class Create_native_func : public Create_func
129
129
{
130
130
public:
131
 
  virtual Item* create(Session* session, lex_string_t name, List<Item>* item_list)
 
131
  virtual Item* create(Session* session, str_ref name, List<Item>* item_list)
132
132
  {
133
133
    if (item_list && has_named_parameters(*item_list))
134
134
    {
135
 
      my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), name.str);
 
135
      my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), name.data());
136
136
      return NULL;
137
137
    }
138
138
    return create_native(session, name, item_list);
145
145
    @param item_list The function parameters, none of which are named
146
146
    @return An item representing the function call
147
147
  */
148
 
  virtual Item* create_native(Session*, lex_string_t name, List<Item>*) = 0;
 
148
  virtual Item* create_native(Session*, str_ref name, List<Item>*) = 0;
149
149
};
150
150
 
151
151
 
156
156
class Create_func_arg0 : public Create_func
157
157
{
158
158
public:
159
 
  virtual Item* create(Session *session, lex_string_t name, List<Item> *item_list);
 
159
  virtual Item* create(Session *session, str_ref name, List<Item> *item_list);
160
160
 
161
161
  /**
162
162
    Builder method, with no arguments.
174
174
class Create_func_arg1 : public Create_func
175
175
{
176
176
public:
177
 
  virtual Item* create(Session *session, lex_string_t name, List<Item> *item_list);
 
177
  virtual Item* create(Session *session, str_ref name, List<Item> *item_list);
178
178
 
179
179
  /**
180
180
    Builder method, with one argument.
193
193
class Create_func_arg2 : public Create_func
194
194
{
195
195
public:
196
 
  virtual Item* create(Session *session, lex_string_t name, List<Item> *item_list);
 
196
  virtual Item* create(Session *session, str_ref name, List<Item> *item_list);
197
197
 
198
198
  /**
199
199
    Builder method, with two arguments.
213
213
class Create_func_arg3 : public Create_func
214
214
{
215
215
public:
216
 
  virtual Item* create(Session *session, lex_string_t name, List<Item> *item_list);
 
216
  virtual Item* create(Session *session, str_ref name, List<Item> *item_list);
217
217
 
218
218
  /**
219
219
    Builder method, with three arguments.
246
246
  virtual Item* create(Session *session, Item *arg1);
247
247
 
248
248
  static Create_func_bin s_singleton;
249
 
 
250
 
protected:
251
 
  Create_func_bin() {}
252
249
};
253
250
 
254
251
class Create_func_concat : public Create_native_func
255
252
{
256
253
public:
257
 
  virtual Item* create_native(Session *session, lex_string_t name, List<Item> *item_list);
 
254
  virtual Item* create_native(Session *session, str_ref name, List<Item> *item_list);
258
255
 
259
256
  static Create_func_concat s_singleton;
260
 
 
261
 
protected:
262
 
  Create_func_concat() {}
263
257
};
264
258
 
265
259
 
266
260
class Create_func_concat_ws : public Create_native_func
267
261
{
268
262
public:
269
 
  virtual Item* create_native(Session *session, lex_string_t name, List<Item> *item_list);
 
263
  virtual Item* create_native(Session *session, str_ref name, List<Item> *item_list);
270
264
 
271
265
  static Create_func_concat_ws s_singleton;
272
 
 
273
 
protected:
274
 
  Create_func_concat_ws() {}
275
266
};
276
267
 
277
268
 
286
277
  }
287
278
 
288
279
  static Create_func_conv s_singleton;
289
 
protected:
290
 
  Create_func_conv() {}
291
280
};
292
281
 
293
282
Create_func_conv Create_func_conv::s_singleton;
300
289
  virtual Item* create(Session *session, Item *arg1);
301
290
 
302
291
  static Create_func_cot s_singleton;
303
 
 
304
 
protected:
305
 
  Create_func_cot() {}
306
292
};
307
293
 
308
294
class Create_func_date_format : public Create_func_arg2
316
302
  }
317
303
 
318
304
  static Create_func_date_format s_singleton;
319
 
protected:
320
 
  Create_func_date_format() {}
321
305
};
322
306
 
323
307
Create_func_date_format Create_func_date_format::s_singleton;
330
314
  virtual Item* create(Session *session, Item *arg1, Item *arg2);
331
315
 
332
316
  static Create_func_datediff s_singleton;
333
 
 
334
 
protected:
335
 
  Create_func_datediff() {}
336
317
};
337
318
 
338
319
 
347
328
  }
348
329
 
349
330
  static Create_func_dayname s_singleton;
350
 
 
351
 
protected:
352
 
  Create_func_dayname() {}
353
331
};
354
332
 
355
333
Create_func_dayname Create_func_dayname::s_singleton;
365
343
  }
366
344
 
367
345
  static Create_func_dayofmonth s_singleton;
368
 
protected:
369
 
  Create_func_dayofmonth() {}
370
346
};
371
347
 
372
348
Create_func_dayofmonth Create_func_dayofmonth::s_singleton;
382
358
  }
383
359
 
384
360
  static Create_func_dayofweek s_singleton;
385
 
protected:
386
 
  Create_func_dayofweek() {}
387
361
};
388
362
 
389
363
Create_func_dayofweek Create_func_dayofweek::s_singleton;
399
373
  }
400
374
 
401
375
  static Create_func_dayofyear s_singleton;
402
 
protected:
403
 
  Create_func_dayofyear() {}
404
376
};
405
377
 
406
378
Create_func_dayofyear Create_func_dayofyear::s_singleton;
413
385
  virtual Item* create(Session *session, Item *arg1, Item *arg2);
414
386
 
415
387
  static Create_func_decode s_singleton;
416
 
 
417
 
protected:
418
 
  Create_func_decode() {}
419
388
};
420
389
 
421
390
 
430
399
  }
431
400
 
432
401
  static Create_func_degrees s_singleton;
433
 
protected:
434
 
  Create_func_degrees() {}
435
402
};
436
403
 
437
404
Create_func_degrees Create_func_degrees::s_singleton;
440
407
{
441
408
 
442
409
public:
443
 
  virtual Item* create_native(Session *session, lex_string_t name, List<Item> *item_list);
 
410
  virtual Item* create_native(Session *session, str_ref name, List<Item> *item_list);
444
411
 
445
412
  static Create_func_export_set s_singleton;
446
 
 
447
 
protected:
448
 
  Create_func_export_set() {}
449
413
};
450
414
 
451
415
 
452
416
class Create_func_field : public Create_native_func
453
417
{
454
418
public:
455
 
  virtual Item* create_native(Session *session, lex_string_t name, List<Item> *item_list);
 
419
  virtual Item* create_native(Session *session, str_ref name, List<Item> *item_list);
456
420
 
457
421
  static Create_func_field s_singleton;
458
 
 
459
 
protected:
460
 
  Create_func_field() {}
461
422
};
462
423
 
463
424
 
466
427
public:
467
428
  using Create_func_arg2::create;
468
429
 
469
 
  virtual Item* create(Session *session, Item *arg1, Item *arg2);
 
430
  virtual Item* create(Session *session, Item *arg1, Item *arg2)
 
431
  {
 
432
    return new (session->mem) Item_func_find_in_set(arg1, arg2);
 
433
  }
470
434
 
471
435
  static Create_func_find_in_set s_singleton;
472
 
 
473
 
protected:
474
 
  Create_func_find_in_set() {}
475
436
};
476
437
 
477
438
class Create_func_found_rows : public Create_func_arg0
479
440
public:
480
441
  using Create_func_arg0::create;
481
442
 
482
 
  virtual Item* create(Session *session);
 
443
  virtual Item* create(Session *session)
 
444
  {
 
445
    return new (session->mem) Item_func_found_rows();
 
446
  }
483
447
 
484
448
  static Create_func_found_rows s_singleton;
485
 
 
486
 
protected:
487
 
  Create_func_found_rows() {}
488
449
};
489
450
 
490
451
 
493
454
public:
494
455
  using Create_func_arg1::create;
495
456
 
496
 
  virtual Item* create(Session *session, Item *arg1);
 
457
  virtual Item* create(Session *session, Item *arg1)
 
458
  {
 
459
    return new (session->mem) Item_func_from_days(arg1);
 
460
  }
497
461
 
498
462
  static Create_func_from_days s_singleton;
499
 
 
500
 
protected:
501
 
  Create_func_from_days() {}
502
463
};
503
464
 
504
465
 
505
466
class Create_func_from_unixtime : public Create_native_func
506
467
{
507
468
public:
508
 
  virtual Item* create_native(Session *session, lex_string_t name, List<Item> *item_list);
 
469
  virtual Item* create_native(Session *session, str_ref name, List<Item> *item_list);
509
470
 
510
471
  static Create_func_from_unixtime s_singleton;
511
 
 
512
 
protected:
513
 
  Create_func_from_unixtime() {}
514
472
};
515
473
 
516
474
 
517
475
class Create_func_greatest : public Create_native_func
518
476
{
519
477
public:
520
 
  virtual Item* create_native(Session *session, lex_string_t name, List<Item> *item_list);
 
478
  virtual Item* create_native(Session *session, str_ref name, List<Item> *item_list);
521
479
 
522
480
  static Create_func_greatest s_singleton;
523
 
 
524
 
protected:
525
 
  Create_func_greatest() {}
526
481
};
527
482
 
528
483
 
531
486
public:
532
487
  using Create_func_arg2::create;
533
488
 
534
 
  virtual Item* create(Session *session, Item *arg1, Item *arg2);
 
489
  virtual Item* create(Session *session, Item *arg1, Item *arg2)
 
490
  {
 
491
    return new (session->mem) Item_func_ifnull(arg1, arg2);
 
492
  }
535
493
 
536
494
  static Create_func_ifnull s_singleton;
537
 
 
538
 
protected:
539
 
  Create_func_ifnull() {}
540
495
};
541
496
 
542
497
 
545
500
public:
546
501
  using Create_func_arg2::create;
547
502
 
548
 
  virtual Item* create(Session *session, Item *arg1, Item *arg2);
 
503
  virtual Item* create(Session *session, Item *arg1, Item *arg2)
 
504
  {
 
505
    return new (session->mem) Item_func_locate(arg1, arg2);
 
506
  }
549
507
 
550
508
  static Create_func_instr s_singleton;
551
 
 
552
 
protected:
553
 
  Create_func_instr() {}
554
509
};
555
510
 
556
511
 
559
514
public:
560
515
  using Create_func_arg1::create;
561
516
 
562
 
  virtual Item* create(Session *session, Item *arg1);
 
517
  virtual Item* create(Session *session, Item *arg1)
 
518
  {
 
519
    return new (session->mem) Item_func_isnull(arg1);
 
520
  }
563
521
 
564
522
  static Create_func_isnull s_singleton;
565
 
 
566
 
protected:
567
 
  Create_func_isnull() {}
568
523
};
569
524
 
570
525
 
573
528
public:
574
529
  using Create_func_arg1::create;
575
530
 
576
 
  virtual Item* create(Session *session, Item *arg1);
 
531
  virtual Item* create(Session *session, Item *arg1)
 
532
  {
 
533
    return new (session->mem) Item_func_last_day(arg1);
 
534
  }
577
535
 
578
536
  static Create_func_last_day s_singleton;
579
 
 
580
 
protected:
581
 
  Create_func_last_day() {}
582
537
};
583
538
 
584
539
 
585
540
class Create_func_last_insert_id : public Create_native_func
586
541
{
587
542
public:
588
 
  virtual Item* create_native(Session *session, lex_string_t name, List<Item> *item_list);
 
543
  virtual Item* create_native(Session *session, str_ref name, List<Item> *item_list);
589
544
 
590
545
  static Create_func_last_insert_id s_singleton;
591
 
 
592
 
protected:
593
 
  Create_func_last_insert_id() {}
594
546
};
595
547
 
596
548
 
599
551
public:
600
552
  using Create_func_arg1::create;
601
553
 
602
 
  virtual Item* create(Session *session, Item *arg1);
 
554
  virtual Item* create(Session *session, Item *arg1)
 
555
  {
 
556
    return new (session->mem) Item_func_lcase(arg1);
 
557
  }
603
558
 
604
559
  static Create_func_lcase s_singleton;
605
 
 
606
 
protected:
607
 
  Create_func_lcase() {}
608
560
};
609
561
 
610
562
 
611
563
class Create_func_least : public Create_native_func
612
564
{
613
565
public:
614
 
  virtual Item* create_native(Session *session, lex_string_t name, List<Item> *item_list);
 
566
  virtual Item* create_native(Session *session, str_ref name, List<Item> *item_list);
615
567
 
616
568
  static Create_func_least s_singleton;
617
 
 
618
 
protected:
619
 
  Create_func_least() {}
620
569
};
621
570
 
622
571
class Create_func_load_file : public Create_func_arg1
624
573
public:
625
574
  using Create_func_arg1::create;
626
575
 
627
 
  virtual Item* create(Session *session, Item *arg1);
 
576
  virtual Item* create(Session *session, Item *arg1)
 
577
  {
 
578
    return new (session->mem) Item_load_file(*session, arg1);
 
579
  }
628
580
 
629
581
  static Create_func_load_file s_singleton;
630
 
 
631
 
protected:
632
 
  Create_func_load_file() {}
633
582
};
634
583
 
635
 
 
636
584
class Create_func_locate : public Create_native_func
637
585
{
638
586
public:
639
 
  virtual Item* create_native(Session *session, lex_string_t name, List<Item> *item_list);
 
587
  virtual Item* create_native(Session *session, str_ref name, List<Item> *item_list);
640
588
 
641
589
  static Create_func_locate s_singleton;
642
 
 
643
 
protected:
644
 
  Create_func_locate() {}
645
590
};
646
591
 
647
 
 
648
592
class Create_func_lpad : public Create_func_arg3
649
593
{
650
594
public:
656
600
  }
657
601
 
658
602
  static Create_func_lpad s_singleton;
659
 
protected:
660
 
  Create_func_lpad() {}
661
603
};
662
604
 
663
605
Create_func_lpad Create_func_lpad::s_singleton;
673
615
  }
674
616
 
675
617
  static Create_func_ltrim s_singleton;
676
 
protected:
677
 
  Create_func_ltrim() {}
678
618
};
679
619
 
680
620
Create_func_ltrim Create_func_ltrim::s_singleton;
690
630
  }
691
631
 
692
632
  static Create_func_makedate s_singleton;
693
 
protected:
694
 
  Create_func_makedate() {}
695
633
};
696
634
 
697
635
Create_func_makedate Create_func_makedate::s_singleton;
699
637
class Create_func_make_set : public Create_native_func
700
638
{
701
639
public:
702
 
  virtual Item* create_native(Session *session, lex_string_t name, List<Item> *item_list);
 
640
  virtual Item* create_native(Session *session, str_ref name, List<Item> *item_list);
703
641
 
704
642
  static Create_func_make_set s_singleton;
705
 
 
706
 
protected:
707
 
  Create_func_make_set() {}
708
643
};
709
644
 
710
645
 
719
654
  }
720
655
 
721
656
  static Create_func_monthname s_singleton;
722
 
protected:
723
 
  Create_func_monthname() {}
724
657
};
725
658
 
726
659
Create_func_monthname Create_func_monthname::s_singleton;
733
666
  virtual Item* create(Session *session, Item *arg1, Item *arg2);
734
667
 
735
668
  static Create_func_name_const s_singleton;
736
 
 
737
 
protected:
738
 
  Create_func_name_const() {}
739
669
};
740
670
 
741
671
 
750
680
  }
751
681
 
752
682
  static Create_func_nullif s_singleton;
753
 
protected:
754
 
  Create_func_nullif() {}
755
683
};
756
684
 
757
685
Create_func_nullif Create_func_nullif::s_singleton;
764
692
  virtual Item* create(Session *session, Item *arg1);
765
693
 
766
694
  static Create_func_oct s_singleton;
767
 
 
768
 
protected:
769
 
  Create_func_oct() {}
770
695
};
771
696
 
772
697
class Create_func_period_add : public Create_func_arg2
774
699
public:
775
700
  using Create_func_arg2::create;
776
701
 
777
 
  virtual Item* create(Session *session, Item *arg1, Item *arg2);
 
702
  virtual Item* create(Session *session, Item *arg1, Item *arg2)
 
703
  {
 
704
    return new (session->mem) Item_func_period_add(arg1, arg2);
 
705
  }
778
706
 
779
707
  static Create_func_period_add s_singleton;
780
 
 
781
 
protected:
782
 
  Create_func_period_add() {}
783
708
};
784
709
 
785
710
 
788
713
public:
789
714
  using Create_func_arg2::create;
790
715
 
791
 
  virtual Item* create(Session *session, Item *arg1, Item *arg2);
 
716
  virtual Item* create(Session *session, Item *arg1, Item *arg2)
 
717
  {
 
718
    return new (session->mem) Item_func_period_diff(arg1, arg2);
 
719
  }
792
720
 
793
721
  static Create_func_period_diff s_singleton;
794
 
 
795
 
protected:
796
 
  Create_func_period_diff() {}
797
722
};
798
723
 
799
724
 
802
727
public:
803
728
  using Create_func_arg0::create;
804
729
 
805
 
  virtual Item* create(Session *session);
 
730
  virtual Item* create(Session *session)
 
731
  {
 
732
    return new (session->mem) Item_static_float_func("pi()", M_PI, 6, 8);
 
733
  }
806
734
 
807
735
  static Create_func_pi s_singleton;
808
 
 
809
 
protected:
810
 
  Create_func_pi() {}
811
736
};
812
737
 
813
738
class Create_func_radians : public Create_func_arg1
815
740
public:
816
741
  using Create_func_arg1::create;
817
742
 
818
 
  virtual Item* create(Session *session, Item *arg1);
 
743
  virtual Item* create(Session *session, Item *arg1)
 
744
  {
 
745
    return new (session->mem) Item_func_units("radians", arg1, M_PI/180, 0.0);
 
746
  }
819
747
 
820
748
  static Create_func_radians s_singleton;
821
 
protected:
822
 
  Create_func_radians() {}
823
749
};
824
750
 
825
751
 
826
752
class Create_func_round : public Create_native_func
827
753
{
828
754
public:
829
 
  virtual Item* create_native(Session *session, lex_string_t name, List<Item> *item_list);
 
755
  virtual Item* create_native(Session *session, str_ref name, List<Item> *item_list);
830
756
 
831
757
  static Create_func_round s_singleton;
832
 
protected:
833
 
  Create_func_round() {}
834
758
};
835
759
 
836
760
 
845
769
  }
846
770
 
847
771
  static Create_func_row_count s_singleton;
848
 
protected:
849
 
  Create_func_row_count() {}
850
772
};
851
773
 
852
774
Create_func_row_count Create_func_row_count::s_singleton;
862
784
  }
863
785
 
864
786
  static Create_func_rpad s_singleton;
865
 
protected:
866
 
  Create_func_rpad() {}
867
787
};
868
788
 
869
789
Create_func_rpad Create_func_rpad::s_singleton;
879
799
  }
880
800
 
881
801
  static Create_func_rtrim s_singleton;
882
 
 
883
 
protected:
884
 
  Create_func_rtrim() {}
885
802
};
886
803
 
887
804
Create_func_rtrim Create_func_rtrim::s_singleton;
897
814
  }
898
815
 
899
816
  static Create_func_sign s_singleton;
900
 
protected:
901
 
  Create_func_sign() {}
902
817
};
903
818
 
904
819
Create_func_sign Create_func_sign::s_singleton;
911
826
  virtual Item* create(Session *session, Item *arg1);
912
827
 
913
828
  static Create_func_space s_singleton;
914
 
protected:
915
 
  Create_func_space() {}
916
829
};
917
830
 
918
831
class Create_func_strcmp : public Create_func_arg2
926
839
  }
927
840
  
928
841
  static Create_func_strcmp s_singleton;
929
 
protected:
930
 
  Create_func_strcmp() {}
931
842
};
932
843
 
933
844
Create_func_strcmp Create_func_strcmp::s_singleton;
943
854
  }
944
855
 
945
856
  static Create_func_tan s_singleton;
946
 
protected:
947
 
  Create_func_tan() {}
948
857
};
949
858
 
950
859
Create_func_tan Create_func_tan::s_singleton;
960
869
  }
961
870
 
962
871
  static Create_func_time_format s_singleton;
963
 
protected:
964
 
  Create_func_time_format() {}
965
872
};
966
873
 
967
874
Create_func_time_format Create_func_time_format::s_singleton;
977
884
  }
978
885
 
979
886
  static Create_func_to_days s_singleton;
980
 
protected:
981
 
  Create_func_to_days() {}
982
887
};
983
888
 
984
889
Create_func_to_days Create_func_to_days::s_singleton;
994
899
  }
995
900
 
996
901
  static Create_func_ucase s_singleton;
997
 
protected:
998
 
  Create_func_ucase() {}
999
902
};
1000
903
 
1001
904
Create_func_ucase Create_func_ucase::s_singleton;
1003
906
class Create_func_unix_timestamp : public Create_native_func
1004
907
{
1005
908
public:
1006
 
  virtual Item* create_native(Session *session, lex_string_t name, List<Item> *item_list);
 
909
  virtual Item* create_native(Session *session, str_ref name, List<Item> *item_list);
1007
910
 
1008
911
  static Create_func_unix_timestamp s_singleton;
1009
 
protected:
1010
 
  Create_func_unix_timestamp() {}
1011
912
};
1012
913
 
1013
914
 
1022
923
  }
1023
924
 
1024
925
  static Create_func_weekday s_singleton;
1025
 
protected:
1026
 
  Create_func_weekday() {}
1027
926
};
1028
927
 
1029
928
Create_func_weekday Create_func_weekday::s_singleton;
1036
935
 
1037
936
Create_udf_func Create_udf_func::s_singleton;
1038
937
 
1039
 
Item* Create_udf_func::create(Session *session, lex_string_t name, List<Item> *item_list)
 
938
Item* Create_udf_func::create(Session *session, str_ref name, List<Item> *item_list)
1040
939
{
1041
 
  return create(session, plugin::Function::get(std::string(name.str, name.length)), item_list);
 
940
  return create(session, plugin::Function::get(to_string(name)), item_list);
1042
941
}
1043
942
 
1044
943
Item* Create_udf_func::create(Session *session, const plugin::Function *udf, List<Item> *item_list)
1045
944
{
1046
945
  assert(udf);
1047
 
  int arg_count= item_list ? item_list->size() : 0;
1048
946
  Item_func* func= (*udf)(&session->mem);
1049
 
  if (!func->check_argument_count(arg_count))
 
947
  if (!func->check_argument_count(item_list ? item_list->size() : 0))
1050
948
  {
1051
949
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), func->func_name());
1052
950
    return NULL;
1056
954
  return func;
1057
955
}
1058
956
 
1059
 
Item* Create_func_arg0::create(Session *session, lex_string_t name, List<Item> *item_list)
 
957
Item* Create_func_arg0::create(Session *session, str_ref name, List<Item> *item_list)
1060
958
{
1061
 
  if (item_list && item_list->size())
1062
 
  {
1063
 
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1064
 
    return NULL;
1065
 
  }
1066
 
  return create(session);
 
959
  if (not item_list || not item_list->size())
 
960
    return create(session);
 
961
  my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());
 
962
  return NULL;
1067
963
}
1068
964
 
1069
 
Item* Create_func_arg1::create(Session *session, lex_string_t name, List<Item> *item_list)
 
965
Item* Create_func_arg1::create(Session *session, str_ref name, List<Item> *item_list)
1070
966
{
1071
 
  int arg_count= item_list ? item_list->size() : 0;
1072
 
  if (arg_count != 1)
 
967
  if (not item_list || item_list->size() != 1)
1073
968
  {
1074
 
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
 
969
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());
1075
970
    return NULL;
1076
971
  }
1077
972
 
1078
973
  Item *param_1= item_list->pop();
1079
 
 
1080
 
  if (! param_1->is_autogenerated_name)
1081
 
  {
1082
 
    my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), name.str);
1083
 
    return NULL;
1084
 
  }
1085
 
 
1086
 
  return create(session, param_1);
 
974
  if (param_1->is_autogenerated_name)
 
975
    return create(session, param_1);
 
976
  my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), name.data());
 
977
  return NULL;
1087
978
}
1088
979
 
1089
 
 
1090
 
Item*
1091
 
Create_func_arg2::create(Session *session, lex_string_t name, List<Item> *item_list)
 
980
Item* Create_func_arg2::create(Session *session, str_ref name, List<Item> *item_list)
1092
981
{
1093
 
  int arg_count= item_list ? item_list->size() : 0;
1094
 
  if (arg_count != 2)
 
982
  if (not item_list || item_list->size() != 2)
1095
983
  {
1096
 
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
 
984
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());
1097
985
    return NULL;
1098
986
  }
1099
987
 
1100
988
  Item *param_1= item_list->pop();
1101
989
  Item *param_2= item_list->pop();
1102
990
 
1103
 
  if (   (! param_1->is_autogenerated_name)
1104
 
      || (! param_2->is_autogenerated_name))
1105
 
  {
1106
 
    my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), name.str);
1107
 
    return NULL;
1108
 
  }
1109
 
 
 
991
  if (param_1->is_autogenerated_name
 
992
    && param_2->is_autogenerated_name)
1110
993
  return create(session, param_1, param_2);
 
994
  my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), name.data());
 
995
  return NULL;
1111
996
}
1112
997
 
1113
 
 
1114
 
Item*
1115
 
Create_func_arg3::create(Session *session, lex_string_t name, List<Item> *item_list)
 
998
Item* Create_func_arg3::create(Session *session, str_ref name, List<Item> *item_list)
1116
999
{
1117
 
  int arg_count= item_list ? item_list->size() : 0;
1118
 
  if (arg_count != 3)
 
1000
  if (not item_list || item_list->size() != 3)
1119
1001
  {
1120
 
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
 
1002
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());
1121
1003
    return NULL;
1122
1004
  }
1123
1005
 
1125
1007
  Item *param_2= item_list->pop();
1126
1008
  Item *param_3= item_list->pop();
1127
1009
 
1128
 
  if (   (! param_1->is_autogenerated_name)
1129
 
      || (! param_2->is_autogenerated_name)
1130
 
      || (! param_3->is_autogenerated_name))
1131
 
  {
1132
 
    my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), name.str);
1133
 
    return NULL;
1134
 
  }
1135
 
 
1136
 
  return create(session, param_1, param_2, param_3);
 
1010
  if (param_1->is_autogenerated_name
 
1011
    && param_2->is_autogenerated_name
 
1012
    && param_3->is_autogenerated_name)
 
1013
    return create(session, param_1, param_2, param_3);
 
1014
  my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), name.data());
 
1015
  return NULL;
1137
1016
}
1138
1017
 
1139
1018
Create_func_bin Create_func_bin::s_singleton;
1140
1019
 
1141
 
Item*
1142
 
Create_func_bin::create(Session *session, Item *arg1)
 
1020
Item* Create_func_bin::create(Session *session, Item *arg1)
1143
1021
{
1144
1022
  Item *i10= new (session->mem) Item_int(10, 2);
1145
1023
  Item *i2= new (session->mem) Item_int(2, 1);
1148
1026
 
1149
1027
Create_func_concat Create_func_concat::s_singleton;
1150
1028
 
1151
 
Item*
1152
 
Create_func_concat::create_native(Session *session, lex_string_t name, List<Item> *item_list)
 
1029
Item* Create_func_concat::create_native(Session *session, str_ref name, List<Item> *item_list)
1153
1030
{
1154
 
  int arg_count= item_list ? item_list->size() : 0;
1155
 
  if (arg_count < 1)
1156
 
  {
1157
 
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1158
 
    return NULL;
1159
 
  }
1160
 
 
1161
 
  return new (session->mem) Item_func_concat(*session, *item_list);
 
1031
  if (item_list && item_list->size() >= 1)
 
1032
    return new (session->mem) Item_func_concat(*session, *item_list);
 
1033
  my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());
 
1034
  return NULL;
1162
1035
}
1163
1036
 
1164
 
 
1165
1037
Create_func_concat_ws Create_func_concat_ws::s_singleton;
1166
1038
 
1167
 
Item*
1168
 
Create_func_concat_ws::create_native(Session *session, lex_string_t name,
1169
 
                                     List<Item> *item_list)
 
1039
Item* Create_func_concat_ws::create_native(Session *session, str_ref name, List<Item> *item_list)
1170
1040
{
1171
 
  int arg_count= item_list ? item_list->size() : 0;
1172
1041
  /* "WS" stands for "With Separator": this function takes 2+ arguments */
1173
 
  if (arg_count < 2)
1174
 
  {
1175
 
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1176
 
    return NULL;
1177
 
  }
1178
 
 
1179
 
  return new (session->mem) Item_func_concat_ws(*session, *item_list);
 
1042
  if (item_list && item_list->size() >= 2)
 
1043
    return new (session->mem) Item_func_concat_ws(*session, *item_list);
 
1044
  my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());
 
1045
  return NULL;
1180
1046
}
1181
1047
 
1182
1048
Create_func_cot Create_func_cot::s_singleton;
1202
1068
Create_func_export_set Create_func_export_set::s_singleton;
1203
1069
 
1204
1070
Item*
1205
 
Create_func_export_set::create_native(Session *session, lex_string_t name, List<Item> *item_list)
 
1071
Create_func_export_set::create_native(Session *session, str_ref name, List<Item> *item_list)
1206
1072
{
1207
1073
  switch (item_list ? item_list->size() : 0) 
1208
1074
  {
1230
1096
      Item *param_5= item_list->pop();
1231
1097
      return new (session->mem) Item_func_export_set(param_1, param_2, param_3, param_4, param_5);
1232
1098
    }
1233
 
  default:
1234
 
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1235
1099
  }
 
1100
  my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());
1236
1101
  return NULL;
1237
1102
}
1238
1103
 
1239
1104
 
1240
1105
Create_func_field Create_func_field::s_singleton;
1241
1106
 
1242
 
Item*
1243
 
Create_func_field::create_native(Session *session, lex_string_t name,
1244
 
                                 List<Item> *item_list)
 
1107
Item* Create_func_field::create_native(Session *session, str_ref name, List<Item> *item_list)
1245
1108
{
1246
 
  int arg_count= item_list ? item_list->size() : 0;
1247
 
  if (arg_count < 2)
1248
 
  {
1249
 
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1250
 
    return NULL;
1251
 
  }
1252
 
 
1253
 
  return new (session->mem) Item_func_field(*item_list);
 
1109
  if (item_list && item_list->size() >= 2)
 
1110
    return new (session->mem) Item_func_field(*item_list);
 
1111
  my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());
 
1112
  return NULL;
1254
1113
}
1255
1114
 
1256
 
 
1257
1115
Create_func_find_in_set Create_func_find_in_set::s_singleton;
1258
 
 
1259
 
Item*
1260
 
Create_func_find_in_set::create(Session *session, Item *arg1, Item *arg2)
1261
 
{
1262
 
  return new (session->mem) Item_func_find_in_set(arg1, arg2);
1263
 
}
1264
 
 
1265
1116
Create_func_found_rows Create_func_found_rows::s_singleton;
1266
 
 
1267
 
Item*
1268
 
Create_func_found_rows::create(Session *session)
1269
 
{
1270
 
  return new (session->mem) Item_func_found_rows();
1271
 
}
1272
 
 
1273
 
 
1274
1117
Create_func_from_days Create_func_from_days::s_singleton;
1275
 
 
1276
 
Item*
1277
 
Create_func_from_days::create(Session *session, Item *arg1)
1278
 
{
1279
 
  return new (session->mem) Item_func_from_days(arg1);
1280
 
}
1281
 
 
1282
 
 
1283
1118
Create_func_from_unixtime Create_func_from_unixtime::s_singleton;
1284
1119
 
1285
 
Item*
1286
 
Create_func_from_unixtime::create_native(Session *session, lex_string_t name,
1287
 
                                         List<Item> *item_list)
 
1120
Item* Create_func_from_unixtime::create_native(Session *session, str_ref name, List<Item> *item_list)
1288
1121
{
1289
1122
  switch (item_list ? item_list->size() : 0) 
1290
1123
  {
1300
1133
      Item *ut= new (session->mem) Item_func_from_unixtime(param_1);
1301
1134
      return new (session->mem) Item_func_date_format(ut, param_2, 0);
1302
1135
    }
1303
 
  default:
1304
 
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1305
1136
  }
 
1137
  my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());
1306
1138
  return NULL;
1307
1139
}
1308
1140
 
1309
 
 
1310
1141
Create_func_greatest Create_func_greatest::s_singleton;
1311
1142
 
1312
 
Item*
1313
 
Create_func_greatest::create_native(Session *session, lex_string_t name,
1314
 
                                    List<Item> *item_list)
 
1143
Item* Create_func_greatest::create_native(Session *session, str_ref name, List<Item> *item_list)
1315
1144
{
1316
 
  int arg_count= item_list ? item_list->size() : 0;
1317
 
  if (arg_count < 2)
1318
 
  {
1319
 
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1320
 
    return NULL;
1321
 
  }
1322
 
 
 
1145
  if (item_list && item_list->size() >= 2)
1323
1146
  return new (session->mem) Item_func_max(*item_list);
 
1147
  my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());
 
1148
  return NULL;
1324
1149
}
1325
1150
 
1326
1151
Create_func_ifnull Create_func_ifnull::s_singleton;
1327
 
 
1328
 
Item*
1329
 
Create_func_ifnull::create(Session *session, Item *arg1, Item *arg2)
1330
 
{
1331
 
  return new (session->mem) Item_func_ifnull(arg1, arg2);
1332
 
}
1333
 
 
1334
 
 
1335
1152
Create_func_instr Create_func_instr::s_singleton;
1336
 
 
1337
 
Item*
1338
 
Create_func_instr::create(Session *session, Item *arg1, Item *arg2)
1339
 
{
1340
 
  return new (session->mem) Item_func_locate(arg1, arg2);
1341
 
}
1342
 
 
1343
 
 
1344
1153
Create_func_isnull Create_func_isnull::s_singleton;
1345
 
 
1346
 
Item*
1347
 
Create_func_isnull::create(Session *session, Item *arg1)
1348
 
{
1349
 
  return new (session->mem) Item_func_isnull(arg1);
1350
 
}
1351
 
 
1352
 
 
1353
1154
Create_func_last_day Create_func_last_day::s_singleton;
1354
 
 
1355
 
Item*
1356
 
Create_func_last_day::create(Session *session, Item *arg1)
1357
 
{
1358
 
  return new (session->mem) Item_func_last_day(arg1);
1359
 
}
1360
 
 
1361
 
 
1362
1155
Create_func_last_insert_id Create_func_last_insert_id::s_singleton;
1363
1156
 
1364
 
Item*
1365
 
Create_func_last_insert_id::create_native(Session *session, lex_string_t name,
1366
 
                                          List<Item> *item_list)
 
1157
Item* Create_func_last_insert_id::create_native(Session *session, str_ref name, List<Item> *item_list)
1367
1158
{
1368
1159
  int arg_count= item_list ? item_list->size() : 0;
1369
 
  switch (arg_count) {
 
1160
  switch (arg_count) 
 
1161
  {
1370
1162
  case 0:
1371
1163
    {
1372
1164
      return new (session->mem) Item_func_last_insert_id();
1376
1168
      Item *param_1= item_list->pop();
1377
1169
      return new (session->mem) Item_func_last_insert_id(param_1);
1378
1170
    }
1379
 
  default:
1380
 
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1381
1171
  }
 
1172
  my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());
1382
1173
  return NULL;
1383
1174
}
1384
1175
 
1385
 
 
1386
1176
Create_func_lcase Create_func_lcase::s_singleton;
1387
 
 
1388
 
Item*
1389
 
Create_func_lcase::create(Session *session, Item *arg1)
1390
 
{
1391
 
  return new (session->mem) Item_func_lcase(arg1);
1392
 
}
1393
 
 
1394
 
 
1395
1177
Create_func_least Create_func_least::s_singleton;
1396
1178
 
1397
 
Item*
1398
 
Create_func_least::create_native(Session *session, lex_string_t name,
1399
 
                                 List<Item> *item_list)
 
1179
Item* Create_func_least::create_native(Session *session, str_ref name, List<Item> *item_list)
1400
1180
{
1401
 
  int arg_count= item_list ? item_list->size() : 0;
1402
 
  if (arg_count < 2)
1403
 
  {
1404
 
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1405
 
    return NULL;
1406
 
  }
1407
 
 
1408
 
  return new (session->mem) Item_func_min(*item_list);
 
1181
  if (item_list && item_list->size() >= 2)
 
1182
    return new (session->mem) Item_func_min(*item_list);
 
1183
  my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());
 
1184
  return NULL;
1409
1185
}
1410
1186
 
1411
1187
Create_func_load_file Create_func_load_file::s_singleton;
1412
 
 
1413
 
Item*
1414
 
Create_func_load_file::create(Session *session, Item *arg1)
1415
 
{
1416
 
  return new (session->mem) Item_load_file(*session, arg1);
1417
 
}
1418
 
 
1419
 
 
1420
1188
Create_func_locate Create_func_locate::s_singleton;
1421
1189
 
1422
 
Item*
1423
 
Create_func_locate::create_native(Session *session, lex_string_t name,
1424
 
                                  List<Item> *item_list)
 
1190
Item* Create_func_locate::create_native(Session *session, str_ref name, List<Item> *item_list)
1425
1191
{
1426
 
  int arg_count= item_list ? item_list->size() : 0;
1427
 
  switch (arg_count) 
 
1192
  switch (item_list ? item_list->size() : 0) 
1428
1193
  {
1429
1194
  case 2:
1430
1195
    {
1441
1206
      /* Yes, parameters in that order : 2, 1, 3 */
1442
1207
      return new (session->mem) Item_func_locate(param_2, param_1, param_3);
1443
1208
    }
1444
 
  default:
1445
 
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1446
1209
  }
 
1210
  my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());
1447
1211
  return NULL;
1448
1212
}
1449
1213
 
1450
1214
Create_func_make_set Create_func_make_set::s_singleton;
1451
1215
 
1452
 
Item*
1453
 
Create_func_make_set::create_native(Session *session_arg, lex_string_t name,
1454
 
                                    List<Item> *item_list)
 
1216
Item* Create_func_make_set::create_native(Session *session_arg, str_ref name, List<Item> *item_list)
1455
1217
{
1456
 
  int arg_count= item_list ? item_list->size() : 0;
1457
 
  if (arg_count < 2)
 
1218
  if (not item_list || item_list->size() < 2)
1458
1219
  {
1459
 
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
 
1220
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());
1460
1221
    return NULL;
1461
1222
  }
1462
1223
 
1466
1227
 
1467
1228
Create_func_oct Create_func_oct::s_singleton;
1468
1229
 
1469
 
Item*
1470
 
Create_func_oct::create(Session *session, Item *arg1)
 
1230
Item* Create_func_oct::create(Session *session, Item *arg1)
1471
1231
{
1472
1232
  Item *i10= new (session->mem) Item_int((int32_t) 10,2);
1473
1233
  Item *i8= new (session->mem) Item_int((int32_t) 8,1);
1475
1235
}
1476
1236
 
1477
1237
Create_func_period_add Create_func_period_add::s_singleton;
1478
 
 
1479
 
Item*
1480
 
Create_func_period_add::create(Session *session, Item *arg1, Item *arg2)
1481
 
{
1482
 
  return new (session->mem) Item_func_period_add(arg1, arg2);
1483
 
}
1484
 
 
1485
 
 
1486
1238
Create_func_period_diff Create_func_period_diff::s_singleton;
1487
 
 
1488
 
Item*
1489
 
Create_func_period_diff::create(Session *session, Item *arg1, Item *arg2)
1490
 
{
1491
 
  return new (session->mem) Item_func_period_diff(arg1, arg2);
1492
 
}
1493
 
 
1494
 
 
1495
1239
Create_func_pi Create_func_pi::s_singleton;
1496
 
 
1497
 
Item*
1498
 
Create_func_pi::create(Session *session)
1499
 
{
1500
 
  return new (session->mem) Item_static_float_func("pi()", M_PI, 6, 8);
1501
 
}
1502
 
 
1503
1240
Create_func_radians Create_func_radians::s_singleton;
1504
 
 
1505
 
Item*
1506
 
Create_func_radians::create(Session *session, Item *arg1)
1507
 
{
1508
 
  return new (session->mem) Item_func_units("radians", arg1,
1509
 
                                             M_PI/180, 0.0);
1510
 
}
1511
 
 
1512
1241
Create_func_round Create_func_round::s_singleton;
1513
1242
 
1514
 
Item* Create_func_round::create_native(Session *session, lex_string_t name, List<Item> *item_list)
 
1243
Item* Create_func_round::create_native(Session *session, str_ref name, List<Item> *item_list)
1515
1244
{
1516
1245
  switch (item_list ? item_list->size() : 0) 
1517
1246
  {
1518
1247
  case 1:
1519
 
  {
1520
 
    Item *param_1= item_list->pop();
1521
 
    Item *i0 = new (session->mem) Item_int("0", 0, 1);
1522
 
    return new (session->mem) Item_func_round(param_1, i0, 0);
1523
 
  }
 
1248
    {
 
1249
      Item *param_1= item_list->pop();
 
1250
      Item *i0 = new (session->mem) Item_int("0", 0, 1);
 
1251
      return new (session->mem) Item_func_round(param_1, i0, 0);
 
1252
    }
1524
1253
  case 2:
1525
 
  {
1526
 
    Item *param_1= item_list->pop();
1527
 
    Item *param_2= item_list->pop();
1528
 
    return new (session->mem) Item_func_round(param_1, param_2, 0);
1529
 
  }
1530
 
  default:
1531
 
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1532
 
  }
 
1254
    {
 
1255
      Item *param_1= item_list->pop();
 
1256
      Item *param_2= item_list->pop();
 
1257
      return new (session->mem) Item_func_round(param_1, param_2, 0);
 
1258
    }
 
1259
  }
 
1260
  my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());
1533
1261
  return NULL;
1534
1262
}
1535
1263
 
1536
1264
Create_func_space Create_func_space::s_singleton;
1537
1265
 
1538
 
Item*
1539
 
Create_func_space::create(Session *session, Item *arg1)
 
1266
Item* Create_func_space::create(Session *session, Item *arg1)
1540
1267
{
1541
1268
  /**
1542
1269
    TODO: Fix Bug#23637
1548
1275
 
1549
1276
  if (cs->mbminlen > 1)
1550
1277
  {
1551
 
    sp= new (session->mem) Item_string("", 0, cs, DERIVATION_COERCIBLE);
 
1278
    sp= new (session->mem) Item_string(str_ref(""), cs, DERIVATION_COERCIBLE);
1552
1279
    sp->str_value.copy(" ", 1, cs);
1553
1280
  }
1554
1281
  else
1555
1282
  {
1556
 
    sp= new (session->mem) Item_string(" ", 1, cs, DERIVATION_COERCIBLE);
 
1283
    sp= new (session->mem) Item_string(str_ref(" "), cs, DERIVATION_COERCIBLE);
1557
1284
  }
1558
1285
 
1559
1286
  return new (session->mem) Item_func_repeat(*session, sp, arg1);
1561
1288
 
1562
1289
Create_func_unix_timestamp Create_func_unix_timestamp::s_singleton;
1563
1290
 
1564
 
Item*
1565
 
Create_func_unix_timestamp::create_native(Session *session, lex_string_t name,
1566
 
                                          List<Item> *item_list)
 
1291
Item* Create_func_unix_timestamp::create_native(Session *session, str_ref name, List<Item> *item_list)
1567
1292
{
1568
1293
  switch (item_list ? item_list->size() : 0) 
1569
1294
  {
1571
1296
    return new (session->mem) Item_func_unix_timestamp();
1572
1297
  case 1:
1573
1298
    return new (session->mem) Item_func_unix_timestamp(item_list->pop());
1574
 
  default:
1575
 
    my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.str);
1576
1299
  }
 
1300
  my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());
1577
1301
  return NULL;
1578
1302
}
1579
1303
 
1664
1388
    FunctionContainer::getMutableMap()[func->name]= func->builder;
1665
1389
}
1666
1390
 
1667
 
Create_func* find_native_function_builder(lex_string_t name)
 
1391
Create_func* find_native_function_builder(str_ref name)
1668
1392
{
1669
 
  return find_ptr2(FunctionContainer::getMap(), name.str);
 
1393
  return find_ptr2(FunctionContainer::getMap(), name.data());
1670
1394
}
1671
1395
 
1672
1396
Item* create_func_char_cast(Session *session, Item *a, int len, const charset_info_st* cs)