← 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: Brian Aker
  • Date: 2010-11-30 00:29:39 UTC
  • mto: (1965.2.2 build)
  • mto: This revision was merged to the branch mainline in revision 1966.
  • Revision ID: brian@tangent.org-20101130002939-8bzz3xpa0aapbq2w
Fix sleep() so that a kill command will kill it.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/handler/ha_innodb.cc
102
102
#include "log0log.h"
103
103
#include "lock0lock.h"
104
104
#include "dict0crea.h"
105
 
#include "create_replication.h"
106
105
#include "btr0cur.h"
107
106
#include "btr0btr.h"
108
107
#include "fsp0fsp.h"
120
119
 
121
120
#include "ha_innodb.h"
122
121
#include "data_dictionary.h"
123
 
#include "replication_dictionary.h"
124
122
#include "internal_dictionary.h"
125
123
#include "handler0vars.h"
126
124
 
129
127
#include <string>
130
128
 
131
129
#include "plugin/innobase/handler/status_function.h"
132
 
#include "plugin/innobase/handler/replication_log.h"
133
 
 
134
 
#include <google/protobuf/io/zero_copy_stream.h>
135
 
#include <google/protobuf/io/zero_copy_stream_impl.h>
136
 
#include <google/protobuf/io/coded_stream.h>
137
 
#include <google/protobuf/text_format.h>
138
130
 
139
131
using namespace std;
140
132
using namespace drizzled;
179
171
static plugin::TableFunction* innodb_sys_foreign_tool= NULL;
180
172
static plugin::TableFunction* innodb_sys_foreign_cols_tool= NULL;
181
173
 
182
 
static ReplicationLog *replication_logger= NULL;
183
 
typedef constrained_check<uint32_t, UINT32_MAX, 10> open_files_constraint;
184
 
static open_files_constraint innobase_open_files;
185
 
typedef constrained_check<uint32_t, 10, 1> mirrored_log_groups_constraint;
186
 
static mirrored_log_groups_constraint innobase_mirrored_log_groups;
187
 
typedef constrained_check<uint32_t, 100, 2> log_files_in_group_constraint;
188
 
static log_files_in_group_constraint innobase_log_files_in_group;
189
 
typedef constrained_check<uint32_t, 6, 0> force_recovery_constraint;
190
 
force_recovery_constraint innobase_force_recovery;
191
 
typedef constrained_check<size_t, SIZE_MAX, 256*1024, 1024> log_buffer_constraint;
192
 
static log_buffer_constraint innobase_log_buffer_size;
193
 
typedef constrained_check<size_t, SIZE_MAX, 512*1024, 1024> additional_mem_pool_constraint;
194
 
static additional_mem_pool_constraint innobase_additional_mem_pool_size;
195
 
typedef constrained_check<unsigned int, 1000, 1> autoextend_constraint;
196
 
static autoextend_constraint innodb_auto_extend_increment;
197
 
typedef constrained_check<size_t, SIZE_MAX, 5242880, 1048576> buffer_pool_constraint;
198
 
static buffer_pool_constraint innobase_buffer_pool_size;
199
 
typedef constrained_check<uint32_t, MAX_BUFFER_POOLS, 1> buffer_pool_instances_constraint;
200
 
static buffer_pool_instances_constraint innobase_buffer_pool_instances;
201
 
typedef constrained_check<uint32_t, UINT32_MAX, 100> io_capacity_constraint;
202
 
static io_capacity_constraint innodb_io_capacity;
203
 
typedef constrained_check<uint32_t, 5000, 1> purge_batch_constraint;
204
 
static purge_batch_constraint innodb_purge_batch_size;
205
 
typedef constrained_check<uint32_t, 1, 0> purge_threads_constraint;
206
 
static purge_threads_constraint innodb_n_purge_threads;
207
 
typedef constrained_check<uint16_t, 2, 0> trinary_constraint;
208
 
static trinary_constraint innodb_flush_log_at_trx_commit;
209
 
typedef constrained_check<unsigned int, 99, 0> max_dirty_pages_constraint;
210
 
static max_dirty_pages_constraint innodb_max_dirty_pages_pct;
211
 
static uint64_constraint innodb_max_purge_lag;
212
 
static uint64_nonzero_constraint innodb_stats_sample_pages;
213
 
typedef constrained_check<uint32_t, 64, 1> io_threads_constraint;
214
 
static io_threads_constraint innobase_read_io_threads;
215
 
static io_threads_constraint innobase_write_io_threads;
216
 
 
217
 
typedef constrained_check<uint32_t, 1000, 0> concurrency_constraint;
218
 
static concurrency_constraint innobase_commit_concurrency;
219
 
static concurrency_constraint innobase_thread_concurrency;
220
 
static uint32_nonzero_constraint innodb_concurrency_tickets;
221
 
 
222
 
typedef constrained_check<int64_t, INT64_MAX, 1024*1024, 1024*1024> log_file_constraint;
223
 
static log_file_constraint innobase_log_file_size;
224
 
 
225
 
static uint64_constraint innodb_replication_delay;
 
174
static long innobase_mirrored_log_groups, innobase_log_files_in_group,
 
175
  innobase_log_buffer_size,
 
176
  innobase_force_recovery, innobase_open_files;
 
177
static long innobase_additional_mem_pool_size= 8*1024*1024L;
 
178
static ulong innobase_commit_concurrency = 0;
 
179
static ulong innobase_read_io_threads;
 
180
static ulong innobase_write_io_threads;
 
181
static int64_t innobase_buffer_pool_instances = 1;
 
182
 
 
183
/**
 
184
 * @TODO: Turn this into size_t as soon as we have a Variable<size_t>
 
185
 */
 
186
static int64_t innobase_buffer_pool_size= 128*1024*1024;
 
187
static int64_t innobase_log_file_size;
226
188
 
227
189
/** Percentage of the buffer pool to reserve for 'old' blocks.
228
190
Connected to buf_LRU_old_ratio. */
229
 
typedef constrained_check<uint32_t, 95, 5> old_blocks_constraint;
230
 
static old_blocks_constraint innobase_old_blocks_pct;
231
 
 
232
 
static uint32_constraint innodb_sync_spin_loops;
233
 
static uint32_constraint innodb_spin_wait_delay;
234
 
static uint32_constraint innodb_thread_sleep_delay;
235
 
 
236
 
typedef constrained_check<uint32_t, 64, 0> read_ahead_threshold_constraint;
237
 
static read_ahead_threshold_constraint innodb_read_ahead_threshold;
 
191
static uint innobase_old_blocks_pct;
238
192
 
239
193
/* The default values for the following char* start-up parameters
240
194
are determined in innobase_init below: */
241
195
 
242
 
std::string innobase_data_home_dir;
243
 
std::string innobase_data_file_path;
244
 
std::string innobase_log_group_home_dir;
245
 
static string innobase_file_format_name;
246
 
static string innobase_change_buffering;
 
196
static char*  innobase_data_home_dir      = NULL;
 
197
static char*  innobase_data_file_path     = NULL;
 
198
static char*  innobase_log_group_home_dir   = NULL;
 
199
static char*  innobase_file_format_name   = NULL;
 
200
static char*  innobase_change_buffering   = NULL;
247
201
 
248
202
/* The highest file format being used in the database. The value can be
249
203
set by user, however, it will be adjusted to the newer file format if
250
204
a table of such format is created/opened. */
251
 
static string innobase_file_format_max;
 
205
static char*    innobase_file_format_max                = NULL;
 
206
 
 
207
static char*  innobase_file_flush_method   = NULL;
252
208
 
253
209
/* Below we have boolean-valued start-up parameters, and their default
254
210
values */
255
211
 
256
 
typedef constrained_check<uint16_t, 2, 0> trinary_constraint;
257
 
static trinary_constraint innobase_fast_shutdown;
258
 
 
259
 
/* "innobase_file_format_check" decides whether we would continue
260
 
booting the server if the file format stamped on the system
261
 
table space exceeds the maximum file format supported
262
 
by the server. Can be set during server startup at command
263
 
line or configure file, and a read only variable after
264
 
server startup */
265
 
 
266
 
/* If a new file format is introduced, the file format
267
 
name needs to be updated accordingly. Please refer to
268
 
file_format_name_map[] defined in trx0sys.c for the next
269
 
file format name. */
270
 
 
 
212
static ulong  innobase_fast_shutdown      = 1;
271
213
static my_bool  innobase_file_format_check = TRUE;
 
214
#ifdef UNIV_LOG_ARCHIVE
 
215
static my_bool  innobase_log_archive      = FALSE;
 
216
static char*  innobase_log_arch_dir     = NULL;
 
217
#endif /* UNIV_LOG_ARCHIVE */
272
218
static my_bool  innobase_use_doublewrite    = TRUE;
273
219
static my_bool  innobase_use_checksums      = TRUE;
274
220
static my_bool  innobase_rollback_on_timeout    = FALSE;
275
221
static my_bool  innobase_create_status_file   = FALSE;
276
 
static bool innobase_use_replication_log;
277
 
static bool support_xa;
278
 
static bool strict_mode;
279
 
typedef constrained_check<uint32_t, 1024*1024*1024, 1> lock_wait_constraint;
280
 
static lock_wait_constraint lock_wait_timeout;
281
222
 
282
223
static char*  internal_innobase_data_file_path  = NULL;
283
224
 
 
225
static char*  innodb_version_str = (char*) INNODB_VERSION_STR;
 
226
 
284
227
/* The following counter is used to convey information to InnoDB
285
228
about server activity: in selects it is not sensible to call
286
229
srv_active_wake_master_thread after each fetch or search, we only do
360
303
    }
361
304
    
362
305
    /* These get strdup'd from vm variables */
 
306
    free(innobase_data_home_dir);
 
307
    free(innobase_log_group_home_dir);
363
308
 
364
309
  }
365
310
 
514
459
 
515
460
  void doGetTableIdentifiers(drizzled::CachedDirectory &directory,
516
461
                             const drizzled::SchemaIdentifier &schema_identifier,
517
 
                             drizzled::TableIdentifier::vector &set_of_identifiers);
 
462
                             drizzled::TableIdentifiers &set_of_identifiers);
518
463
  bool validateCreateTableOption(const std::string &key, const std::string &state);
519
464
  void dropTemporarySchema();
520
465
 
543
488
 
544
489
void InnobaseEngine::doGetTableIdentifiers(drizzled::CachedDirectory &directory,
545
490
                                           const drizzled::SchemaIdentifier &schema_identifier,
546
 
                                           drizzled::TableIdentifier::vector &set_of_identifiers)
 
491
                                           drizzled::TableIdentifiers &set_of_identifiers)
547
492
{
548
493
  CachedDirectory::Entries entries= directory.getEntries();
549
494
 
619
564
  return ENOENT;
620
565
}
621
566
 
 
567
/** @brief Initialize the default value of innodb_commit_concurrency.
 
568
 
 
569
Once InnoDB is running, the innodb_commit_concurrency must not change
 
570
from zero to nonzero. (Bug #42101)
 
571
 
 
572
The initial default value is 0, and without this extra initialization,
 
573
SET GLOBAL innodb_commit_concurrency=DEFAULT would set the parameter
 
574
to 0, even if it was initially set to nonzero at the command line
 
575
or configuration file. */
 
576
static
 
577
void
 
578
innobase_commit_concurrency_init_default(void);
 
579
/*==========================================*/
622
580
 
623
581
/************************************************************//**
624
582
Validate the file format name and return its corresponding id.
641
599
 
642
600
static const char innobase_engine_name[]= "InnoDB";
643
601
 
 
602
/*************************************************************//**
 
603
Check for a valid value of innobase_commit_concurrency.
 
604
@return 0 for valid innodb_commit_concurrency */
 
605
static
 
606
int
 
607
innobase_commit_concurrency_validate(
 
608
/*=================================*/
 
609
  Session*      , /*!< in: thread handle */
 
610
  drizzle_sys_var*  , /*!< in: pointer to system
 
611
            variable */
 
612
  void*       save, /*!< out: immediate result
 
613
            for update function */
 
614
  drizzle_value*    value)  /*!< in: incoming string */
 
615
{
 
616
  int64_t   intbuf;
 
617
  ulong   commit_concurrency;
 
618
 
 
619
  if (value->val_int(value, &intbuf)) {
 
620
    /* The value is NULL. That is invalid. */
 
621
    return(1);
 
622
  }
 
623
 
 
624
  *reinterpret_cast<ulong*>(save) = commit_concurrency
 
625
    = static_cast<ulong>(intbuf);
 
626
 
 
627
  /* Allow the value to be updated, as long as it remains zero
 
628
  or nonzero. */
 
629
  return(!(!commit_concurrency == !innobase_commit_concurrency));
 
630
}
 
631
 
 
632
static DRIZZLE_SessionVAR_BOOL(support_xa, PLUGIN_VAR_OPCMDARG,
 
633
  "Enable InnoDB support for the XA two-phase commit",
 
634
  /* check_func */ NULL, /* update_func */ NULL,
 
635
  /* default */ TRUE);
 
636
 
 
637
static DRIZZLE_SessionVAR_BOOL(table_locks, PLUGIN_VAR_OPCMDARG,
 
638
  "Enable InnoDB locking in LOCK TABLES",
 
639
  /* check_func */ NULL, /* update_func */ NULL,
 
640
  /* default */ TRUE);
 
641
 
 
642
static DRIZZLE_SessionVAR_BOOL(strict_mode, PLUGIN_VAR_OPCMDARG,
 
643
  "Use strict mode when evaluating create options.",
 
644
  NULL, NULL, TRUE);
 
645
 
 
646
static DRIZZLE_SessionVAR_ULONG(lock_wait_timeout, PLUGIN_VAR_RQCMDARG,
 
647
  "Timeout in seconds an InnoDB transaction may wait for a lock before being rolled back. Values above 100000000 disable the timeout.",
 
648
  NULL, NULL, 50, 1, 1024 * 1024 * 1024, 0);
 
649
 
644
650
 
645
651
/*****************************************************************//**
646
652
Commits a transaction in an InnoDB database. */
907
913
ibool
908
914
thd_supports_xa(
909
915
/*============*/
910
 
  void* )  /*!< in: thread handle (Session*), or NULL to query
 
916
  void* session)  /*!< in: thread handle (Session*), or NULL to query
911
917
        the global innodb_supports_xa */
912
918
{
913
 
  /* TODO: Add support here for per-session value */
914
 
  return(support_xa);
 
919
  return(SessionVAR((Session*) session, support_xa));
915
920
}
916
921
 
917
922
/******************************************************************//**
921
926
ulong
922
927
thd_lock_wait_timeout(
923
928
/*==================*/
924
 
  void*)  /*!< in: thread handle (Session*), or NULL to query
 
929
  void* session)  /*!< in: thread handle (Session*), or NULL to query
925
930
      the global innodb_lock_wait_timeout */
926
931
{
927
 
  /* TODO: Add support here for per-session value */
928
932
  /* According to <drizzle/plugin.h>, passing session == NULL
929
933
  returns the global value of the session variable. */
930
 
  return((ulong)lock_wait_timeout.get());
931
 
}
932
 
 
933
 
/******************************************************************//**
934
 
Set the time waited for the lock for the current query. */
935
 
extern "C" UNIV_INTERN
936
 
void
937
 
thd_set_lock_wait_time(
938
 
/*===================*/
939
 
        void*   thd,    /*!< in: thread handle (THD*) */
940
 
        ulint   value)  /*!< in: time waited for the lock */
941
 
{
942
 
        if (thd) {
943
 
          static_cast<Session*>(thd)->utime_after_lock+= value;
944
 
        }
 
934
  return(SessionVAR((Session*) session, lock_wait_timeout));
945
935
}
946
936
 
947
937
/********************************************************************//**
956
946
  return *(trx_t**) session->getEngineData(innodb_engine_ptr);
957
947
}
958
948
 
959
 
 
960
 
plugin::ReplicationReturnCode ReplicationLog::apply(Session &session,
961
 
                                                    const message::Transaction &message)
962
 
{
963
 
  char *data= new char[message.ByteSize()];
964
 
 
965
 
  message.SerializeToArray(data, message.ByteSize());
966
 
 
967
 
  trx_t *trx= session_to_trx(&session);
968
 
 
969
 
  uint64_t trx_id= message.transaction_context().transaction_id();
970
 
  ulint error= insert_replication_message(data, message.ByteSize(), trx, trx_id);
971
 
  (void)error;
972
 
 
973
 
  delete[] data;
974
 
 
975
 
  return plugin::SUCCESS;
976
 
}
977
 
 
978
949
/********************************************************************//**
979
950
Call this function when mysqld passes control to the client. That is to
980
951
avoid deadlocks on the adaptive hash S-latch possibly held by session. For more
1039
1010
  case DB_INTERRUPTED:
1040
1011
    my_error(ER_QUERY_INTERRUPTED, MYF(0));
1041
1012
    /* fall through */
1042
 
 
1043
 
  case DB_FOREIGN_EXCEED_MAX_CASCADE:
1044
 
    push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
1045
 
                        HA_ERR_ROW_IS_REFERENCED,
1046
 
                        "InnoDB: Cannot delete/update "
1047
 
                        "rows with cascading foreign key "
1048
 
                        "constraints that exceed max "
1049
 
                        "depth of %d. Please "
1050
 
                        "drop extra constraints and try "
1051
 
                        "again", DICT_FK_MAX_RECURSIVE_LOAD);
1052
 
    /* fall through */
1053
 
 
1054
1013
  case DB_ERROR:
1055
1014
  default:
1056
1015
    return(-1); /* unspecified error */
1208
1167
  if (cs) {
1209
1168
    *mbminlen = cs->mbminlen;
1210
1169
    *mbmaxlen = cs->mbmaxlen;
1211
 
    ut_ad(*mbminlen < DATA_MBMAX);
1212
 
    ut_ad(*mbmaxlen < DATA_MBMAX);
1213
1170
  } else {
1214
1171
    ut_a(cset == 0);
1215
1172
    *mbminlen = *mbmaxlen = 0;
1839
1796
  value= value - (value % align_val);
1840
1797
}
1841
1798
 
1842
 
static void auto_extend_update(Session *, sql_var_t)
1843
 
{
1844
 
  srv_auto_extend_increment= innodb_auto_extend_increment.get();
1845
 
}
1846
 
 
1847
 
static void io_capacity_update(Session *, sql_var_t)
1848
 
{
1849
 
  srv_io_capacity= innodb_io_capacity.get();
1850
 
}
1851
 
 
1852
 
static void purge_batch_update(Session *, sql_var_t)
1853
 
{
1854
 
  srv_purge_batch_size= innodb_purge_batch_size.get();
1855
 
}
1856
 
 
1857
 
static void purge_threads_update(Session *, sql_var_t)
1858
 
{
1859
 
  srv_n_purge_threads= innodb_n_purge_threads.get();
1860
 
}
1861
 
 
1862
 
static void innodb_adaptive_hash_index_update(Session *, sql_var_t)
1863
 
{
1864
 
  if (btr_search_enabled)
1865
 
  {
1866
 
    btr_search_enable();
1867
 
  } else {
1868
 
    btr_search_disable();
1869
 
  }
1870
 
}
1871
 
 
1872
 
static void innodb_old_blocks_pct_update(Session *, sql_var_t)
1873
 
{
1874
 
  innobase_old_blocks_pct= buf_LRU_old_ratio_update(innobase_old_blocks_pct.get(), TRUE);
1875
 
}
1876
 
 
1877
 
static void innodb_thread_concurrency_update(Session *, sql_var_t)
1878
 
{
1879
 
  srv_thread_concurrency= innobase_thread_concurrency.get();
1880
 
}
1881
 
 
1882
 
static void innodb_sync_spin_loops_update(Session *, sql_var_t)
1883
 
{
1884
 
  srv_n_spin_wait_rounds= innodb_sync_spin_loops.get();
1885
 
}
1886
 
 
1887
 
static void innodb_spin_wait_delay_update(Session *, sql_var_t)
1888
 
{
1889
 
  srv_spin_wait_delay= innodb_spin_wait_delay.get();
1890
 
}
1891
 
 
1892
 
static void innodb_thread_sleep_delay_update(Session *, sql_var_t)
1893
 
{
1894
 
  srv_thread_sleep_delay= innodb_thread_sleep_delay.get();
1895
 
}
1896
 
 
1897
 
static void innodb_read_ahead_threshold_update(Session *, sql_var_t)
1898
 
{
1899
 
  srv_read_ahead_threshold= innodb_read_ahead_threshold.get();
1900
 
}
1901
 
 
1902
 
 
1903
 
static int innodb_commit_concurrency_validate(Session *session, set_var *var)
1904
 
{
1905
 
   uint32_t new_value= var->save_result.uint32_t_value;
1906
 
 
1907
 
   if ((innobase_commit_concurrency.get() == 0 && new_value != 0) ||
1908
 
       (innobase_commit_concurrency.get() != 0 && new_value == 0))
1909
 
   {
1910
 
     push_warning_printf(session,
1911
 
                         DRIZZLE_ERROR::WARN_LEVEL_WARN,
1912
 
                         ER_WRONG_ARGUMENTS,
1913
 
                         _("Once InnoDB is running, innodb_commit_concurrency "
1914
 
                           "must not change between zero and nonzero."));
1915
 
     return 1;
1916
 
   }
1917
 
   return 0;
1918
 
}
1919
 
 
1920
 
/*************************************************************//**
1921
 
Check if it is a valid file format. This function is registered as
1922
 
a callback with MySQL.
1923
 
@return 0 for valid file format */
1924
 
static
1925
 
int
1926
 
innodb_file_format_name_validate(
1927
 
/*=============================*/
1928
 
  Session*      , /*!< in: thread handle */
1929
 
  set_var *var)
1930
 
{
1931
 
  const char *file_format_input = var->value->str_value.ptr();
1932
 
  if (file_format_input == NULL)
1933
 
    return 1;
1934
 
 
1935
 
  if (file_format_input != NULL) {
1936
 
    uint  format_id;
1937
 
 
1938
 
    format_id = innobase_file_format_name_lookup(
1939
 
      file_format_input);
1940
 
 
1941
 
    if (format_id <= DICT_TF_FORMAT_MAX) {
1942
 
      innobase_file_format_name =
1943
 
        trx_sys_file_format_id_to_name(format_id);
1944
 
 
1945
 
      return(0);
1946
 
    }
1947
 
  }
1948
 
 
1949
 
  return(1);
1950
 
}
1951
 
 
1952
 
/*************************************************************//**
1953
 
Check if it is a valid value of innodb_change_buffering. This function is
1954
 
registered as a callback with MySQL.
1955
 
@return 0 for valid innodb_change_buffering */
1956
 
static
1957
 
int
1958
 
innodb_change_buffering_validate(
1959
 
/*=============================*/
1960
 
  Session*      , /*!< in: thread handle */
1961
 
  set_var *var)
1962
 
{
1963
 
  const char *change_buffering_input = var->value->str_value.ptr();
1964
 
 
1965
 
  if (change_buffering_input == NULL)
1966
 
    return 1;
1967
 
 
1968
 
  ulint use;
1969
 
 
1970
 
  for (use = 0;
1971
 
       use < UT_ARR_SIZE(innobase_change_buffering_values);
1972
 
       ++use) {
1973
 
    if (!innobase_strcasecmp(change_buffering_input,
1974
 
                             innobase_change_buffering_values[use]))
1975
 
    {
1976
 
      ibuf_use= static_cast<ibuf_use_t>(use); 
1977
 
      return 0;
1978
 
    }
1979
 
  }
1980
 
 
1981
 
  return 1;
1982
 
}
1983
 
 
1984
 
 
1985
 
/*************************************************************//**
1986
 
Check if valid argument to innodb_file_format_max. This function
1987
 
is registered as a callback with MySQL.
1988
 
@return 0 for valid file format */
1989
 
static
1990
 
int
1991
 
innodb_file_format_max_validate(
1992
 
/*==============================*/
1993
 
  Session*   session, /*!< in: thread handle */
1994
 
  set_var *var)
1995
 
{
1996
 
  const char *file_format_input = var->value->str_value.ptr();
1997
 
  if (file_format_input == NULL)
1998
 
    return 1;
1999
 
 
2000
 
  if (file_format_input != NULL) {
2001
 
    int format_id = innobase_file_format_validate_and_set(file_format_input);
2002
 
 
2003
 
    if (format_id > DICT_TF_FORMAT_MAX) {
2004
 
      /* DEFAULT is "on", which is invalid at runtime. */
2005
 
      return 1;
2006
 
    }
2007
 
 
2008
 
    if (format_id >= 0) {
2009
 
      innobase_file_format_max= 
2010
 
        trx_sys_file_format_id_to_name((uint)format_id);
2011
 
 
2012
 
      /* Update the max format id in the system tablespace. */
2013
 
      char name_buff[100];
2014
 
      strcpy(name_buff, innobase_file_format_max.c_str());
2015
 
      if (trx_sys_file_format_max_set(format_id, (const char **)&name_buff))
2016
 
      {
2017
 
        errmsg_printf(ERRMSG_LVL_WARN,
2018
 
                      " [Info] InnoDB: the file format in the system "
2019
 
                      "tablespace is now set to %s.\n", name_buff);
2020
 
        innobase_file_format_max= name_buff;
2021
 
      }
2022
 
      return(0);
2023
 
 
2024
 
    } else {
2025
 
      push_warning_printf(session,
2026
 
                          DRIZZLE_ERROR::WARN_LEVEL_WARN,
2027
 
                          ER_WRONG_ARGUMENTS,
2028
 
                          "InnoDB: invalid innodb_file_format_max "
2029
 
                          "value; can be any format up to %s "
2030
 
                          "or equivalent id of %d",
2031
 
                          trx_sys_file_format_id_to_name(DICT_TF_FORMAT_MAX),
2032
 
                          DICT_TF_FORMAT_MAX);
2033
 
    }
2034
 
  }
2035
 
 
2036
 
  return(1);
2037
 
}
2038
 
 
2039
 
 
2040
1799
/*********************************************************************//**
2041
1800
Opens an InnoDB database.
2042
1801
@return 0 on success, error code on failure */
2052
1811
  InnobaseEngine *actuall_engine_ptr;
2053
1812
  const module::option_map &vm= context.getOptions();
2054
1813
 
2055
 
  srv_auto_extend_increment= innodb_auto_extend_increment.get();
2056
 
  srv_io_capacity= innodb_io_capacity.get();
2057
 
  srv_purge_batch_size= innodb_purge_batch_size.get();
2058
 
  srv_n_purge_threads= innodb_n_purge_threads.get();
2059
 
  srv_flush_log_at_trx_commit= innodb_flush_log_at_trx_commit.get();
2060
 
  srv_max_buf_pool_modified_pct= innodb_max_dirty_pages_pct.get();
2061
 
  srv_max_purge_lag= innodb_max_purge_lag.get();
2062
 
  srv_stats_sample_pages= innodb_stats_sample_pages.get();
2063
 
  srv_n_free_tickets_to_enter= innodb_concurrency_tickets.get();
2064
 
  srv_replication_delay= innodb_replication_delay.get();
2065
 
  srv_thread_concurrency= innobase_thread_concurrency.get();
2066
 
  srv_n_spin_wait_rounds= innodb_sync_spin_loops.get();
2067
 
  srv_spin_wait_delay= innodb_spin_wait_delay.get();
2068
 
  srv_thread_sleep_delay= innodb_thread_sleep_delay.get();
2069
 
  srv_read_ahead_threshold= innodb_read_ahead_threshold.get();
2070
 
 
2071
1814
  /* Inverted Booleans */
2072
1815
 
2073
1816
  innobase_use_checksums= (vm.count("disable-checksums")) ? false : true;
2074
1817
  innobase_use_doublewrite= (vm.count("disable-doublewrite")) ? false : true;
2075
1818
  srv_adaptive_flushing= (vm.count("disable-adaptive-flushing")) ? false : true;
2076
1819
  srv_use_sys_malloc= (vm.count("use-internal-malloc")) ? false : true;
2077
 
  support_xa= (vm.count("disable-xa")) ? false : true;
2078
 
  btr_search_enabled= (vm.count("disable-adaptive-hash-index")) ? false : true;
2079
 
 
2080
 
 
2081
 
  /* Hafta do this here because we need to late-bind the default value */
 
1820
  (SessionVAR(NULL,support_xa))= (vm.count("disable-xa")) ? false : true;
 
1821
  (SessionVAR(NULL,table_locks))= (vm.count("disable-table-locks")) ? false : true;
 
1822
 
 
1823
  if (vm.count("io-capacity"))
 
1824
  {
 
1825
    if (srv_io_capacity < 100)
 
1826
    {
 
1827
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for io-capacity\n"));
 
1828
      exit(-1);
 
1829
    }
 
1830
  }
 
1831
 
2082
1832
  if (vm.count("data-home-dir"))
2083
1833
  {
2084
 
    innobase_data_home_dir= vm["data-home-dir"].as<string>();
2085
 
  }
2086
 
  else
2087
 
  {
2088
 
    innobase_data_home_dir= getDataHome().file_string();
2089
 
  }
2090
 
 
 
1834
    innobase_data_home_dir= strdup(vm["data-home-dir"].as<string>().c_str());
 
1835
  }
 
1836
  else
 
1837
  {
 
1838
    innobase_data_home_dir= strdup(getDataHome().file_string().c_str());
 
1839
  }
 
1840
 
 
1841
  if (vm.count("fast-shutdown"))
 
1842
  {
 
1843
    if (innobase_fast_shutdown > 2)
 
1844
    {
 
1845
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for fast-shutdown\n"));
 
1846
      exit(-1);
 
1847
    }
 
1848
  }
 
1849
 
 
1850
  if (vm.count("file-format-max"))
 
1851
  {
 
1852
    innobase_file_format_max= const_cast<char *>(vm["file-format-max"].as<string>().c_str());
 
1853
  }
 
1854
 
 
1855
  if (vm.count("file-format-check"))
 
1856
  {
 
1857
    innobase_file_format_check= vm["file-format-check"].as<bool>();
 
1858
  }
 
1859
 
 
1860
  if (vm.count("flush-log-at-trx-commit"))
 
1861
  {
 
1862
    if (srv_flush_log_at_trx_commit > 2)
 
1863
    {
 
1864
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for flush-log-at-trx-commit\n"));
 
1865
      exit(-1);
 
1866
    }
 
1867
  }
 
1868
 
 
1869
  if (vm.count("flush-method"))
 
1870
  {
 
1871
    innobase_file_flush_method= const_cast<char *>(vm["flush-method"].as<string>().c_str());
 
1872
  }
 
1873
  else
 
1874
  {
 
1875
    innobase_file_flush_method= NULL;
 
1876
  }
 
1877
 
 
1878
#ifdef UNIV_LOG_ARCHIVE
 
1879
  if (vm.count("log-arch-dir"))
 
1880
  {
 
1881
    innobase_log_arch_dir= const_cast<char *>(vm["log-arch-dir"].as<string>().c_str());
 
1882
  }
 
1883
 
 
1884
  else
 
1885
  {
 
1886
    innobase_log_arch_dir= NULL;
 
1887
  }
 
1888
#endif /* UNIV_LOG_ARCHIVE */
 
1889
 
 
1890
  if (vm.count("max-dirty-pages-pct"))
 
1891
  {
 
1892
    if (srv_max_buf_pool_modified_pct > 99)
 
1893
    {
 
1894
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for max-dirty-pages-pct\n"));
 
1895
      exit(-1);
 
1896
    }
 
1897
  }
 
1898
 
 
1899
  if (vm.count("stats-sample-pages"))
 
1900
  {
 
1901
    if (srv_stats_sample_pages < 8)
 
1902
    {
 
1903
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for stats-sample-pages\n"));
 
1904
      exit(-1);
 
1905
    }
 
1906
  }
 
1907
 
 
1908
  if (vm.count("additional-mem-pool-size"))
 
1909
  {
 
1910
    align_value(innobase_additional_mem_pool_size);
 
1911
 
 
1912
    if (innobase_additional_mem_pool_size < 512*1024L)
 
1913
    {
 
1914
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for additional-mem-pool-size\n"));
 
1915
      exit(-1);
 
1916
    }
 
1917
 
 
1918
  }
 
1919
 
 
1920
  if (vm.count("autoextend-increment"))
 
1921
  {
 
1922
    if (srv_auto_extend_increment < 1 || srv_auto_extend_increment > 1000)
 
1923
    {
 
1924
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for autoextend-increment\n"));
 
1925
      exit(-1);
 
1926
    }
 
1927
  }
 
1928
 
 
1929
  if (vm.count("buffer-pool-size"))
 
1930
  {
 
1931
    align_value(innobase_buffer_pool_size, 1024*1024);
 
1932
    if (innobase_buffer_pool_size < 5*1024*1024)
 
1933
    {
 
1934
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for buffer-pool-size\n"));
 
1935
      exit(-1);
 
1936
    }
 
1937
    
 
1938
  }
 
1939
 
 
1940
  if (vm.count("buffer-pool-instances"))
 
1941
  {
 
1942
    if (innobase_buffer_pool_instances > MAX_BUFFER_POOLS)
 
1943
    {
 
1944
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for buffer-pool-instances\n"));
 
1945
      exit(-1);
 
1946
    }
 
1947
    
 
1948
  }
 
1949
 
 
1950
  if (vm.count("commit-concurrency"))
 
1951
  {
 
1952
    if (srv_replication_delay > 1000)
 
1953
    {
 
1954
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for commit-concurrency\n"));
 
1955
      exit(-1);
 
1956
    }
 
1957
  }
 
1958
 
 
1959
  if (vm.count("concurrency-tickets"))
 
1960
  {
 
1961
    if (srv_n_free_tickets_to_enter < 1)
 
1962
    {
 
1963
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for concurrency-tickets\n"));
 
1964
      exit(-1);
 
1965
    }
 
1966
  }
 
1967
 
 
1968
  if (vm.count("read-io-threads"))
 
1969
  {
 
1970
    if (innobase_read_io_threads < 1 || innobase_read_io_threads > 64)
 
1971
    {
 
1972
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for read-io-threads\n"));
 
1973
      exit(-1);
 
1974
    }
 
1975
  }
 
1976
 
 
1977
  if (vm.count("write-io-threads"))
 
1978
  {
 
1979
    if (innobase_write_io_threads < 1 || innobase_write_io_threads > 64)
 
1980
    {
 
1981
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for write-io-threads\n"));
 
1982
      exit(-1);
 
1983
    }
 
1984
  }
 
1985
 
 
1986
  if (vm.count("force-recovery"))
 
1987
  {
 
1988
    if (innobase_force_recovery > 6)
 
1989
    {
 
1990
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for force-recovery\n"));
 
1991
      exit(-1);
 
1992
    }
 
1993
  }
 
1994
 
 
1995
  if (vm.count("log-buffer-size"))
 
1996
  {
 
1997
    align_value(innobase_log_buffer_size);
 
1998
    if (innobase_log_buffer_size < 256*1024L)
 
1999
    {
 
2000
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for log-file-size\n"));
 
2001
      exit(-1);
 
2002
    }
 
2003
  }
 
2004
 
 
2005
  if (vm.count("log-file-size"))
 
2006
  {
 
2007
    align_value(innobase_log_file_size, 1024*1024);
 
2008
    if (innobase_log_file_size < 1*1024*1024L)
 
2009
    {
 
2010
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for log-file-size\n"));
 
2011
      exit(-1);
 
2012
    }
 
2013
  }
 
2014
 
 
2015
  if (vm.count("log-files-in-group"))
 
2016
  {
 
2017
    if (innobase_log_files_in_group < 2 || innobase_log_files_in_group > 100)
 
2018
    {
 
2019
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for log-files-in-group\n"));
 
2020
      exit(-1);
 
2021
    }
 
2022
  }
 
2023
 
 
2024
  if (vm.count("mirrored-log-groups"))
 
2025
  {
 
2026
    if (innobase_mirrored_log_groups < 1 || innobase_mirrored_log_groups > 10)
 
2027
    {
 
2028
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for mirrored-log-groups\n"));
 
2029
      exit(-1);
 
2030
    }
 
2031
  }
 
2032
 
 
2033
  if (vm.count("open-files"))
 
2034
  {
 
2035
    if (innobase_open_files < 10)
 
2036
    {
 
2037
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for open-files\n"));
 
2038
      exit(-1);
 
2039
    }
 
2040
  }
 
2041
 
 
2042
  if (vm.count("thread-concurrency"))
 
2043
  {
 
2044
    if (srv_thread_concurrency > 1000)
 
2045
    {
 
2046
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for thread-concurrency\n"));
 
2047
      exit(-1);
 
2048
    }
 
2049
  }
2091
2050
 
2092
2051
  if (vm.count("data-file-path"))
2093
2052
  {
2094
 
    innobase_data_file_path= vm["data-file-path"].as<string>();
2095
 
  }
2096
 
 
 
2053
    innobase_data_file_path= const_cast<char *>(vm["data-file-path"].as<string>().c_str());
 
2054
  }
 
2055
  else
 
2056
  {
 
2057
    innobase_data_file_path= NULL;
 
2058
  }
 
2059
 
 
2060
  if (vm.count("version"))
 
2061
  {
 
2062
    innodb_version_str= const_cast<char *>(vm["version"].as<string>().c_str());
 
2063
  }
 
2064
 
 
2065
  if (vm.count("read-ahead-threshold"))
 
2066
  {
 
2067
    if (srv_read_ahead_threshold > 64)
 
2068
    {
 
2069
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for read-ahead-threshold\n"));
 
2070
      exit(-1);
 
2071
    }
 
2072
  }
 
2073
 
 
2074
  if (vm.count("strict-mode"))
 
2075
  {
 
2076
    (SessionVAR(NULL,strict_mode))= vm["strict-mode"].as<bool>();
 
2077
  }
 
2078
 
 
2079
  if (vm.count("lock-wait-timeout"))
 
2080
  {
 
2081
    if (vm["lock-wait-timeout"].as<unsigned long>() < 1 || vm["lock-wait-timeout"].as<unsigned long>() > 1024*1024*1024)
 
2082
    {
 
2083
      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for lock-wait-timeout\n"));
 
2084
      exit(-1);
 
2085
    }
 
2086
 
 
2087
    (SessionVAR(NULL,lock_wait_timeout))= vm["lock-wait-timeout"].as<unsigned long>();
 
2088
  }
2097
2089
 
2098
2090
  innodb_engine_ptr= actuall_engine_ptr= new InnobaseEngine(innobase_engine_name);
2099
2091
 
2117
2109
  }
2118
2110
#endif /* UNIV_DEBUG */
2119
2111
 
 
2112
  /* Check that values don't overflow on 32-bit systems. */
 
2113
  if (sizeof(ulint) == 4) {
 
2114
    if (innobase_buffer_pool_size > UINT32_MAX) {
 
2115
      errmsg_printf(ERRMSG_LVL_ERROR, 
 
2116
                    "innobase_buffer_pool_size can't be over 4GB"
 
2117
                    " on 32-bit systems");
 
2118
 
 
2119
      goto error;
 
2120
    }
 
2121
 
 
2122
    if (innobase_log_file_size > UINT32_MAX) {
 
2123
      errmsg_printf(ERRMSG_LVL_ERROR, 
 
2124
                    "innobase_log_file_size can't be over 4GB"
 
2125
                    " on 32-bit systems");
 
2126
 
 
2127
      goto error;
 
2128
    }
 
2129
  }
 
2130
 
2120
2131
  os_innodb_umask = (ulint)internal::my_umask;
2121
2132
 
2122
2133
 
2127
2138
 
2128
2139
  /* The default dir for data files is the datadir of MySQL */
2129
2140
 
2130
 
  srv_data_home = (char *)innobase_data_home_dir.c_str();
 
2141
  srv_data_home = (char *)innobase_data_home_dir;
2131
2142
 
2132
2143
  /* Set default InnoDB data file size to 10 MB and let it be
2133
2144
    auto-extending. Thus users can use InnoDB in >= 4.0 without having
2134
2145
    to specify any startup options. */
2135
2146
 
2136
 
  if (innobase_data_file_path.empty()) 
2137
 
  {
2138
 
    innobase_data_file_path= std::string("ibdata1:10M:autoextend");
 
2147
  if (!innobase_data_file_path) {
 
2148
    innobase_data_file_path = (char*) "ibdata1:10M:autoextend";
2139
2149
  }
2140
2150
 
2141
2151
  /* Since InnoDB edits the argument in the next call, we make another
2142
2152
    copy of it: */
2143
2153
 
2144
 
  internal_innobase_data_file_path = strdup(innobase_data_file_path.c_str());
 
2154
  internal_innobase_data_file_path = strdup(innobase_data_file_path);
2145
2155
 
2146
2156
  ret = (bool) srv_parse_data_file_paths_and_sizes(
2147
2157
                                                   internal_innobase_data_file_path);
2161
2171
 
2162
2172
  if (vm.count("log-group-home-dir"))
2163
2173
  {
2164
 
    innobase_log_group_home_dir= vm["log-group-home-dir"].as<string>();
 
2174
    innobase_log_group_home_dir= strdup(vm["log-group-home-dir"].as<string>().c_str());
2165
2175
  }
2166
2176
  else
2167
2177
  {
2168
 
    innobase_log_group_home_dir= getDataHome().file_string();
 
2178
    innobase_log_group_home_dir = strdup(getDataHome().file_string().c_str());
2169
2179
  }
2170
2180
 
 
2181
#ifdef UNIV_LOG_ARCHIVE
 
2182
  /* Since innodb_log_arch_dir has no relevance under MySQL,
 
2183
    starting from 4.0.6 we always set it the same as
 
2184
innodb_log_group_home_dir: */
 
2185
 
 
2186
  innobase_log_arch_dir = innobase_log_group_home_dir;
 
2187
 
 
2188
  srv_arch_dir = innobase_log_arch_dir;
 
2189
#endif /* UNIG_LOG_ARCHIVE */
 
2190
 
2171
2191
  ret = (bool)
2172
 
    srv_parse_log_group_home_dirs((char *)innobase_log_group_home_dir.c_str());
 
2192
    srv_parse_log_group_home_dirs(innobase_log_group_home_dir);
2173
2193
 
2174
 
  if (ret == FALSE || innobase_mirrored_log_groups.get() != 1) {
2175
 
    errmsg_printf(ERRMSG_LVL_ERROR,
2176
 
                  _("syntax error in innodb_log_group_home_dir, or a "
2177
 
                  "wrong number of mirrored log groups"));
 
2194
  if (ret == FALSE || innobase_mirrored_log_groups != 1) {
 
2195
    errmsg_printf(ERRMSG_LVL_ERROR, "syntax error in innodb_log_group_home_dir, or a "
 
2196
                  "wrong number of mirrored log groups");
2178
2197
 
2179
2198
    goto mem_free_and_error;
2180
2199
  }
2197
2216
    format_id = 0;
2198
2217
  }
2199
2218
 
 
2219
  if (vm.count("purge-batch-size"))
 
2220
  {
 
2221
    srv_purge_batch_size= vm["purge-batch-size"].as<unsigned long>();
 
2222
    if (srv_purge_batch_size < 1 || srv_purge_batch_size > 5000)
 
2223
    {
 
2224
      errmsg_printf(ERRMSG_LVL_ERROR, "InnoDB: wrong purge-batch_size.");
 
2225
      goto mem_free_and_error;
 
2226
    }
 
2227
  }
 
2228
 
 
2229
  if (vm.count("n-purge-threads"))
 
2230
  {
 
2231
    srv_n_purge_threads= vm["n-purge-threads"].as<unsigned long>();
 
2232
    if (srv_n_purge_threads > 1)
 
2233
    {
 
2234
      errmsg_printf(ERRMSG_LVL_ERROR, "InnoDB: wrong n-purge-threads.");
 
2235
      goto mem_free_and_error;
 
2236
    }
 
2237
  }
 
2238
 
2200
2239
  srv_file_format = format_id;
2201
2240
 
 
2241
  /* Given the type of innobase_file_format_name we have little
 
2242
    choice but to cast away the constness from the returned name.
 
2243
    innobase_file_format_name is used in the MySQL set variable
 
2244
    interface and so can't be const. */
 
2245
 
2202
2246
  innobase_file_format_name =
2203
 
    trx_sys_file_format_id_to_name(format_id);
 
2247
    (char*) trx_sys_file_format_id_to_name(format_id);
2204
2248
 
2205
2249
  /* Check innobase_file_format_check variable */
2206
2250
  if (!innobase_file_format_check)
2215
2259
  /* Did the user specify a format name that we support?
2216
2260
     As a side effect it will update the variable
2217
2261
     srv_max_file_format_at_startup */
2218
 
  if (innobase_file_format_validate_and_set(innobase_file_format_max.c_str()) < 0)
 
2262
  if (innobase_file_format_validate_and_set(innobase_file_format_max) < 0)
2219
2263
  {
2220
 
    errmsg_printf(ERRMSG_LVL_ERROR, _("InnoDB: invalid "
 
2264
    errmsg_printf(ERRMSG_LVL_ERROR, "InnoDB: invalid "
2221
2265
                    "innodb_file_format_max value: "
2222
2266
                    "should be any value up to %s or its "
2223
 
                    "equivalent numeric id"),
 
2267
                    "equivalent numeric id",
2224
2268
                    trx_sys_file_format_id_to_name(DICT_TF_FORMAT_MAX));
2225
2269
    goto mem_free_and_error;
2226
2270
  }
2233
2277
         use < UT_ARR_SIZE(innobase_change_buffering_values);
2234
2278
         use++) {
2235
2279
      if (!innobase_strcasecmp(
2236
 
                               innobase_change_buffering.c_str(),
 
2280
                               vm["change-buffering"].as<string>().c_str(),
2237
2281
                               innobase_change_buffering_values[use])) {
2238
 
        ibuf_use = static_cast<ibuf_use_t>(use);
 
2282
        ibuf_use = (ibuf_use_t) use;
2239
2283
        goto innobase_change_buffering_inited_ok;
2240
2284
      }
2241
2285
    }
2249
2293
 
2250
2294
innobase_change_buffering_inited_ok:
2251
2295
  ut_a((ulint) ibuf_use < UT_ARR_SIZE(innobase_change_buffering_values));
2252
 
  innobase_change_buffering = innobase_change_buffering_values[ibuf_use];
 
2296
  innobase_change_buffering = (char*)
 
2297
    innobase_change_buffering_values[ibuf_use];
2253
2298
 
2254
2299
  /* --------------------------------------------------*/
2255
2300
 
2256
 
  if (vm.count("flush-method") != 0)
2257
 
  {
2258
 
    srv_file_flush_method_str = (char *)vm["flush-method"].as<string>().c_str();
2259
 
  }
 
2301
  srv_file_flush_method_str = innobase_file_flush_method;
2260
2302
 
2261
2303
  srv_n_log_groups = (ulint) innobase_mirrored_log_groups;
2262
2304
  srv_n_log_files = (ulint) innobase_log_files_in_group;
2263
2305
  srv_log_file_size = (ulint) innobase_log_file_size;
2264
2306
 
 
2307
#ifdef UNIV_LOG_ARCHIVE
 
2308
  srv_log_archive_on = (ulint) innobase_log_archive;
 
2309
#endif /* UNIV_LOG_ARCHIVE */
2265
2310
  srv_log_buffer_size = (ulint) innobase_log_buffer_size;
2266
2311
 
2267
2312
  srv_buf_pool_size = (ulint) innobase_buffer_pool_size;
2296
2341
 
2297
2342
  data_mysql_default_charset_coll = (ulint)default_charset_info->number;
2298
2343
 
 
2344
  innobase_commit_concurrency_init_default();
 
2345
 
2299
2346
  /* Since we in this module access directly the fields of a trx
2300
2347
    struct, and due to different headers and flags it might happen that
2301
2348
    mutex_t has a different size in this module and in InnoDB
2304
2351
 
2305
2352
  err = innobase_start_or_create_for_mysql();
2306
2353
 
2307
 
  if (err != DB_SUCCESS)
2308
 
  {
2309
 
    goto mem_free_and_error;
2310
 
  }
2311
 
 
2312
 
  err = dict_create_sys_replication_log();
2313
 
 
2314
2354
  if (err != DB_SUCCESS) {
2315
2355
    goto mem_free_and_error;
2316
2356
  }
2317
2357
 
2318
 
 
2319
 
  innobase_old_blocks_pct = buf_LRU_old_ratio_update(innobase_old_blocks_pct.get(),
 
2358
  innobase_old_blocks_pct = buf_LRU_old_ratio_update(innobase_old_blocks_pct,
2320
2359
                                                     TRUE);
2321
2360
 
2322
2361
  innobase_open_tables = hash_create(200);
2378
2417
  context.add(innodb_sys_foreign_cols_tool);
2379
2418
 
2380
2419
  context.add(new(std::nothrow)InnodbInternalTables());
2381
 
  context.add(new(std::nothrow)InnodbReplicationTable());
2382
 
 
2383
 
  if (innobase_use_replication_log)
2384
 
  {
2385
 
    replication_logger= new(std::nothrow)ReplicationLog();
2386
 
    context.add(replication_logger);
2387
 
    ReplicationLog::setup(replication_logger);
2388
 
  }
2389
 
 
2390
 
  context.registerVariable(new sys_var_const_string_val("data-home-dir", innobase_data_home_dir));
2391
 
  context.registerVariable(new sys_var_const_string_val("flush-method", 
2392
 
                                                        vm.count("flush-method") ?  vm["flush-method"].as<string>() : ""));
2393
 
  context.registerVariable(new sys_var_const_string_val("log-group-home-dir", innobase_log_group_home_dir));
2394
 
  context.registerVariable(new sys_var_const_string_val("data-file-path", innobase_data_file_path));
2395
 
  context.registerVariable(new sys_var_const_string_val("version", vm["version"].as<string>()));
2396
 
 
2397
 
 
2398
 
  context.registerVariable(new sys_var_bool_ptr_readonly("replication_log", &innobase_use_replication_log));
2399
 
  context.registerVariable(new sys_var_bool_ptr_readonly("checksums", &innobase_use_checksums));
2400
 
  context.registerVariable(new sys_var_bool_ptr_readonly("doublewrite", &innobase_use_doublewrite));
2401
 
  context.registerVariable(new sys_var_bool_ptr("file-per-table", &srv_file_per_table));
2402
 
  context.registerVariable(new sys_var_bool_ptr_readonly("file-format-check", &innobase_file_format_check));
2403
 
  context.registerVariable(new sys_var_bool_ptr("adaptive-flushing", &srv_adaptive_flushing));
2404
 
  context.registerVariable(new sys_var_bool_ptr("status-file", &innobase_create_status_file));
2405
 
  context.registerVariable(new sys_var_bool_ptr_readonly("use-sys-malloc", &srv_use_sys_malloc));
2406
 
  context.registerVariable(new sys_var_bool_ptr_readonly("use-native-aio", &srv_use_native_aio));
2407
 
 
2408
 
  context.registerVariable(new sys_var_bool_ptr("support-xa", &support_xa));
2409
 
  context.registerVariable(new sys_var_bool_ptr("strict_mode", &strict_mode));
2410
 
  context.registerVariable(new sys_var_constrained_value<uint32_t>("lock_wait_timeout", lock_wait_timeout));
2411
 
 
2412
 
  context.registerVariable(new sys_var_constrained_value_readonly<size_t>("additional_mem_pool_size",innobase_additional_mem_pool_size));
2413
 
  context.registerVariable(new sys_var_constrained_value<uint32_t>("autoextend_increment",
2414
 
                                                                   innodb_auto_extend_increment,
2415
 
                                                                   auto_extend_update));
2416
 
  context.registerVariable(new sys_var_constrained_value<uint32_t>("io_capacity",
2417
 
                                                                   innodb_io_capacity,
2418
 
                                                                   io_capacity_update));
2419
 
  context.registerVariable(new sys_var_constrained_value<uint32_t>("purge_batch_size",
2420
 
                                                                   innodb_purge_batch_size,
2421
 
                                                                   purge_batch_update));
2422
 
  context.registerVariable(new sys_var_constrained_value<uint32_t>("purge_threads",
2423
 
                                                                   innodb_n_purge_threads,
2424
 
                                                                   purge_threads_update));
2425
 
  context.registerVariable(new sys_var_constrained_value<uint16_t>("fast_shutdown", innobase_fast_shutdown));
2426
 
  context.registerVariable(new sys_var_std_string("file_format",
2427
 
                                                  innobase_file_format_name,
2428
 
                                                  innodb_file_format_name_validate));
2429
 
  context.registerVariable(new sys_var_std_string("change_buffering",
2430
 
                                                  innobase_change_buffering,
2431
 
                                                  innodb_change_buffering_validate));
2432
 
  context.registerVariable(new sys_var_std_string("file_format_max",
2433
 
                                                  innobase_file_format_max,
2434
 
                                                  innodb_file_format_max_validate));
2435
 
  context.registerVariable(new sys_var_constrained_value_readonly<size_t>("buffer_pool_size", innobase_buffer_pool_size));
2436
 
  context.registerVariable(new sys_var_constrained_value_readonly<int64_t>("log_file_size", innobase_log_file_size));
2437
 
  context.registerVariable(new sys_var_constrained_value_readonly<uint16_t>("flush_log_at_trx_commit",
2438
 
                                                  innodb_flush_log_at_trx_commit));
2439
 
  context.registerVariable(new sys_var_constrained_value_readonly<unsigned int>("max_dirty_pages_pct",
2440
 
                                                  innodb_max_dirty_pages_pct));
2441
 
  context.registerVariable(new sys_var_constrained_value_readonly<uint64_t>("max_purge_lag", innodb_max_purge_lag));
2442
 
  context.registerVariable(new sys_var_constrained_value_readonly<uint64_t>("stats_sample_pages", innodb_stats_sample_pages));
2443
 
  context.registerVariable(new sys_var_bool_ptr("adaptive_hash_index", &btr_search_enabled, innodb_adaptive_hash_index_update));
2444
 
 
2445
 
  context.registerVariable(new sys_var_constrained_value<uint32_t>("commit_concurrency",
2446
 
                                                                   innobase_commit_concurrency,
2447
 
                                                                   innodb_commit_concurrency_validate));
2448
 
  context.registerVariable(new sys_var_constrained_value<uint32_t>("concurrency_tickets",
2449
 
                                                                   innodb_concurrency_tickets));
2450
 
  context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("read_io_threads", innobase_read_io_threads));
2451
 
  context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("write_io_threads", innobase_write_io_threads));
2452
 
  context.registerVariable(new sys_var_constrained_value_readonly<uint64_t>("replication_delay", innodb_replication_delay));
2453
 
  context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("force_recovery", innobase_force_recovery));
2454
 
  context.registerVariable(new sys_var_constrained_value_readonly<size_t>("log_buffer_size", innobase_log_buffer_size));
2455
 
  context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("log_files_in_group", innobase_log_files_in_group));
2456
 
  context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("mirrored_log_groups", innobase_mirrored_log_groups));
2457
 
  context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("open_files", innobase_open_files));
2458
 
  context.registerVariable(new sys_var_constrained_value<uint32_t>("old_blocks_pct",
2459
 
                                                                   innobase_old_blocks_pct,
2460
 
                                                                   innodb_old_blocks_pct_update));
2461
 
  context.registerVariable(new sys_var_uint32_t_ptr("old_blocks_time", &buf_LRU_old_threshold_ms));
2462
 
  context.registerVariable(new sys_var_constrained_value<uint32_t>("sync_spin_loops", innodb_sync_spin_loops, innodb_sync_spin_loops_update));
2463
 
  context.registerVariable(new sys_var_constrained_value<uint32_t>("spin_wait_delay", innodb_spin_wait_delay, innodb_spin_wait_delay_update));
2464
 
  context.registerVariable(new sys_var_constrained_value<uint32_t>("thread_sleep_delay", innodb_thread_sleep_delay, innodb_thread_sleep_delay_update));
2465
 
  context.registerVariable(new sys_var_constrained_value<uint32_t>("thread_concurrency",
2466
 
                                                                   innobase_thread_concurrency,
2467
 
                                                                   innodb_thread_concurrency_update));
2468
 
  context.registerVariable(new sys_var_constrained_value<uint32_t>("read_ahead_threshold",
2469
 
                                                                   innodb_read_ahead_threshold,
2470
 
                                                                   innodb_read_ahead_threshold_update));
 
2420
 
2471
2421
  /* Get the current high water mark format. */
2472
 
  innobase_file_format_max = trx_sys_file_format_max_get();
2473
 
  btr_search_fully_disabled = (!btr_search_enabled);
 
2422
  innobase_file_format_max = (char*) trx_sys_file_format_max_get();
2474
2423
 
2475
2424
  return(FALSE);
2476
2425
error:
2579
2528
    Note, the position is current because of
2580
2529
    prepare_commit_mutex */
2581
2530
retry:
2582
 
    if (innobase_commit_concurrency.get() > 0) {
 
2531
    if (innobase_commit_concurrency > 0) {
2583
2532
      pthread_mutex_lock(&commit_cond_m);
2584
2533
      commit_threads++;
2585
2534
 
2586
 
      if (commit_threads > innobase_commit_concurrency.get()) {
 
2535
      if (commit_threads > innobase_commit_concurrency) {
2587
2536
        commit_threads--;
2588
2537
        pthread_cond_wait(&commit_cond,
2589
2538
          &commit_cond_m);
2608
2557
    innobase_commit_low(trx);
2609
2558
    trx->flush_log_later = FALSE;
2610
2559
 
2611
 
    if (innobase_commit_concurrency.get() > 0) {
 
2560
    if (innobase_commit_concurrency > 0) {
2612
2561
      pthread_mutex_lock(&commit_cond_m);
2613
2562
      commit_threads--;
2614
2563
      pthread_cond_signal(&commit_cond);
2855
2804
  /* Warn if rolling back some things... */
2856
2805
  if (session->getKilled() != Session::NOT_KILLED &&
2857
2806
      trx->conc_state != TRX_NOT_STARTED &&
2858
 
      trx->undo_no > 0 &&
 
2807
      trx->undo_no.low > 0 &&
2859
2808
      global_system_variables.log_warnings)
2860
2809
  {
2861
 
      errmsg_printf(ERRMSG_LVL_WARN,
 
2810
      errmsg_printf(ERRMSG_LVL_WARN, 
2862
2811
      "Drizzle is closing a connection during a KILL operation\n"
2863
 
      "that has an active InnoDB transaction.  %llu row modifications will "
 
2812
      "that has an active InnoDB transaction.  %lu row modifications will "
2864
2813
      "roll back.\n",
2865
 
      (ullint) trx->undo_no);
 
2814
      (ulong) trx->undo_no.low);
2866
2815
  }
2867
2816
 
2868
2817
  innobase_rollback_trx(trx);
3296
3245
    err = row_search_max_autoinc(index, col_name, &read_auto_inc);
3297
3246
 
3298
3247
    switch (err) {
3299
 
    case DB_SUCCESS: {
3300
 
      uint64_t col_max_value;
3301
 
 
3302
 
      col_max_value = innobase_get_int_col_max_value(field);
3303
 
 
 
3248
    case DB_SUCCESS:
3304
3249
      /* At the this stage we do not know the increment
3305
 
         nor the offset, so use a default increment of 1. */
3306
 
 
3307
 
      auto_inc = innobase_next_autoinc(read_auto_inc, 1, 1, col_max_value);
3308
 
 
 
3250
         or the offset, so use a default increment of 1. */
 
3251
      auto_inc = read_auto_inc + 1;
3309
3252
      break;
3310
 
    }
 
3253
 
3311
3254
    case DB_RECORD_NOT_FOUND:
3312
3255
      ut_print_timestamp(stderr);
3313
3256
      fprintf(stderr, "  InnoDB: MySQL and InnoDB data "
3580
3523
    /* We update the highest file format in the system table
3581
3524
    space, if this table has higher file format setting. */
3582
3525
 
3583
 
    char changed_file_format_max[100];
3584
 
    strcpy(changed_file_format_max, innobase_file_format_max.c_str());
3585
 
    trx_sys_file_format_max_upgrade((const char **)&changed_file_format_max,
 
3526
    trx_sys_file_format_max_upgrade(
 
3527
      (const char**) &innobase_file_format_max,
3586
3528
      dict_table_get_format(prebuilt->table));
3587
 
    innobase_file_format_max= changed_file_format_max;
3588
3529
  }
3589
3530
 
 
3531
  info(HA_STATUS_NO_LOCK | HA_STATUS_VARIABLE | HA_STATUS_CONST);
 
3532
 
3590
3533
  /* Only if the table has an AUTOINC column. */
3591
3534
  if (prebuilt->table != NULL && getTable()->found_next_number_field != NULL) {
3592
3535
 
3604
3547
    dict_table_autoinc_unlock(prebuilt->table);
3605
3548
  }
3606
3549
 
3607
 
  info(HA_STATUS_NO_LOCK | HA_STATUS_VARIABLE | HA_STATUS_CONST);
3608
 
 
3609
3550
  return(0);
3610
3551
}
3611
3552
 
3853
3794
  case DRIZZLE_TYPE_DATETIME:
3854
3795
  case DRIZZLE_TYPE_DATE:
3855
3796
  case DRIZZLE_TYPE_TIMESTAMP:
3856
 
  case DRIZZLE_TYPE_ENUM:
3857
3797
    return(DATA_INT);
3858
3798
  case DRIZZLE_TYPE_DOUBLE:
3859
3799
    return(DATA_DOUBLE);
3860
3800
  case DRIZZLE_TYPE_BLOB:
3861
3801
    return(DATA_BLOB);
3862
 
  case DRIZZLE_TYPE_UUID:
3863
 
    return(DATA_FIXBINARY);
3864
 
  case DRIZZLE_TYPE_NULL:
 
3802
  default:
3865
3803
    ut_error;
3866
3804
  }
3867
3805
 
4101
4039
      ulint     key_len;
4102
4040
      const unsigned char*    src_start;
4103
4041
      enum_field_types  real_type;
4104
 
      const CHARSET_INFO* cs= field->charset();
4105
4042
 
4106
4043
      key_len = key_part->length;
4107
4044
 
4123
4060
      memcpy(buff, src_start, true_len);
4124
4061
      buff += true_len;
4125
4062
 
4126
 
      /* Pad the unused space with spaces. */
 
4063
      /* Pad the unused space with spaces. Note that no
 
4064
      padding is ever needed for UCS-2 because in MySQL,
 
4065
      all UCS2 characters are 2 bytes, as MySQL does not
 
4066
      support surrogate pairs, which are needed to represent
 
4067
      characters in the range U+10000 to U+10FFFF. */
4127
4068
 
4128
4069
      if (true_len < key_len) {
4129
 
        ulint   pad_len = key_len - true_len;
4130
 
        ut_a(!(pad_len % cs->mbminlen));
4131
 
 
4132
 
        cs->cset->fill(cs, buff, pad_len,
4133
 
                       0x20 /* space */);
 
4070
        ulint pad_len = key_len - true_len;
 
4071
        memset(buff, ' ', pad_len);
4134
4072
        buff += pad_len;
4135
4073
      }
4136
4074
    }
4238
4176
 
4239
4177
  /* Note that in InnoDB, i is the column number. MySQL calls columns
4240
4178
  'fields'. */
4241
 
  for (i = 0; i < n_fields; i++)
 
4179
  for (i = 0; i < n_fields; i++) 
4242
4180
  {
4243
 
    const dict_col_t *col= &index->table->cols[i];
4244
4181
    templ = prebuilt->mysql_template + n_requested_fields;
4245
4182
    field = table->getField(i);
4246
4183
 
4288
4225
    templ->col_no = i;
4289
4226
 
4290
4227
    if (index == clust_index) {
4291
 
      templ->rec_field_no = dict_col_get_clust_pos(col, index);
 
4228
      templ->rec_field_no = dict_col_get_clust_pos(
 
4229
        &index->table->cols[i], index);
4292
4230
    } else {
4293
4231
      templ->rec_field_no = dict_index_get_nth_col_pos(
4294
4232
                index, i);
4317
4255
      mysql_prefix_len = templ->mysql_col_offset
4318
4256
        + templ->mysql_col_len;
4319
4257
    }
4320
 
    templ->type = col->mtype;
 
4258
    templ->type = index->table->cols[i].mtype;
4321
4259
    templ->mysql_type = (ulint)field->type();
4322
4260
 
4323
4261
    if (templ->mysql_type == DATA_MYSQL_TRUE_VARCHAR) {
4325
4263
        (((Field_varstring*)field)->pack_length_no_ptr());
4326
4264
    }
4327
4265
 
4328
 
    templ->charset = dtype_get_charset_coll(col->prtype);
4329
 
    templ->mbminlen = dict_col_get_mbminlen(col);
4330
 
    templ->mbmaxlen = dict_col_get_mbmaxlen(col);
4331
 
    templ->is_unsigned = col->prtype & DATA_UNSIGNED;
 
4266
    templ->charset = dtype_get_charset_coll(
 
4267
      index->table->cols[i].prtype);
 
4268
    templ->mbminlen = index->table->cols[i].mbminlen;
 
4269
    templ->mbmaxlen = index->table->cols[i].mbmaxlen;
 
4270
    templ->is_unsigned = index->table->cols[i].prtype
 
4271
              & DATA_UNSIGNED;
4332
4272
    if (templ->type == DATA_BLOB) {
4333
4273
      prebuilt->templ_contains_blob = TRUE;
4334
4274
    }
4546
4486
 
4547
4487
  error = row_insert_for_mysql((byte*) record, prebuilt);
4548
4488
 
4549
 
  user_session->setXaId(trx->id);
 
4489
  user_session->setXaId((ib_uint64_t) ut_conv_dulint_to_longlong(trx->id));
4550
4490
 
4551
4491
  /* Handle duplicate key errors */
4552
4492
  if (auto_inc_used) {
4869
4809
 
4870
4810
  error = row_update_for_mysql((byte*) old_row, prebuilt);
4871
4811
 
4872
 
  user_session->setXaId(trx->id);
 
4812
  user_session->setXaId((ib_uint64_t) ut_conv_dulint_to_longlong(trx->id));
4873
4813
 
4874
4814
  /* We need to do some special AUTOINC handling for the following case:
4875
4815
 
4961
4901
 
4962
4902
  error = row_update_for_mysql((byte*) record, prebuilt);
4963
4903
 
4964
 
  user_session->setXaId(trx->id);
 
4904
  user_session->setXaId((ib_uint64_t) ut_conv_dulint_to_longlong(trx->id));
4965
4905
 
4966
4906
  innodb_srv_conc_exit_innodb(trx);
4967
4907
 
6232
6172
# error "DICT_TF_ZSSIZE_MAX < 1"
6233
6173
#endif
6234
6174
 
6235
 
    if (strict_mode)
 
6175
    if (SessionVAR(&session, strict_mode))
6236
6176
    {
6237
6177
      if (! srv_file_per_table)
6238
6178
      {
6279
6219
                          lex_identified_temp_table ? name2 : NULL,
6280
6220
                          iflags);
6281
6221
 
6282
 
  session.setXaId(trx->id);
 
6222
  session.setXaId((ib_uint64_t) ut_conv_dulint_to_longlong(trx->id));
6283
6223
 
6284
6224
  if (error) {
6285
6225
    goto cleanup;
6360
6300
    /* We update the highest file format in the system table
6361
6301
      space, if this table has higher file format setting. */
6362
6302
 
6363
 
    char changed_file_format_max[100];
6364
 
    strcpy(changed_file_format_max, innobase_file_format_max.c_str());
6365
 
    trx_sys_file_format_max_upgrade((const char **)&changed_file_format_max,
6366
 
      dict_table_get_format(innobase_table));
6367
 
    innobase_file_format_max= changed_file_format_max;
 
6303
    trx_sys_file_format_max_upgrade((const char**) &innobase_file_format_max,
 
6304
                                    dict_table_get_format(innobase_table));
6368
6305
  }
6369
6306
 
6370
6307
  /* Note: We can't call update_session() as prebuilt will not be
6536
6473
                                   session_sql_command(&session)
6537
6474
                                   == SQLCOM_DROP_DB);
6538
6475
 
6539
 
  session.setXaId(trx->id);
 
6476
  session.setXaId((ib_uint64_t) ut_conv_dulint_to_longlong(trx->id));
6540
6477
 
6541
6478
  /* Flush the log to reduce probability that the .frm files and
6542
6479
    the InnoDB data dictionary get out-of-sync if the user runs
6758
6695
 
6759
6696
  error = innobase_rename_table(trx, from.getPath().c_str(), to.getPath().c_str(), TRUE);
6760
6697
 
6761
 
  session.setXaId(trx->id);
 
6698
  session.setXaId((ib_uint64_t) ut_conv_dulint_to_longlong(trx->id));
6762
6699
 
6763
6700
  /* Tell the InnoDB server that there might be work for
6764
6701
    utility threads: */
7066
7003
 
7067
7004
        /* If index does not belong to the table of share structure. Search
7068
7005
        index->table instead */
7069
 
        if (index->table != ib_table) {
 
7006
        if (index->table != ib_table
 
7007
            && strcmp(index->table->name, share->table_name)) {
7070
7008
                i = 0;
7071
7009
                ind = dict_table_get_first_index(index->table);
7072
7010
 
7130
7068
  dict_index_t* index;
7131
7069
  ha_rows   rec_per_key;
7132
7070
  ib_int64_t  n_rows;
 
7071
  ulong   j;
 
7072
  ulong   i;
7133
7073
  os_file_stat_t  stat_info;
7134
7074
 
7135
7075
  /* If we are forcing recovery at a high level, we will suppress
7136
7076
  statistics calculation on tables, because that may crash the
7137
7077
  server if an index is badly corrupted. */
7138
7078
 
 
7079
  if (srv_force_recovery >= SRV_FORCE_NO_IBUF_MERGE) {
 
7080
 
 
7081
    /* We return success (0) instead of HA_ERR_CRASHED,
 
7082
    because we want MySQL to process this query and not
 
7083
    stop, like it would do if it received the error code
 
7084
    HA_ERR_CRASHED. */
 
7085
 
 
7086
    return(0);
 
7087
  }
 
7088
 
7139
7089
  /* We do not know if MySQL can call this function before calling
7140
7090
  external_lock(). To be safe, update the session of the current table
7141
7091
  handle. */
7227
7177
    acquiring latches inside InnoDB, we do not call it if we
7228
7178
    are asked by MySQL to avoid locking. Another reason to
7229
7179
    avoid the call is that it uses quite a lot of CPU.
7230
 
    See Bug#38185. */
7231
 
    if (flag & HA_STATUS_NO_LOCK) {
7232
 
      /* We do not update delete_length if no
7233
 
         locking is requested so the "old" value can
7234
 
         remain. delete_length is initialized to 0 in
7235
 
         the ha_statistics' constructor. */
7236
 
    } else if (UNIV_UNLIKELY
7237
 
               (srv_force_recovery >= SRV_FORCE_NO_IBUF_MERGE)) {
7238
 
      /* Avoid accessing the tablespace if
7239
 
         innodb_crash_recovery is set to a high value. */
7240
 
      stats.delete_length = 0;
7241
 
    } else {
 
7180
    See Bug#38185.
 
7181
    We do not update delete_length if no locking is requested
 
7182
    so the "old" value can remain. delete_length is initialized
 
7183
    to 0 in the ha_statistics' constructor. */
 
7184
    if (!(flag & HA_STATUS_NO_LOCK)) {
 
7185
 
7242
7186
      /* lock the data dictionary to avoid races with
7243
7187
      ibd_file_missing and tablespace_discarded */
7244
7188
      row_mysql_lock_data_dictionary(prebuilt->trx);
7284
7228
  }
7285
7229
 
7286
7230
  if (flag & HA_STATUS_CONST) {
7287
 
    ulong i;
7288
7231
    /* Verify the number of index in InnoDB and MySQL
7289
7232
       matches up. If prebuilt->clust_index_was_generated
7290
7233
       holds, InnoDB defines GEN_CLUST_INDEX internally */
7300
7243
    }
7301
7244
 
7302
7245
    for (i = 0; i < getTable()->getShare()->sizeKeys(); i++) {
7303
 
      ulong j;
7304
7246
      /* We could get index quickly through internal
7305
7247
         index mapping with the index translation table.
7306
7248
         The identity of index (match up index name with
7366
7308
    }
7367
7309
  }
7368
7310
 
7369
 
  if (srv_force_recovery >= SRV_FORCE_NO_IBUF_MERGE) {
7370
 
    goto func_exit;
7371
 
  }
7372
 
 
7373
7311
  if (flag & HA_STATUS_ERRKEY) {
7374
7312
    const dict_index_t* err_index;
7375
7313
 
7391
7329
    stats.auto_increment_value = innobase_peek_autoinc();
7392
7330
  }
7393
7331
 
7394
 
func_exit:
7395
7332
  prebuilt->trx->op_info = (char*)"";
7396
7333
 
7397
7334
  return(0);
8092
8029
{
8093
8030
  trx_t*      trx;
8094
8031
  static const char truncated_msg[] = "... truncated...\n";
8095
 
  const long    MAX_STATUS_SIZE = 1048576;
 
8032
  const long    MAX_STATUS_SIZE = 64000;
8096
8033
  ulint     trx_list_start = ULINT_UNDEFINED;
8097
8034
  ulint     trx_list_end = ULINT_UNDEFINED;
8098
8035
 
8121
8058
 
8122
8059
  if (flen > MAX_STATUS_SIZE) {
8123
8060
    usable_len = MAX_STATUS_SIZE;
8124
 
    srv_truncated_status_writes++;
8125
8061
  } else {
8126
8062
    usable_len = flen;
8127
8063
  }
8157
8093
 
8158
8094
  mutex_exit(&srv_monitor_file_mutex);
8159
8095
 
8160
 
  stat_print(session, innobase_engine_name, strlen(innobase_engine_name),
8161
 
             STRING_WITH_LEN(""), str, flen);
 
8096
  bool result = FALSE;
8162
8097
 
 
8098
  if (stat_print(session, innobase_engine_name, strlen(innobase_engine_name),
 
8099
      STRING_WITH_LEN(""), str, flen)) {
 
8100
    result= TRUE;
 
8101
  }
8163
8102
  free(str);
8164
8103
 
8165
8104
  return(FALSE);
8508
8447
        && (sql_command == SQLCOM_INSERT_SELECT
8509
8448
            || sql_command == SQLCOM_REPLACE_SELECT
8510
8449
            || sql_command == SQLCOM_UPDATE
8511
 
            || sql_command == SQLCOM_CREATE_TABLE
8512
 
            || sql_command == SQLCOM_SET_OPTION)) {
 
8450
            || sql_command == SQLCOM_CREATE_TABLE)) {
8513
8451
 
8514
8452
      /* If we either have innobase_locks_unsafe_for_binlog
8515
8453
      option set or this session is using READ COMMITTED
8517
8455
      is not set to serializable and MySQL is doing
8518
8456
      INSERT INTO...SELECT or REPLACE INTO...SELECT
8519
8457
      or UPDATE ... = (SELECT ...) or CREATE  ...
8520
 
      SELECT... or SET ... = (SELECT ...) without
8521
 
      FOR UPDATE or IN SHARE MODE in select,
8522
 
      then we use consistent read for select. */
 
8458
      SELECT... without FOR UPDATE or IN SHARE
 
8459
      MODE in select, then we use consistent read
 
8460
      for select. */
8523
8461
 
8524
8462
      prebuilt->select_lock_type = LOCK_NONE;
8525
8463
      prebuilt->stored_select_lock_type = LOCK_NONE;
8607
8545
}
8608
8546
 
8609
8547
/*******************************************************************//**
8610
 
This function reads the global auto-inc counter. It doesn't use the
 
8548
This function reads the global auto-inc counter. It doesn't use the 
8611
8549
AUTOINC lock even if the lock mode is set to TRADITIONAL.
8612
8550
@return the autoinc value */
8613
8551
UNIV_INTERN
8627
8565
 
8628
8566
  auto_inc = dict_table_autoinc_read(innodb_table);
8629
8567
 
8630
 
  if (auto_inc == 0) {
8631
 
    ut_print_timestamp(stderr);
8632
 
    fprintf(stderr, "  InnoDB: AUTOINC next value generation "
8633
 
            "is disabled for '%s'\n", innodb_table->name);
8634
 
  }
 
8568
  ut_a(auto_inc > 0);
8635
8569
 
8636
8570
  dict_table_autoinc_unlock(innodb_table);
8637
8571
 
9049
8983
uint64_t InnobaseEngine::doGetCurrentTransactionId(Session *session)
9050
8984
{
9051
8985
  trx_t *trx= session_to_trx(session);
9052
 
  return (trx->id);
 
8986
  return (ib_uint64_t) ut_conv_dulint_to_longlong(trx->id);
9053
8987
}
9054
8988
 
9055
8989
uint64_t InnobaseEngine::doGetNewTransactionId(Session *session)
9067
9001
  trx->id= trx_sys_get_new_trx_id();
9068
9002
  mutex_exit(&kernel_mutex);
9069
9003
 
9070
 
  uint64_t transaction_id= trx->id;
 
9004
  uint64_t transaction_id= (ib_uint64_t) ut_conv_dulint_to_longlong(trx->id);
9071
9005
 
9072
9006
  return transaction_id;
9073
9007
}
9204
9138
  }
9205
9139
}
9206
9140
 
9207
 
 
 
9141
/*************************************************************//**
 
9142
Check if it is a valid file format. This function is registered as
 
9143
a callback with MySQL.
 
9144
@return 0 for valid file format */
 
9145
static
 
9146
int
 
9147
innodb_file_format_name_validate(
 
9148
/*=============================*/
 
9149
  Session*      , /*!< in: thread handle */
 
9150
  drizzle_sys_var*  , /*!< in: pointer to system
 
9151
            variable */
 
9152
  void*       save, /*!< out: immediate result
 
9153
            for update function */
 
9154
  drizzle_value*    value)  /*!< in: incoming string */
 
9155
{
 
9156
  const char* file_format_input;
 
9157
  char    buff[STRING_BUFFER_USUAL_SIZE];
 
9158
  int   len = sizeof(buff);
 
9159
 
 
9160
  ut_a(save != NULL);
 
9161
  ut_a(value != NULL);
 
9162
 
 
9163
  file_format_input = value->val_str(value, buff, &len);
 
9164
 
 
9165
  if (file_format_input != NULL) {
 
9166
    uint  format_id;
 
9167
 
 
9168
    format_id = innobase_file_format_name_lookup(
 
9169
      file_format_input);
 
9170
 
 
9171
    if (format_id <= DICT_TF_FORMAT_MAX) {
 
9172
      /* Save a pointer to the name in the
 
9173
         'file_format_name_map' constant array. */
 
9174
      *static_cast<const char**>(save) =
 
9175
        trx_sys_file_format_id_to_name(format_id);
 
9176
 
 
9177
      return(0);
 
9178
    }
 
9179
  }
 
9180
 
 
9181
  *static_cast<const char**>(save) = NULL;
 
9182
  return(1);
 
9183
}
 
9184
 
 
9185
/****************************************************************//**
 
9186
Update the system variable innodb_file_format using the "saved"
 
9187
value. This function is registered as a callback with MySQL. */
 
9188
static
 
9189
void
 
9190
innodb_file_format_name_update(
 
9191
/*===========================*/
 
9192
  Session*      ,   /*!< in: thread handle */
 
9193
  drizzle_sys_var*  ,   /*!< in: pointer to
 
9194
              system variable */
 
9195
  void*       var_ptr,  /*!< out: where the
 
9196
              formal string goes */
 
9197
  const void*     save)   /*!< in: immediate result
 
9198
              from check function */
 
9199
{
 
9200
  const char* format_name;
 
9201
 
 
9202
  ut_a(var_ptr != NULL);
 
9203
  ut_a(save != NULL);
 
9204
 
 
9205
  format_name = *static_cast<const char*const*>(save);
 
9206
 
 
9207
  if (format_name) {
 
9208
    uint  format_id;
 
9209
 
 
9210
    format_id = innobase_file_format_name_lookup(format_name);
 
9211
 
 
9212
    if (format_id <= DICT_TF_FORMAT_MAX) {
 
9213
      srv_file_format = format_id;
 
9214
    }
 
9215
  }
 
9216
 
 
9217
  *static_cast<const char**>(var_ptr)
 
9218
    = trx_sys_file_format_id_to_name(srv_file_format);
 
9219
}
 
9220
 
 
9221
/*************************************************************//**
 
9222
Check if valid argument to innodb_file_format_max. This function
 
9223
is registered as a callback with MySQL.
 
9224
@return 0 for valid file format */
 
9225
static
 
9226
int
 
9227
innodb_file_format_max_validate(
 
9228
/*==============================*/
 
9229
  Session*      session, /*!< in: thread handle */
 
9230
  drizzle_sys_var*  , /*!< in: pointer to system
 
9231
            variable */
 
9232
  void*       save, /*!< out: immediate result
 
9233
            for update function */
 
9234
  drizzle_value*    value)  /*!< in: incoming string */
 
9235
{
 
9236
  const char* file_format_input;
 
9237
  char    buff[STRING_BUFFER_USUAL_SIZE];
 
9238
  int   len = sizeof(buff);
 
9239
  int   format_id;
 
9240
 
 
9241
  ut_a(save != NULL);
 
9242
  ut_a(value != NULL);
 
9243
 
 
9244
  file_format_input = value->val_str(value, buff, &len);
 
9245
 
 
9246
  if (file_format_input != NULL) {
 
9247
    format_id = innobase_file_format_validate_and_set(file_format_input);
 
9248
 
 
9249
    if (format_id >= 0) {
 
9250
      /* Save a pointer to the name in the
 
9251
         'file_format_name_map' constant array. */
 
9252
      *static_cast<const char**>(save) =
 
9253
        trx_sys_file_format_id_to_name((uint)format_id);
 
9254
 
 
9255
      return(0);
 
9256
 
 
9257
    } else {
 
9258
      push_warning_printf(session,
 
9259
                          DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
9260
                          ER_WRONG_ARGUMENTS,
 
9261
                          "InnoDB: invalid innodb_file_format_max "
 
9262
                          "value; can be any format up to %s "
 
9263
                          "or equivalent id of %d",
 
9264
                          trx_sys_file_format_id_to_name(DICT_TF_FORMAT_MAX),
 
9265
                          DICT_TF_FORMAT_MAX);
 
9266
    }
 
9267
  }
 
9268
 
 
9269
  *static_cast<const char**>(save) = NULL;
 
9270
  return(1);
 
9271
}
 
9272
 
 
9273
/****************************************************************//**
 
9274
Update the system variable innodb_file_format_max using the "saved"
 
9275
value. This function is registered as a callback with MySQL. */
 
9276
static
 
9277
void
 
9278
innodb_file_format_max_update(
 
9279
/*============================*/
 
9280
  Session*      session,  /*!< in: thread handle */
 
9281
  drizzle_sys_var*  ,   /*!< in: pointer to
 
9282
              system variable */
 
9283
  void*       var_ptr,  /*!< out: where the
 
9284
              formal string goes */
 
9285
  const void*     save)   /*!< in: immediate result
 
9286
              from check function */
 
9287
{
 
9288
  const char* format_name_in;
 
9289
  const char**  format_name_out;
 
9290
  uint    format_id;
 
9291
 
 
9292
  ut_a(save != NULL);
 
9293
  ut_a(var_ptr != NULL);
 
9294
 
 
9295
  format_name_in = *static_cast<const char*const*>(save);
 
9296
 
 
9297
  if (!format_name_in) {
 
9298
 
 
9299
    return;
 
9300
  }
 
9301
 
 
9302
  format_id = innobase_file_format_name_lookup(format_name_in);
 
9303
 
 
9304
  if (format_id > DICT_TF_FORMAT_MAX) {
 
9305
    /* DEFAULT is "on", which is invalid at runtime. */
 
9306
    push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
9307
            ER_WRONG_ARGUMENTS,
 
9308
            "Ignoring SET innodb_file_format=%s",
 
9309
            format_name_in);
 
9310
    return;
 
9311
  }
 
9312
 
 
9313
  format_name_out = static_cast<const char**>(var_ptr);
 
9314
 
 
9315
  /* Update the max format id in the system tablespace. */
 
9316
  if (trx_sys_file_format_max_set(format_id, format_name_out)) {
 
9317
    ut_print_timestamp(stderr);
 
9318
    fprintf(stderr,
 
9319
      " [Info] InnoDB: the file format in the system "
 
9320
      "tablespace is now set to %s.\n", *format_name_out);
 
9321
  }
 
9322
}
 
9323
 
 
9324
/****************************************************************//**
 
9325
Update the system variable innodb_adaptive_hash_index using the "saved"
 
9326
value. This function is registered as a callback with MySQL. */
 
9327
static
 
9328
void
 
9329
innodb_adaptive_hash_index_update(
 
9330
/*==============================*/
 
9331
  Session*      ,   /*!< in: thread handle */
 
9332
  drizzle_sys_var*  ,   /*!< in: pointer to
 
9333
              system variable */
 
9334
  void*       , /*!< out: where the
 
9335
              formal string goes */
 
9336
  const void*     save)   /*!< in: immediate result
 
9337
              from check function */
 
9338
{
 
9339
  if (*(bool*) save) {
 
9340
    btr_search_enable();
 
9341
  } else {
 
9342
    btr_search_disable();
 
9343
  }
 
9344
}
 
9345
 
 
9346
/****************************************************************//**
 
9347
Update the system variable innodb_old_blocks_pct using the "saved"
 
9348
value. This function is registered as a callback with MySQL. */
 
9349
static
 
9350
void
 
9351
innodb_old_blocks_pct_update(
 
9352
/*=========================*/
 
9353
        Session*                        ,       /*!< in: thread handle */
 
9354
        drizzle_sys_var*        ,       /*!< in: pointer to
 
9355
                                                system variable */
 
9356
        void*                           ,/*!< out: where the
 
9357
                                                formal string goes */
 
9358
        const void*                     save)   /*!< in: immediate result
 
9359
                                                from check function */
 
9360
{
 
9361
        innobase_old_blocks_pct = buf_LRU_old_ratio_update(
 
9362
                *static_cast<const uint*>(save), TRUE);
 
9363
}
 
9364
 
 
9365
/*************************************************************//**
 
9366
Check if it is a valid value of innodb_change_buffering. This function is
 
9367
registered as a callback with MySQL.
 
9368
@return 0 for valid innodb_change_buffering */
 
9369
static
 
9370
int
 
9371
innodb_change_buffering_validate(
 
9372
/*=============================*/
 
9373
  Session*      , /*!< in: thread handle */
 
9374
  drizzle_sys_var*  , /*!< in: pointer to system
 
9375
            variable */
 
9376
  void*       save, /*!< out: immediate result
 
9377
            for update function */
 
9378
  drizzle_value*    value)  /*!< in: incoming string */
 
9379
{
 
9380
  const char* change_buffering_input;
 
9381
  char    buff[STRING_BUFFER_USUAL_SIZE];
 
9382
  int   len = sizeof(buff);
 
9383
 
 
9384
  ut_a(save != NULL);
 
9385
  ut_a(value != NULL);
 
9386
 
 
9387
  change_buffering_input = value->val_str(value, buff, &len);
 
9388
 
 
9389
  if (change_buffering_input != NULL) {
 
9390
    ulint use;
 
9391
 
 
9392
    for (use = 0; use < UT_ARR_SIZE(innobase_change_buffering_values);
 
9393
         use++) {
 
9394
      if (!innobase_strcasecmp(
 
9395
            change_buffering_input,
 
9396
            innobase_change_buffering_values[use])) {
 
9397
        *(ibuf_use_t*) save = (ibuf_use_t) use;
 
9398
        return(0);
 
9399
      }
 
9400
    }
 
9401
  }
 
9402
 
 
9403
  return(1);
 
9404
}
 
9405
 
 
9406
/****************************************************************//**
 
9407
Update the system variable innodb_change_buffering using the "saved"
 
9408
value. This function is registered as a callback with MySQL. */
 
9409
static
 
9410
void
 
9411
innodb_change_buffering_update(
 
9412
/*===========================*/
 
9413
  Session*      ,   /*!< in: thread handle */
 
9414
  drizzle_sys_var*  ,   /*!< in: pointer to
 
9415
              system variable */
 
9416
  void*       var_ptr,  /*!< out: where the
 
9417
              formal string goes */
 
9418
  const void*     save)   /*!< in: immediate result
 
9419
              from check function */
 
9420
{
 
9421
  ut_a(var_ptr != NULL);
 
9422
  ut_a(save != NULL);
 
9423
  ut_a((*(ibuf_use_t*) save) < IBUF_USE_COUNT);
 
9424
 
 
9425
  ibuf_use = *(const ibuf_use_t*) save;
 
9426
 
 
9427
  *(const char**) var_ptr = innobase_change_buffering_values[ibuf_use];
 
9428
}
 
9429
 
 
9430
/* plugin options */
 
9431
static DRIZZLE_SYSVAR_BOOL(checksums, innobase_use_checksums,
 
9432
  PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
 
9433
  "Enable InnoDB checksums validation (enabled by default). ",
 
9434
  NULL, NULL, TRUE);
 
9435
 
 
9436
static DRIZZLE_SYSVAR_STR(data_home_dir, innobase_data_home_dir,
 
9437
  PLUGIN_VAR_READONLY,
 
9438
  "The common part for InnoDB table spaces.",
 
9439
  NULL, NULL, NULL);
 
9440
 
 
9441
static DRIZZLE_SYSVAR_BOOL(doublewrite, innobase_use_doublewrite,
 
9442
  PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
 
9443
  "Enable InnoDB doublewrite buffer (enabled by default). ",
 
9444
  NULL, NULL, TRUE);
 
9445
 
 
9446
static DRIZZLE_SYSVAR_ULONG(io_capacity, srv_io_capacity,
 
9447
  PLUGIN_VAR_RQCMDARG,
 
9448
  "Number of IOPs the server can do. Tunes the background IO rate",
 
9449
  NULL, NULL, 200, 100, ~0L, 0);
 
9450
 
 
9451
static DRIZZLE_SYSVAR_ULONG(purge_batch_size, srv_purge_batch_size,
 
9452
  PLUGIN_VAR_OPCMDARG,
 
9453
  "Number of UNDO logs to purge in one batch from the history list. "
 
9454
  "Default is 20",
 
9455
  NULL, NULL,
 
9456
  20,                   /* Default setting */
 
9457
  1,                    /* Minimum value */
 
9458
  5000, 0);             /* Maximum value */
 
9459
 
 
9460
static DRIZZLE_SYSVAR_ULONG(purge_threads, srv_n_purge_threads,
 
9461
  PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_READONLY,
 
9462
  "Purge threads can be either 0 or 1. Default is 0.",
 
9463
  NULL, NULL,
 
9464
  0,                    /* Default setting */
 
9465
  0,                    /* Minimum value */
 
9466
  1, 0);                /* Maximum value */
 
9467
 
 
9468
static DRIZZLE_SYSVAR_ULONG(fast_shutdown, innobase_fast_shutdown,
 
9469
  PLUGIN_VAR_OPCMDARG,
 
9470
  "Speeds up the shutdown process of the InnoDB storage engine. Possible "
 
9471
  "values are 0, 1 (faster)"
 
9472
  " or 2 (fastest - crash-like)"
 
9473
  ".",
 
9474
  NULL, NULL, 1, 0, 2, 0);
 
9475
 
 
9476
static DRIZZLE_SYSVAR_BOOL(file_per_table, srv_file_per_table,
 
9477
  PLUGIN_VAR_NOCMDARG,
 
9478
  "Stores each InnoDB table to an .ibd file in the database dir.",
 
9479
  NULL, NULL, TRUE);
 
9480
 
 
9481
static DRIZZLE_SYSVAR_STR(file_format, innobase_file_format_name,
 
9482
  PLUGIN_VAR_RQCMDARG,
 
9483
  "File format to use for new tables in .ibd files.",
 
9484
  innodb_file_format_name_validate,
 
9485
  innodb_file_format_name_update, "Barracuda");
 
9486
 
 
9487
/* "innobase_file_format_check" decides whether we would continue
 
9488
booting the server if the file format stamped on the system
 
9489
table space exceeds the maximum file format supported
 
9490
by the server. Can be set during server startup at command
 
9491
line or configure file, and a read only variable after
 
9492
server startup */
 
9493
static DRIZZLE_SYSVAR_BOOL(file_format_check, innobase_file_format_check,
 
9494
  PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_READONLY,
 
9495
  "Whether to perform system file format check.",
 
9496
  NULL, NULL, TRUE);
 
9497
 
 
9498
/* If a new file format is introduced, the file format
 
9499
name needs to be updated accordingly. Please refer to
 
9500
file_format_name_map[] defined in trx0sys.c for the next
 
9501
file format name. */
 
9502
static DRIZZLE_SYSVAR_STR(file_format_max, innobase_file_format_max,
 
9503
  PLUGIN_VAR_OPCMDARG,
 
9504
  "The highest file format in the tablespace.",
 
9505
  innodb_file_format_max_validate,
 
9506
  innodb_file_format_max_update,
 
9507
  "Antelope");
 
9508
 
 
9509
static DRIZZLE_SYSVAR_ULONG(flush_log_at_trx_commit, srv_flush_log_at_trx_commit,
 
9510
  PLUGIN_VAR_OPCMDARG,
 
9511
  "Set to 0 (write and flush once per second),"
 
9512
  " 1 (write and flush at each commit)"
 
9513
  " or 2 (write at commit, flush once per second).",
 
9514
  NULL, NULL, 1, 0, 2, 0);
 
9515
 
 
9516
static DRIZZLE_SYSVAR_STR(flush_method, innobase_file_flush_method,
 
9517
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
 
9518
  "With which method to flush data.", NULL, NULL, NULL);
 
9519
 
 
9520
#ifdef UNIV_LOG_ARCHIVE
 
9521
static DRIZZLE_SYSVAR_STR(log_arch_dir, innobase_log_arch_dir,
 
9522
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
 
9523
  "Where full logs should be archived.", NULL, NULL, NULL);
 
9524
 
 
9525
static DRIZZLE_SYSVAR_BOOL(log_archive, innobase_log_archive,
 
9526
  PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_READONLY,
 
9527
  "Set to 1 if you want to have logs archived.", NULL, NULL, FALSE);
 
9528
#endif /* UNIV_LOG_ARCHIVE */
 
9529
 
 
9530
static DRIZZLE_SYSVAR_STR(log_group_home_dir, innobase_log_group_home_dir,
 
9531
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
 
9532
  "Path to InnoDB log files.", NULL, NULL, NULL);
 
9533
 
 
9534
static DRIZZLE_SYSVAR_ULONG(max_dirty_pages_pct, srv_max_buf_pool_modified_pct,
 
9535
  PLUGIN_VAR_RQCMDARG,
 
9536
  "Percentage of dirty pages allowed in bufferpool.",
 
9537
  NULL, NULL, 75, 0, 99, 0);
 
9538
 
 
9539
static DRIZZLE_SYSVAR_BOOL(adaptive_flushing, srv_adaptive_flushing,
 
9540
  PLUGIN_VAR_NOCMDARG,
 
9541
  "Attempt flushing dirty pages to avoid IO bursts at checkpoints.",
 
9542
  NULL, NULL, TRUE);
 
9543
 
 
9544
static DRIZZLE_SYSVAR_ULONG(max_purge_lag, srv_max_purge_lag,
 
9545
  PLUGIN_VAR_RQCMDARG,
 
9546
  "Desired maximum length of the purge queue (0 = no limit)",
 
9547
  NULL, NULL, 0, 0, ~0L, 0);
 
9548
 
 
9549
static DRIZZLE_SYSVAR_BOOL(status_file, innobase_create_status_file,
 
9550
  PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_NOSYSVAR,
 
9551
  "Enable SHOW INNODB STATUS output in the innodb_status.<pid> file",
 
9552
  NULL, NULL, FALSE);
 
9553
 
 
9554
static DRIZZLE_SYSVAR_ULONGLONG(stats_sample_pages, srv_stats_sample_pages,
 
9555
  PLUGIN_VAR_RQCMDARG,
 
9556
  "The number of index pages to sample when calculating statistics (default 8)",
 
9557
  NULL, NULL, 8, 1, ~0ULL, 0);
 
9558
 
 
9559
static DRIZZLE_SYSVAR_BOOL(adaptive_hash_index, btr_search_enabled,
 
9560
  PLUGIN_VAR_OPCMDARG,
 
9561
  "Enable InnoDB adaptive hash index (enabled by default).",
 
9562
  NULL, innodb_adaptive_hash_index_update, TRUE);
 
9563
 
 
9564
static DRIZZLE_SYSVAR_ULONG(replication_delay, srv_replication_delay,
 
9565
  PLUGIN_VAR_RQCMDARG,
 
9566
  "Replication thread delay (ms) on the slave server if "
 
9567
  "innodb_thread_concurrency is reached (0 by default)",
 
9568
  NULL, NULL, 0, 0, ~0UL, 0);
 
9569
 
 
9570
static DRIZZLE_SYSVAR_LONG(additional_mem_pool_size, innobase_additional_mem_pool_size,
 
9571
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
 
9572
  "Size of a memory pool InnoDB uses to store data dictionary information and other internal data structures.",
 
9573
  NULL, NULL, 8*1024*1024L, 512*1024L, LONG_MAX, 1024);
 
9574
 
 
9575
static DRIZZLE_SYSVAR_UINT(autoextend_increment, srv_auto_extend_increment,
 
9576
  PLUGIN_VAR_RQCMDARG,
 
9577
  "Data file autoextend increment in megabytes",
 
9578
  NULL, NULL, 8L, 1L, 1000L, 0);
 
9579
 
 
9580
static DRIZZLE_SYSVAR_LONGLONG(buffer_pool_size, innobase_buffer_pool_size,
 
9581
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
 
9582
  "The size of the memory buffer InnoDB uses to cache data and indexes of its tables.",
 
9583
  NULL, NULL, 128*1024*1024L, 5*1024*1024L, INT64_MAX, 1024*1024L);
 
9584
 
 
9585
static DRIZZLE_SYSVAR_LONGLONG(buffer_pool_instances, innobase_buffer_pool_instances,
 
9586
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
 
9587
  "Number of buffer pool instances, set to higher value on high-end machines to increase scalability",
 
9588
  NULL, NULL, 1L, 1L, MAX_BUFFER_POOLS, 1L);
 
9589
 
 
9590
static DRIZZLE_SYSVAR_ULONG(commit_concurrency, innobase_commit_concurrency,
 
9591
  PLUGIN_VAR_RQCMDARG,
 
9592
  "Helps in performance tuning in heavily concurrent environments.",
 
9593
  innobase_commit_concurrency_validate, NULL, 0, 0, 1000, 0);
 
9594
 
 
9595
static DRIZZLE_SYSVAR_ULONG(concurrency_tickets, srv_n_free_tickets_to_enter,
 
9596
  PLUGIN_VAR_RQCMDARG,
 
9597
  "Number of times a thread is allowed to enter InnoDB within the same SQL query after it has once got the ticket",
 
9598
  NULL, NULL, 500L, 1L, ~0L, 0);
 
9599
 
 
9600
static DRIZZLE_SYSVAR_ULONG(read_io_threads, innobase_read_io_threads,
 
9601
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
 
9602
  "Number of background read I/O threads in InnoDB.",
 
9603
  NULL, NULL, 4, 1, 64, 0);
 
9604
 
 
9605
static DRIZZLE_SYSVAR_ULONG(write_io_threads, innobase_write_io_threads,
 
9606
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
 
9607
  "Number of background write I/O threads in InnoDB.",
 
9608
  NULL, NULL, 4, 1, 64, 0);
 
9609
 
 
9610
static DRIZZLE_SYSVAR_LONG(force_recovery, innobase_force_recovery,
 
9611
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
 
9612
  "Helps to save your data in case the disk image of the database becomes corrupt.",
 
9613
  NULL, NULL, 0, 0, 6, 0);
 
9614
 
 
9615
static DRIZZLE_SYSVAR_LONG(log_buffer_size, innobase_log_buffer_size,
 
9616
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
 
9617
  "The size of the buffer which InnoDB uses to write log to the log files on disk.",
 
9618
  NULL, NULL, 8*1024*1024L, 256*1024L, LONG_MAX, 1024);
 
9619
 
 
9620
static DRIZZLE_SYSVAR_LONGLONG(log_file_size, innobase_log_file_size,
 
9621
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
 
9622
  "Size of each log file in a log group.",
 
9623
  NULL, NULL, 20*1024*1024L, 1*1024*1024L, INT64_MAX, 1024*1024L);
 
9624
 
 
9625
static DRIZZLE_SYSVAR_LONG(log_files_in_group, innobase_log_files_in_group,
 
9626
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
 
9627
  "Number of log files in the log group. InnoDB writes to the files in a circular fashion. Value 3 is recommended here.",
 
9628
  NULL, NULL, 2, 2, 100, 0);
 
9629
 
 
9630
static DRIZZLE_SYSVAR_LONG(mirrored_log_groups, innobase_mirrored_log_groups,
 
9631
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
 
9632
  "Number of identical copies of log groups we keep for the database. Currently this should be set to 1.",
 
9633
  NULL, NULL, 1, 1, 10, 0);
 
9634
 
 
9635
static DRIZZLE_SYSVAR_UINT(old_blocks_pct, innobase_old_blocks_pct,
 
9636
  PLUGIN_VAR_RQCMDARG,
 
9637
  "Percentage of the buffer pool to reserve for 'old' blocks.",
 
9638
  NULL, innodb_old_blocks_pct_update, 100 * 3 / 8, 5, 95, 0);
 
9639
 
 
9640
static DRIZZLE_SYSVAR_UINT(old_blocks_time, buf_LRU_old_threshold_ms,
 
9641
  PLUGIN_VAR_RQCMDARG,
 
9642
  "Move blocks to the 'new' end of the buffer pool if the first access"
 
9643
  " was at least this many milliseconds ago."
 
9644
  " The timeout is disabled if 0 (the default).",
 
9645
  NULL, NULL, 0, 0, UINT32_MAX, 0);
 
9646
 
 
9647
static DRIZZLE_SYSVAR_LONG(open_files, innobase_open_files,
 
9648
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
 
9649
  "How many files at the maximum InnoDB keeps open at the same time.",
 
9650
  NULL, NULL, 300L, 10L, LONG_MAX, 0);
 
9651
 
 
9652
static DRIZZLE_SYSVAR_ULONG(sync_spin_loops, srv_n_spin_wait_rounds,
 
9653
  PLUGIN_VAR_RQCMDARG,
 
9654
  "Count of spin-loop rounds in InnoDB mutexes (30 by default)",
 
9655
  NULL, NULL, 30L, 0L, ~0L, 0);
 
9656
 
 
9657
static DRIZZLE_SYSVAR_ULONG(spin_wait_delay, srv_spin_wait_delay,
 
9658
  PLUGIN_VAR_OPCMDARG,
 
9659
  "Maximum delay between polling for a spin lock (6 by default)",
 
9660
  NULL, NULL, 6L, 0L, ~0L, 0);
 
9661
 
 
9662
static DRIZZLE_SYSVAR_ULONG(thread_concurrency, srv_thread_concurrency,
 
9663
  PLUGIN_VAR_RQCMDARG,
 
9664
  "Helps in performance tuning in heavily concurrent environments. Sets the maximum number of threads allowed inside InnoDB. Value 0 will disable the thread throttling.",
 
9665
  NULL, NULL, 0, 0, 1000, 0);
 
9666
 
 
9667
static DRIZZLE_SYSVAR_ULONG(thread_sleep_delay, srv_thread_sleep_delay,
 
9668
  PLUGIN_VAR_RQCMDARG,
 
9669
  "Time of innodb thread sleeping before joining InnoDB queue (usec). Value 0 disable a sleep",
 
9670
  NULL, NULL, 10000L, 0L, ~0L, 0);
 
9671
 
 
9672
static DRIZZLE_SYSVAR_STR(data_file_path, innobase_data_file_path,
 
9673
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
 
9674
  "Path to individual files and their sizes.",
 
9675
  NULL, NULL, NULL);
 
9676
 
 
9677
static DRIZZLE_SYSVAR_STR(version, innodb_version_str,
 
9678
  PLUGIN_VAR_NOCMDOPT | PLUGIN_VAR_READONLY,
 
9679
  "InnoDB version", NULL, NULL, INNODB_VERSION_STR);
 
9680
 
 
9681
static DRIZZLE_SYSVAR_BOOL(use_sys_malloc, srv_use_sys_malloc,
 
9682
  PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
 
9683
  "Use OS memory allocator instead of InnoDB's internal memory allocator",
 
9684
  NULL, NULL, TRUE);
 
9685
 
 
9686
static DRIZZLE_SYSVAR_BOOL(use_native_aio, srv_use_native_aio,
 
9687
  PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
 
9688
  "Use native AIO if supported on this platform.",
 
9689
  NULL, NULL, TRUE);
 
9690
 
 
9691
static DRIZZLE_SYSVAR_STR(change_buffering, innobase_change_buffering,
 
9692
  PLUGIN_VAR_RQCMDARG,
 
9693
  "Buffer changes to reduce random access: "
 
9694
  "OFF, ON, inserting, deleting, changing or purging..",
 
9695
  innodb_change_buffering_validate,
 
9696
  innodb_change_buffering_update, "all");
 
9697
 
 
9698
static DRIZZLE_SYSVAR_ULONG(read_ahead_threshold, srv_read_ahead_threshold,
 
9699
  PLUGIN_VAR_RQCMDARG,
 
9700
  "Number of pages that must be accessed sequentially for InnoDB to "
 
9701
  "trigger a readahead.",
 
9702
  NULL, NULL, 56, 0, 64, 0);
9208
9703
 
9209
9704
static void init_options(drizzled::module::option_context &context)
9210
9705
{
9216
9711
  context("disable-doublewrite",
9217
9712
          "Disable InnoDB doublewrite buffer.");
9218
9713
  context("io-capacity",
9219
 
          po::value<io_capacity_constraint>(&innodb_io_capacity)->default_value(200),
 
9714
          po::value<unsigned long>(&srv_io_capacity)->default_value(200),
9220
9715
          "Number of IOPs the server can do. Tunes the background IO rate");
9221
9716
  context("fast-shutdown",
9222
 
          po::value<trinary_constraint>(&innobase_fast_shutdown)->default_value(1), 
 
9717
          po::value<unsigned long>(&innobase_fast_shutdown)->default_value(1), 
9223
9718
          "Speeds up the shutdown process of the InnoDB storage engine. Possible values are 0, 1 (faster) or 2 (fastest - crash-like).");
9224
9719
  context("purge-batch-size",
9225
 
          po::value<purge_batch_constraint>(&innodb_purge_batch_size)->default_value(20),
 
9720
          po::value<unsigned long>(&srv_purge_batch_size)->default_value(20),
9226
9721
          "Number of UNDO logs to purge in one batch from the history list. "
9227
9722
          "Default is 20.");
9228
9723
  context("purge-threads",
9229
 
          po::value<purge_threads_constraint>(&innodb_n_purge_threads)->default_value(0),
 
9724
          po::value<unsigned long>(&srv_n_purge_threads)->default_value(0),
9230
9725
          "Purge threads can be either 0 or 1. Defalut is 0.");
9231
9726
  context("file-per-table",
9232
9727
          po::value<bool>(&srv_file_per_table)->default_value(false)->zero_tokens(),
9233
9728
          "Stores each InnoDB table to an .ibd file in the database dir.");
9234
9729
  context("file-format",
9235
 
          po::value<string>(&innobase_file_format_name)->default_value("Antelope"),
 
9730
          po::value<string>()->default_value("Antelope"),
9236
9731
          "File format to use for new tables in .ibd files.");
9237
9732
  context("file-format-max",
9238
 
          po::value<string>(&innobase_file_format_max)->default_value("Antelope"),
 
9733
          po::value<string>()->default_value("Antelope"),
9239
9734
          "The highest file format in the tablespace.");
9240
9735
  context("file-format-check",
9241
9736
          po::value<bool>(&innobase_file_format_check)->default_value(true)->zero_tokens(),
9242
9737
          "Whether to perform system file format check.");
9243
9738
  context("flush-log-at-trx-commit",
9244
 
          po::value<trinary_constraint>(&innodb_flush_log_at_trx_commit)->default_value(1),
 
9739
          po::value<unsigned long>(&srv_flush_log_at_trx_commit)->default_value(1),
9245
9740
          "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).");
9246
9741
  context("flush-method",
9247
9742
          po::value<string>(),
9248
9743
          "With which method to flush data.");
 
9744
#ifdef UNIV_LOG_ARCHIVE
 
9745
  context("log-arch-dir",
 
9746
          po::value<string>(),
 
9747
          "Where full logs should be archived.");
 
9748
  context("log-archive",
 
9749
          po::value<bool>(&innobase_log_archive)->default_value(false)->zero_tokens(),
 
9750
          "Set to 1 if you want to have logs archived.");
 
9751
#endif /* UNIV_LOG_ARCHIVE */
9249
9752
  context("log-group-home-dir",
9250
9753
          po::value<string>(),
9251
9754
          "Path to InnoDB log files.");
9252
9755
  context("max-dirty-pages-pct",
9253
 
          po::value<max_dirty_pages_constraint>(&innodb_max_dirty_pages_pct)->default_value(75),
 
9756
          po::value<unsigned long>(&srv_max_buf_pool_modified_pct)->default_value(75),
9254
9757
          "Percentage of dirty pages allowed in bufferpool.");
9255
9758
  context("disable-adaptive-flushing",
9256
9759
          "Do not attempt flushing dirty pages to avoid IO bursts at checkpoints.");
9257
9760
  context("max-purge-lag",
9258
 
          po::value<uint64_constraint>(&innodb_max_purge_lag)->default_value(0),
 
9761
          po::value<unsigned long>(&srv_max_purge_lag)->default_value(0),
9259
9762
          "Desired maximum length of the purge queue (0 = no limit)");
9260
9763
  context("status-file",
9261
9764
          po::value<bool>(&innobase_create_status_file)->default_value(false)->zero_tokens(),
9263
9766
  context("disable-stats-on-metadata",
9264
9767
          "Disable statistics gathering for metadata commands such as SHOW TABLE STATUS (on by default)");
9265
9768
  context("stats-sample-pages",
9266
 
          po::value<uint64_nonzero_constraint>(&innodb_stats_sample_pages)->default_value(8),
 
9769
          po::value<uint64_t>(&srv_stats_sample_pages)->default_value(8),
9267
9770
          "The number of index pages to sample when calculating statistics (default 8)");
9268
9771
  context("disable-adaptive-hash-index",
9269
9772
          "Enable InnoDB adaptive hash index (enabled by default)");
9270
9773
  context("replication-delay",
9271
 
          po::value<uint64_constraint>(&innodb_replication_delay)->default_value(0),
 
9774
          po::value<unsigned long>(&srv_replication_delay)->default_value(0),
9272
9775
          "Replication thread delay (ms) on the slave server if innodb_thread_concurrency is reached (0 by default)");
9273
9776
  context("additional-mem-pool-size",
9274
 
          po::value<additional_mem_pool_constraint>(&innobase_additional_mem_pool_size)->default_value(8*1024*1024L),
 
9777
          po::value<long>(&innobase_additional_mem_pool_size)->default_value(8*1024*1024L),
9275
9778
          "Size of a memory pool InnoDB uses to store data dictionary information and other internal data structures.");
9276
9779
  context("autoextend-increment",
9277
 
          po::value<autoextend_constraint>(&innodb_auto_extend_increment)->default_value(8L),
 
9780
          po::value<uint32_t>(&srv_auto_extend_increment)->default_value(8L),
9278
9781
          "Data file autoextend increment in megabytes");
9279
9782
  context("buffer-pool-size",
9280
 
          po::value<buffer_pool_constraint>(&innobase_buffer_pool_size)->default_value(128*1024*1024L),
 
9783
          po::value<int64_t>(&innobase_buffer_pool_size)->default_value(128*1024*1024L),
9281
9784
          "The size of the memory buffer InnoDB uses to cache data and indexes of its tables.");
9282
9785
  context("buffer-pool-instances",
9283
 
          po::value<buffer_pool_instances_constraint>(&innobase_buffer_pool_instances)->default_value(1),
 
9786
          po::value<int64_t>(&innobase_buffer_pool_instances)->default_value(1),
9284
9787
          "Number of buffer pool instances, set to higher value on high-end machines to increase scalability");
9285
9788
 
9286
9789
  context("commit-concurrency",
9287
 
          po::value<concurrency_constraint>(&innobase_commit_concurrency)->default_value(0),
 
9790
          po::value<unsigned long>(&innobase_commit_concurrency)->default_value(0),
9288
9791
          "Helps in performance tuning in heavily concurrent environments.");
9289
9792
  context("concurrency-tickets",
9290
 
          po::value<uint32_nonzero_constraint>(&innodb_concurrency_tickets)->default_value(500L),
 
9793
          po::value<unsigned long>(&srv_n_free_tickets_to_enter)->default_value(500L),
9291
9794
          "Number of times a thread is allowed to enter InnoDB within the same SQL query after it has once got the ticket");
9292
9795
  context("read-io-threads",
9293
 
          po::value<io_threads_constraint>(&innobase_read_io_threads)->default_value(4),
 
9796
          po::value<unsigned long>(&innobase_read_io_threads)->default_value(4),
9294
9797
          "Number of background read I/O threads in InnoDB.");
9295
9798
  context("write-io-threads",
9296
 
          po::value<io_threads_constraint>(&innobase_write_io_threads)->default_value(4),
 
9799
          po::value<unsigned long>(&innobase_write_io_threads)->default_value(4),
9297
9800
          "Number of background write I/O threads in InnoDB.");
9298
9801
  context("force-recovery",
9299
 
          po::value<force_recovery_constraint>(&innobase_force_recovery)->default_value(0),
 
9802
          po::value<long>(&innobase_force_recovery)->default_value(0),
9300
9803
          "Helps to save your data in case the disk image of the database becomes corrupt.");
9301
9804
  context("log-buffer-size",
9302
 
          po::value<log_buffer_constraint>(&innobase_log_buffer_size)->default_value(8*1024*1024L),
 
9805
          po::value<long>(&innobase_log_buffer_size)->default_value(8*1024*1024L),
9303
9806
          "The size of the buffer which InnoDB uses to write log to the log files on disk.");
9304
9807
  context("log-file-size",
9305
 
          po::value<log_file_constraint>(&innobase_log_file_size)->default_value(20*1024*1024L),
 
9808
          po::value<int64_t>(&innobase_log_file_size)->default_value(20*1024*1024L),
9306
9809
          "The size of the buffer which InnoDB uses to write log to the log files on disk.");
9307
9810
  context("log-files-in-group",
9308
 
          po::value<log_files_in_group_constraint>(&innobase_log_files_in_group)->default_value(2),
 
9811
          po::value<long>(&innobase_log_files_in_group)->default_value(2),
9309
9812
          "Number of log files in the log group. InnoDB writes to the files in a circular fashion.");
9310
9813
  context("mirrored-log-groups",
9311
 
          po::value<mirrored_log_groups_constraint>(&innobase_mirrored_log_groups)->default_value(1),
 
9814
          po::value<long>(&innobase_mirrored_log_groups)->default_value(1),
9312
9815
          "Number of identical copies of log groups we keep for the database. Currently this should be set to 1.");
9313
9816
  context("open-files",
9314
 
          po::value<open_files_constraint>(&innobase_open_files)->default_value(300L),
 
9817
          po::value<long>(&innobase_open_files)->default_value(300L),
9315
9818
          "How many files at the maximum InnoDB keeps open at the same time.");
9316
9819
  context("sync-spin-loops",
9317
 
          po::value<uint32_constraint>(&innodb_sync_spin_loops)->default_value(30L),
 
9820
          po::value<unsigned long>(&srv_n_spin_wait_rounds)->default_value(30L),
9318
9821
          "Count of spin-loop rounds in InnoDB mutexes (30 by default)");
9319
9822
  context("spin-wait-delay",
9320
 
          po::value<uint32_constraint>(&innodb_spin_wait_delay)->default_value(6L),
 
9823
          po::value<unsigned long>(&srv_spin_wait_delay)->default_value(6L),
9321
9824
          "Maximum delay between polling for a spin lock (6 by default)");
9322
9825
  context("thread-concurrency",
9323
 
          po::value<concurrency_constraint>(&innobase_thread_concurrency)->default_value(0),
 
9826
          po::value<unsigned long>(&srv_thread_concurrency)->default_value(0),
9324
9827
          "Helps in performance tuning in heavily concurrent environments. Sets the maximum number of threads allowed inside InnoDB. Value 0 will disable the thread throttling.");
9325
9828
  context("thread-sleep-delay",
9326
 
          po::value<uint32_constraint>(&innodb_thread_sleep_delay)->default_value(10000L),
 
9829
          po::value<unsigned long>(&srv_thread_sleep_delay)->default_value(10000L),
9327
9830
          "Time of innodb thread sleeping before joining InnoDB queue (usec). Value 0 disable a sleep");
9328
9831
  context("data-file-path",
9329
9832
          po::value<string>(),
9334
9837
  context("use-internal-malloc",
9335
9838
          "Use InnoDB's internal memory allocator instal of the OS memory allocator.");
9336
9839
  context("change-buffering",
9337
 
          po::value<string>(&innobase_change_buffering),
 
9840
          po::value<string>(),
9338
9841
          "Buffer changes to reduce random access: OFF, ON, inserting, deleting, changing, or purging.");
9339
9842
  context("read-ahead-threshold",
9340
 
          po::value<read_ahead_threshold_constraint>(&innodb_read_ahead_threshold)->default_value(56),
 
9843
          po::value<unsigned long>(&srv_read_ahead_threshold)->default_value(56),
9341
9844
          "Number of pages that must be accessed sequentially for InnoDB to trigger a readahead.");
9342
9845
  context("disable-xa",
9343
9846
          "Disable InnoDB support for the XA two-phase commit");
9344
9847
  context("disable-table-locks",
9345
9848
          "Disable InnoDB locking in LOCK TABLES");
9346
9849
  context("strict-mode",
9347
 
          po::value<bool>(&strict_mode)->default_value(false)->zero_tokens(),
 
9850
          po::value<bool>()->default_value(false)->zero_tokens(),
9348
9851
          "Use strict mode when evaluating create options.");
9349
 
  context("replication-log",
9350
 
          po::value<bool>(&innobase_use_replication_log)->default_value(false),
9351
 
          _("Enable internal replication log."));
9352
9852
  context("lock-wait-timeout",
9353
 
          po::value<lock_wait_constraint>(&lock_wait_timeout)->default_value(50),
9354
 
          _("Timeout in seconds an InnoDB transaction may wait for a lock before being rolled back. Values above 100000000 disable the timeout."));
9355
 
  context("old-blocks-pct",
9356
 
          po::value<old_blocks_constraint>(&innobase_old_blocks_pct)->default_value(100 * 3 / 8),
9357
 
          _("Percentage of the buffer pool to reserve for 'old' blocks."));
9358
 
  context("old-blocks-time",
9359
 
          po::value<uint32_t>(&buf_LRU_old_threshold_ms)->default_value(0),
9360
 
          _("ove blocks to the 'new' end of the buffer pool if the first access"
9361
 
            " was at least this many milliseconds ago."
9362
 
            " The timeout is disabled if 0 (the default)."));
 
9853
          po::value<unsigned long>()->default_value(50),
 
9854
          "Timeout in seconds an InnoDB transaction may wait for a lock before being rolled back. Values above 100000000 disable the timeout.");
9363
9855
}
9364
9856
 
9365
 
 
 
9857
static drizzle_sys_var* innobase_system_variables[]= {
 
9858
  DRIZZLE_SYSVAR(additional_mem_pool_size),
 
9859
  DRIZZLE_SYSVAR(autoextend_increment),
 
9860
  DRIZZLE_SYSVAR(buffer_pool_size),
 
9861
  DRIZZLE_SYSVAR(buffer_pool_instances),
 
9862
  DRIZZLE_SYSVAR(checksums),
 
9863
  DRIZZLE_SYSVAR(commit_concurrency),
 
9864
  DRIZZLE_SYSVAR(concurrency_tickets),
 
9865
  DRIZZLE_SYSVAR(data_file_path),
 
9866
  DRIZZLE_SYSVAR(data_home_dir),
 
9867
  DRIZZLE_SYSVAR(doublewrite),
 
9868
  DRIZZLE_SYSVAR(fast_shutdown),
 
9869
  DRIZZLE_SYSVAR(read_io_threads),
 
9870
  DRIZZLE_SYSVAR(write_io_threads),
 
9871
  DRIZZLE_SYSVAR(file_per_table),
 
9872
  DRIZZLE_SYSVAR(file_format),
 
9873
  DRIZZLE_SYSVAR(file_format_check),
 
9874
  DRIZZLE_SYSVAR(file_format_max),
 
9875
  DRIZZLE_SYSVAR(flush_log_at_trx_commit),
 
9876
  DRIZZLE_SYSVAR(flush_method),
 
9877
  DRIZZLE_SYSVAR(force_recovery),
 
9878
  DRIZZLE_SYSVAR(lock_wait_timeout),
 
9879
#ifdef UNIV_LOG_ARCHIVE
 
9880
  DRIZZLE_SYSVAR(log_arch_dir),
 
9881
  DRIZZLE_SYSVAR(log_archive),
 
9882
#endif /* UNIV_LOG_ARCHIVE */
 
9883
  DRIZZLE_SYSVAR(log_buffer_size),
 
9884
  DRIZZLE_SYSVAR(log_file_size),
 
9885
  DRIZZLE_SYSVAR(log_files_in_group),
 
9886
  DRIZZLE_SYSVAR(log_group_home_dir),
 
9887
  DRIZZLE_SYSVAR(max_dirty_pages_pct),
 
9888
  DRIZZLE_SYSVAR(max_purge_lag),
 
9889
  DRIZZLE_SYSVAR(adaptive_flushing),
 
9890
  DRIZZLE_SYSVAR(mirrored_log_groups),
 
9891
  DRIZZLE_SYSVAR(old_blocks_pct),
 
9892
  DRIZZLE_SYSVAR(old_blocks_time),
 
9893
  DRIZZLE_SYSVAR(open_files),
 
9894
  DRIZZLE_SYSVAR(stats_sample_pages),
 
9895
  DRIZZLE_SYSVAR(adaptive_hash_index),
 
9896
  DRIZZLE_SYSVAR(replication_delay),
 
9897
  DRIZZLE_SYSVAR(status_file),
 
9898
  DRIZZLE_SYSVAR(strict_mode),
 
9899
  DRIZZLE_SYSVAR(support_xa),
 
9900
  DRIZZLE_SYSVAR(sync_spin_loops),
 
9901
  DRIZZLE_SYSVAR(spin_wait_delay),
 
9902
  DRIZZLE_SYSVAR(table_locks),
 
9903
  DRIZZLE_SYSVAR(thread_concurrency),
 
9904
  DRIZZLE_SYSVAR(thread_sleep_delay),
 
9905
  DRIZZLE_SYSVAR(version),
 
9906
  DRIZZLE_SYSVAR(use_sys_malloc),
 
9907
  DRIZZLE_SYSVAR(use_native_aio),
 
9908
  DRIZZLE_SYSVAR(change_buffering),
 
9909
  DRIZZLE_SYSVAR(read_ahead_threshold),
 
9910
  DRIZZLE_SYSVAR(io_capacity),
 
9911
  DRIZZLE_SYSVAR(purge_threads),
 
9912
  DRIZZLE_SYSVAR(purge_batch_size),
 
9913
  NULL
 
9914
};
9366
9915
 
9367
9916
DRIZZLE_DECLARE_PLUGIN
9368
9917
{
9373
9922
  "Supports transactions, row-level locking, and foreign keys",
9374
9923
  PLUGIN_LICENSE_GPL,
9375
9924
  innobase_init, /* Plugin Init */
9376
 
  NULL, /* system variables */
 
9925
  innobase_system_variables, /* system variables */
9377
9926
  init_options /* reserved */
9378
9927
}
9379
9928
DRIZZLE_DECLARE_PLUGIN_END;
9401
9950
  return res;
9402
9951
}
9403
9952
 
 
9953
/** @brief Initialize the default value of innodb_commit_concurrency.
 
9954
 
 
9955
Once InnoDB is running, the innodb_commit_concurrency must not change
 
9956
from zero to nonzero. (Bug #42101)
 
9957
 
 
9958
The initial default value is 0, and without this extra initialization,
 
9959
SET GLOBAL innodb_commit_concurrency=DEFAULT would set the parameter
 
9960
to 0, even if it was initially set to nonzero at the command line
 
9961
or configuration file. */
 
9962
static
 
9963
void
 
9964
innobase_commit_concurrency_init_default(void)
 
9965
/*==========================================*/
 
9966
{
 
9967
  DRIZZLE_SYSVAR_NAME(commit_concurrency).def_val
 
9968
    = innobase_commit_concurrency;
 
9969
}
 
9970
 
9404
9971
/***********************************************************************
9405
9972
This function checks each index name for a table against reserved
9406
9973
system default primary index name 'GEN_CLUST_INDEX'. If a name matches,