database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-30 16:24:05 +03:00
Code Activity

Merge mskold@bk-internal.mysql.com:/home/bk/mysql-5.0-ndb

Browse Source 
into mysql.com:/usr/local/home/marty/MySQL/test/mysql-5.0-ndb


sql/set_var.cc:
  Auto merged
sql/sql_select.cc:
  Auto merged
This commit is contained in:
unknown
2005-01-10 09:31:17 +01:00
parent 6cfef07c05 99f07f83ac
commit 88e845067b
34 changed files with 521 additions and 401 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
mysql-test/ndb/basic.result
View File

@ -26,17 +26,17 @@ CONNECT [<connectstring>] Connect to management server (reconnect i
QUIT Quit management client QUIT Quit management client
<severity> = ALERT | CRITICAL | ERROR | WARNING | INFO | DEBUG <severity> = ALERT | CRITICAL | ERROR | WARNING | INFO | DEBUG
<category> = STARTUP | SHUTDOWN | STATISTICS | CHECKPOINT | NODERESTART | CONNECTION | INFO | ERROR | GREP | DEBUG | BACKUP <category> = STARTUP | SHUTDOWN | STATISTICS | CHECKPOINT | NODERESTART | CONNECTION | INFO | ERROR | CONGESTION | DEBUG | BACKUP
<level> = 0 - 15 <level> = 0 - 15
<id> = ALL | Any database node id <id> = ALL | Any database node id
Connected to Management Server at: localhost:1186 Connected to Management Server at: localhost:1186
Node 1: started (Version 4.1.9) Node 1: started (Version 5.0.3)
Node 2: started (Version 4.1.9) Node 2: started (Version 5.0.3)
Node 1: started (Version 4.1.9) Node 1: started (Version 5.0.3)
Node 2: started (Version 4.1.9) Node 2: started (Version 5.0.3)
Executing CLUSTERLOG on node 1 OK! Executing CLUSTERLOG on node 1 OK!
Executing CLUSTERLOG on node 2 OK! Executing CLUSTERLOG on node 2 OK!

2
mysql-test/ndb/restart.test
View File

@ -8,5 +8,5 @@ sleep 5
all clusterlog connection=8 all clusterlog connection=8
sleep 1 sleep 1
1 restart 1 restart
sleep 5 sleep 10
clusterlog on all clusterlog on all

4
mysql-test/r/ctype_utf8.result
View File

@ -448,7 +448,7 @@ show create table t1;
Table Create Table Table Create Table
t1 CREATE TABLE `t1` ( t1 CREATE TABLE `t1` (
`c` char(10) character set utf8 default NULL, `c` char(10) character set utf8 default NULL,
UNIQUE KEY `a` TYPE BTREE (`c`(1)) UNIQUE KEY `a` USING BTREE (`c`(1))
) ENGINE=HEAP DEFAULT CHARSET=latin1 ) ENGINE=HEAP DEFAULT CHARSET=latin1
insert into t1 values ('a'),('b'),('c'),('d'),('e'),('f'); insert into t1 values ('a'),('b'),('c'),('d'),('e'),('f');
insert into t1 values ('aa'); insert into t1 values ('aa');
@ -606,7 +606,7 @@ show create table t1;
Table Create Table Table Create Table
t1 CREATE TABLE `t1` ( t1 CREATE TABLE `t1` (
`c` char(10) character set utf8 collate utf8_bin default NULL, `c` char(10) character set utf8 collate utf8_bin default NULL,
UNIQUE KEY `a` TYPE BTREE (`c`(1)) UNIQUE KEY `a` USING BTREE (`c`(1))
) ENGINE=HEAP DEFAULT CHARSET=latin1 ) ENGINE=HEAP DEFAULT CHARSET=latin1
insert into t1 values ('a'),('b'),('c'),('d'),('e'),('f'); insert into t1 values ('a'),('b'),('c'),('d'),('e'),('f');
insert into t1 values ('aa'); insert into t1 values ('aa');

6
mysql-test/r/heap.result
View File

@ -556,9 +556,9 @@ t1 CREATE TABLE `t1` (
`v` varchar(10) default NULL, `v` varchar(10) default NULL,
`c` char(10) default NULL, `c` char(10) default NULL,
`t` varchar(50) default NULL, `t` varchar(50) default NULL,
KEY `v` TYPE BTREE (`v`), KEY `v` USING BTREE (`v`),
KEY `c` TYPE BTREE (`c`), KEY `c` USING BTREE (`c`),
KEY `t` TYPE BTREE (`t`(10)) KEY `t` USING BTREE (`t`(10))
) ENGINE=HEAP DEFAULT CHARSET=latin1 ) ENGINE=HEAP DEFAULT CHARSET=latin1
select count(*) from t1; select count(*) from t1;
count(*) count(*)

25
mysql-test/r/ndb_charset.result
View File

@ -305,31 +305,6 @@ count(*)
48 48
drop table t1; drop table t1;
create table t1 ( create table t1 (
a char(5) character set ucs2,
b varchar(7) character set utf8,
primary key(a, b)
) engine=ndb;
insert into t1 values
('a','A '),('B ','b'),('c','C '),('D','d'),('e ','E'),('F','f '),
('A','b '),('b ','C'),('C','d '),('d','E'),('E ','f'),
('a','C '),('B ','d'),('c','E '),('D','f');
insert into t1 values('d','f');
ERROR 23000: Duplicate entry '' for key 1
select a,b,length(a),length(b) from t1 order by a,b limit 3;
a b length(a) length(b)
a A 2 2
A b 2 2
a C 2 2
select a,b,length(a),length(b) from t1 order by a desc, b desc limit 3;
a b length(a) length(b)
F f 2 3
E f 2 1
e E 2 1
select a,b,length(a),length(b) from t1 where a='c' and b='c';
a b length(a) length(b)
c C 2 5
drop table t1;
create table t1 (
a char(10) primary key a char(10) primary key
) engine=ndb; ) engine=ndb;
insert into t1 values ('jonas % '); insert into t1 values ('jonas % ');

4
mysql-test/r/show_check.result
View File

@ -298,7 +298,7 @@ select @@max_heap_table_size;
1047552 1047552
CREATE TABLE t1 ( CREATE TABLE t1 (
a int(11) default NULL, a int(11) default NULL,
KEY a TYPE BTREE (a) KEY a USING BTREE (a)
) ENGINE=HEAP; ) ENGINE=HEAP;
CREATE TABLE t2 ( CREATE TABLE t2 (
b int(11) default NULL, b int(11) default NULL,
@ -307,7 +307,7 @@ index(b)
CREATE TABLE t3 ( CREATE TABLE t3 (
a int(11) default NULL, a int(11) default NULL,
b int(11) default NULL, b int(11) default NULL,
KEY a TYPE BTREE (a), KEY a USING BTREE (a),
index(b) index(b)
) ENGINE=HEAP; ) ENGINE=HEAP;
insert into t1 values (1),(2); insert into t1 values (1),(2);

6
mysql-test/r/sql_mode.result
View File

@ -17,7 +17,7 @@ t1 CREATE TABLE `t1` (
`pseudo` varchar(35) character set latin2 NOT NULL default '', `pseudo` varchar(35) character set latin2 NOT NULL default '',
`email` varchar(60) character set latin2 NOT NULL default '', `email` varchar(60) character set latin2 NOT NULL default '',
PRIMARY KEY (`a`), PRIMARY KEY (`a`),
UNIQUE KEY `email` TYPE BTREE (`email`) UNIQUE KEY `email` USING BTREE (`email`)
) ENGINE=HEAP DEFAULT CHARSET=latin1 ROW_FORMAT=DYNAMIC ) ENGINE=HEAP DEFAULT CHARSET=latin1 ROW_FORMAT=DYNAMIC
set @@sql_mode="ansi_quotes"; set @@sql_mode="ansi_quotes";
show variables like 'sql_mode'; show variables like 'sql_mode';
@ -30,7 +30,7 @@ t1 CREATE TABLE "t1" (
"pseudo" varchar(35) character set latin2 NOT NULL default '', "pseudo" varchar(35) character set latin2 NOT NULL default '',
"email" varchar(60) character set latin2 NOT NULL default '', "email" varchar(60) character set latin2 NOT NULL default '',
PRIMARY KEY ("a"), PRIMARY KEY ("a"),
UNIQUE KEY "email" TYPE BTREE ("email") UNIQUE KEY "email" USING BTREE ("email")
) ENGINE=HEAP DEFAULT CHARSET=latin1 ROW_FORMAT=DYNAMIC ) ENGINE=HEAP DEFAULT CHARSET=latin1 ROW_FORMAT=DYNAMIC
set @@sql_mode="no_table_options"; set @@sql_mode="no_table_options";
show variables like 'sql_mode'; show variables like 'sql_mode';
@ -43,7 +43,7 @@ t1 CREATE TABLE `t1` (
`pseudo` varchar(35) character set latin2 NOT NULL default '', `pseudo` varchar(35) character set latin2 NOT NULL default '',
`email` varchar(60) character set latin2 NOT NULL default '', `email` varchar(60) character set latin2 NOT NULL default '',
PRIMARY KEY (`a`), PRIMARY KEY (`a`),
UNIQUE KEY `email` TYPE BTREE (`email`) UNIQUE KEY `email` USING BTREE (`email`)
) )
set @@sql_mode="no_key_options"; set @@sql_mode="no_key_options";
show variables like 'sql_mode'; show variables like 'sql_mode';

32
mysql-test/t/ndb_charset.test
View File

@ -217,24 +217,24 @@ select count(*) from t1 x, t1 y, t1 z where x.a = y.a and y.a = z.a;
drop table t1; drop table t1;
# minimal multi-byte test # minimal multi-byte test
# removed by jonas as this requires a configure --with-extra-charsets
create table t1 ( #create table t1 (
a char(5) character set ucs2, # a char(5) character set ucs2,
b varchar(7) character set utf8, # b varchar(7) character set utf8,
primary key(a, b) # primary key(a, b)
) engine=ndb; #) engine=ndb;
# #
insert into t1 values #insert into t1 values
('a','A '),('B ','b'),('c','C '),('D','d'),('e ','E'),('F','f '), # ('a','A '),('B ','b'),('c','C '),('D','d'),('e ','E'),('F','f '),
('A','b '),('b ','C'),('C','d '),('d','E'),('E ','f'), # ('A','b '),('b ','C'),('C','d '),('d','E'),('E ','f'),
('a','C '),('B ','d'),('c','E '),('D','f'); # ('a','C '),('B ','d'),('c','E '),('D','f');
-- error 1062 #-- error 1062
insert into t1 values('d','f'); #insert into t1 values('d','f');
# #
select a,b,length(a),length(b) from t1 order by a,b limit 3; #select a,b,length(a),length(b) from t1 order by a,b limit 3;
select a,b,length(a),length(b) from t1 order by a desc, b desc limit 3; #select a,b,length(a),length(b) from t1 order by a desc, b desc limit 3;
select a,b,length(a),length(b) from t1 where a='c' and b='c'; #select a,b,length(a),length(b) from t1 where a='c' and b='c';
drop table t1; #drop table t1;
# bug # bug
create table t1 ( create table t1 (

4
mysql-test/t/show_check.test
View File

@ -219,7 +219,7 @@ select @@max_heap_table_size;
CREATE TABLE t1 ( CREATE TABLE t1 (
a int(11) default NULL, a int(11) default NULL,
KEY a TYPE BTREE (a) KEY a USING BTREE (a)
) ENGINE=HEAP; ) ENGINE=HEAP;
CREATE TABLE t2 ( CREATE TABLE t2 (
@ -230,7 +230,7 @@ CREATE TABLE t2 (
CREATE TABLE t3 ( CREATE TABLE t3 (
a int(11) default NULL, a int(11) default NULL,
b int(11) default NULL, b int(11) default NULL,
KEY a TYPE BTREE (a), KEY a USING BTREE (a),
index(b) index(b)
) ENGINE=HEAP; ) ENGINE=HEAP;

3
ndb/examples/ndbapi_async_example/ndbapi_async.cpp
View File

@ -145,9 +145,6 @@ int create_table(Ndb * myNdb);
int tempErrors = 0; int tempErrors = 0;
int permErrors = 0; int permErrors = 0;
/**
* Helper function for callback(...)
*/
void void
closeTransaction(Ndb * ndb , async_callback_t * cb) closeTransaction(Ndb * ndb , async_callback_t * cb)
{ {

2
ndb/include/kernel/LogLevel.hpp
View File

@ -57,7 +57,7 @@ public:
llInfo = CFG_LOGLEVEL_INFO - CFG_MIN_LOGLEVEL, llInfo = CFG_LOGLEVEL_INFO - CFG_MIN_LOGLEVEL,
llWarning = CFG_LOGLEVEL_WARNING - CFG_MIN_LOGLEVEL, llWarning = CFG_LOGLEVEL_WARNING - CFG_MIN_LOGLEVEL,
llError = CFG_LOGLEVEL_ERROR - CFG_MIN_LOGLEVEL, llError = CFG_LOGLEVEL_ERROR - CFG_MIN_LOGLEVEL,
llGrep = CFG_LOGLEVEL_GREP - CFG_MIN_LOGLEVEL, llCongestion = CFG_LOGLEVEL_CONGESTION - CFG_MIN_LOGLEVEL,
llDebug = CFG_LOGLEVEL_DEBUG - CFG_MIN_LOGLEVEL llDebug = CFG_LOGLEVEL_DEBUG - CFG_MIN_LOGLEVEL
,llBackup = CFG_LOGLEVEL_BACKUP - CFG_MIN_LOGLEVEL ,llBackup = CFG_LOGLEVEL_BACKUP - CFG_MIN_LOGLEVEL
}; };

437
ndb/include/mgmapi/mgmapi.h
View File

@ -18,45 +18,46 @@
#define MGMAPI_H #define MGMAPI_H
/** /**
* @mainpage NDB Cluster Management API * @mainpage MySQL Cluster Management API
* *
* The NDB Cluster Management API (MGM API) is a C API * The MySQL Cluster Management API (MGM API) is a C language API
* that is used to: * that is used for:
* - Start and stop database nodes (ndbd processes) * - Starting and stopping database nodes (ndbd processes)
* - Start and stop NDB Cluster backups * - Starting and stopping Cluster backups
* - Control the NDB Cluster log * - Controlling the NDB Cluster log
* - Perform other administrative tasks * - Performing other administrative tasks
* *
* @section General Concepts * @section secMgmApiGeneral General Concepts
* *
* Each MGM API function needs a management server handle * Each MGM API function needs a management server handle
* of type @ref NdbMgmHandle. * of type @ref NdbMgmHandle.
* This handle is initally created by calling the * This handle is created by calling the function
* function ndb_mgm_create_handle() and freed by calling * function ndb_mgm_create_handle() and freed by calling
* ndb_mgm_destroy_handle(). * ndb_mgm_destroy_handle().
* *
* A function can return: * A function can return any of the following:
* -# An integer value. * -# An integer value, with
* A value of <b>-1</b> indicates an error. * a value of <b>-1</b> indicating an error.
* -# A non-const pointer value. A <var>NULL</var> value indicates an error; * -# A non-constant pointer value. A <var>NULL</var> value indicates an error;
* otherwise, the return value must be freed * otherwise, the return value must be freed
* by the user of the MGM API * by the programmer
* -# A const pointer value. A <var>NULL</var> value indicates an error. * -# A constant pointer value, with a <var>NULL</var> value indicating an error.
* Returned value should not be freed. * The returned value should <em>not</em> be freed.
* *
* Error conditions can be identified by using the appropriate * Error conditions can be identified by using the appropriate
* error-reporting functions ndb_mgm_get_latest_error() and * error-reporting functions ndb_mgm_get_latest_error() and
* @ref ndb_mgm_error. * @ref ndb_mgm_error.
* *
* Below is an example of usage (without error handling for brevity). * Here is an example using the MGM API (without error handling for brevity's sake).
* @code * @code
* NdbMgmHandle handle= ndb_mgm_create_handle(); * NdbMgmHandle handle= ndb_mgm_create_handle();
* ndb_mgm_connect(handle,0,0,0); * ndb_mgm_connect(handle,0,0,0);
* struct ndb_mgm_cluster_state *state= ndb_mgm_get_status(handle); * struct ndb_mgm_cluster_state *state= ndb_mgm_get_status(handle);
* for(int i=0; i < state->no_of_nodes; i++) * for(int i=0; i < state->no_of_nodes; i++)
* { * {
* printf("node with id=%d ", state->node_states[i].node_id); * struct ndb_mgm_node_state *node_state= &state->node_states[i];
* if(state->node_states[i].version != 0) * printf("node with ID=%d ", node_state->node_id);
* if(node_state->version != 0)
* printf("connected\n"); * printf("connected\n");
* else * else
* printf("not connected\n"); * printf("not connected\n");
@ -64,6 +65,27 @@
* free((void*)state); * free((void*)state);
* ndb_mgm_destroy_handle(&handle); * ndb_mgm_destroy_handle(&handle);
* @endcode * @endcode
*
* @section secLogEvents Log Events
*
* The database nodes and management server(s) regularly and on specific
* occations report on various log events that occurs in the cluster. These
* log events are written to the cluster log. Optionally a mgmapi client
* may listen to these events by using the method ndb_mgm_listen_event().
* Each log event belongs to a category, @ref ndb_mgm_event_category, and
* has a severity, @ref ndb_mgm_event_severity, associated with it. Each
* log event also has a level (0-15) associated with it.
*
* Which log events that come out is controlled with ndb_mgm_listen_event(),
* ndb_mgm_set_clusterlog_loglevel(), and
* ndb_mgm_set_clusterlog_severity_filter().
*
* Below is an example of how to listen to events related to backup.
*
* @code
* int filter[] = { 15, NDB_MGM_EVENT_CATEGORY_BACKUP, 0 };
* int fd = ndb_mgm_listen_event(handle, filter);
* @endcode
*/ */
/** @addtogroup MGM_C_API /** @addtogroup MGM_C_API
@ -87,15 +109,15 @@ extern "C" {
*/ */
enum ndb_mgm_node_type { enum ndb_mgm_node_type {
NDB_MGM_NODE_TYPE_UNKNOWN = -1 /** Node type not known*/ NDB_MGM_NODE_TYPE_UNKNOWN = -1 /** Node type not known*/
,NDB_MGM_NODE_TYPE_API /** An application node (API) */ ,NDB_MGM_NODE_TYPE_API /** An application (NdbApi) node */
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL #ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
= NODE_TYPE_API = NODE_TYPE_API
#endif #endif
,NDB_MGM_NODE_TYPE_NDB /** A database node (DB) */ ,NDB_MGM_NODE_TYPE_NDB /** A database node */
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL #ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
= NODE_TYPE_DB = NODE_TYPE_DB
#endif #endif
,NDB_MGM_NODE_TYPE_MGM /** A mgmt server node (MGM)*/ ,NDB_MGM_NODE_TYPE_MGM /** A management server node */
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL #ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
= NODE_TYPE_MGM = NODE_TYPE_MGM
#endif #endif
@ -228,16 +250,18 @@ extern "C" {
#endif #endif
/** /**
* Status of a node in the cluster * Status of a node in the cluster.
* *
* Sub-structure in enum ndb_mgm_cluster_state * Sub-structure in enum ndb_mgm_cluster_state
* returned by ndb_mgm_get_status() * returned by ndb_mgm_get_status().
* *
* @note @ref node_status, @ref start_phase, @ref dynamic_id * @note <var>node_status</var>, <var>start_phase</var>,
* and @ref node_group are only relevant for database nodes * <var>dynamic_id</var>
* and <var>node_group</var> are relevant only for database nodes,
* i.e. <var>node_type</var> == @ref NDB_MGM_NODE_TYPE_NDB.
*/ */
struct ndb_mgm_node_state { struct ndb_mgm_node_state {
/** NDB Cluster node id*/ /** NDB Cluster node ID*/
int node_id; int node_id;
/** Type of NDB Cluster node*/ /** Type of NDB Cluster node*/
enum ndb_mgm_node_type node_type; enum ndb_mgm_node_type node_type;
@ -245,12 +269,12 @@ extern "C" {
enum ndb_mgm_node_status node_status; enum ndb_mgm_node_status node_status;
/** Start phase. /** Start phase.
* *
* @note Start phase is only valid if node_type is * @note Start phase is only valid if the <var>node_type</var> is
* NDB_MGM_NODE_TYPE_NDB and node_status is * NDB_MGM_NODE_TYPE_NDB and the <var>node_status</var> is
* NDB_MGM_NODE_STATUS_STARTING * NDB_MGM_NODE_STATUS_STARTING
*/ */
int start_phase; int start_phase;
/** Id for heartbeats and master take-over (only valid for DB nodes) /** ID for heartbeats and master take-over (only valid for DB nodes)
*/ */
int dynamic_id; int dynamic_id;
/** Node group of node (only valid for DB nodes)*/ /** Node group of node (only valid for DB nodes)*/
@ -261,9 +285,9 @@ extern "C" {
* management server * management server
*/ */
int connect_count; int connect_count;
/** Ip adress of node when it connected to the management server. /** IP address of node when it connected to the management server.
* @note it will be empty if the management server has restarted * @note This value will be empty if the management server has restarted
* after the node connected. * since the node last connected.
*/ */
char connect_address[ char connect_address[
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL #ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
@ -273,11 +297,11 @@ extern "C" {
}; };
/** /**
* State of all nodes in the cluster returned from * State of all nodes in the cluster; returned from
* ndb_mgm_get_status() * ndb_mgm_get_status()
*/ */
struct ndb_mgm_cluster_state { struct ndb_mgm_cluster_state {
/** No of entries in the node_states array */ /** Number of entries in the node_states array */
int no_of_nodes; int no_of_nodes;
/** An array with node_states*/ /** An array with node_states*/
struct ndb_mgm_node_state node_states[ struct ndb_mgm_node_state node_states[
@ -288,7 +312,7 @@ extern "C" {
}; };
/** /**
* Default reply from the server (for future use, not used today) * Default reply from the server (reserved for future use)
*/ */
struct ndb_mgm_reply { struct ndb_mgm_reply {
/** 0 if successful, otherwise error code. */ /** 0 if successful, otherwise error code. */
@ -325,92 +349,90 @@ extern "C" {
#endif #endif
/** /**
* Log severities (used to filter the cluster log) * Log event severities (used to filter the cluster log,
* ndb_mgm_set_clusterlog_severity_filter(), and filter listening to events
* ndb_mgm_listen_event())
*/ */
enum ndb_mgm_clusterlog_level { enum ndb_mgm_event_severity {
NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL = -1, NDB_MGM_ILLEGAL_EVENT_SEVERITY = -1,
/* must range from 0 and up, indexes into an array */ /* Must be a nonnegative integer (used for array indexing) */
/** Cluster log on*/ /** Cluster log on */
NDB_MGM_CLUSTERLOG_ON = 0, NDB_MGM_EVENT_SEVERITY_ON = 0,
/** Used in NDB Cluster developement */ /** Used in NDB Cluster developement */
NDB_MGM_CLUSTERLOG_DEBUG = 1, NDB_MGM_EVENT_SEVERITY_DEBUG = 1,
/** Informational messages*/ /** Informational messages*/
NDB_MGM_CLUSTERLOG_INFO = 2, NDB_MGM_EVENT_SEVERITY_INFO = 2,
/** Conditions that are not error condition, but might require handling /** Conditions that are not error condition, but might require handling.
*/ */
NDB_MGM_CLUSTERLOG_WARNING = 3, NDB_MGM_EVENT_SEVERITY_WARNING = 3,
/** Conditions that should be corrected */ /** Conditions that, while not fatal, should be corrected. */
NDB_MGM_CLUSTERLOG_ERROR = 4, NDB_MGM_EVENT_SEVERITY_ERROR = 4,
/** Critical conditions, like device errors or out of resources */ /** Critical conditions, like device errors or out of resources */
NDB_MGM_CLUSTERLOG_CRITICAL = 5, NDB_MGM_EVENT_SEVERITY_CRITICAL = 5,
/** A condition that should be corrected immediately, /** A condition that should be corrected immediately,
* such as a corrupted system * such as a corrupted system
*/ */
NDB_MGM_CLUSTERLOG_ALERT = 6, NDB_MGM_EVENT_SEVERITY_ALERT = 6,
/* must be next number, works as bound in loop */ /* must be next number, works as bound in loop */
/** All severities */ /** All severities */
NDB_MGM_CLUSTERLOG_ALL = 7 NDB_MGM_EVENT_SEVERITY_ALL = 7
}; };
/** /**
* Log categories, used to set filter on the clusterlog using * Log event categories, used to set filter level on the log events using
* ndb_mgm_set_loglevel_clusterlog() * ndb_mgm_set_clusterlog_loglevel() and ndb_mgm_listen_event()
*/ */
enum ndb_mgm_event_category { enum ndb_mgm_event_category {
/** /**
* Invalid * Invalid log event category
*/ */
NDB_MGM_ILLEGAL_EVENT_CATEGORY = -1, NDB_MGM_ILLEGAL_EVENT_CATEGORY = -1,
/** /**
* Events during all kinds of startups * Log events during all kinds of startups
*/ */
NDB_MGM_EVENT_CATEGORY_STARTUP = CFG_LOGLEVEL_STARTUP, NDB_MGM_EVENT_CATEGORY_STARTUP = CFG_LOGLEVEL_STARTUP,
/** /**
* Events during shutdown * Log events during shutdown
*/ */
NDB_MGM_EVENT_CATEGORY_SHUTDOWN = CFG_LOGLEVEL_SHUTDOWN, NDB_MGM_EVENT_CATEGORY_SHUTDOWN = CFG_LOGLEVEL_SHUTDOWN,
/** /**
* Transaction statistics (Job level, TCP/IP speed) * Statistics log events
*/ */
NDB_MGM_EVENT_CATEGORY_STATISTIC = CFG_LOGLEVEL_STATISTICS, NDB_MGM_EVENT_CATEGORY_STATISTIC = CFG_LOGLEVEL_STATISTICS,
/** /**
* Events regarding checkpoints * Log events related to checkpoints
*/ */
NDB_MGM_EVENT_CATEGORY_CHECKPOINT = CFG_LOGLEVEL_CHECKPOINT, NDB_MGM_EVENT_CATEGORY_CHECKPOINT = CFG_LOGLEVEL_CHECKPOINT,
/** /**
* Events during node restart * Log events during node restart
*/ */
NDB_MGM_EVENT_CATEGORY_NODE_RESTART = CFG_LOGLEVEL_NODERESTART, NDB_MGM_EVENT_CATEGORY_NODE_RESTART = CFG_LOGLEVEL_NODERESTART,
/** /**
* Events on connection between cluster nodes * Log events related to connections between cluster nodes
*/ */
NDB_MGM_EVENT_CATEGORY_CONNECTION = CFG_LOGLEVEL_CONNECTION, NDB_MGM_EVENT_CATEGORY_CONNECTION = CFG_LOGLEVEL_CONNECTION,
/** /**
* Backup events * Backup related log events
*/ */
NDB_MGM_EVENT_CATEGORY_BACKUP = CFG_LOGLEVEL_BACKUP, NDB_MGM_EVENT_CATEGORY_BACKUP = CFG_LOGLEVEL_BACKUP,
/**
* Congestion related log events
*/
NDB_MGM_EVENT_CATEGORY_CONGESTION = CFG_LOGLEVEL_CONGESTION,
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
/** /**
* Loglevel debug * Loglevel debug
*/ */
NDB_MGM_EVENT_CATEGORY_DEBUG = CFG_LOGLEVEL_DEBUG, NDB_MGM_EVENT_CATEGORY_DEBUG = CFG_LOGLEVEL_DEBUG,
#endif
/** /**
* Loglevel info * Uncategorized log events (severity info)
*/ */
NDB_MGM_EVENT_CATEGORY_INFO = CFG_LOGLEVEL_INFO, NDB_MGM_EVENT_CATEGORY_INFO = CFG_LOGLEVEL_INFO,
/** /**
* Loglevel warning * Uncategorized log events (severity warning or higher)
*/
NDB_MGM_EVENT_CATEGORY_WARNING = CFG_LOGLEVEL_WARNING,
/**
* Loglevel error
*/ */
NDB_MGM_EVENT_CATEGORY_ERROR = CFG_LOGLEVEL_ERROR, NDB_MGM_EVENT_CATEGORY_ERROR = CFG_LOGLEVEL_ERROR,
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
/**
*
*/
NDB_MGM_EVENT_CATEGORY_GREP = CFG_LOGLEVEL_GREP,
#endif
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL #ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
NDB_MGM_MIN_EVENT_CATEGORY = CFG_MIN_LOGLEVEL, NDB_MGM_MIN_EVENT_CATEGORY = CFG_MIN_LOGLEVEL,
NDB_MGM_MAX_EVENT_CATEGORY = CFG_MAX_LOGLEVEL NDB_MGM_MAX_EVENT_CATEGORY = CFG_MAX_LOGLEVEL
@ -424,7 +446,8 @@ extern "C" {
*/ */
/** /**
* Get latest error associated with a management server handle * Get the most recent error associated with the management server whose handle
* is used as the value of <var>handle</var>.
* *
* @param handle Management handle * @param handle Management handle
* @return Latest error code * @return Latest error code
@ -432,7 +455,7 @@ extern "C" {
int ndb_mgm_get_latest_error(const NdbMgmHandle handle); int ndb_mgm_get_latest_error(const NdbMgmHandle handle);
/** /**
* Get latest main error message associated with a handle * Get the most recent general error message associated with a handle
* *
* @param handle Management handle. * @param handle Management handle.
* @return Latest error message * @return Latest error message
@ -440,9 +463,9 @@ extern "C" {
const char * ndb_mgm_get_latest_error_msg(const NdbMgmHandle handle); const char * ndb_mgm_get_latest_error_msg(const NdbMgmHandle handle);
/** /**
* Get latest error description associated with a handle * Get the most recent error description associated with a handle
* *
* The error description gives some additional information to * The error description gives some additional information regarding
* the error message. * the error message.
* *
* @param handle Management handle. * @param handle Management handle.
@ -452,7 +475,7 @@ extern "C" {
#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED #ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
/** /**
* Get latest internal source code error line associated with a handle * Get the most recent internal source code error line associated with a handle
* *
* @param handle Management handle. * @param handle Management handle.
* @return Latest internal source code line of latest error * @return Latest internal source code line of latest error
@ -468,15 +491,15 @@ extern "C" {
*/ */
/** /**
* Create a handle to a management server * Create a handle to a management server.
* *
* @return A management handle<br> * @return A management handle<br>
* or NULL if no management handle could be created. * or <var>NULL</var> if no management handle could be created.
*/ */
NdbMgmHandle ndb_mgm_create_handle(); NdbMgmHandle ndb_mgm_create_handle();
/** /**
* Destroy a management server handle * Destroy a management server handle.
* *
* @param handle Management handle * @param handle Management handle
*/ */
@ -489,7 +512,7 @@ extern "C" {
*/ */
/** /**
* Set connect string to management server * Sets the connectstring for a management server
* *
* @param handle Management handle * @param handle Management handle
* @param connect_string Connect string to the management server, * @param connect_string Connect string to the management server,
@ -500,38 +523,47 @@ extern "C" {
* <connectstring> := [<nodeid-specification>,]<host-specification>[,<host-specification>] * <connectstring> := [<nodeid-specification>,]<host-specification>[,<host-specification>]
* <nodeid-specification> := nodeid=<id> * <nodeid-specification> := nodeid=<id>
* <host-specification> := <host>[:<port>] * <host-specification> := <host>[:<port>]
* <id> is an integer larger than 1 identifying a node in config.ini * <id> is an integer greater than 0 identifying a node in config.ini
* <port> is an integer referring to a regular unix port * <port> is an integer referring to a regular unix port
* <host> is a string which is a valid Internet host address * <host> is a string containing a valid network host address
* @endcode * @endcode
*/ */
int ndb_mgm_set_connectstring(NdbMgmHandle handle, int ndb_mgm_set_connectstring(NdbMgmHandle handle,
const char *connect_string); const char *connect_string);
/** /**
* Get connectstring used for connection * Gets the connectstring used for a connection
* *
* @note returns what the connectstring defaults to if the * @note This function returns the default connectstring if no call to
* ndb_mgm_set_connectstring() call has not been performed * ndb_mgm_set_connectstring() has been performed. Also, the
* returned connectstring may be formatted differently.
* *
* @param handle Management handle * @param handle Management handle
* @param buf Buffer to hold result
* @param buf_sz Size of buffer.
* *
* @return connectstring * @return connectstring (same as <var>buf</var>)
*/ */
const char *ndb_mgm_get_connectstring(NdbMgmHandle handle, char *buf, int buf_sz); const char *ndb_mgm_get_connectstring(NdbMgmHandle handle, char *buf, int buf_sz);
/** /**
* Connect to a management server. Coonect string is set by * Connects to a management server. Connectstring is set by
* ndb_mgm_set_connectstring(). * ndb_mgm_set_connectstring().
* *
* @param handle Management handle. * @param handle Management handle.
* @param no_retries Number of retries to connect
* (0 means connect once).
* @param retry_delay_in_seconds
* How long to wait until retry is performed.
* @param verbose Make printout regarding connect retries.
*
* @return -1 on error. * @return -1 on error.
*/ */
int ndb_mgm_connect(NdbMgmHandle handle, int no_retries, int ndb_mgm_connect(NdbMgmHandle handle, int no_retries,
int retry_delay_in_seconds, int verbose); int retry_delay_in_seconds, int verbose);
/** /**
* Disconnect from a management server * Disconnects from a management server
* *
* @param handle Management handle. * @param handle Management handle.
* @return -1 on error. * @return -1 on error.
@ -539,17 +571,17 @@ extern "C" {
int ndb_mgm_disconnect(NdbMgmHandle handle); int ndb_mgm_disconnect(NdbMgmHandle handle);
/** /**
* Get nodeid used in the connection * Gets connection node ID
* *
* @param handle Management handle * @param handle Management handle
* *
* @return node id, 0 indicated that no nodeid has been * @return Node ID; 0 indicates that no node ID has been
* specified * specified
*/ */
int ndb_mgm_get_configuration_nodeid(NdbMgmHandle handle); int ndb_mgm_get_configuration_nodeid(NdbMgmHandle handle);
/** /**
* Get port used in the connection * Gets connection port
* *
* @param handle Management handle * @param handle Management handle
* *
@ -558,7 +590,7 @@ extern "C" {
int ndb_mgm_get_connected_port(NdbMgmHandle handle); int ndb_mgm_get_connected_port(NdbMgmHandle handle);
/** /**
* Get host used in the connection * Gets connection host
* *
* @param handle Management handle * @param handle Management handle
* *
@ -569,12 +601,12 @@ extern "C" {
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL #ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
/** @} *********************************************************************/ /** @} *********************************************************************/
/** /**
* @name Functions: Convert between different data formats * @name Functions: Used to convert between different data formats
* @{ * @{
*/ */
/** /**
* Convert a string to a ndb_mgm_node_type * Converts a string to an <var>ndb_mgm_node_type</var> value
* *
* @param type Node type as string. * @param type Node type as string.
* @return NDB_MGM_NODE_TYPE_UNKNOWN if invalid string. * @return NDB_MGM_NODE_TYPE_UNKNOWN if invalid string.
@ -582,24 +614,24 @@ extern "C" {
enum ndb_mgm_node_type ndb_mgm_match_node_type(const char * type); enum ndb_mgm_node_type ndb_mgm_match_node_type(const char * type);
/** /**
* Convert an ndb_mgm_node_type to a string * Converts an ndb_mgm_node_type to a string
* *
* @param type Node type. * @param type Node type.
* @return NULL if invalid id. * @return <var>NULL</var> if invalid ID.
*/ */
const char * ndb_mgm_get_node_type_string(enum ndb_mgm_node_type type); const char * ndb_mgm_get_node_type_string(enum ndb_mgm_node_type type);
/** /**
* Convert an ndb_mgm_node_type to a alias string * Converts an ndb_mgm_node_type to a alias string
* *
* @param type Node type. * @param type Node type.
* @return NULL if invalid id. * @return <var>NULL</var> if the ID is invalid.
*/ */
const char * ndb_mgm_get_node_type_alias_string(enum ndb_mgm_node_type type, const char * ndb_mgm_get_node_type_alias_string(enum ndb_mgm_node_type type,
const char **str); const char **str);
/** /**
* Convert a string to a ndb_mgm_node_status * Converts a string to a <var>ndb_mgm_node_status</var> value
* *
* @param status NDB node status string. * @param status NDB node status string.
* @return NDB_MGM_NODE_STATUS_UNKNOWN if invalid string. * @return NDB_MGM_NODE_STATUS_UNKNOWN if invalid string.
@ -607,32 +639,32 @@ extern "C" {
enum ndb_mgm_node_status ndb_mgm_match_node_status(const char * status); enum ndb_mgm_node_status ndb_mgm_match_node_status(const char * status);
/** /**
* Convert an id to a string * Converts an ID to a string
* *
* @param status NDB node status. * @param status NDB node status.
* @return NULL if invalid id. * @return <var>NULL</var> if invalid ID.
*/ */
const char * ndb_mgm_get_node_status_string(enum ndb_mgm_node_status status); const char * ndb_mgm_get_node_status_string(enum ndb_mgm_node_status status);
const char * ndb_mgm_get_clusterlog_level_string(enum ndb_mgm_clusterlog_level); const char * ndb_mgm_get_event_severity_string(enum ndb_mgm_event_severity);
ndb_mgm_event_category ndb_mgm_match_event_category(const char *); ndb_mgm_event_category ndb_mgm_match_event_category(const char *);
const char * ndb_mgm_get_event_category_string(enum ndb_mgm_event_category); const char * ndb_mgm_get_event_category_string(enum ndb_mgm_event_category);
#endif #endif
/** @} *********************************************************************/ /** @} *********************************************************************/
/** /**
* @name Functions: State of cluster * @name Functions: Cluster status
* @{ * @{
*/ */
/** /**
* Get status of the nodes in an NDB Cluster * Gets status of the nodes in an NDB Cluster
* *
* Note the caller must free the pointer returned. * @note The caller must free the pointer returned by this function.
* *
* @param handle Management handle. * @param handle Management handle.
* *
* @return Cluster state (or NULL on error). * @return Cluster state (or <var>NULL</var> on error).
*/ */
struct ndb_mgm_cluster_state * ndb_mgm_get_status(NdbMgmHandle handle); struct ndb_mgm_cluster_state * ndb_mgm_get_status(NdbMgmHandle handle);
@ -643,36 +675,36 @@ extern "C" {
*/ */
/** /**
* Stop database nodes * Stops database nodes
* *
* @param handle Management handle. * @param handle Management handle.
* @param no_of_nodes no of database nodes<br> * @param no_of_nodes Number of database nodes to be stopped<br>
* 0 - means all database nodes in cluster<br> * 0: All database nodes in cluster<br>
* n - Means stop n node(s) specified in the * n: Stop the <var>n</var> node(s) specified in the
* array node_list * array node_list
* @param node_list List of node ids of database nodes to be stopped * @param node_list List of node IDs for database nodes to be stopped
* *
* @return No of nodes stopped (or -1 on error) * @return Number of nodes stopped (-1 on error)
* *
* @note The function is equivalent * @note This function is equivalent
* to ndb_mgm_stop2(handle, no_of_nodes, node_list, 0) * to calling ndb_mgm_stop2(handle, no_of_nodes, node_list, 0)
*/ */
int ndb_mgm_stop(NdbMgmHandle handle, int no_of_nodes, int ndb_mgm_stop(NdbMgmHandle handle, int no_of_nodes,
const int * node_list); const int * node_list);
/** /**
* Stop database nodes * Stops database nodes
* *
* @param handle Management handle. * @param handle Management handle.
* @param no_of_nodes No of database nodes<br> * @param no_of_nodes Number of database nodes to stop<br>
* 0 - means all database nodes in cluster<br> * 0: All database nodes in cluster<br>
* n - Means stop n node(s) specified in * n: Stop the <var>n</var> node(s) specified in
* the array node_list * the array node_list
* @param node_list List of node ids of database nodes to be stopped * @param node_list List of node IDs of database nodes to be stopped
* @param abort Don't perform gracefull stop, * @param abort Don't perform graceful stop,
* but rather stop immediatly * but rather stop immediately
* *
* @return No of nodes stopped (or -1 on error). * @return Number of nodes stopped (-1 on error).
*/ */
int ndb_mgm_stop2(NdbMgmHandle handle, int no_of_nodes, int ndb_mgm_stop2(NdbMgmHandle handle, int no_of_nodes,
const int * node_list, int abort); const int * node_list, int abort);
@ -681,15 +713,15 @@ extern "C" {
* Restart database nodes * Restart database nodes
* *
* @param handle Management handle. * @param handle Management handle.
* @param no_of_nodes No of database nodes<br> * @param no_of_nodes Number of database nodes to restart<br>
* 0 - means all database nodes in cluster<br> * 0: All database nodes in cluster<br>
* n - Means stop n node(s) specified in the * n: Restart the <var>n</var> node(s) specified in the
* array node_list * array node_list
* @param node_list List of node ids of database nodes to be stopped * @param node_list List of node IDs of database nodes to be restarted
* *
* @return No of nodes stopped (or -1 on error). * @return Number of nodes restarted (-1 on error).
* *
* @note The function is equivalent to * @note This function is equivalent to calling
* ndb_mgm_restart2(handle, no_of_nodes, node_list, 0, 0, 0); * ndb_mgm_restart2(handle, no_of_nodes, node_list, 0, 0, 0);
*/ */
int ndb_mgm_restart(NdbMgmHandle handle, int no_of_nodes, int ndb_mgm_restart(NdbMgmHandle handle, int no_of_nodes,
@ -699,18 +731,18 @@ extern "C" {
* Restart database nodes * Restart database nodes
* *
* @param handle Management handle. * @param handle Management handle.
* @param no_of_nodes No of database nodes<br> * @param no_of_nodes Number of database nodes to be restarted:<br>
* 0 - means all database nodes in cluster<br> * 0: Restart all database nodes in the cluster<br>
* n - Means stop n node(s) specified in the * n: Restart the <var>n</var> node(s) specified in the
* array node_list * array node_list
* @param node_list List of node ids of database nodes to be stopped * @param node_list List of node IDs of database nodes to be restarted
* @param initial Remove filesystem from node(s) restarting * @param initial Remove filesystem from restarting node(s)
* @param nostart Don't actually start node(s) but leave them * @param nostart Don't actually start node(s) but leave them
* waiting for start command * waiting for start command
* @param abort Don't perform gracefull restart, * @param abort Don't perform graceful restart,
* but rather restart immediatly * but rather restart immediately
* *
* @return No of nodes stopped (or -1 on error). * @return Number of nodes stopped (-1 on error).
*/ */
int ndb_mgm_restart2(NdbMgmHandle handle, int no_of_nodes, int ndb_mgm_restart2(NdbMgmHandle handle, int no_of_nodes,
const int * node_list, int initial, const int * node_list, int initial,
@ -720,19 +752,19 @@ extern "C" {
* Start database nodes * Start database nodes
* *
* @param handle Management handle. * @param handle Management handle.
* @param no_of_nodes No of database nodes<br> * @param no_of_nodes Number of database nodes to be started<br>
* 0 - means all database nodes in cluster<br> * 0: Start all database nodes in the cluster<br>
* n - Means start n node(s) specified in * n: Start the <var>n</var> node(s) specified in
* the array node_list * the array node_list
* @param node_list List of node ids of database nodes to be started * @param node_list List of node IDs of database nodes to be started
* *
* @return No of nodes started (or -1 on error). * @return Number of nodes actually started (-1 on error).
* *
* @note The nodes to start must have been started with nostart(-n) * @note The nodes to be started must have been started with nostart(-n)
* argument. * argument.
* This means that the database node binary is started and * This means that the database node binary is started and
* waiting for a START management command which will * waiting for a START management command which will
* actually start the database node functionality * actually enable the database node
*/ */
int ndb_mgm_start(NdbMgmHandle handle, int ndb_mgm_start(NdbMgmHandle handle,
int no_of_nodes, int no_of_nodes,
@ -740,75 +772,83 @@ extern "C" {
/** @} *********************************************************************/ /** @} *********************************************************************/
/** /**
* @name Functions: Logging * @name Functions: Controlling Clusterlog output
* @{ * @{
*/ */
/** /**
* Filter cluster log * Filter cluster log severities
* *
* @param handle NDB management handle. * @param handle NDB management handle.
* @param level A cluster log level to filter. * @param severity A cluster log severity to filter.
* @param enable set 1=enable 0=disable * @param enable set 1=enable o 0=disable
* @param reply Reply message. * @param reply Reply message.
* *
* @return -1 on error. * @return -1 on error.
*/ */
int ndb_mgm_filter_clusterlog(NdbMgmHandle handle, int ndb_mgm_set_clusterlog_severity_filter(NdbMgmHandle handle,
enum ndb_mgm_clusterlog_level level, enum ndb_mgm_event_severity severity,
int enable, int enable,
struct ndb_mgm_reply* reply); struct ndb_mgm_reply* reply);
/** /**
* Get log filter * Get clusterlog severity filter
* *
* @param handle NDB management handle * @param handle NDB management handle
* *
* @return A vector of seven elements, * @return A vector of seven elements,
* where each element contains * where each element contains
* 1 if a severity is enabled and 0 if not. * 1 if a severity indicator is enabled and 0 if not.
* A severity is stored at position * A severity level is stored at position
* ndb_mgm_clusterlog_level, * ndb_mgm_clusterlog_level;
* for example the "error" level is stored in position * for example the "error" level is stored in position
* [NDB_MGM_CLUSTERLOG_ERROR-1]. * [NDB_MGM_EVENT_SEVERITY_ERROR].
* The first element in the vector signals * The first element [NDB_MGM_EVENT_SEVERITY_ON] in
* whether the clusterlog * the vector signals
* whether the cluster log
* is disabled or enabled. * is disabled or enabled.
*/ */
unsigned int *ndb_mgm_get_logfilter(NdbMgmHandle handle); const unsigned int *ndb_mgm_get_clusterlog_severity_filter(NdbMgmHandle handle);
/** /**
* Set log category and levels for the cluster log * Set log category and levels for the cluster log
* *
* @param handle NDB management handle. * @param handle NDB management handle.
* @param nodeId Node id. * @param nodeId Node ID.
* @param category Event category. * @param category Event category.
* @param level Log level (0-15). * @param level Log level (0-15).
* @param reply Reply message. * @param reply Reply message.
* @return -1 on error. * @return -1 on error.
*/ */
int ndb_mgm_set_loglevel_clusterlog(NdbMgmHandle handle, int ndb_mgm_set_clusterlog_loglevel(NdbMgmHandle handle,
int nodeId, int nodeId,
enum ndb_mgm_event_category category, enum ndb_mgm_event_category category,
int level, int level,
struct ndb_mgm_reply* reply); struct ndb_mgm_reply* reply);
/** @} *********************************************************************/
/** /**
* Listen to log events * @name Functions: Listening to log events
* * @{
* @param filter pairs of { level, ndb_mgm_event_category } that will be
* pushed to fd, level=0 ends lists
*
* @return fd which events will be pushed to
*/ */
int ndb_mgm_listen_event(NdbMgmHandle handle, int filter[]);
/**
* Listen to log events. They are read from the return file descriptor
* and the format is textual, and the same as in the cluster log.
*
* @param handle NDB management handle.
* @param filter pairs of { level, ndb_mgm_event_category } that will be
* pushed to fd, level=0 ends list.
*
* @return fd filedescriptor to read events from
*/
int ndb_mgm_listen_event(NdbMgmHandle handle, const int filter[]);
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL #ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
/** /**
* Set log category and levels for the Node * Set log category and levels for the Node
* *
* @param handle NDB management handle. * @param handle NDB management handle.
* @param nodeId Node id. * @param nodeId Node ID.
* @param category Event category. * @param category Event category.
* @param level Log level (0-15). * @param level Log level (0-15).
* @param reply Reply message. * @param reply Reply message.
@ -840,13 +880,13 @@ extern "C" {
/** /**
* Start backup * Start backup
* *
* @param handle NDB management handle. * @param handle NDB management handle.
* @param wait_completed 0=don't wait for confirmation, * @param wait_completed 0: Don't wait for confirmation<br>
* 1=wait for backup started, * 1: Wait for backup to be started<br>
* 2=wait for backup completed * 2: Wait for backup to be completed
* @param backup_id Backup id is returned from function. * @param backup_id Backup ID is returned from function.
* @param reply Reply message. * @param reply Reply message.
* @return -1 on error. * @return -1 on error.
*/ */
int ndb_mgm_start_backup(NdbMgmHandle handle, int wait_completed, int ndb_mgm_start_backup(NdbMgmHandle handle, int wait_completed,
unsigned int* backup_id, unsigned int* backup_id,
@ -856,7 +896,7 @@ extern "C" {
* Abort backup * Abort backup
* *
* @param handle NDB management handle. * @param handle NDB management handle.
* @param backup_id Backup Id. * @param backup_id Backup ID.
* @param reply Reply message. * @param reply Reply message.
* @return -1 on error. * @return -1 on error.
*/ */
@ -874,7 +914,7 @@ extern "C" {
* Enter Single user mode * Enter Single user mode
* *
* @param handle NDB management handle. * @param handle NDB management handle.
* @param nodeId Node Id of the single user node * @param nodeId Node ID of the single user node
* @param reply Reply message. * @param reply Reply message.
* @return -1 on error. * @return -1 on error.
*/ */
@ -885,7 +925,6 @@ extern "C" {
* Exit Single user mode * Exit Single user mode
* *
* @param handle NDB management handle. * @param handle NDB management handle.
* @param nodeId Node Id of the single user node
* @param reply Reply message. * @param reply Reply message.
* *
* @return -1 on error. * @return -1 on error.
@ -904,11 +943,11 @@ extern "C" {
* Get configuration * Get configuration
* @param handle NDB management handle. * @param handle NDB management handle.
* @param version Version of configuration, 0 means latest * @param version Version of configuration, 0 means latest
* (which is the only supported input at this point) * (Currently this is the only supported value for this parameter)
* *
* @return configuration * @return configuration
* *
* @note the caller must call ndb_mgm_destroy_configuration() * @note The caller is responsible for calling ndb_mgm_destroy_configuration()
*/ */
struct ndb_mgm_configuration * ndb_mgm_get_configuration(NdbMgmHandle handle, struct ndb_mgm_configuration * ndb_mgm_get_configuration(NdbMgmHandle handle,
unsigned version); unsigned version);
@ -941,6 +980,36 @@ extern "C" {
int ndb_mgm_check_connection(NdbMgmHandle handle); int ndb_mgm_check_connection(NdbMgmHandle handle);
#endif #endif
#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
enum ndb_mgm_clusterlog_level {
NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL = -1,
NDB_MGM_CLUSTERLOG_ON = 0,
NDB_MGM_CLUSTERLOG_DEBUG = 1,
NDB_MGM_CLUSTERLOG_INFO = 2,
NDB_MGM_CLUSTERLOG_WARNING = 3,
NDB_MGM_CLUSTERLOG_ERROR = 4,
NDB_MGM_CLUSTERLOG_CRITICAL = 5,
NDB_MGM_CLUSTERLOG_ALERT = 6,
NDB_MGM_CLUSTERLOG_ALL = 7
};
inline
int ndb_mgm_filter_clusterlog(NdbMgmHandle h,
enum ndb_mgm_clusterlog_level s,
int e, struct ndb_mgm_reply* r)
{ return ndb_mgm_set_clusterlog_severity_filter(h,(ndb_mgm_event_severity)s,
e,r); }
inline
const unsigned int *ndb_mgm_get_logfilter(NdbMgmHandle h)
{ return ndb_mgm_get_clusterlog_severity_filter(h); }
inline
int ndb_mgm_set_loglevel_clusterlog(NdbMgmHandle h, int n,
enum ndb_mgm_event_category c,
int l, struct ndb_mgm_reply* r)
{ return ndb_mgm_set_clusterlog_loglevel(h,n,c,l,r); }
#endif
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

2
ndb/include/mgmapi/mgmapi_config_parameters.h
View File

@ -94,7 +94,7 @@
#define CFG_LOGLEVEL_INFO 256 #define CFG_LOGLEVEL_INFO 256
#define CFG_LOGLEVEL_WARNING 257 #define CFG_LOGLEVEL_WARNING 257
#define CFG_LOGLEVEL_ERROR 258 #define CFG_LOGLEVEL_ERROR 258
#define CFG_LOGLEVEL_GREP 259 #define CFG_LOGLEVEL_CONGESTION 259
#define CFG_LOGLEVEL_DEBUG 260 #define CFG_LOGLEVEL_DEBUG 260
#define CFG_LOGLEVEL_BACKUP 261 #define CFG_LOGLEVEL_BACKUP 261
#define CFG_MAX_LOGLEVEL 261 #define CFG_MAX_LOGLEVEL 261

37
ndb/include/ndbapi/Ndb.hpp
View File

@ -51,20 +51,20 @@
The procedure for using transactions is as follows: The procedure for using transactions is as follows:
-# Start transaction (instantiate an NdbTransaction object) -# Start transaction (instantiate an NdbTransaction object)
-# Add and define operations associated with the transaction using the -# Add and define operations associated with the transaction using instances of one or more of the
NdbOperation, NdbScanOperation, NdbIndexOperation, and NdbIndexScanOperation classes. NdbOperation, NdbScanOperation, NdbIndexOperation, and NdbIndexScanOperation classes
-# Execute transaction -# Execute transaction (call NdbTransaction::execute())
The execution can be of two different types, The operation can be of two different types,
<var>Commit</var> or <var>NoCommit</var>. <var>Commit</var> or <var>NoCommit</var>.
If the execution is of type <var>NoCommit</var>, If the operation is of type <var>NoCommit</var>,
then the application program executes part of a transaction, then the application program executes the operation part of a transaction,
but without actually committing the transaction. but without actually committing the transaction.
After executing a <var>NoCommit</var> transaction, the program can continue After executing a <var>NoCommit</var> operation, the program can continue
to add and define more operations to the transaction to add and define more operations to the transaction
for later execution. for later execution.
If the execute is of type <var>Commit</var>, then the transaction is If the operation is of type <var>Commit</var>, then the transaction is
immediately committed. The transaction <em>must</em> be closed after it has been immediately committed. The transaction <em>must</em> be closed after it has been
commited (event if commit fails), and no further addition or definition of commited (event if commit fails), and no further addition or definition of
operations for this transaction is allowed. operations for this transaction is allowed.
@ -78,15 +78,16 @@
(typically created using Ndb::startTransaction()). (typically created using Ndb::startTransaction()).
At this point, the transaction is only being defined, At this point, the transaction is only being defined,
and is not yet sent to the NDB kernel. and is not yet sent to the NDB kernel.
-# Define operations and add them to the transaction, using -# Define operations and add them to the transaction, using one or more of
NdbTransaction::getNdbOperation(), - NdbTransaction::getNdbOperation()
NdbTransaction::getNdbScanOperation(), - NdbTransaction::getNdbScanOperation()
NdbTransaction::getNdbIndexOperation(), or - NdbTransaction::getNdbIndexOperation()
NdbTransaction::getNdbIndexScanOperation(), - NdbTransaction::getNdbIndexScanOperation()
and methods of the respective NdbOperation class. along with the appropriate methods of the respective NdbOperation class
(or one possiblt one or more of its subclasses).
Note that the transaction has still not yet been sent to the NDB kernel. Note that the transaction has still not yet been sent to the NDB kernel.
-# Execute the transaction, using the NdbTransaction::execute() method. -# Execute the transaction, using the NdbTransaction::execute() method.
-# Close the transaction (using Ndb::closeTransaction()). -# Close the transaction (call Ndb::closeTransaction()).
For an example of this process, see the program listing in For an example of this process, see the program listing in
@ref ndbapi_simple.cpp. @ref ndbapi_simple.cpp.
@ -506,7 +507,8 @@
are more frequent than each 10 ms, are more frequent than each 10 ms,
additional support from the operating system is required. additional support from the operating system is required.
-# For methods that are affected by the adaptive send alorithm -# For methods that are affected by the adaptive send alorithm
(such as NdbTransaction::execute()), there is a <var>force</var> parameter (such as NdbTransaction::execute()), there is a <var>force</var>
parameter
that overrides its default behaviour in this regard and forces that overrides its default behaviour in this regard and forces
immediate transmission to all nodes. See the inidvidual NDB API class immediate transmission to all nodes. See the inidvidual NDB API class
listings for more information. listings for more information.
@ -1344,10 +1346,9 @@ public:
int sendPollNdb(int aMillisecondNumber = WAITFOR_RESPONSE_TIMEOUT, int sendPollNdb(int aMillisecondNumber = WAITFOR_RESPONSE_TIMEOUT,
int minNoOfEventsToWakeup = 1, int minNoOfEventsToWakeup = 1,
int forceSend = 0); int forceSend = 0);
/** @} *********************************************************************/
#endif #endif
/** @} *********************************************************************/
/** /**
* @name Error Handling * @name Error Handling
* @{ * @{

22
ndb/include/ndbapi/NdbBlob.hpp
View File

@ -107,6 +107,9 @@ public:
Closed = 3, Closed = 3,
Invalid = 9 Invalid = 9
}; };
/**
* Get the state of a NdbBlob object.
*/
State getState(); State getState();
/** /**
* Inline blob header. * Inline blob header.
@ -116,7 +119,7 @@ public:
}; };
/** /**
* Prepare to read blob value. The value is available after execute. * Prepare to read blob value. The value is available after execute.
* Use getNull to check for NULL and getLength to get the real length * Use getNull() to check for NULL and getLength() to get the real length
* and to check for truncation. Sets current read/write position to * and to check for truncation. Sets current read/write position to
* after the data read. * after the data read.
*/ */
@ -129,10 +132,10 @@ public:
*/ */
int setValue(const void* data, Uint32 bytes); int setValue(const void* data, Uint32 bytes);
/** /**
* Callback for setActiveHook. Invoked immediately when the prepared * Callback for setActiveHook(). Invoked immediately when the prepared
* operation has been executed (but not committed). Any getValue or * operation has been executed (but not committed). Any getValue() or
* setValue is done first. The blob handle is active so readData or * setValue() is done first. The blob handle is active so readData or
* writeData etc can be used to manipulate blob value. A user-defined * writeData() etc can be used to manipulate blob value. A user-defined
* argument is passed along. Returns non-zero on error. * argument is passed along. Returns non-zero on error.
*/ */
typedef int ActiveHook(NdbBlob* me, void* arg); typedef int ActiveHook(NdbBlob* me, void* arg);
@ -195,10 +198,15 @@ public:
const NdbError& getNdbError() const; const NdbError& getNdbError() const;
/** /**
* Return info about all blobs in this operation. * Return info about all blobs in this operation.
*
* Get first blob in list.
*/ */
// Get first blob in list
NdbBlob* blobsFirstBlob(); NdbBlob* blobsFirstBlob();
// Get next blob in list after this one /**
* Return info about all blobs in this operation.
*
* Get next blob in list. Initialize with blobsFirstBlob().
*/
NdbBlob* blobsNextBlob(); NdbBlob* blobsNextBlob();
private: private:

40
ndb/include/ndbapi/NdbDictionary.hpp
View File

@ -631,7 +631,7 @@ public:
* Assignment operator, deep copy * Assignment operator, deep copy
* @param table Table to be copied * @param table Table to be copied
*/ */
Table& operator=(const Table&); Table& operator=(const Table& table);
/** /**
* Name of table * Name of table
@ -946,12 +946,12 @@ public:
#endif #endif
}; };
/* /**
* Constructor * Constructor
* @param name Name of event * @param name Name of event
*/ */
Event(const char *name); Event(const char *name);
/* /**
* Constructor * Constructor
* @param name Name of event * @param name Name of event
* @param table Reference retrieved from NdbDictionary * @param table Reference retrieved from NdbDictionary
@ -994,9 +994,12 @@ public:
*/ */
void addTableEvent(const TableEvent te); void addTableEvent(const TableEvent te);
/** /**
* Get/set durability of the event * Set durability of the event
*/
void setDurability(EventDurability);
/**
* Get durability of the event
*/ */
void setDurability(EventDurability ed);
EventDurability getDurability() const; EventDurability getDurability() const;
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL #ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
void addColumn(const Column &c); void addColumn(const Column &c);
@ -1116,6 +1119,13 @@ public:
/** /**
* Fetch list of all objects, optionally restricted to given type. * Fetch list of all objects, optionally restricted to given type.
*
* @param list List of objects returned in the dictionary
* @param type Restrict returned list to only contain objects of
* this type
*
* @return -1 if error.
*
*/ */
int listObjects(List & list, Object::Type type = Object::TypeUndefined); int listObjects(List & list, Object::Type type = Object::TypeUndefined);
int listObjects(List & list, int listObjects(List & list,
@ -1168,10 +1178,10 @@ public:
/** /**
* Create event given defined Event instance * Create event given defined Event instance
* @param Event to create * @param event Event to create
* @return 0 if successful otherwise -1. * @return 0 if successful otherwise -1.
*/ */
int createEvent(const Event &); int createEvent(const Event &event);
/** /**
* Drop event with given name * Drop event with given name
@ -1199,17 +1209,17 @@ public:
/** /**
* Create defined table given defined Table instance * Create defined table given defined Table instance
* @param Table Table to create * @param table Table to create
* @return 0 if successful otherwise -1. * @return 0 if successful otherwise -1.
*/ */
int createTable(const Table &); int createTable(const Table &table);
/** /**
* Drop table given retrieved Table instance * Drop table given retrieved Table instance
* @param Table Table to drop * @param table Table to drop
* @return 0 if successful otherwise -1. * @return 0 if successful otherwise -1.
*/ */
int dropTable(Table &); int dropTable(Table & table);
/** /**
* Drop table given table name * Drop table given table name
@ -1220,12 +1230,12 @@ public:
/** /**
* Alter defined table given defined Table instance * Alter defined table given defined Table instance
* @param Table Table to alter * @param table Table to alter
* @return -2 (incompatible version) <br> * @return -2 (incompatible version) <br>
* -1 general error <br> * -1 general error <br>
* 0 success * 0 success
*/ */
int alterTable(const Table &); int alterTable(const Table &table);
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL #ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
/** /**
@ -1257,10 +1267,10 @@ public:
/** /**
* Create index given defined Index instance * Create index given defined Index instance
* @param Index to create * @param index Index to create
* @return 0 if successful otherwise -1. * @return 0 if successful otherwise -1.
*/ */
int createIndex(const Index &); int createIndex(const Index &index);
/** /**
* Drop index with given name * Drop index with given name

2
ndb/include/ndbapi/NdbError.hpp
View File

@ -204,6 +204,7 @@ struct NdbError {
*/ */
char * details; char * details;
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
NdbError(){ NdbError(){
status = UnknownResult; status = UnknownResult;
classification = NoError; classification = NoError;
@ -227,6 +228,7 @@ struct NdbError {
ndberror.details = details; ndberror.details = details;
return ndberror; return ndberror;
} }
#endif
}; };
class NdbOut& operator <<(class NdbOut&, const NdbError &); class NdbOut& operator <<(class NdbOut&, const NdbError &);

5
ndb/include/ndbapi/NdbEventOperation.hpp
View File

@ -132,7 +132,7 @@ public:
* next() has returned a value greater than * next() has returned a value greater than
* zero. If a specific attribute has not changed the corresponding * zero. If a specific attribute has not changed the corresponding
* NdbRecAttr will be in state UNDEFINED. This is checked by * NdbRecAttr will be in state UNDEFINED. This is checked by
* NdbRecAttr::isNull() which then returns -1. * NdbRecAttr::isNULL() which then returns -1.
* *
* @param anAttrName Attribute name * @param anAttrName Attribute name
* @param aValue If this is non-NULL, then the attribute value * @param aValue If this is non-NULL, then the attribute value
@ -144,6 +144,9 @@ public:
* (indicating error). * (indicating error).
*/ */
NdbRecAttr *getValue(const char *anAttrName, char *aValue = 0); NdbRecAttr *getValue(const char *anAttrName, char *aValue = 0);
/**
* See getValue().
*/
NdbRecAttr *getPreValue(const char *anAttrName, char *aValue = 0); NdbRecAttr *getPreValue(const char *anAttrName, char *aValue = 0);
/** /**

7
ndb/include/ndbapi/NdbIndexScanOperation.hpp
View File

@ -45,7 +45,7 @@ public:
* @returns 0 for success and -1 for failure * @returns 0 for success and -1 for failure
* @see NdbScanOperation::readTuples * @see NdbScanOperation::readTuples
*/ */
int readTuples(LockMode = LM_Read, int readTuples(LockMode lock_mode = LM_Read,
Uint32 batch = 0, Uint32 batch = 0,
Uint32 parallel = 0, Uint32 parallel = 0,
bool order_by = false, bool order_by = false,
@ -90,15 +90,14 @@ public:
* An index stores also all-NULL keys. Doing index scan with empty * An index stores also all-NULL keys. Doing index scan with empty
* bound set returns all table tuples. * bound set returns all table tuples.
* *
* @param attrName Attribute name, alternatively: * @param attr Attribute name, alternatively:
* @param anAttrId Index column id (starting from 0)
* @param type Type of bound * @param type Type of bound
* @param value Pointer to bound value, 0 for NULL * @param value Pointer to bound value, 0 for NULL
* @param len Value length in bytes. * @param len Value length in bytes.
* Fixed per datatype and can be omitted * Fixed per datatype and can be omitted
* @return 0 if successful otherwise -1 * @return 0 if successful otherwise -1
*/ */
int setBound(const char* attr, int type, const void* aValue, Uint32 len = 0); int setBound(const char* attr, int type, const void* value, Uint32 len = 0);
/** /**
* Define bound on index key in range scan using index column id. * Define bound on index key in range scan using index column id.

3
ndb/include/ndbapi/NdbOperation.hpp
View File

@ -966,6 +966,7 @@ protected:
#include <stdlib.h> #include <stdlib.h>
#endif #endif
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
inline inline
int int
@ -1215,4 +1216,6 @@ NdbOperation::setValue(Uint32 anAttrId, double aPar)
return setValue(anAttrId, (const char*)&aPar, (Uint32)8); return setValue(anAttrId, (const char*)&aPar, (Uint32)8);
} }
#endif // doxygen
#endif #endif

4
ndb/include/ndbapi/NdbRecAttr.hpp
View File

@ -281,6 +281,8 @@ private:
const NdbDictionary::Column* m_column; const NdbDictionary::Column* m_column;
}; };
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
inline inline
NdbDictionary::Column::Type NdbDictionary::Column::Type
NdbRecAttr::getType() const { NdbRecAttr::getType() const {
@ -457,5 +459,7 @@ NdbRecAttr::isNULL() const
class NdbOut& operator <<(class NdbOut&, const NdbRecAttr &); class NdbOut& operator <<(class NdbOut&, const NdbRecAttr &);
#endif // ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
#endif #endif

17
ndb/include/ndbapi/NdbScanOperation.hpp
View File

@ -70,7 +70,8 @@ public:
* NdbOperation::getValue are updated with values * NdbOperation::getValue are updated with values
* from the scanned tuple. * from the scanned tuple.
* *
* @param fetchAllowed If set to false, then fetching is disabled * @param fetchAllowed If set to false, then fetching is disabled
* @param forceSend If true send will occur immediately (see @ref secAdapt)
* *
* The NDB API will contact the NDB Kernel for more tuples * The NDB API will contact the NDB Kernel for more tuples
* when necessary to do so unless you set the fetchAllowed * when necessary to do so unless you set the fetchAllowed
@ -122,6 +123,13 @@ public:
* @return an NdbOperation or NULL. * @return an NdbOperation or NULL.
*/ */
NdbOperation* updateCurrentTuple(); NdbOperation* updateCurrentTuple();
/**
* Update current tuple
*
* @param updateTrans Transaction that should perform the update
*
* @return an NdbOperation or NULL.
*/
NdbOperation* updateCurrentTuple(NdbTransaction* updateTrans); NdbOperation* updateCurrentTuple(NdbTransaction* updateTrans);
/** /**
@ -129,6 +137,13 @@ public:
* @return 0 on success or -1 on failure * @return 0 on success or -1 on failure
*/ */
int deleteCurrentTuple(); int deleteCurrentTuple();
/**
* Delete current tuple
*
* @param takeOverTransaction Transaction that should perform the delete
*
* @return 0 on success or -1 on failure
*/
int deleteCurrentTuple(NdbTransaction* takeOverTransaction); int deleteCurrentTuple(NdbTransaction* takeOverTransaction);
/** /**

4
ndb/include/ndbapi/NdbTransaction.hpp
View File

@ -796,6 +796,8 @@ private:
void define_scan_op(NdbIndexScanOperation*); void define_scan_op(NdbIndexScanOperation*);
}; };
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
inline inline
Uint32 Uint32
NdbTransaction::get_send_size() NdbTransaction::get_send_size()
@ -1034,4 +1036,6 @@ NdbTransaction::ptr2int(){
typedef NdbTransaction NdbConnection; typedef NdbTransaction NdbConnection;
#endif // ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
#endif #endif

51
ndb/include/ndbapi/ndb_cluster_connection.hpp
View File

@ -20,39 +20,42 @@
/** /**
* @class Ndb_cluster_connection * @class Ndb_cluster_connection
* @brief Represents a connection to a cluster of storage nodes * @brief Represents a connection to a cluster of storage nodes.
* *
* Always start your application program by creating a * Any NDB application program should begin with the creation of a
* Ndb_cluster_connection object. Your application should contain * single Ndb_cluster_connection object, and should make use of one
* only one Ndb_cluster_connection. Your application connects to * and only one Ndb_cluster_connection. The application connects to
* a cluster management server when method connect() is called. * a cluster management server when this object's connect() method is called.
* With the method wait_until_ready() it is possible to wait * By using the wait_until_ready() method it is possible to wait
* for the connection to one or several storage nodes. * for the connection to reach one or more storage nodes.
*/ */
class Ndb_cluster_connection { class Ndb_cluster_connection {
public: public:
/** /**
* Create a connection to a cluster of storage nodes * Create a connection to a cluster of storage nodes
* *
* @param specify the connectstring for where to find the * @param connectstring The connectstring for where to find the
* management server * management server
*/ */
Ndb_cluster_connection(const char * connect_string = 0); Ndb_cluster_connection(const char * connectstring = 0);
~Ndb_cluster_connection(); ~Ndb_cluster_connection();
/** /**
* Connect to a cluster management server * Connect to a cluster management server
* *
* @param no_retries specifies the number of retries to perform * @param no_retries specifies the number of retries to attempt
* if the connect fails, negative number results in infinite * in the event of connection failure; a negative value
* number of retries * will result in the attempt to connect being repeated
* indefinitely
*
* @param retry_delay_in_seconds specifies how often retries should * @param retry_delay_in_seconds specifies how often retries should
* be performed * be performed
* @param verbose specifies if the method should print progess
* *
* @return 0 if success, * @param verbose specifies if the method should print a report of its progess
* 1 if retriable error, *
* -1 if non-retriable error * @return 0 = success,
* 1 = recoverable error,
* -1 = non-recoverable error
*/ */
int connect(int no_retries=0, int retry_delay_in_seconds=1, int verbose=0); int connect(int no_retries=0, int retry_delay_in_seconds=1, int verbose=0);
@ -61,15 +64,15 @@ public:
#endif #endif
/** /**
* Wait until one or several storage nodes are connected * Wait until the requested connection with one or more storage nodes is successful
* *
* @param time_out_for_first_alive number of seconds to wait until * @param timeout_for_first_alive Number of seconds to wait until
* first alive node is detected * first live node is detected
* @param timeout_after_first_alive number of seconds to wait after * @param timeout_after_first_alive Number of seconds to wait after
* first alive node is detected * first live node is detected
* *
* @return 0 all nodes alive, * @return = 0 all nodes live,
* > 0 at least one node alive, * > 0 at least one node live,
* < 0 error * < 0 error
*/ */
int wait_until_ready(int timeout_for_first_alive, int wait_until_ready(int timeout_for_first_alive,

4
ndb/include/ndbapi/ndberror.h
View File

@ -21,6 +21,8 @@
extern "C" { extern "C" {
#endif #endif
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
typedef enum typedef enum
{ {
ndberror_st_success = 0, ndberror_st_success = 0,
@ -93,6 +95,8 @@ const char *ndberror_classification_message(ndberror_classification);
void ndberror_update(ndberror_struct *); void ndberror_update(ndberror_struct *);
int ndb_error_string(int err_no, char *str, unsigned int size); int ndb_error_string(int err_no, char *str, unsigned int size);
#endif /* doxygen skip internal*/
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

4
ndb/src/common/debugger/EventLogger.cpp
View File

@ -105,10 +105,6 @@ const EventLoggerBase::EventRepLogLevelMatrix EventLoggerBase::matrix[] = {
{ EventReport::CreateLogBytes, LogLevel::llInfo, 11, Logger::LL_INFO }, { EventReport::CreateLogBytes, LogLevel::llInfo, 11, Logger::LL_INFO },
{ EventReport::InfoEvent, LogLevel::llInfo, 2, Logger::LL_INFO }, { EventReport::InfoEvent, LogLevel::llInfo, 2, Logger::LL_INFO },
//Global replication
{ EventReport::GrepSubscriptionInfo, LogLevel::llGrep, 7, Logger::LL_INFO},
{ EventReport::GrepSubscriptionAlert, LogLevel::llGrep, 7, Logger::LL_ALERT},
// Backup // Backup
{ EventReport::BackupStarted, LogLevel::llBackup, 7, Logger::LL_INFO }, { EventReport::BackupStarted, LogLevel::llBackup, 7, Logger::LL_INFO },
{ EventReport::BackupCompleted, LogLevel::llBackup, 7, Logger::LL_INFO }, { EventReport::BackupCompleted, LogLevel::llBackup, 7, Logger::LL_INFO },

9
ndb/src/common/util/NdbSqlUtil.cpp
View File

@ -545,6 +545,15 @@ NdbSqlUtil::cmpDate(const void* info, const void* p1, unsigned n1, const void* p
assert(! full); assert(! full);
return CmpUnknown; return CmpUnknown;
#else #else
char t1[4], t2[4];
if (n1 == 3 && n2 == 3)
{
memcpy(t1, p1, 3);
memcpy(t2, p2, 3);
p1 = t1;
p2 = t2;
n1 = n2 = 4;
}
if (n2 >= 4) { // may access 4-th byte if (n2 >= 4) { // may access 4-th byte
const uchar* v1 = (const uchar*)p1; const uchar* v1 = (const uchar*)p1;
const uchar* v2 = (const uchar*)p2; const uchar* v2 = (const uchar*)p2;

110
ndb/src/mgmapi/mgmapi.cpp
View File

@ -916,67 +916,68 @@ ndb_mgm_restart(NdbMgmHandle handle, int no_of_nodes, const int *node_list)
return ndb_mgm_restart2(handle, no_of_nodes, node_list, 0, 0, 0); return ndb_mgm_restart2(handle, no_of_nodes, node_list, 0, 0, 0);
} }
static const char *clusterlog_level_names[]= static const char *clusterlog_severity_names[]=
{ "enabled", "debug", "info", "warning", "error", "critical", "alert" }; { "enabled", "debug", "info", "warning", "error", "critical", "alert" };
struct ndb_mgm_clusterlog_levels struct ndb_mgm_event_severities
{ {
const char* name; const char* name;
enum ndb_mgm_clusterlog_level level; enum ndb_mgm_event_severity severity;
} clusterlog_levels[] = { } clusterlog_severities[] = {
{ clusterlog_level_names[0], NDB_MGM_CLUSTERLOG_ON }, { clusterlog_severity_names[0], NDB_MGM_EVENT_SEVERITY_ON },
{ clusterlog_level_names[1], NDB_MGM_CLUSTERLOG_DEBUG }, { clusterlog_severity_names[1], NDB_MGM_EVENT_SEVERITY_DEBUG },
{ clusterlog_level_names[2], NDB_MGM_CLUSTERLOG_INFO }, { clusterlog_severity_names[2], NDB_MGM_EVENT_SEVERITY_INFO },
{ clusterlog_level_names[3], NDB_MGM_CLUSTERLOG_WARNING }, { clusterlog_severity_names[3], NDB_MGM_EVENT_SEVERITY_WARNING },
{ clusterlog_level_names[4], NDB_MGM_CLUSTERLOG_ERROR }, { clusterlog_severity_names[4], NDB_MGM_EVENT_SEVERITY_ERROR },
{ clusterlog_level_names[5], NDB_MGM_CLUSTERLOG_CRITICAL }, { clusterlog_severity_names[5], NDB_MGM_EVENT_SEVERITY_CRITICAL },
{ clusterlog_level_names[6], NDB_MGM_CLUSTERLOG_ALERT }, { clusterlog_severity_names[6], NDB_MGM_EVENT_SEVERITY_ALERT },
{ "all", NDB_MGM_CLUSTERLOG_ALL }, { "all", NDB_MGM_EVENT_SEVERITY_ALL },
{ 0, NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL }, { 0, NDB_MGM_ILLEGAL_EVENT_SEVERITY },
}; };
extern "C" extern "C"
ndb_mgm_clusterlog_level ndb_mgm_event_severity
ndb_mgm_match_clusterlog_level(const char * name) ndb_mgm_match_event_severity(const char * name)
{ {
if(name == 0) if(name == 0)
return NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL; return NDB_MGM_ILLEGAL_EVENT_SEVERITY;
for(int i = 0; clusterlog_levels[i].name !=0 ; i++) for(int i = 0; clusterlog_severities[i].name !=0 ; i++)
if(strcasecmp(name, clusterlog_levels[i].name) == 0) if(strcasecmp(name, clusterlog_severities[i].name) == 0)
return clusterlog_levels[i].level; return clusterlog_severities[i].severity;
return NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL; return NDB_MGM_ILLEGAL_EVENT_SEVERITY;
} }
extern "C" extern "C"
const char * const char *
ndb_mgm_get_clusterlog_level_string(enum ndb_mgm_clusterlog_level level) ndb_mgm_get_event_severity_string(enum ndb_mgm_event_severity severity)
{ {
int i= (int)level; int i= (int)severity;
if (i >= 0 && i < (int)NDB_MGM_CLUSTERLOG_ALL) if (i >= 0 && i < (int)NDB_MGM_EVENT_SEVERITY_ALL)
return clusterlog_level_names[i]; return clusterlog_severity_names[i];
for(i = (int)NDB_MGM_CLUSTERLOG_ALL; clusterlog_levels[i].name != 0; i++) for(i = (int)NDB_MGM_EVENT_SEVERITY_ALL; clusterlog_severities[i].name != 0; i++)
if(clusterlog_levels[i].level == level) if(clusterlog_severities[i].severity == severity)
return clusterlog_levels[i].name; return clusterlog_severities[i].name;
return 0; return 0;
} }
extern "C" extern "C"
unsigned int * const unsigned int *
ndb_mgm_get_logfilter(NdbMgmHandle handle) ndb_mgm_get_clusterlog_severity_filter(NdbMgmHandle handle)
{ {
SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_get_logfilter"); SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_get_clusterlog_severity_filter");
static Uint32 enabled[(int)NDB_MGM_CLUSTERLOG_ALL] = {0,0,0,0,0,0,0}; static unsigned int enabled[(int)NDB_MGM_EVENT_SEVERITY_ALL]=
{0,0,0,0,0,0,0};
const ParserRow<ParserDummy> getinfo_reply[] = { const ParserRow<ParserDummy> getinfo_reply[] = {
MGM_CMD("clusterlog", NULL, ""), MGM_CMD("clusterlog", NULL, ""),
MGM_ARG(clusterlog_level_names[0], Int, Mandatory, ""), MGM_ARG(clusterlog_severity_names[0], Int, Mandatory, ""),
MGM_ARG(clusterlog_level_names[1], Int, Mandatory, ""), MGM_ARG(clusterlog_severity_names[1], Int, Mandatory, ""),
MGM_ARG(clusterlog_level_names[2], Int, Mandatory, ""), MGM_ARG(clusterlog_severity_names[2], Int, Mandatory, ""),
MGM_ARG(clusterlog_level_names[3], Int, Mandatory, ""), MGM_ARG(clusterlog_severity_names[3], Int, Mandatory, ""),
MGM_ARG(clusterlog_level_names[4], Int, Mandatory, ""), MGM_ARG(clusterlog_severity_names[4], Int, Mandatory, ""),
MGM_ARG(clusterlog_level_names[5], Int, Mandatory, ""), MGM_ARG(clusterlog_severity_names[5], Int, Mandatory, ""),
MGM_ARG(clusterlog_level_names[6], Int, Mandatory, ""), MGM_ARG(clusterlog_severity_names[6], Int, Mandatory, ""),
}; };
CHECK_HANDLE(handle, NULL); CHECK_HANDLE(handle, NULL);
CHECK_CONNECTED(handle, NULL); CHECK_CONNECTED(handle, NULL);
@ -986,20 +987,21 @@ ndb_mgm_get_logfilter(NdbMgmHandle handle)
reply = ndb_mgm_call(handle, getinfo_reply, "get info clusterlog", &args); reply = ndb_mgm_call(handle, getinfo_reply, "get info clusterlog", &args);
CHECK_REPLY(reply, NULL); CHECK_REPLY(reply, NULL);
for(int i=0; i < (int)NDB_MGM_CLUSTERLOG_ALL; i++) { for(int i=0; i < (int)NDB_MGM_EVENT_SEVERITY_ALL; i++) {
reply->get(clusterlog_level_names[i], &enabled[i]); reply->get(clusterlog_severity_names[i], &enabled[i]);
} }
return enabled; return enabled;
} }
extern "C" extern "C"
int int
ndb_mgm_filter_clusterlog(NdbMgmHandle handle, ndb_mgm_set_clusterlog_severity_filter(NdbMgmHandle handle,
enum ndb_mgm_clusterlog_level level, enum ndb_mgm_event_severity severity,
int enable, int enable,
struct ndb_mgm_reply* /*reply*/) struct ndb_mgm_reply* /*reply*/)
{ {
SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_filter_clusterlog"); SET_ERROR(handle, NDB_MGM_NO_ERROR,
"Executing: ndb_mgm_set_clusterlog_severity_filter");
const ParserRow<ParserDummy> filter_reply[] = { const ParserRow<ParserDummy> filter_reply[] = {
MGM_CMD("set logfilter reply", NULL, ""), MGM_CMD("set logfilter reply", NULL, ""),
MGM_ARG("result", String, Mandatory, "Error message"), MGM_ARG("result", String, Mandatory, "Error message"),
@ -1010,7 +1012,7 @@ ndb_mgm_filter_clusterlog(NdbMgmHandle handle,
CHECK_CONNECTED(handle, -1); CHECK_CONNECTED(handle, -1);
Properties args; Properties args;
args.put("level", level); args.put("level", severity);
args.put("enable", enable); args.put("enable", enable);
const Properties *reply; const Properties *reply;
@ -1045,10 +1047,9 @@ struct ndb_mgm_event_categories
{ "CHECKPOINT", NDB_MGM_EVENT_CATEGORY_CHECKPOINT }, { "CHECKPOINT", NDB_MGM_EVENT_CATEGORY_CHECKPOINT },
{ "DEBUG", NDB_MGM_EVENT_CATEGORY_DEBUG }, { "DEBUG", NDB_MGM_EVENT_CATEGORY_DEBUG },
{ "INFO", NDB_MGM_EVENT_CATEGORY_INFO }, { "INFO", NDB_MGM_EVENT_CATEGORY_INFO },
{ "WARNING", NDB_MGM_EVENT_CATEGORY_WARNING },
{ "ERROR", NDB_MGM_EVENT_CATEGORY_ERROR }, { "ERROR", NDB_MGM_EVENT_CATEGORY_ERROR },
{ "GREP", NDB_MGM_EVENT_CATEGORY_GREP },
{ "BACKUP", NDB_MGM_EVENT_CATEGORY_BACKUP }, { "BACKUP", NDB_MGM_EVENT_CATEGORY_BACKUP },
{ "CONGESTION", NDB_MGM_EVENT_CATEGORY_CONGESTION },
{ 0, NDB_MGM_ILLEGAL_EVENT_CATEGORY } { 0, NDB_MGM_ILLEGAL_EVENT_CATEGORY }
}; };
@ -1080,13 +1081,13 @@ ndb_mgm_get_event_category_string(enum ndb_mgm_event_category status)
extern "C" extern "C"
int int
ndb_mgm_set_loglevel_clusterlog(NdbMgmHandle handle, int nodeId, ndb_mgm_set_clusterlog_loglevel(NdbMgmHandle handle, int nodeId,
enum ndb_mgm_event_category cat, enum ndb_mgm_event_category cat,
int level, int level,
struct ndb_mgm_reply* /*reply*/) struct ndb_mgm_reply* /*reply*/)
{ {
SET_ERROR(handle, NDB_MGM_NO_ERROR, SET_ERROR(handle, NDB_MGM_NO_ERROR,
"Executing: ndb_mgm_set_loglevel_clusterlog"); "Executing: ndb_mgm_set_clusterlog_loglevel");
const ParserRow<ParserDummy> clusterlog_reply[] = { const ParserRow<ParserDummy> clusterlog_reply[] = {
MGM_CMD("set cluster loglevel reply", NULL, ""), MGM_CMD("set cluster loglevel reply", NULL, ""),
MGM_ARG("result", String, Mandatory, "Error message"), MGM_ARG("result", String, Mandatory, "Error message"),
@ -1105,7 +1106,7 @@ ndb_mgm_set_loglevel_clusterlog(NdbMgmHandle handle, int nodeId,
"set cluster loglevel", &args); "set cluster loglevel", &args);
CHECK_REPLY(reply, -1); CHECK_REPLY(reply, -1);
DBUG_ENTER("ndb_mgm_set_loglevel_clusterlog"); DBUG_ENTER("ndb_mgm_set_clusterlog_loglevel");
DBUG_PRINT("enter",("node=%d, category=%d, level=%d", nodeId, cat, level)); DBUG_PRINT("enter",("node=%d, category=%d, level=%d", nodeId, cat, level));
BaseString result; BaseString result;
@ -1157,7 +1158,7 @@ ndb_mgm_set_loglevel_node(NdbMgmHandle handle, int nodeId,
extern "C" extern "C"
int int
ndb_mgm_listen_event(NdbMgmHandle handle, int filter[]) ndb_mgm_listen_event(NdbMgmHandle handle, const int filter[])
{ {
SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_listen_event"); SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_listen_event");
const ParserRow<ParserDummy> stat_reply[] = { const ParserRow<ParserDummy> stat_reply[] = {
@ -1195,7 +1196,10 @@ ndb_mgm_listen_event(NdbMgmHandle handle, int filter[])
handle->socket = tmp; handle->socket = tmp;
CHECK_REPLY(reply, -1); if(reply == NULL) {
close(sockfd);
CHECK_REPLY(reply, -1);
}
return sockfd; return sockfd;
} }

37
ndb/src/mgmclient/CommandInterpreter.cpp
View File

@ -1246,7 +1246,7 @@ CommandInterpreter::executeClusterLog(char* parameters)
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
enum ndb_mgm_clusterlog_level severity = NDB_MGM_CLUSTERLOG_ALL; enum ndb_mgm_event_severity severity = NDB_MGM_EVENT_SEVERITY_ALL;
char * tmpString = my_strdup(parameters,MYF(MY_WME)); char * tmpString = my_strdup(parameters,MYF(MY_WME));
My_auto_ptr<char> ap1(tmpString); My_auto_ptr<char> ap1(tmpString);
@ -1254,7 +1254,7 @@ CommandInterpreter::executeClusterLog(char* parameters)
char * item = strtok_r(tmpString, " ", &tmpPtr); char * item = strtok_r(tmpString, " ", &tmpPtr);
int enable; int enable;
Uint32 *enabled = ndb_mgm_get_logfilter(m_mgmsrv); const unsigned int *enabled= ndb_mgm_get_logfilter(m_mgmsrv);
if(enabled == NULL) { if(enabled == NULL) {
ndbout << "Couldn't get status" << endl; ndbout << "Couldn't get status" << endl;
printError(); printError();
@ -1276,8 +1276,8 @@ CommandInterpreter::executeClusterLog(char* parameters)
printf("enabled[%d] = %d\n", i, enabled[i]); printf("enabled[%d] = %d\n", i, enabled[i]);
#endif #endif
ndbout << "Severities enabled: "; ndbout << "Severities enabled: ";
for(i = 1; i < (int)NDB_MGM_CLUSTERLOG_ALL; i++) { for(i = 1; i < (int)NDB_MGM_EVENT_SEVERITY_ALL; i++) {
const char *str= ndb_mgm_get_clusterlog_level_string((ndb_mgm_clusterlog_level)i); const char *str= ndb_mgm_get_event_severity_string((ndb_mgm_event_severity)i);
if (str == 0) if (str == 0)
{ {
DBUG_ASSERT(false); DBUG_ASSERT(false);
@ -1311,8 +1311,10 @@ CommandInterpreter::executeClusterLog(char* parameters)
int res_enable; int res_enable;
item = strtok_r(NULL, " ", &tmpPtr); item = strtok_r(NULL, " ", &tmpPtr);
if (item == NULL) { if (item == NULL) {
res_enable= ndb_mgm_filter_clusterlog(m_mgmsrv, res_enable=
NDB_MGM_CLUSTERLOG_ON, enable, NULL); ndb_mgm_set_clusterlog_severity_filter(m_mgmsrv,
NDB_MGM_EVENT_SEVERITY_ON,
enable, NULL);
if (res_enable < 0) if (res_enable < 0)
{ {
ndbout << "Couldn't set filter" << endl; ndbout << "Couldn't set filter" << endl;
@ -1324,32 +1326,33 @@ CommandInterpreter::executeClusterLog(char* parameters)
} }
do { do {
severity= NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL; severity= NDB_MGM_ILLEGAL_EVENT_SEVERITY;
if (strcasecmp(item, "ALL") == 0) { if (strcasecmp(item, "ALL") == 0) {
severity = NDB_MGM_CLUSTERLOG_ALL; severity = NDB_MGM_EVENT_SEVERITY_ALL;
} else if (strcasecmp(item, "ALERT") == 0) { } else if (strcasecmp(item, "ALERT") == 0) {
severity = NDB_MGM_CLUSTERLOG_ALERT; severity = NDB_MGM_EVENT_SEVERITY_ALERT;
} else if (strcasecmp(item, "CRITICAL") == 0) { } else if (strcasecmp(item, "CRITICAL") == 0) {
severity = NDB_MGM_CLUSTERLOG_CRITICAL; severity = NDB_MGM_EVENT_SEVERITY_CRITICAL;
} else if (strcasecmp(item, "ERROR") == 0) { } else if (strcasecmp(item, "ERROR") == 0) {
severity = NDB_MGM_CLUSTERLOG_ERROR; severity = NDB_MGM_EVENT_SEVERITY_ERROR;
} else if (strcasecmp(item, "WARNING") == 0) { } else if (strcasecmp(item, "WARNING") == 0) {
severity = NDB_MGM_CLUSTERLOG_WARNING; severity = NDB_MGM_EVENT_SEVERITY_WARNING;
} else if (strcasecmp(item, "INFO") == 0) { } else if (strcasecmp(item, "INFO") == 0) {
severity = NDB_MGM_CLUSTERLOG_INFO; severity = NDB_MGM_EVENT_SEVERITY_INFO;
} else if (strcasecmp(item, "DEBUG") == 0) { } else if (strcasecmp(item, "DEBUG") == 0) {
severity = NDB_MGM_CLUSTERLOG_DEBUG; severity = NDB_MGM_EVENT_SEVERITY_DEBUG;
} else if (strcasecmp(item, "OFF") == 0 || } else if (strcasecmp(item, "OFF") == 0 ||
strcasecmp(item, "ON") == 0) { strcasecmp(item, "ON") == 0) {
if (enable < 0) // only makes sense with toggle if (enable < 0) // only makes sense with toggle
severity = NDB_MGM_CLUSTERLOG_ON; severity = NDB_MGM_EVENT_SEVERITY_ON;
} }
if (severity == NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL) { if (severity == NDB_MGM_ILLEGAL_EVENT_SEVERITY) {
ndbout << "Invalid severity level: " << item << endl; ndbout << "Invalid severity level: " << item << endl;
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
res_enable = ndb_mgm_filter_clusterlog(m_mgmsrv, severity, enable, NULL); res_enable= ndb_mgm_set_clusterlog_severity_filter(m_mgmsrv, severity,
enable, NULL);
if (res_enable < 0) if (res_enable < 0)
{ {
ndbout << "Couldn't set filter" << endl; ndbout << "Couldn't set filter" << endl;

12
ndb/src/mgmsrv/ConfigInfo.cpp
View File

@ -1105,6 +1105,18 @@ const ConfigInfo::ParamInfo ConfigInfo::m_ParamInfo[] = {
"0", "0",
"15" }, "15" },
{
CFG_LOGLEVEL_CONGESTION,
"LogLevelCongestion",
DB_TOKEN,
"Congestion info printed on stdout",
ConfigInfo::CI_USED,
false,
ConfigInfo::CI_INT,
"0",
"0",
"15" },
{ {
CFG_LOGLEVEL_ERROR, CFG_LOGLEVEL_ERROR,
"LogLevelError", "LogLevelError",

6
ndb/src/mgmsrv/Services.cpp
View File

@ -1184,13 +1184,13 @@ MgmApiSession::startAll(Parser<MgmApiSession>::Context &,
void void
MgmApiSession::setLogFilter(Parser_t::Context &ctx, MgmApiSession::setLogFilter(Parser_t::Context &ctx,
const class Properties &args) { const class Properties &args) {
Uint32 level; Uint32 severity;
Uint32 enable; Uint32 enable;
args.get("level", &level); args.get("level", &severity);
args.get("enable", &enable); args.get("enable", &enable);
int result = m_mgmsrv.setEventLogFilter(level, enable); int result = m_mgmsrv.setEventLogFilter(severity, enable);
m_output->println("set logfilter reply"); m_output->println("set logfilter reply");
m_output->println("result: %d", result); m_output->println("result: %d", result);

5
sql/set_var.cc
View File

@ -749,11 +749,11 @@ struct show_var_st init_vars[]= {
{"innodb_fast_shutdown", (char*) &innobase_fast_shutdown, SHOW_MY_BOOL}, {"innodb_fast_shutdown", (char*) &innobase_fast_shutdown, SHOW_MY_BOOL},
{"innodb_file_io_threads", (char*) &innobase_file_io_threads, SHOW_LONG }, {"innodb_file_io_threads", (char*) &innobase_file_io_threads, SHOW_LONG },
{"innodb_file_per_table", (char*) &innobase_file_per_table, SHOW_MY_BOOL}, {"innodb_file_per_table", (char*) &innobase_file_per_table, SHOW_MY_BOOL},
{"innodb_locks_unsafe_for_binlog", (char*) &innobase_locks_unsafe_for_binlog, SHOW_MY_BOOL},
{"innodb_flush_log_at_trx_commit", (char*) &innobase_flush_log_at_trx_commit, SHOW_INT}, {"innodb_flush_log_at_trx_commit", (char*) &innobase_flush_log_at_trx_commit, SHOW_INT},
{"innodb_flush_method", (char*) &innobase_unix_file_flush_method, SHOW_CHAR_PTR}, {"innodb_flush_method", (char*) &innobase_unix_file_flush_method, SHOW_CHAR_PTR},
{"innodb_force_recovery", (char*) &innobase_force_recovery, SHOW_LONG }, {"innodb_force_recovery", (char*) &innobase_force_recovery, SHOW_LONG },
{"innodb_lock_wait_timeout", (char*) &innobase_lock_wait_timeout, SHOW_LONG }, {"innodb_lock_wait_timeout", (char*) &innobase_lock_wait_timeout, SHOW_LONG },
{"innodb_locks_unsafe_for_binlog", (char*) &innobase_locks_unsafe_for_binlog, SHOW_MY_BOOL},
{"innodb_log_arch_dir", (char*) &innobase_log_arch_dir, SHOW_CHAR_PTR}, {"innodb_log_arch_dir", (char*) &innobase_log_arch_dir, SHOW_CHAR_PTR},
{"innodb_log_archive", (char*) &innobase_log_archive, SHOW_MY_BOOL}, {"innodb_log_archive", (char*) &innobase_log_archive, SHOW_MY_BOOL},
{"innodb_log_buffer_size", (char*) &innobase_log_buffer_size, SHOW_LONG }, {"innodb_log_buffer_size", (char*) &innobase_log_buffer_size, SHOW_LONG },
@ -762,10 +762,9 @@ struct show_var_st init_vars[]= {
{"innodb_log_group_home_dir", (char*) &innobase_log_group_home_dir, SHOW_CHAR_PTR}, {"innodb_log_group_home_dir", (char*) &innobase_log_group_home_dir, SHOW_CHAR_PTR},
{sys_innodb_max_dirty_pages_pct.name, (char*) &sys_innodb_max_dirty_pages_pct, SHOW_SYS}, {sys_innodb_max_dirty_pages_pct.name, (char*) &sys_innodb_max_dirty_pages_pct, SHOW_SYS},
{sys_innodb_max_purge_lag.name, (char*) &sys_innodb_max_purge_lag, SHOW_SYS}, {sys_innodb_max_purge_lag.name, (char*) &sys_innodb_max_purge_lag, SHOW_SYS},
{sys_innodb_table_locks.name, (char*) &sys_innodb_table_locks, SHOW_SYS},
{sys_innodb_max_purge_lag.name, (char*) &sys_innodb_max_purge_lag, SHOW_SYS},
{"innodb_mirrored_log_groups", (char*) &innobase_mirrored_log_groups, SHOW_LONG}, {"innodb_mirrored_log_groups", (char*) &innobase_mirrored_log_groups, SHOW_LONG},
{"innodb_open_files", (char*) &innobase_open_files, SHOW_LONG }, {"innodb_open_files", (char*) &innobase_open_files, SHOW_LONG },
{sys_innodb_table_locks.name, (char*) &sys_innodb_table_locks, SHOW_SYS},
{"innodb_thread_concurrency", (char*) &innobase_thread_concurrency, SHOW_LONG }, {"innodb_thread_concurrency", (char*) &innobase_thread_concurrency, SHOW_LONG },
#endif #endif
{sys_interactive_timeout.name,(char*) &sys_interactive_timeout, SHOW_SYS}, {sys_interactive_timeout.name,(char*) &sys_interactive_timeout, SHOW_SYS},

2
sql/sql_select.cc
View File

@ -7907,7 +7907,7 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
table->s->keys_for_keyread.init(); table->s->keys_for_keyread.init();
table->s->keys_in_use.init(); table->s->keys_in_use.init();
/* For easier error reporting */ /* For easier error reporting */
table->s->table_cache_key= (char*) table->s->db= ""; table->s->table_cache_key= (char*) (table->s->db= "");
/* Calculate which type of fields we will store in the temporary table */ /* Calculate which type of fields we will store in the temporary table */

4
sql/sql_show.cc
View File

@ -889,12 +889,12 @@ store_create_info(THD *thd, TABLE_LIST *table_list, String *packet)
{ {
if (share->db_type == DB_TYPE_HEAP && if (share->db_type == DB_TYPE_HEAP &&
key_info->algorithm == HA_KEY_ALG_BTREE) key_info->algorithm == HA_KEY_ALG_BTREE)
packet->append(" TYPE BTREE", 11); packet->append(" USING BTREE", 12);
// +BAR: send USING only in non-default case: non-spatial rtree // +BAR: send USING only in non-default case: non-spatial rtree
if ((key_info->algorithm == HA_KEY_ALG_RTREE) && if ((key_info->algorithm == HA_KEY_ALG_RTREE) &&
!(key_info->flags & HA_SPATIAL)) !(key_info->flags & HA_SPATIAL))
packet->append(" TYPE RTREE", 11); packet->append(" USING RTREE", 12);
} }
packet->append(" (", 2); packet->append(" (", 2);