Merge tnurnberg@bk-internal.mysql.com:/home/bk/mysql-5.1-maint

into  sin.intern.azundris.com:/home/tnurnberg/10776/51-10776


configure.in:
  Auto merged

config/ac-macros/ha_ndbcluster.m4

@@ -277,6 +277,13 @@ AC_DEFUN([MYSQL_SETUP_NDBCLUSTER], [
     ndb_bin_am_ldflags=""
   fi
 
+  # building dynamic breaks on AIX. (If you want to try it and get unresolved
+  # __vec__delete2 and some such, try linking against libhC.)
+  case "$host_os" in
+    aix3.* | aix4.0.* | aix4.1.*) ;;
+    *) ndb_bin_am_ldflags="-static";;
+  esac
+
   # libndbclient versioning when linked with GNU ld.
   if $LD --version 2>/dev/null|grep -q GNU; then
     NDB_LD_VERSION_SCRIPT="-Wl,--version-script=\$(top_builddir)/storage/ndb/src/libndb.ver"

config/ac-macros/large_file.m4

@@ -127,14 +127,9 @@ AC_DEFUN([MYSQL_SYS_LARGEFILE],
 	hpux10.[2-9][0-9]* | hpux1[1-9]* | hpux[2-9][0-9]*)
 	  ac_cv_sys_largefile_source=1 ;;
 	esac])
-     AC_SYS_LARGEFILE_MACRO_VALUE(_LARGE_FILES,
-       ac_cv_sys_large_files,
-       [Large files support on AIX-style hosts.],
-       [case "$host_os" in
-	# AIX 4.2 and later
-	aix4.[2-9]* | aix4.1[0-9]* | aix[5-9].* | aix[1-9][0-9]*)
-	  ac_cv_sys_large_files=1 ;;
-	esac])
+
+     # AIX 4.2 and later -- do nothing, include standards.h instead.
+     # this goes for both GNU and IBM C and C++ compilers.
    fi
   ])
 

include/mysql.h

@@ -27,6 +27,10 @@
 #ifndef _mysql_h
 #define _mysql_h
 
+#ifdef _AIX           /* large-file support will break without this */
+#include <standards.h>
+#endif
+
 #ifdef __CYGWIN__     /* CYGWIN implements a UNIX API */
 #undef WIN
 #undef _WIN

storage/ndb/src/mgmclient/Makefile.am

@@ -36,6 +36,7 @@ INCLUDES += -I$(top_srcdir)/storage/ndb/include/mgmapi \
 LDADD_LOC = $(noinst_LTLIBRARIES) \
 	    ../common/portlib/libportlib.la \
             @readline_link@ \
+            $(top_builddir)/storage/ndb/src/libndbclient.la \
             $(top_builddir)/dbug/libdbug.a \
             $(top_builddir)/mysys/libmysys.a \
             $(top_builddir)/strings/libmystrings.a \

storage/ndb/src/mgmsrv/Makefile.am

@@ -38,7 +38,7 @@ INCLUDES_LOC = -I$(top_srcdir)/storage/ndb/src/ndbapi \
                -I$(top_srcdir)/storage/ndb/src/common/mgmcommon \
                -I$(top_srcdir)/storage/ndb/src/mgmclient
 
-LDADD_LOC = $(top_builddir)/storage/ndb/src/mgmclient/CommandInterpreter.o \
+LDADD_LOC = $(top_builddir)/storage/ndb/src/mgmclient/CommandInterpreter.lo \
             $(top_builddir)/storage/ndb/src/libndbclient.la \
             $(top_builddir)/dbug/libdbug.a \
             $(top_builddir)/mysys/libmysys.a \

storage/ndb/src/ndbapi/NdbScanOperation.cpp

@@ -1202,7 +1202,7 @@ NdbIndexScanOperation::setBound(const NdbColumnImpl* tAttrInfo,
     Uint32 tupKeyLen = theTupKeyLen;
     union {
       Uint32 tempData[2000];
-      Uint64 __align;
+      Uint64 __my_align;
     };
     Uint64 *valPtr;
     if(remaining > totalLen && aligned && nobytes){

storage/ndb/test/ndbapi/benchronja.cpp

@@ -41,7 +41,14 @@
 #define MAXSTRLEN 16 
 #define MAXATTR 64
 #define MAXTABLES 64
-#define MAXTHREADS 256
+#define NDB_MAXTHREADS 256
+/*
+  NDB_MAXTHREADS used to be just MAXTHREADS, which collides with a
+  #define from <sys/thread.h> on AIX (IBM compiler).  We explicitly
+  #undef it here lest someone use it by habit and get really funny
+  results.  K&R says we may #undef non-existent symbols, so let's go.
+*/
+#undef MAXTHREADS
 #define MAXATTRSIZE 8000
 #define START_TIMER NdbTimer timer; timer.doStart();
 #define STOP_TIMER timer.doStop();
@@ -56,18 +63,18 @@ struct ThreadNdb
   Ndb* NdbRef;
 };
 
-static NdbThread* threadLife[MAXTHREADS];
+static NdbThread* threadLife[NDB_MAXTHREADS];
 static unsigned int tNoOfThreads;
 static unsigned int tNoOfOpsPerExecute;
 static unsigned int tNoOfRecords;
 static unsigned int tNoOfOperations;
-static int ThreadReady[MAXTHREADS];
-static int ThreadStart[MAXTHREADS];
+static int ThreadReady[NDB_MAXTHREADS];
+static int ThreadStart[NDB_MAXTHREADS];
 
 NDB_COMMAND(benchronja, "benchronja", "benchronja", "benchronja", 65535){
   ndb_init();
 
-  ThreadNdb		tabThread[MAXTHREADS];
+  ThreadNdb		tabThread[NDB_MAXTHREADS];
   int			i = 0 ;
   int			cont = 0 ;
   Ndb*			pMyNdb = NULL ; //( "TEST_DB" );	
@@ -84,7 +91,7 @@ NDB_COMMAND(benchronja, "benchronja", "benchronja", "benchronja", 65535){
   {
     if (strcmp(argv[i], "-t") == 0){
       tNoOfThreads = atoi(argv[i+1]);
-      if ((tNoOfThreads < 1) || (tNoOfThreads > MAXTHREADS)) goto error_input;
+      if ((tNoOfThreads < 1) || (tNoOfThreads > NDB_MAXTHREADS)) goto error_input;
     }else if (strcmp(argv[i], "-o") == 0){
       tNoOfOperations = atoi(argv[i+1]);
       if (tNoOfOperations < 1) goto error_input;

storage/ndb/test/ndbapi/flexAsynch.cpp

@@ -35,7 +35,14 @@
 #define MAXSTRLEN 16 
 #define MAXATTR 64
 #define MAXTABLES 64
-#define MAXTHREADS 128
+#define NDB_MAXTHREADS 128
+/*
+  NDB_MAXTHREADS used to be just MAXTHREADS, which collides with a
+  #define from <sys/thread.h> on AIX (IBM compiler).  We explicitly
+  #undef it here lest someone use it by habit and get really funny
+  results.  K&R says we may #undef non-existent symbols, so let's go.
+*/
+#undef MAXTHREADS
 #define MAXPAR 1024
 #define MAXATTRSIZE 1000
 #define PKSIZE 2
@@ -76,10 +83,10 @@ struct ThreadNdb
   int ThreadNo;
 };
 
-static NdbThread*               threadLife[MAXTHREADS];
+static NdbThread*               threadLife[NDB_MAXTHREADS];
 static int                              tNodeId;
-static int                              ThreadReady[MAXTHREADS];
-static StartType                ThreadStart[MAXTHREADS];
+static int                              ThreadReady[NDB_MAXTHREADS];
+static StartType                ThreadStart[NDB_MAXTHREADS];
 static char                             tableName[MAXTABLES][MAXSTRLEN+1];
 static char                             attrName[MAXATTR][MAXSTRLEN+1];
 
@@ -160,7 +167,7 @@ NDB_COMMAND(flexAsynch, "flexAsynch", "flexAsynch", "flexAsynch", 65535)
     return NDBT_ProgramExit(NDBT_WRONGARGS);
   }
 
-  pThreadData = new ThreadNdb[MAXTHREADS];
+  pThreadData = new ThreadNdb[NDB_MAXTHREADS];
 
   ndbout << endl << "FLEXASYNCH - Starting normal mode" << endl;
   ndbout << "Perform benchmark of insert, update and delete transactions";
@@ -844,7 +851,7 @@ readArguments(int argc, const char** argv){
   while (argc > 1){
     if (strcmp(argv[i], "-t") == 0){
       tNoOfThreads = atoi(argv[i+1]);
-      if ((tNoOfThreads < 1) || (tNoOfThreads > MAXTHREADS)){
+      if ((tNoOfThreads < 1) || (tNoOfThreads > NDB_MAXTHREADS)){
 	ndbout_c("Invalid no of threads");
         return -1;
       }

storage/ndb/test/ndbapi/flexHammer.cpp

@@ -66,7 +66,14 @@ ErrorData * flexHammerErrorData;
 #define MAXSTRLEN 16 
 #define MAXATTR 64
 #define MAXTABLES 64
-#define MAXTHREADS 256
+#define NDB_MAXTHREADS 256
+/*
+  NDB_MAXTHREADS used to be just MAXTHREADS, which collides with a
+  #define from <sys/thread.h> on AIX (IBM compiler).  We explicitly
+  #undef it here lest someone use it by habit and get really funny
+  results.  K&R says we may #undef non-existent symbols, so let's go.
+*/
+#undef MAXTHREADS
 #define MAXATTRSIZE 100
 // Max number of retries if something fails
 #define MaxNoOfAttemptsC 10 
@@ -119,8 +126,8 @@ static int			tAttributeSize;
 static int			tNoOfOperations;
 static int			tNoOfRecords;
 static int			tNoOfLoops;
-static				ReadyType ThreadReady[MAXTHREADS];
-static				StartType ThreadStart[MAXTHREADS];
+static				ReadyType ThreadReady[NDB_MAXTHREADS];
+static				StartType ThreadStart[NDB_MAXTHREADS];
 static char			tableName[MAXTABLES][MAXSTRLEN];
 static char			attrName[MAXATTR][MAXSTRLEN];
 static int			theSimpleFlag = 0;
@@ -640,7 +647,7 @@ readArguments (int argc, const char** argv)
   while (argc > 1) {
     if (strcmp(argv[i], "-t") == 0) {
       tNoOfThreads = atoi(argv[i+1]);
-      if ((tNoOfThreads < 1) || (tNoOfThreads > MAXTHREADS))
+      if ((tNoOfThreads < 1) || (tNoOfThreads > NDB_MAXTHREADS))
 	return(1);
     }
     else if (strcmp(argv[i], "-o") == 0) {

storage/ndb/test/ndbapi/flexScan.cpp

@@ -68,7 +68,14 @@
 #define MAXSTRLEN 16 
 #define MAXATTR 64
 #define MAXTABLES 64
-#define MAXTHREADS 256
+#define NDB_MAXTHREADS 256
+/*
+  NDB_MAXTHREADS used to be just MAXTHREADS, which collides with a
+  #define from <sys/thread.h> on AIX (IBM compiler).  We explicitly
+  #undef it here lest someone use it by habit and get really funny
+  results.  K&R says we may #undef non-existent symbols, so let's go.
+*/
+#undef MAXTHREADS
 #define MAXATTRSIZE 64
 
 enum StartType { 
@@ -848,7 +855,7 @@ static int readArguments(int argc, const char** argv)
     if (strcmp(argv[i], "-t") == 0) {
       if (argv[i + 1] != NULL) {
 	tNoOfThreads = atoi(argv[i + 1]);
-	if ((tNoOfThreads < 1) || (tNoOfThreads > MAXTHREADS)) {
+	if ((tNoOfThreads < 1) || (tNoOfThreads > NDB_MAXTHREADS)) {
 	  retValue = -1;
 	} // if
       } // if

storage/ndb/test/ndbapi/flexTT.cpp

@@ -35,7 +35,14 @@
 #define MAXSTRLEN 16 
 #define MAXATTR 64
 #define MAXTABLES 64
-#define MAXTHREADS 128
+#define NDB_MAXTHREADS 128
+/*
+  NDB_MAXTHREADS used to be just MAXTHREADS, which collides with a
+  #define from <sys/thread.h> on AIX (IBM compiler).  We explicitly
+  #undef it here lest someone use it by habit and get really funny
+  results.  K&R says we may #undef non-existent symbols, so let's go.
+*/
+#undef MAXTHREADS
 #define MAXPAR 1024
 #define MAXATTRSIZE 1000
 #define PKSIZE 1
@@ -101,10 +108,10 @@ static void input_error();
                                       
 ErrorData * flexTTErrorData;
 
-static NdbThread*                       threadLife[MAXTHREADS];
+static NdbThread*                       threadLife[NDB_MAXTHREADS];
 static int                              tNodeId;
-static int                              ThreadReady[MAXTHREADS];
-static StartType                        ThreadStart[MAXTHREADS];
+static int                              ThreadReady[NDB_MAXTHREADS];
+static StartType                        ThreadStart[NDB_MAXTHREADS];
 static char                             tableName[1][MAXSTRLEN+1];
 static char                             attrName[5][MAXSTRLEN+1];
 
@@ -184,7 +191,7 @@ NDB_COMMAND(flexTT, "flexTT", "flexTT", "flexTT", 65535)
     return NDBT_ProgramExit(NDBT_WRONGARGS);
   }
 
-  pThreadData = new ThreadNdb[MAXTHREADS];
+  pThreadData = new ThreadNdb[NDB_MAXTHREADS];
 
   ndbout << endl << "FLEXTT - Starting normal mode" << endl;
   ndbout << "Perform TimesTen benchmark" << endl;
@@ -798,7 +805,7 @@ readArguments(int argc, const char** argv){
   while (argc > 1){
     if (strcmp(argv[i], "-t") == 0){
       tNoOfThreads = atoi(argv[i+1]);
-      if ((tNoOfThreads < 1) || (tNoOfThreads > MAXTHREADS)){
+      if ((tNoOfThreads < 1) || (tNoOfThreads > NDB_MAXTHREADS)){
 	ndbout_c("Invalid no of threads");
         return -1;
       }

storage/ndb/test/ndbapi/flexTimedAsynch.cpp

@@ -57,7 +57,14 @@
 #define MAXSTRLEN 16 
 #define MAXATTR 64
 #define MAXTABLES 64
-#define MAXTHREADS 256
+#define NDB_MAXTHREADS 256
+/*
+  NDB_MAXTHREADS used to be just MAXTHREADS, which collides with a
+  #define from <sys/thread.h> on AIX (IBM compiler).  We explicitly
+  #undef it here lest someone use it by habit and get really funny
+  results.  K&R says we may #undef non-existent symbols, so let's go.
+*/
+#undef MAXTHREADS
 #define MAXATTRSIZE 1000
 #define PKSIZE 1
 
@@ -95,10 +102,10 @@ static int failed = 0 ; // lame global variable that keeps track of failed trans
                         // incremented in executeCallback() and reset in main()
 /************************************************************* < epaulsa */
 
-static NdbThread* threadLife[MAXTHREADS];
+static NdbThread* threadLife[NDB_MAXTHREADS];
 static int tNodeId;
-static int ThreadReady[MAXTHREADS];
-static StartType ThreadStart[MAXTHREADS];
+static int ThreadReady[NDB_MAXTHREADS];
+static StartType ThreadStart[NDB_MAXTHREADS];
 static char tableName[MAXTABLES][MAXSTRLEN+1];
 static char attrName[MAXATTR][MAXSTRLEN+1];
 static int *getAttrValueTable;
@@ -174,7 +181,7 @@ void deleteAttributeSpace(){
 NDB_COMMAND(flexTimedAsynch, "flexTimedAsynch", "flexTimedAsynch [-tpoilcas]", "flexTimedAsynch", 65535)
 {
   ndb_init();
-  ThreadNdb		tabThread[MAXTHREADS];
+  ThreadNdb		tabThread[NDB_MAXTHREADS];
   int                   tLoops=0;
   int                   returnValue;
   //NdbOut flexTimedAsynchNdbOut;
@@ -615,8 +622,8 @@ void readArguments(int argc, const char** argv)
       if (strcmp(argv[i], "-t") == 0)
 	{
 	  tNoOfThreads = atoi(argv[i+1]);
-	  //      if ((tNoOfThreads < 1) || (tNoOfThreads > MAXTHREADS))
-	  if ((tNoOfThreads < 1) || (tNoOfThreads > MAXTHREADS))
+	  //      if ((tNoOfThreads < 1) || (tNoOfThreads > NDB_MAXTHREADS))
+	  if ((tNoOfThreads < 1) || (tNoOfThreads > NDB_MAXTHREADS))
 	    exit(-1);
 	}
       else if (strcmp(argv[i], "-i") == 0)
@@ -628,7 +635,7 @@ void readArguments(int argc, const char** argv)
       else if (strcmp(argv[i], "-p") == 0)
 	{
 	  tNoOfTransInBatch = atoi(argv[i+1]);
-	  //if ((tNoOfTransInBatch < 1) || (tNoOfTransInBatch > MAXTHREADS))
+	  //if ((tNoOfTransInBatch < 1) || (tNoOfTransInBatch > NDB_MAXTHREADS))
 	  if ((tNoOfTransInBatch < 1) || (tNoOfTransInBatch > 10000))
 	    exit(-1);
 	}

storage/ndb/test/ndbapi/initronja.cpp

@@ -29,7 +29,14 @@
 #define MAXSTRLEN 16 
 #define MAXATTR 64
 #define MAXTABLES 64
-#define MAXTHREADS 256
+#define NDB_MAXTHREADS 256
+/*
+  NDB_MAXTHREADS used to be just MAXTHREADS, which collides with a
+  #define from <sys/thread.h> on AIX (IBM compiler).  We explicitly
+  #undef it here lest someone use it by habit and get really funny
+  results.  K&R says we may #undef non-existent symbols, so let's go.
+*/
+#undef MAXTHREADS
 #define MAXATTRSIZE 8000
 
 static unsigned int tNoOfRecords;

storage/ndb/test/ndbapi/testIndexStat.cpp

@@ -1210,8 +1210,8 @@ struct V_rir {
   static double data(const Range& range) { return (double)range.errpct; }
 };
 
-template static void computestat<Key, V_rpk>(Stat& stat);
-template static void computestat<Range, V_rir>(Stat& stat);
+template void computestat<Key, V_rpk>(Stat& stat);
+template void computestat<Range, V_rir>(Stat& stat);
 
 static Stat g_stat_rpk; // summaries over loops
 static Stat g_stat_rir;
@@ -1297,43 +1297,43 @@ my_long_options[] =
 {
   NDB_STD_OPTS("testIndexStat"),
   { "loglevel", 1001, "Logging level in this program 0-3 (default 0)",
-    (gptr*)&g_opts.loglevel, (gptr*)&g_opts.loglevel, 0,
+    (uchar **)&g_opts.loglevel, (uchar **)&g_opts.loglevel, 0,
     GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
   { "seed", 1002, "Random seed (0=loop number, default -1=random)",
-    (gptr*)&g_opts.seed, (gptr*)&g_opts.seed, 0,
+    (uchar **)&g_opts.seed, (uchar **)&g_opts.seed, 0,
     GET_INT, REQUIRED_ARG, -1, 0, 0, 0, 0, 0 },
   { "loop", 1003, "Number of test loops (default 1, 0=forever)",
-    (gptr*)&g_opts.loop, (gptr*)&g_opts.loop, 0,
+    (uchar **)&g_opts.loop, (uchar **)&g_opts.loop, 0,
     GET_INT, REQUIRED_ARG, 1, 0, 0, 0, 0, 0 },
   { "rows", 1004, "Number of rows (default 100000)",
-    (gptr*)&g_opts.rows, (gptr*)&g_opts.rows, 0,
+    (uchar **)&g_opts.rows, (uchar **)&g_opts.rows, 0,
     GET_UINT, REQUIRED_ARG, 100000, 0, 0, 0, 0, 0 },
   { "ops", 1005, "Number of index scans per loop (default 1000)",
-    (gptr*)&g_opts.ops, (gptr*)&g_opts.ops, 0,
+    (uchar **)&g_opts.ops, (uchar **)&g_opts.ops, 0,
     GET_UINT, REQUIRED_ARG, 1000, 0, 0, 0, 0, 0 },
   { "dupkeys", 1006, "Pct records per key (min 100, default 1000)",
-    (gptr*)&g_opts.dupkeys, (gptr*)&g_opts.dupkeys, 0,
+    (uchar **)&g_opts.dupkeys, (uchar **)&g_opts.dupkeys, 0,
     GET_UINT, REQUIRED_ARG, 1000, 0, 0, 0, 0, 0 },
   { "scanpct", 1007, "Preferred max pct of total rows per scan (default 5)",
-    (gptr*)&g_opts.scanpct, (gptr*)&g_opts.scanpct, 0,
+    (uchar **)&g_opts.scanpct, (uchar **)&g_opts.scanpct, 0,
     GET_UINT, REQUIRED_ARG, 5, 0, 0, 0, 0, 0 },
   { "nullkeys", 1008, "Pct nulls in each key attribute (default 10)",
-    (gptr*)&g_opts.nullkeys, (gptr*)&g_opts.nullkeys, 0,
+    (uchar **)&g_opts.nullkeys, (uchar **)&g_opts.nullkeys, 0,
     GET_UINT, REQUIRED_ARG, 10, 0, 0, 0, 0, 0 },
   { "eqscans", 1009, "Pct scans for partial/full equality (default 50)",
-    (gptr*)&g_opts.eqscans, (gptr*)&g_opts.eqscans, 0,
+    (uchar **)&g_opts.eqscans, (uchar **)&g_opts.eqscans, 0,
     GET_UINT, REQUIRED_ARG, 50, 0, 0, 0, 0, 0 },
   { "dupscans", 1010, "Pct scans using same bounds (default 10)",
-    (gptr*)&g_opts.dupscans, (gptr*)&g_opts.dupscans, 0,
+    (uchar **)&g_opts.dupscans, (uchar **)&g_opts.dupscans, 0,
     GET_UINT, REQUIRED_ARG, 10, 0, 0, 0, 0, 0 },
   { "keeptable", 1011, "Use existing table and data if any and do not drop",
-    (gptr*)&g_opts.keeptable, (gptr*)&g_opts.keeptable, 0,
+    (uchar **)&g_opts.keeptable, (uchar **)&g_opts.keeptable, 0,
     GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
   { "no-extra-checks", 1012, "Omit expensive consistency checks",
-    (gptr*)&g_opts.nochecks, (gptr*)&g_opts.nochecks, 0,
+    (uchar **)&g_opts.nochecks, (uchar **)&g_opts.nochecks, 0,
     GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
   { "abort-on-error", 1013, "Dump core on any error",
-    (gptr*)&g_opts.abort, (gptr*)&g_opts.abort, 0,
+    (uchar **)&g_opts.abort, (uchar **)&g_opts.abort, 0,
     GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
   { 0, 0, 0,
     0, 0, 0,

storage/ndb/test/ndbapi/testOperations.cpp

@@ -98,11 +98,6 @@ OperationTestCase matrix[] = {
   result = NDBT_FAILED; \
   break; }
 
-#define C3(b)  if (!(b)) { \
-  g_err  << "ERR: "<< step->getName() \
-         << " failed on line " << __LINE__ << endl; \
-  abort(); return NDBT_FAILED; }
-
 #define C3(b)  if (!(b)) { \
   g_err  << "ERR: failed on line " << __LINE__ << endl; \
   return NDBT_FAILED; }

storage/ndb/test/ndbapi/testScanFilter.cpp

@@ -49,7 +49,15 @@ const char COL_LEN = 7;
 * there are six columns, 'i', 'j', 'k', 'l', 'm', 'n', and each on is equal to 1 or 1,
 * Since each tuple should be unique in this case, then TUPLE_NUM = 2 power 6 = 64 
 */
-const int TUPLE_NUM = (int)pow(2, COL_LEN-1);    
+#ifdef _AIX
+/*
+  IBM xlC_r breaks on the initialization with pow():
+  "The expression must be an integral constant expression."
+*/
+const int TUPLE_NUM = 64;
+#else
+const int TUPLE_NUM = (int)pow(2, COL_LEN-1);
+#endif
 
 /*
 * the recursive level of random scan filter, can 
@@ -479,7 +487,7 @@ int get_column_id(char ch)
 */
 bool check_col_equal_one(int tuple_no, int col_id)
 {
-  int i = (int)pow(2, 6 - col_id);
+  int i = (int)pow((double)2, (double)(6 - col_id));
   int j = tuple_no / i;
   if(j % 2)
     return true;

storage/ndb/test/ndbapi/test_event_merge.cpp

@@ -2184,57 +2184,57 @@ my_long_options[] =
 {
   NDB_STD_OPTS("test_event_merge"),
   { "abort-on-error", 1001, "Do abort() on any error",
-    (gptr*)&g_opts.abort_on_error, (gptr*)&g_opts.abort_on_error, 0,
+    (uchar **)&g_opts.abort_on_error, (uchar **)&g_opts.abort_on_error, 0,
     GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
   { "loglevel", 1002, "Logging level in this program 0-3 (default 0)",
-    (gptr*)&g_opts.loglevel, (gptr*)&g_opts.loglevel, 0,
+    (uchar **)&g_opts.loglevel, (uchar **)&g_opts.loglevel, 0,
     GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
   { "loop", 1003, "Number of test loops (default 5, 0=forever)",
-    (gptr*)&g_opts.loop, (gptr*)&g_opts.loop, 0,
+    (uchar **)&g_opts.loop, (uchar **)&g_opts.loop, 0,
     GET_INT, REQUIRED_ARG, 5, 0, 0, 0, 0, 0 },
   { "maxops", 1004, "Approx number of PK operations per table (default 1000)",
-    (gptr*)&g_opts.maxops, (gptr*)&g_opts.maxops, 0,
+    (uchar **)&g_opts.maxops, (uchar **)&g_opts.maxops, 0,
     GET_UINT, REQUIRED_ARG, 1000, 0, 0, 0, 0, 0 },
   { "maxpk", 1005, "Number of different PK values (default 10, max 1000)",
-    (gptr*)&g_opts.maxpk, (gptr*)&g_opts.maxpk, 0,
+    (uchar **)&g_opts.maxpk, (uchar **)&g_opts.maxpk, 0,
     GET_UINT, REQUIRED_ARG, 10, 0, 0, 0, 0, 0 },
   { "maxtab", 1006, "Number of tables (default 10, max 100)",
-    (gptr*)&g_opts.maxtab, (gptr*)&g_opts.maxtab, 0,
+    (uchar **)&g_opts.maxtab, (uchar **)&g_opts.maxtab, 0,
     GET_INT, REQUIRED_ARG, 10, 0, 0, 0, 0, 0 },
   { "no-blobs", 1007, "Omit blob attributes (5.0: true)",
-    (gptr*)&g_opts.no_blobs, (gptr*)&g_opts.no_blobs, 0,
+    (uchar **)&g_opts.no_blobs, (uchar **)&g_opts.no_blobs, 0,
     GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
   { "no-implicit-nulls", 1008, "Insert must include all attrs"
                                " i.e. no implicit NULLs",
-    (gptr*)&g_opts.no_implicit_nulls, (gptr*)&g_opts.no_implicit_nulls, 0,
+    (uchar **)&g_opts.no_implicit_nulls, (uchar **)&g_opts.no_implicit_nulls, 0,
     GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
   { "no-missing-update", 1009, "Update must include all non-PK attrs",
-    (gptr*)&g_opts.no_missing_update, (gptr*)&g_opts.no_missing_update, 0,
+    (uchar **)&g_opts.no_missing_update, (uchar **)&g_opts.no_missing_update, 0,
     GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
   { "no-multiops", 1010, "Allow only 1 operation per commit",
-    (gptr*)&g_opts.no_multiops, (gptr*)&g_opts.no_multiops, 0,
+    (uchar **)&g_opts.no_multiops, (uchar **)&g_opts.no_multiops, 0,
     GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
   { "no-nulls", 1011, "Create no NULL values",
-    (gptr*)&g_opts.no_nulls, (gptr*)&g_opts.no_nulls, 0,
+    (uchar **)&g_opts.no_nulls, (uchar **)&g_opts.no_nulls, 0,
     GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
   { "one-blob", 1012, "Only one blob attribute (default 2)",
-    (gptr*)&g_opts.one_blob, (gptr*)&g_opts.one_blob, 0,
+    (uchar **)&g_opts.one_blob, (uchar **)&g_opts.one_blob, 0,
     GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
   { "opstring", 1013, "Operations to run e.g. idiucdc (c is commit) or"
                       " iuuc:uudc (the : separates loops)",
-    (gptr*)&g_opts.opstring, (gptr*)&g_opts.opstring, 0,
+    (uchar **)&g_opts.opstring, (uchar **)&g_opts.opstring, 0,
     GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
   { "seed", 1014, "Random seed (0=loop number, default -1=random)",
-    (gptr*)&g_opts.seed, (gptr*)&g_opts.seed, 0,
+    (uchar **)&g_opts.seed, (uchar **)&g_opts.seed, 0,
     GET_INT, REQUIRED_ARG, -1, 0, 0, 0, 0, 0 },
   { "separate-events", 1015, "Do not combine events per GCI (5.0: true)",
-    (gptr*)&g_opts.separate_events, (gptr*)&g_opts.separate_events, 0,
+    (uchar **)&g_opts.separate_events, (uchar **)&g_opts.separate_events, 0,
     GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
   { "tweak", 1016, "Whatever the source says",
-    (gptr*)&g_opts.tweak, (gptr*)&g_opts.tweak, 0,
+    (uchar **)&g_opts.tweak, (uchar **)&g_opts.tweak, 0,
     GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
   { "use-table", 1017, "Use existing tables",
-    (gptr*)&g_opts.use_table, (gptr*)&g_opts.use_table, 0,
+    (uchar **)&g_opts.use_table, (uchar **)&g_opts.use_table, 0,
     GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
   { 0, 0, 0,
     0, 0, 0,

storage/ndb/test/odbc/SQL99_test/SQL99_test.cpp

@@ -27,7 +27,14 @@ using namespace std; //
 #define MAXROW			64
 #define DEFROW			8
 
-#define MAXTHREADS		24
+/*
+  NDB_MAXTHREADS used to be just MAXTHREADS, which collides with a
+  #define from <sys/thread.h> on AIX (IBM compiler).  We explicitly
+  #undef it here lest someone use it by habit and get really funny
+  results.  K&R says we may #undef non-existent symbols, so let's go.
+*/
+#undef MAXTHREADS
+#define NDB_MAXTHREADS		24
 #define DEFTHREADS		2
 
 #define MAXTABLES		16
@@ -83,7 +90,7 @@ int main(int argc, char* argv[]){
     char* szTableNames = (char*)malloc(sizeof(char)*nNoOfTables*MAX_TABLE_NAME) ;
     memset(szTableNames, 0, sizeof(char)*nNoOfTables*MAX_TABLE_NAME) ;
 
-	UintPtr pThreadHandles[MAXTHREADS] = { NULL } ;
+	UintPtr pThreadHandles[NDB_MAXTHREADS] = { NULL } ;
 
     AssignTableNames(szTableNames, nNoOfTables) ;
 
@@ -313,7 +320,7 @@ void ParseArguments(int argc, const char** argv){
         if (strcmp(argv[i], "-t") == 0)
             {
             nNoOfThreads = atoi(argv[i+1]);
-            if ((nNoOfThreads < 1) || (nNoOfThreads > MAXTHREADS))
+            if ((nNoOfThreads < 1) || (nNoOfThreads > NDB_MAXTHREADS))
                 nNoOfThreads = DEFTHREADS ;
             }
         else if (strcmp(argv[i], "-c") == 0)

storage/ndb/test/run-test/main.cpp

@@ -77,60 +77,60 @@ my_bool opt_core;
 static struct my_option g_options[] =
 {
   { "help", '?', "Display this help and exit.", 
-    (gptr*) &g_help, (gptr*) &g_help,
+    (uchar **) &g_help, (uchar **) &g_help,
     0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 }, 
   { "version", 'V', "Output version information and exit.", 0, 0, 0, 
     GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0 }, 
   { "clusters", 256, "Cluster",
-    (gptr*) &g_clusters, (gptr*) &g_clusters,
+    (uchar **) &g_clusters, (uchar **) &g_clusters,
     0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
   { "replicate", 1024, "replicate",
-    (gptr*) &g_dummy, (gptr*) &g_dummy,
+    (uchar **) &g_dummy, (uchar **) &g_dummy,
     0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
   { "log-file", 256, "log-file",
-    (gptr*) &g_log_filename, (gptr*) &g_log_filename,
+    (uchar **) &g_log_filename, (uchar **) &g_log_filename,
     0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
   { "testcase-file", 'f', "testcase-file",
-    (gptr*) &g_test_case_filename, (gptr*) &g_test_case_filename,
+    (uchar **) &g_test_case_filename, (uchar **) &g_test_case_filename,
     0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
   { "report-file", 'r', "report-file",
-    (gptr*) &g_report_filename, (gptr*) &g_report_filename,
+    (uchar **) &g_report_filename, (uchar **) &g_report_filename,
     0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
   { "basedir", 256, "Base path",
-    (gptr*) &g_basedir, (gptr*) &g_basedir,
+    (uchar **) &g_basedir, (uchar **) &g_basedir,
     0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
   { "baseport", 256, "Base port",
-    (gptr*) &g_baseport, (gptr*) &g_baseport,
+    (uchar **) &g_baseport, (uchar **) &g_baseport,
     0, GET_INT, REQUIRED_ARG, g_baseport, 0, 0, 0, 0, 0},
   { "prefix", 256, "mysql install dir",
-    (gptr*) &g_prefix, (gptr*) &g_prefix,
+    (uchar **) &g_prefix, (uchar **) &g_prefix,
     0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
   { "verbose", 'v', "Verbosity",
-    (gptr*) &g_verbosity, (gptr*) &g_verbosity,
+    (uchar **) &g_verbosity, (uchar **) &g_verbosity,
     0, GET_INT, REQUIRED_ARG, g_verbosity, 0, 0, 0, 0, 0},
   { "configure", 256, "configure",
-    (gptr*) &g_do_setup, (gptr*) &g_do_setup,
+    (uchar **) &g_do_setup, (uchar **) &g_do_setup,
     0, GET_INT, REQUIRED_ARG, g_do_setup, 0, 0, 0, 0, 0 },
   { "deploy", 256, "deploy",
-    (gptr*) &g_do_deploy, (gptr*) &g_do_deploy,
+    (uchar **) &g_do_deploy, (uchar **) &g_do_deploy,
     0, GET_INT, REQUIRED_ARG, g_do_deploy, 0, 0, 0, 0, 0 },
   { "sshx", 256, "sshx",
-    (gptr*) &g_do_sshx, (gptr*) &g_do_sshx,
+    (uchar **) &g_do_sshx, (uchar **) &g_do_sshx,
     0, GET_INT, REQUIRED_ARG, g_do_sshx, 0, 0, 0, 0, 0 },
   { "start", 256, "start",
-    (gptr*) &g_do_start, (gptr*) &g_do_start,
+    (uchar **) &g_do_start, (uchar **) &g_do_start,
     0, GET_INT, REQUIRED_ARG, g_do_start, 0, 0, 0, 0, 0 },
   { "fqpn", 256, "Fully qualified path-names ",
-    (gptr*) &g_fqpn, (gptr*) &g_fqpn,
+    (uchar **) &g_fqpn, (uchar **) &g_fqpn,
     0, GET_INT, REQUIRED_ARG, g_fqpn, 0, 0, 0, 0, 0 },
   { "default-ports", 256, "Use default ports when possible",
-    (gptr*) &g_default_ports, (gptr*) &g_default_ports,
+    (uchar **) &g_default_ports, (uchar **) &g_default_ports,
     0, GET_INT, REQUIRED_ARG, g_default_ports, 0, 0, 0, 0, 0 },
   { "mode", 256, "Mode 0=interactive 1=regression 2=bench",
-    (gptr*) &g_mode, (gptr*) &g_mode,
+    (uchar **) &g_mode, (uchar **) &g_mode,
     0, GET_INT, REQUIRED_ARG, g_mode, 0, 0, 0, 0, 0 },
   { "quit", 256, "Quit before starting tests",
-    (gptr*) &g_mode, (gptr*) &g_do_quit,
+    (uchar **) &g_mode, (uchar **) &g_do_quit,
     0, GET_BOOL, NO_ARG, g_do_quit, 0, 0, 0, 0, 0 },
   { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
 };

storage/ndb/test/src/NDBT_Test.cpp

@@ -1195,35 +1195,35 @@ static struct my_option my_long_options[] =
 {
   NDB_STD_OPTS(""),
   { "print", OPT_PRINT, "Print execution tree",
-    (gptr*) &opt_print, (gptr*) &opt_print, 0,
+    (uchar **) &opt_print, (uchar **) &opt_print, 0,
     GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
   { "print_html", OPT_PRINT_HTML, "Print execution tree in html table format",
-    (gptr*) &opt_print_html, (gptr*) &opt_print_html, 0,
+    (uchar **) &opt_print_html, (uchar **) &opt_print_html, 0,
     GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
   { "print_cases", OPT_PRINT_CASES, "Print list of test cases",
-    (gptr*) &opt_print_cases, (gptr*) &opt_print_cases, 0,
+    (uchar **) &opt_print_cases, (uchar **) &opt_print_cases, 0,
     GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
   { "records", 'r', "Number of records", 
-    (gptr*) &opt_records, (gptr*) &opt_records, 0,
+    (uchar **) &opt_records, (uchar **) &opt_records, 0,
     GET_INT, REQUIRED_ARG, 1000, 0, 0, 0, 0, 0 },
   { "loops", 'l', "Number of loops",
-    (gptr*) &opt_loops, (gptr*) &opt_loops, 0,
+    (uchar **) &opt_loops, (uchar **) &opt_loops, 0,
     GET_INT, REQUIRED_ARG, 5, 0, 0, 0, 0, 0 },
   { "seed", 1024, "Random seed",
-    (gptr*) &opt_seed, (gptr*) &opt_seed, 0,
+    (uchar **) &opt_seed, (uchar **) &opt_seed, 0,
     GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
   { "testname", 'n', "Name of test to run",
-    (gptr*) &opt_testname, (gptr*) &opt_testname, 0,
+    (uchar **) &opt_testname, (uchar **) &opt_testname, 0,
     GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
   { "remote_mgm", 'm',
     "host:port to mgmsrv of remote cluster",
-    (gptr*) &opt_remote_mgm, (gptr*) &opt_remote_mgm, 0,
+    (uchar **) &opt_remote_mgm, (uchar **) &opt_remote_mgm, 0,
     GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
   { "timer", 't', "Print execution time",
-    (gptr*) &opt_timer, (gptr*) &opt_timer, 0,
+    (uchar **) &opt_timer, (uchar **) &opt_timer, 0,
     GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
   { "verbose", 'v', "Print verbose status",
-    (gptr*) &opt_verbose, (gptr*) &opt_verbose, 0,
+    (uchar **) &opt_verbose, (uchar **) &opt_verbose, 0,
     GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
   { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
 };