Source for PostgreSQL patch set
--- /export/mysql/extsql-build/builds/8.4.1/rhel4/x86/1/0.0/src/backend/utils/misc/Makefile 2008-02-19 05:30:09.000000000 -0500
+++ src/backend/utils/misc/Makefile 2009-11-28 09:57:35.000000000 -0500
@@ -15,5 +15,7 @@
override CPPFLAGS := -I$(srcdir) $(CPPFLAGS)
-OBJS = guc.o help_config.o pg_rusage.o ps_status.o superuser.o tzparser.o
+# EXTSQL START
+OBJS = guc.o help_config.o pg_rusage.o ps_status.o superuser.o tzparser.o extsql.o
+# EXTSQL END
# This location might depend on the installation directories. Therefore
--- /export/mysql/extsql-build/builds/8.4.1/rhel4/x86/1/0.0/src/backend/nodes/copyfuncs.c 2009-06-17 21:27:02.000000000 -0400
+++ src/backend/nodes/copyfuncs.c 2009-11-28 10:01:07.000000000 -0500
@@ -2926,4 +2926,65 @@
}
+// EXTSQL START
+static VariableShowStatsStmt *
+_copyVariableShowStatsStmt(VariableShowStatsStmt *from)
+{
+ VariableShowStatsStmt *newnode = makeNode(VariableShowStatsStmt);
+
+ COPY_NODE_FIELD(stats_vars);
+ COPY_STRING_FIELD(stats_class);
+ COPY_STRING_FIELD(wild);
+ COPY_STRING_FIELD(stats_order_var);
+ COPY_STRING_FIELD(stats_where_var);
+ COPY_SCALAR_FIELD(stats_order_dir);
+ COPY_SCALAR_FIELD(stats_order_limit);
+ COPY_SCALAR_FIELD(stats_hourly);
+ COPY_SCALAR_FIELD(stats_where_num);
+ COPY_SCALAR_FIELD(stats_where_char);
+
+ return newnode;
+}
+
+static VariableStatisticsUsage *
+_copyVariableStatisticsUsage(VariableStatisticsUsage *from)
+{
+ VariableStatisticsUsage *newnode = makeNode(VariableStatisticsUsage);
+
+ return newnode;
+}
+
+static VariableStatisticsEnable *
+_copyVariableStatisticsEnable(VariableStatisticsEnable *from)
+{
+ VariableStatisticsEnable *newnode = makeNode(VariableStatisticsEnable);
+
+ COPY_SCALAR_FIELD(stats_status);
+
+ return newnode;
+}
+
+static VariableStatisticsReset *
+_copyVariableStatisticsReset(VariableStatisticsReset *from)
+{
+ VariableStatisticsReset *newnode = makeNode(VariableStatisticsReset);
+
+ COPY_STRING_FIELD(config_file);
+
+ return newnode;
+}
+
+static VariableStatisticsFileIO *
+_copyVariableStatisticsFileIO(VariableStatisticsFileIO *from)
+{
+ VariableStatisticsFileIO *newnode = makeNode(VariableStatisticsFileIO);
+
+ COPY_SCALAR_FIELD(stats_io_mode);
+ COPY_SCALAR_FIELD(stats_confirm);
+ COPY_STRING_FIELD(stats_reload_file);
+
+ return newnode;
+}
+// EXTSQL END
+
static DiscardStmt *
_copyDiscardStmt(DiscardStmt *from)
@@ -3892,4 +3953,21 @@
retval = _copyVariableShowStmt(from);
break;
+ // EXTSQL START
+ case T_VariableShowStatsStmt:
+ retval = _copyVariableShowStatsStmt(from);
+ break;
+ case T_VariableStatisticsUsage:
+ retval = _copyVariableStatisticsUsage(from);
+ break;
+ case T_VariableStatisticsEnable:
+ retval = _copyVariableStatisticsEnable(from);
+ break;
+ case T_VariableStatisticsReset:
+ retval = _copyVariableStatisticsReset(from);
+ break;
+ case T_VariableStatisticsFileIO:
+ retval = _copyVariableStatisticsFileIO(from);
+ break;
+ // EXTSQL END
case T_DiscardStmt:
retval = _copyDiscardStmt(from);
--- /export/mysql/extsql-build/builds/8.4.1/rhel4/x86/1/0.0/src/backend/nodes/equalfuncs.c 2009-06-17 21:27:02.000000000 -0400
+++ src/backend/nodes/equalfuncs.c 2009-11-28 10:04:00.000000000 -0500
@@ -1510,4 +1510,54 @@
}
+// EXTSQL START
+static bool
+_equalVariableShowStatsStmt(VariableShowStatsStmt *a, VariableShowStatsStmt *b)
+{
+ COMPARE_NODE_FIELD(stats_vars);
+ COMPARE_STRING_FIELD(stats_class);
+ COMPARE_STRING_FIELD(wild);
+ COMPARE_STRING_FIELD(stats_order_var);
+ COMPARE_STRING_FIELD(stats_where_var);
+ COMPARE_SCALAR_FIELD(stats_order_dir);
+ COMPARE_SCALAR_FIELD(stats_order_limit);
+ COMPARE_SCALAR_FIELD(stats_where_num);
+ COMPARE_SCALAR_FIELD(stats_where_char);
+
+ return true;
+}
+
+static bool
+_equalVariableStatisticsUsage(VariableStatisticsUsage *a, VariableStatisticsUsage *b)
+{
+ return true;
+}
+
+static bool
+_equalVariableStatisticsEnable(VariableStatisticsEnable *a, VariableStatisticsEnable *b)
+{
+ COMPARE_SCALAR_FIELD(stats_status);
+
+ return true;
+}
+
+static bool
+_equalVariableStatisticsReset(VariableStatisticsReset *a, VariableStatisticsReset *b)
+{
+ COMPARE_STRING_FIELD(config_file);
+
+ return true;
+}
+
+static bool
+_equalVariableStatisticsFileIO(VariableStatisticsFileIO *a, VariableStatisticsFileIO *b)
+{
+ COMPARE_SCALAR_FIELD(stats_io_mode);
+ COMPARE_SCALAR_FIELD(stats_confirm);
+ COMPARE_STRING_FIELD(stats_reload_file);
+
+ return true;
+}
+// EXTSQL END
+
static bool
_equalDiscardStmt(DiscardStmt *a, DiscardStmt *b)
@@ -2669,4 +2719,21 @@
retval = _equalVariableShowStmt(a, b);
break;
+ // EXTSQL START
+ case T_VariableShowStatsStmt:
+ retval = _equalVariableShowStatsStmt(a, b);
+ break;
+ case T_VariableStatisticsUsage:
+ retval = _equalVariableStatisticsUsage(a, b);
+ break;
+ case T_VariableStatisticsEnable:
+ retval = _equalVariableStatisticsEnable(a, b);
+ break;
+ case T_VariableStatisticsReset:
+ retval = _equalVariableStatisticsReset(a, b);
+ break;
+ case T_VariableStatisticsFileIO:
+ retval = _equalVariableStatisticsFileIO(a, b);
+ break;
+ // EXTSQL END
case T_DiscardStmt:
retval = _equalDiscardStmt(a, b);
--- /export/mysql/extsql-build/builds/8.4.1/rhel4/x86/1/0.0/src/backend/parser/gram.y 2009-07-05 22:58:48.000000000 -0400
+++ src/backend/parser/gram.y 2009-11-28 10:10:19.000000000 -0500
@@ -391,4 +391,13 @@
%type TableLikeOptionList
%type TableLikeOption
+
+/* EXTSQL START */
+ %type stats_order_dir stats_compare stats_hourly stats_limit_clause
+ maybe_confirm
+ %type wild stats_class stats_var maybe_file_name
+ %type stats_var_list
+ %type stats_where_clause stats_order_clause StatisticsStmt
+/* EXTSQL END */
+
%type ColQualList
%type ColConstraint ColConstraintElem ConstraintAttr
@@ -456,4 +465,9 @@
HANDLER HAVING HEADER_P HOLD HOUR_P
+ /* EXTSQL START */
+ CONFIRM
+ HISTORY
+ /* EXTSQL END */
+
IDENTITY_P IF_P ILIKE IMMEDIATE IMMUTABLE IMPLICIT_P IN_P
INCLUDING INCREMENT INDEX INDEXES INHERIT INHERITS INITIALLY
@@ -690,4 +704,7 @@
| RuleStmt
| SelectStmt
+ // EXTSQL START
+ | StatisticsStmt
+ // EXTSQL END
| TransactionStmt
| TruncateStmt
@@ -1400,4 +1417,38 @@
$$ = (Node *) n;
}
+ /* EXTSQL START */
+ | SHOW STATISTICS
+ {
+ VariableShowStatsStmt *n = makeNode(VariableShowStatsStmt);
+ n->stats_vars = NULL;
+ n->stats_class = NULL;
+ n->wild = NULL;
+ n->stats_where_var = NULL;
+ n->stats_where_num = 0;
+ n->stats_where_char = '0';
+ n->stats_order_var = NULL;
+ n->stats_order_dir = 0;
+ n->stats_hourly = 0;
+ n->stats_order_limit = 0;
+ $$ = (Node *) n;
+ }
+
+ /* 3 4 5 6 7 8 9 10 */
+ | SHOW STATISTICS stats_var_list FROM stats_class wild stats_where_clause stats_order_clause stats_hourly stats_limit_clause
+ {
+ VariableShowStatsStmt *n = makeNode(VariableShowStatsStmt);
+ n->stats_vars = $3;
+ n->stats_class = $5;
+ n->wild = $6;
+ n->stats_where_var = ((VariableShowStatsStmt *) $7)->stats_where_var;
+ n->stats_where_num = ((VariableShowStatsStmt *) $7)->stats_where_num;
+ n->stats_where_char = ((VariableShowStatsStmt *) $7)->stats_where_char;
+ n->stats_order_var = ((VariableShowStatsStmt *) $8)->stats_order_var;
+ n->stats_order_dir = ((VariableShowStatsStmt *) $8)->stats_order_dir;
+ n->stats_hourly = $9;
+ n->stats_order_limit = $10;
+ $$ = (Node *) n;
+ }
+ /* EXTSQL END */
| SHOW TIME ZONE
{
@@ -1426,4 +1477,152 @@
;
+/* EXTSQL START */
+
+stats_class:
+ '*' { $$ = "*"; }
+ | ColId ;
+
+stats_compare:
+ '=' { $$ = '='; }
+ | '<' { $$ = '<'; }
+ | '>' { $$ = '>'; };
+
+stats_hourly :
+ /* empty */ { $$=0; }
+ | HISTORY { $$=1; };
+
+stats_limit_clause:
+ /* empty */
+ {
+ $$ = 0;
+ }
+
+ | LIMIT ICONST
+ {
+ $$ = $2;
+ }
+ ;
+
+stats_order_clause:
+ /* empty */
+ {
+ VariableShowStatsStmt *n = makeNode(VariableShowStatsStmt);
+ n->stats_order_var = NULL;
+ n->stats_order_dir = 0 ;
+ $$ = (Node *) n;
+ }
+
+ | ORDER BY stats_var stats_order_dir
+ {
+
+ VariableShowStatsStmt *n = makeNode(VariableShowStatsStmt);
+ n->stats_order_var = $3;
+ n->stats_order_dir = $4 ;
+ $$ = (Node *) n;
+ }
+ ;
+
+stats_order_dir:
+ /* empty */ { $$ = 1; }
+ | ASC { $$ =1; }
+ | DESC { $$ =0; };
+
+stats_var: '*'
+ | ColId ;
+
+stats_var_list:
+ stats_var_list ',' stats_var { $$ = lappend($1, makeString($3)); }
+ | stats_var { $$ = list_make1(makeString($1)); }
+ ;
+
+stats_where_clause:
+ /* empty */
+ {
+ VariableShowStatsStmt *n = makeNode(VariableShowStatsStmt);
+ n->stats_where_var = NULL;
+ n->stats_where_char = 0;
+ n->stats_where_num = 0;
+ $$ = (Node *) n;
+ }
+
+ | WHERE stats_var stats_compare ICONST
+ {
+ VariableShowStatsStmt *n = makeNode(VariableShowStatsStmt);
+ n->stats_where_var = $2;
+ n->stats_where_char = $3;
+ n->stats_where_num = $4;
+ $$ = (Node *) n;
+ }
+ ;
+
+wild:
+ LIKE SCONST { $$ = $2; }
+| /* empty */{ $$ = NULL;} ;
+
+
+StatisticsStmt:
+ STATISTICS
+ {
+ VariableStatisticsUsage *n = makeNode(VariableStatisticsUsage);
+ $$ = (Node *) n;
+ }
+ | STATISTICS ON
+ {
+ VariableStatisticsEnable *n = makeNode(VariableStatisticsEnable);
+ n->stats_status = 1;
+ $$ = (Node *) n;
+ }
+ | STATISTICS OFF
+ {
+ VariableStatisticsEnable *n = makeNode(VariableStatisticsEnable);
+ n->stats_status = 0;
+ $$ = (Node *) n;
+ }
+ | STATISTICS RESET maybe_file_name
+ {
+ VariableStatisticsReset *n = makeNode(VariableStatisticsReset);
+ n->config_file = $3;
+ $$ = (Node *) n;
+ }
+ | STATISTICS READ maybe_confirm file_name
+ {
+ VariableStatisticsFileIO *n = makeNode(VariableStatisticsFileIO);
+ n->stats_io_mode = 0;
+ n->stats_confirm = $3;
+ n->stats_reload_file = $4;
+ $$ = (Node *) n;
+ }
+ | STATISTICS WRITE file_name
+ {
+ VariableStatisticsFileIO *n = makeNode(VariableStatisticsFileIO);
+ n->stats_io_mode = 1;
+ n->stats_confirm = 0;
+ n->stats_reload_file = $3;
+ $$ = (Node *) n;
+ }
+ ;
+
+maybe_file_name:
+ /* nothing */
+ {
+ $$ = NULL;
+ }
+ | file_name
+ {
+ $$ = $1;
+ }
+ ;
+
+maybe_confirm:
+ /* nothing */
+ {
+ $$ = 0;
+ }
+ | CONFIRM
+ {
+ $$ = 1;
+ }
+ ;
+/* EXTSQL END */
ConstraintsSetStmt:
--- /export/mysql/extsql-build/builds/8.4.1/rhel4/x86/1/0.0/src/backend/postmaster/postmaster.c 2009-08-24 16:08:40.000000000 -0400
+++ src/backend/postmaster/postmaster.c 2009-11-28 13:50:13.000000000 -0500
@@ -1024,4 +1024,21 @@
load_ident();
+ // EXTSQL START
+ int startType = 0;
+
+ // if the default config params contain a non null
+ // extsql_reload_file and its contents look valid, we will set
+ // startType to STATS_INIT_RELOAD, otherwise STATS_INIT_NORMAL
+ elog(LOG, "ExtSQL(postmaster): ready to call extsql_prep and extsql_init");
+ extsql_prep(&startType, NULL, extsql_reload_file);
+
+ // if reload fails here, just do a regular startup
+ if (startType == STATS_INIT_FAILURE) {
+ startType = STATS_INIT_NORMAL;
+ }
+
+ extsql_init(Shared->extsql_class_list, startType, Shared->extsql_reload_file);
+ // EXTSQL END
+
/*
* Remember postmaster startup time
@@ -4034,4 +4051,9 @@
ExitPostmaster(int status)
{
+ // EXTSQL START
+ if (*extsql_reload_file)
+ if (extsql_reload(STATS_WRITE_RELOAD, extsql_reload_file))
+ sql_print_error("ExtSQL: Error encountered during reload WRITE");
+ // EXTSQL END
/* should cleanup shared memory and kill all backends */
--- /export/mysql/extsql-build/builds/8.4.1/rhel4/x86/1/0.0/src/backend/tcop/pquery.c 2009-06-11 10:49:02.000000000 -0400
+++ src/backend/tcop/pquery.c 2009-11-28 13:59:56.000000000 -0500
@@ -1176,4 +1176,11 @@
IsA(utilityStmt, VariableSetStmt) ||
IsA(utilityStmt, VariableShowStmt) ||
+ // EXTSQL START
+ IsA(utilityStmt, VariableShowStatsStmt) ||
+ IsA(utilityStmt, VariableStatisticsUsage) ||
+ IsA(utilityStmt, VariableStatisticsEnable) ||
+ IsA(utilityStmt, VariableStatisticsReset) ||
+ IsA(utilityStmt, VariableStatisticsFileIO) ||
+ // EXTSQL END
IsA(utilityStmt, ConstraintsSetStmt) ||
/* efficiency hacks from here down */
--- /export/mysql/extsql-build/builds/8.4.1/rhel4/x86/1/0.0/src/backend/tcop/utility.c 2009-06-11 16:46:11.000000000 -0400
+++ src/backend/tcop/utility.c 2009-11-28 13:58:22.000000000 -0500
@@ -58,4 +58,9 @@
#include "utils/syscache.h"
+// EXTSQL START
+#ifndef EXTSQL_H
+#include "utils/extsql.h"
+#endif
+// EXTSQL END
/*
@@ -924,4 +929,62 @@
break;
+ // EXTSQL START
+ case T_VariableShowStatsStmt:
+ {
+ char varList[100] = {'\0'};
+ VariableShowStatsStmt *n = (VariableShowStatsStmt *) parsetree;
+
+ if (0) {
+ elog(LOG, "ExtSQL: internal variables (%s) class %s, \
+ hourly %d, wild %s, ORDER BY %s, direction %d, LIMIT %d, \
+ WHERE var %s, compare %d, value %d",
+ varList, n->stats_class, n->stats_hourly, n->wild,
+ n->stats_order_var,
+ n->stats_order_dir, n->stats_order_limit,
+ n->stats_where_var,
+ n->stats_where_char, n->stats_where_num);
+
+ }
+
+ mysql_show_extsql(MyProc, n->stats_class, dest, n->stats_vars,
+ n->stats_hourly, n->wild, n->stats_order_var,
+ n->stats_order_dir, n->stats_order_limit,
+ n->stats_where_var, n->stats_where_num,
+ n->stats_where_char);
+ }
+ break;
+
+ case T_VariableStatisticsUsage:
+ {
+ extsql_usage(MyProc, dest);
+ }
+ break;
+
+ case T_VariableStatisticsEnable:
+ {
+ VariableStatisticsEnable *n = (VariableStatisticsEnable *) parsetree;
+
+ extsql_enable(MyProc, dest, n->stats_status);
+ }
+ break;
+
+ case T_VariableStatisticsReset:
+ {
+ VariableStatisticsReset *n = (VariableStatisticsReset *) parsetree;
+
+ extsql_reset(MyProc, dest, n->config_file);
+ }
+ break;
+
+ case T_VariableStatisticsFileIO:
+ {
+ VariableStatisticsFileIO *n = (VariableStatisticsFileIO *) parsetree;
+
+ extsql_file_io(MyProc, dest, n->stats_io_mode,
+ n->stats_confirm, n->stats_reload_file);
+ }
+ break;
+ // EXTSQL END
+
case T_DiscardStmt:
DiscardCommand((DiscardStmt *) parsetree, isTopLevel);
@@ -1151,4 +1214,21 @@
return true;
+ // EXTSQL START
+ case T_VariableShowStatsStmt:
+ return false;
+
+ case T_VariableStatisticsUsage:
+ return false;
+
+ case T_VariableStatisticsEnable:
+ return false;
+
+ case T_VariableStatisticsReset:
+ return false;
+
+ case T_VariableStatisticsFileIO:
+ return false;
+ // EXTSQL END
+
default:
return false;
@@ -1205,4 +1285,38 @@
}
+ // EXTSQL START
+ case T_VariableShowStatsStmt:
+ {
+ VariableShowStatsStmt *n = (VariableShowStatsStmt *) parsetree;
+
+ return GetPGVariableResultDesc(n->stats_class);
+ }
+
+ case T_VariableStatisticsUsage:
+ {
+ return NULL;
+ }
+
+ case T_VariableStatisticsEnable:
+ {
+ VariableStatisticsEnable *n = (VariableStatisticsEnable *) parsetree;
+
+ return GetPGVariableResultDesc(n->stats_status);
+ }
+
+ case T_VariableStatisticsReset:
+ {
+ VariableStatisticsReset *n = (VariableStatisticsReset *) parsetree;
+
+ return GetPGVariableResultDesc(n->config_file);
+ }
+ case T_VariableStatisticsFileIO:
+ {
+ VariableStatisticsFileIO *n = (VariableStatisticsFileIO *) parsetree;
+
+ return GetPGVariableResultDesc(n->stats_reload_file);
+ }
+ // EXTSQL END
+
default:
return NULL;
@@ -1262,4 +1376,8 @@
const char *tag;
+ // EXTSQL START ZZ - put a function call here to capture all
+ extsql_inc(&Questions, 1);
+ // EXTSQL END
+
switch (nodeTag(parsetree))
{
@@ -1267,16 +1385,28 @@
case T_InsertStmt:
tag = "INSERT";
+ // EXTSQL START
+ extsql_inc(&Com_insert, 1);
+ // EXTSQL END
break;
case T_DeleteStmt:
tag = "DELETE";
+ // EXTSQL START
+ extsql_inc(&Com_delete, 1);
+ // EXTSQL END
break;
case T_UpdateStmt:
tag = "UPDATE";
+ // EXTSQL START
+ extsql_inc(&Com_update, 1);
+ // EXTSQL END
break;
case T_SelectStmt:
tag = "SELECT";
+ // EXTSQL START
+ extsql_inc(&Com_select, 1);
+ // EXTSQL END
break;
@@ -1290,4 +1420,7 @@
case TRANS_STMT_BEGIN:
tag = "BEGIN";
+ // EXTSQL START
+ extsql_inc(&Com_begin, 1);
+ // EXTSQL END
break;
@@ -1298,4 +1431,7 @@
case TRANS_STMT_COMMIT:
tag = "COMMIT";
+ // EXTSQL START
+ extsql_inc(&Com_commit, 1);
+ // EXTSQL END
break;
@@ -1303,4 +1439,7 @@
case TRANS_STMT_ROLLBACK_TO:
tag = "ROLLBACK";
+ // EXTSQL START
+ extsql_inc(&Com_rollback, 1);
+ // EXTSQL END
break;
@@ -1365,4 +1504,7 @@
case T_CreateStmt:
tag = "CREATE TABLE";
+ // EXTSQL START
+ extsql_inc(&Com_create_table, 1);
+ // EXTSQL END
break;
@@ -1416,4 +1558,7 @@
case OBJECT_TABLE:
tag = "DROP TABLE";
+ // EXTSQL START
+ extsql_inc(&Com_drop_table, 1);
+ // EXTSQL END
break;
case OBJECT_SEQUENCE:
@@ -1828,4 +1973,26 @@
break;
+ // EXTSQL START
+ case T_VariableShowStatsStmt:
+ tag = "SHOW STATISTICS";
+ break;
+
+ case T_VariableStatisticsUsage:
+ tag = "STATISTICS";
+ break;
+
+ case T_VariableStatisticsEnable:
+ tag = "STATISTICS";
+ break;
+
+ case T_VariableStatisticsReset:
+ tag = "STATISTICS";
+ break;
+
+ case T_VariableStatisticsFileIO:
+ tag = "STATISTICS";
+ break;
+ // EXTSQL END
+
case T_DiscardStmt:
switch (((DiscardStmt *) parsetree)->target)
--- /export/mysql/extsql-build/builds/8.4.1/rhel4/x86/1/0.0/src/backend/utils/init/postinit.c 2009-07-08 13:53:32.000000000 -0400
+++ src/backend/utils/init/postinit.c 2009-11-28 14:02:41.000000000 -0500
@@ -652,4 +652,27 @@
pgstat_bestart();
+ // EXTSQL START
+ if (bootstrap) {
+ int startType = 0;
+
+ // if the default config params contain a non null
+ // extsql_reload_file and its contents look valid, we will set
+ // startType to STATS_INIT_RELOAD, otherwise STATS_INIT_NORMAL
+ // elog(LOG, "ExtSQL(postinit-1): ready to call extsql_prep and extsql_init");
+ extsql_prep(&startType, NULL, extsql_reload_file);
+
+ // if reload fails here, just do a regular startup
+ if (startType == STATS_INIT_FAILURE) {
+ startType = STATS_INIT_NORMAL;
+ }
+ extsql_init(Shared->extsql_class_list, startType, Shared->extsql_reload_file);
+
+ } else {
+ // elog(LOG, "ExtSQL(postinit-2): skip extsql_prep, ready to call extsql_thread_init");
+ extsql_thread_init(MyProc, STATS_THD_INIT_NORM);
+
+ }
+ // EXTSQL END
+
/* close the transaction we started above */
if (!bootstrap)
--- /export/mysql/extsql-build/builds/8.4.1/rhel4/x86/1/0.0/src/backend/utils/misc/guc.c 2009-09-03 18:08:14.000000000 -0400
+++ src/backend/utils/misc/guc.c 2009-11-29 09:09:33.000000000 -0500
@@ -1641,4 +1641,33 @@
},
+ // EXTSQL START
+ {
+ {"extsql_active", PGC_POSTMASTER, DEVELOPER_OPTIONS,
+ gettext_noop("Set the Extended Statistics internal debug level for output to error log. Use with caution!"),
+ NULL
+ },
+ (int *)&extsql_active,
+ 0, 0, INT_MAX, NULL, NULL
+ },
+
+ {
+ {"extsql_counter", PGC_POSTMASTER, DEVELOPER_OPTIONS,
+ gettext_noop("Set the Extended Statistics internal counter. Use with caution!"),
+ NULL
+ },
+ (int *)&extsql_counter,
+ 0, 0, INT_MAX, NULL, NULL
+ },
+
+ {
+ {"extsql_debug", PGC_POSTMASTER, DEVELOPER_OPTIONS,
+ gettext_noop("Set the Extended Statistics debug level for output to error log. Use with caution!"),
+ NULL
+ },
+ (int *)&extsql_debug,
+ 0, 0, INT_MAX, NULL, NULL
+ },
+ // EXTSQL END
+
{
{"commit_delay", PGC_USERSET, WAL_SETTINGS,
@@ -2301,4 +2330,42 @@
},
+ // EXTSQL START
+ {
+ {"extsql_class_list", PGC_POSTMASTER, DEVELOPER_OPTIONS,
+ gettext_noop("This is a specially formatted list of class definitions that define what statistics are collected."),
+ NULL
+ },
+ &extsql_class_list,
+ "", NULL, NULL
+ },
+
+ {
+ {"extsql_key", PGC_POSTMASTER, DEVELOPER_OPTIONS,
+ gettext_noop("This is a license key used with a binary distribution of ExtSQL."),
+ NULL
+ },
+ &extsql_key,
+ "", NULL, NULL
+ },
+
+ {
+ {"extsql_users", PGC_POSTMASTER, DEVELOPER_OPTIONS,
+ gettext_noop("This contains an additional list of userids allowed to run statistics (root always can)."),
+ NULL
+ },
+ &extsql_users,
+ "", NULL, NULL
+ },
+
+ {
+ {"extsql_reload_file", PGC_POSTMASTER, DEVELOPER_OPTIONS,
+ gettext_noop("Allow the server to record statistics data in the specified file and reload upon restart."),
+ NULL
+ },
+ &extsql_reload_file,
+ "", NULL, NULL
+ },
+ // EXTSQL END
+
{
/* Not for general use --- used by SET ROLE */
--- /export/mysql/extsql-build/builds/8.4.1/rhel4/x86/1/0.0/src/include/nodes/nodes.h 2009-06-11 10:49:11.000000000 -0400
+++ src/include/nodes/nodes.h 2009-11-28 14:08:32.000000000 -0500
@@ -291,4 +291,11 @@
T_VariableSetStmt,
T_VariableShowStmt,
+ /* EXTSQL START */
+ T_VariableShowStatsStmt,
+ T_VariableStatisticsUsage,
+ T_VariableStatisticsEnable,
+ T_VariableStatisticsReset,
+ T_VariableStatisticsFileIO,
+ /* EXTSQL END */
T_DiscardStmt,
T_CreateTrigStmt,
--- /export/mysql/extsql-build/builds/8.4.1/rhel4/x86/1/0.0/src/include/nodes/parsenodes.h 2009-06-17 21:27:02.000000000 -0400
+++ src/include/nodes/parsenodes.h 2009-11-28 14:11:34.000000000 -0500
@@ -1314,4 +1314,69 @@
} VariableShowStmt;
+/* EXTSQL START */
+/* ----------------------
+ * Show Statistics Statement
+ * ----------------------
+ */
+
+typedef struct VariableShowStatsStmt
+{
+ NodeTag type;
+ List *stats_vars;
+ char *stats_class;
+ char *wild;
+ char *stats_order_var;
+ char *stats_where_var;
+ int stats_order_dir;
+ int stats_order_limit;
+ int stats_hourly;
+ int stats_where_num;
+ int stats_where_char;
+} VariableShowStatsStmt;
+
+/* ----------------------
+ * Statistics Statement
+ * ----------------------
+ */
+
+typedef struct VariableStatisticsUsage
+{
+ NodeTag type;
+} VariableStatisticsUsage;
+
+/* ----------------------
+ * Statistics ON|OFF Statement
+ * ----------------------
+ */
+
+typedef struct VariableStatisticsEnable
+{
+ NodeTag type;
+ int stats_status;
+} VariableStatisticsEnable;
+
+/* ----------------------
+ * Statistics RESET Statement
+ * ----------------------
+ */
+
+typedef struct VariableStatisticsReset
+{
+ NodeTag type;
+ char *config_file;
+} VariableStatisticsReset;
+
+/* ----------------------
+ * Statistics READ|WRITE Statement
+ * ----------------------
+ */
+typedef struct VariableStatisticsFileIO
+{
+ NodeTag type;
+ int stats_io_mode, stats_confirm;
+ char *stats_reload_file;
+} VariableStatisticsFileIO;
+/* EXTSQL END */
+
/* ----------------------
* Create Table Statement
--- /export/mysql/extsql-build/builds/8.4.1/rhel4/x86/1/0.0/src/include/storage/proc.h 2009-02-23 04:28:50.000000000 -0500
+++ src/include/storage/proc.h 2009-11-28 14:13:14.000000000 -0500
@@ -99,4 +99,12 @@
struct PGPROC *lwWaitLink; /* next waiter for same LW lock */
+ // EXTSQL START
+ #define STATS_MAX_CLASSES 7
+ int statIndex[STATS_MAX_CLASSES]; // ZZ - stores the indexes to use when incrementing
+ // quick lookup into statsData
+
+ int statVerify; // store the magic here to verify a good set
+ // EXTSQL END
+
/* Info about lock the process is currently waiting for, if any. */
/* waitLock and waitProcLock are NULL if not currently waiting. */
--- /export/mysql/extsql-build/builds/8.4.1/rhel4/x86/1/0.0/src/include/tcop/dest.h 2009-06-11 10:49:12.000000000 -0400
+++ src/include/tcop/dest.h 2009-11-28 14:14:46.000000000 -0500
@@ -123,4 +123,7 @@
CommandDest mydest;
/* Private fields might appear beyond this point... */
+ // EXTSQL START
+ int verify;
+ // EXTSQL END
};
--- /export/mysql/extsql-build/builds/8.4.1/rhel4/x86/1/0.0/src/include/utils/guc.h 2009-09-03 18:08:14.000000000 -0400
+++ src/include/utils/guc.h 2009-11-28 14:15:42.000000000 -0500
@@ -18,4 +18,7 @@
#include "utils/array.h"
+// EXTSQL START
+#include "utils/extsql.h"
+// EXTSQL END
/*
--- /export/mysql/extsql-build/builds/8.4.1/rhel4/x86/1/0.0/src/include/parser/kwlist.h 2009-04-06 04:42:53.000000000 -0400
+++ src/include/parser/kwlist.h 2009-11-28 10:14:27.000000000 -0500
@@ -85,4 +85,7 @@
PG_KEYWORD("concurrently", CONCURRENTLY, UNRESERVED_KEYWORD)
PG_KEYWORD("configuration", CONFIGURATION, UNRESERVED_KEYWORD)
+// EXTSQL START
+PG_KEYWORD("confirm", CONFIRM, UNRESERVED_KEYWORD)
+// EXTSQL END
PG_KEYWORD("connection", CONNECTION, UNRESERVED_KEYWORD)
PG_KEYWORD("constraint", CONSTRAINT, RESERVED_KEYWORD)
--- /export/mysql/extsql-build/builds/8.4.1/rhel4/x86/1/0.0/src/backend/utils/misc/extsql.c 1969-12-31 19:00:00.000000000 -0500
+++ src/backend/utils/misc/extsql.c 2009-12-01 08:13:40.000000000 -0500
@@ -0,0 +1,4437 @@
+/* Copyright (C) 2006, 2007, 2008, 2009, 2010 Software Workshop Incorporated
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
+
+#define PGSQL 1
+
+#ifdef PGSQL
+#include "utils/extsql.h"
+
+#else // MYSQL
+
+#include "mysql_priv.h"
+#include "stacktrace.h"
+
+#endif // PGSQL or MYSQL
+
+// DEBUG FLAGS -- we show decimal, has to be used in SET GLOBAL extsql_debug= val
+#define STATS_DUMP 1 // dump stats internal data on every SHOW command
+#define STATS_DUMP_ONCE 2 // just dump it once and clear stats_debug ZZ
+#define STATS_SHOW_PARAMS 4 // show parameters to SHOW STATISTICS
+#define STATS_INC_PARAMS 8 // print warning on bad param to extsql_inc
+#define STATS_ADMIN 16 // allow write/read/reset commands
+#define STATS_TEST_TWO 32 // testing
+#define STATS_INC_VAR 64 // show details on stats increment
+#define STATS_THD_INIT_PARAMS 128 // show parameters on thread init
+#define STATS_THD_INIT_LOOP 256 // show search for matching/new instance of class
+#define STATS_DISABLE_INC 512 // disable extsql_inc processing
+#define STATS_THREAD_CHK 1024 // do a check of the thread on each inc, only print errors
+#define STATS_DUMP_START 2048 // dump all tracking info at server start
+#define STATS_TIME_DETAIL 4096 // show start secs/minutes if min/hour are units
+#define STATS_EXTRA_VARS 8192 // allow user to select untested vars for tracking
+#define STATS_MEM_ALLOC 16384 // show startup mem allocs
+#define STATS_TIME_CHANGE 32768 // show start of time roll over processing
+#define STATS_RELOAD 65536 // show reload processing
+#define STATS_TEST_ONE 131072 // testing
+#define STATS_PID 262144 // show server pid as part of show statistics, for gdb
+
+#define PROG_POINT(x,y) sql_print_information("ExtSQL: PROGRESS POINT %s (0x%x)", x, y)
+
+// LIMITS
+#define STATS_MAX_TIME_LABEL 20
+#define STATS_WARNING_LIMIT 10
+
+#define MAX_BUFF_SIZE 2048 // used for temporary buffs of user input (product of next two)
+#define MAX_VAR_SIZE 45 // max length we allows for a Var name that is tracked.
+#define MAX_VARS_IN_CLASS 50 // max number of vars in single class def & row of output
+#define DATE_SIZE 30
+
+// MISC
+#define ARRAY_INDEX(i,j,size_j,k,size_k) ( (i * size_j +j) * size_k + k)
+
+
+// just testing
+
+time_t StartTime;
+
+// GLOBAL's defined in GLOBAL struct, extsql.h,
+// few vars here where compiler needs static addresses. Set global in extsql_init_globals
+
+// these are globals initially set in postgresql.conf -- extsql_init has not been called yet,
+// need to have a static address allocated, extsql_init_globals will then copy to Shared.
+ulong extsql_active=0, extsql_counter=0, extsql_debug=0, queries=0, connects=0;
+char *extsql_class_list=NULL, *extsql_reload_file=NULL;
+
+
+#ifdef PGSQL
+
+pGLOBAL Shared; // Used for shared memory/globals - only dynamic allocation at start.
+
+#else // MYSQL
+
+GLOBAL GShared; // can be static, shared between threads
+pGLOBAL Shared = &GShared;
+
+#endif
+
+
+// CONSTANT GLOBALS HERE
+
+char *extsqlClassesSupported[STATS_MAX_CLASSES] = {"condb", "conuser", "db", "host", "server", "user", NULL};
+char *extsql_key, *extsql_users;
+static char *extsql_version = "\nExtSQL version: __STATS_VERSION__\n"; // keep \n at start and end!
+
+
+// vars we have tested and confirmed with, they can set STATS_EXTRA_VARS to override.
+static char *allowedVarsArray[MAX_VARS] = {"Com_begin", "Com_commit", "Com_create_table",
+ "Com_delete", "Com_drop_table", "Com_insert", "Com_lock_tables", "Com_replace",
+ "Com_rollback", "Com_select", "Com_set_option", "Com_show_fields", "Com_stmt_execute",
+ "Com_stmt_prepare", "Com_update", "Connections", "Created_tmp_tables",
+ "Created_tmp_disk_tables", "Handler_read_rnd", "Handler_read_rnd_next",
+ "Qcache_hits", "Questions", "Select_full_join", "Select_range_check",
+ "Select_scan", "Slow_queries", NULL };
+
+static char *startTypeName[] = { "FAILURE", "NORMAL", "RESET", "RELOAD" };
+
+char **allowedVars = allowedVarsArray;
+
+static char *adminDisabled = "ExtSQL: In this release STATISTICS RESET/READ/WRITE are disabled by default due \
+to incomplete testing. If you wish to use these commands you must added the following to the server \
+config file and restart the server: extsql_debug = 16";
+
+
+// FUNCTION prototypes
+
+int extsql_init_globals(void);
+static void extsql_stats_dump(void);
+static void extsql_thread_dump(THD *thd, int doDump);
+static int extsql_store_var_addr(char *varAddr);
+static void extsql_init_proc_vars(int *threadID, int *command, char **user, char **db, char **host,
+ char **proc_info, int **indexPtr, int **statVerify);
+
+
+#ifdef PGSQL
+
+ulong Com_begin, Com_commit, Com_create_table, Com_delete,
+ Com_drop_table, Com_insert, Com_rollback, Com_select, Com_update, Connections, Questions;
+
+char *ShmemPtr = NULL; // for shared memory
+static slock_t *MemLock = NULL; // spin lock needs to be in shared mem region.
+char **NextFree = NULL; // for shared memory!
+
+struct show_var_st status_vars[] = {
+ {"Com_begin", &Com_begin},
+ {"Com_commit", &Com_commit},
+ {"Com_create_table", &Com_create_table},
+ {"Com_delete", &Com_delete},
+ {"Com_drop_table", &Com_drop_table},
+ {"Com_insert", &Com_insert},
+ {"Com_rollback", &Com_rollback},
+ {"Com_select", &Com_select},
+ {"Com_update", &Com_update},
+ {"Connections", &Connections},
+ {"Questions", &Questions},
+ {NullS, (ulong *) 0}
+};
+char *command_name[] = {"n/a for pgsql", "n/a for pgsql", NULL};
+
+// change in number of args from 7.4.19 -> 8.4
+#ifdef PGSQL_8
+#define TupleDescInitEntry(a,b,c,d,e,f,g) TupleDescInitEntry(a,b,c,d,e,f)
+#endif
+
+int mysql_show_extsql(THD *thd, const char *stats_class, DestReceiver *dest, List *stats_vars,
+ uint stats_hourly, const char *wild, char *stats_order_var,
+ const uint stats_order_dir, const uint stats_order_limit, char *stats_where_var,
+ const uint stats_where_num, const uint stats_where_char);
+
+#define SHMEM_SIZE 1000000 // ZZ - need to predict based on class list for pgsql
+#define SHMEM_RESERVE 100000
+
+// need our own my_malloc to zero alloc'd memory
+// NOTE - this allocs from our limited shared memory area, we don't FREE. This should
+// only be used for extsql data
+// Temporary buffers used for i/o should be alloced with just "malloc/free"
+char * extsql_malloc(int, uint);
+char * extsql_malloc(int size, uint flags) { // from our shared memory segment, pointed at by ShmemPtr;
+
+ char *newStart; // similiar code in shmem.c
+ char *newFree;
+ char *addr;
+
+
+ if (ShmemPtr == NULL || NextFree == NULL) { // not allocated yet
+ sql_print_error("ExtSQL extsql_malloc failure, shared memory not allocated!");
+ return(NULL);
+ }
+
+ size = MAXALIGN(size);
+
+ SpinLockAcquire(MemLock);
+
+ newStart = *NextFree;
+
+ /* extra alignment for large requests, since they are probably buffers */
+ if (size >= BLCKSZ) {
+ newStart = (char *) BUFFERALIGN(newStart);
+ }
+
+ newFree = newStart + size;
+ if (newFree <= SHMEM_SIZE + ShmemPtr) {
+ addr = newStart;
+ *NextFree = newFree;
+
+ } else {
+ addr = NULL;
+ }
+
+ SpinLockRelease(MemLock);
+
+ if (!addr)
+ ereport(WARNING,
+ (errcode(ERRCODE_OUT_OF_MEMORY),
+ errmsg("ExtSQL - out of shared memory")));
+
+ bzero(addr, size);
+
+ if STATS_DEBUG(STATS_MEM_ALLOC ) {
+ sql_print_information("ExtSQL: alloc at 0x%x, of %d bytes",
+ (uint)addr, size);
+ }
+
+ return(addr);
+
+} // end my_malloc for PGSQL
+
+// need our own strdup for pgsql
+// NOTE - this allocs from our limited shared memory area, we don't FREE. This should
+// only be used for extsql data
+// Temporary buffers used for i/o should be alloced with just "strdup"
+char * extsql_strdup(char *, uint flags);
+char * extsql_strdup(char *srcStr, uint flags) {
+
+ int size = strlen(srcStr);
+ char *newStr = NULL;
+
+ newStr = extsql_malloc(size+1, 0); // second param doesn't matter for PGSQL
+
+ if (!newStr) {
+ sql_print_error("ExtSQL my_strdup: failed to allocate size (%d)", size);
+ return(NULL);
+ } else {
+ strcpy(newStr, srcStr);
+
+ }
+
+ return(newStr);
+
+} // end my_strdup for PGSQL
+
+
+static void my_datetime_to_str(time_t *, char *);
+static void my_datetime_to_str(time_t *secsNow, char *date) {
+
+ struct tm *timeNow;
+ timeNow=localtime(secsNow);
+
+ strftime(date, DATE_SIZE , "%m/%d/%y %H:%M:%S", timeNow);
+
+}
+
+// wild_case_compare -- from MySQL source, not ours. We don't use
+// charset info for PGSQL.
+int wild_case_compare(int cs, const char *str,const char *wildstr);
+int wild_case_compare(int cs, const char *str,const char *wildstr)
+{
+ char wild_many='%', wild_one='_', wild_prefix='\\';
+ int flag;
+
+ while (*wildstr) {
+
+ while (*wildstr && *wildstr != wild_many && *wildstr != wild_one) {
+
+ if (*wildstr == wild_prefix && wildstr[1])
+ wildstr++;
+
+ if (toupper(*wildstr++) !=
+ toupper(*str++))
+ return(1);
+ }
+
+ if (! *wildstr ) return(*str != 0);
+
+ if (*wildstr++ == wild_one) {
+ if (! *str++)
+ return(1); /* One char; skip */
+
+ } else { /* Found '*' */
+ if (!*wildstr)
+ return(0); /* '*' as last char: OK */
+
+ flag=(*wildstr != wild_many && *wildstr != wild_one);
+ do {
+
+ if (flag) {
+ char cmp;
+ if ((cmp= *wildstr) == wild_prefix && wildstr[1])
+ cmp=wildstr[1];
+ cmp=toupper(cmp);
+ while (*str && toupper(*str) != cmp)
+ str++;
+ if (!*str)
+ return(1);
+ }
+
+ if (wild_case_compare(0, str,wildstr) == 0)
+ return(0);
+
+ } while (*str++);
+ return(1);
+ }
+ }
+ return(*str != '\0');
+} // end wild_case_compare
+
+
+#else // MYSQL
+
+
+// for mysql we just use what they have
+#define extsql_malloc(a,b) my_malloc(a,b)
+#define extsql_strdup(a,b) my_strdup(a,b)
+
+static int extsql_output_prep_2_col(char *col1, char *col2, Protocol *protocol,
+ List- field_list, char *fill2);
+static int extsql_output_2_col(char *col1Str, int col1Int, char *col2Str,
+ int col2Int, Protocol *protocol, char *fill1);
+
+#endif // PGSQL or MYSQL build
+
+
+
+#ifdef EXTSQL_50
+#define net_printf net_printf_error
+#define PROTOCOL Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF
+#else
+#define PROTOCOL 1
+#endif
+
+
+// remove this define if you are building from source, will skip license checks.
+// #define EXTSQL_BINARY
+
+
+#ifndef DBUG_RETURN
+#define DBUG_RETURN(x) return(x)
+#endif
+
+//
+// START ACTUAL EXTSQL FUNCTION DEFINITIONS
+//
+
+#ifdef PGSQL
+int extsql_usage(THD* thd, DestReceiver *protocol) {
+
+#ifdef NEVER__
+}
+#endif
+
+#else
+int extsql_usage(THD* thd) {
+#endif
+
+#ifdef PGSQL
+ TupOutputState *tstate;
+ TupleDesc tupdesc = NULL;
+#else
+ Item* item;
+ List
- field_list;
+ Protocol *protocol = thd->protocol;
+ char *tstate = NULL, *tupdesc = '\0';
+#endif
+
+ char* enableHelp = "Turn statistics on or off";
+ char* enableUsage = "STATISTICS ON|OFF";
+ char* resetHelp = "Reset statistics [reread conf file]";
+ char* resetUsage = "STATISTICS RESET ['conf file']";
+ char* readHelp = "Read saved statistics data";
+ char* readUsage = "STATISTICS READ [CONFIRM] 'data file'";
+ char* writeHelp = "Write out statistics data";
+ char* writeUsage = "STATISTICS WRITE 'data file'";
+
+ DBUG_ENTER("extsql_usage");
+
+ // return if not authorized, disabled or inactive
+ if (extsql_check(thd, 1)) DBUG_RETURN(1);
+
+#ifdef PGSQL
+ if (extsql_output_prep_2_col("Function", "Usage", protocol, &tstate,
+ tupdesc)) {
+ DBUG_RETURN(1);
+ }
+#else
+ if (extsql_output_prep_2_col("Function", "Usage", protocol, field_list,
+ tupdesc)) {
+ DBUG_RETURN(1);
+ }
+#endif
+
+ if (extsql_output_2_col(enableHelp, 0, enableUsage, 0, protocol, tstate)) {
+ DBUG_RETURN(1);
+ }
+
+ if (extsql_output_2_col(resetHelp, 0, resetUsage, 0, protocol, tstate)) {
+ DBUG_RETURN(1);
+ }
+
+ if (extsql_output_2_col(readHelp, 0, readUsage, 0, protocol, tstate)) {
+ DBUG_RETURN(1);
+ }
+
+ if (extsql_output_2_col(writeHelp, 0, writeUsage, 0, protocol, tstate)) {
+ DBUG_RETURN(1);
+ }
+
+ extsql_output_complete(thd, tstate);
+
+ DBUG_RETURN(0);
+}
+
+// simple routine to turn extsql on or off using "STATISTICS ON|OFF"
+// grammer
+#ifdef PGSQL
+int extsql_enable(THD* thd, DestReceiver *protocol, uint status) {
+
+#ifdef NEVER__
+}
+#endif
+
+#else
+int extsql_enable(THD* thd, uint status) {
+#endif
+
+#ifdef PGSQL
+ TupOutputState *tstate;
+ TupleDesc tupdesc = NULL;
+#else
+ Item* item;
+ List
- field_list;
+ Protocol *protocol = thd->protocol;
+ char *tstate = NULL, *tupdesc = '\0';
+#endif
+ DBUG_ENTER("extsql_enable");
+
+ // return if not authorized, disabled or inactive
+ if (extsql_check(thd, 1)) DBUG_RETURN(1);
+
+ // accept any positive integer
+ if (status > 0) { status = 1; }
+
+ Shared->extsql_active = status;
+
+#ifdef PGSQL
+ if (extsql_output_prep_2_col("extsql_active", "status", protocol, &tstate,
+ tupdesc)) {
+ DBUG_RETURN(1);
+ }
+#else
+ if (extsql_output_prep_2_col("extsql_active", "status", protocol, field_list,
+ tupdesc)) {
+ DBUG_RETURN(1);
+ }
+#endif
+
+ if (extsql_output_2_col(NULL, Shared->extsql_active, NULL, 1, protocol, tstate)) {
+ DBUG_RETURN(1);
+ }
+
+ extsql_output_complete(thd, tstate);
+
+ DBUG_RETURN(0);
+}
+
+// handler for "STATISTICS RESET"
+#ifdef PGSQL
+int extsql_reset(THD* thd, DestReceiver *protocol, const char* conf) {
+
+#ifdef NEVER__
+}
+#endif
+
+#else
+int extsql_reset(THD* thd, const char* conf) {
+#endif
+
+#ifdef PGSQL
+ TupOutputState *tstate;
+ TupleDesc tupdesc = NULL;
+#else
+ Item* item;
+ List
- field_list;
+ Protocol *protocol = thd->protocol;
+ char *tstate = NULL, *tupdesc = '\0';
+#endif
+
+ int startType = STATS_INIT_RESET;
+
+ DBUG_ENTER("extsql_reset");
+
+ if (! STATS_DEBUG(STATS_ADMIN)) { // disabled
+ net_printf(thd, 0, adminDisabled);
+ return(0);
+ }
+
+ // return if not authorized, disabled or inactive
+ if (extsql_check(thd, 0)) DBUG_RETURN(1);
+
+ // in this case, extsql_prep will parse and process the conf
+ // file.
+ if (conf != NULL) {
+ extsql_prep(&startType, conf, NULL);
+ if (startType == STATS_INIT_FAILURE) {
+ net_printf(thd, 0, "ExtSQL: Error reading config file");
+ DBUG_RETURN(1);
+ }
+ }
+
+ if (extsql_init(Shared->extsql_class_list, startType, Shared->extsql_reload_file)) {
+ net_printf(thd, 0, "ExtSQL: Reset failed");
+ DBUG_RETURN(1);
+ }
+
+#ifdef PGSQL
+ if (extsql_output_prep_2_col("message", "status", protocol, &tstate,
+ tupdesc)) {
+ DBUG_RETURN(1);
+ }
+#else
+ if (extsql_output_prep_2_col("message", "status", protocol, field_list,
+ tupdesc)) {
+ DBUG_RETURN(1);
+ }
+#endif
+
+ if (extsql_output_2_col("Statistics reset", 0, NULL, 1, protocol, tstate)) {
+ DBUG_RETURN(1);
+ }
+
+ extsql_output_complete(thd, tstate);
+
+ return 0;
+}
+
+// handler for "STATISTICS READ|WRITE"
+#ifdef PGSQL
+int extsql_file_io(THD* thd, DestReceiver *protocol, uint io_mode, uint confirm,
+ char* reload_file) {
+
+#ifdef NEVER__
+}
+#endif
+
+#else
+int extsql_file_io(THD* thd, uint io_mode, uint confirm,
+ char* reload_file) {
+#endif
+
+#ifdef PGSQL
+ TupOutputState *tstate;
+ TupleDesc tupdesc = NULL;
+#else
+ Item* item;
+ List
- field_list;
+ Protocol *protocol = thd->protocol;
+ char *tstate = NULL, *tupdesc = '\0';
+#endif
+
+ int startType = STATS_INIT_RELOAD;
+ int prevState = Shared->extsql_active;
+
+ char* reloadFileCopy = extsql_strdup(reload_file, MYF(MY_WME));
+ char* message = extsql_strdup((io_mode ? "Reload file written successfully." :
+ "Reload file read successfully. Statistics are disabled. "),
+ MYF(MY_WME));
+
+ DBUG_ENTER("extsql_file-io");
+
+ if (! STATS_DEBUG(STATS_ADMIN)) { // disabled
+ net_printf(thd, 0, adminDisabled);
+ return(0);
+ }
+
+ // return if not authorized, disabled or inactive
+ if (extsql_check(thd, 0)) DBUG_RETURN(1);
+
+ Shared->extsql_active = 0;
+
+
+ // writing file
+ if (io_mode) {
+
+ if (extsql_reload(STATS_WRITE_RELOAD, reloadFileCopy)) {
+ net_printf(thd, 0, "ExtSQL: Error encountered during reload WRITE");
+ Shared->extsql_active = prevState;
+ DBUG_RETURN(1);
+ }
+
+ Shared->extsql_active = 1;
+
+ // reading file
+ } else {
+
+ extsql_prep(&startType, NULL, reloadFileCopy);
+
+ if (startType == STATS_INIT_FAILURE) {
+ net_printf(thd, 0, "Error reading reload file or version incompatibility.");
+ Shared->extsql_active = prevState;
+ DBUG_RETURN(1);
+ }
+
+ if (startType == STATS_INIT_CONFIRM && !confirm) {
+ net_printf(thd, 0,
+ "Class data in reload file or hostname does not match. Use STATISTICS READ CONFIRM '%s' to override.",
+ reload_file);
+ Shared->extsql_active = prevState;
+ DBUG_RETURN(1);
+ }
+
+ if (extsql_init(Shared->extsql_class_list, STATS_INIT_RELOAD, reloadFileCopy)) {
+ net_printf(thd, 0, "ExtSQL: Read failed");
+ Shared->extsql_active = prevState;
+ DBUG_RETURN(1);
+ }
+
+ Shared->extsql_active = 0;
+ }
+
+
+#ifdef PGSQL
+ if (extsql_output_prep_2_col("message", "status", protocol, &tstate,
+ tupdesc)) {
+ DBUG_RETURN(1);
+ }
+#else
+ if (extsql_output_prep_2_col("message", "status", protocol, field_list,
+ tupdesc)) {
+ DBUG_RETURN(1);
+ }
+#endif
+
+ if (extsql_output_2_col(message, 0, NULL, 1, protocol, tstate)) {
+ DBUG_RETURN(1);
+ }
+
+ extsql_output_complete(thd, tstate);
+
+ return 0;
+}
+
+// convenience function to check user authorization
+// checks to see if the specified 'user' is in the string containing
+// authorized users 'authUsers', set by admin with extsql_users=".."
+// return 1 if authorized, 0 otherwise
+static int extsql_user_auth(char *user, char *authUsers) {
+
+ char *tPtr, *token;
+ char tmpUser[STATS_TMP_BUFF_SIZE];
+ int found;
+
+ DBUG_ENTER("extsql_user_auth");
+
+ // we search allowed users each time in case list changes
+ if (strlen(authUsers) >= STATS_TMP_BUFF_SIZE-1) {
+ sql_print_error("ExtSQL: user list has exceeded storage limits");
+ return(0);
+ }
+
+ strcpy(tmpUser, authUsers);
+ tPtr = tmpUser;
+ found = 0;
+
+ while ( (token = strtok(tPtr, ", ")) ) {
+
+ tPtr = NULL;
+ if (!strcmp(token, user) || !strcmp("root", user)) { // match
+ found = 1;
+ break;
+ }
+ } // end while - more user names
+
+ if (!found) {
+ return(0);
+ }
+
+ return(1); // they are okay!
+
+} // end extsql_user_auth
+
+// Check for authorized user, enabled and active extsql
+int extsql_check(THD* thd, int overrideActive) {
+
+ char *user;
+
+ DBUG_ENTER("extsql_check");
+
+ if (Shared->extsql_disabled) { // just get out
+ net_printf(thd, 0, "ExtSQL: disabled");
+ DBUG_RETURN(1);
+ }
+
+ if (!(Shared->extsql_active || overrideActive)) { // just get out
+ net_printf(thd, 0, "ExtSQL: deactivated");
+ DBUG_RETURN(1);
+ }
+
+#ifdef PGSQL
+ user = MyProcPort->user_name;
+#else
+
+#ifdef EXTSQL_50
+ user = thd->security_ctx->user;
+#else
+ user = thd->user;
+#endif
+
+#endif
+
+ // are they authorized
+ if (!extsql_user_auth(user, extsql_users)) {
+
+ // let the DBA know just in case.
+ sql_print_warning("ExtSQL: attempted access by user: %s", user);
+ net_printf(thd, 0, "ExtSQL: access not allowed to user: %s",
+ user);
+ DBUG_RETURN(1);
+ }
+
+ DBUG_RETURN(0);
+}
+
+// generic function to do output prep, identify column headers, types
+// INPUT: col1 and col2 (col2 can be NULL)
+// non-zero return on failure, one or two columns
+// NOTE dest,tstate, and tupdesc are declared in the calling function,
+// same vars will be used in call to extsql_output_2_col
+// fill1 and fill2 are placeholders to keep function calls the same
+int extsql_output_prep_2_col(char *col1, char *col2
+
+#ifdef PGSQL
+ ,DestReceiver *dest, TupOutputState **tstate, TupleDesc tupdesc
+#else
+ ,Protocol *protocol, List
- field_list, char *fill2
+#endif
+
+) {
+
+ if (!col1) {
+ sql_print_error("ExtSQL: extsql_output_prep_2_col missing col1.");
+ return(1);
+ }
+
+#ifdef PGSQL
+
+ // tuple descriptor for up to two cols
+ if (col2) {
+
+ tupdesc = CreateTemplateTupleDesc(2, false);
+
+ TupleDescInitEntry(tupdesc, (AttrNumber) 1, col1,
+ TEXTOID, -1, 0, false);
+ TupleDescInitEntry(tupdesc, (AttrNumber) 2, col2,
+ TEXTOID, -1, 0, false);
+ } else {
+ tupdesc = CreateTemplateTupleDesc(1, false);
+ TupleDescInitEntry(tupdesc, (AttrNumber) 1, col1,
+ TEXTOID, -1, 0, false);
+ }
+
+ // prepare for projection of tuples
+ *tstate = begin_tup_output_tupdesc(dest, tupdesc);
+
+#else
+ Item *item;
+
+ // column headers
+ field_list.push_back(item = new Item_empty_string(col1, MAX_VAR_SIZE));
+ if (col2) {
+ field_list.push_back(item = new Item_empty_string(col2, MAX_VAR_SIZE));
+ }
+
+ // output the column headers
+ if (protocol->send_fields(&field_list, PROTOCOL)) {
+ sql_print_error("ExtSQL: output_prep_2_col protocol write failed");
+ return(1);
+ }
+
+#endif
+
+ return(0);
+
+} // end extsql_output_prep_2_col
+
+
+// generic function to send output rows (up to 2 cols, char data)
+// INPUT: col1Str (value), col2Str maybe NULL
+// NOTE tstate is declared in the calling function,
+// same vars will be used in call to extsql_output_prep_2_col
+// null strings will result in using integer values
+int extsql_output_2_col(char *col1Str, int col1Int, char *col2Str, int col2Int
+
+#ifdef PGSQL
+ ,DestReceiver *dest, TupOutputState *tstate
+#else
+ ,Protocol *protocol, char *fill1
+#endif
+
+
+) {
+
+ bool cleanup1 = false;
+ bool cleanup2 = false;
+
+#ifdef PGSQL
+ char *values[2];
+#endif
+
+ // Convert ints to char*
+ if (col1Str == NULL) {
+ cleanup1 = true;
+ col1Str = (char*)my_malloc(8 * sizeof (char), MYF(MY_WME | MY_ZEROFILL));
+ sprintf(col1Str, "%d", col1Int);
+ }
+
+ if (col2Str == NULL) {
+ cleanup2 = true;
+ col2Str = (char*)my_malloc(8 * sizeof (char), MYF(MY_WME | MY_ZEROFILL));
+ sprintf(col2Str, "%d", col2Int);
+ }
+
+#ifdef PGSQL
+
+
+ // assign to the values array ZZ - not done
+ if (col1Str) {
+ values[0] = col1Str;
+ }
+
+ if (col2Str) {
+ values[1] = col2Str;
+ }
+
+ // send it to dest
+ do_tup_output(tstate, values);
+
+
+#else
+ protocol->prepare_for_resend();
+ if (col1Str) {
+ protocol->store(col1Str, strlen(col1Str), system_charset_info);
+ } else { // must be int
+ protocol->store((longlong) col1Int);
+ }
+
+ if (col2Str) {
+ protocol->store(col2Str, strlen(col2Str), system_charset_info);
+ } else { // must be int
+ protocol->store((longlong) col2Int);
+ }
+
+ if (protocol->write()) {
+ sql_print_error("ExtSQL: output_2_col protocol write failed");
+ return(1);
+ }
+#endif
+
+ // cleanup dynamic memory allocation
+ if (cleanup1) { my_free(col1Str, MYF(0)); }
+ if (cleanup2) { my_free(col2Str, MYF(0)); }
+
+ return(0);
+
+} // end extsql_output_2_col
+
+// generic function to handle transmission end
+void extsql_output_complete(
+
+#ifdef PGSQL
+ THD *thd, TupOutputState *tstate
+#else
+ THD *thd, char *tstate
+#endif
+
+ ) {
+
+#ifdef PGSQL
+ end_tup_output(tstate);
+#else
+
+ send_eof(thd);
+
+#endif
+
+} // end extsql_output_complete
+
+
+// called from the parser in response to a SHOW STATISTICS command.
+// wild is what is given in the LIKE 'wild'
+int mysql_show_extsql(THD *thd,
+ const char *stats_class,
+#ifdef PGSQL
+ DestReceiver *protocol,
+ List *stats_vars,
+#else
+ List &stats_vars,
+#endif
+ uint stats_hourly,
+ const char *wild,
+#ifdef PGSQL
+ char *stats_order_var,
+#else
+ const char *stats_order_var,
+#endif
+ const uint stats_order_dir,
+ const uint stats_order_limit,
+#ifdef PGSQL
+ char *stats_where_var,
+#else
+ const char *stats_where_var,
+#endif
+ const uint stats_where_num,
+ const uint stats_where_char)
+{
+#ifdef PGSQL
+
+#define VALUE_LIMIT 100
+ TupOutputState *tstate;
+ TupleDesc tupdesc = NULL;
+
+#ifdef PGSQL_8
+ ListCell *item;
+#else
+ List *item;
+#endif
+
+ int listCount;
+ char *values[MAX_VARS_IN_CLASS], *valuesPtr[VALUE_LIMIT], valueBuff[256]; // output
+ int ptrIndex = 0;
+ int system_charset_info = 0; // not used in PGSQL, just placeholder, call our func.
+
+#else
+
+ Item *item;
+ List
- field_list; // has column headings, all strings.
+ List check_vars;
+ Protocol *protocol= thd->protocol;
+ LEX_COLUMN *column;
+ char *tstate = NULL; char *tupdesc = '\0'; // placeholders for tstate and tupdesc
+
+#endif
+
+ char *columnName; // used in output for MySQL PGSQL
+ int res = 0;
+ int namedVars = 0; // are they asking for specific vars
+ char listBuff[MAX_BUFF_SIZE], timeBuff[DATE_SIZE];
+ char *varListPtr = listBuff;
+ int timeLimit = 0, currentTime = 0, indexTime = 0, varIndex = 0;
+ char *varName, *termChar;
+ int varNameLength = 0, timeCount = 0, rowCount = 0, whereVarAddedList = 0;
+
+ pSTATS_CLASS_DATA stats_class_data;
+ STAT_VAR **statPtr;
+ int i, maxVar, maxTime, instance, maxInstance, var, found=0, value = 0, skip = 0,
+ rowHasData;
+ char *user;
+ MYSQL_TIME mysql_time;
+
+#ifdef EXTSQL_50
+ user = thd->security_ctx->user;
+#else
+
+#ifdef PGSQL
+ user = MyProcPort->user_name;
+#else
+ user = thd->user;
+#endif
+#endif
+
+ DBUG_ENTER("mysql_show_extsql");
+
+ // CHECK FOR DATA DUMPS OR TESTS
+ if STATS_DEBUG(STATS_DUMP) {
+ extsql_stats_dump();
+ extsql_thread_dump(thd, 1);
+
+ } else if STATS_DEBUG(STATS_DUMP_ONCE) { // just once
+ extsql_stats_dump();
+ extsql_thread_dump(thd, 1);
+ Shared->extsql_debug -= STATS_DUMP_ONCE; // clear
+
+ }
+
+ if STATS_DEBUG(STATS_TEST_ONE) {
+
+ Shared->extsql_active = 0;
+ Shared->extsql_debug -= STATS_TEST_ONE; // clear
+ extsql_stats_dump();
+ if (extsql_reload(STATS_WRITE_RELOAD, Shared->extsql_reload_file)) {
+ sql_print_error("ExtSQL: Error encountered during reload WRITE");
+ }
+ extsql_stats_dump();
+ Shared->extsql_active = 1;
+
+ }
+
+ if STATS_DEBUG(STATS_TEST_TWO) {
+
+ Shared->extsql_debug -= STATS_TEST_TWO; // clear
+ extsql_stats_dump();
+
+ if (0) {
+ extsql_init(Shared->extsql_class_list, STATS_INIT_RELOAD, Shared->extsql_reload_file);
+ } else {
+ extsql_init(Shared->extsql_class_list, STATS_INIT_RESET, Shared->extsql_reload_file);
+ }
+
+ extsql_stats_dump();
+
+ } // end if-else testing
+
+
+ // return if not authorized, disabled or inactive
+ if (extsql_check(thd, 0)) DBUG_RETURN(1);
+
+ // okay, statistics are active, prepare for output.
+ if STATS_DEBUG(STATS_SHOW_PARAMS) {
+ sql_print_information("ExtSQL: internal variables class %s,\
+ hourly %d, wild %s, ORDER BY %s, direction %d, LIMIT %d, \
+ WHERE var %s, compare %d, value %d",
+ stats_class, stats_hourly, wild,
+ stats_order_var,
+ stats_order_dir, stats_order_limit,
+ stats_where_var,
+ stats_where_char, stats_where_num);
+ }
+
+ if (stats_class == NULL) { // they want help/status
+
+ pSTATS_CLASS_DATA stats_class_data;
+ STAT_VAR **statPtr;
+
+
+ char *Usage = "Usage";
+ char *Help = "SHOW STATISTICS (* | Var[,Var]) FROM Class [LIKE 'Instance']";
+ char *Help2 = " [WHERE Var ('<'|'>'|'=') num] [ORDER BY Var] [HISTORY] [LIMIT rows_or_time]";
+#ifdef EXTSQL_50
+ char *Help3 = "also available from INFORMATION_SCHEMA, SHOW TABLES FROM INFORMATION_SCHEMA for list.\
+ExtSQL reported as part of EXTSTATS_(Class) tables.";
+#endif
+ char *Version = "Version";
+#ifdef EXTSQL_BINARY
+ char *Key = "License Key";
+#endif
+ char *Users = "Stat Users";
+ char *Blank = " ";
+ int maxVar, maxTime, maxInstance, var, instance, classCount;
+
+#ifdef PGSQL
+ if (extsql_output_prep_2_col("Item", "Value", protocol, &tstate, tupdesc)) {
+ DBUG_RETURN(1);
+ }
+#else
+ if (extsql_output_prep_2_col("Item", "Value", protocol, field_list, tupdesc)) {
+ DBUG_RETURN(1);
+ }
+#endif
+
+ if (extsql_output_2_col(Usage, 0, Help, 0, protocol, tstate)) {
+ DBUG_RETURN(1);
+ }
+
+ if (extsql_output_2_col(Usage, 0, Help2, 0, protocol, tstate)) {
+ DBUG_RETURN(1);
+ }
+
+#ifdef EXTSQL_50
+ if (extsql_output_2_col(Usage, 0, Help3, 0, protocol, tstate)) {
+ DBUG_RETURN(1);
+ }
+#endif
+
+ if (extsql_output_2_col(Version, 0, Shared->extsql_version+1, 0, protocol, tstate)) {
+ DBUG_RETURN(1);
+ }
+
+#ifdef EXTSQL_BINARY
+ if (extsql_output_2_col(Key, 0, extsql_key, 0, protocol, tstate)) {
+ DBUG_RETURN(1);
+ }
+#endif
+
+ if (extsql_output_2_col(Users, 0, extsql_users, 0, protocol, tstate)) {
+ DBUG_RETURN(1);
+ }
+
+ if STATS_DEBUG(STATS_PID) { // show the pid of the server for gdb
+ sprintf(listBuff, "(%d)", getpid());
+ if (extsql_output_2_col("Server PID", 0, listBuff, 0, protocol, tstate)) {
+ DBUG_RETURN(1);
+ }
+ }
+
+ // now we show them the class list stuff
+ classCount = 0;
+ for (stats_class_data = Shared->statData; classCount < STATS_MAX_CLASSES && stats_class_data->maxInstance;
+ stats_class_data++, classCount++) {
+
+ maxVar = stats_class_data->maxVar;
+ maxTime = stats_class_data->maxTime-1;
+ maxInstance = stats_class_data->maxInstance;
+
+ if (extsql_output_2_col(Blank, 0, Blank, 0, protocol, tstate)) {
+ DBUG_RETURN(1);
+ }
+
+ // how many instances are in use
+ for (instance=0;
+ instance < maxInstance && stats_class_data->instanceIndex[instance];
+ instance++) {
+ }
+
+ sprintf(listBuff, "Max instances/in use (%d/%d), Max vars (%d), Max time (%d), Time units(%c)",
+ maxInstance, instance, maxVar, maxTime, stats_class_data->timeUnits);
+
+ if (extsql_output_2_col(stats_class_data->name, 0, listBuff, 0, protocol, tstate)) {
+ DBUG_RETURN(1);
+ }
+
+ strcpy(listBuff, " ");
+
+ for (var=0, statPtr = stats_class_data->varIndex;
+ (var < maxVar) && *statPtr ;
+ var++, statPtr++) {
+
+ sprintf(listBuff+strlen(listBuff),"%s ", (*statPtr)->name);
+ }
+
+ if (extsql_output_2_col(stats_class_data->name, 0, listBuff, 0, protocol, tstate)) {
+ DBUG_RETURN(1);
+ }
+
+ } // end for - all clasees
+
+
+ extsql_output_complete(thd, tstate);
+ DBUG_RETURN(0);
+
+ } // end if - just showing help
+ // NOTE - normal RETURN ONLY here!
+
+
+ // find the instance list for the class we are looking for
+ found = 0;
+ for (stats_class_data = Shared->statData; stats_class_data->maxInstance;
+ stats_class_data++) {
+ if (!strcmp(stats_class_data->name, stats_class)) { // found it
+ found = 1;
+ break;
+ }
+ } // end for
+
+ if (!found) {
+ net_printf(thd, 0, "ExtSQL: can't find requested class %s, enter SHOW STATISTICS for usage.",
+ stats_class);
+ DBUG_RETURN(1);
+ }
+
+ // AT THIS POINT stats_class_data points to the requested class
+ maxVar = stats_class_data->maxVar;
+ maxTime = stats_class_data->maxTime;
+ maxInstance = stats_class_data->maxInstance; // needed for array indexing
+
+
+ // NOTE - a LOT of checking first to make sure inputs make sense.
+
+ if (stats_order_var) { // they used ORDER BY
+ net_printf(thd, 0, "ExtSQL: ORDER BY not supported in this version.");
+ DBUG_RETURN(1);
+ }
+
+ // CHECK that the limit is NOT larger than allowed if done for time
+ if (stats_hourly && stats_order_limit >= maxTime) {
+ net_printf(thd, 0, "ExtSQL, limit of %d is greater than stored time for this class of %d.",
+ stats_order_limit, maxTime-1);
+ DBUG_RETURN(1);
+ }
+
+ // CHECK BLOCK - check the where character
+ if (stats_where_char) {
+
+ switch (stats_where_char) {
+
+ case '>':
+ case '<':
+ case '=':
+ break;
+
+ default:
+ net_printf(thd, 0, "ExtSQL: unsupported comparison (%c), enter SHOW_STATISTICS for usage.", stats_where_char);
+ DBUG_RETURN(1);
+
+ } // end switch
+ }
+
+ // Set listCount to the number of Var column headings we will have
+#ifdef PGSQL
+
+ // For PGSQL we need to count the columns what we have ahead of time
+ listCount = 0; namedVars = 0;
+ foreach(item, stats_vars) {
+
+ char *var1 = strVal(lfirst(item));
+
+ if (!strcmp(var1, "statistics") ) { // ZZ - not really best way to check, default list
+
+ // loop through for count
+ for (var=0, statPtr = stats_class_data->varIndex;
+ (var < stats_class_data->maxVar) && *statPtr ;
+ var++, statPtr++) {
+ listCount++;
+ }
+ break;
+ }
+
+ listCount++;
+ namedVars = 1; // redundant
+ } // end for - all vars in list
+
+#else
+
+ if (stats_vars.elements) {
+ namedVars = 1;
+ }
+
+#endif
+
+ // CHECK BLOCK - if they gave us specific columns (namedVars=1) to display,
+ // check those vars are actually being tracked
+ if (namedVars) {
+
+
+
+#ifdef PGSQL
+
+ foreach(item, stats_vars) { // output the column heading
+
+ columnName = strVal(lfirst(item));
+#else
+
+ List_iterator stats_column(stats_vars);
+
+ while ((column=stats_column++)) { // search for a match in class
+
+ columnName = (char *)column->column.ptr();
+#endif
+
+ found = 0;
+ for (var = 0, statPtr = stats_class_data->varIndex;
+ (var < maxVar) && *statPtr ;
+ var++, statPtr++) {
+
+ if (strlen(columnName) > MAX_VAR_SIZE - 5) {
+ net_printf(thd, 0, "ExtSQL: Var is too long");
+ DBUG_RETURN(1);
+ }
+
+ if (!strcasecmp((*statPtr)->name, columnName)) { // ZZ - low case input in postgres?
+ found = 1;
+ break;
+ }
+ } // end for - all vars
+
+ if (!found) {
+ net_printf(thd, 0, "ExtSQL: can't find Var %s, SHOW STATISTICS for usage.",
+ columnName);
+ DBUG_RETURN(1);
+ }
+
+ } // end while/for - more columns
+
+#ifdef NEVER__
+ } // to keep indent level correct in emacs
+#endif
+
+ } // end if - named vars are being tracked.
+
+
+ // CHECK BLOCK - if we have an ORDER by or WHERE clause variable, check those also
+ if (stats_where_var || stats_order_var) {
+
+#ifdef PGSQL
+
+ List *checkList;
+
+ if (stats_where_var && stats_order_var) {
+ checkList = (List *)list_make2(makeString(stats_where_var), makeString(stats_order_var));
+
+ } else if (stats_where_var) {
+ checkList = (List *)list_make1(makeString(stats_where_var));
+
+ } else {
+ checkList = (List *)list_make1(makeString(stats_order_var));
+ }
+
+ foreach(item, checkList) { // check the list
+
+ columnName = strVal(lfirst(item));
+
+#else
+ if (stats_where_var) {
+ String *tmpStr = new (thd->mem_root) String ((const char *)stats_where_var, strlen(stats_where_var), system_charset_info);
+ check_vars.push_back(new LEX_COLUMN (*tmpStr, 0));
+ }
+
+ if (stats_order_var) {
+ String *tmpStr = new (thd->mem_root) String ((const char *)stats_order_var, strlen(stats_where_var), system_charset_info);
+ check_vars.push_back(new LEX_COLUMN (*tmpStr, 0));
+ }
+
+ List_iterator stats_column(stats_vars);
+
+ while ((column=stats_column++)) { // search for a match in class
+
+ columnName = (char *)column->column.ptr();
+
+#endif
+
+ found = 0;
+ for (var = 0, statPtr = stats_class_data->varIndex;
+ (var < stats_class_data->maxVar) && *statPtr ;
+ var++, statPtr++) {
+
+ // make sure the name isn't too long
+ if (strlen(columnName) > MAX_VAR_SIZE - 5) {
+ net_printf(thd, 0, "ExtSQL: Var (%s) is too long, check entry.",
+ columnName);
+ DBUG_RETURN(1);
+ }
+
+ if (!strcasecmp((*statPtr)->name, columnName)) {
+ found = 1;
+ break;
+ }
+
+ } // end for - all vars
+
+ if (!found) {
+ net_printf(thd, 0, "ExtSQL: can't find Var %s, enter SHOW STATISTICS for usage.",
+ columnName);
+ DBUG_RETURN(1);
+ }
+ } // end while - more columns
+
+#ifdef NEVER__
+ } // to keep indent level correct in emacs
+#endif
+
+ } // end if - specified where or order by var
+
+ // START OUTPUT - prepare and output the header columns
+ // The class name (always FIRST column)
+ // PGSQL uses a predefined array of column headers, need to keep count
+ // MYSQL uses a stack approach.
+
+#ifdef PGSQL
+ if (stats_hourly) {
+ listCount += 2; // class name and time
+ } else {
+ listCount++; // add just one for the class name
+ }
+ i = 1; // current param position
+
+ tupdesc = CreateTemplateTupleDesc(listCount, false);
+
+ TupleDescInitEntry(tupdesc, (AttrNumber) i++, stats_class, TEXTOID, -1, 0, false);
+
+#else
+ field_list.push_back(item = new Item_empty_string(stats_class, STATS_MAX_NAME));
+#endif
+
+ // if HOURLY is asked for, it is always the SECOND column
+ if (stats_hourly) {
+ char *units;
+ switch (stats_class_data->timeUnits) {
+ case 'm':
+ units = "minutes";
+ break;
+ case 'h':
+ units = "hours";
+ break;
+ case 'd':
+ units = "days";
+ break;
+ default:
+ units = "UNKNOWN";
+ }
+
+#ifdef PGSQL
+ TupleDescInitEntry(tupdesc, (AttrNumber) i++, units, TEXTOID, -1, 0, false);
+#else
+ field_list.push_back(item = new Item_empty_string(units, 30)); // max size of 'minutes'
+#endif
+
+ }
+
+ // Then the variable list, this will either be what they specified, or
+ // the conf list. We do a SPECIAL check to see if they have included a
+ // WHERE clause. If they have, but it is not included in the column list
+ // we will add it, but it will not be displayed on output
+
+ // LARGE else block here depending on whether they specified list, or we use default!
+ strcpy(varListPtr,","); // init the list
+
+ if (namedVars) { // they identified the columns they want
+
+ char tempName[MAX_VAR_SIZE]; // ZZ
+
+#ifdef PGSQL
+ foreach(item, stats_vars) { // output the column heading
+
+ columnName = strVal(lfirst(item));
+#else
+
+ List_iterator stats_column2(stats_vars);
+ while ((column=stats_column2++)) { // search for a match in class
+
+ columnName = (char *)column->column.ptr();
+#endif
+
+ if (strlen(columnName) > MAX_VAR_SIZE - 5) {
+ net_printf(thd, 0, "ExtSQL: Var is too long");
+ DBUG_RETURN(1);
+ }
+
+
+#ifdef PGSQL
+ TupleDescInitEntry(tupdesc, (AttrNumber) i++, columnName, TEXTOID, -1, 0, false);
+
+#else
+ field_list.push_back(item = new Item_uint(columnName, MY_INT64_NUM_DECIMAL_DIGITS ));
+#endif
+
+ strcat(varListPtr, columnName);
+ strcat(varListPtr, ",");
+
+ } // end while - more columns
+#ifdef NEVER__
+ } // to keep indent level correct in emacs
+#endif
+
+ // is the where var on the list
+ if (stats_where_var) {
+ if (strlen(stats_where_var) > MAX_VAR_SIZE - 5) {
+ net_printf(thd, 0, "ExtSQL: WHERE Var too long");
+ DBUG_RETURN(1);
+ }
+ strcpy(tempName, ",");
+ strcat(tempName, stats_where_var);
+ strcat(tempName, ",");
+ if (strstr(varListPtr,tempName)) {
+ whereVarAddedList = 0;
+ } else {
+ whereVarAddedList = 1;
+ strcat(varListPtr, stats_where_var);
+ strcat(varListPtr,",");
+ }
+ } // end if - where clause
+
+
+ } else { // we output default column headings and create varListPtr
+
+ // loop through the var names for headings
+ for (var=0, statPtr = stats_class_data->varIndex;
+ (var < stats_class_data->maxVar) && *statPtr ;
+ var++, statPtr++) {
+
+#ifdef PGSQL
+ TupleDescInitEntry(tupdesc, (AttrNumber) i++, (*statPtr)->name, TEXTOID, -1, 0, false);
+#else
+ field_list.push_back(item = new Item_uint((*statPtr)->name, MY_INT64_NUM_DECIMAL_DIGITS ));
+ item->maybe_null=1;
+#endif
+ strcat(varListPtr,(*statPtr)->name );
+ strcat(varListPtr, ",");
+
+ // check to make sure we don't bust string
+ if (strlen(varListPtr) > MAX_BUFF_SIZE - 50) {
+ net_printf(thd, 0, "ExtSQL: Var list too long");
+ DBUG_RETURN(1);
+ }
+ } // end for - all instances
+ } // end if - use defaults
+
+ // output the column headers
+#ifdef PGSQL
+ tstate = begin_tup_output_tupdesc(protocol, tupdesc);
+#else
+ if (protocol->send_fields(&field_list, PROTOCOL)) {
+ DBUG_RETURN(1);
+ }
+
+#endif
+
+ // AT THIS POINT the output columns are in varListPtr
+ // next, if they will be asking for hourly output, we prepare an array
+ // of hour indexes.
+ if STATS_DEBUG(STATS_SHOW_PARAMS) {
+ sql_print_information("ExtSQL: varListPtr is (%s), whereVarAddedList(%d)",
+ varListPtr, whereVarAddedList);
+ }
+
+ timeLimit = 1; // by default we only show one time.
+ currentTime = stats_class_data->time; // time we are currently logging to.
+
+ if (stats_hourly) { // reset the proper inner loop limits
+ if (stats_order_limit) {
+ timeLimit = stats_order_limit; // whatever thy wanted
+ } else {
+ timeLimit = maxTime-1; // they get it all
+ } // end if else - time limit
+ } // end if - user wants hours displayed.
+
+
+ // AT THIS POINT - we have the varListPtr area with the oolumns in the
+ // display order we want. Remember, zero index holds the total. The
+ // currentTime has our present location and it is circular, i.e. if
+ // maxTime for the class is 4, we store current + 3. If the currentTime
+ // is 2, the proper way to display all hours, starting with the most
+ // recent is to show 2(current),1(prior),3(more prior) - skip 0
+
+ // the currentTime has no correlation to actual clock time, it is just
+ // a position within a circular buffer of times, each class could have
+ // a different limit.
+
+ // START outputing data for the every instance within the matching class
+ // we now go through all the instances.
+ for (instance=0; instance < maxInstance && stats_class_data->instanceIndex[instance] ;
+ instance++) {
+
+ if (wild && wild_case_compare(system_charset_info,
+ stats_class_data->instanceIndex[instance], wild) ) {
+
+ continue; // skip this one
+ } // end if - wild match
+
+ // are we over our output LIMIT
+ if (!stats_hourly && stats_order_limit) { // not doing times, put limit on general output
+ if (rowCount >= stats_order_limit) {
+ break;
+ }
+ }
+
+ // loop through the times, if stats_hourly is not set we just print the stuff for zero
+ // time, the grand totals
+ // if stats_timely is set we will output a number of hours starting at currentTime, and
+ // limited by timeLimit (starts at 1).
+ for (timeCount = 0, indexTime = stats_hourly ? currentTime : 0 ;
+ timeCount < timeLimit && indexTime >= 0;
+ timeCount++, indexTime-- ) {
+
+ // if we are outputing times, we have to adjust our indexTime
+ if (stats_hourly && !indexTime) { // we have gone back to the total
+ indexTime = maxTime - 1; // pick the last
+ }
+
+ // prepare the data row
+ skip = 0;
+
+#ifdef PGSQL
+ // nothing special required here
+ // NOTE, variable i keeps our index in values array
+ i = 0;
+#else
+ protocol->prepare_for_resend();
+#endif
+ res = 0;
+ rowHasData = 0; // do we have anything to show, only on HISTORY (stats_hourly set)
+
+ // first column - instance name - always
+#ifdef PGSQL
+ values[i++] = stats_class_data->instanceIndex[instance];
+#else
+ protocol->store(stats_class_data->instanceIndex[instance],
+ strlen(stats_class_data->instanceIndex[instance]), system_charset_info);
+#endif
+
+ // if we are doing times, second column is times - always, we use indexTime
+ if (stats_hourly) {
+ value = (int) stats_class_data->timeLabels[indexTime];
+
+ // convert to local time and then to a string for output
+#ifdef PGSQL
+ // ZZ need time conversion/zone
+ mysql_time = value;
+#else
+ thd->variables.time_zone->gmt_sec_to_TIME(&mysql_time, (my_time_t) value);
+#endif
+
+ my_datetime_to_str(&mysql_time, timeBuff);
+
+ // we normally chop seconds off the time, from: 2008-04-04 14:59:48 TO 2008-04-04 14:59
+ if (!STATS_DEBUG(STATS_TIME_DETAIL)) {
+ timeBuff[strlen(timeBuff) - 3] = '\0';
+ }
+#ifdef PGSQL
+ values[i++] = timeBuff;
+#else
+ protocol->store(timeBuff, strlen(timeBuff), system_charset_info);
+#endif
+
+ } // end if - hourly
+
+ // loop through varListPtr, output the vars in the proper order
+ // varListPtr = ",bytes,selects," varName will move through this
+ for ( varName = varListPtr; *varName ; varName = strstr(varName, ",")) {
+
+ varName++; // move off the comma
+ //sql_print_information(" target varName is (%s)", varName);
+
+ if (! *varName) { // we are done
+ break;
+ }
+
+ varNameLength = strchr(varName, ',') - varName;
+
+ // okay, varName points at a name, lets go through the index looking
+ // for a match
+ found = 0;
+ value = 0;
+
+ for (varIndex=0, statPtr = stats_class_data->varIndex;
+ varIndex < maxVar && *statPtr;
+ varIndex++, statPtr++) {
+
+ termChar = (*statPtr)->name + varNameLength +1; // point to end of the current var name
+
+ if (!strncasecmp( (*statPtr)->name, varName, varNameLength)) {
+ found = 1;
+ value = stats_class_data->data [ARRAY_INDEX(instance, varIndex, maxVar,
+ indexTime, maxTime)];
+
+ // before we send, check the value if they have set a WHERE condition
+ if (stats_where_var && !strncasecmp((*statPtr)->name, stats_where_var, varNameLength)) { // match
+
+ switch (stats_where_char) {
+
+ case '>':
+ if (value <= stats_where_num) skip = 1; // this row is no good
+ break;
+
+ case '<':
+ if (value >= stats_where_num) skip = 1; // this row is no good
+ break;
+
+ case '=':
+ if (value != stats_where_num) skip = 1; // this row is no good
+ break;
+
+ default:
+
+ sql_print_warning("ExtSQL: unsupported comparison (%d)", stats_where_char);
+
+ } // end switch
+
+ rowHasData = 1;
+
+ } // end if - match using WHERE clause
+
+ if (skip) {
+ break;
+ }
+
+ if (whereVarAddedList && !strncasecmp((*statPtr)->name, stats_where_var, varNameLength)) {
+ break; // don't output the where column, they didn't ask for it
+ }
+
+#ifdef PGSQL
+ // convert to text, store ptr addr and then free
+ // after send
+ sprintf(valueBuff, "%d", value);
+ values[i] = strdup(valueBuff);
+ valuesPtr[ptrIndex++] = values[i++]; // need to free after output
+ if (ptrIndex >= VALUE_LIMIT) {
+ sql_print_error("ExtSQL, output value limit reached");
+ DBUG_RETURN(1);
+ }
+#else
+ protocol->store((longlong) value);
+#endif
+
+ if (value) { // is it non-zero
+ rowHasData = 1;
+ }
+ break;
+ } // end if - matching
+
+ } // end for - a matching var in the list
+
+ if (skip) {
+ break;
+ }
+
+ if (!found) {
+
+#ifdef PGSQL
+ values[i++] = "n/a";
+#else
+ value=999999;
+ protocol->store((longlong) value);
+#endif
+
+ }
+
+ } // end for - requested values
+
+ if (skip || (stats_hourly && !rowHasData)) { // free it up!
+
+ // if PGSQL we allocate some value space above, make sure we free it in all situations.
+#ifdef PGSQL
+ if (ptrIndex) {
+ for (ptrIndex--; ptrIndex; ptrIndex--) {
+ if (valuesPtr[ptrIndex]) {
+ free(valuesPtr[ptrIndex]);
+ }
+ }
+ }
+#endif
+ continue;
+ }
+
+
+ // send the row to the user,
+
+#ifdef PGSQL
+ do_tup_output(tstate, values);
+
+ if (ptrIndex) {
+ for (ptrIndex--; ptrIndex; ptrIndex--) {
+ if (valuesPtr[ptrIndex]) {
+ free(valuesPtr[ptrIndex]);
+ }
+ }
+ }
+#else
+ if (protocol->write()) {
+ sql_print_error("ExtSQL, protocol write failed");
+ DBUG_RETURN(1);
+ }
+#endif
+
+ rowCount++; // keep track of the count if have a general LIMIT in effect.
+
+ } // end for - all requested times
+
+ } // end for - all instances
+
+
+ extsql_output_complete(thd, tstate);
+ DBUG_RETURN(0);
+
+} // end mysql_show_statistics
+
+
+// record a statistic_increment call
+void extsql_inc(ulong *V, ulong C)
+{
+
+#ifdef PGSQL
+ THD *thd = MyProc;
+ time_t log_sec, now_sec;
+#else
+ THD *thd = current_thd;
+ my_time_t log_sec, now_sec;
+#endif
+
+ pSTATS_CLASS_DATA stats_class_data;
+ STAT_VAR **var_ptr;
+ int i, var, offset, offsetLimit, classCount, found = 0, instance, maxVar, maxTime;
+ int threadID, command;
+ char *user = "", *host = "", *db = "", *proc_info = "";
+ int *statVerify = 0, *indexPtr = 0;
+
+ if (!Shared->extsql_active || Shared->extsql_disabled || STATS_DEBUG(STATS_DISABLE_INC)) {
+ return;
+ }
+
+#ifdef EXTSQL_50
+ // during init we stored just offsets from THD structure status_var to each stat
+ // for nonglobal items -- we got an address in V, need to determine if it is a real global
+ // or something incremented as part of a thread. We check to see if it is in the
+ // address range of the status_var structure of the current thread
+ char *off;
+ off = (char *) V;
+ if (off >= (char *)&(thd->status_var) && off < (char *)&(thd->status_var)+sizeof(thd->status_var)) {
+ V = (ulong *)(off - (char *)&(thd->status_var)) ;
+ if STATS_DEBUG(STATS_INC_VAR) sql_print_information(" altered to: 0x%x, base: 0x%x",
+ V, &(thd->status_var));
+ }
+#endif
+
+ // check against the list of Vars we are tracking
+ for (i = 0; i < Shared->varAddrCount; i++) {
+ if (Shared->varAddrTrackArray[i] == (char *) V) { // one we are tracking
+ found = 1;
+ break;
+ }
+ } // end for - all tracked vars
+
+ if (!found) {
+ return;
+ }
+
+#ifndef PGSQL
+ // ZZ ignore slow_launch_threads and early byte counts - unstable at this point
+ if (V == (ulong *) &slow_launch_threads || thd->command == COM_CONNECT) {
+ return;
+ }
+#endif
+
+ // input checks
+ if (!thd
+#ifndef PGSQL
+ || !thd->thread_id
+#endif
+ ) { // don't do thread zero for now
+ if STATS_DEBUG(STATS_INC_PARAMS) {
+ sql_print_information("ExtSQL: Got null thread or thd 0");
+ }
+ return;
+ }
+
+ extsql_init_proc_vars(&threadID, &command, &user, &db, &host, &proc_info, &indexPtr, &statVerify);
+
+ // we need something for these values
+ if (!user) {
+ user="(null)";
+ }
+
+ if (!host) {
+ host="(null)";
+ }
+
+ if (*statVerify != STATS_MAGIC_NUM) {
+ Shared->extsql_counter++; // ZZ - how many do we get?
+ return;
+ } // end if - badmagic
+
+
+ // too many warnings, turn it off
+ if (Shared->extsql_counter > STATS_WARNING_LIMIT) {
+ Shared->extsql_active = 0;
+ sql_print_warning("ExtSQL: deactivated due to high internal warning count(%d), dumping internals",
+ (int)Shared->extsql_counter);
+ extsql_stats_dump();
+ return;
+ }
+
+ if STATS_DEBUG(STATS_THREAD_CHK) {
+ extsql_thread_dump(thd, 0); // do a check of indexes, no output unless error
+ }
+
+ // we get time in seconds, for performance we only call localtime once/minute to do the min,hour,day conversions
+ // could use thd->start_time, always avail? ZZ
+ now_sec = time(NULL);
+
+ if (Shared->lastMin != (int)(now_sec/60)) { // we rolled over
+
+ // let's try and get the lock, if we fail, someone else doing rollover
+ if (pthread_mutex_trylock(&Shared->LOCK_stats_clock)) {
+ // nothing to do
+
+ } else {
+
+ struct tm now_date;
+ localtime_r(&now_sec, &now_date);
+
+ Shared->lastMin = (int)(now_sec/60);
+
+ // check all time for classes
+ classCount = 0;
+ for (stats_class_data = Shared->statData;
+ classCount < STATS_MAX_CLASSES && stats_class_data->maxInstance;
+ stats_class_data++, classCount++) {
+
+ int now_time;
+
+ switch (stats_class_data->timeUnits) {
+ case 'm':
+ now_time = now_date.tm_min;
+ break;
+
+ case 'h':
+ now_time = now_date.tm_hour;
+ break;
+
+ case 'd':
+ now_time = now_date.tm_mday;
+ break;
+
+ default:
+ now_time = now_date.tm_hour;
+ Shared->extsql_active = 0;
+ sql_print_error("ExtSQL: deactivated, got invalid time unit (%d)", stats_class_data->timeUnits);
+
+#ifdef PGSQL
+ pthread_mutex_unlock(&Shared->LOCK_stats_clock);
+#else
+ VOID(pthread_mutex_unlock(&Shared->LOCK_stats_clock));
+#endif
+ return;
+ }
+
+ if (now_time != stats_class_data->lastTime) { // rolled over
+ stats_class_data->lastTime = now_time;
+
+ // increment time and do checks
+ stats_class_data->time++;
+
+ if (stats_class_data->time >= stats_class_data->maxTime) { // reset to start
+ stats_class_data->time = 1; // zero index is used for totals
+ }
+
+ // create label, MM/DD HH:MM
+
+ if STATS_DEBUG(STATS_TIME_CHANGE) {
+ sql_print_information("ExtSQL, class %s, time change: cur clock time is %d, time index s %d",
+ stats_class_data->name, now_time, stats_class_data->time);
+ }
+
+ // reset counters for that time to zero for all variables
+ for (instance=0, maxVar = stats_class_data->maxVar, maxTime = stats_class_data->maxTime;
+ instance < stats_class_data->maxInstance; instance++) {
+ for (var=0; var < maxVar; var++) {
+
+ offset = ARRAY_INDEX(instance, var, maxVar, stats_class_data->time, maxTime);
+ offsetLimit = stats_class_data->dataEnd - stats_class_data->data;
+
+
+ // check to make sure offset isn't out of limits
+ if (offset < 0 || offset >= offsetLimit ) {
+ sql_print_warning("ExtSQL: warning, TIME reset offset of 0x%x (%d,%d,%d,%d,%d) for 0x%x class %s of thd %d/%s exceeds bound of 0x%x(0x%x)",
+ offset, instance, var, maxVar, stats_class_data->time, maxTime,
+ (uint)V, stats_class_data->name, threadID, command_name[command], offsetLimit, *statVerify);
+ Shared->extsql_counter++;
+ extsql_thread_dump(thd, 1);
+#ifdef PGSQL
+ pthread_mutex_unlock(&Shared->LOCK_stats_clock);
+#else
+ VOID(pthread_mutex_unlock(&Shared->LOCK_stats_clock));
+#endif
+ return;
+ }
+
+ stats_class_data->data[offset] = 0;
+
+ // store unix time
+ // we normally round it off to minutes/hours/days depending on units
+ if (!STATS_DEBUG(STATS_TIME_DETAIL)) {
+
+ switch (stats_class_data->timeUnits) {
+ case 'm':
+ log_sec = now_sec - (now_sec % 60);
+ break;
+
+ case 'h':
+ log_sec = now_sec - (now_sec % 3600);
+ break;
+
+ case 'd':
+ log_sec = now_sec - (now_sec % 3600);
+ break;
+
+ default:
+ now_time = now_date.tm_hour;
+ Shared->extsql_active = 0;
+ sql_print_error("ExtSQL: deactivated, got invalid time unit (%d)", stats_class_data->timeUnits);
+ return;
+ }
+
+ } else {
+
+ log_sec = now_sec;
+
+ } // end if/else - don't round off time
+
+ stats_class_data->timeLabels[stats_class_data->time] = log_sec;
+
+ } // end for - vars
+ } // end for - instances
+ } // end if - new time
+
+ } // end for - all classes
+
+#ifdef PGSQL
+ pthread_mutex_unlock(&Shared->LOCK_stats_clock);
+#else
+ VOID(pthread_mutex_unlock(&Shared->LOCK_stats_clock));
+#endif
+ } // end if-else - got the lock
+ } //end if - time rolled over
+
+
+ // ready to increment value
+ if STATS_DEBUG(STATS_INC_VAR) sql_print_information("ExtSQL: 0x%x by %d", (uint)V,(int)C);
+
+ // look for the value being tracked in all classes
+ classCount = 0;
+ for (stats_class_data = Shared->statData;
+ classCount < STATS_MAX_CLASSES && stats_class_data->maxInstance;
+ stats_class_data++, classCount++) {
+
+ var_ptr = stats_class_data->varIndex;
+ for (var = 0, maxVar = stats_class_data->maxVar, maxTime = stats_class_data->maxTime
+ ; var < maxVar ; var_ptr++,var++) {
+ if ((*var_ptr)->addr == (char *)V) { // we are tracking it
+
+ i = indexPtr[(int)classCount];
+
+ if (i < 0 || i >= stats_class_data->maxInstance) { // bound exceeded
+ sql_print_warning("ExtSQL: index (%d) bad value (0x%x/0x%x), V(0x%x), classCount(%d), thd(%d/%s/%s) user(%s), host(%s) db(%s) magic(0x%x)",
+ classCount, i, stats_class_data->maxInstance, (uint) V, classCount,
+ threadID, proc_info, command_name[command],
+ user, host, db, *statVerify);
+ Shared->extsql_counter++;
+ extsql_thread_dump(thd, 1);
+ return;
+ }
+
+ // increment it for the class for the 0 (summary time) and the current time
+ offset = ARRAY_INDEX(i, var, maxVar, stats_class_data->time, maxTime);
+ offsetLimit = stats_class_data->dataEnd - stats_class_data->data;
+
+ if STATS_DEBUG(STATS_INC_VAR) {
+ sql_print_information("ExtSQL, class %s, i (%d) incrementing %s by (%d), offset/Limit(%d/%d)",
+ stats_class_data->name, i, (*var_ptr)->name, (int) *V, offset, offsetLimit);
+ }
+
+ // check to make sure offset isn't out of limits
+ if (offset < 0 || offset >= offsetLimit ) {
+ sql_print_warning("ExtSQL: warning, DATA inc offset of 0x%x (%d,%d,%d,%d,%d) for 0x%x class %s of thd %d/%s exceeds bound of 0x%x(0x%x)",
+ offset, i, var, maxVar, stats_class_data->time, maxTime,
+ (uint)V, stats_class_data->name, threadID, command_name[command], offsetLimit, *statVerify);
+ Shared->extsql_counter++;
+ extsql_thread_dump(thd, 1);
+ return;
+ }
+
+ stats_class_data->data[offset] += C;
+
+ offset = ARRAY_INDEX(i, var, maxVar, 0, maxTime);
+ stats_class_data->data[offset] += C;
+ break; // check the next class
+ } // end if - match
+ } // end for - all vars
+
+ } // end for - all classes
+
+} // end function extsql_inc
+
+#ifdef EXTSQL_BINARY
+#include "../../../../../../../bin/checkParam.h"
+#endif
+
+
+// extsql_prep - invoked to set/confirm start type
+// OUTPUT: startType - STATS_INIT_FAILURE, _NORMAL, _RESET, _RELOAD
+// it will log an error message on _FAILURE
+// INPUT: confFile - may be NULL (startType = NORMAL). If present the files is scanned
+// for new global extsql vars: _class_list, _users, _reload_file, _debug, _license_key
+// and the startType is set to _RESET.
+// reload_file - may be NULL. If present and contents is valid, startType
+// set to _RELOAD, file is scanned to make sure hostname and class list matches.
+// NO global vars are changed!!
+// NOTE: At present only ONE of confFile and realodFile may be set, error otherwise.
+//
+void extsql_prep(int *startType, const char *confFile, char *reloadFile) {
+
+ // if no extsql_reload_file is present:
+ // mysql: reloadFile == 0
+ // pgsql: reloadFile[0] == 0
+
+ extsql_init_globals();
+
+ if (! STATS_DEBUG(STATS_ADMIN) ) { // always normal
+ *startType = STATS_INIT_NORMAL;
+ return;
+ }
+
+#ifdef PGSQL
+ if (!*startType && *reloadFile) *startType = STATS_INIT_RELOAD;
+#else
+ if (!*startType && reloadFile) *startType = STATS_INIT_RELOAD;
+#endif
+
+ if (*startType == STATS_INIT_RELOAD && reloadFile != NULL) {
+
+ // read reload file
+ File reloadHandle;
+ char *memPtr = NULL, *srcPtr = NULL, *tmpPtr = NULL, *tmpPtr2 = NULL;
+ int size, i, fieldLength;
+ char *rfVersion = NULL, *rfClassList = NULL, *rfHostname = NULL;
+ char *extsql_class_listNoWS; char hostname[FN_REFLEN];
+
+ if (gethostname(hostname, FN_REFLEN) < 0) {
+ strcpy(hostname, "localhost");
+ }
+
+ if ((reloadHandle = my_open(reloadFile, O_RDONLY|O_BINARY, MYF(0))) < 0 ) {
+ sql_print_information("ExtSQL: Specified reload_file could not be opened: %s", reloadFile);
+ *startType = STATS_INIT_FAILURE;
+ return;
+ }
+
+ if (!(size = extsql_read_section_bytes(reloadFile, reloadHandle, &memPtr,
+ "RELOAD", 0))) {
+ sql_print_error("ExtSQL: Error reading from file %s", reloadFile);
+ *startType = STATS_INIT_FAILURE;
+ return;
+ }
+
+ // find version, classlist and hostname
+ for (srcPtr = memPtr, i = 0; i < size; srcPtr++, i++) {
+
+ if (!strncmp(srcPtr, "host: ", 6)) { // found hostname
+ tmpPtr = srcPtr + strlen("host: ");
+ fieldLength = 0;
+ while (*tmpPtr != '\n') {
+ ++fieldLength;
+ ++tmpPtr;
+ }
+
+ rfHostname = strndup(srcPtr + strlen("host: "), fieldLength);
+ }
+
+ if (!strncmp(srcPtr, "EXT version: ", 17)) { // found extsql version
+ tmpPtr = srcPtr + strlen("EXT version: ");
+ fieldLength = 0;
+ while (*tmpPtr != '\n') {
+ ++fieldLength;
+ ++tmpPtr;
+ }
+
+ ++fieldLength; // we want the trailing '\n' here
+
+ rfVersion = strndup(srcPtr + strlen("EXT version: "), fieldLength);
+ }
+
+ if (!strncmp(srcPtr, "extsql_class_list: ", 19)) { // found class list
+ tmpPtr = srcPtr + strlen("extsql_class_list: ");
+ fieldLength = 0;
+
+ while (*tmpPtr != '\n') {
+ ++fieldLength;
+ ++tmpPtr;
+ }
+
+ rfClassList = strndup(srcPtr + strlen("extsql_class_list: "),
+ fieldLength);
+ }
+ }
+
+ // by here, all pointers should be set, or we've got a badly
+ // formatted reload file
+ if (!(rfVersion && rfClassList && rfHostname)) {
+ sql_print_error("ExtSQL: Malformatted reload file %s", reloadFile);
+ *startType = STATS_INIT_FAILURE;
+ return;
+ }
+
+ // check for mismatches that are okay, but require confirmation
+ if (strcmp(rfHostname, hostname)) {
+ sql_print_information("ExtSQL: hostname mismatch (file: %s, server: %s)",
+ rfHostname, hostname);
+ *startType = STATS_INIT_CONFIRM;
+ return;
+ }
+
+ if (strcmp(rfVersion, Shared->extsql_version+1)) {
+ sql_print_information("ExtSQL: version mismatch (file: %s, server: %s)",
+ rfVersion, Shared->extsql_version+1);
+ *startType = STATS_INIT_CONFIRM;
+ return;
+ }
+
+
+ // we need a duplicate of extsql_class_list without whitespace
+ extsql_class_listNoWS = extsql_strdup(Shared->extsql_class_list, MYF(MY_WME));
+ for (tmpPtr = Shared->extsql_class_list, tmpPtr2 = extsql_class_listNoWS;
+ *tmpPtr != '\0'; ++tmpPtr) {
+
+ if (!(*tmpPtr == ' ' || *tmpPtr == '\t'))
+ *tmpPtr2++ = *tmpPtr;
+ }
+
+ *tmpPtr2 = '\0';
+
+ if (strcmp(rfClassList, extsql_class_listNoWS)) {
+ sql_print_information("ExtSQL: class list mismatch (file: %s, server: %s)",
+ rfClassList, extsql_class_listNoWS);
+ *startType = STATS_INIT_CONFIRM;
+ return;
+ }
+
+ my_free(extsql_class_listNoWS, MYF(0));
+ my_free(rfHostname, MYF(0));
+ my_free(rfVersion, MYF(0));
+ my_free(rfClassList, MYF(0));
+ my_free(memPtr, MYF(0));
+
+ } else if (*startType == STATS_INIT_RESET && confFile != NULL) {
+
+ char line[2048];
+ FILE* conf = fopen(confFile, "r");
+
+ // parse conf file
+ if (conf == NULL) {
+ sql_print_error("ExtSQL: Unable to open conf file %s", confFile);
+ *startType = STATS_INIT_FAILURE;
+ return;
+ }
+
+ while (fgets(line, 1024, conf) != NULL) {
+
+ // lowercase directive name and strip all whitespace
+ bool foundEqual = false;
+ int equalPos = 0, readPos = 0, writePos = 0;
+ char *directive, *data;
+
+ while (line[readPos] != '\0') {
+
+ if (line[readPos] == '=') {
+ foundEqual = true;
+ equalPos = writePos;
+ }
+
+ if (!foundEqual && line[readPos] > 64 && line[readPos] < 91)
+ line[readPos] += 32;
+
+ if (!(line[readPos] == '\t' || line[readPos] == ' ' ||
+ line[readPos] == '\n' || line[readPos] == '"' ||
+ line[readPos] == '\'')) {
+ line[writePos] = line[readPos];
+ ++writePos;
+ }
+
+ ++readPos;
+ } // end while line
+
+ line[writePos] = '\0';
+
+ if (strncmp(line, "extsql_", 7)) continue;
+
+ directive = strndup(line, equalPos);
+ data = line + (equalPos + 1) * (sizeof(char));
+
+ // set the appropriate data member
+ if (!strcmp(directive, "extsql_class_list"))
+ Shared->extsql_class_list = extsql_strdup(data, MYF(MY_WME));
+ else if (!strcmp(directive, "extsql_users"))
+ extsql_users = extsql_strdup(data, MYF(MY_WME));
+ else if (!strcmp(directive, "extsql_reload_file"))
+ Shared->extsql_reload_file = extsql_strdup(data, MYF(MY_WME));
+ else if (!strcmp(directive, "extsql_debug"))
+ Shared->extsql_debug = atoi(extsql_strdup(data, MYF(MY_WME)));
+ else if (!strcmp(directive, "extsql_key")) {
+ extsql_key = extsql_strdup(data, MYF(MY_WME));
+ sql_print_information("ExtSQL: extsql_key %s", data);
+ }
+ else {
+ sql_print_error("ExtSQL: Unknown configuration directive: %s",
+ directive);
+ *startType = STATS_INIT_FAILURE;
+ }
+
+ } // end while read conf
+
+ } else {
+ *startType = STATS_INIT_NORMAL;
+ }
+}
+
+
+
+// extsql_init_globals - MySQL uses threads for each server, Postgres uses a separate process.
+// Shared memory is used to speed our operations, data seg is shared between threads in MySQL,
+// but separate in postgres. To keep common code we need to alloc the area for our globals,
+// store in section //GLOBALS a top of this file. Not really needed to MySQL, but doesn't hurt.
+// BIG code change, need to switch all refs to pointers!
+// my_malloc is ifdef'd for PGSQL to do the shared memory magic!
+// Return 1 on failure
+int extsql_init_globals() {
+
+#ifdef PGSQL
+ // we allocate a big hunk of shared memory
+ bool memFound = false;
+
+ ShmemPtr = (char *) ShmemInitStruct("ExtSQL Data", SHMEM_SIZE, &memFound);
+
+ if (!ShmemPtr) {
+ sql_print_error("ExtSQL extsql_init_globals: can't init shared mem area of %d bytes", SHMEM_SIZE);
+ return(1);
+ }
+
+ if STATS_DEBUG(STATS_DUMP_START) {
+ sql_print_information("ExtSQL extsql_init_globals: ShmemPtr at 0x%x, memFound(%d)", (uint)ShmemPtr, memFound);
+ }
+
+ if (memFound) { // issue warning, should have only been called once!
+
+ // set our two pointers again
+ MemLock = (slock_t *) ShmemPtr; // already initialized.
+ NextFree = (char **) ShmemPtr + sizeof(slock_t *);
+ return(0); // ZZ - not fatal?
+ }
+
+ // if we get here, FIRST and ONLY time through for original allocation.
+
+ // our MemLock and NextFree live at the start of the region.
+ // this is needed for the PGSQL version of extsql_malloc
+ MemLock = (slock_t *) ShmemPtr;
+ SpinLockInit(MemLock);
+ NextFree = (char **)ShmemPtr + sizeof(slock_t *);
+ *NextFree = (char *)NextFree + sizeof(NextFree);
+
+ // okay alloc the global space
+ Shared = (pGLOBAL) extsql_malloc(sizeof(GLOBAL), MYF(MY_WME | MY_ZEROFILL) );
+ if (!Shared) {
+ sql_print_error("ExtSQL extsql_init_globals: can't alloc shared area.");
+ return(1);
+ }
+
+ Shared->extsql_class_list = extsql_strdup(extsql_class_list, MYF(MY_WME));
+ Shared->extsql_key = extsql_strdup(extsql_key, MYF(MY_WME));
+ Shared->extsql_users = extsql_strdup(extsql_users, MYF(MY_WME));
+ Shared->extsql_version = extsql_strdup(extsql_version, MYF(MY_WME));
+ Shared->extsql_reload_file = extsql_strdup(extsql_reload_file, MYF(MY_WME));
+
+#else
+ static int didInit = 0;
+
+ if (!didInit) {
+ // THIS IS MYSQL, the Shared structure is static and already declared.
+ Shared->extsql_class_list = extsql_class_list;
+ Shared->extsql_key = extsql_key;
+ Shared->extsql_users = extsql_users;
+ Shared->extsql_version = extsql_version;
+ Shared->extsql_reload_file = extsql_reload_file;
+ didInit = 1;
+ } else {
+ return(0);
+ }
+
+ (void) pthread_mutex_init(&Shared->LOCK_stats_clock,MY_MUTEX_INIT_FAST);
+#endif
+
+ // take care of copying some startup global values
+ Shared->extsql_active = extsql_active;
+ Shared->extsql_counter = extsql_counter;
+ Shared->extsql_debug = extsql_debug;
+
+
+ if STATS_DEBUG(STATS_DUMP_START) {
+ sql_print_information("ExtSQL: Globals are active(%d), debug(%d), extsql_class_list(%s), extsql_version(%s), extsql_users(%s), extsql_reload_file(%s)",
+ (int)Shared->extsql_active, (int)Shared->extsql_debug, Shared->extsql_class_list,
+ Shared->extsql_version, Shared->extsql_users, Shared->extsql_reload_file);
+ }
+
+
+ return(0);
+
+} // end extsql_init_globals
+
+
+// Called to initialize tracking data structures, potentially reload with prior data.
+// We may be here from a NORMAL init, first time, or a RESET in the middle of a server run
+// or a RELOAD from a start or the middle of server run.
+// extsql_prep has already been invoked, so global extsql_ vars are set
+int extsql_init(char *extsql_classlist, int startType, char *reloadFile)
+{
+ int extsql_willbe_active = 1; // track state during init process, global extsql_active is
+ // always set to off during init.
+ int reloadFail = 0;
+
+ //extsql_class_list is a comma separated list of which define what we will
+ // be tracking, number of instances, times of data, and which variables
+ // "db,max-5,time-10,units-d(Com_show_tables,Com_show_variables),
+ // user,max-50,time-24,units-m(Bytes_sent,Bytes_received)"
+ // class_name, max-instance_limit, max-time_limit, units-(min|day|hour) (var_list)
+ char *parse_string, *malloc_addr;
+ char *token, *tmpPtr;
+ pSTATS_CLASS_DATA stats_class_data;
+ STAT_VAR **var_ptr = 0;
+ struct show_var_st *status_var_ptr = status_vars;
+ int found = 0, skip = 0, foundParen = 0, num = 0, i = 0, j = 0, size = 0, classCount = 0, totalSize = 0;
+ int thisDebug = 0; char timeUnit;
+
+ sql_print_information("ExtSQL start type(%s): %s", startTypeName[startType], Shared->extsql_version+1);
+
+ // allocate our global area
+ if (extsql_init_globals()) {
+ sql_print_error("ExtSQL: start aborted. Failed to alloc global shared mem.");
+ return(1);
+ }
+
+ // Shared->extsql_class_list = my_strdup(extsql_class_list, MYF(MY_WME));
+ // Shared->extsql_reload_file = my_strdup(extsql_reload_file, MYF(MY_WME));
+
+
+ Shared->extsql_active = 0; // will be set at end of this function if returned to active
+
+
+ if (startType == STATS_INIT_FAILURE) {
+ sql_print_error("ExtSQL: disabled. Start aborted due to prior errors");
+
+ // We do not set Shared->extsql_disabled, may just be a failed reload/reset, okay to try again.
+ return(1);
+ }
+
+
+#ifdef EXTSQL_BINARY
+
+ int status, days;
+
+ // license sequence is ONLY area for returns before end of function!
+ if (!extsql_key) {
+ sql_print_error("ExtSQL: disabled. No license key found for binary build, make sure to define ExtSQL_key in /etc/my.cnf.");
+ Shared->extsql_active = 0; // turn it all off
+ Shared->extsql_disabled = 1;
+ return(1);
+ }
+
+ if (status = checkParam(Shared->extsql_version+1, extsql_key, &days)) {
+ sql_print_error("ExtSQL: disabled. Improper license key found(%s), code %d.",
+ Shared->extsql_version+1, status);
+ Shared->extsql_active = 0; // turn it all off
+ Shared->extsql_disabled = 1; // turn it all off
+ return(1);
+ }
+
+ if (days == 99999) {
+ sql_print_information("ExtSQL: Permanent license verified.");
+
+ } else if (days < 31) {
+
+ // limited time
+ sql_print_warning("ExtSQL: Evaluation license good for server startup only %d more days.", days);
+
+ } else {
+
+ // expired
+ sql_print_error("ExtSQL: disabled. Evaluation period has expired.");
+ Shared->extsql_disabled = 1; // turn it all off
+ Shared->extsql_active = 0; // turn it all off
+ return(1);
+
+ }
+
+#endif
+
+ if (!extsql_users) {
+ sql_print_information("ExtSQL: no defined user list, only root user allowed");
+ extsql_users="root";
+ } else {
+ sql_print_information("ExtSQL: access allowed only to users: %s", extsql_users);
+ }
+
+ if (!extsql_class_list) {
+ extsql_willbe_active = 0; // turn it all off
+ Shared->extsql_disabled = 1; // turn it all off
+ Shared->extsql_active = 0; // turn it all off
+ sql_print_information("ExtSQL: deactivated by user, no extsql_class_list defined");
+ return(1);
+
+ } else {
+ extsql_willbe_active = 1;
+ }
+
+ //init our var addr tracking array to unstored
+ bzero((char *) Shared->varAddrTrackArray, sizeof(Shared->varAddrTrackArray));
+ Shared->varAddrCount = 0;
+
+ // if we are here because of a RESET, there should be something in the statAllocArray
+ // from prior - check to make sure -- if _NORMAL, we zero the whole thing.
+ if (startType != STATS_INIT_NORMAL) { // _RELOAD or _RESET
+
+ // wait just a bit for all threads to know we've stopped
+ Shared->extsql_reload_in_progress = 1;
+ sleep(2);
+
+ if (startType == STATS_INIT_RESET && ( ! Shared->statsAllocArray[0] || ! Shared->allocIndex) ) { // empty!
+ sql_print_error("ExtSQL: deactivated, RESET request failed, no prior data found.");
+ extsql_willbe_active = 0;
+
+ } else { // free up any existing for RELOAD or RESET
+
+ char *addr;
+ for (i = 0, addr = Shared->statsAllocArray[i]; (addr = Shared->statsAllocArray[i]) && i < STATS_MAX_NUM_ALLOC; i++) {
+ my_free(addr, MYF(0));
+ }
+ } // end if - memory clear necessary
+
+ } else {
+
+ Shared->extsql_reload_in_progress = 0;
+
+ } // end if-else startType other than NORMAL
+
+
+ bzero((char *) Shared->statsAllocArray, sizeof(Shared->statsAllocArray));
+ Shared->allocIndex = 0; // for recording mem allocations
+ bzero((char *) &Shared->statData, sizeof(Shared->statData)); // zero out all the contents, support restart - reload
+
+ if STATS_DEBUG(STATS_DUMP_START) sql_print_information("ExtSQL tracking classes: %s", extsql_class_list); //DEBUG
+
+ if (!(parse_string = extsql_strdup(extsql_class_list, MYF(MY_WME)))) {
+ Shared->extsql_active = 0;
+ Shared->extsql_disabled = 1;
+ Shared->extsql_reload_in_progress = 0;
+ sql_print_error( "ExtSQL: disabled, unable to dup extsql_class_list(%s)",
+ extsql_class_list);
+ return(1);
+
+ }
+
+ if (startType == STATS_INIT_NORMAL || startType == STATS_INIT_RESET) { // init structures on RESET/NORMAL starts, skip on RELOAD
+
+ int i = 0; // track our position in statVars
+ Shared->statsAllocArray[Shared->allocIndex++] = parse_string;
+ malloc_addr = parse_string;
+
+
+ while ( (token = strtok(parse_string, ", ")) ) { // start new loop on each class name
+
+ char **tPtr;
+ parse_string = NULL;
+ found = 0; num = 0;
+
+ // should have a class name
+ if (thisDebug) sql_print_information("ExtSQL, Class token is (%s)", token);
+
+
+ // is it allowable
+ for (tPtr = extsqlClassesSupported; *tPtr; tPtr++) {
+ if (!strcmp(token, *tPtr)) {
+ found = 1;
+ break;
+ }
+ } // end for - allowable class names
+
+ if (! found) {
+ extsql_willbe_active = 0;
+ sql_print_error("ExtSQL: deactivated, bad class name (%s)", token);
+ break;
+ }
+
+ // we have a valid class name, make sure it is not a dup
+ found = 0;
+ for (stats_class_data = Shared->statData; stats_class_data->name[0]; stats_class_data++) {
+ if (!strcmp(token, stats_class_data->name)) {
+ found = 1;
+ break;
+ }
+ } // end for - existing classes
+
+ if (found) {
+ extsql_willbe_active = 0;
+ sql_print_error("ExtSQL: deactivated, duplicate class name (%s)", token);
+ break;
+ }
+
+ // okay we have a good name, start loading the structure
+ strncpy(stats_class_data->name, token, STATS_MAX_NAME-1);
+
+ // set our starting time
+ stats_class_data->time = 0;
+
+
+ // get the next token, should be instance limit
+ if (! (token = strtok(parse_string, ", "))) {
+ extsql_willbe_active = 0;
+ sql_print_error("ExtSQL: deactivated, incomplete class definitions, started with (%s)",
+ extsql_class_list);
+ break;
+ }
+
+ // should start with max-
+ if (strncmp(token, "max-", 4)) {
+ extsql_willbe_active = 0;
+ sql_print_error("ExtSQL: deactivated, missing max instance amount, got (%s)",
+ token);
+ break;
+ }
+
+ // get the number for max instances and allocate space
+ num = atoi(token+4);
+ if (!num) {
+ extsql_willbe_active = 0;
+ sql_print_error("ExtSQL: deactivated, missing valid instance amount, got (%s)",
+ token);
+ break;
+ }
+ stats_class_data->maxInstance = num;
+
+ // we null term it by getting one more than required
+ if (!(stats_class_data->instanceIndex = (char **)extsql_malloc( ((num+1) * sizeof(char *)),
+ MYF(MY_WME | MY_ZEROFILL)) )) {
+ extsql_willbe_active = 0;
+ sql_print_error("ExtSQL: deactivated, can't allocate class instance memory");
+ break;
+ }
+ Shared->statsAllocArray[Shared->allocIndex++] = (char *)stats_class_data->instanceIndex;
+
+
+ // good instance limit, now get time limit
+ if (! (token = strtok(parse_string, ", "))) {
+ extsql_willbe_active = 0;
+ sql_print_error("ExtSQL: deactivated, incomplete class definitions, missing time limit, started with (%s)",
+ extsql_class_list);
+ break;
+ }
+
+ // should start with time-
+ if (strncmp(token, "time-", 5)) {
+ extsql_willbe_active = 0;
+ sql_print_error("ExtSQL: deactivated, missing max time amount, got (%s)",
+ token);
+ break;
+ }
+
+ // get the number for max times
+ num = atoi(token+5);
+ num += 1; // always the zero hour - totals
+ if (!num || num < 2) {
+ extsql_willbe_active = 0;
+ sql_print_error("ExtSQL: deactivated, missing valid time amount, got (%s)",
+ token);
+ break;
+ }
+ stats_class_data->maxTime = num;
+
+ // allocate space ZZ add to size count reported
+ if (!(stats_class_data->timeLabels = (my_time_t *)extsql_malloc( ((num+1) * sizeof(my_time_t)),
+ MYF(MY_WME | MY_ZEROFILL)) )) {
+ extsql_willbe_active = 0;
+ sql_print_error("ExtSQL: deactivated, can't allocate class time label memory");
+ break;
+ }
+ Shared->statsAllocArray[Shared->allocIndex++] = (char *) stats_class_data->timeLabels;
+
+ // get the time Units, m - minutes, h - hours, d - days
+ if (! (token = strtok(parse_string, ", "))) {
+ extsql_willbe_active = 0;
+ sql_print_error("ExtSQL: deactivated, incomplete class definitions, missing timeUnits started with (%s)",
+ token);
+ break;
+ }
+
+ // should start with units-
+ if (strncmp(token, "units-", 6)) {
+ extsql_willbe_active = 0;
+ sql_print_error("ExtSQL: deactivated, missing units amount, got (%s)",
+ token);
+ break;
+ }
+
+ // get the time units
+ timeUnit = *(token+6);
+ if (timeUnit == 'm') {
+ stats_class_data->timeUnits = 'm';
+ } else if (timeUnit == 'h') {
+ stats_class_data->timeUnits = 'h';
+ } else if (timeUnit == 'd') {
+ stats_class_data->timeUnits = 'd';
+ } else {
+ extsql_willbe_active = 0;
+ sql_print_error("ExtSQL: deactivated, missing valid time unit amount, got (%c)",
+ timeUnit);
+ break;
+ }
+
+ // set remaining vars
+ stats_class_data->maxVar = 0;
+ stats_class_data->lastTime = 0;
+
+ // okay, next token is var list like: (Com_show_tables,Com_show_variables) OR
+ // ( Com_.... )
+ // first and last token have parens
+ // clear out tmp storage
+ j = 0; // keep track of var tokens
+ i = 0;
+ foundParen = 0; // haven't seen closing paren
+ while (!foundParen && (token = strtok(parse_string, ", ")) ) {
+
+ if (thisDebug) sql_print_information("ExtSQL, variable token is (%s)", token);
+
+ // none of the tokens should be close to MAX_VAR_SIZE
+ if (strlen(token) > MAX_VAR_SIZE - 5) {
+ extsql_willbe_active = 0;
+ sql_print_error("ExtSQL, var name too long in var list (%s)",
+ token);
+ break;
+ }
+
+ // if we got a closing paren by itself, we're done
+ if (!strcmp(")", token)) {
+ break;
+ }
+
+ // should have a paren( on first one, move past that
+ if (!j) {
+ if (token[0] != '(') {
+ extsql_willbe_active = 0;
+ sql_print_error("ExtSQL, bad format in var list, missing ( in %s",
+ token);
+ break;
+ }
+
+ // okay, now we count the , from opening to closing paren, need to know
+ // how many vars there are so we can allocate space for pointer array to them
+ for (i = 0, num = 1, tmpPtr = token; *tmpPtr != ')'; tmpPtr++) {
+ if (*tmpPtr == ',') {
+ num++;
+ }
+ } // end for - token string
+
+ // we null term pointer array by alloc of one extra
+ if (!(stats_class_data->varIndex = (STAT_VAR **)extsql_malloc( ((num+1) * sizeof(pSTAT_VAR)),
+ MYF(MY_WME | MY_ZEROFILL)) )) {
+ extsql_willbe_active = 0;
+ sql_print_error("ExtSQL: deactivated, can't allocate class varIndex memory");
+ break;
+ }
+
+ Shared->statsAllocArray[Shared->allocIndex++] = (char *) stats_class_data->varIndex;
+ var_ptr = stats_class_data->varIndex; // pointer to array of pointer to each var we find below
+
+ // check to see if got just a ')', in that case we get the next
+ if (!strcmp(token, "(")) {
+ token = strtok(parse_string, ", ");
+ } else {
+ token++; // move off paren
+ }
+
+ if (thisDebug) sql_print_information("ExtSQL, FIRST variable token is (%s)", token);
+
+ } // end if - starting paren
+
+ if (token[strlen(token) - 1] == ')') { // last one
+ token[strlen(token) - 1] = '\0'; // null it out early
+ foundParen = 1;
+ if (thisDebug) sql_print_information("ExtSQL, LAST variable token is (%s)", token);
+ }
+
+ // unless the debug flag is set, check to see if allowed
+ if (!STATS_DEBUG(STATS_EXTRA_VARS)) {
+ char **varPtr; extsql_willbe_active = 0;
+ for (varPtr = allowedVars; *varPtr; varPtr++) {
+ if (!strcmp(*varPtr, token)) {
+ extsql_willbe_active = 1;
+ break;
+ } // end if
+ } // end for - all allowed
+
+ if (!extsql_willbe_active) {
+ sql_print_error("ExtSQL, requested tracking var (%s) not on approved list. Please check spelling and documenation. This setting can be overridden via debug flag (STATS_EXTRA_VARS)",
+ token);
+ break;
+ }
+ } // end if - check approved vars
+
+
+ j++; // token count
+
+ // we should now have a token, look for match in status_vars
+ found = 0; skip = 0;
+ for (status_var_ptr = status_vars; status_var_ptr->name; status_var_ptr++) {
+
+ if (thisDebug) sql_print_information("ExtSQL, status_var is %s(0x%x)",
+ status_var_ptr->name, (uint)status_var_ptr->value );
+
+ if (!strcmp(token, status_var_ptr->name)) { // match
+
+ if (!status_var_ptr->value && strcmp(token, "Questions")) { // no address assigned, not tracking this
+ // okay if Questions, we will fix below
+
+
+#ifdef EXTSQL_50
+ // okay if Bytes_received - first item
+ if (strcmp(token,"Bytes_received")) { // only okay for Bytes_received
+#endif
+ sql_print_error("ExtSQL, variable (%s) has no address, can not be tracked",
+ status_var_ptr->name);
+ extsql_willbe_active = 0;
+ break;
+#ifdef EXTSQL_50
+ }
+#endif
+ } // end if - no address
+
+ // allocate room for the structure itself, put the address in the pointer array
+ if (!(*var_ptr = (STAT_VAR *)extsql_malloc( (sizeof(STAT_VAR)),
+ MYF(MY_WME | MY_ZEROFILL)) )) {
+ extsql_willbe_active = 0;
+ skip = 1;
+ sql_print_error("ExtSQL: deactivated, can't allocate class var memory");
+ break;
+ }
+
+ Shared->statsAllocArray[Shared->allocIndex++] = (char *) *var_ptr;
+
+ if (!((*var_ptr)->name = extsql_strdup(status_var_ptr->name, MYF(MY_WME)))) {
+ extsql_willbe_active = 0;
+ sql_print_error( "ExtSQL: deactivated, unable to alloc for (%s)",
+ status_var_ptr->name);
+ break;
+ } // end if - malloc
+
+ Shared->statsAllocArray[Shared->allocIndex++] = (*var_ptr)->name;
+
+#ifdef PGSQL
+ (*var_ptr)->addr = (char *)status_var_ptr->value;
+#else
+
+ // SPECIAL here, if the value is Connections or Questions, we override with our internal
+ // tracking variable address (connects or queries) -- special case for them.
+ if (!strcmp(token, "Questions")) {
+ (*var_ptr)->addr = (char *)&Shared->queries;
+ } else if (!strcmp(token, "Connections")) {
+ (*var_ptr)->addr = (char *)&Shared->connects;
+ } else { // regular
+ (*var_ptr)->addr = (char *)status_var_ptr->value;
+ }
+#endif
+
+ found = 1;
+ if (thisDebug) sql_print_information("ExtSQL: tracking varIndex[%d] var(%s), addr(0x%x)\n",
+ i, (*var_ptr)->name, (uint)(*var_ptr)->addr);
+ (uint)stats_class_data->maxVar++;
+ i++;
+
+ // store the addr in our quick look up array, only if its not already there
+ if (extsql_store_var_addr((*var_ptr)->addr)) {
+ extsql_willbe_active = 0;
+ break;
+ }
+
+ break ; // look for next one
+
+ } // end if - match
+
+ } // end for - more status vars
+
+ if (skip) { // we missed a variable that had a zero address, that is okay.
+ continue;
+ }
+
+ if (! found ) { // could not complete match on one of their variables
+ extsql_willbe_active = 0;
+ sql_print_error( "ExtSQL: deactivated, could not complete variable match for (%s)",
+ token);
+ }
+
+ if (! extsql_willbe_active || ! stats_class_data->maxVar) { // had failure somewhere above
+ extsql_willbe_active = 0;
+ break;
+ }
+ var_ptr++;
+
+ } // end while - more tokens in var list
+
+ if (! extsql_willbe_active) { // had a failure above
+ break;
+ }
+
+ } // end while - more token in class definitions
+
+ } else if (startType == STATS_INIT_RELOAD) {
+
+ // make copy of class list in the event of failure
+ char* oldClassList = extsql_strdup(extsql_class_list, MYF(MY_WME));
+
+ if (extsql_reload(STATS_READ_RELOAD, reloadFile)) { // reload failed
+
+ sql_print_error("ExtSQL: Reload FAIL--resetting class list OLD(%s), NEW(%s)",
+ oldClassList, extsql_class_list);
+
+ // restore old class list
+ extsql_class_list = oldClassList;
+
+ // reset
+ startType = STATS_INIT_RESET;
+ extsql_willbe_active = 1; // reload should log error
+ reloadFail = 1; // flag to return error status
+ }
+
+ } // end if-else startType (NORMAL, RESET or RELOAD
+
+
+ if (extsql_willbe_active) { // calculate data sizes for each class and print what we got
+ size = 0;
+
+ for (stats_class_data = Shared->statData, classCount = 0;
+ classCount < STATS_MAX_CLASSES && stats_class_data->maxInstance;
+ stats_class_data++, classCount++) {
+
+ if STATS_DEBUG(STATS_DUMP_START) sql_print_information("ExtSQL, class %s, max inst %d, max vars %d, max time %d %d",
+ stats_class_data->name, stats_class_data->maxInstance,
+ stats_class_data->maxVar, stats_class_data->maxTime,
+ stats_class_data->timeUnits);
+
+ // loop through all vars
+ for (var_ptr = stats_class_data->varIndex, i = 0; i < stats_class_data->maxVar;
+ var_ptr++, i++) {
+ if STATS_DEBUG(STATS_DUMP_START) sql_print_information(" Var %s at addr 0x%x", (*var_ptr)->name, (uint)(*var_ptr)->addr);
+ } // end for all vars defined
+
+ size = stats_class_data->maxInstance * stats_class_data->maxVar *
+ stats_class_data->maxTime * sizeof(ulong);
+
+ // if NOT RELOAD (a NORMAL OR RESET start) allocate data space
+ if (startType != STATS_INIT_RELOAD) {
+ if (!(stats_class_data->data = (ulong *)extsql_malloc(size, MYF(MY_WME | MY_ZEROFILL)) )) {
+ extsql_willbe_active = 0;
+ sql_print_error("ExtSQL: deactivated, failed to alloc %d bytes for class %s data",
+ size, stats_class_data->name);
+ break;
+ }
+
+ Shared->statsAllocArray[Shared->allocIndex++] = (char *)stats_class_data->data;
+ stats_class_data->dataEnd = stats_class_data->data + size/sizeof(ulong);
+ }
+
+ // set end marker
+ if STATS_DEBUG(STATS_DUMP_START) sql_print_information(" Data allocated %d bytes, data start at 0x%x, end at 0x%x",
+ size, (uint)stats_class_data->data, (uint)stats_class_data->dataEnd);
+ totalSize += size;
+
+#ifdef PGSQL
+ if (totalSize + SHMEM_RESERVE > SHMEM_SIZE) {
+ extsql_willbe_active = 0;
+ sql_print_error("ExtSQL: deactivated, projected mem usage (%d) too close to limit of %d",
+ size, SHMEM_SIZE);
+ }
+#endif
+
+ } // end for - all classes
+ } // end if - stats will be active
+
+ if (startType != STATS_INIT_NORMAL) { // RELOAD or RESET, clear any stored thread instance info
+
+#ifndef PGSQL
+
+ // loop through ALL threads and zero indexes
+ i = 1;
+ while (pthread_mutex_trylock(&LOCK_thread_count)) { // didn't get it, do UNLOCK!!!!
+ sleep(i++);
+ sql_print_information("ExtSQL: Trying to completed RELOAD/RESET, can't get lock, sleeping for (%d)",i);
+ if (i > 5) {
+ extsql_willbe_active = 0;
+
+ VOID(pthread_mutex_unlock(&LOCK_thread_count));
+ break;
+ }
+ } // end while - get thread lock
+
+
+ if (extsql_willbe_active) { // loop through all threads
+
+ I_List_iterator it(threads);
+ THD *tmp;
+ int *indexPtr, *statVerify;
+
+ while ((tmp=it++)) {
+ extsql_thread_init(tmp, STATS_THD_INIT_ALL);
+ } // end while - more threads
+
+ } // end if - extsqlwillbeactive
+
+ VOID(pthread_mutex_unlock(&LOCK_thread_count));
+#endif
+
+#ifdef NEVER__
+ }
+#endif
+
+ } // end if - RELOAD or RESET
+
+ if (extsql_willbe_active) {
+ Shared->extsql_active = 1;
+ sql_print_information("ExtSQL ACTIVE allocated memory: %d bytes for %d classes",
+ totalSize, classCount);
+ } else {
+ sql_print_information("ExtSQL NOT ACTIVE");
+ Shared->extsql_active = 0;
+ }// end if - stats active
+
+ Shared->extsql_reload_in_progress = 0; // in all cases.
+
+ if (Shared->extsql_active && !reloadFail) {
+ return(0);
+ } else {
+ return(1);
+ }
+
+} // end extsql_init
+
+
+// extsql_init_proc_vars - is used to abstract the different locations in which both
+// MySQL and Postgres store process/status info
+// this is always with respect to the current thread -- not all are available for both!
+static void extsql_init_proc_vars(int *threadID, int *command, char **user, char **db, char **host,
+ char **proc_info, int **indexPtr, int **statVerify) {
+
+#ifdef PGSQL
+ THD *thd = MyProc;
+#else
+ THD *thd = current_thd;
+#endif
+
+#ifdef PGSQL
+ *user = MyProcPort->user_name;
+ *statVerify = &thd->statVerify;
+ *indexPtr = thd->statIndex;
+ *proc_info = "n/a";
+ *host = "n/a";
+ *command = 1;
+ *threadID = getpid();
+#else
+
+#ifdef EXTSQL_50
+ *user = thd->security_ctx->user;
+ *host = thd->security_ctx->host;
+ *statVerify = &thd->security_ctx->statVerify;
+ *indexPtr = thd->security_ctx->statIndex;
+#else
+ *user = thd->user;
+ *host = thd->host;
+ *statVerify = &thd->statVerify;
+ *indexPtr = thd->statIndex;
+#endif
+
+ // more just MySQL
+ *command = thd->command;
+ *proc_info = (char *)thd->proc_info;
+ *threadID = thd->thread_id;
+#endif
+
+#ifdef PGSQL
+ *db = MyProcPort->database_name;
+#else
+ *db = thd->db;
+#endif
+
+
+} // end extsql_init_proc_vars
+
+// this function prints hex bytes from the startAddr for size
+static void extsql_print_bytes(char *startAddr, int size) {
+
+ char *tmpPtr;
+ int i;
+ char buff[120] = {'\0'};
+
+ for (i = 0, tmpPtr=startAddr; i < size; tmpPtr++, i++) {
+
+ if (!(i%8) && strlen(buff)) {
+ sql_print_information("ExtSQL: 0x%x - %s", (uint)startAddr+i, buff);
+ buff[0] = '\0';
+ }
+ sprintf(buff+strlen(buff), "0x%x (0x%x) / ", i, *tmpPtr);
+
+ } // end for - entire string
+
+ if (strlen(buff)) {
+ sql_print_information("ExtSQL: 0x%x - %s", (uint)startAddr+i, buff);
+ }
+
+} // end extsql_print_bytes
+
+
+// this utility function reds a section header in a
+// RELOAD file and stores to address of memPtr,
+// as input if memPtr is zero, this function allocates memory and it must be
+// freed by caller. If memPtr is nonzero, we assume caller has allocated space!
+// returns 0 on error, hdr is the name of the header we should be reading
+// num is context for an error.
+int extsql_read_section_bytes(char *fileName, File fileDes, char **memPtr,
+ char *hdr, int num) {
+
+ char buff[80];
+ int size;
+
+
+ // read the section hdr
+ if (my_read(fileDes, buff, STATS_SECTION_HDR, MYF(MY_WME)) != STATS_SECTION_HDR) {
+ sql_print_error("ExtSQL: Section header byte count read failed on file %s, (%s/%d)",
+ fileName, hdr, num);
+ return(0);
+ }
+
+ if (!strstr(buff, hdr)) { // missing
+ sql_print_error("ExtSQL: Section header from file %s unexpected, got %s, wanted %s",
+ fileName, buff, hdr);
+ return(0);
+ }
+
+ size = atoi(buff + STATS_SECTION_BYTES);
+
+ if (size <= 0) {
+ sql_print_error("ExtSQL: Section header bad size (%d) on file %s, (%s/%d)",
+ size, fileName, hdr, num);
+ return(0);
+ }
+
+
+ if (*memPtr == NULL) { // alloc memory for the data
+ if (!(*memPtr = (char *)extsql_malloc(size, MYF(MY_WME | MY_ZEROFILL)))) {
+ sql_print_error("ExtSQL: Could not alloc %d bytes to read data on file %s, (%s/%d)",
+ size, fileName, hdr, num);
+ return(0);
+ }
+ }
+
+ if (my_read(fileDes, *memPtr, size, MYF(MY_WME)) != size) {
+ sql_print_error("ExtSQL: Section header data read failed on file %s for %d bytes, (%s/%d)",
+ fileName, size, hdr, num);
+ return(0);
+ }
+
+ return(size);
+} // end extsql_read_section_bytes
+
+
+// extsql_write_section_hdr - writes the header for a section to the RELOAD
+// file. The hdr should curretnly be 6 chars in length. The size is the
+// size of the data to be stored in that section.
+// Returns non zero on error, puts msg in error log.
+static int extsql_write_section_hdr(char *loadFileName, File reloadFile, char *hdr, int size) {
+
+ char buff[60];
+
+ if (strlen(hdr) != 6) {
+ sql_print_error("ExtSQL: Bad header length for %s", hdr);
+ return(1);
+ }
+
+ sprintf(buff, "\nEXT %s: %09d\n", hdr, size);
+
+ if (strlen(buff) != STATS_SECTION_HDR) { // sanity check
+ sql_print_error("ExtSQL: Bad length for %s section hdr, %d/%d",
+ hdr, STATS_SECTION_HDR, strlen(buff));
+ return(1);
+ }
+
+
+ if (my_write(reloadFile, (byte*) buff, STATS_SECTION_HDR, MYF(MY_WME)) != STATS_SECTION_HDR) {
+ sql_print_error("ExtSQL: Could not write %s header section to RELOAD file %s (%d/%d)",
+ hdr, loadFileName, size, reloadFile);
+ return(1);
+ }
+
+ return(0);
+
+} // end - extsql_write_section_hdr
+
+
+// manage reload data - this function take care of reading/write reload data.
+// WRITE_RELOAD: It creates the file used for the RELOAD command, most of it
+// consists of binary data, but the first few lines are in ASCII so that a 'head' can
+// be done on the file to extract general info
+// READ_RELOAD: Reads in file, sets globa statData and extsql_class_list to what is found
+// in the file.
+// IN: action (STATS_WRITE_RELOAD, STATS_READ_RELOAD)
+// IN: loadFileName (name of reload file to read/write)
+// GLOBALS: will read/write extsql_class_list and statData
+int extsql_reload(int action, char *loadFileName) {
+
+ File reloadFile; // a file descriptor
+ char buff[STATS_TMP_BUFF_SIZE];
+ char *memPtr; // memPtr holds dynamic alloc, needs to be freed!
+ my_time_t now_sec;
+ MYSQL_TIME mysql_time;
+
+#ifndef PGSQL
+ THD *thd = _current_thd();
+#endif
+
+ char dateBuff[80];
+#define CLASS_SIZE 8192
+ char classBuff[CLASS_SIZE];
+ char *srcPtr, *destPtr, *actionStr, *className, **ptrPtr;
+
+ pSTATS_CLASS_DATA stats_class_data;
+ int maxVar, maxTime, maxInstance, var, found, instance, classCount, size, size2, mode, i;
+ int numClasses;
+ char hostname[FN_REFLEN]; // defined in my_global.h
+
+ if (! STATS_DEBUG(STATS_ADMIN)) { // disabled
+ sql_print_information(adminDisabled);
+ return(0);
+ }
+
+ if (gethostname(hostname, FN_REFLEN) < 0) { // failed
+ strcpy(hostname, "localhost");
+ }
+
+ // Shared->extsql_debug |= STATS_RELOAD;
+
+ if (action == STATS_WRITE_RELOAD) { // set some params
+ mode = O_WRONLY|O_CREAT|O_BINARY;
+ actionStr = "write/store";
+ } else if (action == STATS_READ_RELOAD) {
+ mode = O_RDONLY|O_BINARY;
+ actionStr = "read/restore";
+ } else {
+ sql_print_error("ExtSQL: unexpected reload request (%d)", action);
+ return(1);
+ }
+
+ if (strlen(Shared->extsql_class_list) >= CLASS_SIZE) {
+ sql_print_error("ExtSQL: extsql_class_list too long for configured limit, can't save RELOAD data.");
+ return(1);
+ }
+
+ // open the file
+ if ((reloadFile= my_open(loadFileName, mode, MYF(0))) < 0 ) {
+ sql_print_error("ExtSQL: Unable to open %s for %s of RELOAD data, aborted (%d).",
+ loadFileName, actionStr, errno);
+ return(1);
+ }
+ sql_print_information("ExtSQL: (%s) Reload file is %s, Current active extsql_class_list is %s",
+ actionStr, loadFileName, Shared->extsql_class_list);
+
+ // get the current date/time, do any conversions
+ now_sec = time(NULL);
+
+#ifdef PGSQL
+ // need time convesion ZZ
+ mysql_time = now_sec;
+#else
+ thd->variables.time_zone->gmt_sec_to_TIME(&mysql_time, (my_time_t) now_sec);
+#endif
+
+ my_datetime_to_str(&mysql_time, dateBuff);
+
+ // strip ALL blanks from current class_list, count classes
+ numClasses = 0;
+ for (srcPtr=Shared->extsql_class_list, destPtr=classBuff; *srcPtr; srcPtr++) {
+
+ if (*srcPtr != ' ' && *srcPtr != '\t') {
+ *destPtr++ = *srcPtr;
+ }
+
+ if (*srcPtr == ')') {
+ numClasses++;
+ }
+ } // end for - all chars
+
+ // null term
+ *destPtr = '\0';
+
+ // write/read the header lines first, following format, designed to allow grep "EXT" to show
+ // useful info:
+ //
+ // line 0 - "\nEXT RELOAD: 000000025\n (ALL section headers, 12 char prefix, 9 char size
+ // line 1 - "EXT data stored on: date/time\n"
+ // line 2 - "EXT From host: bit.bongo.com\n"
+ // line 3 - "EXT extsql version: version\n"
+ // line 4 - "EXT\n"
+ // line 3 - "EXT ExtSQL extsql_class_list: db,max-130,time-100,units-m,(Binlog_cache_disk_use,Binlog_cache_use...\n"
+ // line 5 - "EXT\n";
+
+ if (action == STATS_WRITE_RELOAD) {
+
+ sprintf(buff, "\
+EXT data stored: %s\n\
+EXT from host: %s\n\
+EXT version: %s\n\
+EXT num classes: %d\n\
+EXT\n\
+EXT extsql_class_list: %s\n\
+EXT\n", dateBuff, hostname, Shared->extsql_version+1, numClasses, classBuff);
+
+
+ if (extsql_write_section_hdr(loadFileName, reloadFile, "RELOAD", strlen(buff))) {
+ return(1);
+ }
+
+ if (my_write(reloadFile, (byte*) buff, strlen(buff), MYF(MY_WME)) != strlen(buff)) {
+ sql_print_error("ExtSQL: Could not %s header data to RELOAD file %s", actionStr, loadFileName);
+ return(1);
+ }
+
+ } else { // READ
+
+ char *classListStart;
+
+ memPtr = NULL; // read_section_bytes will alloc space
+ if (!(size = extsql_read_section_bytes(loadFileName, reloadFile, &memPtr,
+ "RELOAD", 0))) {
+ return(1);
+ }
+
+ // find the stored class list.
+ found = 0;
+ for (srcPtr = memPtr, i = 0; i < size; srcPtr++, i++) {
+ if (!strncmp(srcPtr, "extsql_class_list:", 18)) { // found it
+ found = 1;
+ classListStart = srcPtr + strlen("extsql_class_list: ");
+ break;
+ }
+
+ } // end for - all chars in header
+
+ if (!found) {
+ sql_print_error("ExtSQL: Could not find class info in %s, section size (%d) (%s)",
+ loadFileName, size, memPtr);
+ my_free(memPtr, MYF(0));
+ return(1);
+ }
+
+ // NULL term the class list
+ for (i = 0; *(srcPtr+i) != '\n'; i++) ;
+ *(srcPtr+i) = '\0'; // null term
+
+ // check for new class list
+ if (strncmp(classListStart, classBuff, strlen(classBuff)) ||
+ strlen(classListStart) != strlen(classBuff)) {
+
+ char *numClassPtr;
+
+ if (!(Shared->extsql_class_list = extsql_strdup(srcPtr, MYF(MY_WME)))) {
+ sql_print_error("ExtSQL: reload failed, unable to alloc space for new class list");
+ return(1);
+ }
+
+ // check the number of classes present
+ numClasses = 0;
+ if (!(numClassPtr = strstr(memPtr, "num classes: "))) {
+ sql_print_error("ExtSQL: failed to find class count in reload file");
+ return(1);
+ }
+ numClasses = atoi(numClassPtr + strlen("num classes: "));
+
+
+ sql_print_information("ExtSQL: %d classes found, new class list will be loaded: %s",
+ numClasses, Shared->extsql_class_list);
+
+ } // end if - new class list
+
+ my_free(memPtr, MYF(0));
+
+ } // end if - else (first section)
+
+ if STATS_DEBUG(STATS_RELOAD) {
+ sql_print_information("ExtSQL: during %s on %s, completed section RELOAD", actionStr, hostname);
+ }
+
+ // loop and read/write each class data to/from the RELOAD file
+ classCount = 0;
+ for (stats_class_data = Shared->statData; classCount < STATS_MAX_CLASSES && classCount < numClasses;
+ stats_class_data++, classCount++) {
+
+ STAT_VAR **statPtr;
+
+
+ // -- below section repeated for each class
+ // -- write the binary data in sections, each unique section preceded by byte count that follows
+ // line 6 - "\nEXT CLAS n: 000000000\n" (class number, 0..n
+ // - structure STATS_CLASS_DATA
+
+ sprintf(buff, "CLAS %1d", classCount);
+
+ if (action == STATS_WRITE_RELOAD) {
+
+ if (extsql_write_section_hdr(loadFileName, reloadFile, buff, sizeof(STATS_CLASS_DATA))) {
+ return(1);
+ }
+
+ if (my_write(reloadFile, (byte*) stats_class_data, sizeof(STATS_CLASS_DATA),
+ MYF(MY_WME)) != sizeof(STATS_CLASS_DATA)) {
+ sql_print_error("ExtSQL: Could not %s class %d header data to RELOAD file %s", actionStr,
+ classCount, loadFileName);
+ return(1);
+ }
+
+ } else { // READ
+
+ memPtr = (char *) stats_class_data;
+ if (!extsql_read_section_bytes(loadFileName, reloadFile, &memPtr,
+ buff, classCount)) {
+ return(1);
+ }
+
+ }
+
+ className = stats_class_data->name;
+ maxVar = stats_class_data->maxVar;
+ maxTime = stats_class_data->maxTime;
+ maxInstance = stats_class_data->maxInstance;
+
+
+ // sanity check, make sure the className is on our supported list
+ for (i = 0, ptrPtr=extsqlClassesSupported; i < STATS_MAX_CLASSES; i++, ptrPtr++) {
+
+ found = 0;
+ if (! strcmp(className, *ptrPtr)) {
+ found = 1;
+ break;
+ }
+ } // end for - all supported classes
+
+ if (!found) {
+ sql_print_error("ExtSQL: Bad class name found (%s)", className);
+ return(1);
+ }
+
+ // print out summary info on the CLASS
+ if STATS_DEBUG(STATS_RELOAD) {
+ sql_print_information("ExtSQL: During reload (%s), starting section %s", actionStr, buff);
+ sql_print_information("CLASS is %s, maxInstance(%d), maxVar(%d), maxTime(%d), time(%d), \
+timeUnits(%c), lastTime(%d)",
+ stats_class_data->name, maxInstance, maxVar, maxTime,
+ stats_class_data->time, stats_class_data->timeUnits,
+ stats_class_data->lastTime);
+ }
+
+ // - "\nEXT INSTNC: 3400\n"
+ // - instanceNames 1..n from char **instanceIndex
+
+ if (action == STATS_WRITE_RELOAD) {
+
+ // count the size of what we have
+ size = 0;
+ for (instance = 0; instance < maxInstance && stats_class_data->instanceIndex[instance];
+ instance++) {
+ size += strlen(stats_class_data->instanceIndex[instance]) + 1; // don't forget the NULL!
+ } // end for - all class instances
+
+ if (!(memPtr = (char *)extsql_malloc(size, MYF(MY_WME | MY_ZEROFILL)))) {
+ sql_print_error("ExtSQL: Could not alloc %d bytes to write instance data for class %d",
+ size, classCount);
+ return(1);
+ }
+
+ // write the data to memPtr
+ size = 0;
+ for (instance = 0; instance < maxInstance && stats_class_data->instanceIndex[instance];
+ instance++) {
+ strcpy(memPtr + size, stats_class_data->instanceIndex[instance]);
+
+ if STATS_DEBUG(STATS_RELOAD) sql_print_information("ExtSQL: INSTNC (%d/%s)",
+ instance, memPtr+size);
+
+ size += strlen(stats_class_data->instanceIndex[instance]);
+ size++; // don't forget the NULL!
+
+ } // end for - all class instances
+
+
+ if (extsql_write_section_hdr(loadFileName, reloadFile, "INSTNC", size)) {
+ my_free(memPtr, MYF(0));
+ return(1);
+ }
+
+ if (my_write(reloadFile, (byte*) memPtr, size,
+ MYF(MY_WME)) != size) {
+ sql_print_error("ExtSQL: Could write instance data to RELOAD file %s for %d",
+ loadFileName, classCount);
+ my_free(memPtr, MYF(0));
+ return(1);
+ }
+
+ my_free(memPtr, MYF(0));
+
+ } else { // READ
+
+ memPtr = NULL;
+ if (!(size2 = extsql_read_section_bytes(loadFileName, reloadFile, &memPtr,
+ "INSTNC", classCount))) {
+ return(1);
+ }
+
+ // allocate memory to hold the instanceIndex array!
+ if (!(stats_class_data->instanceIndex = (char **)extsql_malloc( ((maxInstance+1) * sizeof(char *)),
+ MYF(MY_WME | MY_ZEROFILL)) )) {
+ sql_print_error("ExtSQL: Could not alloc space for instanceIndex, RELOAD file %s for %d",
+ loadFileName, classCount);
+ return(1);
+ }
+
+
+ // move the data from buffer to memory, it is a long sequence of null
+ // terminated instance names.
+ // careful, we limit ourselves based not on the max supported, but how many
+ // instances we really had.
+ size = 0;
+ for (instance = 0, srcPtr = memPtr; instance < maxInstance && srcPtr - memPtr < size2; instance++) {
+
+ size = strlen(srcPtr) + 1; // don't forget the NULL
+
+ if (!(destPtr = extsql_malloc(size, MYF(MY_WME | MY_ZEROFILL)))) {
+ sql_print_error("ExtSQL: Memory alloc failed on instance(%d), class(%d)",
+ instance, classCount);
+ my_free(memPtr, MYF(0));
+ return(1);
+ }
+
+ strcpy(destPtr, srcPtr);
+ stats_class_data->instanceIndex[instance] = destPtr;
+ srcPtr += size;
+
+ if STATS_DEBUG(STATS_RELOAD) sql_print_information("ExtSQL: INSTNC (%d/%s)",
+ instance, stats_class_data->instanceIndex[instance]);
+
+ // sql_print_information("ExtSQL: On read, instance(%d) at addr (0x%x), at (%s)", instance, destPtr, destPtr);
+ } // end for - all instance names
+
+ my_free(memPtr, MYF(0));
+
+ }
+
+ if STATS_DEBUG(STATS_RELOAD) {
+ sql_print_information("ExtSQL: during %s, completed section INSTNC, class (%d)",
+ actionStr, classCount);
+ }
+
+ // - "\nEXT VAR___: 2343\n"
+ // - structure STAT_VAR from STAT_VAR **varIndex
+
+ if (action == STATS_WRITE_RELOAD) {
+
+ // count the size of what we have, this is an array of pointers to structures, store
+ // the addr and the string
+ statPtr = stats_class_data->varIndex;
+ size = 0;
+ for (var = 0; var < maxVar; var++, statPtr++) {
+ size += sizeof(char *) + strlen((*statPtr)->name) + 1;
+ }
+
+ if (!(memPtr = (char *)extsql_malloc(size, MYF(MY_WME | MY_ZEROFILL)))) {
+ sql_print_error("ExtSQL: Could not alloc %d bytes to write varIndex data for class %d",
+ size, classCount);
+ return(1);
+ }
+
+ // write the data to buffPtr (address, followed by null term name)
+ statPtr = stats_class_data->varIndex;
+ size = 0;
+ for (var = 0; var < maxVar; var++, statPtr++) {
+ ptrPtr = (char **)(memPtr+size);
+ *ptrPtr = (*statPtr)->addr; // ZZ - var addr may not match on restart?
+ size += sizeof (char *);
+ strcpy(memPtr+size, (*statPtr)->name);
+ size += strlen((*statPtr)->name);
+ if STATS_DEBUG(STATS_RELOAD) sql_print_information("ExtSQL: VAR (%d / %s / 0x%x)",
+ var, (*statPtr)->name, (uint)(*statPtr)->addr);
+ *(memPtr+size++) = '\0'; // don't forget the NULL
+ }
+
+ if (extsql_write_section_hdr(loadFileName, reloadFile, "VAR___", size)) {
+ my_free(memPtr, MYF(0));
+ return(1);
+ }
+
+
+ if (my_write(reloadFile, (byte*) memPtr, size,
+ MYF(MY_WME)) != size) {
+ sql_print_error("ExtSQL: Could write varIndexdata to RELOAD file %s for %d",
+ loadFileName, classCount);
+ my_free(memPtr, MYF(0));
+ return(1);
+ }
+
+ my_free(memPtr, MYF(0));
+
+ } else { // READ
+
+ memPtr = NULL;
+ if (!(size2 = extsql_read_section_bytes(loadFileName, reloadFile, &memPtr,
+ "VAR___", classCount))) {
+ return(1);
+ }
+
+ // alloc memory for the complete var index of pointers
+ if (!(stats_class_data->varIndex = (STAT_VAR **)extsql_malloc( ((maxVar+1) * sizeof(pSTAT_VAR)),
+ MYF(MY_WME | MY_ZEROFILL)) )) {
+ sql_print_error("ExtSQL: Could not alloc space for varIndex, RELOAD file %s for %d",
+ loadFileName, classCount);
+ return(1);
+ }
+
+
+ // move the data from buff to memory, careful that we don't exceed what
+ // we actually read in.
+ statPtr = stats_class_data->varIndex;
+ size = 0;
+ for (var = 0, srcPtr = memPtr; srcPtr - memPtr < size2; var++, statPtr++) {
+
+ // allocate room to the STAT_VAR structure we will point to and that will hold
+ // the name and addr
+ if (!(*statPtr = (STAT_VAR *)extsql_malloc( (sizeof(STAT_VAR)),
+ MYF(MY_WME | MY_ZEROFILL)) )) {
+ sql_print_error("ExtSQL: Could not alloc space for STAT_VAR structure, RELOAD file %s for %d",
+ loadFileName, classCount);
+ return(1);
+ }
+
+ ptrPtr = (char **)srcPtr;
+ (*statPtr)->addr = *ptrPtr;
+
+ // move to name
+ size = sizeof (char *);
+ srcPtr += size; // start of name
+ size = strlen(srcPtr) + 1; // length
+
+ if (!(destPtr = extsql_malloc(size, MYF(MY_WME | MY_ZEROFILL)))) {
+ sql_print_error("ExtSQL: Memory alloc failed on var(%d), class(%d)",
+ var, classCount);
+ my_free(memPtr, MYF(0));
+ return(1);
+ }
+
+ strcpy(destPtr, srcPtr); // copy name to allocated memory
+ (*statPtr)->name = destPtr; // set pointer
+
+ // need to store the address in our quick lookup array, it would have been cleared
+ // prior to the reload
+ if (extsql_store_var_addr((*statPtr)->addr )) {
+ return(1);
+ }
+
+ if STATS_DEBUG(STATS_RELOAD) sql_print_information("ExtSQL: VAR (%d / %s / 0x%x)",
+ var, (*statPtr)->name, (uint)(*statPtr)->addr);
+
+ srcPtr += size; // move to next addr/name pair
+
+ } // end for - all vars
+
+ my_free(memPtr, MYF(0));
+
+ } // end if - else
+
+ if STATS_DEBUG(STATS_RELOAD) {
+ sql_print_information("ExtSQL: during %s, completed section VAR___, class (%d)",
+ actionStr, classCount);
+ }
+
+ // - "\nEXT TIME: 2123\n"
+ // - my_time_t array of time entries for each data entry from my_time_t *timeLabels
+
+
+ if (action == STATS_WRITE_RELOAD) {
+
+ // count the size of what we have, this is an array of time labels,
+ // just items of my_time_t all in a row
+ size = sizeof(my_time_t) * maxTime;
+
+ if (extsql_write_section_hdr(loadFileName, reloadFile, "TIME__", size)) {
+ return(1);
+ }
+
+ if STATS_DEBUG(STATS_RELOAD) {
+
+ strcpy(buff, "ExtSQL: TIME ");
+
+ // only the first 10!
+ for (i = 0; i < maxTime && i < 10; i++) {
+ sprintf(buff+strlen(buff), "(%d / %d)", i, (int)stats_class_data->timeLabels[i]);
+ }
+
+ sql_print_information(buff);
+ }
+
+ if (my_write(reloadFile, (byte*) stats_class_data->timeLabels, size,
+ MYF(MY_WME)) != size) {
+ sql_print_error("ExtSQL: Could write timeLabels data to RELOAD file %s for %d",
+ loadFileName, classCount);
+ return(1);
+ }
+
+ // just to satisfy compiler that extsql_print_bytes could be used!
+ if (!strcmp(loadFileName, "bongongongog")) {
+ extsql_print_bytes((char *)stats_class_data->timeLabels, size);
+ }
+
+ } else { // READ
+
+ // this one is easy, just read it right in, space has already been allocated!
+ memPtr = NULL;
+ if (!extsql_read_section_bytes(loadFileName, reloadFile, &memPtr,
+ "TIME__", classCount)) {
+ return(1);
+ }
+
+ // DON'T FREE memPtr here
+ stats_class_data->timeLabels = (my_time_t *) memPtr;
+
+ if STATS_DEBUG(STATS_RELOAD) {
+
+ strcpy(buff, "ExtSQL: TIME ");
+
+ // only the first 10!
+ for (i = 0; i < maxTime && i < 10; i++) {
+ sprintf(buff+strlen(buff), "(%d / %d)", i, (int)stats_class_data->timeLabels[i]);
+ }
+
+ sql_print_information(buff);
+ }
+
+ } // end if - else
+
+ if STATS_DEBUG(STATS_RELOAD) {
+ sql_print_information("ExtSQL: during %s, completed section TIME__, class (%d)",
+ actionStr, classCount);
+ }
+
+ // - "\nEXT DATA__: 000342432\n"
+ // - ulong data (actual recorded data) from ulong *data
+
+ // get the size of the data section
+ size = stats_class_data->maxInstance * stats_class_data->maxVar *
+ stats_class_data->maxTime * sizeof(ulong);
+
+ if (action == STATS_WRITE_RELOAD) {
+
+
+ // sanity check, size should be same as diff, remember offset in dataEnd
+ // is as an index to ulong entries, size is in bytes!
+ size2 = (stats_class_data->dataEnd - stats_class_data->data) * sizeof(ulong);
+ if (size != size2) {
+ sql_print_error("ExtSQL: data size error (%d/%d) for class %d",
+ size, size2, classCount);
+ return(1);
+ }
+
+ if (extsql_write_section_hdr(loadFileName, reloadFile, "DATA__", size)) {
+ return(1);
+ }
+
+ if (my_write(reloadFile, (byte*) stats_class_data->data, size,
+ MYF(MY_WME)) != size) {
+ sql_print_error("ExtSQL: Could write ext data to RELOAD file %s for %d",
+ loadFileName, classCount);
+ return(1);
+ }
+
+ } else { // READ
+
+ // this one is easy, just read it right in!
+ memPtr = NULL;
+ if (!(size2 = extsql_read_section_bytes(loadFileName, reloadFile, &memPtr,
+ "DATA__", classCount)) ) {
+ return(1);
+ }
+
+ // sanity check, same size?
+ if (size != size2) {
+ sql_print_error("ExtSQL: data size error (%d/%d) for class %d",
+ size, size2, classCount);
+
+ my_free(memPtr, MYF(0));
+ return(1);
+ }
+
+ // DON'T FREE memPtr here
+ stats_class_data->data = (ulong *) memPtr;
+
+ // set dataEnd
+ stats_class_data->dataEnd = stats_class_data->data + size/sizeof(ulong);
+
+ } // end if -else
+
+
+ if STATS_DEBUG(STATS_RELOAD) {
+ sql_print_information("ExtSQL: during %s, completed section DATA__, class (%d)",
+ actionStr, classCount);
+ }
+ // - "\nEXT CLASS n: 2\n" (repeat part for each class)
+
+ } // end for - all classes
+
+ return(0);
+
+} // end extsql_write_reload
+
+// extsql_store_var_addr - stores just the address of a tracked var in a single array
+// this makes increment processing much quicker on the lookup to see if we are
+// tracking a variable
+static int extsql_store_var_addr(char *varAddr) {
+
+ int k, varAddrFound;
+
+ for (k = 0, varAddrFound = 0; k < Shared->varAddrCount; k++) {
+
+ if (Shared->varAddrTrackArray[k] == varAddr) { // it's there
+ varAddrFound = 1;
+ break;
+ }
+ } // end for - existing array values
+
+ if (!varAddrFound && k < MAX_VARS) { // not there and not at end, add it
+ Shared->varAddrTrackArray[k] = varAddr;
+ Shared->varAddrCount++;
+
+ } else if (!varAddrFound && k >= MAX_VARS) {
+ sql_print_error("ExtSQL: disabled, var tracking limit of %d exceeded",
+ MAX_VARS);
+ return(1);
+ }
+
+ return(0);
+
+} // end extsql_store_var_addr
+
+
+// print out all the internal data structures
+static void extsql_stats_dump() {
+
+ pSTATS_CLASS_DATA stats_class_data;
+ STAT_VAR **statPtr;
+ int i, time, maxVar, maxTime, maxInstance, var, value, instance, classCount;
+ char buff[STATS_TMP_BUFF_SIZE];
+
+
+ // DEBUG LOG TO FILE
+ // general info
+ sql_print_information("ExtSQL: DUMP START (%d)", (int)StartTime);
+ sql_print_information(" version (%s)", Shared->extsql_version+17); // don't reprint version
+ sql_print_information(" extsql_class_string (%s)", Shared->extsql_class_list);
+ sql_print_information(" extsql_users (%s)", extsql_users);
+
+
+ // varAddrTrackArray
+ sprintf(buff," varAddrTrackArray (%d): ", Shared->varAddrCount);
+
+ for (i = 0; i < MAX_VARS && i < 40 && i < Shared->varAddrCount; i++) {
+ sprintf(buff + strlen(buff),"(0x%x) ", (uint) Shared->varAddrTrackArray[i]);
+ }
+
+ sql_print_information(buff);
+
+
+ // loop and print everything to the log file
+ classCount = 0;
+ for (stats_class_data = Shared->statData; classCount < STATS_MAX_CLASSES && stats_class_data->maxInstance;
+ stats_class_data++, classCount++) {
+
+ maxVar = stats_class_data->maxVar;
+ maxTime = stats_class_data->maxTime;
+ maxInstance = stats_class_data->maxInstance;
+
+
+ // print out summary info on the CLASS
+ sql_print_information("CLASS is %s, maxInstance(%d), maxVar(%d), maxTime(%d), time(%d), \
+timeUnits(%c), lastTime(%d)",
+ stats_class_data->name, maxInstance, maxVar, maxTime,
+ stats_class_data->time, stats_class_data->timeUnits,
+ stats_class_data->lastTime);
+
+ sql_print_information(" Base of instanceIndex array at 0x%x", (uint)stats_class_data->instanceIndex);
+
+ for (instance=0;
+ instance < maxInstance && stats_class_data->instanceIndex[instance];
+ instance++) {
+ sql_print_information(" instanceIndex[%d] = (%s), addr(0x%x)",
+ instance, stats_class_data->instanceIndex[instance],
+ (uint) stats_class_data->instanceIndex[instance]);
+ } // end for -- all instances
+
+ for (var=0, statPtr = stats_class_data->varIndex;
+ (var < stats_class_data->maxVar) && *statPtr ;
+ var++, statPtr++) {
+ sql_print_information(" varIndex[0x%x] = name(%s), addr(0x%x)",
+ var, (*statPtr)->name, (uint)(*statPtr)->addr);
+
+ } // end for - all vars
+
+ for (instance=0; instance < maxInstance; instance++) {
+ for (var=0, statPtr = stats_class_data->varIndex;
+ var < stats_class_data->maxVar && *statPtr;
+ var++, statPtr++) {
+ for (time = 0; time < maxTime; time++) {
+
+ value = stats_class_data->data [ARRAY_INDEX(instance, var, maxVar,
+ time, maxTime)];
+ if (value) {
+ sql_print_information(" statData[%d-%s][%d-%s][%d](%d) = %d",
+ instance, stats_class_data->instanceIndex[instance],
+ var, (*statPtr)->name,
+ time, (int)stats_class_data->timeLabels[time],
+ value);
+
+ } // end if - value
+ } // end for - all times
+ } // end for - all variables
+ } // end for - all instances
+
+ } // end for - log file write all classes
+ sql_print_information("ExtSQL: DUMP END ");
+
+} // end extsql_stats_dump
+
+
+
+// dump/check thread info
+// if doDump is set, then go ahead and dump all info on all threads;
+// otherwise just create output if there is an error.
+static void extsql_thread_dump(THD *thd, int doDump)
+{
+
+#ifndef PGSQL
+ if (pthread_mutex_trylock(&LOCK_thread_count)) { // forget about it!
+ return;
+ }; // For unlink from list
+#endif
+
+#ifdef PGSQL
+
+ // NEED this ZZ
+#else
+
+ I_List_iterator it(threads);
+ THD *tmp;
+ pthread_t my_id = pthread_self();
+ int foundError = 0;
+ char *user, *host;
+ int *statVerify, *indexPtr;
+
+ if (doDump) {
+ sql_print_information("ExtSQL: this thread id is %d", thd->thread_id);
+ }
+
+
+
+ while ((tmp=it++))
+ {
+#ifdef EXTSQL_50
+ user = tmp->security_ctx->user;
+ host = tmp->security_ctx->host;
+ statVerify = &tmp->security_ctx->statVerify;
+ indexPtr = tmp->security_ctx->statIndex;
+#else
+ user = tmp->user;
+ host = tmp->host;
+ statVerify = &tmp->statVerify;
+ indexPtr = tmp->statIndex;
+#endif
+
+ if (doDump) {
+ sql_print_information("ExtSQL: thd(%d/%s/%s) user(%s) host(%s) db(%s) magic(0x%x)",
+ tmp->thread_id, tmp->proc_info, command_name[tmp->command], user,
+ host, tmp->db, *statVerify);
+ }
+
+ for (int i = 0; i < STATS_MAX_CLASSES; i++) {
+ if (indexPtr[i]) {
+
+ if ( (*statVerify == STATS_MAGIC_NUM) &&
+ ( (indexPtr[i] >= Shared->statData[i].maxInstance) || indexPtr[i] < 0) ) {
+ sql_print_warning("ExtSQL: special check failed: thd(%d/%s/%s) user(%s) host(%s) db(%s) magic(0x%x)",
+ tmp->thread_id, tmp->proc_info, command_name[tmp->command], user,
+ host, tmp->db, *statVerify);
+ sql_print_warning(" index(%d), value(0x%x/0x%x)",
+ i, indexPtr[i], Shared->statData[i].maxInstance);
+ }
+
+ if (doDump) {
+ sql_print_information(" index(%d), value(0x%x/0x%x)",
+ i, indexPtr[i], Shared->statData[i].maxInstance);
+ } // end if - dump value
+
+ } // end if - has value
+ } // end for - all entries in this thread
+ } // end while - still more threads
+
+#endif
+
+#ifndef PGSQL
+ VOID(pthread_mutex_unlock(&LOCK_thread_count));
+#endif
+
+} // end extsql_thread_dump
+
+
+
+// a new thread has been created, init the stat tracking structures
+// if (initType == STATS_THD_INIT_DB) is set, the thread exists, but a 'use' command was given to change DB's
+// we need to update the db index ONLY!
+// if initType == STATS_THD_INIT_ALL -- we reset everybody no matter what!
+int extsql_thread_init(THD *thd, int initType)
+
+{
+ int i, threadID, command;
+ char *tmpName = "", classStart;
+ int classCount = 0;
+ int found = 0;
+ pSTATS_CLASS_DATA stats_class_data;
+ char *user = "", *host = "", *db = "", *proc_info = "", **instPtr;
+ int *statVerify = 0, *indexPtr = 0;
+ char tmpBuff[STATS_TMP_BUFF_SIZE];
+
+
+ if (initType != STATS_THD_INIT_ALL) { // normal
+
+ if (!Shared->extsql_active || Shared->extsql_disabled) { // shouldn't normally even get here
+ return(0);
+ }
+
+ if (initType == STATS_THD_INIT_DB) { // ZZ -return
+ // return(0);
+ }
+ }
+
+ // attach to our shared memory!
+ if (extsql_init_globals()) {
+ return(1);
+ }
+
+ if STATS_DEBUG(STATS_DUMP_START) {
+ extsql_stats_dump();
+ }
+
+ StartTime = time(NULL);
+
+ extsql_init_proc_vars(&threadID, &command, &user, &db, &host, &proc_info, &indexPtr, &statVerify);
+
+
+ // OKAY, if (initType == STATS_THD_INIT_DB) is set we should already be tracking data on this thread, just
+ // need to change the db index - SO, we should have already done an init on this
+ // thread and the MAGIC should have been set, if not, get out!
+ if (initType == STATS_THD_INIT_DB) {
+ if (*statVerify != STATS_MAGIC_NUM) {
+ return(1);
+ }
+ }
+
+ // check that we have a host and db
+ if (! host || ! *host || *host == '\0') {
+ host = "(null)";
+ }
+
+ if (! db || ! *db || *db == '\0') {
+ db = "(null)";
+ }
+
+ // we don't do thread zero -- ZZ disabled temp
+ if (0 && ! threadID) {
+ sql_print_warning("ExtSQL: thread_init called for thread zero in error");
+ return(0);
+ }
+
+ // for root stuff, i.e. phpMyAdmin, the db is (null).
+ if STATS_DEBUG(STATS_THD_INIT_PARAMS) {
+ sql_print_information("ExtSQL: thread (%d) started for db %s(0x%x), user %s(0x%x), host %s(0x%x)",
+ threadID, db, (uint)db, user, (uint)user, host, (uint)host);
+ }
+
+ // for quick indexing on increment, we store the index values used to track the instances
+ // used by this thread within the thread itself
+ // see if user and db names are there already
+
+ // check/add indexes depending on classes that we are collecting for;
+
+ // init the class index array to zero if this is a first time init or for ALL
+ if (!(initType == STATS_THD_INIT_DB)) {
+ for (i = 0; i< STATS_MAX_CLASSES; i++) {
+ indexPtr[i] = 0;
+ }
+ *statVerify = 0; // will be set below when we find match on anything.
+ }
+
+ for (stats_class_data = Shared->statData, classCount = 0;
+ classCount < STATS_MAX_CLASSES && stats_class_data->maxInstance;
+ stats_class_data++, classCount++) {
+
+ classStart = stats_class_data->name[0];
+
+ if ((initType == STATS_THD_INIT_DB) && classStart != 'd' && classStart != 'c') { // we just want the db or condb
+ continue;
+ }
+
+ switch (classStart) { // LIST should match extsqlClassesSupported[]
+
+ case 'c': // connect
+
+ if ((initType == STATS_THD_INIT_DB) && stats_class_data->name[3] != 'd') { // not condb
+ continue;
+ }
+
+ if (stats_class_data->name[3] == 'd') { // condb - db@host
+
+ strcpy(tmpBuff, db);
+
+ } else if (stats_class_data->name[3] == 'u') { // conuser- user@host
+ strcpy(tmpBuff, user);
+
+ } else {
+
+ sql_print_error("ExtSQL: disabled, unexpected connection class name %s",
+ stats_class_data->name);
+ Shared->extsql_disabled = 1;
+ break;
+ }
+
+ strcat(tmpBuff, "@");
+ strcat(tmpBuff, host);
+ tmpName = tmpBuff;
+
+ break;
+
+ case 'd': // db
+
+ tmpName = db;
+ break;
+
+ case 'h': // host
+
+ tmpName = host;
+ break;
+
+ case 's': // server -- cum total of all on this server
+
+ tmpName = "server";
+ break;
+
+ case 'u': // user
+
+ tmpName = user;
+ break;
+
+ default:
+
+ sql_print_error("ExtSQL: disabled, unexpected class name %s",
+ stats_class_data->name);
+ Shared->extsql_disabled = 1;
+
+ } // end switch
+
+ // make sure we got something in tmpName
+ if (!tmpName) {
+ // sql_print_warning("ExtSQL: got null tmpName instance value for class %s, forcing to (null)", stats_class_data->name);
+ tmpName = "(null)";
+ }
+
+ if (Shared->extsql_disabled) {
+ break;
+ }
+
+ // now try to match or insert
+ // check for new or existing instance, LOCK statData during the search
+ found = 0;
+
+ i = 0;
+ for (instPtr = (char **)stats_class_data->instanceIndex;
+ i < stats_class_data->maxInstance; instPtr++, i++) {
+
+ if STATS_DEBUG(STATS_THD_INIT_LOOP) {
+ sql_print_information(" Looking for match of %s with %s", *instPtr, tmpName);
+ }
+
+ if (!*instPtr) { // at a blank, fill it
+
+ // Grab the lock now, check to see if it is still NULL
+ // if it is, fill it in
+ (void) pthread_mutex_lock(&Shared->LOCK_stats_load); // IMPORTANT, don't leave with unlock!
+
+ if (!*instPtr) { // at a blank, fill it
+ if (!(*instPtr = extsql_strdup(tmpName, MYF(MY_WME)))) {
+ Shared->extsql_disabled = 1;
+ sql_print_error("ExtSQL: disabled, unable to alloc instance item %s",
+ tmpName);
+ // UNLOCK statData
+ (void) pthread_mutex_unlock(&Shared->LOCK_stats_load); // IMPORTANT!
+ break;
+ }
+ found = 1;
+
+ Shared->statsAllocArray[Shared->allocIndex] = *instPtr;
+
+ // UNLOCK statData
+ (void) pthread_mutex_unlock(&Shared->LOCK_stats_load); // IMPORTANT!
+
+ indexPtr[classCount] = i;
+
+ if STATS_DEBUG(STATS_THD_INIT_LOOP) {
+ sql_print_information("ExtSQL, NEW statIndex[%d]->%d for %s in class %s stored as (%s)",
+ classCount, i, tmpName, stats_class_data->name,
+ Shared->statsAllocArray[Shared->allocIndex]);
+ }
+
+ Shared->allocIndex++;
+ break;
+
+ } // end if - was emtpy - fill in new values
+
+ // if we get here it is not null, someone else got it ahead of us. May have filled in another value,
+ // or what we want. -- we release lock, we will fall throught to below and check for a match, and keep looping
+ // UNLOCK statData
+ (void) pthread_mutex_unlock(&Shared->LOCK_stats_load); // IMPORTANT!
+
+ } // end if - was empty - fill in new value
+
+ if (!strcmp(*instPtr, tmpName)) { // match
+ indexPtr[classCount] = i;
+ found = 1;
+ break;
+ }
+
+ } // end for - each instance
+
+
+ // check for max instances exceeded
+ if (! found) {
+ sql_print_warning("ExtSQL: disabled, instances exceed tracking limit for class %s with %s",
+ stats_class_data->name, tmpName);
+ Shared->extsql_disabled = 1;
+ break;
+ }
+
+ // if we get here, something was found.
+ *statVerify = STATS_MAGIC_NUM;
+
+ if (Shared->extsql_disabled) {
+ break;
+ }
+
+ } // end for - each class
+ if STATS_DEBUG(STATS_DUMP_START) {
+ extsql_stats_dump();
+ }
+
+#ifdef PGSQL
+ extsql_inc(&Connections, 1);
+#endif
+
+ return(0);
+
+} // end extsql_thread_init
+
+#ifdef EXTSQL_50
+// only for information schema, in 5 and above
+
+extern bool schema_table_store_record(THD *thd, TABLE *table);
+
+// We fill the table with our tracking data, depending on the name
+int fill_schema_extsql(THD *thd, TABLE_LIST *tables, COND *cond)
+{
+
+ const char *wild= thd->lex->wild ? thd->lex->wild->ptr() : NullS;
+ TABLE *table= tables->table;
+ CHARSET_INFO *scs= system_charset_info;
+
+ pSTATS_CLASS_DATA stats_class_data;
+ STAT_VAR **statPtr;
+ ST_SCHEMA_TABLE *schema_table= tables->schema_table;
+ int found, var, maxVar, maxTime, maxInstance, currentTime, timeLimit, timeCount, indexTime,
+ varNameLength, varIndex, value, stats_hourly, fieldIndex=0, rowHasData, doZeroTime=1;
+ char listBuff[MAX_BUFF_SIZE], className[STATS_MAX_NAME];
+ char *varListPtr = listBuff, *stats_class = className, *varName, *termChar;
+ MYSQL_TIME now_mysql_time;
+ char *user;
+
+ DBUG_ENTER("schema_table_store_record");
+
+ // are they authorized
+#ifdef EXTSQL_50
+ user = thd->security_ctx->user;
+#else
+ user = thd->user;
+#endif
+
+ // return if not authorized, disabled or inactive
+ if (extsql_check(thd, 0)) DBUG_RETURN(1);
+
+ // lets make sure this is one of our tables
+ if (!strncmp(schema_table->table_name, "EXTSTATS_", 9)) { // one of ours
+
+ int found, var, maxVar;
+
+ // lets get the class name off the end
+ strcpy(stats_class, schema_table->table_name + 9);
+
+ // find the data for the Class we are interested in
+ found = 0;
+ for (stats_class_data = Shared->statData; stats_class_data->maxInstance;
+ stats_class_data++) {
+ if (!strcmp(stats_class_data->name, stats_class)) { // found it
+ found = 1;
+ break;
+ }
+ } // end for
+
+ if (!found) {
+ net_printf_error(thd, 0, "ExtSQL: can't fill requested SCHEMA TABLE %s(%s). The \
+most likely reason is that no data is being recorded for that class. Use SHOW STATISTICS to see \
+what is being tracked.",
+
+ schema_table->table_name, stats_class);
+ DBUG_RETURN(0);
+ }
+
+ } else { // called by mistake
+ net_printf_error(thd, 0, "ExtSQL: schema called in error to fill table %s.",
+ schema_table->table_name);
+ DBUG_RETURN(0);
+ }
+
+ // AT THIS POINT stats_class_data points to the requested class
+ maxVar = stats_class_data->maxVar;
+ maxTime = stats_class_data->maxTime;
+ maxInstance = stats_class_data->maxInstance; // needed for array indexing
+
+ currentTime = stats_class_data->time; // time we are currently logging to.
+ timeLimit = maxTime-1; // they get it all
+
+ // we need to now load the columns in the PROPER order, data is recorded as it
+ // occurs, but the Var name order is controlled by the user, we try to use
+ // that order.
+ strcpy(varListPtr,","); // init the list
+ // loop through the instance variables for names
+ for (var=0, statPtr = stats_class_data->varIndex;
+ (var < stats_class_data->maxVar) && *statPtr ;
+ var++, statPtr++) {
+
+ strcat(varListPtr,(*statPtr)->name );
+ strcat(varListPtr, ",");
+
+ if (strlen(varListPtr) > MAX_BUFF_SIZE - 50) {
+ net_printf(thd, 0, "ExtSQL: List of Vars too long");
+ DBUG_RETURN(1);
+ }
+ } // end for - all instances
+
+
+ // Remember, zero index holds the total. The
+ // currentTime has our present location and it is circular, i.e. if
+ // maxTime for the class is 4, we store current + 3. If the currentTime
+ // is 2, the proper way to display all hours, starting with the most
+ // recent is to show 2(current),1(prior),3(more prior) - skip 0
+ // we now go through all the instances, we will be loading the table
+ // with instance_name, time, var, var, .....
+ for (int instance=0; instance < maxInstance && stats_class_data->instanceIndex[instance] ;
+ instance++) {
+
+ // loop through the times,
+ // if stats_timely is set we will output a number of hours starting at currentTime, and
+ // limited by timeLimit (starts at 1).
+ // For INFORMATION_SCHEMA we have a real problem, need to print the totals under
+ // time heading of 0000-00-00 00:00 (zero time), but then pick up and print the rest,
+ // have to really hack the loop control to make first output special, zero time.
+ // If doZeroTime = 1 -- we need to output the zero values(totals)
+ doZeroTime = 1;
+
+ for (timeCount = 0, indexTime = currentTime ;
+ timeCount < timeLimit && indexTime >= 0;
+ timeCount++, indexTime-- ) {
+
+ // we have to adjust our indexTime for wrap
+ if (!indexTime && !doZeroTime) { // we have gone back to the total
+ indexTime = maxTime - 1; // pick the last
+ }
+
+ restore_record(table, s->default_values);
+ fieldIndex = 0;
+ rowHasData = 0; // do we have anything to show, only on HISTORY
+
+ // first column - instance name - always
+ table->field[fieldIndex++]->store(stats_class_data->instanceIndex[instance],
+ strlen(stats_class_data->instanceIndex[instance]), scs);
+
+ // second column is times - always, we use indexTime
+ if (indexTime) {
+ thd->variables.time_zone->gmt_sec_to_TIME(&now_mysql_time,
+ (my_time_t) stats_class_data->timeLabels[indexTime]);
+ } else {
+ char *zeroTime = "0000-00-00 00:00:00";
+ str_to_time_with_warn(zeroTime, strlen(zeroTime), &now_mysql_time);
+ }
+
+ table->field[fieldIndex++]->store_time(&now_mysql_time, MYSQL_TIMESTAMP_DATETIME);
+
+ // loop through varListPtr, output the vars in the DEFAULT order
+ // varListPtr = ",bytes,selects," varName will move through this
+ for ( varName = varListPtr; *varName ; varName = strstr(varName, ",")) {
+
+ varName++; // move off the comma
+ //sql_print_information(" target varName is (%s)", varName);
+
+ if (! *varName) { // we are done
+ break;
+ }
+
+ varNameLength = strchr(varName, ',') - varName;
+
+ // okay, varName points at a name, lets go through the index looking
+ // for a match
+ found = 0;
+ for (varIndex=0, statPtr = stats_class_data->varIndex;
+ varIndex < maxVar && *statPtr;
+ varIndex++, statPtr++) {
+
+ termChar = (*statPtr)->name + varNameLength +1; // point to end of the current var name
+
+ if (!strncmp( (*statPtr)->name, varName, varNameLength)) {
+ found = 1;
+ value = stats_class_data->data [ARRAY_INDEX(instance, varIndex, maxVar,
+ indexTime, maxTime)];
+
+ table->field[fieldIndex++]->store((longlong) value, TRUE);
+ if (value) { // is it non-zero
+ rowHasData = 1;
+ }
+ break;
+ }
+
+ } // end for - a matching var in the list
+
+ if (!found) {
+ table->field[fieldIndex++]->store((longlong) 9999999, TRUE);
+ }
+
+ } // end for - requested values
+
+ if (!indexTime) { // it had hit zero and we have outputed totals
+ doZeroTime = 0; // don't do it again for this class
+ indexTime = 1; // we want it to zero again for wrap.
+ timeCount--; // this row doesn't count
+ }
+
+ if (!rowHasData) {
+ continue;
+ }
+
+ // record the row
+ if (schema_table_store_record(thd, table)) {
+ sql_print_error("ExtSQL, protocol write failed");
+ DBUG_RETURN(1);
+ }
+ } // end for - all requested times
+
+ } // end for - all instances
+
+ return 0;
+}
+
+#endif
--- /export/mysql/extsql-build/builds/8.4.1/rhel4/x86/1/0.0/src/include/utils/extsql.h 1969-12-31 19:00:00.000000000 -0500
+++ src/include/utils/extsql.h 2009-11-29 17:01:47.000000000 -0500
@@ -0,0 +1,217 @@
+
+/* Copyright (C) 2006, 2007, 2008, 2009, 2010 Software Workshop Incorporated
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
+
+#ifndef EXTSQL_H
+#define EXTSQL_H 1
+#endif
+
+#define PGSQL 1
+
+#ifdef PGSQL
+#define PGSQL_8 1 // only for 8.4 builds and above.
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "postgres.h"
+#include "libpq/pqcomm.h"
+#include "miscadmin.h"
+#include "catalog/pg_type.h"
+#include "tcop/dest.h"
+#include "executor/executor.h"
+#include "storage/proc.h"
+#include "storage/backendid.h"
+#include "libpq/libpq-be.h"
+#include "libpq/hba.h"
+#include "storage/pg_shmem.h" // ZZ shared memory
+#include "storage/spin.h"
+#include "storage/fd.h"
+#include "nodes/pg_list.h"
+
+// need this stuff for PGSQL, mimics where stored in mysql (mysqld.cc)
+// by default we are set for MySQL 4.x, PGSQL set for any PGSQL build where
+// MySQL stuff will NOT apply
+
+// NOTE variadic macros below, invoke with either '...' or '__VA_ARGS__' compiler dependent!
+#define sql_print_information(str, ...) elog(LOG, str, ##__VA_ARGS__)
+#define sql_print_warning(str, ...) elog(LOG, str, ##__VA_ARGS__)
+#define sql_print_error(str, ...) elog(LOG, str, ##__VA_ARGS__)
+
+#define net_printf(thd, x, str, ...) elog(ERROR, str, ##__VA_ARGS__)
+
+#define DBUG_RETURN(x) return(x)
+#define DBUG_ENTER(x)
+
+#define NullS (char *) 0
+
+#define MY_MUTEX_INIT_FAST &my_fast_mutexattr
+
+#define pthread_mutex_trylock(lock) pthread_mutex_lock(lock)
+#define my_free(x, y) free(x)
+#define my_malloc(a,b) malloc(a)
+#define my_open(fileName, mode, flag) open(fileName, mode)
+#define my_read(fd, buff, bytes, flags) read(fd, buff, bytes)
+#define my_write(fd, buff, bytes, flags) write(fd, buff, bytes)
+#define MY_WME 1
+#define MY_NABP 1
+#define MY_ZEROFILL 1
+#define MYF(a) a
+#define O_BINARY 0 // ZZ
+
+
+#define FN_REFLEN 255
+
+
+typedef char byte;
+typedef time_t my_time_t;
+typedef time_t MYSQL_TIME;
+typedef struct PGPROC THD;
+typedef struct show_var_st {
+ char *name;
+ ulong *value;
+} SHOW_VAR;
+
+extern ulong Com_begin, Com_commit, Com_create_table, Com_delete,
+ Com_drop_table, Com_insert, Com_rollback, Com_select, Com_update, Connections, Questions;
+extern int mysql_show_extsql(THD *thd, const char *stats_class, DestReceiver *dest, List *stats_vars,
+ uint stats_hourly, const char *wild, char *stats_order_var,
+ const uint stats_order_dir, const uint stats_order_limit, char *stats_where_var,
+ const uint stats_where_num, const uint stats_where_char);
+
+#endif // PGSQL
+
+
+
+#define STATS_DEBUG(Val) (Val & extsql_debug ? 1 : 0)
+
+#define STATS_MAGIC_NUM 0x12345678
+#define STATS_MAX_NAME 20 // max size of a Class name
+#define STATS_TMP_BUFF_SIZE 2048
+
+#define STATS_INIT_FAILURE 0 // define the start types
+#define STATS_INIT_NORMAL 1
+#define STATS_INIT_RESET 2
+#define STATS_INIT_RELOAD 3
+#define STATS_INIT_CONFIRM 4
+
+#define STATS_THD_INIT_NORM 5
+#define STATS_THD_INIT_DB 6
+#define STATS_THD_INIT_ALL 7
+
+#define STATS_WRITE_RELOAD 1 // actions taken with reload file
+#define STATS_READ_RELOAD 2
+#define STATS_SECTION_HDR 23 // characters in reload file section hdrs
+#define STATS_SECTION_BYTES 13 // offset to first digit in byte count
+
+#define STATS_MAX_NUM_ALLOC 200 // max independent mem allocs we track
+#define MAX_VARS 50 // the most unique Vars we can track
+
+// #define EXTSQL_50 1 -- external define set during build during configure.
+// #define EXTSQL_BINARY 1 -- external define set during build during configure.
+
+typedef struct stat_vars {
+ char *name;
+ char *addr;
+} STAT_VAR, *pSTAT_VAR;
+
+typedef struct stats_class_data { // keep this padded to 4 byte borders
+ char name[STATS_MAX_NAME]; // class name
+ ulong *data; // pointer to data area for that class
+ // 3-d array [instance index][var index][hour index, 0-summary]
+ ulong *dataEnd; // where does data end - limit check
+ int maxInstance;
+ char **instanceIndex; // indexes for named instances
+ int maxVar;
+ STAT_VAR **varIndex; // indexes for vars, name & addr
+ int maxTime;
+ char *varList; // NOT USED ZZ
+ int time; // the current time unit we are logging to
+ char timeUnits; // d - day, h - hour, m - minute
+ char padd[3];
+ my_time_t *timeLabels; // absolute time for each time entry in data
+ int lastTime; // the last clock time we saw for data logged
+} STATS_CLASS_DATA, *pSTATS_CLASS_DATA;
+
+
+// SHARED MEM -- all our global data
+typedef struct global_alloc { // in same order as declared in extsql.cc
+ STATS_CLASS_DATA statData[STATS_MAX_CLASSES];
+ char *extsql_class_list, *extsql_reload_file;
+
+ char *statsAllocArray[STATS_MAX_NUM_ALLOC]; // used to track mem allocs for reset/free
+ int allocIndex; // our position in the global statsAllocArray
+
+ pthread_mutex_t LOCK_stats_load, LOCK_stats_clock;
+
+ char *extsql_key, *extsql_users, *extsql_version;
+
+ ulong extsql_active, // temp stop extsql activity, can be user re-activated by SET
+ extsql_disabled, // perm stop extsql activity, severe/license error, only cleared by server restart
+ extsql_reload_in_progress, // temp stop extsql activity during startType reset/reload
+ extsql_debug, queries, connects, extsql_counter;
+
+ char *varAddrTrackArray[MAX_VARS]; // tracks addr of vars of interest, speeds up increment search.
+ int varAddrCount; // how many do we have being tracked
+ int lastMin; // top of minute processing
+
+} GLOBAL, *pGLOBAL;
+
+extern pGLOBAL Shared;
+
+// FOLLOWING only used at startup, then referenced from Shared.
+extern ulong extsql_active, extsql_counter, extsql_debug, queries, connects;
+extern char *extsql_class_list, *extsql_key, *extsql_users, *extsql_reload_file;
+
+
+// FUNCTION PROTOTYPES
+int extsql_init_globals();
+int extsql_check(THD*, int);
+
+#ifdef PGSQL
+int extsql_output_prep_2_col(char *col1, char *col2,DestReceiver *dest,
+ TupOutputState **tstate, TupleDesc tupdesc);
+int extsql_output_2_col(char *col1Str, int col1Int, char *col2Str, int col2Int,
+ DestReceiver *dest, TupOutputState *tstate);
+void extsql_output_complete(THD *, TupOutputState *);
+int extsql_usage(THD*, DestReceiver*);
+int extsql_enable(THD*, DestReceiver*, uint);
+int extsql_reset(THD* thd, DestReceiver*, const char* conf);
+int extsql_file_io(THD* thd, DestReceiver*, uint io_mode, uint confirm, char* reload_file);
+#else
+static int extsql_output_prep_2_col(char *col1, char *col2, Protocol *protocol,
+ List
- field_list, char *fill2);
+static int extsql_output_2_col(char *col1Str, int col1Int, char *col2Str,
+ int col2Int, Protocol *protocol, char *fill1);
+void extsql_output_complete(THD* thd, char *tstate);
+int extsql_usage(THD*);
+int extsql_enable(THD*, uint);
+int extsql_reset(THD* thd, const char* conf);
+int extsql_file_io(THD* thd, uint io_mode, uint confirm, char* reload_file);
+#endif
+
+extern void extsql_inc(ulong *V, ulong C);
+extern int extsql_init(char *, int, char *);
+extern void extsql_prep(int *, const char *, char *);
+int extsql_thread_init(THD *thd, int initType);
+int extsql_read_section_bytes(char*, File, char**, char*, int);
+int extsql_reload(int action, char *loadFileName);
|
