← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_parse.cc

  • Committer: Olaf van der Spek
  • Date: 2011-10-17 21:54:16 UTC
  • mfrom: (2440.3.1 rf)
  • mto: This revision was merged to the branch mainline in revision 2442.
  • Revision ID: olafvdspek@gmail.com-20111017215416-vqk97rkutm3hujjz
Refactor

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_parse.cc
451
451
 
452
452
static int execute_command(Session *session)
453
453
{
454
 
  bool res= false;
455
 
 
456
454
  /* first Select_Lex (have special meaning for many of non-SELECTcommands) */
457
455
  Select_Lex *select_lex= &session->lex().select_lex;
458
456
 
459
 
  /* list of all tables in query */
460
 
  TableList *all_tables;
461
 
 
462
457
  /*
463
458
    In many cases first table of main Select_Lex have special meaning =>
464
459
    check that it is first table in global list and relink it first in
476
471
  */
477
472
  session->lex().first_lists_tables_same();
478
473
 
 
474
  /* list of all tables in query */
479
475
  /* should be assigned after making first tables same */
480
 
  all_tables= session->lex().query_tables;
 
476
  TableList* all_tables= session->lex().query_tables;
481
477
 
482
478
  /* set context for commands which do not use setup_tables */
483
479
  select_lex->context.resolve_in_table_list_only((TableList*)select_lex->table_list.first);
496
492
 
497
493
  assert(not session->transaction.stmt.hasModifiedNonTransData());
498
494
 
499
 
  if (! (session->server_status & SERVER_STATUS_AUTOCOMMIT)
500
 
      && ! session->inTransaction()
 
495
  if (not (session->server_status & SERVER_STATUS_AUTOCOMMIT)
 
496
      && not session->inTransaction()
501
497
      && session->lex().statement->isTransactional())
502
498
  {
503
499
    if (not session->startTransaction())
508
504
  }
509
505
 
510
506
  /* now we are ready to execute the statement */
511
 
  res= session->lex().statement->execute();
 
507
  bool res= session->lex().statement->execute();
512
508
  session->set_proc_info("query end");
513
509
  /*
514
510
    The return value for ROW_COUNT() is "implementation dependent" if the
516
512
    wants. We also keep the last value in case of SQLCOM_CALL or
517
513
    SQLCOM_EXECUTE.
518
514
  */
519
 
  if (! (sql_command_flags[session->lex().sql_command].test(CF_BIT_HAS_ROW_COUNT)))
 
515
  if (not sql_command_flags[session->lex().sql_command].test(CF_BIT_HAS_ROW_COUNT))
520
516
  {
521
517
    session->row_count_func= -1;
522
518
  }
523
519
 
524
 
  return (res || session->is_error());
 
520
  return res || session->is_error();
525
521
}
 
522
 
526
523
bool execute_sqlcom_select(Session *session, TableList *all_tables)
527
524
{
528
525
  LEX   *lex= &session->lex();
805
802
  LEX  *lex= &session->lex();
806
803
  statement::AlterTable *statement= (statement::AlterTable *)lex->statement;
807
804
 
808
 
  if (check_identifier_name(field_name, ER_TOO_LONG_IDENT))
 
805
  if (check_identifier_name(*field_name, ER_TOO_LONG_IDENT))
809
806
    return true;
810
807
 
811
808
  if (type_modifier & PRI_KEY_FLAG)
1568
1565
}
1569
1566
 
1570
1567
 
1571
 
bool check_identifier_name(lex_string_t *str, error_t err_code,
1572
 
                           uint32_t max_char_length,
1573
 
                           const char *param_for_err_msg)
 
1568
bool check_identifier_name(lex_string_t str, error_t err_code)
1574
1569
{
 
1570
  uint32_t max_char_length= NAME_CHAR_LEN;
1575
1571
  /*
1576
1572
    We don't support non-BMP characters in identifiers at the moment,
1577
1573
    so they should be prohibited until such support is done.
1580
1576
  const charset_info_st * const cs= &my_charset_utf8mb4_general_ci;
1581
1577
 
1582
1578
  int well_formed_error;
1583
 
  uint32_t res= cs->cset->well_formed_len(cs, str->begin(), str->end(), max_char_length, &well_formed_error);
 
1579
  uint32_t res= cs->cset->well_formed_len(cs, str.begin(), str.end(), max_char_length, &well_formed_error);
1584
1580
 
1585
1581
  if (well_formed_error)
1586
1582
  {
1587
 
    my_error(ER_INVALID_CHARACTER_STRING, MYF(0), "identifier", str->data());
 
1583
    my_error(ER_INVALID_CHARACTER_STRING, MYF(0), "identifier", str.data());
1588
1584
    return true;
1589
1585
  }
1590
1586
 
1591
 
  if (str->size() == res)
 
1587
  if (str.size() == res)
1592
1588
    return false;
1593
1589
 
1594
1590
  switch (err_code)
1596
1592
  case EE_OK:
1597
1593
    break;
1598
1594
  case ER_WRONG_STRING_LENGTH:
1599
 
    my_error(err_code, MYF(0), str->data(), param_for_err_msg, max_char_length);
 
1595
    my_error(err_code, MYF(0), str.data(), "", max_char_length);
1600
1596
    break;
1601
1597
  case ER_TOO_LONG_IDENT:
1602
 
    my_error(err_code, MYF(0), str->data());
 
1598
    my_error(err_code, MYF(0), str.data());
1603
1599
    break;
1604
1600
  default:
1605
1601
    assert(false);