← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/show.cc

  • Committer: Brian Aker
  • Date: 2011-01-22 07:12:16 UTC
  • mfrom: (2096.1.16 alter-table)
  • Revision ID: brian@tangent.org-20110122071216-j0e8bwecb1cqefm9
Merge in work for parser cleanup.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/show.cc
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
 
4
 *  Copyright (C) 2010 Brian Aker
4
5
 *  Copyright (C) 2008 Sun Microsystems, Inc.
5
6
 *
6
7
 *  This program is free software; you can redistribute it and/or modify
50
51
#include "drizzled/internal/my_sys.h"
51
52
#include "drizzled/message/statement_transform.h"
52
53
 
 
54
#include "drizzled/statement/show.h"
 
55
#include "drizzled/statement/show_errors.h"
 
56
#include "drizzled/statement/show_warnings.h"
 
57
 
53
58
 
54
59
#include <sys/stat.h>
55
60
 
143
148
  return '`';
144
149
}
145
150
 
 
151
namespace show {
 
152
 
 
153
bool buildScemas(Session *session)
 
154
{
 
155
  session->getLex()->sql_command= SQLCOM_SELECT;
 
156
  session->getLex()->statement= new statement::Show(session);
 
157
 
 
158
  std::string column_name= "Database";
 
159
  if (session->getLex()->wild)
 
160
  {
 
161
    column_name.append(" (");
 
162
    column_name.append(session->getLex()->wild->ptr());
 
163
    column_name.append(")");
 
164
  }
 
165
 
 
166
  if (session->getLex()->current_select->where)
 
167
  {
 
168
    if (prepare_new_schema_table(session, session->getLex(), "SCHEMAS"))
 
169
      return false;
 
170
  }
 
171
  else
 
172
  {
 
173
    if (prepare_new_schema_table(session, session->getLex(), "SHOW_SCHEMAS"))
 
174
      return false;
 
175
  }
 
176
 
 
177
  Item_field *my_field= new Item_field(&session->lex->current_select->context, NULL, NULL, "SCHEMA_NAME");
 
178
  my_field->is_autogenerated_name= false;
 
179
  my_field->set_name(column_name.c_str(), column_name.length(), system_charset_info);
 
180
 
 
181
  if (session->add_item_to_list(my_field))
 
182
    return false;
 
183
 
 
184
  if (session->add_order_to_list(my_field, true))
 
185
    return false;
 
186
 
 
187
  return true;
 
188
}
 
189
 
 
190
bool buildTables(Session *session, const char *ident)
 
191
{
 
192
  session->getLex()->sql_command= SQLCOM_SELECT;
 
193
 
 
194
  drizzled::statement::Show *select= new statement::Show(session);
 
195
  session->getLex()->statement= select;
 
196
 
 
197
  std::string column_name= "Tables_in_";
 
198
 
 
199
  util::string::const_shared_ptr schema(session->schema());
 
200
  if (ident)
 
201
  {
 
202
    identifier::Schema identifier(ident);
 
203
    column_name.append(ident);
 
204
    session->getLex()->select_lex.db= const_cast<char *>(ident);
 
205
    if (not plugin::StorageEngine::doesSchemaExist(identifier))
 
206
    {
 
207
      my_error(ER_BAD_DB_ERROR, MYF(0), ident);
 
208
    }
 
209
    select->setShowPredicate(ident, "");
 
210
  }
 
211
  else if (schema and not schema->empty())
 
212
  {
 
213
    column_name.append(*schema);
 
214
    select->setShowPredicate(*schema, "");
 
215
  }
 
216
  else
 
217
  {
 
218
    my_error(ER_NO_DB_ERROR, MYF(0));
 
219
    return false;
 
220
  }
 
221
 
 
222
 
 
223
  if (session->getLex()->wild)
 
224
  {
 
225
    column_name.append(" (");
 
226
    column_name.append(session->getLex()->wild->ptr());
 
227
    column_name.append(")");
 
228
  }
 
229
 
 
230
  if (prepare_new_schema_table(session, session->getLex(), "SHOW_TABLES"))
 
231
    return false;
 
232
 
 
233
  Item_field *my_field= new Item_field(&session->lex->current_select->context, NULL, NULL, "TABLE_NAME");
 
234
  my_field->is_autogenerated_name= false;
 
235
  my_field->set_name(column_name.c_str(), column_name.length(), system_charset_info);
 
236
 
 
237
  if (session->add_item_to_list(my_field))
 
238
    return false;
 
239
 
 
240
  if (session->add_order_to_list(my_field, true))
 
241
    return false;
 
242
 
 
243
  return true;
 
244
}
 
245
 
 
246
bool buildTemporaryTables(Session *session)
 
247
{
 
248
  session->getLex()->sql_command= SQLCOM_SELECT;
 
249
 
 
250
  session->getLex()->statement= new statement::Show(session);
 
251
 
 
252
 
 
253
  if (prepare_new_schema_table(session, session->getLex(), "SHOW_TEMPORARY_TABLES"))
 
254
    return false;
 
255
 
 
256
  if (session->add_item_to_list( new Item_field(&session->lex->current_select->context, NULL, NULL, "*")))
 
257
    return false;
 
258
 
 
259
  (session->lex->current_select->with_wild)++;
 
260
 
 
261
  return true;
 
262
}
 
263
 
 
264
bool buildTableStatus(Session *session, const char *ident)
 
265
{
 
266
  session->getLex()->sql_command= SQLCOM_SELECT;
 
267
  drizzled::statement::Show *select= new statement::Show(session);
 
268
  session->getLex()->statement= select;
 
269
 
 
270
  std::string column_name= "Tables_in_";
 
271
 
 
272
  util::string::const_shared_ptr schema(session->schema());
 
273
  if (ident)
 
274
  {
 
275
    session->getLex()->select_lex.db= const_cast<char *>(ident);
 
276
 
 
277
    identifier::Schema identifier(ident);
 
278
    if (not plugin::StorageEngine::doesSchemaExist(identifier))
 
279
    {
 
280
      my_error(ER_BAD_DB_ERROR, MYF(0), ident);
 
281
    }
 
282
 
 
283
    select->setShowPredicate(ident, "");
 
284
  }
 
285
  else if (schema)
 
286
  {
 
287
    select->setShowPredicate(*schema, "");
 
288
  }
 
289
  else
 
290
  {
 
291
    my_error(ER_NO_DB_ERROR, MYF(0));
 
292
    return false;
 
293
  }
 
294
 
 
295
  if (prepare_new_schema_table(session, session->getLex(), "SHOW_TABLE_STATUS"))
 
296
    return false;
 
297
 
 
298
  if (session->add_item_to_list( new Item_field(&session->lex->current_select->
 
299
                                                  context,
 
300
                                                  NULL, NULL, "*")))
 
301
    return false;
 
302
 
 
303
  (session->lex->current_select->with_wild)++;
 
304
 
 
305
  return true;
 
306
}
 
307
 
 
308
bool buildColumns(Session *session, const char *schema_ident, Table_ident *table_ident)
 
309
{
 
310
  session->getLex()->sql_command= SQLCOM_SELECT;
 
311
 
 
312
  drizzled::statement::Show *select= new statement::Show(session);
 
313
  session->getLex()->statement= select;
 
314
 
 
315
  util::string::const_shared_ptr schema(session->schema());
 
316
  if (schema_ident)
 
317
  {
 
318
    select->setShowPredicate(schema_ident, table_ident->table.str);
 
319
  }
 
320
  else if (table_ident->db.str)
 
321
  {
 
322
    select->setShowPredicate(table_ident->db.str, table_ident->table.str);
 
323
  }
 
324
  else if (schema)
 
325
  {
 
326
    select->setShowPredicate(*schema, table_ident->table.str);
 
327
  }
 
328
  else
 
329
  {
 
330
    my_error(ER_NO_DB_ERROR, MYF(0));
 
331
    return false;
 
332
  }
 
333
 
 
334
  {
 
335
    drizzled::identifier::Table identifier(select->getShowSchema().c_str(), table_ident->table.str);
 
336
    if (not plugin::StorageEngine::doesTableExist(*session, identifier))
 
337
    {
 
338
      my_error(ER_NO_SUCH_TABLE, MYF(0),
 
339
               select->getShowSchema().c_str(), 
 
340
               table_ident->table.str);
 
341
    }
 
342
  }
 
343
 
 
344
  if (prepare_new_schema_table(session, session->getLex(), "SHOW_COLUMNS"))
 
345
    return false;
 
346
 
 
347
  if (session->add_item_to_list( new Item_field(&session->lex->current_select->context, NULL, NULL, "*")))
 
348
    return false;
 
349
 
 
350
  (session->lex->current_select->with_wild)++;
 
351
 
 
352
  return true;
 
353
}
 
354
 
 
355
bool buildWarnings(Session *session)
 
356
{
 
357
  session->getLex()->sql_command = SQLCOM_SHOW_WARNS;
 
358
  session->getLex()->statement= new statement::ShowWarnings(session);
 
359
 
 
360
  return true;
 
361
}
 
362
 
 
363
bool buildErrors(Session *session)
 
364
{
 
365
  session->getLex()->sql_command = SQLCOM_SHOW_ERRORS;
 
366
  session->getLex()->statement= new statement::ShowErrors(session);
 
367
 
 
368
  return true;
 
369
}
 
370
 
 
371
bool buildIndex(Session *session, const char *schema_ident, Table_ident *table_ident)
 
372
{
 
373
  session->getLex()->sql_command= SQLCOM_SELECT;
 
374
  drizzled::statement::Show *select= new statement::Show(session);
 
375
  session->getLex()->statement= select;
 
376
 
 
377
  util::string::const_shared_ptr schema(session->schema());
 
378
  if (schema_ident)
 
379
  {
 
380
    select->setShowPredicate(schema_ident, table_ident->table.str);
 
381
  }
 
382
  else if (table_ident->db.str)
 
383
  {
 
384
    select->setShowPredicate(table_ident->db.str, table_ident->table.str);
 
385
  }
 
386
  else if (schema)
 
387
  {
 
388
    select->setShowPredicate(*schema, table_ident->table.str);
 
389
  }
 
390
  else
 
391
  {
 
392
    my_error(ER_NO_DB_ERROR, MYF(0));
 
393
    return false;
 
394
  }
 
395
 
 
396
  {
 
397
    drizzled::identifier::Table identifier(select->getShowSchema().c_str(), table_ident->table.str);
 
398
    if (not plugin::StorageEngine::doesTableExist(*session, identifier))
 
399
    {
 
400
      my_error(ER_NO_SUCH_TABLE, MYF(0),
 
401
               select->getShowSchema().c_str(), 
 
402
               table_ident->table.str);
 
403
    }
 
404
  }
 
405
 
 
406
  if (prepare_new_schema_table(session, session->getLex(), "SHOW_INDEXES"))
 
407
    return false;
 
408
 
 
409
  if (session->add_item_to_list( new Item_field(&session->lex->current_select->context, NULL, NULL, "*")))
 
410
    return false;
 
411
 
 
412
  (session->lex->current_select->with_wild)++;
 
413
 
 
414
  return true;
 
415
}
 
416
 
 
417
bool buildStatus(Session *session, const drizzled::sql_var_t is_global)
 
418
{
 
419
  session->getLex()->sql_command= SQLCOM_SELECT;
 
420
  session->getLex()->statement= new statement::Show(session);
 
421
 
 
422
  if (is_global == OPT_GLOBAL)
 
423
  {
 
424
    if (prepare_new_schema_table(session, session->getLex(), "GLOBAL_STATUS"))
 
425
      return false;
 
426
  }
 
427
  else
 
428
  {
 
429
    if (prepare_new_schema_table(session, session->getLex(), "SESSION_STATUS"))
 
430
      return false;
 
431
  }
 
432
 
 
433
  std::string key("Variable_name");
 
434
  std::string value("Value");
 
435
 
 
436
  Item_field *my_field= new Item_field(&session->lex->current_select->context, NULL, NULL, "VARIABLE_NAME");
 
437
  my_field->is_autogenerated_name= false;
 
438
  my_field->set_name(key.c_str(), key.length(), system_charset_info);
 
439
 
 
440
  if (session->add_item_to_list(my_field))
 
441
    return false;
 
442
 
 
443
  my_field= new Item_field(&session->lex->current_select->context, NULL, NULL, "VARIABLE_VALUE");
 
444
  my_field->is_autogenerated_name= false;
 
445
  my_field->set_name(value.c_str(), value.length(), system_charset_info);
 
446
 
 
447
  if (session->add_item_to_list(my_field))
 
448
    return false;
 
449
 
 
450
  return true;
 
451
}
 
452
 
 
453
bool buildCreateTable(Session *session, Table_ident *ident)
 
454
{
 
455
  session->getLex()->sql_command= SQLCOM_SELECT;
 
456
  statement::Show *select= new statement::Show(session);
 
457
  session->getLex()->statement= select;
 
458
 
 
459
  if (session->getLex()->statement == NULL)
 
460
    return false;
 
461
 
 
462
  if (prepare_new_schema_table(session, session->getLex(), "TABLE_SQL_DEFINITION"))
 
463
    return false;
 
464
 
 
465
  util::string::const_shared_ptr schema(session->schema());
 
466
  if (ident->db.str)
 
467
  {
 
468
    select->setShowPredicate(ident->db.str, ident->table.str);
 
469
  }
 
470
  else if (schema)
 
471
  {
 
472
    select->setShowPredicate(*schema, ident->table.str);
 
473
  }
 
474
  else
 
475
  {
 
476
    my_error(ER_NO_DB_ERROR, MYF(0));
 
477
    return false;
 
478
  }
 
479
 
 
480
  std::string key("Table");
 
481
  std::string value("Create Table");
 
482
 
 
483
  Item_field *my_field= new Item_field(&session->lex->current_select->context, NULL, NULL, "TABLE_NAME");
 
484
  my_field->is_autogenerated_name= false;
 
485
  my_field->set_name(key.c_str(), key.length(), system_charset_info);
 
486
 
 
487
  if (session->add_item_to_list(my_field))
 
488
    return false;
 
489
 
 
490
  my_field= new Item_field(&session->lex->current_select->context, NULL, NULL, "TABLE_SQL_DEFINITION");
 
491
  my_field->is_autogenerated_name= false;
 
492
  my_field->set_name(value.c_str(), value.length(), system_charset_info);
 
493
 
 
494
  if (session->add_item_to_list(my_field))
 
495
    return false;
 
496
 
 
497
  return true;
 
498
}
 
499
 
 
500
bool buildProcesslist(Session *session)
 
501
{
 
502
  session->getLex()->sql_command= SQLCOM_SELECT;
 
503
  session->getLex()->statement= new statement::Show(session);
 
504
 
 
505
  if (prepare_new_schema_table(session, session->getLex(), "PROCESSLIST"))
 
506
    return false;
 
507
 
 
508
  if (session->add_item_to_list( new Item_field(&session->lex->current_select->context, NULL, NULL, "*")))
 
509
    return false;
 
510
 
 
511
  (session->lex->current_select->with_wild)++;
 
512
 
 
513
  return true;
 
514
}
 
515
 
 
516
bool buildVariables(Session *session, const drizzled::sql_var_t is_global)
 
517
{
 
518
  session->getLex()->sql_command= SQLCOM_SELECT;
 
519
  session->getLex()->statement= new statement::Show(session);
 
520
 
 
521
  if (is_global == OPT_GLOBAL)
 
522
  {
 
523
    if (prepare_new_schema_table(session, session->getLex(), "GLOBAL_VARIABLES"))
 
524
      return false;
 
525
  }
 
526
  else
 
527
  {
 
528
    if (prepare_new_schema_table(session, session->getLex(), "SESSION_VARIABLES"))
 
529
      return false;
 
530
  }
 
531
 
 
532
  std::string key("Variable_name");
 
533
  std::string value("Value");
 
534
 
 
535
  Item_field *my_field= new Item_field(&session->lex->current_select->context, NULL, NULL, "VARIABLE_NAME");
 
536
  my_field->is_autogenerated_name= false;
 
537
  my_field->set_name(key.c_str(), key.length(), system_charset_info);
 
538
 
 
539
  if (session->add_item_to_list(my_field))
 
540
    return false;
 
541
 
 
542
  my_field= new Item_field(&session->lex->current_select->context, NULL, NULL, "VARIABLE_VALUE");
 
543
  my_field->is_autogenerated_name= false;
 
544
  my_field->set_name(value.c_str(), value.length(), system_charset_info);
 
545
 
 
546
  if (session->add_item_to_list(my_field))
 
547
    return false;
 
548
 
 
549
  return true;
 
550
}
 
551
 
 
552
bool buildCreateSchema(Session *session, LEX_STRING &ident)
 
553
{
 
554
  session->getLex()->sql_command= SQLCOM_SELECT;
 
555
  drizzled::statement::Show *select= new statement::Show(session);
 
556
  session->getLex()->statement= select;
 
557
 
 
558
  if (prepare_new_schema_table(session, session->getLex(), "SCHEMA_SQL_DEFINITION"))
 
559
    return false;
 
560
 
 
561
  util::string::const_shared_ptr schema(session->schema());
 
562
  if (ident.str)
 
563
  {
 
564
    select->setShowPredicate(ident.str);
 
565
  }
 
566
  else if (schema)
 
567
  {
 
568
    select->setShowPredicate(*schema);
 
569
  }
 
570
  else
 
571
  {
 
572
    my_error(ER_NO_DB_ERROR, MYF(0));
 
573
    return false;
 
574
  }
 
575
 
 
576
  std::string key("Database");
 
577
  std::string value("Create Database");
 
578
 
 
579
  Item_field *my_field= new Item_field(&session->lex->current_select->context, NULL, NULL, "SCHEMA_NAME");
 
580
  my_field->is_autogenerated_name= false;
 
581
  my_field->set_name(key.c_str(), key.length(), system_charset_info);
 
582
 
 
583
  if (session->add_item_to_list(my_field))
 
584
    return false;
 
585
 
 
586
  my_field= new Item_field(&session->lex->current_select->context, NULL, NULL, "SCHEMA_SQL_DEFINITION");
 
587
  my_field->is_autogenerated_name= false;
 
588
  my_field->set_name(value.c_str(), value.length(), system_charset_info);
 
589
 
 
590
  if (session->add_item_to_list(my_field))
 
591
    return false;
 
592
 
 
593
  return true;
 
594
}
 
595
 
 
596
bool buildDescribe(Session *session, Table_ident *ident)
 
597
{
 
598
  session->getLex()->lock_option= TL_READ;
 
599
  init_select(session->getLex());
 
600
  session->getLex()->current_select->parsing_place= SELECT_LIST;
 
601
  session->getLex()->sql_command= SQLCOM_SELECT;
 
602
  drizzled::statement::Show *select= new statement::Show(session);
 
603
  session->getLex()->statement= select;
 
604
  session->getLex()->select_lex.db= 0;
 
605
 
 
606
  util::string::const_shared_ptr schema(session->schema());
 
607
  if (ident->db.str)
 
608
  {
 
609
    select->setShowPredicate(ident->db.str, ident->table.str);
 
610
  }
 
611
  else if (schema)
 
612
  {
 
613
    select->setShowPredicate(*schema, ident->table.str);
 
614
  }
 
615
  else
 
616
  {
 
617
    my_error(ER_NO_DB_ERROR, MYF(0));
 
618
    return false;
 
619
  }
 
620
 
 
621
  {
 
622
    drizzled::identifier::Table identifier(select->getShowSchema().c_str(), ident->table.str);
 
623
    if (not plugin::StorageEngine::doesTableExist(*session, identifier))
 
624
    {
 
625
      my_error(ER_NO_SUCH_TABLE, MYF(0),
 
626
               select->getShowSchema().c_str(), 
 
627
               ident->table.str);
 
628
    }
 
629
  }
 
630
 
 
631
  if (prepare_new_schema_table(session, session->getLex(), "SHOW_COLUMNS"))
 
632
  {
 
633
    return false;
 
634
  }
 
635
 
 
636
  if (session->add_item_to_list( new Item_field(&session->lex->current_select->
 
637
                                                  context,
 
638
                                                  NULL, NULL, "*")))
 
639
  {
 
640
    return false;
 
641
  }
 
642
 
 
643
  (session->lex->current_select->with_wild)++;
 
644
 
 
645
  return true;
 
646
}
 
647
 
 
648
} /* namespace drizzled */
 
649
 
146
650
} /* namespace drizzled */