~drizzle-trunk/drizzle/development : revision 2440.2.4

128

class Create_native_func : public Create_func

129

{

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

{

133

if (item_list && has_named_parameters(*item_list))

134

{

145

@param item_list The function parameters, none of which are named

146

@return An item representing the function call

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

};

150

151

156

class Create_func_arg0 : public Create_func

157

{

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

161

/**

162

Builder method, with no arguments.

174

class Create_func_arg1 : public Create_func

175

{

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

179

/**

180

Builder method, with one argument.

193

class Create_func_arg2 : public Create_func

194

{

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

198

/**

199

Builder method, with two arguments.

213

class Create_func_arg3 : public Create_func

214

{

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

218

/**

219

Builder method, with three arguments.

246

virtual Item* create(Session *session, Item *arg1);

247

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

592

656

601

}

657

602

658

603

static Create_func_lpad s_singleton;

659

protected:

660

Create_func_lpad() {}

661

604

};

662

605

663

606

Create_func_lpad Create_func_lpad::s_singleton;

673

616

}

674

617

675

618

static Create_func_ltrim s_singleton;

676

protected:

677

Create_func_ltrim() {}

678

619

};

679

620

680

621

Create_func_ltrim Create_func_ltrim::s_singleton;

690

631

}

691

632

692

633

static Create_func_makedate s_singleton;

693

protected:

694

Create_func_makedate() {}

695

634

};

696

635

697

636

Create_func_makedate Create_func_makedate::s_singleton;

699

638

class Create_func_make_set : public Create_native_func

700

639

{

701

640

public:

702

virtual Item* create_native(Session *session, lex_string_t name, List<Item> *item_list);

641

virtual Item* create_native(Session *session, str_ref name, List<Item> *item_list);

703

642

704

643

static Create_func_make_set s_singleton;

705

706

protected:

707

Create_func_make_set() {}

708

644

};

709

645

710

646

719

655

}

720

656

721

657

static Create_func_monthname s_singleton;

722

protected:

723

Create_func_monthname() {}

724

658

};

725

659

726

660

Create_func_monthname Create_func_monthname::s_singleton;

733

667

virtual Item* create(Session *session, Item *arg1, Item *arg2);

734

668

735

669

static Create_func_name_const s_singleton;

736

737

protected:

738

Create_func_name_const() {}

739

670

};

740

671

741

672

750

681

}

751

682

752

683

static Create_func_nullif s_singleton;

753

protected:

754

Create_func_nullif() {}

755

684

};

756

685

757

686

Create_func_nullif Create_func_nullif::s_singleton;

764

693

virtual Item* create(Session *session, Item *arg1);

765

694

766

695

static Create_func_oct s_singleton;

767

768

protected:

769

Create_func_oct() {}

770

696

};

771

697

772

698

class Create_func_period_add : public Create_func_arg2

774

700

public:

775

701

using Create_func_arg2::create;

776

702

777

virtual Item* create(Session *session, Item *arg1, Item *arg2);

703

virtual Item* create(Session *session, Item *arg1, Item *arg2)

704

{

705

return new (session->mem) Item_func_period_add(arg1, arg2);

706

}

778

707

779

708

static Create_func_period_add s_singleton;

780

781

protected:

782

Create_func_period_add() {}

783

709

};

784

710

785

711

788

714

public:

789

715

using Create_func_arg2::create;

790

716

791

virtual Item* create(Session *session, Item *arg1, Item *arg2);

717

virtual Item* create(Session *session, Item *arg1, Item *arg2)

718

{

719

return new (session->mem) Item_func_period_diff(arg1, arg2);

720

}

792

721

793

722

static Create_func_period_diff s_singleton;

794

795

protected:

796

Create_func_period_diff() {}

797

723

};

798

724

799

725

802

728

public:

803

729

using Create_func_arg0::create;

804

730

805

virtual Item* create(Session *session);

731

virtual Item* create(Session *session)

732

{

733

return new (session->mem) Item_static_float_func("pi()", M_PI, 6, 8);

734

}

806

735

807

736

static Create_func_pi s_singleton;

808

809

protected:

810

Create_func_pi() {}

811

737

};

812

738

813

739

class Create_func_radians : public Create_func_arg1

815

741

public:

816

742

using Create_func_arg1::create;

817

743

818

virtual Item* create(Session *session, Item *arg1);

744

virtual Item* create(Session *session, Item *arg1)

745

{

746

return new (session->mem) Item_func_units("radians", arg1, M_PI/180, 0.0);

747

}

819

748

820

749

static Create_func_radians s_singleton;

821

protected:

822

Create_func_radians() {}

823

750

};

824

751

825

752

826

753

class Create_func_round : public Create_native_func

827

754

{

828

755

public:

829

virtual Item* create_native(Session *session, lex_string_t name, List<Item> *item_list);

756

virtual Item* create_native(Session *session, str_ref name, List<Item> *item_list);

830

757

831

758

static Create_func_round s_singleton;

832

protected:

833

Create_func_round() {}

834

759

};

835

760

836

761

845

770

}

846

771

847

772

static Create_func_row_count s_singleton;

848

protected:

849

Create_func_row_count() {}

850

773

};

851

774

852

775

Create_func_row_count Create_func_row_count::s_singleton;

862

785

}

863

786

864

787

static Create_func_rpad s_singleton;

865

protected:

866

Create_func_rpad() {}

867

788

};

868

789

869

790

Create_func_rpad Create_func_rpad::s_singleton;

879

800

}

880

801

881

802

static Create_func_rtrim s_singleton;

882

883

protected:

884

Create_func_rtrim() {}

885

803

};

886

804

887

805

Create_func_rtrim Create_func_rtrim::s_singleton;

897

815

}

898

816

899

817

static Create_func_sign s_singleton;

900

protected:

901

Create_func_sign() {}

902

818

};

903

819

904

820

Create_func_sign Create_func_sign::s_singleton;

911

827

virtual Item* create(Session *session, Item *arg1);

912

828

913

829

static Create_func_space s_singleton;

914

protected:

915

Create_func_space() {}

916

830

};

917

831

918

832

class Create_func_strcmp : public Create_func_arg2

926

840

}

927

841

928

842

static Create_func_strcmp s_singleton;

929

protected:

930

Create_func_strcmp() {}

931

843

};

932

844

933

845

Create_func_strcmp Create_func_strcmp::s_singleton;

943

855

}

944

856

945

857

static Create_func_tan s_singleton;

946

protected:

947

Create_func_tan() {}

948

858

};

949

859

950

860

Create_func_tan Create_func_tan::s_singleton;

960

870

}

961

871

962

872

static Create_func_time_format s_singleton;

963

protected:

964

Create_func_time_format() {}

965

873

};

966

874

967

875

Create_func_time_format Create_func_time_format::s_singleton;

977

885

}

978

886

979

887

static Create_func_to_days s_singleton;

980

protected:

981

Create_func_to_days() {}

982

888

};

983

889

984

890

Create_func_to_days Create_func_to_days::s_singleton;

994

900

}

995

901

996

902

static Create_func_ucase s_singleton;

997

protected:

998

Create_func_ucase() {}

999

903

};

1000

904

1001

905

Create_func_ucase Create_func_ucase::s_singleton;

1003

907

class Create_func_unix_timestamp : public Create_native_func

1004

908

{

1005

909

public:

1006

virtual Item* create_native(Session *session, lex_string_t name, List<Item> *item_list);

910

virtual Item* create_native(Session *session, str_ref name, List<Item> *item_list);

1007

911

1008

912

static Create_func_unix_timestamp s_singleton;

1009

protected:

1010

Create_func_unix_timestamp() {}

1011

913

};

1012

914

1013

915

1022

924

}

1023

925

1024

926

static Create_func_weekday s_singleton;

1025

protected:

1026

Create_func_weekday() {}

1027

927

};

1028

928

1029

929

Create_func_weekday Create_func_weekday::s_singleton;

1036

936

1037

937

Create_udf_func Create_udf_func::s_singleton;

1038

938

1039

Item* Create_udf_func::create(Session *session, lex_string_t name, List<Item> *item_list)

939

Item* Create_udf_func::create(Session *session, str_ref name, List<Item> *item_list)

1040

940

{

1041

941

return create(session, plugin::Function::get(to_string(name)), item_list);

1042

942

}

1056

956

return func;

1057

957

}

1058

958

1059

Item* Create_func_arg0::create(Session *session, lex_string_t name, List<Item> *item_list)

959

Item* Create_func_arg0::create(Session *session, str_ref name, List<Item> *item_list)

1060

960

{

1061

if (item_list && item_list->size())

1062

{

1063

my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());

1064

return NULL;

1065

}

1066

return create(session);

961

if (not item_list || not item_list->size())

962

return create(session);

963

my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());

964

return NULL;

1067

965

}

1068

966

1069

Item* Create_func_arg1::create(Session *session, lex_string_t name, List<Item> *item_list)

967

Item* Create_func_arg1::create(Session *session, str_ref name, List<Item> *item_list)

1070

968

{

1071

int arg_count= item_list ? item_list->size() : 0;

1072

if (arg_count != 1)

969

if (not item_list || item_list->size() != 1)

1073

970

{

1074

971

my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());

1075

972

return NULL;

1076

973

}

1077

974

1078

975

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.data());

1083

return NULL;

1084

}

1085

1086

return create(session, param_1);

976

if (param_1->is_autogenerated_name)

977

return create(session, param_1);

978

my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), name.data());

979

return NULL;

1087

980

}

1088

981

1089

1090

Item*

1091

Create_func_arg2::create(Session *session, lex_string_t name, List<Item> *item_list)

982

Item* Create_func_arg2::create(Session *session, str_ref name, List<Item> *item_list)

1092

983

{

1093

int arg_count= item_list ? item_list->size() : 0;

1094

if (arg_count != 2)

984

if (not item_list || item_list->size() != 2)

1095

985

{

1096

986

my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());

1097

987

return NULL;

1100

990

Item *param_1= item_list->pop();

1101

991

Item *param_2= item_list->pop();

1102

992

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.data());

1107

return NULL;

1108

}

1109

993

if (param_1->is_autogenerated_name

994

&& param_2->is_autogenerated_name)

1110

995

return create(session, param_1, param_2);

996

my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), name.data());

997

return NULL;

1111

998

}

1112

999

1113

1114

Item*

1115

Create_func_arg3::create(Session *session, lex_string_t name, List<Item> *item_list)

1000

Item* Create_func_arg3::create(Session *session, str_ref name, List<Item> *item_list)

1116

1001

{

1117

int arg_count= item_list ? item_list->size() : 0;

1118

if (arg_count != 3)

1002

if (not item_list || item_list->size() != 3)

1119

1003

{

1120

1004

my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());

1121

1005

return NULL;

1125

1009

Item *param_2= item_list->pop();

1126

1010

Item *param_3= item_list->pop();

1127

1011

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.data());

1133

return NULL;

1134

}

1135

1136

return create(session, param_1, param_2, param_3);

1012

if (param_1->is_autogenerated_name

1013

&& param_2->is_autogenerated_name

1014

&& param_3->is_autogenerated_name)

1015

return create(session, param_1, param_2, param_3);

1016

my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), name.data());

1017

return NULL;

1137

1018

}

1138

1019

1139

1020

Create_func_bin Create_func_bin::s_singleton;

1140

1021

1141

Item*

1142

Create_func_bin::create(Session *session, Item *arg1)

1022

Item* Create_func_bin::create(Session *session, Item *arg1)

1143

1023

{

1144

1024

Item *i10= new (session->mem) Item_int(10, 2);

1145

1025

Item *i2= new (session->mem) Item_int(2, 1);

1148

1028

1149

1029

Create_func_concat Create_func_concat::s_singleton;

1150

1030

1151

Item*

1152

Create_func_concat::create_native(Session *session, lex_string_t name, List<Item> *item_list)

1031

Item* Create_func_concat::create_native(Session *session, str_ref name, List<Item> *item_list)

1153

1032

{

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.data());

1158

return NULL;

1159

}

1160

1161

return new (session->mem) Item_func_concat(*session, *item_list);

1033

if (item_list && item_list->size() >= 1)

1034

return new (session->mem) Item_func_concat(*session, *item_list);

1035

my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());

1036

return NULL;

1162

1037

}

1163

1038

1164

1165

1039

Create_func_concat_ws Create_func_concat_ws::s_singleton;

1166

1040

1167

Item*

1168

Create_func_concat_ws::create_native(Session *session, lex_string_t name,

1169

List<Item> *item_list)

1041

Item* Create_func_concat_ws::create_native(Session *session, str_ref name, List<Item> *item_list)

1170

1042

{

1171

int arg_count= item_list ? item_list->size() : 0;

1172

1043

/* "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.data());

1176

return NULL;

1177

}

1178

1179

return new (session->mem) Item_func_concat_ws(*session, *item_list);

1044

if (item_list && item_list->size() >= 2)

1045

return new (session->mem) Item_func_concat_ws(*session, *item_list);

1046

my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());

1047

return NULL;

1180

1048

}

1181

1049

1182

1050

Create_func_cot Create_func_cot::s_singleton;

1202

1070

Create_func_export_set Create_func_export_set::s_singleton;

1203

1071

1204

1072

Item*

1205

Create_func_export_set::create_native(Session *session, lex_string_t name, List<Item> *item_list)

1073

Create_func_export_set::create_native(Session *session, str_ref name, List<Item> *item_list)

1206

1074

{

1207

1075

switch (item_list ? item_list->size() : 0)

1208

1076

{

1230

1098

Item *param_5= item_list->pop();

1231

1099

return new (session->mem) Item_func_export_set(param_1, param_2, param_3, param_4, param_5);

1232

1100

}

1233

default:

1234

my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());

1235

1101

}

1102

my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());

1236

1103

return NULL;

1237

1104

}

1238

1105

1239

1106

1240

1107

Create_func_field Create_func_field::s_singleton;

1241

1108

1242

Item*

1243

Create_func_field::create_native(Session *session, lex_string_t name,

1244

List<Item> *item_list)

1109

Item* Create_func_field::create_native(Session *session, str_ref name, List<Item> *item_list)

1245

1110

{

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.data());

1250

return NULL;

1251

}

1252

1253

return new (session->mem) Item_func_field(*item_list);

1111

if (item_list && item_list->size() >= 2)

1112

return new (session->mem) Item_func_field(*item_list);

1113

my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());

1114

return NULL;

1254

1115

}

1255

1116

1256

1257

1117

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

1118

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

1119

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

1120

Create_func_from_unixtime Create_func_from_unixtime::s_singleton;

1284

1121

1285

Item*

1286

Create_func_from_unixtime::create_native(Session *session, lex_string_t name,

1287

List<Item> *item_list)

1122

Item* Create_func_from_unixtime::create_native(Session *session, str_ref name, List<Item> *item_list)

1288

1123

{

1289

1124

switch (item_list ? item_list->size() : 0)

1290

1125

{

1300

1135

Item *ut= new (session->mem) Item_func_from_unixtime(param_1);

1301

1136

return new (session->mem) Item_func_date_format(ut, param_2, 0);

1302

1137

}

1303

default:

1304

my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());

1305

1138

}

1139

my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());

1306

1140

return NULL;

1307

1141

}

1308

1142

1309

1310

1143

Create_func_greatest Create_func_greatest::s_singleton;

1311

1144

1312

Item*

1313

Create_func_greatest::create_native(Session *session, lex_string_t name,

1314

List<Item> *item_list)

1145

Item* Create_func_greatest::create_native(Session *session, str_ref name, List<Item> *item_list)

1315

1146

{

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.data());

1320

return NULL;

1321

}

1322

1147

if (item_list && item_list->size() >= 2)

1323

1148

return new (session->mem) Item_func_max(*item_list);

1149

my_error(ER_WRONG_PARAMCOUNT_TO_FUNCTION, MYF(0), name.data());

1150

return NULL;

1324

1151

}

1325

1152

1326

1153

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

1154

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

1155

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

1156

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

1157

Create_func_last_insert_id Create_func_last_insert_id::s_singleton;

1363

1158

1364

Item*

1365

Create_func_last_insert_id::create_native(Session *session, lex_string_t name,

1366

List<Item> *item_list)

1159

Item* Create_func_last_insert_id::create_native(Session *session, str_ref name, List<Item> *item_list)

1367

1160

{

1368

1161

int arg_count= item_list ? item_list->size() : 0;

1369

1162

switch (arg_count) {

1384

1177

1385

1178

1386

1179

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

1180

Create_func_least Create_func_least::s_singleton;

1396

1181

1397

Item*

1398

Create_func_least::create_native(Session *session, lex_string_t name,

1399

List<Item> *item_list)

1182

Item* Create_func_least::create_native(Session *session, str_ref name, List<Item> *item_list)

1400

1183

{

1401

1184

int arg_count= item_list ? item_list->size() : 0;

1402

1185

if (arg_count < 2)

1409

1192

}

1410

1193

1411

1194

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

1195

Create_func_locate Create_func_locate::s_singleton;

1421

1196

1422

1197

Item*

1423

Create_func_locate::create_native(Session *session, lex_string_t name,

1198

Create_func_locate::create_native(Session *session, str_ref name,

1424

1199

List<Item> *item_list)

1425

1200

{

1426

1201

int arg_count= item_list ? item_list->size() : 0;

1450

1225

Create_func_make_set Create_func_make_set::s_singleton;

1451

1226

1452

1227

Item*

1453

Create_func_make_set::create_native(Session *session_arg, lex_string_t name,

1228

Create_func_make_set::create_native(Session *session_arg, str_ref name,

1454

1229

List<Item> *item_list)

1455

1230

{

1456

1231

int arg_count= item_list ? item_list->size() : 0;

1475

1250

}

1476

1251

1477

1252

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

1253

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

1254

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

1255

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

1256

Create_func_round Create_func_round::s_singleton;

1513

1257

1514

Item* Create_func_round::create_native(Session *session, lex_string_t name, List<Item> *item_list)

1258

Item* Create_func_round::create_native(Session *session, str_ref name, List<Item> *item_list)

1515

1259

{

1516

1260

switch (item_list ? item_list->size() : 0)

1517

1261

{

1561

1305

1562

1306

Create_func_unix_timestamp Create_func_unix_timestamp::s_singleton;

1563

1307

1564

Item*

1565

Create_func_unix_timestamp::create_native(Session *session, lex_string_t name,

1566

List<Item> *item_list)

1308

Item* Create_func_unix_timestamp::create_native(Session *session, str_ref name, List<Item> *item_list)

1567

1309

{

1568

1310

switch (item_list ? item_list->size() : 0)

1569

1311

{

1664

1406

FunctionContainer::getMutableMap()[func->name]= func->builder;

1665

1407

}

1666

1408

1667

Create_func* find_native_function_builder(lex_string_t name)

1409

Create_func* find_native_function_builder(str_ref name)

1668

1410

{

1669

1411

return find_ptr2(FunctionContainer::getMap(), name.data());

1670

1412

}