← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/handler/ha_innodb.cc

  • Committer: Stewart Smith
  • Date: 2011-01-13 06:27:34 UTC
  • mto: This revision was merged to the branch mainline in revision 2083.
  • Revision ID: stewart@flamingspork.com-20110113062734-m3dg1vz2ussyykmy
https://launchpad.net/bugs/582486
remove suppressions from valgrind.supp for bug 582486 which seems to have been fixed at some point in the past.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/handler/ha_innodb.cc
114
114
#include "ha_prototypes.h"
115
115
#include "ut0mem.h"
116
116
#include "ibuf0ibuf.h"
 
117
#include "mysql_addons.h"
117
118
 
118
119
#include "ha_innodb.h"
119
120
#include "data_dictionary.h"
133
134
#include <google/protobuf/io/coded_stream.h>
134
135
#include <google/protobuf/text_format.h>
135
136
 
136
 
#include <boost/thread/mutex.hpp>
137
 
 
138
137
using namespace std;
139
138
using namespace drizzled;
140
139
 
141
140
/** to protect innobase_open_files */
142
 
static boost::mutex innobase_share_mutex;
143
 
 
 
141
static pthread_mutex_t innobase_share_mutex;
144
142
/** to force correct commit order in binlog */
 
143
static pthread_mutex_t prepare_commit_mutex;
145
144
static ulong commit_threads = 0;
146
 
static boost::condition_variable commit_cond;
147
 
static boost::mutex commit_cond_m;
 
145
static pthread_mutex_t commit_threads_m;
 
146
static pthread_cond_t commit_cond;
 
147
static pthread_mutex_t commit_cond_m;
148
148
static bool innodb_inited = 0;
149
149
 
150
150
#define INSIDE_HA_INNOBASE_CC
160
160
#endif /* MYSQL_DYNAMIC_PLUGIN && __WIN__ */
161
161
 
162
162
static plugin::XaStorageEngine* innodb_engine_ptr= NULL;
163
 
 
 
163
static plugin::TableFunction* status_table_function_ptr= NULL;
 
164
static plugin::TableFunction* cmp_tool= NULL;
 
165
static plugin::TableFunction* cmp_reset_tool= NULL;
 
166
static plugin::TableFunction* cmp_mem_tool= NULL;
 
167
static plugin::TableFunction* cmp_mem_reset_tool= NULL;
 
168
static plugin::TableFunction* innodb_trx_tool= NULL;
 
169
static plugin::TableFunction* innodb_locks_tool= NULL;
 
170
static plugin::TableFunction* innodb_lock_waits_tool= NULL;
 
171
static plugin::TableFunction* innodb_sys_tables_tool= NULL;
 
172
static plugin::TableFunction* innodb_sys_tablestats_tool= NULL;
 
173
 
 
174
static plugin::TableFunction* innodb_sys_indexes_tool= NULL;
 
175
static plugin::TableFunction* innodb_sys_columns_tool= NULL;
 
176
static plugin::TableFunction* innodb_sys_fields_tool= NULL;
 
177
static plugin::TableFunction* innodb_sys_foreign_tool= NULL;
 
178
static plugin::TableFunction* innodb_sys_foreign_cols_tool= NULL;
 
179
 
 
180
static ReplicationLog *replication_logger= NULL;
164
181
typedef constrained_check<uint32_t, UINT32_MAX, 10> open_files_constraint;
165
182
static open_files_constraint innobase_open_files;
166
183
typedef constrained_check<uint32_t, 10, 1> mirrored_log_groups_constraint;
333
350
      srv_free_paths_and_sizes();
334
351
      if (internal_innobase_data_file_path)
335
352
        free(internal_innobase_data_file_path);
 
353
      pthread_mutex_destroy(&innobase_share_mutex);
 
354
      pthread_mutex_destroy(&prepare_commit_mutex);
 
355
      pthread_mutex_destroy(&commit_threads_m);
 
356
      pthread_mutex_destroy(&commit_cond_m);
 
357
      pthread_cond_destroy(&commit_cond);
336
358
    }
337
359
    
338
360
    /* These get strdup'd from vm variables */
422
444
  doDropSchema(
423
445
  /*===================*/
424
446
        /* out: error number */
425
 
    const identifier::Schema  &identifier); /* in: database path; inside InnoDB the name
 
447
    const SchemaIdentifier  &identifier); /* in: database path; inside InnoDB the name
426
448
        of the last directory in the path is used as
427
449
        the database name: for example, in 'mysql/data/test'
428
450
        the database name is 'test' */
461
483
 
462
484
  UNIV_INTERN int doCreateTable(Session &session,
463
485
                                Table &form,
464
 
                                const identifier::Table &identifier,
 
486
                                const TableIdentifier &identifier,
465
487
                                message::Table&);
466
 
  UNIV_INTERN int doRenameTable(Session&, const identifier::Table &from, const identifier::Table &to);
467
 
  UNIV_INTERN int doDropTable(Session &session, const identifier::Table &identifier);
 
488
  UNIV_INTERN int doRenameTable(Session&, const TableIdentifier &from, const TableIdentifier &to);
 
489
  UNIV_INTERN int doDropTable(Session &session, const TableIdentifier &identifier);
468
490
 
469
 
  UNIV_INTERN virtual bool get_error_message(int error, String *buf) const;
 
491
  UNIV_INTERN virtual bool get_error_message(int error, String *buf);
470
492
 
471
493
  UNIV_INTERN uint32_t max_supported_keys() const;
472
494
  UNIV_INTERN uint32_t max_supported_key_length() const;
483
505
  }
484
506
 
485
507
  int doGetTableDefinition(drizzled::Session& session,
486
 
                           const identifier::Table &identifier,
 
508
                           const TableIdentifier &identifier,
487
509
                           drizzled::message::Table &table_proto);
488
510
 
489
 
  bool doDoesTableExist(drizzled::Session& session, const identifier::Table &identifier);
 
511
  bool doDoesTableExist(drizzled::Session& session, const TableIdentifier &identifier);
490
512
 
491
513
  void doGetTableIdentifiers(drizzled::CachedDirectory &directory,
492
 
                             const drizzled::identifier::Schema &schema_identifier,
493
 
                             drizzled::identifier::Table::vector &set_of_identifiers);
 
514
                             const drizzled::SchemaIdentifier &schema_identifier,
 
515
                             drizzled::TableIdentifier::vector &set_of_identifiers);
494
516
  bool validateCreateTableOption(const std::string &key, const std::string &state);
495
517
  void dropTemporarySchema();
496
518
 
518
540
}
519
541
 
520
542
void InnobaseEngine::doGetTableIdentifiers(drizzled::CachedDirectory &directory,
521
 
                                           const drizzled::identifier::Schema &schema_identifier,
522
 
                                           drizzled::identifier::Table::vector &set_of_identifiers)
 
543
                                           const drizzled::SchemaIdentifier &schema_identifier,
 
544
                                           drizzled::TableIdentifier::vector &set_of_identifiers)
523
545
{
524
546
  CachedDirectory::Entries entries= directory.getEntries();
525
547
 
526
 
  std::string search_string(schema_identifier.getSchemaName());
527
 
 
528
 
  boost::algorithm::to_lower(search_string);
529
 
 
530
 
  if (search_string.compare("data_dictionary") == 0)
531
 
  {
532
 
    set_of_identifiers.push_back(identifier::Table(schema_identifier.getSchemaName(), "SYS_REPLICATION_LOG"));
533
 
  }
534
 
 
535
548
  for (CachedDirectory::Entries::iterator entry_iter= entries.begin(); 
536
549
       entry_iter != entries.end(); ++entry_iter)
537
550
  {
559
572
           Using schema_identifier here to stop unused warning, could use
560
573
           definition.schema() instead
561
574
        */
562
 
        identifier::Table identifier(schema_identifier.getSchemaName(), definition.name());
 
575
        TableIdentifier identifier(schema_identifier.getSchemaName(), definition.name());
563
576
        set_of_identifiers.push_back(identifier);
564
577
      }
565
578
    }
566
579
  }
567
580
}
568
581
 
569
 
bool InnobaseEngine::doDoesTableExist(Session &session, const identifier::Table &identifier)
 
582
bool InnobaseEngine::doDoesTableExist(Session &session, const TableIdentifier &identifier)
570
583
{
571
584
  string proto_path(identifier.getPath());
572
585
  proto_path.append(DEFAULT_FILE_EXTENSION);
574
587
  if (session.getMessageCache().doesTableMessageExist(identifier))
575
588
    return true;
576
589
 
577
 
  std::string search_string(identifier.getPath());
578
 
  boost::algorithm::to_lower(search_string);
579
 
 
580
 
  if (search_string.compare("data_dictionary/sys_replication_log") == 0)
581
 
    return true;
582
 
 
583
590
  if (access(proto_path.c_str(), F_OK))
584
591
  {
585
592
    return false;
589
596
}
590
597
 
591
598
int InnobaseEngine::doGetTableDefinition(Session &session,
592
 
                                         const identifier::Table &identifier,
 
599
                                         const TableIdentifier &identifier,
593
600
                                         message::Table &table_proto)
594
601
{
595
602
  string proto_path(identifier.getPath());
599
606
  if (session.getMessageCache().getTableMessage(identifier, table_proto))
600
607
    return EEXIST;
601
608
 
602
 
  if (read_replication_log_table_message(identifier.getTableName().c_str(), &table_proto) == 0)
603
 
    return EEXIST;
604
 
 
605
609
  if (access(proto_path.c_str(), F_OK))
606
610
  {
607
611
    return errno;
802
806
ibool
803
807
thd_is_replication_slave_thread(
804
808
/*============================*/
805
 
  drizzled::Session* ) /*!< in: thread handle (Session*) */
 
809
  void* ) /*!< in: thread handle (Session*) */
806
810
{
807
811
  return false;
808
812
}
876
880
ibool
877
881
thd_has_edited_nontrans_tables(
878
882
/*===========================*/
879
 
  drizzled::Session *session)  /*!< in: thread handle (Session*) */
 
883
  void*   session)  /*!< in: thread handle (Session*) */
880
884
{
881
 
  return((ibool)session->transaction.all.hasModifiedNonTransData());
 
885
  return((ibool)((Session *)session)->transaction.all.hasModifiedNonTransData());
882
886
}
883
887
 
884
888
/******************************************************************//**
888
892
ibool
889
893
thd_is_select(
890
894
/*==========*/
891
 
  const drizzled::Session *session)  /*!< in: thread handle (Session*) */
 
895
  const void* session)  /*!< in: thread handle (Session*) */
892
896
{
893
 
  return(session->getSqlCommand() == SQLCOM_SELECT);
 
897
  return(session_sql_command((const Session*) session) == SQLCOM_SELECT);
894
898
}
895
899
 
896
900
/******************************************************************//**
901
905
ibool
902
906
thd_supports_xa(
903
907
/*============*/
904
 
  drizzled::Session* )  /*!< in: thread handle (Session*), or NULL to query
 
908
  void* )  /*!< in: thread handle (Session*), or NULL to query
905
909
        the global innodb_supports_xa */
906
910
{
907
911
  /* TODO: Add support here for per-session value */
915
919
ulong
916
920
thd_lock_wait_timeout(
917
921
/*==================*/
918
 
  drizzled::Session*)  /*!< in: thread handle (Session*), or NULL to query
 
922
  void*)  /*!< in: thread handle (Session*), or NULL to query
919
923
      the global innodb_lock_wait_timeout */
920
924
{
921
925
  /* TODO: Add support here for per-session value */
930
934
void
931
935
thd_set_lock_wait_time(
932
936
/*===================*/
933
 
        drizzled::Session*      in_session,     /*!< in: thread handle (THD*) */
 
937
        void*   thd,    /*!< in: thread handle (THD*) */
934
938
        ulint   value)  /*!< in: time waited for the lock */
935
939
{
936
 
  if (in_session)
937
 
    in_session->utime_after_lock+= value;
 
940
        if (thd) {
 
941
          static_cast<Session*>(thd)->utime_after_lock+= value;
 
942
        }
938
943
}
939
944
 
940
945
/********************************************************************//**
960
965
  trx_t *trx= session_to_trx(&session);
961
966
 
962
967
  uint64_t trx_id= message.transaction_context().transaction_id();
963
 
  uint32_t seg_id= message.segment_id();
964
 
  uint64_t end_timestamp= message.transaction_context().end_timestamp();
965
 
  bool is_end_segment= message.end_segment();
966
 
  trx->log_commit_id= TRUE;
967
 
  ulint error= insert_replication_message(data, message.ByteSize(), trx, trx_id,
968
 
               end_timestamp, is_end_segment, seg_id);
 
968
  ulint error= insert_replication_message(data, message.ByteSize(), trx, trx_id);
969
969
  (void)error;
970
970
 
971
971
  delete[] data;
1076
1076
    tell it also to MySQL so that MySQL knows to empty the
1077
1077
    cached binlog for this transaction */
1078
1078
 
1079
 
    session->markTransactionForRollback(TRUE);
 
1079
    mark_transaction_to_rollback(session, TRUE);
1080
1080
 
1081
1081
    return(HA_ERR_LOCK_DEADLOCK);
1082
1082
 
1085
1085
    latest SQL statement in a lock wait timeout. Previously, we
1086
1086
    rolled back the whole transaction. */
1087
1087
 
1088
 
    session->markTransactionForRollback((bool)row_rollback_on_timeout);
 
1088
    mark_transaction_to_rollback(session, (bool)row_rollback_on_timeout);
1089
1089
 
1090
1090
    return(HA_ERR_LOCK_WAIT_TIMEOUT);
1091
1091
 
1121
1121
 
1122
1122
  case DB_TOO_BIG_RECORD:
1123
1123
    my_error(ER_TOO_BIG_ROWSIZE, MYF(0),
1124
 
             page_get_free_space_of_empty(flags & DICT_TF_COMPACT) / 2);
 
1124
       page_get_free_space_of_empty(flags
 
1125
                  & DICT_TF_COMPACT) / 2);
1125
1126
    return(HA_ERR_TO_BIG_ROW);
1126
1127
 
1127
1128
  case DB_NO_SAVEPOINT:
1132
1133
    tell it also to MySQL so that MySQL knows to empty the
1133
1134
    cached binlog for this transaction */
1134
1135
 
1135
 
    session->markTransactionForRollback(TRUE);
 
1136
    mark_transaction_to_rollback(session, TRUE);
1136
1137
 
1137
1138
    return(HA_ERR_LOCK_TABLE_FULL);
1138
1139
 
1171
1172
innobase_mysql_print_thd(
1172
1173
/*=====================*/
1173
1174
  FILE* f,    /*!< in: output stream */
1174
 
  drizzled::Session *in_session,  /*!< in: pointer to a Drizzle Session object */
 
1175
  void * in_session,  /*!< in: pointer to a Drizzle Session object */
1175
1176
  uint  )   /*!< in: max query length to print, or 0 to
1176
1177
           use the default max length */
1177
1178
{
1178
 
  drizzled::identifier::User::const_shared_ptr user_identifier(in_session->user());
 
1179
  Session *session= reinterpret_cast<Session *>(in_session);
 
1180
  drizzled::identifier::User::const_shared_ptr user_identifier(session->user());
1179
1181
 
1180
1182
  fprintf(f,
1181
1183
          "Drizzle thread %"PRIu64", query id %"PRIu64", %s, %s, %s ",
1182
 
          static_cast<uint64_t>(in_session->getSessionId()),
1183
 
          static_cast<uint64_t>(in_session->getQueryId()),
 
1184
          static_cast<uint64_t>(session->getSessionId()),
 
1185
          static_cast<uint64_t>(session->getQueryId()),
1184
1186
          glob_hostname,
1185
1187
          user_identifier->address().c_str(),
1186
1188
          user_identifier->username().c_str()
1187
1189
  );
1188
 
  fprintf(f, "\n%s", in_session->getQueryString()->c_str());
 
1190
  fprintf(f, "\n%s", session->getQueryString()->c_str());
1189
1191
  putc('\n', f);
1190
1192
}
1191
1193
 
1268
1270
  my_casedn_str(system_charset_info, a);
1269
1271
}
1270
1272
 
 
1273
/**********************************************************************//**
 
1274
Determines the connection character set.
 
1275
@return connection character set */
 
1276
UNIV_INTERN
 
1277
const void*
 
1278
innobase_get_charset(
 
1279
/*=================*/
 
1280
  void* mysql_session)  /*!< in: MySQL thread handle */
 
1281
{
 
1282
  return static_cast<Session*>(mysql_session)->charset();
 
1283
}
 
1284
 
1271
1285
UNIV_INTERN
1272
1286
bool
1273
1287
innobase_isspace(
1277
1291
  return my_isspace(static_cast<const CHARSET_INFO *>(cs), char_to_test);
1278
1292
}
1279
1293
 
 
1294
UNIV_INTERN
 
1295
int
 
1296
innobase_fast_mutex_init(
 
1297
        os_fast_mutex_t*        fast_mutex)
 
1298
{
 
1299
  return pthread_mutex_init(fast_mutex, MY_MUTEX_INIT_FAST);
 
1300
}
 
1301
 
 
1302
/**********************************************************************//**
 
1303
Determines the current SQL statement.
 
1304
@return        SQL statement string */
 
1305
UNIV_INTERN
 
1306
const char*
 
1307
innobase_get_stmt(
 
1308
/*==============*/
 
1309
       void*   session,        /*!< in: MySQL thread handle */
 
1310
       size_t* length)         /*!< out: length of the SQL statement */
 
1311
{
 
1312
  return static_cast<Session*>(session)->getQueryStringCopy(*length);
 
1313
}
 
1314
 
1280
1315
#if defined (__WIN__) && defined (MYSQL_DYNAMIC_PLUGIN)
1281
1316
/*******************************************************************//**
1282
1317
Map an OS error to an errno value. The OS error number is stored in
1631
1666
  ulint   buflen, /*!< in: length of buf, in bytes */
1632
1667
  const char* id, /*!< in: identifier to convert */
1633
1668
  ulint   idlen,  /*!< in: length of id, in bytes */
1634
 
  drizzled::Session *session,/*!< in: MySQL connection thread, or NULL */
 
1669
  void*   session,/*!< in: MySQL connection thread, or NULL */
1635
1670
  ibool   file_id)/*!< in: TRUE=id is a table or database name;
1636
1671
        FALSE=id is an UTF-8 string */
1637
1672
{
1655
1690
    nz[idlen] = 0;
1656
1691
 
1657
1692
    s = nz2.get();
1658
 
    idlen = identifier::Table::filename_to_tablename(nz, nz2.get(), nz2_size);
 
1693
    idlen = TableIdentifier::filename_to_tablename(nz, nz2.get(), nz2_size);
1659
1694
  }
1660
1695
 
1661
1696
  /* See if the identifier needs to be quoted. */
1717
1752
  ulint   buflen, /*!< in: length of buf, in bytes */
1718
1753
  const char* id, /*!< in: identifier to convert */
1719
1754
  ulint   idlen,  /*!< in: length of id, in bytes */
1720
 
  drizzled::Session *session,/*!< in: MySQL connection thread, or NULL */
 
1755
  void*   session,/*!< in: MySQL connection thread, or NULL */
1721
1756
  ibool   table_id)/*!< in: TRUE=id is a table or database name;
1722
1757
        FALSE=id is an index name */
1723
1758
{
1771
1806
/*===============*/
1772
1807
  trx_t*  trx)  /*!< in: transaction */
1773
1808
{
1774
 
  return(trx && trx->mysql_thd && trx->mysql_thd->getKilled());
 
1809
  return(trx && trx->mysql_thd && static_cast<Session*>(trx->mysql_thd)->getKilled());
1775
1810
}
1776
1811
 
1777
1812
/**********************************************************************//**
1981
2016
 
1982
2017
      if (trx_sys_file_format_max_set(format_id, &name_buff))
1983
2018
      {
1984
 
        errmsg_printf(error::WARN,
 
2019
        errmsg_printf(ERRMSG_LVL_WARN,
1985
2020
                      " [Info] InnoDB: the file format in the system "
1986
2021
                      "tablespace is now set to %s.\n", name_buff);
1987
2022
        innobase_file_format_max= name_buff;
2081
2116
      || strcmp(test_tablename.get()
2082
2117
                + srv_mysql50_table_name_prefix.size(),
2083
2118
                test_filename)) {
2084
 
    errmsg_printf(error::ERROR, "tablename encoding has been changed");
 
2119
    errmsg_printf(ERRMSG_LVL_ERROR, "tablename encoding has been changed");
2085
2120
    goto error;
2086
2121
  }
2087
2122
#endif /* UNIV_DEBUG */
2115
2150
  ret = (bool) srv_parse_data_file_paths_and_sizes(
2116
2151
                                                   internal_innobase_data_file_path);
2117
2152
  if (ret == FALSE) {
2118
 
    errmsg_printf(error::ERROR, "InnoDB: syntax error in innodb_data_file_path");
2119
 
 
 
2153
    errmsg_printf(ERRMSG_LVL_ERROR, 
 
2154
                  "InnoDB: syntax error in innodb_data_file_path");
2120
2155
mem_free_and_error:
2121
2156
    srv_free_paths_and_sizes();
2122
2157
    if (internal_innobase_data_file_path)
2141
2176
    srv_parse_log_group_home_dirs((char *)innobase_log_group_home_dir.c_str());
2142
2177
 
2143
2178
  if (ret == FALSE || innobase_mirrored_log_groups.get() != 1) {
2144
 
    errmsg_printf(error::ERROR, _("syntax error in innodb_log_group_home_dir, or a "
2145
 
                                  "wrong number of mirrored log groups"));
 
2179
    errmsg_printf(ERRMSG_LVL_ERROR,
 
2180
                  _("syntax error in innodb_log_group_home_dir, or a "
 
2181
                  "wrong number of mirrored log groups"));
2146
2182
 
2147
2183
    goto mem_free_and_error;
2148
2184
  }
2156
2192
 
2157
2193
    if (format_id > DICT_TF_FORMAT_MAX) {
2158
2194
 
2159
 
      errmsg_printf(error::ERROR, "InnoDB: wrong innodb_file_format.");
 
2195
      errmsg_printf(ERRMSG_LVL_ERROR, "InnoDB: wrong innodb_file_format.");
2160
2196
 
2161
2197
      goto mem_free_and_error;
2162
2198
    }
2185
2221
     srv_max_file_format_at_startup */
2186
2222
  if (innobase_file_format_validate_and_set(innobase_file_format_max.c_str()) < 0)
2187
2223
  {
2188
 
    errmsg_printf(error::ERROR, _("InnoDB: invalid innodb_file_format_max value: "
2189
 
                                  "should be any value up to %s or its equivalent numeric id"),
2190
 
                  trx_sys_file_format_id_to_name(DICT_TF_FORMAT_MAX));
 
2224
    errmsg_printf(ERRMSG_LVL_ERROR, _("InnoDB: invalid "
 
2225
                    "innodb_file_format_max value: "
 
2226
                    "should be any value up to %s or its "
 
2227
                    "equivalent numeric id"),
 
2228
                    trx_sys_file_format_id_to_name(DICT_TF_FORMAT_MAX));
2191
2229
    goto mem_free_and_error;
2192
2230
  }
2193
2231
 
2206
2244
      }
2207
2245
    }
2208
2246
 
2209
 
    errmsg_printf(error::ERROR, "InnoDB: invalid value innodb_change_buffering=%s",
 
2247
    errmsg_printf(ERRMSG_LVL_ERROR,
 
2248
                  "InnoDB: invalid value "
 
2249
                  "innodb_change_buffering=%s",
2210
2250
                  vm["change-buffering"].as<string>().c_str());
2211
2251
    goto mem_free_and_error;
2212
2252
  }
2284
2324
                                                     TRUE);
2285
2325
 
2286
2326
  innobase_open_tables = hash_create(200);
 
2327
  pthread_mutex_init(&innobase_share_mutex, MY_MUTEX_INIT_FAST);
 
2328
  pthread_mutex_init(&prepare_commit_mutex, MY_MUTEX_INIT_FAST);
 
2329
  pthread_mutex_init(&commit_threads_m, MY_MUTEX_INIT_FAST);
 
2330
  pthread_mutex_init(&commit_cond_m, MY_MUTEX_INIT_FAST);
 
2331
  pthread_cond_init(&commit_cond, NULL);
2287
2332
  innodb_inited= 1;
2288
2333
 
2289
2334
  actuall_engine_ptr->dropTemporarySchema();
2290
2335
 
2291
 
  context.add(new InnodbStatusTool);
 
2336
  status_table_function_ptr= new InnodbStatusTool;
2292
2337
 
2293
2338
  context.add(innodb_engine_ptr);
2294
2339
 
2295
 
  context.add(new(std::nothrow)CmpTool(false));
2296
 
 
2297
 
  context.add(new(std::nothrow)CmpTool(true));
2298
 
 
2299
 
  context.add(new(std::nothrow)CmpmemTool(false));
2300
 
 
2301
 
  context.add(new(std::nothrow)CmpmemTool(true));
2302
 
 
2303
 
  context.add(new(std::nothrow)InnodbTrxTool("INNODB_TRX"));
2304
 
 
2305
 
  context.add(new(std::nothrow)InnodbTrxTool("INNODB_LOCKS"));
2306
 
 
2307
 
  context.add(new(std::nothrow)InnodbTrxTool("INNODB_LOCK_WAITS"));
2308
 
 
2309
 
  context.add(new(std::nothrow)InnodbSysTablesTool());
2310
 
 
2311
 
  context.add(new(std::nothrow)InnodbSysTableStatsTool());
2312
 
 
2313
 
  context.add(new(std::nothrow)InnodbSysIndexesTool());
2314
 
 
2315
 
  context.add(new(std::nothrow)InnodbSysColumnsTool());
2316
 
 
2317
 
  context.add(new(std::nothrow)InnodbSysFieldsTool());
2318
 
 
2319
 
  context.add(new(std::nothrow)InnodbSysForeignTool());
2320
 
 
2321
 
  context.add(new(std::nothrow)InnodbSysForeignColsTool());
 
2340
  context.add(status_table_function_ptr);
 
2341
 
 
2342
  cmp_tool= new(std::nothrow)CmpTool(false);
 
2343
  context.add(cmp_tool);
 
2344
 
 
2345
  cmp_reset_tool= new(std::nothrow)CmpTool(true);
 
2346
  context.add(cmp_reset_tool);
 
2347
 
 
2348
  cmp_mem_tool= new(std::nothrow)CmpmemTool(false);
 
2349
  context.add(cmp_mem_tool);
 
2350
 
 
2351
  cmp_mem_reset_tool= new(std::nothrow)CmpmemTool(true);
 
2352
  context.add(cmp_mem_reset_tool);
 
2353
 
 
2354
  innodb_trx_tool= new(std::nothrow)InnodbTrxTool("INNODB_TRX");
 
2355
  context.add(innodb_trx_tool);
 
2356
 
 
2357
  innodb_locks_tool= new(std::nothrow)InnodbTrxTool("INNODB_LOCKS");
 
2358
  context.add(innodb_locks_tool);
 
2359
 
 
2360
  innodb_lock_waits_tool= new(std::nothrow)InnodbTrxTool("INNODB_LOCK_WAITS");
 
2361
  context.add(innodb_lock_waits_tool);
 
2362
 
 
2363
  innodb_sys_tables_tool= new(std::nothrow)InnodbSysTablesTool();
 
2364
  context.add(innodb_sys_tables_tool);
 
2365
 
 
2366
  innodb_sys_tablestats_tool= new(std::nothrow)InnodbSysTableStatsTool();
 
2367
  context.add(innodb_sys_tablestats_tool);
 
2368
 
 
2369
  innodb_sys_indexes_tool= new(std::nothrow)InnodbSysIndexesTool();
 
2370
  context.add(innodb_sys_indexes_tool);
 
2371
 
 
2372
  innodb_sys_columns_tool= new(std::nothrow)InnodbSysColumnsTool();
 
2373
  context.add(innodb_sys_columns_tool);
 
2374
 
 
2375
  innodb_sys_fields_tool= new(std::nothrow)InnodbSysFieldsTool();
 
2376
  context.add(innodb_sys_fields_tool);
 
2377
 
 
2378
  innodb_sys_foreign_tool= new(std::nothrow)InnodbSysForeignTool();
 
2379
  context.add(innodb_sys_foreign_tool);
 
2380
 
 
2381
  innodb_sys_foreign_cols_tool= new(std::nothrow)InnodbSysForeignColsTool();
 
2382
  context.add(innodb_sys_foreign_cols_tool);
2322
2383
 
2323
2384
  context.add(new(std::nothrow)InnodbInternalTables());
2324
2385
  context.add(new(std::nothrow)InnodbReplicationTable());
2325
2386
 
2326
2387
  if (innobase_use_replication_log)
2327
2388
  {
2328
 
    ReplicationLog *replication_logger= new(std::nothrow)ReplicationLog();
 
2389
    replication_logger= new(std::nothrow)ReplicationLog();
2329
2390
    context.add(replication_logger);
2330
2391
    ReplicationLog::setup(replication_logger);
2331
2392
  }
2416
2477
  btr_search_fully_disabled = (!btr_search_enabled);
2417
2478
 
2418
2479
  return(FALSE);
2419
 
 
2420
2480
error:
2421
2481
  return(TRUE);
2422
2482
}
2513
2573
    trx_search_latch_release_if_reserved(trx);
2514
2574
  }
2515
2575
 
2516
 
  if (all)
2517
 
  {
 
2576
  if (all
 
2577
    || (!session_test_options(session, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))) {
 
2578
 
2518
2579
    /* We were instructed to commit the whole transaction, or
2519
2580
    this is an SQL statement end and autocommit is on */
2520
2581
 
2521
2582
    /* We need current binlog position for ibbackup to work.
2522
2583
    Note, the position is current because of
2523
2584
    prepare_commit_mutex */
2524
 
    const uint32_t commit_concurrency= innobase_commit_concurrency.get();
2525
 
    if (commit_concurrency)
2526
 
    {
2527
 
      do 
2528
 
      {
2529
 
        boost::mutex::scoped_lock scopedLock(commit_cond_m);
2530
 
        commit_threads++;
2531
 
 
2532
 
        if (commit_threads <= commit_concurrency) 
2533
 
          break;
2534
 
 
 
2585
retry:
 
2586
    if (innobase_commit_concurrency.get() > 0) {
 
2587
      pthread_mutex_lock(&commit_cond_m);
 
2588
      commit_threads++;
 
2589
 
 
2590
      if (commit_threads > innobase_commit_concurrency.get()) {
2535
2591
        commit_threads--;
2536
 
        commit_cond.wait(scopedLock);
2537
 
      } while (1);
 
2592
        pthread_cond_wait(&commit_cond,
 
2593
          &commit_cond_m);
 
2594
        pthread_mutex_unlock(&commit_cond_m);
 
2595
        goto retry;
 
2596
      }
 
2597
      else {
 
2598
        pthread_mutex_unlock(&commit_cond_m);
 
2599
      }
2538
2600
    }
2539
2601
 
2540
2602
    trx->mysql_log_file_name = NULL;
2547
2609
    innobase_commit_low(trx);
2548
2610
    trx->flush_log_later = FALSE;
2549
2611
 
2550
 
    if (commit_concurrency)
2551
 
    {
2552
 
      boost::mutex::scoped_lock scopedLock(commit_cond_m);
 
2612
    if (innobase_commit_concurrency.get() > 0) {
 
2613
      pthread_mutex_lock(&commit_cond_m);
2553
2614
      commit_threads--;
2554
 
      commit_cond.notify_one();
 
2615
      pthread_cond_signal(&commit_cond);
 
2616
      pthread_mutex_unlock(&commit_cond_m);
2555
2617
    }
2556
2618
 
2557
2619
    /* Now do a write + flush of logs. */
2636
2698
 
2637
2699
  row_unlock_table_autoinc_for_mysql(trx);
2638
2700
 
2639
 
  if (all)
2640
 
  {
 
2701
  if (all
 
2702
    || !session_test_options(session, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) {
 
2703
 
2641
2704
    error = trx_rollback_for_mysql(trx);
2642
2705
  } else {
2643
2706
    error = trx_rollback_last_sql_stat_for_mysql(trx);
2796
2859
      trx->undo_no > 0 &&
2797
2860
      global_system_variables.log_warnings)
2798
2861
  {
2799
 
      errmsg_printf(error::WARN,
 
2862
      errmsg_printf(ERRMSG_LVL_WARN,
2800
2863
      "Drizzle is closing a connection during a KILL operation\n"
2801
2864
      "that has an active InnoDB transaction.  %llu row modifications will "
2802
2865
      "roll back.\n",
2876
2939
  return(true);
2877
2940
}
2878
2941
 
 
2942
/*****************************************************************//**
 
2943
Normalizes a table name string. A normalized name consists of the
 
2944
database name catenated to '/' and table name. An example:
 
2945
test/mytable. On Windows normalization puts both the database name and the
 
2946
table name always to lower case. */
 
2947
static
 
2948
void
 
2949
normalize_table_name(
 
2950
/*=================*/
 
2951
  char*   norm_name,  /*!< out: normalized name as a
 
2952
          null-terminated string */
 
2953
  const char* name)   /*!< in: table name string */
 
2954
{
 
2955
  const char* name_ptr;
 
2956
  const char* db_ptr;
 
2957
  const char* ptr;
 
2958
 
 
2959
  /* Scan name from the end */
 
2960
 
 
2961
  ptr = strchr(name, '\0')-1;
 
2962
 
 
2963
  while (ptr >= name && *ptr != '\\' && *ptr != '/') {
 
2964
    ptr--;
 
2965
  }
 
2966
 
 
2967
  name_ptr = ptr + 1;
 
2968
 
 
2969
  assert(ptr > name);
 
2970
 
 
2971
  ptr--;
 
2972
 
 
2973
  while (ptr >= name && *ptr != '\\' && *ptr != '/') {
 
2974
    ptr--;
 
2975
  }
 
2976
 
 
2977
  db_ptr = ptr + 1;
 
2978
 
 
2979
  memcpy(norm_name, db_ptr, strlen(name) + 1 - (db_ptr - name));
 
2980
 
 
2981
  norm_name[name_ptr - db_ptr - 1] = '/';
 
2982
 
 
2983
#ifdef __WIN__
 
2984
  innobase_casedn_str(norm_name);
 
2985
#endif
 
2986
}
 
2987
 
2879
2988
/********************************************************************//**
2880
2989
Get the upper limit of the MySQL integral and floating-point type.
2881
2990
@return maximum allowed value for the field */
3042
3151
                if (!index_mapping) {
3043
3152
                        /* Report an error if index_mapping continues to be
3044
3153
                        NULL and mysql_num_index is a non-zero value */
3045
 
                        errmsg_printf(error::ERROR, "InnoDB: fail to allocate memory for "
3046
 
                                      "index translation table. Number of Index:%lu, array size:%lu",
 
3154
                        errmsg_printf(ERRMSG_LVL_ERROR,
 
3155
                                      "InnoDB: fail to allocate memory for "
 
3156
                                        "index translation table. Number of "
 
3157
                                        "Index:%lu, array size:%lu",
3047
3158
                                        mysql_num_index,
3048
3159
                                        share->idx_trans_tbl.array_size);
3049
3160
                        ret = FALSE;
3064
3175
                        ib_table, table->key_info[count].name);
3065
3176
 
3066
3177
                if (!index_mapping[count]) {
3067
 
                        errmsg_printf(error::ERROR, "Cannot find index %s in InnoDB index dictionary.",
3068
 
                                      table->key_info[count].name);
 
3178
                        errmsg_printf(ERRMSG_LVL_ERROR, "Cannot find index %s in InnoDB "
 
3179
                                        "index dictionary.",
 
3180
                                        table->key_info[count].name);
3069
3181
                        ret = FALSE;
3070
3182
                        goto func_exit;
3071
3183
                }
3072
3184
 
3073
3185
                /* Double check fetched index has the same
3074
3186
                column info as those in mysql key_info. */
3075
 
                if (!innobase_match_index_columns(&table->key_info[count], index_mapping[count])) {
3076
 
                  errmsg_printf(error::ERROR, "Found index %s whose column info does not match that of MySQL.",
3077
 
                                table->key_info[count].name);
3078
 
                  ret = FALSE;
3079
 
                  goto func_exit;
 
3187
                if (!innobase_match_index_columns(&table->key_info[count],
 
3188
                                                  index_mapping[count])) {
 
3189
                        errmsg_printf(ERRMSG_LVL_ERROR, "Found index %s whose column info "
 
3190
                                        "does not match that of MySQL.",
 
3191
                                        table->key_info[count].name);
 
3192
                        ret = FALSE;
 
3193
                        goto func_exit;
3080
3194
                }
3081
3195
        }
3082
3196
 
3146
3260
    auto_inc = 0;
3147
3261
 
3148
3262
    ut_print_timestamp(stderr);
3149
 
    errmsg_printf(error::ERROR, "InnoDB: Unable to determine the AUTOINC column name");
 
3263
    fprintf(stderr, "  InnoDB: Unable to determine the AUTOINC "
 
3264
            "column name\n");
3150
3265
  }
3151
3266
 
3152
3267
  if (srv_force_recovery >= SRV_FORCE_NO_IBUF_MERGE) {
3196
3311
    }
3197
3312
    case DB_RECORD_NOT_FOUND:
3198
3313
      ut_print_timestamp(stderr);
3199
 
      errmsg_printf(error::ERROR, "InnoDB: MySQL and InnoDB data dictionaries are out of sync.\n"
3200
 
                    "InnoDB: Unable to find the AUTOINC column %s in the InnoDB table %s.\n"
3201
 
                    "InnoDB: We set the next AUTOINC column value to 0,\n"
3202
 
                    "InnoDB: in effect disabling the AUTOINC next value generation.\n"
3203
 
                    "InnoDB: You can either set the next AUTOINC value explicitly using ALTER TABLE\n"
3204
 
                    "InnoDB: or fix the data dictionary by recreating the table.\n",
3205
 
                    col_name, index->table->name);
 
3314
      fprintf(stderr, "  InnoDB: MySQL and InnoDB data "
 
3315
              "dictionaries are out of sync.\n"
 
3316
              "InnoDB: Unable to find the AUTOINC column "
 
3317
              "%s in the InnoDB table %s.\n"
 
3318
              "InnoDB: We set the next AUTOINC column "
 
3319
              "value to 0,\n"
 
3320
              "InnoDB: in effect disabling the AUTOINC "
 
3321
              "next value generation.\n"
 
3322
              "InnoDB: You can either set the next "
 
3323
              "AUTOINC value explicitly using ALTER TABLE\n"
 
3324
              "InnoDB: or fix the data dictionary by "
 
3325
              "recreating the table.\n",
 
3326
              col_name, index->table->name);
3206
3327
 
3207
3328
      /* This will disable the AUTOINC generation. */
3208
3329
      auto_inc = 0;
3228
3349
@return 1 if error, 0 if success */
3229
3350
UNIV_INTERN
3230
3351
int
3231
 
ha_innobase::doOpen(const identifier::Table &identifier,
 
3352
ha_innobase::doOpen(const TableIdentifier &identifier,
3232
3353
                    int   mode,   /*!< in: not used */
3233
3354
                    uint    test_if_locked) /*!< in: not used */
3234
3355
{
3235
3356
  dict_table_t* ib_table;
 
3357
  char    norm_name[FN_REFLEN];
3236
3358
  Session*    session;
3237
3359
 
3238
3360
  UT_NOT_USED(mode);
3247
3369
    getTransactionalEngine()->releaseTemporaryLatches(session);
3248
3370
  }
3249
3371
 
 
3372
  normalize_table_name(norm_name, identifier.getPath().c_str());
 
3373
 
3250
3374
  user_session = NULL;
3251
3375
 
3252
 
  std::string search_string(identifier.getSchemaName());
3253
 
  boost::algorithm::to_lower(search_string);
 
3376
  if (!(share=get_share(identifier.getPath().c_str()))) {
3254
3377
 
3255
 
  if (search_string.compare("data_dictionary") == 0)
3256
 
  {
3257
 
    std::string table_name(identifier.getTableName());
3258
 
    boost::algorithm::to_upper(table_name);
3259
 
    if (!(share=get_share(table_name.c_str())))
3260
 
    {
3261
 
      return 1;
3262
 
    }
3263
 
  }
3264
 
  else
3265
 
  {
3266
 
    if (!(share=get_share(identifier.getKeyPath().c_str())))
3267
 
    {
3268
 
      return(1);
3269
 
    }
 
3378
    return(1);
3270
3379
  }
3271
3380
 
3272
3381
  /* Create buffers for packing the fields of a record. Why
3275
3384
  stored the string length as the first byte. */
3276
3385
 
3277
3386
  upd_and_key_val_buff_len =
3278
 
        getTable()->getShare()->sizeStoredRecord()
 
3387
        getTable()->getShare()->stored_rec_length
3279
3388
        + getTable()->getShare()->max_key_length
3280
3389
        + MAX_REF_PARTS * 3;
3281
3390
 
3293
3402
  }
3294
3403
 
3295
3404
  /* Get pointer to a table object in InnoDB dictionary cache */
3296
 
  if (search_string.compare("data_dictionary") == 0)
3297
 
  {
3298
 
    std::string table_name(identifier.getTableName());
3299
 
    boost::algorithm::to_upper(table_name);
3300
 
    ib_table = dict_table_get(table_name.c_str(), TRUE);
3301
 
  }
3302
 
  else
3303
 
  {
3304
 
    ib_table = dict_table_get(identifier.getKeyPath().c_str(), TRUE);
3305
 
  }
 
3405
  ib_table = dict_table_get(norm_name, TRUE);
3306
3406
  
3307
3407
  if (NULL == ib_table) {
3308
 
    errmsg_printf(error::ERROR, "Cannot find or open table %s from\n"
 
3408
    errmsg_printf(ERRMSG_LVL_ERROR, "Cannot find or open table %s from\n"
3309
3409
        "the internal data dictionary of InnoDB "
3310
3410
        "though the .frm file for the\n"
3311
3411
        "table exists. Maybe you have deleted and "
3319
3419
        "doesn't support.\n"
3320
3420
        "See " REFMAN "innodb-troubleshooting.html\n"
3321
3421
        "how you can resolve the problem.\n",
3322
 
        identifier.getKeyPath().c_str());
 
3422
        norm_name);
3323
3423
    free_share(share);
3324
3424
    upd_buff.resize(0);
3325
3425
    key_val_buff.resize(0);
3328
3428
    return(HA_ERR_NO_SUCH_TABLE);
3329
3429
  }
3330
3430
 
3331
 
  if (ib_table->ibd_file_missing && ! session->doing_tablespace_operation()) {
3332
 
    errmsg_printf(error::ERROR, "MySQL is trying to open a table handle but "
 
3431
  if (ib_table->ibd_file_missing && !session_tablespace_op(session)) {
 
3432
    errmsg_printf(ERRMSG_LVL_ERROR, "MySQL is trying to open a table handle but "
3333
3433
        "the .ibd file for\ntable %s does not exist.\n"
3334
3434
        "Have you deleted the .ibd file from the "
3335
3435
        "database directory under\nthe MySQL datadir, "
3336
3436
        "or have you used DISCARD TABLESPACE?\n"
3337
3437
        "See " REFMAN "innodb-troubleshooting.html\n"
3338
3438
        "how you can resolve the problem.\n",
3339
 
        identifier.getKeyPath().c_str());
 
3439
        norm_name);
3340
3440
    free_share(share);
3341
3441
    upd_buff.resize(0);
3342
3442
    key_val_buff.resize(0);
3348
3448
 
3349
3449
  prebuilt = row_create_prebuilt(ib_table);
3350
3450
 
3351
 
  prebuilt->mysql_row_len = getTable()->getShare()->sizeStoredRecord();
 
3451
  prebuilt->mysql_row_len = getTable()->getShare()->stored_rec_length;
3352
3452
  prebuilt->default_rec = getTable()->getDefaultValues();
3353
3453
  ut_ad(prebuilt->default_rec);
3354
3454
 
3358
3458
  key_used_on_scan = primary_key;
3359
3459
 
3360
3460
  if (!innobase_build_index_translation(getTable(), ib_table, share)) {
3361
 
    errmsg_printf(error::ERROR, "Build InnoDB index translation table for"
3362
 
                    " Table %s failed", identifier.getKeyPath().c_str());
 
3461
    errmsg_printf(ERRMSG_LVL_ERROR, "Build InnoDB index translation table for"
 
3462
                    " Table %s failed", identifier.getPath().c_str());
3363
3463
  }
3364
3464
 
3365
3465
  /* Allocate a buffer for a 'row reference'. A row reference is
3373
3473
    prebuilt->clust_index_was_generated = FALSE;
3374
3474
 
3375
3475
    if (UNIV_UNLIKELY(primary_key >= MAX_KEY)) {
3376
 
      errmsg_printf(error::ERROR, "Table %s has a primary key in "
 
3476
      errmsg_printf(ERRMSG_LVL_ERROR, "Table %s has a primary key in "
3377
3477
                    "InnoDB data dictionary, but not "
3378
3478
                    "in MySQL!", identifier.getTableName().c_str());
3379
3479
 
3428
3528
    }
3429
3529
  } else {
3430
3530
    if (primary_key != MAX_KEY) {
3431
 
      errmsg_printf(error::ERROR,
 
3531
      errmsg_printf(ERRMSG_LVL_ERROR,
3432
3532
                    "Table %s has no primary key in InnoDB data "
3433
3533
                    "dictionary, but has one in MySQL! If you "
3434
3534
                    "created the table with a MySQL version < "
3464
3564
    and it will never be updated anyway. */
3465
3565
 
3466
3566
    if (key_used_on_scan != MAX_KEY) {
3467
 
      errmsg_printf(error::WARN, 
 
3567
      errmsg_printf(ERRMSG_LVL_WARN, 
3468
3568
        "Table %s key_used_on_scan is %lu even "
3469
3569
        "though there is no primary key inside "
3470
3570
        "InnoDB.", identifier.getTableName().c_str(), (ulong) key_used_on_scan);
3663
3763
      charset = get_charset(charset_number);
3664
3764
 
3665
3765
      if (charset == NULL) {
3666
 
        errmsg_printf(error::ERROR, "InnoDB needs charset %lu for doing "
 
3766
        errmsg_printf(ERRMSG_LVL_ERROR, "InnoDB needs charset %lu for doing "
3667
3767
                      "a comparison, but MySQL cannot "
3668
3768
                      "find that charset.",
3669
3769
                      (ulong) charset_number);
4323
4423
  trx_t*    trx = session_to_trx(user_session);
4324
4424
 
4325
4425
  if (prebuilt->trx != trx) {
4326
 
    errmsg_printf(error::ERROR, "The transaction object for the table handle is at "
 
4426
    errmsg_printf(ERRMSG_LVL_ERROR, "The transaction object for the table handle is at "
4327
4427
        "%p, but for the current thread it is at %p",
4328
4428
        (const void*) prebuilt->trx, (const void*) trx);
4329
4429
 
4337
4437
    ut_error;
4338
4438
  }
4339
4439
 
4340
 
  sql_command = user_session->getSqlCommand();
 
4440
  sql_command = session_sql_command(user_session);
4341
4441
 
4342
4442
  if ((sql_command == SQLCOM_ALTER_TABLE
4343
4443
       || sql_command == SQLCOM_CREATE_INDEX
4784
4884
  if (error == DB_SUCCESS
4785
4885
      && getTable()->next_number_field
4786
4886
      && new_row == getTable()->getInsertRecord()
4787
 
      && user_session->getSqlCommand() == SQLCOM_INSERT
 
4887
      && session_sql_command(user_session) == SQLCOM_INSERT
4788
4888
      && (trx->duplicates & (TRX_DUP_IGNORE | TRX_DUP_REPLACE))
4789
4889
    == TRX_DUP_IGNORE)  {
4790
4890
 
5251
5351
         table. Only print message if the index translation
5252
5352
         table exists */
5253
5353
      if (share->idx_trans_tbl.index_mapping) {
5254
 
        errmsg_printf(error::ERROR,
 
5354
        errmsg_printf(ERRMSG_LVL_ERROR,
5255
5355
                      "InnoDB could not find "
5256
5356
                      "index %s key no %u for "
5257
5357
                      "table %s through its "
5269
5369
  }
5270
5370
 
5271
5371
  if (!index) {
5272
 
    errmsg_printf(error::ERROR, 
 
5372
    errmsg_printf(ERRMSG_LVL_ERROR, 
5273
5373
      "Innodb could not find key n:o %u with name %s "
5274
5374
      "from dict cache for table %s",
5275
 
      keynr, getTable()->getShare()->getTableMessage()->indexes(keynr).name().c_str(),
 
5375
      keynr, getTable()->getShare()->getTableProto()->indexes(keynr).name().c_str(),
5276
5376
      prebuilt->table->name);
5277
5377
  }
5278
5378
 
5298
5398
  prebuilt->index = innobase_get_index(keynr);
5299
5399
 
5300
5400
  if (UNIV_UNLIKELY(!prebuilt->index)) {
5301
 
    errmsg_printf(error::WARN, "InnoDB: change_active_index(%u) failed",
 
5401
    errmsg_printf(ERRMSG_LVL_WARN, "InnoDB: change_active_index(%u) failed",
5302
5402
          keynr);
5303
5403
    prebuilt->index_usable = FALSE;
5304
5404
    return(1);
5664
5764
  table. */
5665
5765
 
5666
5766
  if (len != ref_length) {
5667
 
    errmsg_printf(error::ERROR, "Stored ref len is %lu, but table ref len is %lu",
 
5767
    errmsg_printf(ERRMSG_LVL_ERROR, "Stored ref len is %lu, but table ref len is %lu",
5668
5768
        (ulong) len, (ulong) ref_length);
5669
5769
  }
5670
5770
}
5723
5823
 
5724
5824
    if (!col_type) {
5725
5825
      push_warning_printf(
5726
 
                          trx->mysql_thd,
 
5826
                          (Session*) trx->mysql_thd,
5727
5827
                          DRIZZLE_ERROR::WARN_LEVEL_WARN,
5728
5828
                          ER_CANT_CREATE_TABLE,
5729
5829
                          "Error creating table '%s' with "
5757
5857
        /* in data0type.h we assume that the
5758
5858
        number fits in one byte in prtype */
5759
5859
        push_warning_printf(
5760
 
          trx->mysql_thd,
 
5860
          (Session*) trx->mysql_thd,
5761
5861
          DRIZZLE_ERROR::WARN_LEVEL_ERROR,
5762
5862
          ER_CANT_CREATE_TABLE,
5763
5863
          "In InnoDB, charset-collation codes"
5923
6023
        || col_type == DATA_FLOAT
5924
6024
        || col_type == DATA_DOUBLE
5925
6025
        || col_type == DATA_DECIMAL) {
5926
 
        errmsg_printf(error::ERROR, 
 
6026
        errmsg_printf(ERRMSG_LVL_ERROR, 
5927
6027
          "MySQL is trying to create a column "
5928
6028
          "prefix index field, on an "
5929
6029
          "inappropriate data type. Table "
6023
6123
/*================*/
6024
6124
  Session         &session, /*!< in: Session */
6025
6125
  Table&    form,   /*!< in: information on table columns and indexes */
6026
 
        const identifier::Table &identifier,
 
6126
        const TableIdentifier &identifier,
6027
6127
        message::Table& create_proto)
6028
6128
{
6029
6129
  int   error;
6032
6132
  trx_t*    trx;
6033
6133
  int   primary_key_no;
6034
6134
  uint    i;
 
6135
  char    name2[FN_REFLEN];
 
6136
  char    norm_name[FN_REFLEN];
6035
6137
  ib_int64_t  auto_inc_value;
6036
6138
  ulint   iflags;
6037
6139
  /* Cache the value of innodb_file_format, in case it is
6041
6143
  const char* stmt;
6042
6144
  size_t stmt_len;
6043
6145
 
6044
 
  std::string search_string(identifier.getSchemaName());
6045
 
  boost::algorithm::to_lower(search_string);
6046
 
 
6047
 
  if (search_string.compare("data_dictionary") == 0)
6048
 
  {
6049
 
    return HA_WRONG_CREATE_OPTION;
6050
 
  }
 
6146
  const char *table_name= identifier.getPath().c_str();
6051
6147
 
6052
6148
  if (form.getShare()->sizeFields() > 1000) {
6053
6149
    /* The limit probably should be REC_MAX_N_FIELDS - 3 = 1020,
6070
6166
 
6071
6167
  srv_lower_case_table_names = TRUE;
6072
6168
 
 
6169
  strcpy(name2, table_name);
 
6170
 
 
6171
  normalize_table_name(norm_name, name2);
 
6172
 
6073
6173
  /* Latch the InnoDB data dictionary exclusively so that no deadlocks
6074
6174
    or lock waits can happen in it during a table create operation.
6075
6175
    Drop table etc. do this latching in row0mysql.c. */
6177
6277
  if (lex_identified_temp_table)
6178
6278
    iflags |= DICT_TF2_TEMPORARY << DICT_TF2_SHIFT;
6179
6279
 
6180
 
  error= create_table_def(trx, &form, identifier.getKeyPath().c_str(),
6181
 
                          lex_identified_temp_table ? identifier.getKeyPath().c_str() : NULL,
 
6280
  error= create_table_def(trx, &form, norm_name,
 
6281
                          lex_identified_temp_table ? name2 : NULL,
6182
6282
                          iflags);
6183
6283
 
6184
6284
  session.setXaId(trx->id);
6194
6294
      order the rows by their row id which is internally generated
6195
6295
      by InnoDB */
6196
6296
 
6197
 
    error = create_clustered_index_when_no_primary(trx, iflags, identifier.getKeyPath().c_str());
 
6297
    error = create_clustered_index_when_no_primary(trx, iflags, norm_name);
6198
6298
    if (error) {
6199
6299
      goto cleanup;
6200
6300
    }
6202
6302
 
6203
6303
  if (primary_key_no != -1) {
6204
6304
    /* In InnoDB the clustered index must always be created first */
6205
 
    if ((error = create_index(trx, &form, iflags, identifier.getKeyPath().c_str(),
 
6305
    if ((error = create_index(trx, &form, iflags, norm_name,
6206
6306
                              (uint) primary_key_no))) {
6207
6307
      goto cleanup;
6208
6308
    }
6211
6311
  for (i = 0; i < form.getShare()->sizeKeys(); i++) {
6212
6312
    if (i != (uint) primary_key_no) {
6213
6313
 
6214
 
      if ((error = create_index(trx, &form, iflags, identifier.getKeyPath().c_str(),
 
6314
      if ((error = create_index(trx, &form, iflags, norm_name,
6215
6315
                                i))) {
6216
6316
        goto cleanup;
6217
6317
      }
6218
6318
    }
6219
6319
  }
6220
6320
 
6221
 
  stmt= session.getQueryStringCopy(stmt_len);
 
6321
  stmt = innobase_get_stmt(&session, &stmt_len);
6222
6322
 
6223
6323
  if (stmt) {
6224
6324
    string generated_create_table;
6225
6325
    const char *query= stmt;
6226
6326
 
6227
 
    if (session.getSqlCommand() == SQLCOM_CREATE_TABLE)
 
6327
    if (session_sql_command(&session) == SQLCOM_CREATE_TABLE)
6228
6328
    {
6229
6329
      message::transformTableDefinitionToSql(create_proto,
6230
6330
                                             generated_create_table,
6234
6334
 
6235
6335
    error = row_table_add_foreign_constraints(trx,
6236
6336
                                              query, strlen(query),
6237
 
                                              identifier.getKeyPath().c_str(),
 
6337
                                              norm_name,
6238
6338
                                              lex_identified_temp_table);
6239
6339
    switch (error) {
6240
6340
 
6245
6345
                          "Create table '%s' with foreign key constraint"
6246
6346
                          " failed. There is no index in the referenced"
6247
6347
                          " table where the referenced columns appear"
6248
 
                          " as the first columns.\n", identifier.getKeyPath().c_str());
 
6348
                          " as the first columns.\n", norm_name);
6249
6349
      break;
6250
6350
 
6251
6351
    case DB_CHILD_NO_INDEX:
6255
6355
                          "Create table '%s' with foreign key constraint"
6256
6356
                          " failed. There is no index in the referencing"
6257
6357
                          " table where referencing columns appear"
6258
 
                          " as the first columns.\n", identifier.getKeyPath().c_str());
 
6358
                          " as the first columns.\n", norm_name);
6259
6359
      break;
6260
6360
    }
6261
6361
 
6276
6376
 
6277
6377
  log_buffer_flush_to_disk();
6278
6378
 
6279
 
  innobase_table = dict_table_get(identifier.getKeyPath().c_str(), FALSE);
 
6379
  innobase_table = dict_table_get(norm_name, FALSE);
6280
6380
 
6281
6381
  assert(innobase_table != 0);
6282
6382
 
6299
6399
    does a table copy too. */
6300
6400
 
6301
6401
  if ((create_proto.options().has_auto_increment_value()
6302
 
       || session.getSqlCommand() == SQLCOM_ALTER_TABLE
6303
 
       || session.getSqlCommand() == SQLCOM_CREATE_INDEX)
 
6402
       || session_sql_command(&session) == SQLCOM_ALTER_TABLE
 
6403
       || session_sql_command(&session) == SQLCOM_CREATE_INDEX)
6304
6404
      && create_proto.options().auto_increment_value() != 0) {
6305
6405
 
6306
6406
    /* Query was one of :
6393
6493
 
6394
6494
  update_session(getTable()->in_use);
6395
6495
 
6396
 
  if (user_session->getSqlCommand() != SQLCOM_TRUNCATE) {
 
6496
  if (session_sql_command(user_session) != SQLCOM_TRUNCATE) {
6397
6497
  fallback:
6398
6498
    /* We only handle TRUNCATE TABLE t as a special case.
6399
6499
    DELETE FROM t will have to use ha_innobase::doDeleteRecord(),
6427
6527
InnobaseEngine::doDropTable(
6428
6528
/*======================*/
6429
6529
        Session &session,
6430
 
        const identifier::Table &identifier)
 
6530
        const TableIdentifier &identifier)
6431
6531
{
6432
6532
  int error;
6433
6533
  trx_t*  parent_trx;
6434
6534
  trx_t*  trx;
 
6535
  char  norm_name[1000];
6435
6536
 
6436
6537
  ut_a(identifier.getPath().length() < 1000);
6437
6538
 
6438
 
  std::string search_string(identifier.getSchemaName());
6439
 
  boost::algorithm::to_lower(search_string);
6440
 
 
6441
 
  if (search_string.compare("data_dictionary") == 0)
6442
 
  {
6443
 
    return HA_ERR_TABLE_READONLY;
6444
 
  }
 
6539
  /* Strangely, MySQL passes the table name without the '.frm'
 
6540
    extension, in contrast to ::create */
 
6541
  normalize_table_name(norm_name, identifier.getPath().c_str());
6445
6542
 
6446
6543
  /* Get the transaction associated with the current session, or create one
6447
6544
    if not yet created */
6459
6556
 
6460
6557
  /* Drop the table in InnoDB */
6461
6558
 
6462
 
  error = row_drop_table_for_mysql(identifier.getKeyPath().c_str(), trx,
6463
 
                                   session.getSqlCommand()
 
6559
  error = row_drop_table_for_mysql(norm_name, trx,
 
6560
                                   session_sql_command(&session)
6464
6561
                                   == SQLCOM_DROP_DB);
6465
6562
 
6466
6563
  session.setXaId(trx->id);
6488
6585
    if (identifier.getType() == message::Table::TEMPORARY)
6489
6586
    {
6490
6587
      session.getMessageCache().removeTableMessage(identifier);
6491
 
      ulint sql_command = session.getSqlCommand();
 
6588
      ulint sql_command = session_sql_command(&session);
6492
6589
 
6493
6590
      // If this was the final removal to an alter table then we will need
6494
6591
      // to remove the .dfe that was left behind.
6521
6618
bool
6522
6619
InnobaseEngine::doDropSchema(
6523
6620
/*===================*/
6524
 
                             const identifier::Schema &identifier)
 
6621
                             const SchemaIdentifier &identifier)
6525
6622
    /*!< in: database path; inside InnoDB the name
6526
6623
      of the last directory in the path is used as
6527
6624
      the database name: for example, in 'mysql/data/test'
6571
6668
 
6572
6669
void InnobaseEngine::dropTemporarySchema()
6573
6670
{
6574
 
  identifier::Schema schema_identifier(GLOBAL_TEMPORARY_EXT);
 
6671
  SchemaIdentifier schema_identifier(GLOBAL_TEMPORARY_EXT);
6575
6672
  trx_t*  trx= NULL;
6576
6673
  string schema_path(GLOBAL_TEMPORARY_EXT);
6577
6674
 
6608
6705
innobase_rename_table(
6609
6706
/*==================*/
6610
6707
  trx_t*    trx,  /*!< in: transaction */
6611
 
  const identifier::Table &from,
6612
 
  const identifier::Table &to,
 
6708
  const char* from, /*!< in: old name of the table */
 
6709
  const char* to, /*!< in: new name of the table */
6613
6710
  ibool   lock_and_commit)
6614
6711
        /*!< in: TRUE=lock data dictionary and commit */
6615
6712
{
6616
6713
  int error;
 
6714
  char norm_to[FN_REFLEN];
 
6715
  char norm_from[FN_REFLEN];
6617
6716
 
6618
6717
  srv_lower_case_table_names = TRUE;
6619
6718
 
 
6719
  normalize_table_name(norm_to, to);
 
6720
  normalize_table_name(norm_from, from);
 
6721
 
6620
6722
  /* Serialize data dictionary operations with dictionary mutex:
6621
6723
  no deadlocks can occur then in these operations */
6622
6724
 
6624
6726
    row_mysql_lock_data_dictionary(trx);
6625
6727
  }
6626
6728
 
6627
 
  error = row_rename_table_for_mysql(from.getKeyPath().c_str(), to.getKeyPath().c_str(), trx, lock_and_commit);
 
6729
  error = row_rename_table_for_mysql(
 
6730
    norm_from, norm_to, trx, lock_and_commit);
6628
6731
 
6629
6732
  if (error != DB_SUCCESS) {
6630
6733
    FILE* ef = dict_foreign_err_file;
6631
6734
 
6632
6735
    fputs("InnoDB: Renaming table ", ef);
6633
 
    ut_print_name(ef, trx, TRUE, from.getKeyPath().c_str());
 
6736
    ut_print_name(ef, trx, TRUE, norm_from);
6634
6737
    fputs(" to ", ef);
6635
 
    ut_print_name(ef, trx, TRUE, to.getKeyPath().c_str());
 
6738
    ut_print_name(ef, trx, TRUE, norm_to);
6636
6739
    fputs(" failed!\n", ef);
6637
6740
  }
6638
6741
 
6651
6754
/*********************************************************************//**
6652
6755
Renames an InnoDB table.
6653
6756
@return 0 or error code */
6654
 
UNIV_INTERN int InnobaseEngine::doRenameTable(Session &session, const identifier::Table &from, const identifier::Table &to)
 
6757
UNIV_INTERN int InnobaseEngine::doRenameTable(Session &session, const TableIdentifier &from, const TableIdentifier &to)
6655
6758
{
6656
6759
  // A temp table alter table/rename is a shallow rename and only the
6657
6760
  // definition needs to be updated.
6677
6780
 
6678
6781
  trx = innobase_trx_allocate(&session);
6679
6782
 
6680
 
  error = innobase_rename_table(trx, from, to, TRUE);
 
6783
  error = innobase_rename_table(trx, from.getPath().c_str(), to.getPath().c_str(), TRUE);
6681
6784
 
6682
6785
  session.setXaId(trx->id);
6683
6786
 
6702
6805
     is the one we are trying to rename to) and return the generic
6703
6806
     error code. */
6704
6807
  if (error == (int) DB_DUPLICATE_KEY) {
6705
 
    my_error(ER_TABLE_EXISTS_ERROR, to);
 
6808
    my_error(ER_TABLE_EXISTS_ERROR, MYF(0), to.getPath().c_str());
6706
6809
    error = DB_ERROR;
6707
6810
  }
6708
6811
 
6733
6836
  KeyInfo*    key;
6734
6837
  dict_index_t* index;
6735
6838
  unsigned char*    key_val_buff2 = (unsigned char*) malloc(
6736
 
              getTable()->getShare()->sizeStoredRecord()
 
6839
              getTable()->getShare()->stored_rec_length
6737
6840
          + getTable()->getShare()->max_key_length + 100);
6738
 
  ulint   buff2_len = getTable()->getShare()->sizeStoredRecord()
 
6841
  ulint   buff2_len = getTable()->getShare()->stored_rec_length
6739
6842
          + getTable()->getShare()->max_key_length + 100;
6740
6843
  dtuple_t* range_start;
6741
6844
  dtuple_t* range_end;
7018
7121
 
7019
7122
                /* Print an error message if we cannot find the index
7020
7123
                ** in the "index translation table". */
7021
 
                errmsg_printf(error::ERROR,
 
7124
                errmsg_printf(ERRMSG_LVL_ERROR,
7022
7125
                              "Cannot find index %s in InnoDB index "
7023
7126
                                "translation table.", index->name);
7024
7127
        }
7035
7138
                }
7036
7139
        }
7037
7140
 
7038
 
                errmsg_printf(error::ERROR,
 
7141
                errmsg_printf(ERRMSG_LVL_ERROR,
7039
7142
                              "Cannot find matching index number for index %s "
7040
7143
                              "in InnoDB index list.", index->name);
7041
7144
 
7131
7234
    n_rows can not be 0 unless the table is empty, set to 1
7132
7235
    instead. The original problem of bug#29507 is actually
7133
7236
    fixed in the server code. */
7134
 
    if (user_session->getSqlCommand() == SQLCOM_TRUNCATE) {
 
7237
    if (session_sql_command(user_session) == SQLCOM_TRUNCATE) {
7135
7238
 
7136
7239
      n_rows = 1;
7137
7240
 
7215
7318
    ulint       num_innodb_index = UT_LIST_GET_LEN(ib_table->indexes) - prebuilt->clust_index_was_generated;
7216
7319
 
7217
7320
    if (getTable()->getShare()->keys != num_innodb_index) {
7218
 
      errmsg_printf(error::ERROR, "Table %s contains %lu "
 
7321
      errmsg_printf(ERRMSG_LVL_ERROR, "Table %s contains %lu "
7219
7322
                      "indexes inside InnoDB, which "
7220
7323
                      "is different from the number of "
7221
7324
                      "indexes %u defined in the MySQL ",
7235
7338
      index = innobase_get_index(i);
7236
7339
 
7237
7340
      if (index == NULL) {
7238
 
        errmsg_printf(error::ERROR, "Table %s contains fewer "
 
7341
        errmsg_printf(ERRMSG_LVL_ERROR, "Table %s contains fewer "
7239
7342
            "indexes inside InnoDB than "
7240
7343
            "are defined in the MySQL "
7241
7344
            ".frm file. Have you mixed up "
7250
7353
      for (j = 0; j < getTable()->key_info[i].key_parts; j++) {
7251
7354
 
7252
7355
        if (j + 1 > index->n_uniq) {
7253
 
          errmsg_printf(error::ERROR, 
 
7356
          errmsg_printf(ERRMSG_LVL_ERROR, 
7254
7357
"Index %s of %s has %lu columns unique inside InnoDB, but MySQL is asking "
7255
7358
"statistics for %lu columns. Have you mixed up .frm files from different "
7256
7359
"installations? "
7367
7470
  }
7368
7471
 
7369
7472
  if (prebuilt->table->ibd_file_missing) {
7370
 
        errmsg_printf(error::ERROR, "InnoDB: Error:\n"
 
7473
        errmsg_printf(ERRMSG_LVL_ERROR, "InnoDB: Error:\n"
7371
7474
                    "InnoDB: MySQL is trying to use a table handle"
7372
7475
                    " but the .ibd file for\n"
7373
7476
                    "InnoDB: table %s does not exist.\n"
7676
7779
      i++;
7677
7780
    }
7678
7781
    db_name[i] = 0;
7679
 
    ulen= identifier::Table::filename_to_tablename(db_name, uname, sizeof(uname));
 
7782
    ulen= TableIdentifier::filename_to_tablename(db_name, uname, sizeof(uname));
7680
7783
    LEX_STRING *tmp_referenced_db = session->make_lex_string(NULL, uname, ulen, true);
7681
7784
 
7682
7785
    /* Table name */
7683
7786
    tmp_buff += i + 1;
7684
 
    ulen= identifier::Table::filename_to_tablename(tmp_buff, uname, sizeof(uname));
 
7787
    ulen= TableIdentifier::filename_to_tablename(tmp_buff, uname, sizeof(uname));
7685
7788
    LEX_STRING *tmp_referenced_table = session->make_lex_string(NULL, uname, ulen, true);
7686
7789
 
7687
7790
    /** Foreign Fields **/
7759
7862
                              tmp_foreign_fields, tmp_referenced_fields);
7760
7863
 
7761
7864
    ForeignKeyInfo *pf_key_info = (ForeignKeyInfo *)
7762
 
      session->getMemRoot()->duplicate(&f_key_info, sizeof(ForeignKeyInfo));
 
7865
      session->memdup(&f_key_info, sizeof(ForeignKeyInfo));
7763
7866
    f_key_list->push_back(pf_key_info);
7764
7867
    foreign = UT_LIST_GET_NEXT(foreign_list, foreign);
7765
7868
  }
8289
8392
static INNOBASE_SHARE* get_share(const char* table_name)
8290
8393
{
8291
8394
  INNOBASE_SHARE *share;
8292
 
  boost::mutex::scoped_lock scopedLock(innobase_share_mutex);
 
8395
  pthread_mutex_lock(&innobase_share_mutex);
8293
8396
 
8294
8397
  ulint fold = ut_fold_string(table_name);
8295
8398
 
8316
8419
  }
8317
8420
 
8318
8421
  share->use_count++;
 
8422
  pthread_mutex_unlock(&innobase_share_mutex);
8319
8423
 
8320
8424
  return(share);
8321
8425
}
8322
8426
 
8323
8427
static void free_share(INNOBASE_SHARE* share)
8324
8428
{
8325
 
  boost::mutex::scoped_lock scopedLock(innobase_share_mutex);
 
8429
  pthread_mutex_lock(&innobase_share_mutex);
8326
8430
 
8327
8431
#ifdef UNIV_DEBUG
8328
8432
  INNOBASE_SHARE* share2;
8351
8455
    /* TODO: invoke HASH_MIGRATE if innobase_open_tables
8352
8456
    shrinks too much */
8353
8457
  }
 
8458
 
 
8459
  pthread_mutex_unlock(&innobase_share_mutex);
8354
8460
}
8355
8461
 
8356
8462
/*****************************************************************//**
8385
8491
  trx = check_trx_exists(session);
8386
8492
 
8387
8493
  assert(EQ_CURRENT_SESSION(session));
8388
 
  const uint32_t sql_command = session->getSqlCommand();
 
8494
  const uint32_t sql_command = session_sql_command(session);
8389
8495
 
8390
8496
  if (sql_command == SQLCOM_DROP_TABLE) {
8391
8497
 
8471
8577
 
8472
8578
    if ((lock_type >= TL_WRITE_CONCURRENT_INSERT
8473
8579
         && lock_type <= TL_WRITE)
8474
 
        && ! session->doing_tablespace_operation()
 
8580
        && !session_tablespace_op(session)
8475
8581
        && sql_command != SQLCOM_TRUNCATE
8476
8582
        && sql_command != SQLCOM_CREATE_TABLE) {
8477
8583
 
8548
8654
 
8549
8655
  if (auto_inc == 0) {
8550
8656
    ut_print_timestamp(stderr);
8551
 
    errmsg_printf(error::ERROR, "  InnoDB: AUTOINC next value generation is disabled for '%s'\n", innodb_table->name);
 
8657
    fprintf(stderr, "  InnoDB: AUTOINC next value generation "
 
8658
            "is disabled for '%s'\n", innodb_table->name);
8552
8659
  }
8553
8660
 
8554
8661
  dict_table_autoinc_unlock(innodb_table);
8703
8810
/* See comment in Cursor.cc */
8704
8811
UNIV_INTERN
8705
8812
bool
8706
 
InnobaseEngine::get_error_message(int, String *buf) const
 
8813
InnobaseEngine::get_error_message(int, String *buf)
8707
8814
{
8708
8815
  trx_t*  trx = check_trx_exists(current_session);
8709
8816
 
8880
8987
  trx->detailed_error[0]= '\0';
8881
8988
 
8882
8989
  /* Set the isolation level of the transaction. */
8883
 
  trx->isolation_level= innobase_map_isolation_level(session->getTxIsolation());
 
8990
  trx->isolation_level= innobase_map_isolation_level(session_tx_isolation(session));
8884
8991
}
8885
8992
 
8886
8993
void
9148
9255
          "Purge threads can be either 0 or 1. Defalut is 0.");
9149
9256
  context("file-per-table",
9150
9257
          po::value<bool>(&srv_file_per_table)->default_value(false)->zero_tokens(),
9151
 
           "Stores each InnoDB table to an .ibd file in the database dir.");
 
9258
          "Stores each InnoDB table to an .ibd file in the database dir.");
 
9259
  context("file-format",
 
9260
          po::value<string>(&innobase_file_format_name)->default_value("Antelope"),
 
9261
          "File format to use for new tables in .ibd files.");
9152
9262
  context("file-format-max",
9153
9263
          po::value<string>(&innobase_file_format_max)->default_value("Antelope"),
9154
9264
          "The highest file format in the tablespace.");
9155
9265
  context("file-format-check",
9156
9266
          po::value<bool>(&innobase_file_format_check)->default_value(true)->zero_tokens(),
9157
9267
          "Whether to perform system file format check.");
9158
 
  context("file-format",
9159
 
          po::value<string>(&innobase_file_format_name)->default_value("Antelope"),
9160
 
          "File format to use for new tables in .ibd files.");
9161
9268
  context("flush-log-at-trx-commit",
9162
9269
          po::value<trinary_constraint>(&innodb_flush_log_at_trx_commit)->default_value(1),
9163
9270
          "Set to 0 (write and flush once per second), 1 (write and flush at each commit) or 2 (write at commit, flush once per second).");
9293
9400
  "Supports transactions, row-level locking, and foreign keys",
9294
9401
  PLUGIN_LICENSE_GPL,
9295
9402
  innobase_init, /* Plugin Init */
9296
 
  NULL, /* depends */
 
9403
  NULL, /* system variables */
9297
9404
  init_options /* reserved */
9298
9405
}
9299
9406
DRIZZLE_DECLARE_PLUGIN_END;
9345
9452
    if (innobase_strcasecmp(key->name,
9346
9453
                            innobase_index_reserve_name) == 0) {
9347
9454
      /* Push warning to drizzle */
9348
 
      push_warning_printf(trx->mysql_thd,
 
9455
      push_warning_printf((Session*)trx->mysql_thd,
9349
9456
                          DRIZZLE_ERROR::WARN_LEVEL_WARN,
9350
9457
                          ER_WRONG_NAME_FOR_INDEX,
9351
9458
                          "Cannot Create Index with name "
9371
9478
  ulint   buflen;
9372
9479
  const char* id;
9373
9480
  ulint   idlen;
9374
 
  drizzled::Session *session;
 
9481
  void*   session;
9375
9482
  ibool   file_id;
9376
9483
 
9377
9484
  const char* expected;