Commit c617037b authored by unknown's avatar unknown
Browse files

Enabled usage of new system variables for ndb 

  - ndb_use_exact_count
  - ndb_autoincrement_prefetch_sz
  - ndb_use_transactions
  - ndb_force_send
moved "inlined" functions to .cc file since they are virtual anyways
enabled printout od ndb errors in warnings even if mapping existst to mysql error code


sql/ha_ndbcluster.h:
  Enabled usage of new system variables for ndb
    - ndb_use_exact_count
    - ndb_autoincrement_prefetch_sz
    - ndb_use_transactions
    - ndb_force_send
  moved "inlined" functions to .cc file since they are virtual anyways
sql/mysqld.cc:
  Enabled usage of new system variables for ndb
    - ndb_use_exact_count
    - ndb_autoincrement_prefetch_sz
    - ndb_use_transactions
    - ndb_force_send
sql/set_var.cc:
  Enabled usage of new system variables for ndb
    - ndb_use_exact_count
    - ndb_autoincrement_prefetch_sz
    - ndb_use_transactions
    - ndb_force_send
sql/sql_class.h:
  Enabled usage of new system variables for ndb
    - ndb_use_exact_count
    - ndb_autoincrement_prefetch_sz
    - ndb_use_transactions
    - ndb_force_send
parent 692311f5

sql/ha_ndbcluster.cc

+145 −59
Original line number Diff line number Diff line
@@ -39,9 +39,6 @@ static const int parallelism= 240; 
// createable against NDB from this handler

static const int max_transactions= 256;



// Default value for prefetch of autoincrement values

static const ha_rows autoincrement_prefetch= 32;



// connectstring to cluster if given by mysqld

const char *ndbcluster_connectstring= 0;
@@ -103,58 +100,52 @@ struct err_code_mapping 
{

  int ndb_err;

  int my_err;

  int show_warning;

};



static const err_code_mapping err_map[]= 

{

  { 626, HA_ERR_KEY_NOT_FOUND },

  { 630, HA_ERR_FOUND_DUPP_KEY },

  { 893, HA_ERR_FOUND_DUPP_UNIQUE },

  { 721, HA_ERR_TABLE_EXIST },

  { 4244, HA_ERR_TABLE_EXIST },

  { 626, HA_ERR_KEY_NOT_FOUND, 0 },

  { 630, HA_ERR_FOUND_DUPP_KEY, 0 },

  { 893, HA_ERR_FOUND_DUPP_UNIQUE, 0 },

  { 721, HA_ERR_TABLE_EXIST, 1 },

  { 4244, HA_ERR_TABLE_EXIST, 1 },



  { 709, HA_ERR_NO_SUCH_TABLE },

  { 284, HA_ERR_NO_SUCH_TABLE },

  { 709, HA_ERR_NO_SUCH_TABLE, 1 },

  { 284, HA_ERR_NO_SUCH_TABLE, 1 },



  { 266, HA_ERR_LOCK_WAIT_TIMEOUT },

  { 274, HA_ERR_LOCK_WAIT_TIMEOUT },

  { 296, HA_ERR_LOCK_WAIT_TIMEOUT },

  { 297, HA_ERR_LOCK_WAIT_TIMEOUT },

  { 237, HA_ERR_LOCK_WAIT_TIMEOUT },

  { 266, HA_ERR_LOCK_WAIT_TIMEOUT, 1 },

  { 274, HA_ERR_LOCK_WAIT_TIMEOUT, 1 },

  { 296, HA_ERR_LOCK_WAIT_TIMEOUT, 1 },

  { 297, HA_ERR_LOCK_WAIT_TIMEOUT, 1 },

  { 237, HA_ERR_LOCK_WAIT_TIMEOUT, 1 },



  { 623, HA_ERR_RECORD_FILE_FULL },

  { 624, HA_ERR_RECORD_FILE_FULL },

  { 625, HA_ERR_RECORD_FILE_FULL },

  { 826, HA_ERR_RECORD_FILE_FULL },

  { 827, HA_ERR_RECORD_FILE_FULL },

  { 832, HA_ERR_RECORD_FILE_FULL },

  { 623, HA_ERR_RECORD_FILE_FULL, 1 },

  { 624, HA_ERR_RECORD_FILE_FULL, 1 },

  { 625, HA_ERR_RECORD_FILE_FULL, 1 },

  { 826, HA_ERR_RECORD_FILE_FULL, 1 },

  { 827, HA_ERR_RECORD_FILE_FULL, 1 },

  { 832, HA_ERR_RECORD_FILE_FULL, 1 },



  { 0, 1 },

  { 0, 1, 0 },



  { -1, -1 }

  { -1, -1, 1 }

};





static int ndb_to_mysql_error(const NdbError *err)

{

  uint i;

  for (i=0 ; err_map[i].ndb_err != err->code ; i++)

  for (i=0; err_map[i].ndb_err != err->code && err_map[i].my_err != -1; i++);

  if (err_map[i].show_warning)

  {

    if (err_map[i].my_err == -1){

    // Push the NDB error message as warning

    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_ERROR,

			ER_GET_ERRMSG, ER(ER_GET_ERRMSG),

			err->code, err->message, "NDB");

      return err->code;

  }

  }

  // Push the NDB error message as warning

  // this since e.g. HA_ERR_RECORD_FILE_FULL maps to

  // several error codes in NDB, and the uses needs

  // to know which one it is

  push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_ERROR,

		      ER_GET_ERRMSG, ER(ER_GET_ERRMSG),

		      err->code, err->message, "NDB");

  if (err_map[i].my_err == -1)

    return err->code;

  return err_map[i].my_err;

}
@@ -168,7 +159,7 @@ int execute_no_commit(ha_ndbcluster *h, NdbConnection *trans) 
  if (m_batch_execute)

    return 0;

#endif

  return trans->execute(NoCommit,AbortOnError,1);

  return trans->execute(NoCommit,AbortOnError,h->m_force_send);

}



inline
@@ -179,7 +170,18 @@ int execute_commit(ha_ndbcluster *h, NdbConnection *trans) 
  if (m_batch_execute)

    return 0;

#endif

  return trans->execute(Commit,AbortOnError,1);

  return trans->execute(Commit,AbortOnError,h->m_force_send);

}



inline

int execute_commit(THD *thd, NdbConnection *trans)

{

  int m_batch_execute= 0;

#ifdef NOT_USED

  if (m_batch_execute)

    return 0;

#endif

  return trans->execute(Commit,AbortOnError,thd->variables.ndb_force_send);

}



inline
@@ -190,7 +192,7 @@ int execute_no_commit_ie(ha_ndbcluster *h, NdbConnection *trans) 
  if (m_batch_execute)

    return 0;

#endif

  return trans->execute(NoCommit,IgnoreError,1);

  return trans->execute(NoCommit,IgnoreError,h->m_force_send);

}



/*
@@ -233,6 +235,8 @@ void ha_ndbcluster::set_rec_per_key() 


void ha_ndbcluster::records_update()

{

  if (m_ha_not_exact_count)

    return;

  DBUG_ENTER("ha_ndbcluster::records_update");

  struct Ndb_table_local_info *info= (struct Ndb_table_local_info *)m_table_info;

  DBUG_PRINT("info", ("id=%d, no_uncommitted_rows_count=%d",
@@ -256,6 +260,8 @@ void ha_ndbcluster::records_update() 


void ha_ndbcluster::no_uncommitted_rows_execute_failure()

{

  if (m_ha_not_exact_count)

    return;

  DBUG_ENTER("ha_ndbcluster::no_uncommitted_rows_execute_failure");

  THD *thd= current_thd;

  ((Thd_ndb*)(thd->transaction.thd_ndb))->error= 1;
@@ -264,6 +270,8 @@ void ha_ndbcluster::no_uncommitted_rows_execute_failure() 


void ha_ndbcluster::no_uncommitted_rows_init(THD *thd)

{

  if (m_ha_not_exact_count)

    return;

  DBUG_ENTER("ha_ndbcluster::no_uncommitted_rows_init");

  struct Ndb_table_local_info *info= (struct Ndb_table_local_info *)m_table_info;

  Thd_ndb *thd_ndb= (Thd_ndb *)thd->transaction.thd_ndb;
@@ -281,6 +289,8 @@ void ha_ndbcluster::no_uncommitted_rows_init(THD *thd) 


void ha_ndbcluster::no_uncommitted_rows_update(int c)

{

  if (m_ha_not_exact_count)

    return;

  DBUG_ENTER("ha_ndbcluster::no_uncommitted_rows_update");

  struct Ndb_table_local_info *info=

    (struct Ndb_table_local_info *)m_table_info;
@@ -293,6 +303,8 @@ void ha_ndbcluster::no_uncommitted_rows_update(int c) 


void ha_ndbcluster::no_uncommitted_rows_reset(THD *thd)

{

  if (m_ha_not_exact_count)

    return;

  DBUG_ENTER("ha_ndbcluster::no_uncommitted_rows_reset");

  ((Thd_ndb*)(thd->transaction.thd_ndb))->count++;

  ((Thd_ndb*)(thd->transaction.thd_ndb))->error= 0;
@@ -1229,7 +1241,8 @@ inline int ha_ndbcluster::next_result(byte *buf) 
      DBUG_PRINT("info", ("ops_pending: %d", m_ops_pending));    

      if (m_ops_pending)

      {

	if (current_thd->transaction.on)

	//	if (current_thd->transaction.on)

	if (m_transaction_on)

	{

	  if (execute_no_commit(this,trans) != 0)

	    DBUG_RETURN(ndb_err(trans));
@@ -1715,7 +1728,8 @@ int ha_ndbcluster::write_row(byte *record) 
			(int)m_rows_inserted, (int)m_bulk_insert_rows));



    m_bulk_insert_not_flushed= FALSE;

    if (thd->transaction.on)

    //    if (thd->transaction.on)

    if (m_transaction_on)

    {

      if (execute_no_commit(this,trans) != 0)

      {
@@ -1888,7 +1902,7 @@ int ha_ndbcluster::update_row(const byte *old_data, byte *new_data) 
  for (i= 0; i < table->fields; i++) 

  {

    Field *field= table->field[i];

    if ((thd->query_id == field->query_id) &&

    if (((thd->query_id == field->query_id) || m_retrieve_all_fields) &&

        (!(field->flags & PRI_KEY_FLAG)) &&

	set_ndb_value(op, field, i))

      ERR_RETURN(op->getNdbError());
@@ -2547,16 +2561,19 @@ void ha_ndbcluster::info(uint flag) 
    DBUG_PRINT("info", ("HA_STATUS_VARIABLE"));

    if (m_table_info)

    {

      if (m_ha_not_exact_count)

	records= 100;

      else

	records_update();

    }

    else

    {

      Uint64 rows;

      if(ndb_get_table_statistics(m_ndb, m_tabname, &rows, 0) == 0){

      Uint64 rows= 100;

      if (current_thd->variables.ndb_use_exact_count)

	ndb_get_table_statistics(m_ndb, m_tabname, &rows, 0);

      records= rows;

    }

  }

  }

  if (flag & HA_STATUS_CONST)

  {

    DBUG_PRINT("info", ("HA_STATUS_CONST"));
@@ -2943,6 +2960,15 @@ int ha_ndbcluster::external_lock(THD *thd, int lock_type) 
      pointer to point to the NDB transaction. 

     */



    // store thread specific data first to set the right context

    m_force_send=          thd->variables.ndb_force_send;

    m_ha_not_exact_count= !thd->variables.ndb_use_exact_count;

    m_autoincrement_prefetch= thd->variables.ndb_autoincrement_prefetch_sz;

    if (!thd->transaction.on)

      m_transaction_on= FALSE;

    else

      m_transaction_on= thd->variables.ndb_use_transactions;



    m_active_trans= thd->transaction.all.ndb_tid ? 

      (NdbConnection*)thd->transaction.all.ndb_tid:

      (NdbConnection*)thd->transaction.stmt.ndb_tid;
@@ -3063,7 +3089,7 @@ int ndbcluster_commit(THD *thd, void *ndb_transaction) 
                            "stmt" : "all"));

  DBUG_ASSERT(ndb && trans);



  if (execute_commit(0,trans) != 0)

  if (execute_commit(thd,trans) != 0)

  {

    const NdbError err= trans->getNdbError();

    const NdbOperation *error_op= trans->getNdbErrorOperation();
@@ -3617,11 +3643,11 @@ longlong ha_ndbcluster::get_auto_increment() 
  DBUG_ENTER("get_auto_increment");

  DBUG_PRINT("enter", ("m_tabname: %s", m_tabname));

  int cache_size= 

    (m_rows_to_insert - m_rows_inserted < autoincrement_prefetch) ?

    (m_rows_to_insert - m_rows_inserted < m_autoincrement_prefetch) ?

    m_rows_to_insert - m_rows_inserted 

    : (m_rows_to_insert > autoincrement_prefetch) ? 

    : (m_rows_to_insert > m_autoincrement_prefetch) ? 

    m_rows_to_insert 

    : autoincrement_prefetch;

    : m_autoincrement_prefetch;

  Uint64 auto_value= 

    (m_skip_auto_increment) ? 

    m_ndb->readAutoIncrementValue((const NDBTAB *) m_table)
@@ -3659,7 +3685,11 @@ ha_ndbcluster::ha_ndbcluster(TABLE *table_arg): 
  m_blobs_pending(0),

  m_blobs_buffer(0),

  m_blobs_buffer_size(0),

  m_dupkey((uint) -1)

  m_dupkey((uint) -1),

  m_ha_not_exact_count(FALSE),

  m_force_send(TRUE),

  m_autoincrement_prefetch(32),

  m_transaction_on(TRUE)

{ 

  int i;
@@ -4309,6 +4339,62 @@ ha_ndbcluster::records_in_range(uint inx, key_range *min_key, 
  DBUG_RETURN(10); /* Good guess when you don't know anything */

}



ulong ha_ndbcluster::table_flags(void) const

{

  if (m_ha_not_exact_count)

    return m_table_flags | HA_NOT_EXACT_COUNT;

  else

    return m_table_flags;

}

const char * ha_ndbcluster::table_type() const 

{

  return("ndbcluster");

}

uint ha_ndbcluster::max_supported_record_length() const

{ 

  return NDB_MAX_TUPLE_SIZE;

}

uint ha_ndbcluster::max_supported_keys() const

{

  return MAX_KEY;

}

uint ha_ndbcluster::max_supported_key_parts() const 

{

  return NDB_MAX_NO_OF_ATTRIBUTES_IN_KEY;

}

uint ha_ndbcluster::max_supported_key_length() const

{

  return NDB_MAX_KEY_SIZE;

}

bool ha_ndbcluster::low_byte_first() const

{ 

#ifdef WORDS_BIGENDIAN

  return FALSE;

#else

  return TRUE;

#endif

}

bool ha_ndbcluster::has_transactions()

{

  return TRUE;

}

const char* ha_ndbcluster::index_type(uint key_number)

{

  switch (get_index_type(key_number)) {

  case ORDERED_INDEX:

  case UNIQUE_ORDERED_INDEX:

  case PRIMARY_KEY_ORDERED_INDEX:

    return "BTREE";

  case UNIQUE_INDEX:

  case PRIMARY_KEY_INDEX:

  default:

    return "HASH";

  }

}

uint8 ha_ndbcluster::table_cache_type()

{

  return HA_CACHE_TBL_NOCACHE;

}



/*

  Handling the shared NDB_SHARE structure that is needed to

sql/ha_ndbcluster.h

+16 −30
Original line number Diff line number Diff line
@@ -118,15 +118,14 @@ class ha_ndbcluster: public handler 
  int reset();

  int external_lock(THD *thd, int lock_type);

  int start_stmt(THD *thd);

  const char * table_type() const { return("ndbcluster");}

  const char * table_type() const;

  const char ** bas_ext() const;

  ulong table_flags(void) const { return m_table_flags; }

  ulong table_flags(void) const;

  ulong index_flags(uint idx, uint part, bool all_parts) const;

  uint max_supported_record_length() const { return NDB_MAX_TUPLE_SIZE; };

  uint max_supported_keys() const { return MAX_KEY;  }

  uint max_supported_key_parts() const 

    { return NDB_MAX_NO_OF_ATTRIBUTES_IN_KEY; };

  uint max_supported_key_length() const { return NDB_MAX_KEY_SIZE;};

  uint max_supported_record_length() const;

  uint max_supported_keys() const;

  uint max_supported_key_parts() const;

  uint max_supported_key_length() const;



  int rename_table(const char *from, const char *to);

  int delete_table(const char *name);
@@ -135,28 +134,9 @@ class ha_ndbcluster: public handler 
			     THR_LOCK_DATA **to,

			     enum thr_lock_type lock_type);



  bool low_byte_first() const

    { 

#ifdef WORDS_BIGENDIAN

      return FALSE;

#else

      return TRUE;

#endif

    }

  bool has_transactions()  { return TRUE; }



  const char* index_type(uint key_number) {

    switch (get_index_type(key_number)) {

    case ORDERED_INDEX:

    case UNIQUE_ORDERED_INDEX:

    case PRIMARY_KEY_ORDERED_INDEX:

      return "BTREE";

    case UNIQUE_INDEX:

    case PRIMARY_KEY_INDEX:

    default:

      return "HASH";

    }

  }

  bool low_byte_first() const;

  bool has_transactions();

  const char* index_type(uint key_number);



  double scan_time();

  ha_rows records_in_range(uint inx, key_range *min_key, key_range *max_key);
@@ -165,7 +145,7 @@ class ha_ndbcluster: public handler 


  static Thd_ndb* seize_thd_ndb();

  static void release_thd_ndb(Thd_ndb* thd_ndb);

  uint8 table_cache_type() { return HA_CACHE_TBL_NOCACHE; }

  uint8 table_cache_type();

    

 private:

  int alter_table_name(const char *from, const char *to);
@@ -256,6 +236,10 @@ class ha_ndbcluster: public handler 
  char *m_blobs_buffer;

  uint32 m_blobs_buffer_size;

  uint m_dupkey;

  bool m_ha_not_exact_count;

  bool m_force_send;

  ha_rows m_autoincrement_prefetch;

  bool m_transaction_on;



  void set_rec_per_key();

  void records_update();
@@ -265,6 +249,8 @@ class ha_ndbcluster: public handler 
  void no_uncommitted_rows_reset(THD *);



  friend int execute_no_commit(ha_ndbcluster*, NdbConnection*);

  friend int execute_commit(ha_ndbcluster*, NdbConnection*);

  friend int execute_no_commit_ie(ha_ndbcluster*, NdbConnection*);

};



bool ndbcluster_init(void);

sql/mysqld.cc

+30 −4
Original line number Diff line number Diff line
@@ -3947,7 +3947,11 @@ enum options_mysqld 
  OPT_INNODB_FILE_PER_TABLE, OPT_CRASH_BINLOG_INNODB,

  OPT_INNODB_LOCKS_UNSAFE_FOR_BINLOG,

  OPT_SAFE_SHOW_DB, OPT_INNODB_SAFE_BINLOG,

  OPT_INNODB, OPT_ISAM, OPT_NDBCLUSTER, OPT_NDB_CONNECTSTRING, OPT_SKIP_SAFEMALLOC,

  OPT_INNODB, OPT_ISAM,

  OPT_NDBCLUSTER, OPT_NDB_CONNECTSTRING, OPT_NDB_USE_EXACT_COUNT,

  OPT_NDB_FORCE_SEND, OPT_NDB_AUTOINCREMENT_PREFETCH_SZ,

  OPT_NDB_USE_TRANSACTIONS,

  OPT_SKIP_SAFEMALLOC,

  OPT_TEMP_POOL, OPT_TX_ISOLATION,

  OPT_SKIP_STACK_TRACE, OPT_SKIP_SYMLINKS,

  OPT_MAX_BINLOG_DUMP_EVENTS, OPT_SPORADIC_BINLOG_DUMP_FAIL,
@@ -4386,9 +4390,31 @@ Disable with --skip-ndbcluster (will save memory).", 
   (gptr*) &opt_ndbcluster, (gptr*) &opt_ndbcluster, 0, GET_BOOL, NO_ARG, 1, 0, 0,

   0, 0, 0},

#ifdef HAVE_NDBCLUSTER_DB

  {"ndb-connectstring", OPT_NDB_CONNECTSTRING, "Connect string for ndbcluster.",

   (gptr*) &ndbcluster_connectstring, (gptr*) &ndbcluster_connectstring, 0, GET_STR,

   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"ndb-connectstring", OPT_NDB_CONNECTSTRING,

   "Connect string for ndbcluster.",

   (gptr*) &ndbcluster_connectstring, (gptr*) &ndbcluster_connectstring,

   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"ndb_autoincrement_prefetch_sz", OPT_NDB_AUTOINCREMENT_PREFETCH_SZ,

   "Specify number of autoincrement values that are prefetched",

   (gptr*) &global_system_variables.ndb_autoincrement_prefetch_sz,

   (gptr*) &global_system_variables.ndb_autoincrement_prefetch_sz,

   0, GET_INT, REQUIRED_ARG, 32, 1, 256, 0, 0, 0},

  {"ndb_force_send", OPT_NDB_FORCE_SEND,

   "Force send of buffers to ndb immediately without waiting for other threads",

   (gptr*) &global_system_variables.ndb_force_send,

   (gptr*) &global_system_variables.ndb_force_send,

   0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},

  {"ndb_use_exact_count", OPT_NDB_USE_EXACT_COUNT,

   "Use exact records count during query planning and for "

   "fast select count(*)",

   (gptr*) &global_system_variables.ndb_use_exact_count,

   (gptr*) &global_system_variables.ndb_use_exact_count,

   0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},

  {"ndb_use_transactions", OPT_NDB_USE_TRANSACTIONS,

   "Use transactions in ndb",

   (gptr*) &global_system_variables.ndb_use_transactions,

   (gptr*) &global_system_variables.ndb_use_transactions,

   0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},

#endif

  {"new", 'n', "Use very new possible 'unsafe' functions.",

   (gptr*) &global_system_variables.new_mode,

sql/set_var.cc

+31 −1
Original line number Diff line number Diff line
@@ -359,6 +359,23 @@ sys_var_thd_bool sys_innodb_table_locks("innodb_table_locks", 
sys_var_long_ptr	sys_innodb_autoextend_increment("innodb_autoextend_increment",

							&srv_auto_extend_increment);

#endif

#ifdef HAVE_NDBCLUSTER_DB

// ndb thread specific variable settings

sys_var_thd_ulong 

sys_ndb_autoincrement_prefetch_sz("ndb_autoincrement_prefetch_sz",

				  &SV::ndb_autoincrement_prefetch_sz);

sys_var_thd_bool

sys_ndb_force_send("ndb_force_send",

		   &SV::ndb_force_send);

sys_var_thd_bool

sys_ndb_use_exact_count("ndb_use_exact_count",

			&SV::ndb_use_exact_count);

sys_var_thd_bool

sys_ndb_use_transactions("ndb_use_transactions",

			 &SV::ndb_use_transactions);

// ndb server global variable settings

// none

#endif



/* Time/date/datetime formats */
@@ -612,6 +629,12 @@ sys_var *sys_variables[]= 
  &sys_innodb_table_locks,

  &sys_innodb_max_purge_lag,

  &sys_innodb_autoextend_increment,

#endif  

#ifdef HAVE_NDBCLUSTER_DB

  &sys_ndb_autoincrement_prefetch_sz,

  &sys_ndb_force_send,

  &sys_ndb_use_exact_count,

  &sys_ndb_use_transactions,

#endif

  &sys_unique_checks,

  &sys_warning_count
@@ -772,6 +795,13 @@ struct show_var_st init_vars[]= { 
  {sys_myisam_sort_buffer_size.name, (char*) &sys_myisam_sort_buffer_size, SHOW_SYS},

#ifdef __NT__

  {"named_pipe",	      (char*) &opt_enable_named_pipe,       SHOW_MY_BOOL},

#endif

#ifdef HAVE_NDBCLUSTER_DB

  {sys_ndb_autoincrement_prefetch_sz.name,

   (char*) &sys_ndb_autoincrement_prefetch_sz,                      SHOW_SYS},

  {sys_ndb_force_send.name,   (char*) &sys_ndb_force_send,          SHOW_SYS},

  {sys_ndb_use_exact_count.name,(char*) &sys_ndb_use_exact_count,   SHOW_SYS},

  {sys_ndb_use_transactions.name,(char*) &sys_ndb_use_transactions, SHOW_SYS},

#endif

  {sys_net_buffer_length.name,(char*) &sys_net_buffer_length,       SHOW_SYS},

  {sys_net_read_timeout.name, (char*) &sys_net_read_timeout,        SHOW_SYS},

sql/sql_class.h

+6 −0
Original line number Diff line number Diff line
@@ -399,6 +399,12 @@ struct system_variables 
#ifdef HAVE_INNOBASE_DB

  my_bool innodb_table_locks;

#endif /* HAVE_INNOBASE_DB */

#ifdef HAVE_NDBCLUSTER_DB

  ulong ndb_autoincrement_prefetch_sz;

  my_bool ndb_force_send;

  my_bool ndb_use_exact_count;

  my_bool ndb_use_transactions;

#endif /* HAVE_NDBCLUSTER_DB */

  my_bool old_passwords;

  

  /* Only charset part of these variables is sensible */