Merge lp:~mordred/drizzle/plugin-use-sys-var into lp:drizzle/7.0

[Monty Taylor]

Migrated several plugins to use sys_var directly.

[lp:~mordred/drizzle/plugin-use-sys-var]

1920. By Patrick Crews on 2010-11-09

Rollup merge of Andrew's patches

1921. By Patrick Crews on 2010-11-10

Updated translations

1922. By Brian Aker on 2010-11-10

Rollup patch around using shared_ptr with Table messages.

1923. By Brian Aker on 2010-11-11

Merge in changes from Monty for sys var.

=== modified file 'Makefile.am'
--- Makefile.am	2010-10-22 17:58:46 +0000
+++ Makefile.am	2010-11-11 01:16:06 +0000
@@ -139,8 +139,6 @@
 	find . -name '*.gcno' | xargs rm -f 
 	-rm -rf docs/api docs/dev docs/_build docs/doctrees
 
-ChangeLog:
-	bzr log --gnu > ChangeLog
 include config/lint-source.am
 include config/lcov.am
 

=== modified file 'drizzled/set_var.cc'
--- drizzled/set_var.cc	2010-10-25 20:36:07 +0000
+++ drizzled/set_var.cc	2010-11-11 01:16:06 +0000
@@ -18,6 +18,10 @@
  */
 
 #include "config.h"
+
+#include <boost/lexical_cast.hpp>
+#include <string>
+
 #include "drizzled/session.h"
 #include "drizzled/item/string.h"
 #include "drizzled/sql_list.h"
@@ -143,12 +147,24 @@
 */
 int set_var::update(Session *session)
 {
-  if (! value)
-    var->set_default(session, type);
-  else if (var->update(session, this))
-    return -1;				// should never happen
-  if (var->getAfterUpdateTrigger())
-    (*var->getAfterUpdateTrigger())(session, type);
+  try
+  {
+    if (! value)
+      var->set_default(session, type);
+    else if (var->update(session, this))
+      return -1;				// should never happen
+    if (var->getAfterUpdateTrigger())
+      (*var->getAfterUpdateTrigger())(session, type);
+  }
+  catch (boost::exception &)
+  {
+    /* TODO: Fix this to be typesafe once we have properly typed set_var */
+    string new_val= boost::lexical_cast<string>(save_result.uint32_t_value);
+    push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
+                        ER_TRUNCATED_WRONG_VALUE,
+                        ER(ER_TRUNCATED_WRONG_VALUE), var->getName().c_str(),
+                        new_val.c_str());
+  }
   return 0;
 }
 

=== modified file 'drizzled/sys_var.cc'
--- drizzled/sys_var.cc	2010-10-30 23:28:13 +0000
+++ drizzled/sys_var.cc	2010-11-11 01:16:06 +0000
@@ -541,11 +541,18 @@
 
 void sys_var_uint64_t_ptr::set_default(Session *, sql_var_t)
 {
-  bool not_used;
-  LOCK_global_system_variables.lock();
-  *value= getopt_ull_limit_value((uint64_t) option_limits->def_value,
-                                 option_limits, &not_used);
-  LOCK_global_system_variables.unlock();
+  if (have_default_value)
+  {
+    *value= default_value;
+  }
+  else
+  {
+    bool not_used;
+    LOCK_global_system_variables.lock();
+    *value= getopt_ull_limit_value((uint64_t) option_limits->def_value,
+                                   option_limits, &not_used);
+    LOCK_global_system_variables.unlock();
+  }
 }
 
 

=== modified file 'drizzled/sys_var.h'
--- drizzled/sys_var.h	2010-10-30 23:28:13 +0000
+++ drizzled/sys_var.h	2010-11-11 01:16:06 +0000
@@ -94,10 +94,11 @@
   struct option *option_limits; /**< Updated by by sys_var_init() */
   bool m_allow_empty_value; /**< Does variable allow an empty value? */
 public:
-  sys_var(const std::string name_arg, sys_after_update_func func= NULL)
+  sys_var(const std::string &name_arg, sys_after_update_func func= NULL)
     :
     name(name_arg),
     after_update(func),
+    option_limits(NULL),
     m_allow_empty_value(true)
   {}
   virtual ~sys_var() {}
@@ -228,16 +229,50 @@
 class sys_var_uint64_t_ptr :public sys_var
 {
   uint64_t *value;
+  const uint64_t default_value;
+  bool have_default_value;
 public:
-  sys_var_uint64_t_ptr(const char *name_arg, uint64_t *value_ptr_arg)
-    :sys_var(name_arg),value(value_ptr_arg)
-  {  }
-  sys_var_uint64_t_ptr(const char *name_arg, uint64_t *value_ptr_arg,
-		       sys_after_update_func func)
-    :sys_var(name_arg,func), value(value_ptr_arg)
-  {  }
+  sys_var_uint64_t_ptr(const char *name_arg, uint64_t *value_ptr_arg) :
+    sys_var(name_arg),
+    value(value_ptr_arg),
+    default_value(0),
+    have_default_value(false)
+  {  }
+
+  sys_var_uint64_t_ptr(const char *name_arg,
+                       uint64_t *value_ptr_arg,
+                       const uint64_t default_value_in) :
+    sys_var(name_arg),
+    value(value_ptr_arg),
+    default_value(default_value_in),
+    have_default_value(true)
+  {  }
+
+  sys_var_uint64_t_ptr(const char *name_arg,
+                       uint64_t *value_ptr_arg,
+                       sys_after_update_func func) :
+    sys_var(name_arg,func),
+    value(value_ptr_arg),
+    default_value(0),
+    have_default_value(false)
+  {  }
+
+  sys_var_uint64_t_ptr(const char *name_arg,
+                       uint64_t *value_ptr_arg,
+                       sys_after_update_func func,
+                       const uint64_t default_value_in) :
+    sys_var(name_arg,func),
+    value(value_ptr_arg),
+    default_value(default_value_in),
+    have_default_value(true)
+  {  }
+
   bool update(Session *session, set_var *var);
   void set_default(Session *session, sql_var_t type);
+  virtual bool check_default(sql_var_t)
+  {
+    return (not have_default_value) && option_limits == 0;
+  }
   SHOW_TYPE show_type() { return SHOW_LONGLONG; }
   unsigned char *value_ptr(Session *, sql_var_t,
                            const LEX_STRING *)
@@ -266,9 +301,10 @@
 {
 public:
   bool *value;
-  sys_var_bool_ptr(const char *name_arg, bool *value_arg)
-    :sys_var(name_arg),value(value_arg)
-  {  }
+  sys_var_bool_ptr(const std::string &name_arg, bool *value_arg,
+                   sys_after_update_func func= NULL) :
+    sys_var(name_arg, func), value(value_arg)
+  { }
   bool check(Session *session, set_var *var)
   {
     return check_enum(session, var, &bool_typelib);

=== modified file 'm4/pandora_vc_build.m4'
--- m4/pandora_vc_build.m4	2010-04-22 02:46:23 +0000
+++ m4/pandora_vc_build.m4	2010-11-11 01:16:06 +0000
@@ -53,6 +53,7 @@
         PANDORA_VC_REVNO="${PANDORA_BZR_REVNO}"
         PANDORA_VC_REVID=`bzr log -r-1 --show-ids | grep revision-id | cut -f2 -d' ' | head -1`
         PANDORA_VC_BRANCH=`bzr nick`
+	bzr log --gnu > ChangeLog
       fi
     fi
 

=== modified file 'plugin/blitzdb/ha_blitz.cc'
--- plugin/blitzdb/ha_blitz.cc	2010-11-07 04:38:53 +0000
+++ plugin/blitzdb/ha_blitz.cc	2010-11-11 01:16:06 +0000
@@ -22,6 +22,7 @@
 
 using namespace std;
 using namespace drizzled;
+namespace po= boost::program_options;
 
 static pthread_mutex_t blitz_utility_mutex;
 
@@ -1478,6 +1479,8 @@
 
   pthread_mutex_init(&blitz_utility_mutex, NULL);
   context.add(blitz_engine);
+  context.registerVariable(new sys_var_uint64_t_ptr("estimated-rows",
+                                                    &blitz_estimated_rows));
   return 0;
 }
 
@@ -1497,22 +1500,11 @@
   return true;
 }
 
-static DRIZZLE_SYSVAR_ULONGLONG (
-  estimated_rows,
-  blitz_estimated_rows,
-  PLUGIN_VAR_RQCMDARG,
-  "Estimated number of rows that a BlitzDB table will store.",
-  NULL,
-  NULL,
-  0,
-  0,
-  UINT64_MAX,
-  0
-);
-
-static drizzle_sys_var *blitz_system_variables[] = {
-  DRIZZLE_SYSVAR(estimated_rows),
-  NULL
-};
-
-DRIZZLE_PLUGIN(blitz_init, blitz_system_variables, NULL);
+static void blitz_init_options(drizzled::module::option_context &context)
+{
+  context("estimated-rows",
+          po::value<uint64_t>(&blitz_estimated_rows)->default_value(0),
+          N_("Estimated number of rows that a BlitzDB table will store."));
+}
+
+DRIZZLE_PLUGIN(blitz_init, NULL, blitz_init_options);

=== modified file 'plugin/haildb/haildb_engine.cc'
--- plugin/haildb/haildb_engine.cc	2010-11-02 17:19:41 +0000
+++ plugin/haildb/haildb_engine.cc	2010-11-11 01:16:06 +0000
@@ -2818,11 +2818,8 @@
   return err;
 }
 
-static bool  innobase_use_checksums= true;
-static char*  innobase_data_home_dir      = NULL;
 static char*  innobase_log_group_home_dir   = NULL;
 static bool innobase_use_doublewrite= true;
-static unsigned long srv_io_capacity= 200;
 static unsigned long innobase_fast_shutdown= 1;
 static bool srv_file_per_table= false;
 static bool innobase_adaptive_hash_index;
@@ -2848,6 +2845,10 @@
 static buffer_pool_constraint innobase_buffer_pool_size;
 typedef constrained_check<size_t, SIZE_MAX, 512, 1024> additional_mem_pool_constraint;
 static additional_mem_pool_constraint innobase_additional_mem_pool_size;
+static bool  innobase_use_checksums= true;
+typedef constrained_check<unsigned int, UINT_MAX, 100> io_capacity_constraint;
+static io_capacity_constraint srv_io_capacity;
+
 static long innobase_open_files;
 static long innobase_force_recovery;
 static long innobase_log_buffer_size;
@@ -2877,15 +2878,6 @@
   innobase_print_verbose_log= (vm.count("disable-print-verbose-log")) ? false : true;
   srv_use_sys_malloc= (vm.count("use-internal-malloc")) ? false : true;
 
-  if (vm.count("io-capacity"))
-  {
-    if (srv_io_capacity > (unsigned long)~0L || srv_io_capacity < 100)
-    {
-      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value of io-capacity"));
-      return 1;
-    }
-  }
-
   if (vm.count("fast-shutdown"))
   {
     if (innobase_fast_shutdown > 2)
@@ -3016,11 +3008,6 @@
     }
   }
 
-  if (vm.count("data-home-dir"))
-  {
-    innobase_data_home_dir= const_cast<char *>(vm["data-home-dir"].as<string>().c_str());
-  }
-
   if (vm.count("file-format"))
   {
     innobase_file_format_name= const_cast<char *>(vm["file-format"].as<string>().c_str());
@@ -3047,9 +3034,10 @@
   if (err != DB_SUCCESS)
     goto haildb_error;
 
-  if (innobase_data_home_dir)
+
+  if (vm.count("data-home-dir"))
   {
-    err= ib_cfg_set_text("data_home_dir", innobase_data_home_dir);
+    err= ib_cfg_set_text("data_home_dir", vm["data-home-dir"].as<string>().c_str());
     if (err != DB_SUCCESS)
       goto haildb_error;
   }
@@ -3116,7 +3104,7 @@
   if (err != DB_SUCCESS)
     goto haildb_error;
 
-  err= ib_cfg_set_int("io_capacity", srv_io_capacity);
+  err= ib_cfg_set_int("io_capacity", static_cast<unsigned int>(srv_io_capacity));
   if (err != DB_SUCCESS)
     goto haildb_error;
 
@@ -3214,6 +3202,13 @@
   context.registerVariable(new sys_var_constrained_value_readonly<size_t>("additional_mem_pool_size",innobase_additional_mem_pool_size));
   context.registerVariable(new sys_var_constrained_value_readonly<unsigned int>("autoextend_increment", srv_auto_extend_increment));
   context.registerVariable(new sys_var_constrained_value_readonly<size_t>("buffer_pool_size", innobase_buffer_pool_size));
+  context.registerVariable(new sys_var_bool_ptr_readonly("checksums",
+                                                         &innobase_use_checksums));
+  context.registerVariable(new sys_var_bool_ptr_readonly("doublewrite",
+                                                         &innobase_use_doublewrite));
+  context.registerVariable(new sys_var_const_string_val("data_home_dir",
+                                                vm.count("data-home-dir") ?  vm["data-home-dir"].as<string>() : ""));
+  context.registerVariable(new sys_var_constrained_value_readonly<unsigned int>("io_capacity", srv_io_capacity));
 
   haildb_datadict_dump_func_initialize(context);
   config_table_function_initialize(context);
@@ -3344,28 +3339,6 @@
     innobase_create_status_file= status_file_enabled;
 }
 
-static DRIZZLE_SYSVAR_BOOL(checksums, innobase_use_checksums,
-  PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
-  "Enable HailDB checksums validation (enabled by default). "
-  "Disable with --skip-haildb-checksums.",
-  NULL, NULL, true);
-
-static DRIZZLE_SYSVAR_STR(data_home_dir, innobase_data_home_dir,
-  PLUGIN_VAR_READONLY,
-  "The common part for HailDB table spaces.",
-  NULL, NULL, NULL);
-
-static DRIZZLE_SYSVAR_BOOL(doublewrite, innobase_use_doublewrite,
-  PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
-  "Enable HailDB doublewrite buffer (enabled by default). "
-  "Disable with --skip-haildb-doublewrite.",
-  NULL, NULL, true);
-
-static DRIZZLE_SYSVAR_ULONG(io_capacity, srv_io_capacity,
-  PLUGIN_VAR_RQCMDARG,
-  "Number of IOPs the server can do. Tunes the background IO rate",
-  NULL, NULL, 200, 100, ~0L, 0);
-
 static DRIZZLE_SYSVAR_ULONG(fast_shutdown, innobase_fast_shutdown,
   PLUGIN_VAR_OPCMDARG,
   "Speeds up the shutdown process of the HailDB storage engine. Possible "
@@ -3518,7 +3491,7 @@
   context("disable-doublewrite",
           N_("Disable HailDB doublewrite buffer (enabled by default)."));
   context("io-capacity",
-          po::value<unsigned long>(&srv_io_capacity)->default_value(200),
+          po::value<io_capacity_constraint>(&srv_io_capacity)->default_value(200),
           N_("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),
@@ -3596,10 +3569,6 @@
 }
 
 static drizzle_sys_var* innobase_system_variables[]= {
-  DRIZZLE_SYSVAR(checksums),
-  DRIZZLE_SYSVAR(data_home_dir),
-  DRIZZLE_SYSVAR(doublewrite),
-  DRIZZLE_SYSVAR(io_capacity),
   DRIZZLE_SYSVAR(fast_shutdown),
   DRIZZLE_SYSVAR(file_per_table),
   DRIZZLE_SYSVAR(file_format),

=== modified file 'plugin/multi_thread/multi_thread.cc'
--- plugin/multi_thread/multi_thread.cc	2010-10-30 20:52:53 +0000
+++ plugin/multi_thread/multi_thread.cc	2010-11-11 01:16:06 +0000
@@ -28,10 +28,8 @@
 using namespace drizzled;
 
 /* Configuration variables. */
-static uint32_t max_threads;
-
-/* Global's (TBR) */
-static MultiThreadScheduler *scheduler= NULL;
+typedef constrained_check<uint32_t, 4096, 1> max_threads_constraint;
+static max_threads_constraint max_threads;
 
 namespace drizzled
 {
@@ -130,39 +128,18 @@
 static int init(drizzled::module::Context &context)
 {
   
-  const module::option_map &vm= context.getOptions();
-  if (vm.count("max-threads"))
-  {
-    if (max_threads > 4096 || max_threads < 1)
-    {
-      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for max-threads\n"));
-      return 1;
-    }
-  }
-
-  scheduler= new MultiThreadScheduler("multi_thread");
-  context.add(scheduler);
+  context.add(new MultiThreadScheduler("multi_thread"));
 
   return 0;
 }
 
-static DRIZZLE_SYSVAR_UINT(max_threads, max_threads,
-                           PLUGIN_VAR_RQCMDARG,
-                           N_("Maximum number of user threads available."),
-                           NULL, NULL, 2048, 1, 4096, 0);
-
 static void init_options(drizzled::module::option_context &context)
 {
   context("max-threads",
-          po::value<uint32_t>(&max_threads)->default_value(2048),
+          po::value<max_threads_constraint>(&max_threads)->default_value(2048),
           N_("Maximum number of user threads available."));
 }
 
-static drizzle_sys_var* sys_variables[]= {
-  DRIZZLE_SYSVAR(max_threads),
-  NULL
-};
-
 DRIZZLE_DECLARE_PLUGIN
 {
   DRIZZLE_VERSION_ID,
@@ -172,7 +149,7 @@
   "One Thread Per Session Scheduler",
   PLUGIN_LICENSE_GPL,
   init, /* Plugin Init */
-  sys_variables,   /* system variables */
+  NULL,   /* system variables */
   init_options    /* config options */
 }
 DRIZZLE_DECLARE_PLUGIN_END;

=== modified file 'plugin/myisam/ha_myisam.cc'
--- plugin/myisam/ha_myisam.cc	2010-11-08 20:00:45 +0000
+++ plugin/myisam/ha_myisam.cc	2010-11-11 01:16:06 +0000
@@ -58,7 +58,8 @@
 static uint32_t myisam_key_cache_division_limit;
 static uint32_t myisam_key_cache_age_threshold;
 static uint64_t max_sort_file_size;
-static uint64_t sort_buffer_size;
+typedef constrained_check<size_t, SIZE_MAX, 1024, 1024> sort_buffer_constraint;
+static sort_buffer_constraint sort_buffer_size;
 
 void st_mi_isam_share::setKeyCache()
 {
@@ -700,7 +701,7 @@
   param.using_global_keycache = 1;
   param.session= session;
   param.out_flag= 0;
-  param.sort_buffer_length= (size_t)sort_buffer_size;
+  param.sort_buffer_length= static_cast<size_t>(sort_buffer_size);
   strcpy(fixed_name,file->filename);
 
   // Don't lock tables if we have used LOCK Table
@@ -910,7 +911,7 @@
     param.testflag= (T_SILENT | T_REP_BY_SORT | T_QUICK |
                      T_CREATE_MISSING_KEYS);
     param.myf_rw&= ~MY_WAIT_IF_FULL;
-    param.sort_buffer_length=  (size_t)sort_buffer_size;
+    param.sort_buffer_length=  static_cast<size_t>(sort_buffer_size);
     param.stats_method= MI_STATS_METHOD_NULLS_NOT_EQUAL;
     if ((error= (repair(session,param,0) != HA_ADMIN_OK)) && param.retry_repair)
     {
@@ -1483,63 +1484,30 @@
   return (uint)file->state->checksum;
 }
 
-static MyisamEngine *engine= NULL;
-
 static int myisam_init(module::Context &context)
 { 
-  const module::option_map &vm= context.getOptions();
-
-  if (vm.count("max-sort-file-size"))
-  {
-    if (max_sort_file_size > UINT64_MAX)
-    {
-      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for max-sort-file-size\n"));
-      exit(-1);
-    }
-  }
-
-  if (vm.count("sort-buffer-size"))
-  {
-    if (sort_buffer_size < 1024 || sort_buffer_size > SIZE_MAX)
-    {
-      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for sort-buffer-size\n"));
-      exit(-1);
-    }
-  }
-
-  engine= new MyisamEngine(engine_name);
-  context.add(engine);
+  context.add(new MyisamEngine(engine_name));
+  context.registerVariable(new sys_var_constrained_value<size_t>("sort-buffer-size",
+                                                                 sort_buffer_size,
+                                                                 8196*1024));
+  context.registerVariable(new sys_var_uint64_t_ptr("max_sort_file_size",
+                                                    &max_sort_file_size,
+                                                    context.getOptions()["max-sort-file-size"].as<uint64_t>()));
 
   return 0;
 }
 
 
-static DRIZZLE_SYSVAR_ULONGLONG(max_sort_file_size, max_sort_file_size,
-                                PLUGIN_VAR_RQCMDARG,
-                                N_("Don't use the fast sort index method to created index if the temporary file would get bigger than this."),
-                                NULL, NULL, INT32_MAX, 0, UINT64_MAX, 0);
-
-static DRIZZLE_SYSVAR_ULONGLONG(sort_buffer_size, sort_buffer_size,
-                                PLUGIN_VAR_RQCMDARG,
-                                N_("The buffer that is allocated when sorting the index when doing a REPAIR or when creating indexes with CREATE INDEX or ALTER TABLE."),
-                                NULL, NULL, 8192*1024, 1024, SIZE_MAX, 0);
-
 static void init_options(drizzled::module::option_context &context)
 {
   context("max-sort-file-size",
           po::value<uint64_t>(&max_sort_file_size)->default_value(INT32_MAX),
           N_("Don't use the fast sort index method to created index if the temporary file would get bigger than this."));
   context("sort-buffer-size",
-          po::value<uint64_t>(&sort_buffer_size)->default_value(8192*1024),
+          po::value<sort_buffer_constraint>(&sort_buffer_size)->default_value(8192*1024),
           N_("The buffer that is allocated when sorting the index when doing a REPAIR or when creating indexes with CREATE INDEX or ALTER TABLE."));
 }
 
-static drizzle_sys_var* sys_variables[]= {
-  DRIZZLE_SYSVAR(max_sort_file_size),
-  DRIZZLE_SYSVAR(sort_buffer_size),
-  NULL
-};
-
 
 DRIZZLE_DECLARE_PLUGIN
 {
@@ -1550,7 +1518,7 @@
   "Default engine as of MySQL 3.23 with great performance",
   PLUGIN_LICENSE_GPL,
   myisam_init, /* Plugin Init */
-  sys_variables,           /* system variables */
+  NULL,           /* system variables */
   init_options                        /* config options                  */
 }
 DRIZZLE_DECLARE_PLUGIN_END;

=== modified file 'plugin/transaction_log/module.cc'
--- plugin/transaction_log/module.cc	2010-10-25 20:36:07 +0000
+++ plugin/transaction_log/module.cc	2010-11-11 01:16:06 +0000
@@ -63,7 +63,7 @@
 static bool sysvar_transaction_log_enabled= false;
 
 /** Transaction Log plugin system variable - The path to the log file used */
-static char* sysvar_transaction_log_file= (char *)DEFAULT_LOG_FILE_PATH;
+static string sysvar_transaction_log_file;
 
 /** 
  * Transaction Log plugin system variable - A debugging variable to assist 
@@ -83,18 +83,20 @@
  * TransactionLog::FLUSH_FREQUENCY_EVERY_WRITE == 1   ... sync on every write
  * TransactionLog::FLUSH_FREQUENCY_EVERY_SECOND == 2  ... sync at most once a second
  */
-static uint32_t sysvar_transaction_log_flush_frequency= 0;
+typedef constrained_check<int, 2, 0> flush_constraint;
+static flush_constraint sysvar_transaction_log_flush_frequency;
 /**
  * Transaction Log plugin system variable - Number of slots to create
  * for managing write buffers
  */
-static uint32_t sysvar_transaction_log_num_write_buffers= 8;
+typedef constrained_check<uint32_t, 8192, 4> write_buffers_constraint;
+static write_buffers_constraint sysvar_transaction_log_num_write_buffers;
 /**
  * Transaction Log plugin system variable - The name of the replicator plugin
  * to pair the transaction log's applier with.  Defaults to "default"
  */
 static const char DEFAULT_USE_REPLICATOR[]= "default";
-static char *sysvar_transaction_log_use_replicator= (char *)DEFAULT_USE_REPLICATOR;
+static string sysvar_transaction_log_use_replicator;
 
 /** DATA_DICTIONARY views */
 static TransactionLogTool *transaction_log_tool;
@@ -119,57 +121,47 @@
   {
     (void) close(log_file);
   }
+}
 
-  /* These get strdup'd below */
-  free(sysvar_transaction_log_file);
-  free(sysvar_transaction_log_use_replicator);
+static void set_truncate_debug(Session *, sql_var_t)
+{
+  if (transaction_log)
+  {
+    if (sysvar_transaction_log_truncate_debug)
+    {
+      transaction_log->truncate();
+      transaction_log_index->clear();
+      sysvar_transaction_log_truncate_debug= false;
+    }
+  }
 }
 
 static int init(drizzled::module::Context &context)
 {
-  const module::option_map &vm= context.getOptions();
-
-  if (vm.count("flush-frequency"))
-  {
-    if (sysvar_transaction_log_flush_frequency > 2)
-    {
-      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for sync-method\n"));
-      exit(-1);
-    }
-  }
-
-  if (vm.count("num-write-buffers"))
-  {
-    if (sysvar_transaction_log_num_write_buffers < 4 || sysvar_transaction_log_num_write_buffers > 8192)
-    {
-      errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for num-write-buffers\n"));
-      exit(-1);
-    }
-  }
+  context.registerVariable(new sys_var_bool_ptr_readonly("enable",
+                                                         &sysvar_transaction_log_enabled));
+  context.registerVariable(new sys_var_bool_ptr("truncate-debug",
+                                                &sysvar_transaction_log_truncate_debug,
+                                                set_truncate_debug));
+
+  context.registerVariable(new sys_var_const_string("file",
+                                                    sysvar_transaction_log_file));
+  context.registerVariable(new sys_var_const_string("use-replicator",
+                                                    sysvar_transaction_log_use_replicator));
+  context.registerVariable(new sys_var_bool_ptr_readonly("enable-checksum",
+                                                         &sysvar_transaction_log_checksum_enabled));
+  context.registerVariable(new sys_var_constrained_value_readonly<int>("flush-frequency", sysvar_transaction_log_flush_frequency));
+
+  context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("num-write-buffers",
+                                                                            sysvar_transaction_log_num_write_buffers));
 
 
   /* Create and initialize the transaction log itself */
   if (sysvar_transaction_log_enabled)
   {
-    if (vm.count("file"))
-    {
-      sysvar_transaction_log_file= strdup(vm["file"].as<string>().c_str());
-    }
-    else
-    {
-      sysvar_transaction_log_file= strdup(DEFAULT_LOG_FILE_PATH);
-    }
   
-    if (vm.count("use-replicator"))
-    {
-      sysvar_transaction_log_use_replicator= strdup(vm["use-replicator"].as<string>().c_str());
-    }
-    else
-    {
-      sysvar_transaction_log_use_replicator= strdup(DEFAULT_USE_REPLICATOR);
-    }
-    transaction_log= new (nothrow) TransactionLog(string(sysvar_transaction_log_file),
-                                                  sysvar_transaction_log_flush_frequency,
+    transaction_log= new (nothrow) TransactionLog(sysvar_transaction_log_file,
+                                                  static_cast<int>(sysvar_transaction_log_flush_frequency),
                                                   sysvar_transaction_log_checksum_enabled);
 
     if (transaction_log == NULL)
@@ -216,7 +208,7 @@
     transaction_log_applier= new (nothrow) TransactionLogApplier("transaction_log_applier",
                                                                  transaction_log, 
                                                                  transaction_log_index, 
-                                                                 sysvar_transaction_log_num_write_buffers);
+                                                                 static_cast<uint32_t>(sysvar_transaction_log_num_write_buffers));
     if (transaction_log_applier == NULL)
     {
       char errmsg[STRERROR_MAX];
@@ -227,8 +219,8 @@
     }
     context.add(transaction_log_applier);
     ReplicationServices &replication_services= ReplicationServices::singleton();
-    string replicator_name(sysvar_transaction_log_use_replicator);
-    replication_services.attachApplier(transaction_log_applier, replicator_name);
+    replication_services.attachApplier(transaction_log_applier,
+                                       sysvar_transaction_log_use_replicator);
 
     /* Setup DATA_DICTIONARY views */
 
@@ -259,89 +251,6 @@
 }
 
 
-static void set_truncate_debug(Session *,
-                               drizzle_sys_var *, 
-                               void *, 
-                               const void *save)
-{
-  /* 
-   * The const void * save comes directly from the check function, 
-   * which should simply return the result from the set statement. 
-   */
-  if (transaction_log)
-  {
-    if (*(bool *)save != false)
-    {
-      transaction_log->truncate();
-      transaction_log_index->clear();
-    }
-  }
-}
-
-static DRIZZLE_SYSVAR_BOOL(enable,
-                           sysvar_transaction_log_enabled,
-                           PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
-                           N_("Enable transaction log"),
-                           NULL, /* check func */
-                           NULL, /* update func */
-                           false /* default */);
-
-static DRIZZLE_SYSVAR_BOOL(truncate_debug,
-                           sysvar_transaction_log_truncate_debug,
-                           PLUGIN_VAR_NOCMDARG,
-                           N_("DEBUGGING - Truncate transaction log"),
-                           NULL, /* check func */
-                           set_truncate_debug, /* update func */
-                           false /* default */);
-
-static DRIZZLE_SYSVAR_STR(file,
-                          sysvar_transaction_log_file,
-                          PLUGIN_VAR_READONLY,
-                          N_("Path to the file to use for transaction log"),
-                          NULL, /* check func */
-                          NULL, /* update func*/
-                          DEFAULT_LOG_FILE_PATH /* default */);
-
-static DRIZZLE_SYSVAR_STR(use_replicator,
-                          sysvar_transaction_log_use_replicator,
-                          PLUGIN_VAR_READONLY,
-                          N_("Name of the replicator plugin to use (default='default_replicator')"),
-                          NULL, /* check func */
-                          NULL, /* update func*/
-                          DEFAULT_USE_REPLICATOR /* default */);
-
-static DRIZZLE_SYSVAR_BOOL(enable_checksum,
-                           sysvar_transaction_log_checksum_enabled,
-                           PLUGIN_VAR_NOCMDARG,
-                           N_("Enable CRC32 Checksumming of each written transaction log entry"),
-                           NULL, /* check func */
-                           NULL, /* update func */
-                           false /* default */);
-
-static DRIZZLE_SYSVAR_UINT(flush_frequency,
-                           sysvar_transaction_log_flush_frequency,
-                           PLUGIN_VAR_OPCMDARG,
-                           N_("0 == rely on operating system to sync log file (default), "
-                              "1 == sync file at each transaction write, "
-                              "2 == sync log file once per second"),
-                           NULL, /* check func */
-                           NULL, /* update func */
-                           0, /* default */
-                           0,
-                           2,
-                           0);
-
-static DRIZZLE_SYSVAR_UINT(num_write_buffers,
-                           sysvar_transaction_log_num_write_buffers,
-                           PLUGIN_VAR_OPCMDARG,
-                           N_("Number of slots for in-memory write buffers (default=8)."),
-                           NULL, /* check func */
-                           NULL, /* update func */
-                           8, /* default */
-                           4,
-                           8192,
-                           0);
-
 static void init_options(drizzled::module::option_context &context)
 {
   context("truncate-debug",
@@ -354,28 +263,17 @@
           po::value<bool>(&sysvar_transaction_log_enabled)->default_value(false)->zero_tokens(),
           N_("Enable transaction log"));
   context("file",
-          po::value<string>(),
+          po::value<string>(&sysvar_transaction_log_file)->default_value(DEFAULT_LOG_FILE_PATH),
           N_("Path to the file to use for transaction log"));
   context("use-replicator",
-          po::value<string>(),
+          po::value<string>(&sysvar_transaction_log_use_replicator)->default_value(DEFAULT_USE_REPLICATOR),
           N_("Name of the replicator plugin to use (default='default_replicator')")); 
   context("flush-frequency",
-          po::value<uint32_t>(&sysvar_transaction_log_flush_frequency)->default_value(0),
+          po::value<flush_constraint>(&sysvar_transaction_log_flush_frequency)->default_value(0),
           N_("0 == rely on operating system to sync log file (default), 1 == sync file at each transaction write, 2 == sync log file once per second"));
   context("num-write-buffers",
-          po::value<uint32_t>(&sysvar_transaction_log_num_write_buffers)->default_value(8),
+          po::value<write_buffers_constraint>(&sysvar_transaction_log_num_write_buffers)->default_value(8),
           N_("Number of slots for in-memory write buffers (default=8)."));
 }
 
-static drizzle_sys_var* sys_variables[]= {
-  DRIZZLE_SYSVAR(enable),
-  DRIZZLE_SYSVAR(truncate_debug),
-  DRIZZLE_SYSVAR(file),
-  DRIZZLE_SYSVAR(enable_checksum),
-  DRIZZLE_SYSVAR(flush_frequency),
-  DRIZZLE_SYSVAR(num_write_buffers),
-  DRIZZLE_SYSVAR(use_replicator),
-  NULL
-};
-
-DRIZZLE_PLUGIN(init, sys_variables, init_options);
+DRIZZLE_PLUGIN(init, NULL, init_options);

=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2010-11-07 06:50:21 +0000
+++ po/POTFILES.in	2010-11-11 01:16:06 +0000
@@ -57,6 +57,7 @@
 plugin/auth_http/auth_http.cc
 plugin/auth_ldap/auth_ldap.cc
 plugin/blitzdb/ha_blitz.h
+plugin/blitzdb/ha_blitz.cc
 plugin/console/console.cc
 plugin/default_replicator/default_replicator.cc
 plugin/drizzle_protocol/drizzle_protocol.cc

=== modified file 'tests/r/variables.result'
--- tests/r/variables.result	2010-09-02 18:35:05 +0000
+++ tests/r/variables.result	2010-11-11 01:16:06 +0000
@@ -295,7 +295,7 @@
 set global max_write_lock_count=100;
 set global myisam_sort_buffer_size=100;
 Warnings:
-Error	1292	Truncated incorrect sort_buffer_size value: '100'
+Error	1292	Truncated incorrect myisam_sort_buffer_size value: '100'
 set global mysql_protocol_buffer_length=100;
 Warnings:
 Error	1292	Truncated incorrect buffer_length value: '100'