~drizzle-trunk/drizzle/development : revision 1098

43

#define REPORT_TO_USER 2

44

45

using namespace std;

46

using namespace drizzled;

47

using namespace drizzled::plugin;

46

48

47

typedef struct drizzled_plugin_manifest builtin_plugin[];

49

typedef Manifest builtin_plugin[];

48

50

extern builtin_plugin DRIZZLED_BUILTIN_LIST;

49

static drizzled_plugin_manifest *drizzled_builtins[]=

51

static Manifest *drizzled_builtins[]=

50

52

{

51

DRIZZLED_BUILTIN_LIST,(struct drizzled_plugin_manifest *)0

53

DRIZZLED_BUILTIN_LIST,(Manifest *)0

52

54

};

53

55

54

56

char *opt_plugin_load= NULL;

55

57

const char *opt_plugin_load_default= QUOTE_ARG(DRIZZLED_PLUGIN_LIST);

56

58

char *opt_plugin_dir_ptr;

57

59

char opt_plugin_dir[FN_REFLEN];

58

static const char *plugin_declarations_sym= "_mysql_plugin_declarations_";

60

static const char *plugin_declarations_sym= "_drizzled_plugin_declaration_";

59

61

60

62

/* Note that 'int version' must be the first field of every plugin

61

63

sub-structure (plugin->info).

122

124

class sys_var_pluginvar: public sys_var

123

125

{

124

126

public:

125

struct st_plugin_int *plugin;

127

Handle *plugin;

126

128

struct st_mysql_sys_var *plugin_var;

127

129

128

130

static void *operator new(size_t size, MEM_ROOT *mem_root)

154

156

/* prototypes */

155

157

static bool plugin_load_list(MEM_ROOT *tmp_root, int *argc, char **argv,

156

158

const char *list);

157

static int test_plugin_options(MEM_ROOT *, struct st_plugin_int *,

159

static int test_plugin_options(MEM_ROOT *, Handle *,

158

160

int *, char **);

159

static bool register_builtin(struct st_plugin_int *,

160

struct st_plugin_int **);

161

static bool register_builtin(Handle *,

162

Handle **);

161

163

static void unlock_variables(Session *session, struct system_variables *vars);

162

164

static void cleanup_variables(Session *session, struct system_variables *vars);

163

165

static void plugin_vars_free_values(sys_var *vars);

236

238

Plugin support code

237

239

****************************************************************************/

238

240

239

static struct st_plugin_dl *plugin_dl_find(const LEX_STRING *dl)

241

static Library *plugin_dl_find(const LEX_STRING *dl)

240

242

{

241

243

uint32_t i;

242

struct st_plugin_dl *tmp;

244

Library *tmp;

243

245

244

246

for (i= 0; i < plugin_dl_array.elements; i++)

245

247

{

246

tmp= *dynamic_element(&plugin_dl_array, i, struct st_plugin_dl **);

248

tmp= *dynamic_element(&plugin_dl_array, i, Library **);

247

249

if (! my_strnncoll(files_charset_info,

248

250

(const unsigned char *)dl->str, dl->length,

249

251

(const unsigned char *)tmp->dl.str, tmp->dl.length))

252

254

return(0);

253

255

}

254

256

255

static st_plugin_dl *plugin_dl_insert_or_reuse(struct st_plugin_dl *plugin_dl)

257

static Library *plugin_dl_insert_or_reuse(Library *plugin_dl)

256

258

{

257

259

uint32_t i;

258

struct st_plugin_dl *tmp;

260

Library *tmp;

259

261

260

262

for (i= 0; i < plugin_dl_array.elements; i++)

261

263

{

262

tmp= *dynamic_element(&plugin_dl_array, i, struct st_plugin_dl **);

264

tmp= *dynamic_element(&plugin_dl_array, i, Library **);

263

265

{

264

memcpy(tmp, plugin_dl, sizeof(struct st_plugin_dl));

266

memcpy(tmp, plugin_dl, sizeof(Library));

265

267

return(tmp);

266

268

}

267

269

}

268

270

if (insert_dynamic(&plugin_dl_array, (unsigned char*)&plugin_dl))

269

271

return(0);

270

272

tmp= *dynamic_element(&plugin_dl_array, plugin_dl_array.elements - 1,

271

struct st_plugin_dl **)=

272

(struct st_plugin_dl *) memdup_root(&plugin_mem_root, (unsigned char*)plugin_dl,

273

sizeof(struct st_plugin_dl));

273

Library **)=

274

(Library *) memdup_root(&plugin_mem_root, (unsigned char*)plugin_dl,

275

sizeof(Library));

274

276

return(tmp);

275

277

}

276

278

277

static inline void free_plugin_mem(struct st_plugin_dl *p)

279

static inline void free_plugin_mem(Library *p)

278

280

{

279

281

if (p->handle)

280

282

dlclose(p->handle);

282

284

}

283

285

284

286

285

static st_plugin_dl *plugin_dl_add(const LEX_STRING *dl, int report)

287

static Library *plugin_dl_add(const LEX_STRING *dl, int report)

286

288

{

287

289

string dlpath;

288

290

uint32_t plugin_dir_len;

289

struct st_plugin_dl *tmp, plugin_dl;

291

Library *tmp, plugin_dl;

290

292

void *sym;

291

293

plugin_dir_len= strlen(opt_plugin_dir);

292

294

dlpath.reserve(FN_REFLEN);

345

347

return(0);

346

348

}

347

349

348

plugin_dl.plugins= (struct drizzled_plugin_manifest *)sym;

350

plugin_dl.plugins= static_cast<Manifest *>(sym);

349

351

350

352

/* Duplicate and convert dll name */

351

353

plugin_dl.dl.length= dl->length * files_charset_info->mbmaxlen + 1;

364

366

{

365

367

free_plugin_mem(&plugin_dl);

366

368

if (report & REPORT_TO_USER)

367

my_error(ER_OUTOFMEMORY, MYF(0), sizeof(struct st_plugin_dl));

369

my_error(ER_OUTOFMEMORY, MYF(0), sizeof(Library));

368

370

if (report & REPORT_TO_LOG)

369

errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_OUTOFMEMORY), sizeof(struct st_plugin_dl));

371

errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_OUTOFMEMORY), sizeof(Library));

370

372

return(0);

371

373

}

372

374

return(tmp);

379

381

380

382

for (i= 0; i < plugin_dl_array.elements; i++)

381

383

{

382

struct st_plugin_dl *tmp= *dynamic_element(&plugin_dl_array, i,

383

struct st_plugin_dl **);

384

Library *tmp= *dynamic_element(&plugin_dl_array, i,

385

Library **);

384

386

if (! my_strnncoll(files_charset_info,

385

387

(const unsigned char *)dl->str, dl->length,

386

388

(const unsigned char *)tmp->dl.str, tmp->dl.length))

388

390

/* Do not remove this element, unless no other plugin uses this dll. */

389

391

{

390

392

free_plugin_mem(tmp);

391

memset(tmp, 0, sizeof(struct st_plugin_dl));

393

memset(tmp, 0, sizeof(Library));

392

394

}

393

395

break;

394

396

}

398

400

399

401

400

402

401

static st_plugin_int *plugin_insert_or_reuse(struct st_plugin_int *plugin)

403

static Handle *plugin_insert_or_reuse(Handle *plugin)

402

404

{

403

struct st_plugin_int *tmp;

404

405

if (insert_dynamic(&plugin_array, (unsigned char*)&plugin))

405

406

return(0);

406

tmp= *dynamic_element(&plugin_array, plugin_array.elements - 1,

407

struct st_plugin_int **)=

408

(struct st_plugin_int *) memdup_root(&plugin_mem_root, (unsigned char*)plugin,

409

sizeof(struct st_plugin_int));

410

return(tmp);

407

plugin= *dynamic_element(&plugin_array, plugin_array.elements - 1,

408

Handle **);

409

return(plugin);

411

410

}

412

411

413

412

421

420

{

422

421

PluginRegistry &registry= PluginRegistry::getPluginRegistry();

423

422

424

struct st_plugin_int tmp;

425

struct drizzled_plugin_manifest *plugin;

423

Manifest *manifest;

426

424

if (! initialized)

427

425

return(0);

428

426

434

432

errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_UDF_EXISTS), name->str);

435

433

return(true);

436

434

}

437

/* Clear the whole struct to catch future extensions. */

438

memset(&tmp, 0, sizeof(tmp));

439

if (! (tmp.plugin_dl= plugin_dl_add(dl, report)))

440

return(true);

435

Library *library= plugin_dl_add(dl, report);

436

if (library == NULL)

437

return true;

438

439

Handle *tmp= NULL;

441

440

/* Find plugin by name */

442

for (plugin= tmp.plugin_dl->plugins; plugin->name; plugin++)

441

for (manifest= library->plugins; manifest->name; manifest++)

443

442

{

444

uint32_t name_len= strlen(plugin->name);

445

443

if (! my_strnncoll(system_charset_info,

446

444

(const unsigned char *)name->str, name->length,

447

(const unsigned char *)plugin->name,

448

name_len))

445

(const unsigned char *)manifest->name,

446

strlen(manifest->name)))

449

447

{

450

struct st_plugin_int *tmp_plugin_ptr;

448

tmp= new (std::nothrow) Handle(manifest, library);

449

if (tmp == NULL)

450

return true;

451

452

tmp.plugin= plugin;

453

tmp.name.str= (char *)plugin->name;

454

tmp.name.length= name_len;

455

tmp.isInited= false;

456

if (!test_plugin_options(tmp_root, &tmp, argc, argv))

452

if (!test_plugin_options(tmp_root, tmp, argc, argv))

457

453

{

458

if ((tmp_plugin_ptr= plugin_insert_or_reuse(&tmp)))

454

if ((tmp= plugin_insert_or_reuse(tmp)))

459

455

{

460

registry.add(tmp_plugin_ptr);

461

init_alloc_root(&tmp_plugin_ptr->mem_root, 4096, 4096);

456

registry.add(tmp);

457

init_alloc_root(&tmp->mem_root, 4096, 4096);

462

458

return(false);

463

459

}

464

mysql_del_sys_var_chain(tmp.system_vars);

460

mysql_del_sys_var_chain(tmp->system_vars);

465

461

goto err;

466

462

}

467

463

/* plugin was disabled */

479

475

}

480

476

481

477

482

static void plugin_del(struct st_plugin_int *plugin)

478

static void plugin_del(Handle *plugin)

483

479

{

484

480

PluginRegistry &registry= PluginRegistry::getPluginRegistry();

485

481

if (plugin->isInited)

486

482

{

487

if (plugin->plugin->status_vars)

483

if (plugin->getManifest().status_vars)

488

484

{

489

remove_status_vars(plugin->plugin->status_vars);

485

remove_status_vars(plugin->getManifest().status_vars);

490

486

}

491

487

492

if (plugin->plugin->deinit)

493

plugin->plugin->deinit(registry);

488

if (plugin->getManifest().deinit)

489

plugin->getManifest().deinit(registry);

494

490

}

495

491

496

492

/* Free allocated strings before deleting the plugin. */

501

497

pthread_rwlock_wrlock(&LOCK_system_variables_hash);

502

498

mysql_del_sys_var_chain(plugin->system_vars);

503

499

pthread_rwlock_unlock(&LOCK_system_variables_hash);

504

free_root(&plugin->mem_root, MYF(0));

500

delete plugin;

505

501

}

506

502

507

503

static void reap_plugins(void)

508

504

{

509

505

size_t count;

510

506

uint32_t idx;

511

struct st_plugin_int *plugin;

507

drizzled::plugin::Handle *plugin;

512

508

513

509

count= plugin_array.elements;

514

510

515

511

for (idx= 0; idx < count; idx++)

516

512

{

517

plugin= *dynamic_element(&plugin_array, idx, struct st_plugin_int **);

513

plugin= *dynamic_element(&plugin_array, idx, drizzled::plugin::Handle **);

518

514

plugin_del(plugin);

519

515

}

520

516

}

521

517

522

static bool plugin_initialize(struct st_plugin_int *plugin)

518

static bool plugin_initialize(drizzled::plugin::Handle *plugin)

523

519

{

524

520

assert(plugin->isInited == false);

525

521

526

522

PluginRegistry &registry= PluginRegistry::getPluginRegistry();

527

if (plugin->plugin->init)

523

if (plugin->getManifest().init)

528

524

{

529

if (plugin->plugin->init(registry))

525

if (plugin->getManifest().init(registry))

530

526

{

531

527

errmsg_printf(ERRMSG_LVL_ERROR,

532

528

_("Plugin '%s' init function returned error.\n"),

533

plugin->name.str);

529

plugin->getName().c_str());

534

530

goto err;

535

531

}

536

532

}

537

533

plugin->isInited= true;

538

534

539

if (plugin->plugin->status_vars)

535

if (plugin->getManifest().status_vars)

540

536

{

541

add_status_vars(plugin->plugin->status_vars); // add_status_vars makes a copy

537

add_status_vars(plugin->getManifest().status_vars); // add_status_vars makes a copy

542

538

}

543

539

544

540

/*

584

580

int plugin_init(int *argc, char **argv, int flags)

585

581

{

586

582

uint32_t idx;

587

struct drizzled_plugin_manifest **builtins;

588

struct drizzled_plugin_manifest *plugin;

589

struct st_plugin_int tmp, *plugin_ptr;

583

Manifest **builtins;

584

Manifest *manifest;

585

Handle *handle;

590

586

MEM_ROOT tmp_root;

591

587

592

588

if (initialized)

601

597

602

598

603

599

if (my_init_dynamic_array(&plugin_dl_array,

604

sizeof(struct st_plugin_dl *),16,16) ||

600

sizeof(Library *),16,16) ||

605

601

my_init_dynamic_array(&plugin_array,

606

sizeof(struct st_plugin_int *),16,16))

602

sizeof(Handle *),16,16))

607

603

goto err;

608

604

609

605

initialized= 1;

613

609

*/

614

610

for (builtins= drizzled_builtins; *builtins; builtins++)

615

611

{

616

for (plugin= *builtins; plugin->name; plugin++)

612

for (manifest= *builtins; manifest->name; manifest++)

617

613

{

618

memset(&tmp, 0, sizeof(tmp));

619

tmp.plugin= plugin;

620

tmp.name.str= (char *)plugin->name;

621

tmp.name.length= strlen(plugin->name);

614

handle= new (std::nothrow) Handle(manifest);

615

if (handle == NULL)

616

return true;

622

617

623

618

free_root(&tmp_root, MYF(MY_MARK_BLOCKS_FREE));

624

if (test_plugin_options(&tmp_root, &tmp, argc, argv))

619

if (test_plugin_options(&tmp_root, handle, argc, argv))

625

620

continue;

626

621

627

if (register_builtin(&tmp, &plugin_ptr))

622

if (register_builtin(handle, &handle))

628

623

goto err_unlock;

629

624

630

if (plugin_initialize(plugin_ptr))

625

if (plugin_initialize(handle))

631

626

goto err_unlock;

632

627

633

628

}

649

644

*/

650

645

for (idx= 0; idx < plugin_array.elements; idx++)

651

646

{

652

plugin_ptr= *dynamic_element(&plugin_array, idx, struct st_plugin_int **);

653

if (plugin_ptr->isInited == false)

647

handle= *dynamic_element(&plugin_array, idx, Handle **);

648

if (handle->isInited == false)

654

649

{

655

if (plugin_initialize(plugin_ptr))

656

plugin_del(plugin_ptr);

650

if (plugin_initialize(handle))

651

plugin_del(handle);

657

652

}

658

653

}

659

654

670

665

}

671

666

672

667

673

static bool register_builtin(struct st_plugin_int *tmp,

674

struct st_plugin_int **ptr)

668

static bool register_builtin(Handle *tmp,

669

Handle **ptr)

675

670

{

676

671

677

672

PluginRegistry &registry= PluginRegistry::getPluginRegistry();

683

678

return(1);

684

679

685

680

*ptr= *dynamic_element(&plugin_array, plugin_array.elements - 1,

686

struct st_plugin_int **)=

687

(struct st_plugin_int *) memdup_root(&plugin_mem_root, (unsigned char*)tmp,

688

sizeof(struct st_plugin_int));

681

Handle **);

689

682

690

683

registry.add(*ptr);

691

684

701

694

{

702

695

char buffer[FN_REFLEN];

703

696

LEX_STRING name= {buffer, 0}, dl= {NULL, 0}, *str= &name;

704

struct st_plugin_dl *plugin_dl;

705

struct drizzled_plugin_manifest *plugin;

697

Library *plugin_dl;

698

Manifest *plugin;

706

699

char *p= buffer;

707

700

while (list)

708

701

{

778

771

{

779

772

uint32_t idx;

780

773

size_t count= plugin_array.elements;

781

vector<st_plugin_int *> plugins;

782

vector<st_plugin_dl *> dl;

774

vector<Handle *> plugins;

775

vector<Library *> dl;

783

776

784

777

if (initialized)

785

778

{

803

796

dl.reserve(count);

804

797

for (idx= 0; idx < count; idx++)

805

798

dl.push_back(*dynamic_element(&plugin_dl_array, idx,

806

struct st_plugin_dl **));

799

Library **));

807

800

for (idx= 0; idx < count; idx++)

808

801

free_plugin_mem(dl[idx]);

809

802

delete_dynamic(&plugin_dl_array);

1123

1116

{

1124

1117

sys_var *var;

1125

1118

sys_var_pluginvar *pi= NULL;

1126

st_plugin_int *plugin;

1119

Handle *plugin;

1127

1120

1128

1121

pthread_rwlock_rdlock(&LOCK_system_variables_hash);

1129

1122

if ((var= intern_find_sys_var(str, length, false)) &&

1867

1860

}

1868

1861

1869

1862

1870

static int construct_options(MEM_ROOT *mem_root, struct st_plugin_int *tmp,

1863

static int construct_options(MEM_ROOT *mem_root, Handle *tmp,

1871

1864

my_option *options, bool can_disable)

1872

1865

{

1873

const char *plugin_name= tmp->plugin->name;

1866

const char *plugin_name= tmp->getManifest().name;

1874

1867

uint32_t namelen= strlen(plugin_name), optnamelen;

1875

1868

uint32_t buffer_length= namelen * 4 + (can_disable ? 75 : 10);

1876

1869

char *name= (char*) alloc_root(mem_root, buffer_length) + 1;

1916

1909

by my_getopt and register_var() in the first pass uses realloc

1917

1910

*/

1918

1911

1919

for (plugin_option= tmp->plugin->system_vars;

1912

for (plugin_option= tmp->getManifest().system_vars;

1920

1913

plugin_option && *plugin_option; plugin_option++, index++)

1921

1914

{

1922

1915

opt= *plugin_option;

1953

1946

};

1954

1947

}

1955

1948

1956

for (plugin_option= tmp->plugin->system_vars;

1949

for (plugin_option= tmp->getManifest().system_vars;

1957

1950

plugin_option && *plugin_option; plugin_option++, index++)

1958

1951

{

1959

1952

switch ((opt= *plugin_option)->flags & PLUGIN_VAR_TYPEMASK) {

2082

2075

}

2083

2076

2084

2077

2085

static my_option *construct_help_options(MEM_ROOT *mem_root,

2086

struct st_plugin_int *p)

2078

static my_option *construct_help_options(MEM_ROOT *mem_root, Handle *p)

2087

2079

{

2088

2080

st_mysql_sys_var **opt;

2089

2081

my_option *opts;

2090

2082

bool can_disable;

2091

2083

uint32_t count= EXTRA_OPTIONS;

2092

2084

2093

for (opt= p->plugin->system_vars; opt && *opt; opt++, count+= 2) {};

2085

for (opt= p->getManifest().system_vars; opt && *opt; opt++, count+= 2) {};

2094

2086

2095

if (!(opts= (my_option*) alloc_root(mem_root, sizeof(my_option) * count)))

2087

opts= (my_option*)alloc_root(mem_root, (sizeof(my_option) * count));

2088

if (opts == NULL)

2096

2089

return NULL;

2097

2090

2098

2091

memset(opts, 0, sizeof(my_option) * count);

2099

2092

2100

if ((my_strcasecmp(&my_charset_utf8_general_ci, p->name.str, "MyISAM") == 0))

2093

if ((my_strcasecmp(&my_charset_utf8_general_ci, p->getName().c_str(), "MyISAM") == 0))

2101

2094

can_disable= false;

2102

else if ((my_strcasecmp(&my_charset_utf8_general_ci, p->name.str, "MEMORY") == 0))

2095

else if ((my_strcasecmp(&my_charset_utf8_general_ci, p->getName().c_str(), "MEMORY") == 0))

2103

2096

can_disable= false;

2104

2097

else

2105

2098

can_disable= true;

2125

2118

NOTE:

2126

2119

Requires that a write-lock is held on LOCK_system_variables_hash

2127

2120

*/

2128

static int test_plugin_options(MEM_ROOT *tmp_root, struct st_plugin_int *tmp,

2121

static int test_plugin_options(MEM_ROOT *tmp_root, Handle *tmp,

2129

2122

int *argc, char **argv)

2130

2123

{

2131

2124

struct sys_var_chain chain= { NULL, NULL };

2140

2133

sys_var *v;

2141

2134

struct st_bookmark *var;

2142

2135

uint32_t len, count= EXTRA_OPTIONS;

2143

assert(tmp->plugin && tmp->name.str);

2144

2136

2145

for (opt= tmp->plugin->system_vars; opt && *opt; opt++)

2137

for (opt= tmp->getManifest().system_vars; opt && *opt; opt++)

2146

2138

count+= 2; /* --{plugin}-{optname} and --plugin-{plugin}-{optname} */

2147

2139

2148

if ((my_strcasecmp(&my_charset_utf8_general_ci, tmp->name.str, "MyISAM") == 0))

2140

if ((my_strcasecmp(&my_charset_utf8_general_ci, tmp->getName().c_str(), "MyISAM") == 0))

2149

2141

can_disable= false;

2150

else if ((my_strcasecmp(&my_charset_utf8_general_ci, tmp->name.str, "MEMORY") == 0))

2142

else if ((my_strcasecmp(&my_charset_utf8_general_ci, tmp->getName().c_str(), "MEMORY") == 0))

2151

2143

can_disable= false;

2152

2144

else

2153

2145

can_disable= true;

2156

2148

{

2157

2149

if (!(opts= (my_option*) alloc_root(tmp_root, sizeof(my_option) * count)))

2158

2150

{

2159

errmsg_printf(ERRMSG_LVL_ERROR, _("Out of memory for plugin '%s'."), tmp->name.str);

2151

errmsg_printf(ERRMSG_LVL_ERROR, _("Out of memory for plugin '%s'."), tmp->getName().c_str());

2160

2152

return(-1);

2161

2153

}

2162

2154

memset(opts, 0, sizeof(my_option) * count);

2163

2155

2164

2156

if (construct_options(tmp_root, tmp, opts, can_disable))

2165

2157

{

2166

errmsg_printf(ERRMSG_LVL_ERROR, _("Bad options for plugin '%s'."), tmp->name.str);

2158

errmsg_printf(ERRMSG_LVL_ERROR, _("Bad options for plugin '%s'."), tmp->getName().c_str());

2167

2159

return(-1);

2168

2160

}

2169

2161

2173

2165

if (error)

2174

2166

{

2175

2167

errmsg_printf(ERRMSG_LVL_ERROR, _("Parsing options for plugin '%s' failed."),

2176

tmp->name.str);

2168

tmp->getName().c_str());

2177

2169

goto err;

2178

2170

}

2179

2171

}

2181

2173

error= 1;

2182

2174

2183

2175

{

2184

for (opt= tmp->plugin->system_vars; opt && *opt; opt++)

2176

for (opt= tmp->getManifest().system_vars; opt && *opt; opt++)

2185

2177

{

2186

2178

if (((o= *opt)->flags & PLUGIN_VAR_NOSYSVAR))

2187

2179

continue;

2188

2180

2189

if ((var= find_bookmark(tmp->name.str, o->name, o->flags)))

2181

if ((var= find_bookmark(tmp->getName().c_str(), o->name, o->flags)))

2190

2182

v= new (mem_root) sys_var_pluginvar(var->key + 1, o);

2191

2183

else

2192

2184

{

2193

len= tmp->name.length + strlen(o->name) + 2;

2185

len= tmp->getName().length() + strlen(o->name) + 2;

2194

2186

varname= (char*) alloc_root(mem_root, len);

2195

sprintf(varname,"%s-%s",tmp->name.str,o->name);

2187

sprintf(varname,"%s-%s",tmp->getName().c_str(),o->name);

2196

2188

my_casedn_str(&my_charset_utf8_general_ci, varname);

2197

2189

2198

2190

for (p= varname; *p; p++)

2216

2208

if (mysql_add_sys_var_chain(chain.first, NULL))

2217

2209

{

2218

2210

errmsg_printf(ERRMSG_LVL_ERROR, _("Plugin '%s' has conflicting system variables"),

2219

tmp->name.str);

2211

tmp->getName().c_str());

2220

2212

goto err;

2221

2213

}

2222

2214

tmp->system_vars= chain.first;

2235

2227

Help Verbose text with Plugin System Variables

2236

2228

****************************************************************************/

2237

2229

2238

static int option_cmp(my_option *a, my_option *b)

2239

{

2240

return my_strcasecmp(&my_charset_utf8_general_ci, a->name, b->name);

2241

}

2242

2243

2244

void my_print_help_inc_plugins(my_option *main_options, uint32_t size)

2245

{

2246

DYNAMIC_ARRAY all_options;

2247

struct st_plugin_int *p;

2230

class OptionCmp

2231

{

2232

public:

2233

bool operator() (const my_option &a, const my_option &b)

2234

{

2235

return my_strcasecmp(&my_charset_utf8_general_ci, a.name, b.name);

2236

}

2237

};

2238

2239

2240

void my_print_help_inc_plugins(my_option *main_options)

2241

{

2242

vector<my_option> all_options;

2243

Handle *p;

2248

2244

MEM_ROOT mem_root;

2249

my_option *opt;

2245

my_option *opt= NULL;

2250

2246

2251

2247

init_alloc_root(&mem_root, 4096, 4096);

2252

my_init_dynamic_array(&all_options, sizeof(my_option), size, size/4);

2253

2248

2254

2249

if (initialized)

2255

2250

for (uint32_t idx= 0; idx < plugin_array.elements; idx++)

2256

2251

{

2257

p= *dynamic_element(&plugin_array, idx, struct st_plugin_int **);

2258

2259

if (!p->plugin->system_vars ||

2260

!(opt= construct_help_options(&mem_root, p)))

2252

p= *dynamic_element(&plugin_array, idx, Handle **);

2253

2254

if (p->getManifest().system_vars == NULL)

2255

continue;

2256

2257

opt= construct_help_options(&mem_root, p);

2258

if (opt == NULL)

2261

2259

continue;

2262

2260

2263

2261

/* Only options with a non-NULL comment are displayed in help text */

2264

2262

for (;opt->id; opt++)

2263

{

2265

2264

if (opt->comment)

2266

insert_dynamic(&all_options, (unsigned char*) opt);

2265

{

2266

all_options.push_back(*opt);

2267

2268

}

2269

}

2267

2270

}

2268

2271

2269

2272

for (;main_options->id; main_options++)

2270

insert_dynamic(&all_options, (unsigned char*) main_options);

2273

{

2274

if (main_options->comment)

2275

{

2276

all_options.push_back(*main_options);

2277

}

2278

}

2271

2279

2272

sort_dynamic(&all_options, (qsort_cmp) option_cmp);

2280

/**

2281

* @TODO: Fix the my_option building so that it doens't break sort

2282

*

2283

* sort(all_options.begin(), all_options.end(), OptionCmp());

2284

*/

2273

2285

2274

2286

/* main_options now points to the empty option terminator */

2275

insert_dynamic(&all_options, (unsigned char*) main_options);

2276

2277

my_print_help((my_option*) all_options.buffer);

2278

my_print_variables((my_option*) all_options.buffer);

2279

2280

delete_dynamic(&all_options);

2287

all_options.push_back(*main_options);

2288

2289

my_print_help(&*(all_options.begin()));

2290

my_print_variables(&*(all_options.begin()));

2291

2281

2292

free_root(&mem_root, MYF(0));

2293

2282

2294

}

2283

2295