Merge lp:~vjsamuel/drizzle/rplugin-innobase into lp:~drizzle-trunk/drizzle/development

[Vijay Samuel]

[Stewart Smith (stewart)]

The UNIV_LOG_ARCHIVE #ifdef should not be removed. It's not something we want end users seeing. It is *always* a bad idea to set this (unless you're an InnoDB hacker).

I don't see innobase_data_home_dir being freed (or a bunch of the other ones actually)

innobase_additional_mem_pool_size/= 1024;
166 + innobase_additional_mem_pool_size*= 1024;

you meant innobase_additional_mem_pool_size -= innobase_additional_mem_pool_size % 1024 ?
as the above just looks a bit odd.

         "Enable InnoDB checksums validation (enabled by default). Disable with --skip-innodb-checksums.

needs to be fixed

+ "Speeds up the shutdown process of the InnoDB storage engine. Possible values are(faster) or 2 (fastest - crash-like).");

missing the "1"

review: Needs Fixing

=== modified file 'plugin/innobase/handler/ha_innodb.cc'
--- plugin/innobase/handler/ha_innodb.cc	2010-08-08 01:18:02 +0000
+++ plugin/innobase/handler/ha_innodb.cc	2010-08-10 11:52:47 +0000
@@ -88,6 +88,12 @@
 #include <drizzled/transaction_services.h>
 
 #include <boost/algorithm/string.hpp>
+#include <boost/program_options.hpp>
+#include <drizzled/module/option_map.h>
+#include <iostream>
+
+namespace po= boost::program_options;
+using namespace std;
 
 /** @file ha_innodb.cc */
 
@@ -213,10 +219,8 @@
 values */
 
 static ulong  innobase_fast_shutdown      = 1;
-#ifdef UNIV_LOG_ARCHIVE
 static my_bool  innobase_log_archive      = FALSE;
 static char*  innobase_log_arch_dir     = NULL;
-#endif /* UNIV_LOG_ARCHIVE */
 static my_bool  innobase_use_doublewrite    = TRUE;
 static my_bool  innobase_use_checksums      = TRUE;
 static my_bool  innobase_rollback_on_timeout    = FALSE;
@@ -1830,6 +1834,348 @@
   char    *default_path;
   uint    format_id;
   InnobaseEngine *actuall_engine_ptr;
+  const module::option_map &vm= context.getOptions();
+
+  if (vm.count("io-capacity"))
+  {
+    if (srv_io_capacity < 100 || srv_io_capacity > (unsigned long)~0L)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for io-capacity\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("data-home-dir"))
+  {
+    innobase_data_home_dir= strdup(vm["data-home-dir"].as<string>().c_str());
+  }
+
+  else
+  {
+    innobase_data_home_dir= NULL;
+  }
+
+  if (vm.count("fast-shutdown"))
+  {
+    if (innobase_fast_shutdown > 2)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for fast-shutdown\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("file-format"))
+  {
+    innobase_file_format_name= strdup(vm["file-format"].as<string>().c_str());
+  }
+
+  else
+  {
+    innobase_file_format_name= strdup("Antelope");
+  }
+
+  if (vm.count("file-format-check"))
+  {
+    innobase_file_format_check= strdup(vm["file-format-check"].as<string>().c_str());
+  }
+
+  else
+  {
+    innobase_file_format_check= strdup("on");
+  }
+
+  if (vm.count("flush-log-at-trx-commit"))
+  {
+    if (srv_flush_log_at_trx_commit > 2)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for flush-log-at-trx-commit\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("flush-method"))
+  {
+    innobase_unix_file_flush_method= strdup(vm["flush-method"].as<string>().c_str());
+  }
+
+  else
+  {
+    innobase_unix_file_flush_method= NULL;
+  }
+
+  if (vm.count("log-arch-dir"))
+  {
+    innobase_log_arch_dir= strdup(vm["log-arch-dir"].as<string>().c_str());
+  }
+
+  else
+  {
+    innobase_log_arch_dir= NULL;
+  }
+
+  if (vm.count("max-dirty-pages-pct"))
+  {
+    if (srv_max_buf_pool_modified_pct > 99)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for max-dirty-pages-pct\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("max-purge-lag"))
+  {
+    if (srv_max_purge_lag > (unsigned long)~0L)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for max-purge-lag\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("log-group-home-dir"))
+  {
+    innobase_log_group_home_dir= strdup(vm["log-group-home-dir"].as<string>().c_str());
+  }
+
+  else
+  {
+    innobase_log_group_home_dir= NULL;
+  }
+
+  if (vm.count("stats-sample-pages"))
+  {
+    if (srv_stats_sample_pages < 8 || srv_stats_sample_pages > (unsigned long long)~0ULL)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for stats-sample-pages\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("replication-delay"))
+  {
+    if (srv_replication_delay > (unsigned long)~0UL)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for replication-delay\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("additional-mem-pool-size"))
+  {
+    if (innobase_additional_mem_pool_size < 512*1024L || innobase_additional_mem_pool_size > LONG_MAX)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for additional-mem-pool-size\n"));
+      exit(-1);
+    }
+
+    innobase_additional_mem_pool_size/= 1024;
+    innobase_additional_mem_pool_size*= 1024;
+  }
+
+  if (vm.count("commit-concurrency"))
+  {
+    if (srv_replication_delay > 1000)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for commit-concurrency\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("concurrency-tickets"))
+  {
+    if (srv_n_free_tickets_to_enter < 1L || srv_n_free_tickets_to_enter > (unsigned long)~0L)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for concurrency-tickets\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("file-io-threads"))
+  {
+    if (innobase_file_io_threads < 4 || innobase_file_io_threads > 64)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for file-io-threads\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("read-io-threads"))
+  {
+    if (innobase_read_io_threads < 1 || innobase_read_io_threads > 64)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for read-io-threads\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("write-io-threads"))
+  {
+    if (innobase_write_io_threads < 1 || innobase_write_io_threads > 64)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for write-io-threads\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("force-recovery"))
+  {
+    if (innobase_force_recovery > 6)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for force-recovery\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("log-buffer-size"))
+  {
+    if (innobase_log_buffer_size < 256*1024L || innobase_log_buffer_size > LONG_MAX)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for log-file-size\n"));
+      exit(-1);
+    }
+
+    innobase_log_buffer_size/= 1024;
+    innobase_log_buffer_size*= 1024;
+  }
+
+  if (vm.count("log-file-size"))
+  {
+    if (innobase_log_file_size < 1*1024*1024L || innobase_log_file_size > INT64_MAX)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for log-file-size\n"));
+      exit(-1);
+    }
+
+    innobase_log_file_size/= 1024*1024L;
+    innobase_log_file_size*= 1024*1024L;
+  }
+
+  if (vm.count("log-files-in-group"))
+  {
+    if (innobase_log_files_in_group < 2 || innobase_log_files_in_group > 100)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for log-files-in-group\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("mirrored-log-groups"))
+  {
+    if (innobase_mirrored_log_groups < 1 || innobase_mirrored_log_groups > 10)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for mirrored-log-groups\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("open-files"))
+  {
+    if (innobase_open_files < 10L || innobase_open_files > LONG_MAX)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for open-files\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("sync-spin-loops"))
+  {
+    if (srv_n_spin_wait_rounds > (unsigned long)~0L)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for sync-spin-loops\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("spin-wait-delay"))
+  {
+    if (srv_spin_wait_delay > (unsigned long)~0L)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for spin-wait-delay\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("thread-concurrency"))
+  {
+    if (srv_thread_concurrency > 1000)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for thread-concurrency\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("thread-sleep-delay"))
+  {
+    if (srv_thread_sleep_delay > (unsigned long)~0L)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for thread-sleep-delay\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("data-file-path"))
+  {
+    innobase_data_file_path= strdup(vm["data-file-path"].as<string>().c_str());
+  }
+
+  else
+  {
+    innobase_data_file_path= NULL;
+  }
+
+  if (vm.count("version"))
+  {
+    innodb_version_str= strdup(vm["version"].as<string>().c_str());
+  }
+
+  else
+  {
+    innodb_version_str= strdup(INNODB_VERSION_STR);
+  }
+
+  if (vm.count("change-buffering"))
+  {
+    innobase_change_buffering= strdup(vm["change-buffering"].as<string>().c_str());
+  }
+
+  else
+  {
+    innobase_change_buffering= NULL;
+  }
+
+  if (vm.count("read-ahead-threshold"))
+  {
+    if (srv_read_ahead_threshold > 64)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for read-ahead-threshold\n"));
+      exit(-1);
+    }
+  }
+
+  if (vm.count("support-xa"))
+  {
+    (SessionVAR(NULL,support_xa))= vm["support-xa"].as<bool>();
+  }
+
+  if (vm.count("table-locks"))
+  {
+    (SessionVAR(NULL,table_locks))= vm["table-locks"].as<bool>();
+  }
+
+  if (vm.count("strict-mode"))
+  {
+    (SessionVAR(NULL,strict_mode))= vm["strict-mode"].as<bool>();
+  }
+
+  if (vm.count("lock-wait-timeout"))
+  {
+    if (vm["lock-wait-timeout"].as<unsigned long>() < 1 || vm["lock-wait-timeout"].as<unsigned long>() > 1024*1024*1024)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for lock-wait-timeout\n"));
+      exit(-1);
+    }
+
+    (SessionVAR(NULL,lock_wait_timeout))= vm["lock-wait-timeout"].as<unsigned long>();
+  }
 
   innodb_engine_ptr= actuall_engine_ptr= new InnobaseEngine(innobase_engine_name);
 
@@ -8582,6 +8928,154 @@
   "trigger a readahead.",
   NULL, NULL, 56, 0, 64, 0);
 
+static void init_options(drizzled::module::option_context &context)
+{
+  context("checksums",
+          po::value<bool>(&innobase_use_checksums)->default_value(true)->zero_tokens(),
+          "Enable InnoDB checksums validation (enabled by default). Disable with --skip-innodb-checksums.");
+  context("data-home-dir",
+          po::value<string>(),
+          "The common part for InnoDB table spaces.");
+  context("doublewrite",
+          po::value<bool>(&innobase_use_doublewrite)->default_value(true)->zero_tokens(),
+          "Enable InnoDB doublewrite buffer (enabled by default). Disable with --skip-innodb-doublewrite.");
+  context("io-capacity",
+          po::value<unsigned long>(&srv_io_capacity)->default_value(200),
+          "Number of IOPs the server can do. Tunes the background IO rate");
+  context("fast-shutdown",
+          po::value<unsigned long>(&innobase_fast_shutdown)->default_value(1), 
+          "Speeds up the shutdown process of the InnoDB storage engine. Possible values are(faster) or 2 (fastest - crash-like).");
+  context("file-per-table",
+          po::value<bool>(&srv_file_per_table)->default_value(false)->zero_tokens(),
+          "Stores each InnoDB table to an .ibd file in the database dir.");
+  context("file-format",
+          po::value<string>(),
+          "File format to use for new tables in .ibd files.");
+  context("file-format-check",
+          po::value<string>(),
+          "The highest file format in the tablespace.");
+  context("flush-log-at-trx-commit",
+          po::value<unsigned long>(&srv_flush_log_at_trx_commit)->default_value(1),
+          "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).");
+  context("flush-method",
+          po::value<string>(),
+          "With which method to flush data.");
+  context("log-arch-dir",
+          po::value<string>(),
+          "Where full logs should be archived.");
+  context("log-archive",
+          po::value<bool>(&innobase_log_archive)->default_value(false)->zero_tokens(),
+          "Set to 1 if you want to have logs archived.");
+  context("log-group-home-dir",
+          po::value<string>(),
+          "Path to InnoDB log files.");
+  context("max-dirty-pages-pct",
+          po::value<unsigned long>(&srv_max_buf_pool_modified_pct)->default_value(75),
+          "Percentage of dirty pages allowed in bufferpool.");
+  context("adaptive-flushing",
+          po::value<bool>(&srv_adaptive_flushing)->default_value(true)->zero_tokens(),
+          "Attempt flushing dirty pages to avoid IO bursts at checkpoints.");
+  context("max-purge-lag",
+          po::value<unsigned long>(&srv_max_purge_lag)->default_value(0),
+          "Desired maximum length of the purge queue (0 = no limit)");
+  context("status-file",
+          po::value<bool>(&innobase_create_status_file)->default_value(false)->zero_tokens(),
+          "Enable SHOW INNODB STATUS output in the innodb_status.<pid> file");
+  context("stats-on-metadata",
+          po::value<bool>(&innobase_stats_on_metadata)->default_value(true)->zero_tokens(),
+          "Enable statistics gathering for metadata commands such as SHOW TABLE STATUS (on by default)");
+  context("stats-sample-pages",
+          po::value<uint64_t>(&srv_stats_sample_pages)->default_value(8),
+          "The number of index pages to sample when calculating statistics (default 8)");
+  context("adaptive-hash-index",
+          po::value<bool>(&btr_search_enabled)->default_value(true)->zero_tokens(),
+          "Enable InnoDB adaptive hash index (enabled by default)");
+  context("replication-delay",
+          po::value<unsigned long>(&srv_replication_delay)->default_value(0),
+          "Replication thread delay (ms) on the slave server if innodb_thread_concurrency is reached (0 by default)");
+  context("additional-mem-pool-size",
+          po::value<long>(&innobase_additional_mem_pool_size)->default_value(8*1024*1024L),
+          "Size of a memory pool InnoDB uses to store data dictionary information and other internal data structures.");
+  context("autoextend-increment",
+          po::value<uint32_t>(&srv_auto_extend_increment)->default_value(8L),
+          "Data file autoextend increment in megabytes");
+  context("buffer-pool-size",
+          po::value<int64_t>(&innobase_buffer_pool_size)->default_value(8*1024*1024L),
+          "The size of the memory buffer InnoDB uses to cache data and indexes of its tables.");
+  context("commit-concurrency",
+          po::value<unsigned long>(&innobase_commit_concurrency)->default_value(0),
+          "Helps in performance tuning in heavily concurrent environments.");
+  context("concurrency-tickets",
+          po::value<unsigned long>(&srv_n_free_tickets_to_enter)->default_value(500L),
+          "Number of times a thread is allowed to enter InnoDB within the same SQL query after it has once got the ticket");
+  context("file-io-threads",
+          po::value<long>(&innobase_file_io_threads)->default_value(4),
+          "Number of file I/O threads in InnoDB.");
+  context("read-io-threads",
+          po::value<unsigned long>(&innobase_read_io_threads)->default_value(4),
+          "Number of background read I/O threads in InnoDB.");
+  context("write-io-threads",
+          po::value<unsigned long>(&innobase_write_io_threads)->default_value(4),
+          "Number of background write I/O threads in InnoDB.");
+  context("force-recovery",
+          po::value<long>(&innobase_force_recovery)->default_value(0),
+          "Helps to save your data in case the disk image of the database becomes corrupt.");
+  context("log-buffer-size",
+          po::value<long>(&innobase_log_buffer_size)->default_value(8*1024*1024L),
+          "The size of the buffer which InnoDB uses to write log to the log files on disk.");
+  context("log-file-size",
+          po::value<int64_t>(&innobase_log_file_size)->default_value(20*1024*1024L),
+          "The size of the buffer which InnoDB uses to write log to the log files on disk.");
+  context("log-files-in-group",
+          po::value<long>(&innobase_log_files_in_group)->default_value(2),
+          "Number of log files in the log group. InnoDB writes to the files in a circular fashion. Value 3 is recommended here.");
+  context("mirrored-log-groups",
+          po::value<long>(&innobase_mirrored_log_groups)->default_value(1),
+          "Number of identical copies of log groups we keep for the database. Currently this should be set to 1.");
+  context("open-files",
+          po::value<long>(&innobase_open_files)->default_value(300L),
+          "How many files at the maximum InnoDB keeps open at the same time.");
+  context("sync-spin-loops",
+          po::value<unsigned long>(&srv_n_spin_wait_rounds)->default_value(30L),
+          "Count of spin-loop rounds in InnoDB mutexes (30 by default)");
+  context("spin-wait-delay",
+          po::value<unsigned long>(&srv_spin_wait_delay)->default_value(6L),
+          "Maximum delay between polling for a spin lock (6 by default)");
+  context("thread-concurrency",
+          po::value<unsigned long>(&srv_thread_concurrency)->default_value(0),
+          "Helps in performance tuning in heavily concurrent environments. Sets the maximum number of threads allowed inside InnoDB. Value 0 will disable the thread throttling.");
+  context("thread-sleep-delay",
+          po::value<unsigned long>(&srv_thread_sleep_delay)->default_value(10000L),
+          "Time of innodb thread sleeping before joining InnoDB queue (usec). Value 0 disable a sleep");
+  context("data-file-path",
+          po::value<string>(),
+          "Path to individual files and their sizes.");
+  context("version",
+          po::value<string>(),
+          "InnoDB version");
+  context("use-sys-malloc",
+          po::value<bool>(&srv_use_sys_malloc)->default_value(true)->zero_tokens(),
+          "Use OS memory allocator instead of InnoDB's internal memory allocator");
+  context("change-buffering",
+          po::value<string>(),
+          "Buffer changes to reduce random access: OFF, ON, inserting, deleting, changing, or purging.");
+  context("read-ahead-threshold",
+          po::value<unsigned long>(&srv_read_ahead_threshold)->default_value(56),
+          "Number of pages that must be accessed sequentially for InnoDB to trigger a readahead.");
+  context("support-xa",
+          po::value<bool>()->default_value(true)->zero_tokens(),
+          "Enable InnoDB support for the XA two-phase commit");
+  context("table-locks",
+          po::value<bool>()->default_value(true)->zero_tokens(),
+          "Enable InnoDB locking in LOCK TABLES");
+  context("strict-mode",
+          po::value<bool>()->default_value(false)->zero_tokens(),
+          "Use strict mode when evaluating create options.");
+  context("lock-wait-timeout",
+          po::value<unsigned long>()->default_value(50),
+          "Timeout in seconds an InnoDB transaction may wait for a lock before being rolled back. Values above 100000000 disable the timeout.");
+}
+
 static drizzle_sys_var* innobase_system_variables[]= {
   DRIZZLE_SYSVAR(additional_mem_pool_size),
   DRIZZLE_SYSVAR(autoextend_increment),
@@ -8646,7 +9140,7 @@
   PLUGIN_LICENSE_GPL,
   innobase_init, /* Plugin Init */
   innobase_system_variables, /* system variables */
-  NULL /* reserved */
+  init_options /* reserved */
 }
 DRIZZLE_DECLARE_PLUGIN_END;
 
 
=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2010-07-27 00:41:57 +0000
+++ po/POTFILES.in	2010-08-10 11:52:47 +0000
@@ -66,6 +66,7 @@
 plugin/filtered_replicator/filtered_replicator.cc
 plugin/hello_events/hello_events.cc
 plugin/innobase/handler/data_dictionary.cc
+plugin/innobase/handler/ha_innodb.cc
 plugin/innobase/ut/ut0auxconf_pause.c
 plugin/logging_gearman/logging_gearman.cc
 plugin/logging_query/logging_query.cc
 
=== modified file 'tests/t/unsafe_binlog_innodb-master.opt'
--- tests/t/unsafe_binlog_innodb-master.opt	2010-03-15 16:12:10 +0000
+++ tests/t/unsafe_binlog_innodb-master.opt	2010-08-10 11:52:47 +0000
@@ -1,1 +1,1 @@
---innodb_lock_wait_timeout=1
+--innodb.lock-wait-timeout=1
 
=== modified file 'tests/test-run.pl'
--- tests/test-run.pl	2010-08-02 14:35:48 +0000
+++ tests/test-run.pl	2010-08-10 11:52:47 +0000
@@ -2592,9 +2592,7 @@
 	       $idx > 0 ? $idx + 101 : 1);
 
     mtr_add_arg($args,
-      "%s--loose-innodb_data_file_path=ibdata1:20M:autoextend", $prefix);
-
-    mtr_add_arg($args, "%s--loose-innodb-lock-wait-timeout=5", $prefix);
+      "%s--innodb.data-file-path=ibdata1:20M:autoextend", $prefix);
 
   }
   else