- FIX PIVOT bug MDEV-5869 caused by using fop (field option ptr) when NULL.

modified:
  storage/connect/ha_connect.cc

- Suppress the use of connect.in by adding the connect_xtrace system variable.
modified:
  storage/connect/ha_connect.cc

- Make column length, varchar, and temporal column types recognized in discovery
  when using SRCDEF,or PIVOT.
modified:
  storage/connect/ha_connect.cc
  storage/connect/myconn.cpp
  storage/connect/myutil.cpp
  storage/connect/plgdbsem.h

- Avoid (rare) crash when using DECIMAL type. (buf was too small)
modified:
  storage/connect/tabfmt.cpp
  storage/connect/tabmysql.cpp
  storage/connect/tabodbc.cpp
  storage/connect/tabpivot.cpp
  storage/connect/valblk.cpp
  storage/connect/value.cpp

- General cleaning of unused code, standardize tracing, and update version number
modified:
  storage/connect/block.h
  storage/connect/colblk.cpp
  storage/connect/connect.cc
  storage/connect/csort.h
  storage/connect/filamap.cpp
  storage/connect/filamdbf.cpp
  storage/connect/filamfix.cpp
  storage/connect/filamzip.cpp
  storage/connect/ha_connect.cc
  storage/connect/mycat.cc
  storage/connect/myconn.cpp
  storage/connect/mysql-test/connect/r/alter.result
  storage/connect/mysql-test/connect/r/xml.result
  storage/connect/myutil.cpp
  storage/connect/osutil.c
  storage/connect/plgdbsem.h
  storage/connect/plgdbutl.cpp
  storage/connect/plugutil.c
  storage/connect/reldef.cpp
  storage/connect/tabcol.cpp
  storage/connect/tabfmt.cpp
  storage/connect/tabmysql.cpp
  storage/connect/tabodbc.cpp
  storage/connect/tabpivot.cpp
  storage/connect/tabvct.cpp
  storage/connect/user_connect.cc
  storage/connect/valblk.cpp
  storage/connect/value.cpp
  storage/connect/xindex.cpp

storage/connect/block.h

@@ -38,10 +38,9 @@ typedef class BLOCK *PBLOCK;
 class DllExport BLOCK {
  public:
   void * operator new(size_t size, PGLOBAL g, void *p = NULL) {
-#ifdef DEBTRACE
-if (debug != NULL)
- htrc("New BLOCK: size=%d g=%p p=%p\n", size, g, p);
-#endif
+//  if (trace > 2)
+//    htrc("New BLOCK: size=%d g=%p p=%p\n", size, g, p);
+
     return (PlugSubAlloc(g, p, size));
     } // end of new
 

storage/connect/colblk.cpp

@@ -23,6 +23,8 @@
 #include "xindex.h"
 #include "xtable.h"
 
+extern "C" int  trace;
+
 /***********************************************************************/
 /*  COLBLK protected constructor.                                      */
 /***********************************************************************/
@@ -72,9 +74,8 @@ COLBLK::COLBLK(PCOL col1, PTDB tdbp)
 //To_Orig = col1;
   To_Tdb = tdbp;
 
-#ifdef DEBTRACE
- htrc(" copying COLBLK %s from %p to %p\n", Name, col1, this);
-#endif
+  if (trace > 1)
+    htrc(" copying COLBLK %s from %p to %p\n", Name, col1, this);
 
   if (tdbp)
     // Attach the new column to the table block
@@ -112,10 +113,9 @@ bool COLBLK::SetFormat(PGLOBAL g, FORMAT& fmt)
   {
   fmt = Format;
 
-#ifdef DEBTRACE
- htrc("COLBLK: %p format=%c(%d,%d)\n", 
-   this, *fmt.Type, fmt.Length, fmt.Prec);
-#endif
+  if (trace > 1)
+    htrc("COLBLK: %p format=%c(%d,%d)\n", 
+         this, *fmt.Type, fmt.Length, fmt.Prec);
 
   return false;
   } // end of SetFormat
@@ -126,9 +126,8 @@ bool COLBLK::SetFormat(PGLOBAL g, FORMAT& fmt)
 /***********************************************************************/
 bool COLBLK::Eval(PGLOBAL g)
   {
-#ifdef DEBTRACE
- htrc("Col Eval: %s status=%.4X\n", Name, Status);
-#endif
+  if (trace > 1)
+    htrc("Col Eval: %s status=%.4X\n", Name, Status);
 
   if (!GetStatus(BUF_READ)) {
 //  if (To_Tdb->IsNull())
@@ -164,10 +163,9 @@ bool COLBLK::InitValue(PGLOBAL g)
   AddStatus(BUF_READY);
   Value->SetNullable(Nullable);
 
-#ifdef DEBTRACE
- htrc(" colp=%p type=%d value=%p coluse=%.4X status=%.4X\n",
-  this, Buf_Type, Value, ColUse, Status);
-#endif
+  if (trace > 1)
+    htrc(" colp=%p type=%d value=%p coluse=%.4X status=%.4X\n",
+         this, Buf_Type, Value, ColUse, Status);
 
   return false;
   } // end of InitValue

storage/connect/connect.cc

@@ -51,7 +51,7 @@
 /***********************************************************************/
 /*  DB static variables.                                               */
 /***********************************************************************/
-extern int xtrace;
+extern "C" int trace;
 
 /***********************************************************************/
 /*  Routines called internally by semantic routines.                   */
@@ -110,14 +110,14 @@ bool CntCheckDB(PGLOBAL g, PHC handler, const char *pathname)
   bool    rc= false;
   PDBUSER dbuserp= PlgGetUser(g);
 
-  if (xtrace) {
+  if (trace) {
     printf("CntCheckDB: dbuserp=%p\n", dbuserp);
-    } // endif xtrace
+    } // endif trace
 
   if (!dbuserp || !handler)
     return true;
 
-  if (xtrace)
+  if (trace)
     printf("cat=%p oldhandler=%p newhandler=%p\n", dbuserp->Catalog,
     (dbuserp->Catalog) ? ((MYCAT*)dbuserp->Catalog)->GetHandler() : NULL,
            handler);
@@ -149,7 +149,7 @@ bool CntCheckDB(PGLOBAL g, PHC handler, const char *pathname)
   /*********************************************************************/
   sprintf(g->Message, MSG(DATABASE_LOADED), "???");
 
-  if (xtrace)
+  if (trace)
     printf("msg=%s\n", g->Message);
 
   return rc;
@@ -193,7 +193,7 @@ PTDB CntGetTDB(PGLOBAL g, LPCSTR name, MODE mode, PHC h)
   PDBUSER dup= PlgGetUser(g);
   PCATLG  cat= (dup) ? dup->Catalog : NULL;     // Safe over longjmp
 
-  if (xtrace)
+  if (trace)
     printf("CntGetTDB: name=%s mode=%d cat=%p\n", name, mode, cat);
 
   if (!cat)
@@ -213,7 +213,7 @@ PTDB CntGetTDB(PGLOBAL g, LPCSTR name, MODE mode, PHC h)
   // Get table object from the catalog
   tabp= new(g) XTAB(name);
 
-  if (xtrace)
+  if (trace)
     printf("CntGetTDB: tabp=%p\n", tabp);
 
   // Perhaps this should be made thread safe
@@ -223,7 +223,7 @@ PTDB CntGetTDB(PGLOBAL g, LPCSTR name, MODE mode, PHC h)
     printf("CntGetTDB: %s\n", g->Message);
 
  err:
-  if (xtrace)
+  if (trace)
     printf("Returning tdbp=%p mode=%d\n", tdbp, mode);
 
   g->jump_level--;
@@ -243,7 +243,7 @@ bool CntOpenTable(PGLOBAL g, PTDB tdbp, MODE mode, char *c1, char *c2,
 //PCOLUMN cp;
   PDBUSER dup= PlgGetUser(g);
 
-  if (xtrace)
+  if (trace)
     printf("CntOpenTable: tdbp=%p mode=%d\n", tdbp, mode);
 
   if (!tdbp) {
@@ -269,7 +269,7 @@ bool CntOpenTable(PGLOBAL g, PTDB tdbp, MODE mode, char *c1, char *c2,
 
   } else for (p= c1; *p; p+= n) {
     // Allocate only used column blocks
-    if (xtrace)
+    if (trace)
       printf("Allocating column %s\n", p);
 
 //    if (*p == '*') {
@@ -337,7 +337,7 @@ bool CntOpenTable(PGLOBAL g, PTDB tdbp, MODE mode, char *c1, char *c2,
     ((PTDBASE)tdbp)->SetSetCols(tdbp->GetColumns());
 
   // Now do open the physical table
-  if (xtrace)
+  if (trace)
     printf("Opening table %s in mode %d tdbp=%p\n",
            tdbp->GetName(), mode, tdbp);
 
@@ -353,7 +353,7 @@ bool CntOpenTable(PGLOBAL g, PTDB tdbp, MODE mode, char *c1, char *c2,
     } // endif del
 
 
-  if (xtrace)
+  if (trace)
     printf("About to open the table: tdbp=%p\n", tdbp);
 
   if (mode != MODE_ANY && mode != MODE_ALTER) {
@@ -394,7 +394,7 @@ RCODE EvalColumns(PGLOBAL g, PTDB tdbp, bool mrr)
 
   // Save stack and allocation environment and prepare error return
   if (g->jump_level == MAX_JUMP) {
-    if (xtrace) {
+    if (trace) {
       strcpy(g->Message, MSG(TOO_MANY_JUMPS));
       printf("EvalColumns: %s\n", g->Message);
       } // endif
@@ -403,7 +403,7 @@ RCODE EvalColumns(PGLOBAL g, PTDB tdbp, bool mrr)
     } // endif jump_level
 
   if (setjmp(g->jumper[++g->jump_level]) != 0) {
-    if (xtrace)
+    if (trace)
       printf("Error reading columns: %s\n", g->Message);
 
     rc= RC_FX;
@@ -547,7 +547,7 @@ int CntCloseTable(PGLOBAL g, PTDB tdbp)
   if (!tdbp || tdbp->GetUse() != USE_OPEN)
     return rc;                           // Nothing to do
 
-  if (xtrace)
+  if (trace)
     printf("CntCloseTable: tdbp=%p mode=%d\n", tdbp, tdbp->GetMode());
 
   if (tdbp->GetMode() == MODE_DELETE && tdbp->GetUse() == USE_OPEN)
@@ -571,7 +571,7 @@ int CntCloseTable(PGLOBAL g, PTDB tdbp)
 
   g->jump_level--;
 
-  if (xtrace > 1)
+  if (trace > 1)
     printf("Table %s closed\n", tdbp->GetName());
 
 //if (!((PTDBDOX)tdbp)->GetModified())
@@ -580,7 +580,7 @@ int CntCloseTable(PGLOBAL g, PTDB tdbp)
   if (tdbp->GetMode() == MODE_READ || tdbp->GetMode() == MODE_ANY) 
     return 0;
 
-  if (xtrace > 1)
+  if (trace > 1)
     printf("About to reset indexes\n");
 
   // Make all the eventual indexes
@@ -590,7 +590,7 @@ int CntCloseTable(PGLOBAL g, PTDB tdbp)
   rc= tbxp->ResetTableOpt(g, ((PTDBASE)tdbp)->GetDef()->Indexable());
 
  err:
-  if (xtrace > 1)
+  if (trace > 1)
     printf("Done rc=%d\n", rc);
 
   return (rc == RC_OK || rc == RC_INFO) ? 0 : rc;
@@ -859,10 +859,10 @@ int CntIndexRange(PGLOBAL g, PTDB ptdb, const uchar* *key, uint *len,
           } else
             valp->SetBinValue((void*)p);
 
-          if (xtrace) {
+          if (trace) {
             char bf[32];
             printf("i=%d n=%d key=%s\n", i, n, valp->GetCharString(bf));
-            } // endif xtrace
+            } // endif trace
 
           p+= valp->GetClen();
     
@@ -881,7 +881,7 @@ int CntIndexRange(PGLOBAL g, PTDB ptdb, const uchar* *key, uint *len,
 
       xbp->SetNval(n);
 
-      if (xtrace)
+      if (trace)
         printf("xbp=%p Nval=%d i=%d incl=%d\n", xbp, n, i, incl[i]);
 
       k[i]= xbp->Range(g, i + 1, incl[i]);
@@ -890,7 +890,7 @@ int CntIndexRange(PGLOBAL g, PTDB ptdb, const uchar* *key, uint *len,
 
     } // endfor i
 
-  if (xtrace)
+  if (trace)
     printf("k1=%d k0=%d\n", k[1], k[0]);
 
   return k[1] - k[0];

storage/connect/csort.h

@@ -22,9 +22,7 @@
 #define  THRESH    4                /* Threshold for insertion (was 4) */
 #define  MTHRESH   6                /* Threshold for median            */
 
-#ifdef DEBTRACE
-extern  FILE   *debug;              /* Debug file                      */
-#endif
+//extern  FILE   *debug;              /* Debug file                      */
 
 typedef int* const    CPINT;
 

storage/connect/filamap.cpp

@@ -46,6 +46,8 @@
 #include "filamap.h"
 #include "tabdos.h"
 
+extern "C" int  trace;
+
 /* --------------------------- Class MAPFAM -------------------------- */
 
 /***********************************************************************/
@@ -89,9 +91,8 @@ int MAPFAM::GetFileLength(PGLOBAL g)
 
   len = (To_Fb) ? To_Fb->Length :  TXTFAM::GetFileLength(g);
 
-#ifdef DEBTRACE
- htrc("Mapped file length=%d\n", len);
-#endif
+  if (trace)
+    htrc("Mapped file length=%d\n", len);
 
   return len;
   } // end of GetFileLength
@@ -128,9 +129,9 @@ bool MAPFAM::OpenTableFile(PGLOBAL g)
                      && fp->Count && fp->Mode == mode)
         break;
 
-#ifdef DEBTRACE
- htrc("Mapping file, fp=%p\n", fp);
-#endif
+    if (trace)
+      htrc("Mapping file, fp=%p\n", fp);
+
   } else
     fp = NULL;
 
@@ -166,9 +167,9 @@ bool MAPFAM::OpenTableFile(PGLOBAL g)
         sprintf(g->Message, MSG(OPEN_MODE_ERROR),
                 "map", (int) rc, filename);
 
-#ifdef DEBTRACE
- htrc("%s\n", g->Message);
-#endif
+      if (trace)
+        htrc("CreateFileMap: %s\n", g->Message);
+
       return (mode == MODE_READ && rc == ENOENT)
               ? PushWarning(g, Tdbp) : true;
       } // endif hFile
@@ -228,10 +229,9 @@ bool MAPFAM::OpenTableFile(PGLOBAL g)
   Fpos = Mempos = Memory;
   Top = Memory + len;
 
-#ifdef DEBTRACE
- htrc("fp=%p count=%d MapView=%p len=%d Top=%p\n",
-  fp, fp->Count, Memory, len, Top);
-#endif
+  if (trace)
+    htrc("fp=%p count=%d MapView=%p len=%d Top=%p\n",
+          fp, fp->Count, Memory, len, Top);
 
   return AllocateBuffer(g);          // Useful for DBF files
   } // end of OpenTableFile
@@ -365,20 +365,19 @@ int MAPFAM::DeleteRecords(PGLOBAL g, int irc)
   {
   int    n;
 
-#ifdef DEBTRACE
- fprintf(debug,
-  "MAP DeleteDB: irc=%d mempos=%p tobuf=%p Tpos=%p Spos=%p\n",
-  irc, Mempos, To_Buf, Tpos, Spos);
-#endif
+  if (trace)
+    htrc("MAP DeleteDB: irc=%d mempos=%p tobuf=%p Tpos=%p Spos=%p\n",
+         irc, Mempos, To_Buf, Tpos, Spos);
 
   if (irc != RC_OK) {
     /*******************************************************************/
     /*  EOF: position Fpos at the top of map position.                 */
     /*******************************************************************/
     Fpos = Top;
-#ifdef DEBTRACE
- htrc("Fpos placed at file top=%p\n", Fpos);
-#endif
+
+    if (trace)
+      htrc("Fpos placed at file top=%p\n", Fpos);
+
     } // endif irc
 
   if (Tpos == Spos)
@@ -394,17 +393,16 @@ int MAPFAM::DeleteRecords(PGLOBAL g, int irc)
     memmove(Tpos, Spos, n);
     Tpos += n;
 
-#ifdef DEBTRACE
- htrc("move %d bytes\n", n);
-#endif
+    if (trace)
+      htrc("move %d bytes\n", n);
+
     } // endif n
 
   if (irc == RC_OK) {
     Spos = Mempos;                               // New start position
 
-#ifdef DEBTRACE
- htrc("after: Tpos=%p Spos=%p\n", Tpos, Spos);
-#endif
+    if (trace)
+      htrc("after: Tpos=%p Spos=%p\n", Tpos, Spos);
 
   } else if (To_Fb) {                 // Can be NULL for deleted files
     /*******************************************************************/
@@ -432,9 +430,8 @@ int MAPFAM::DeleteRecords(PGLOBAL g, int irc)
       return RC_FX;
       } // endif
 
-#ifdef DEBTRACE
- htrc("done, Tpos=%p newsize=%d drc=%d\n", Tpos, n, drc);
-#endif
+    if (trace)
+     htrc("done, Tpos=%p newsize=%d drc=%d\n", Tpos, n, drc);
 
     if (!SetEndOfFile(fp->Handle)) {
       sprintf(g->Message, MSG(FUNCTION_ERROR),
@@ -466,10 +463,10 @@ void MAPFAM::CloseTableFile(PGLOBAL g)
   PlugCloseFile(g, To_Fb);
   To_Fb = NULL;              // To get correct file size in Cardinality 
 
-#ifdef DEBTRACE
- htrc("MAP Close: closing %s count=%d\n",
-   To_File, (To_Fb) ? To_Fb->Count : 0);
-#endif
+  if (trace)
+    htrc("MAP Close: closing %s count=%d\n",
+         To_File, (To_Fb) ? To_Fb->Count : 0);
+
   } // end of CloseTableFile
 
 /***********************************************************************/

storage/connect/filamdbf.cpp

@@ -485,16 +485,15 @@ bool DBFFAM::OpenTableFile(PGLOBAL g)
   PlugSetPath(filename, To_File, Tdbp->GetPath());
 
   if (!(Stream = PlugOpenFile(g, filename, opmode))) {
-#ifdef DEBTRACE
- htrc("%s\n", g->Message);
-#endif
+    if (trace)
+      htrc("%s\n", g->Message);
+    
     return (mode == MODE_READ && errno == ENOENT)
             ? PushWarning(g, Tdbp) : true;
     } // endif Stream
 
-#ifdef DEBTRACE
- htrc("File %s is open in mode %s\n", filename, opmode);
-#endif
+  if (trace)
+    htrc("File %s is open in mode %s\n", filename, opmode);
 
   To_Fb = dbuserp->Openlist;     // Keep track of File block
 
@@ -853,10 +852,10 @@ void DBFFAM::CloseTableFile(PGLOBAL g)
     rc = PlugCloseFile(g, To_Fb);
 
  fin:
-#ifdef DEBTRACE
- htrc("DBF CloseTableFile: closing %s mode=%d wrc=%d rc=%d\n",
-  To_File, mode, wrc, rc);
-#endif
+  if (trace)
+    htrc("DBF CloseTableFile: closing %s mode=%d wrc=%d rc=%d\n",
+         To_File, mode, wrc, rc);
+
   Stream = NULL;           // So we can know whether table is open
   } // end of CloseTableFile
 

storage/connect/filamzip.cpp

@@ -62,6 +62,7 @@
 /*  DB static variables.                                               */
 /***********************************************************************/
 extern int num_read, num_there, num_eq[];                 // Statistics
+extern "C" int  trace;
 
 /* ------------------------------------------------------------------- */
 
@@ -203,9 +204,8 @@ bool ZIPFAM::AllocateBuffer(PGLOBAL g)
   Buflen = Lrecl + 2;                     // Lrecl does not include CRLF
 //Buflen *= ((Mode == MODE_DELETE) ? DOS_BUFF_LEN : 1);    NIY
 
-#ifdef DEBTRACE
- htrc("SubAllocating a buffer of %d bytes\n", Buflen);
-#endif
+  if (trace)
+    htrc("SubAllocating a buffer of %d bytes\n", Buflen);
 
   To_Buf = (char*)PlugSubAlloc(g, NULL, Buflen);
 
@@ -331,9 +331,9 @@ int ZIPFAM::ReadBuffer(PGLOBAL g)
   } else
     rc = Zerror(g);
 
-#ifdef DEBTRACE
- htrc(" Read: '%s' rc=%d\n", To_Buf, rc);
-#endif
+  if (trace > 1)
+    htrc(" Read: '%s' rc=%d\n", To_Buf, rc);
+
   return rc;
   } // end of ReadBuffer
 
@@ -373,9 +373,8 @@ void ZIPFAM::CloseTableFile(PGLOBAL g)
   {
   int rc = gzclose(Zfile);
 
-#ifdef DEBTRACE
- htrc("ZIP CloseDB: closing %s rc=%d\n", To_File, rc);
-#endif
+  if (trace)
+    htrc("ZIP CloseDB: closing %s rc=%d\n", To_File, rc);
 
   Zfile = NULL;            // So we can know whether table is open
 //To_Fb->Count = 0;        // Avoid double closing by PlugCloseAll
@@ -599,9 +598,8 @@ void ZBKFAM::CloseTableFile(PGLOBAL g)
   } else
     rc = gzclose(Zfile);
 
-#ifdef DEBTRACE
- htrc("ZIP CloseDB: closing %s rc=%d\n", To_File, rc);
-#endif
+  if (trace)
+    htrc("ZIP CloseDB: closing %s rc=%d\n", To_File, rc);
 
   Zfile = NULL;            // So we can know whether table is open
 //To_Fb->Count = 0;        // Avoid double closing by PlugCloseAll

storage/connect/mycat.cc

@@ -96,7 +96,7 @@
 extern "C" HINSTANCE s_hModule;           // Saved module handle
 #endif  // !WIN32
 
-extern int xtrace;
+extern "C" int trace;
 
 PQRYRES OEMColumns(PGLOBAL g, PTOS topt, char *tab, char *db, bool info);
 
@@ -716,7 +716,7 @@ bool MYCAT::GetIndexInfo(PGLOBAL g, PTABDEF defp)
 PRELDEF MYCAT::GetTableDesc(PGLOBAL g, LPCSTR name,
                                        LPCSTR type, PRELDEF *prp)
   {
-	if (xtrace)
+	if (trace)
 		printf("GetTableDesc: name=%s am=%s\n", name, SVP(type));
 
  	// If not specified get the type of this table
@@ -735,7 +735,7 @@ PRELDEF MYCAT::MakeTableDesc(PGLOBAL g, LPCSTR name, LPCSTR am)
   TABTYPE tc;
   PRELDEF tdp= NULL;
 
-	if (xtrace)
+	if (trace)
 		printf("MakeTableDesc: name=%s am=%s\n", name, SVP(am));
 
   /*********************************************************************/
@@ -794,14 +794,14 @@ PTDB MYCAT::GetTable(PGLOBAL g, PTABLE tablep, MODE mode, LPCSTR type)
   PTDB    tdbp= NULL;
   LPCSTR  name= tablep->GetName();
 
-	if (xtrace)
+	if (trace)
 		printf("GetTableDB: name=%s\n", name);
 
   // Look for the description of the requested table
   tdp= GetTableDesc(g, name, type);
 
   if (tdp) {
-		if (xtrace)
+		if (trace)
 			printf("tdb=%p type=%s\n", tdp, tdp->GetType());
 
 		if (tablep->GetQualifier())
@@ -811,7 +811,7 @@ PTDB MYCAT::GetTable(PGLOBAL g, PTABLE tablep, MODE mode, LPCSTR type)
 		} // endif tdp
 
   if (tdbp) {
-		if (xtrace)
+		if (trace)
 			printf("tdbp=%p name=%s amtype=%d\n", tdbp, tdbp->GetName(),
 																						tdbp->GetAmType());
     tablep->SetTo_Tdb(tdbp);

storage/connect/myconn.cpp

@@ -295,7 +295,7 @@ PQRYRES SrcColumns(PGLOBAL g, const char *host, const char *db,
 
   // Send the source command to MySQL
   if (myc.ExecSQL(g, query, &w) == RC_OK)
-    qrp = myc.GetResult(g);
+    qrp = myc.GetResult(g, true);
 
   myc.Close();
   return qrp;
@@ -676,7 +676,7 @@ MYSQL_FIELD *MYSQLC::GetNextField(void)
 /***********************************************************************/
 PQRYRES MYSQLC::GetResult(PGLOBAL g, bool pdb)
   {
-  char        *fmt;
+  char        *fmt, v;
   int          n;
   bool         uns;
   PCOLRES     *pcrp, crp;
@@ -705,7 +705,6 @@ PQRYRES MYSQLC::GetResult(PGLOBAL g, bool pdb)
   qrp->Nblin = 0;
   qrp->Cursor = 0;
 
-
 //for (fld = mysql_fetch_field(m_Res); fld;
 //     fld = mysql_fetch_field(m_Res)) {
   for (fld = GetNextField(); fld; fld = GetNextField()) {
@@ -718,17 +717,19 @@ PQRYRES MYSQLC::GetResult(PGLOBAL g, bool pdb)
     crp->Name = (char*)PlugSubAlloc(g, NULL, fld->name_length + 1);
     strcpy(crp->Name, fld->name);
 
-    if ((crp->Type = MYSQLtoPLG(fld->type)) == TYPE_ERROR) {
+    if ((crp->Type = MYSQLtoPLG(fld->type, &v)) == TYPE_ERROR) {
       sprintf(g->Message, "Type %d not supported for column %s",
                           fld->type, crp->Name);
       return NULL;
     } else if (crp->Type == TYPE_DATE && !pdb)
       // For direct MySQL connection, display the MySQL date string
       crp->Type = TYPE_STRING;
+    else
+      crp->Var = v;
 
     crp->Prec = (crp->Type == TYPE_DOUBLE || crp->Type == TYPE_DECIM)
               ? fld->decimals : 0;
-    crp->Length = fld->max_length;
+    crp->Length = max(fld->length, fld->max_length);
     crp->Clen = GetTypeSize(crp->Type, crp->Length);
     uns = (fld->flags & (UNSIGNED_FLAG | ZEROFILL_FLAG)) ? true : false;
 

storage/connect/mysql-test/connect/r/alter.result

@@ -95,7 +95,7 @@ Warning	1105	This is an outward table, table data were not modified.
 SELECT * FROM t2;
 line
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- Created by CONNECT Version 1.02.0001 February 03, 2014 -->
+<!-- Created by CONNECT Version 1.02.0002 March 16, 2014 -->
 <t1>
 	<row>
 		<TH>c</TH>
@@ -131,7 +131,7 @@ t1	CREATE TABLE `t1` (
 SELECT * FROM t2;
 line
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- Created by CONNECT Version 1.02.0001 February 03, 2014 -->
+<!-- Created by CONNECT Version 1.02.0002 March 16, 2014 -->
 <t1>
 	<row d="One">
 		<c>1</c>

storage/connect/mysql-test/connect/r/xml.result

@@ -413,7 +413,7 @@ DROP TABLE t1;
 SET @a=LOAD_FILE('MYSQLD_DATADIR/test/t1.xml');
 SELECT CAST(@a AS CHAR CHARACTER SET latin1);
 CAST(@a AS CHAR CHARACTER SET latin1)	<?xml version="1.0" encoding="iso-8859-1"?>
-<!-- Created by CONNECT Version 1.02.0001 February 03, 2014 -->
+<!-- Created by CONNECT Version 1.02.0002 March 16, 2014 -->
 <t1>
 	<line>
 		<node>ÀÁÂÃ</node>

storage/connect/myutil.cpp

@@ -58,12 +58,8 @@ int MYSQLtoPLG(char *typname, char *var)
     type = TYPE_ERROR;
 
   if (var) {
-    // This is to make the difference between CHAR and VARCHAR 
-    if (type == TYPE_STRING && stricmp(typname, "char"))
-      *var = 'V';
-
-    // This is to make the difference between temporal values 
     if (type == TYPE_DATE) {
+      // This is to make the difference between temporal values 
       if (!stricmp(typname, "date"))
         *var = 'D';
       else if (!stricmp(typname, "datetime"))
@@ -75,7 +71,11 @@ int MYSQLtoPLG(char *typname, char *var)
       else if (!stricmp(typname, "year"))
         *var = 'Y';
 
-      } // endif type
+    } else if (type == TYPE_STRING && stricmp(typname, "char"))
+      // This is to make the difference between CHAR and VARCHAR 
+      *var = 'V';
+    else
+      *var = 0;
 
     } // endif var
 
@@ -200,7 +200,6 @@ int MYSQLtoPLG(int mytype, char *var)
     case MYSQL_TYPE_TINY_BLOB:
     case MYSQL_TYPE_MEDIUM_BLOB:
     case MYSQL_TYPE_LONG_BLOB:
-      if (var) *var = 'V';
     case MYSQL_TYPE_STRING:
       type = TYPE_STRING;
       break;
@@ -208,6 +207,25 @@ int MYSQLtoPLG(int mytype, char *var)
       type = TYPE_ERROR;
     } // endswitch mytype
 
+  if (var) switch (mytype) {
+    // This is to make the difference between CHAR and VARCHAR 
+    case MYSQL_TYPE_VAR_STRING:
+#if !defined(ALPHA)
+    case MYSQL_TYPE_VARCHAR:
+#endif   // !ALPHA)
+    case MYSQL_TYPE_BLOB:
+    case MYSQL_TYPE_TINY_BLOB:
+    case MYSQL_TYPE_MEDIUM_BLOB:
+    case MYSQL_TYPE_LONG_BLOB: *var = 'V'; break;
+    // This is to make the difference between temporal values 
+    case MYSQL_TYPE_TIMESTAMP: *var = 'S'; break;
+    case MYSQL_TYPE_DATE:      *var = 'D'; break;
+    case MYSQL_TYPE_DATETIME:  *var = 'A'; break;
+    case MYSQL_TYPE_YEAR:      *var = 'Y'; break;
+    case MYSQL_TYPE_TIME:      *var = 'T'; break;
+    default:                   *var = 0;
+    } // endswitch mytype
+
   return type;
   } // end of MYSQLtoPLG
 

storage/connect/osutil.c

@@ -78,8 +78,8 @@ void _splitpath(LPCSTR name, LPSTR drive, LPSTR dir, LPSTR fn, LPSTR ft)
   LPCSTR p2, p = name;
 
 #ifdef DEBTRACE
- fprintf(debug,"SplitPath: name=%s [%s (%d)]\n",
-  XSTR(name), XSTR(__FILE__), __LINE__);
+ htrc("SplitPath: name=%s [%s (%d)]\n", 
+   XSTR(name), XSTR(__FILE__), __LINE__);
 #endif
 
   if (drive) *drive = '\0';
@@ -100,7 +100,7 @@ void _splitpath(LPCSTR name, LPSTR drive, LPSTR dir, LPSTR fn, LPSTR ft)
     if (fn) strcpy(fn, p);
 
 #ifdef DEBTRACE
- fprintf(debug,"SplitPath: name=%s drive=%s dir=%s filename=%s type=%s [%s(%d)]\n",
+ htrc("SplitPath: name=%s drive=%s dir=%s filename=%s type=%s [%s(%d)]\n",
   XSTR(name), XSTR(drive), XSTR(dir), XSTR(fn), XSTR(ft), __FILE__, __LINE__);
 #endif
   } /* end of _splitpath */

storage/connect/plgdbsem.h

@@ -512,6 +512,7 @@ typedef  struct _colres {
   int     Prec;                    /* Precision                        */
   int     Flag;                    /* Flag option value                */
   XFLD    Fld;                     /* Type of field info               */
+  char    Var;                     /* Type added information           */
   } COLRES;
 
 #if defined(WIN32) && !defined(NOEX)

storage/connect/plgdbutl.cpp

@@ -80,9 +80,6 @@ extern pthread_mutex_t parmut;
 #endif  // !WIN32
 #endif  //  THREAD
 
-#define PLGINI      "plugdb.ini"       /* Configuration settings file  */
-#define PLGXINI     "plgcnx.ini"       /* Configuration settings file  */
-
 /***********************************************************************/
 /*  DB static variables.                                               */
 /***********************************************************************/
@@ -90,27 +87,13 @@ bool  Initdone = false;
 bool  plugin = false;  // True when called by the XDB plugin handler 
 
 extern "C" {
-extern char  connectini[];
-       char  plgxini[_MAX_PATH] = PLGXINI;
-       char  plgini[_MAX_PATH] = PLGINI;
-#if defined(WIN32)
-       char  nmfile[_MAX_PATH] = ".\\Log\\plugdb.out";
-       char  pdebug[_MAX_PATH] = ".\\Log\\plgthread.out";
-
-       HINSTANCE s_hModule;           // Saved module handle
-#else   // !WIN32
-       char  nmfile[_MAX_PATH] = "./Log/plugdb.out";
-       char  pdebug[_MAX_PATH] = "./Log/plgthread.out";
-#endif  // !WIN32
-
 #if defined(XMSG)
        char  msglang[16] = "ENGLISH";      // Default language
 #endif
+extern int  trace;
+extern char version[];
 } // extern "C"
 
-extern "C" int  trace;
-extern "C" char version[];
-
 // The debug trace used by the main thread
        FILE *pfile = NULL;
 
@@ -219,27 +202,6 @@ int global_open(GLOBAL *g, int msgid, const char *path, int flags, int mode)
   return h;
 }
 
-
-/**************************************************************************/
-/*  Utility for external callers (such as XDB)                            */
-/**************************************************************************/
-DllExport char *GetIni(int n)
-  {
-  switch (n) {
-    case 1: return plgxini; break;
-    case 2: return nmfile;  break;
-    case 3: return pdebug;  break;
-    case 4: return version; break;
-#if defined(XMSG)
-    case 5: return msglang; break;
-#endif   // XMSG
-    case 6: return connectini; break;
-//  default: return plgini;
-    } // endswitch GetIni
-
-  return plgini;
-  } // end of GetIni
-
 DllExport void SetTrc(void)
   {
   // If tracing is on, debug must be initialized.
@@ -427,138 +389,9 @@ char *PlgGetDataPath(PGLOBAL g)
   {
   PCATLG cat = PlgGetCatalog(g, false);
 
-//if (!cat)
-//  return GetIniString(g, NULL, "DataBase", "DataPath", "", plgini);
-
   return (cat) ? cat->GetDataPath() : NULL;
   } // end of PlgGetDataPath
 
-#if 0
-/***********************************************************************/
-/*  PlgGetXdbPath: sets the fully qualified file name of a database    */
-/*  description file in lgn and the new datapath in dp.                */
-/*  New database description file is a Configuration Settings file     */
-/*  that will be used and updated in case of DB modifications such     */
-/*  as Insert into a VCT file. Look for it and use it if found.        */
-/*  By default the configuration file is DataPath\name.xdb but the     */
-/*  configuration file name may also be specified in Plugdb.ini.       */
-/***********************************************************************/
-bool PlgSetXdbPath(PGLOBAL g, PSZ dbname, PSZ dbpath,
-                              char *lgn,  int lgsize,
-                              char *path, int psize)
-  {
-  char *dp, datapath[_MAX_PATH], ft[_MAX_EXT] = ".xdb";
-  int   n;
-
-  if (path) {
-    dp = path;
-    n = psize;
-  } else {
-    dp = datapath;
-    n = sizeof(datapath);
-  } // endif path
-
-  GetPrivateProfileString("DataBase", "DataPath", "", dp, n, plgini);
-
-  if (trace)
-    htrc("PlgSetXdbPath: path=%s\n", dp);
-
-  if (dbpath) {
-    char fn[_MAX_FNAME];
-
-    strcpy(lgn, dbpath);
-    _splitpath(lgn, NULL, NULL, fn, NULL);
-
-    if (!*fn)       // Old style use command
-      strcat(lgn, dbname);
-
-    _splitpath(lgn, NULL, NULL, dbname, NULL);  // Extract DB name
-  } else if (strcspn(dbname, ":/\\.") < strlen(dbname)) {
-    // dbname name contains the path name of the XDB file
-    strcpy(lgn, dbname);
-    _splitpath(lgn, NULL, NULL, dbname, NULL);  // Extract DB name
-  } else
-    /*******************************************************************/
-    /*  New database description file is a Configuration Settings file */
-    /*  that will be used and updated in case of DB modifications such */
-    /*  as Insert into a VCT file. Look for it and use it if found.    */
-    /*  By default the configuration file is DataPath\name.xdb but the */
-    /*  configuration file name may also be specified in Plugdb.ini.   */
-    /*******************************************************************/
-    GetPrivateProfileString("DBnames", dbname, "", lgn, lgsize, plgini);
-
-  if (*lgn) {
-#if !defined(UNIX)
-    char drive[_MAX_DRIVE];
-    char direc[_MAX_DIR];
-#endif
-    char fname[_MAX_FNAME];
-    char ftype[_MAX_EXT];
-
-    _splitpath(lgn, NULL, NULL, fname, ftype);
-
-    if (!*ftype)
-      strcat(lgn, ft);
-    else if (!stricmp(ftype, ".var")) {
-      strcpy(g->Message, MSG(NO_MORE_VAR));
-      return true;
-      } // endif ftype
-
-    // Given DB description path may be relative to data path
-    PlugSetPath(lgn, lgn, dp);
-
-    // New data path is the path of the configuration setting file
-#if !defined(UNIX)
-    _splitpath(lgn, drive, direc, NULL, NULL);
-    _makepath(dp, drive, direc, "", "");
-#else
-//#error This must be tested for trailing slash
-    _splitpath(lgn, NULL, dp, NULL, NULL);
-#endif
-  } else {
-    // Try dbname[.ext] in the current directory
-    strcpy(lgn, dbname);
-
-    if (!strchr(dbname, '.'))
-      strcat(lgn, ft);
-
-    PlugSetPath(lgn, lgn, dp);
-  } // endif lgn
-
-  if (trace)
-    htrc("PlgSetXdbPath: new DB description file=%s\n", lgn);
-
-  return false;
-  } // end of PlgSetXdbPath
-#endif // 0
-
-/***********************************************************************/
-/*  Extract from a path name the required component.                   */
-/*  This function assumes there is enough space in the buffer.         */
-/***********************************************************************/
-#if 0
-char *ExtractFromPath(PGLOBAL g, char *pBuff, char *FileName, OPVAL op)
-  {
-  char *drive = NULL, *direc = NULL, *fname = NULL, *ftype = NULL;
-
-  switch (op) {           // Determine which part to extract
-#if !defined(UNIX)
-    case OP_FDISK: drive = pBuff; break;
-#endif   // !UNIX
-    case OP_FPATH: direc = pBuff; break;
-    case OP_FNAME: fname = pBuff; break;
-    case OP_FTYPE: ftype = pBuff; break;
-    default:
-      sprintf(g->Message, MSG(INVALID_OPER), op, "ExtractFromPath");
-      return NULL;
-    } // endswitch op
-
-  // Now do the extraction
-  _splitpath(FileName, drive, direc, fname, ftype);
-  return pBuff;
-  } // end of PlgExtractFromPath
-#endif
-
 /***********************************************************************/
 /*  Check the occurence and matching of a pattern against a string.    */
 /*  Because this function is only used for catalog name checking,      */
@@ -1468,19 +1301,17 @@ void *PlgDBSubAlloc(PGLOBAL g, void *memp, size_t size)
   size = ((size + 7) / 8) * 8;       /* Round up size to multiple of 8 */
   pph = (PPOOLHEADER)memp;
 
-#if defined(DEBTRACE)
- htrc("PlgDBSubAlloc: memp=%p size=%d used=%d free=%d\n",
-  memp, size, pph->To_Free, pph->FreeBlk);
-#endif
+  if (trace > 1)
+    htrc("PlgDBSubAlloc: memp=%p size=%d used=%d free=%d\n",
+         memp, size, pph->To_Free, pph->FreeBlk);
 
   if ((uint)size > pph->FreeBlk) {   /* Not enough memory left in pool */
     sprintf(g->Message,
     "Not enough memory in Work area for request of %d (used=%d free=%d)",
             (int) size, pph->To_Free, pph->FreeBlk);
 
-#if defined(DEBTRACE)
- htrc("%s\n", g->Message);
-#endif
+    if (trace)
+      htrc("%s\n", g->Message);
 
     return NULL;
     } // endif size
@@ -1491,10 +1322,11 @@ void *PlgDBSubAlloc(PGLOBAL g, void *memp, size_t size)
   memp = MakePtr(memp, pph->To_Free);   // Points to suballocated block
   pph->To_Free += size;                 // New offset of pool free block
   pph->FreeBlk -= size;                 // New size   of pool free block
-#if defined(DEBTRACE)
- htrc("Done memp=%p used=%d free=%d\n",
-  memp, pph->To_Free, pph->FreeBlk);
-#endif
+
+  if (trace > 1)
+    htrc("Done memp=%p used=%d free=%d\n",
+         memp, pph->To_Free, pph->FreeBlk);
+
   return (memp);
   } // end of PlgDBSubAlloc
 

storage/connect/plugutil.c

@@ -37,8 +37,6 @@
 /*    IBM Linker                                                       */
 /*                                                                     */
 /***********************************************************************/
-//efine DEBTRACE 3
-//efine DEBTRACE2
 
 /***********************************************************************/
 /*                                                                     */
@@ -83,7 +81,6 @@
 extern HINSTANCE s_hModule;                   /* Saved module handle    */
 #endif   // WIN32
 
-extern char plgini[];
 extern int  trace;
 
 #if defined(XMSG)

storage/connect/reldef.cpp

@@ -47,10 +47,6 @@
 #include "valblk.h"
 #include "tabmul.h"
 
-/***********************************************************************/
-/*  External static variables.                                         */
-/***********************************************************************/
-//extern "C" char      plgini[];
 
 /* --------------------------- Class RELDEF -------------------------- */
 

storage/connect/tabcol.cpp

@@ -22,6 +22,8 @@
 #include "xtable.h"
 #include "tabcol.h"
 
+extern "C" int  trace;
+
 /***********************************************************************/
 /*  XTAB public constructor.                                           */
 /***********************************************************************/
@@ -33,9 +35,9 @@ XTAB::XTAB(LPCSTR name, LPCSTR srcdef) : Name(name)
   Schema = NULL;
   Qualifier = NULL;
 
-#ifdef DEBTRACE
- htrc(" making new TABLE %s %s\n", Name, Srcdef);
-#endif
+  if (trace)
+    htrc("XTAB: making new TABLE %s %s\n", Name, Srcdef);
+
   } // end of XTAB constructor
 
 /***********************************************************************/
@@ -49,9 +51,9 @@ XTAB::XTAB(PTABLE tp) : Name(tp->Name)
   Schema = tp->Schema;
   Qualifier = tp->Qualifier;
 
-#ifdef DEBTRACE
- htrc(" making copy TABLE %s %s\n", Name, Srcdef);
-#endif
+  if (trace)
+    htrc(" making copy TABLE %s %s\n", Name, Srcdef);
+
   } // end of XTAB constructor
 
 /***********************************************************************/
@@ -61,9 +63,8 @@ PTABLE XTAB::Link(PTABLE tab2)
   {
   PTABLE tabp;
 
-#ifdef DEBTRACE
- htrc("Linking tables %s... to %s\n", Name, tab2->Name);
-#endif
+  if (trace)
+    htrc("Linking tables %s... to %s\n", Name, tab2->Name);
 
   for (tabp = this; tabp->Next; tabp = tabp->Next) ;
 
@@ -118,9 +119,9 @@ COLUMN::COLUMN(LPCSTR name) : Name(name)
   To_Col = NULL;
   Qualifier = NULL;
 
-#ifdef DEBTRACE
- htrc(" making new COLUMN %s\n", Name);
-#endif
+  if (trace)
+    htrc(" making new COLUMN %s\n", Name);
+
   } // end of COLUMN constructor
 
 /***********************************************************************/

storage/connect/tabfmt.cpp

@@ -1333,7 +1333,7 @@ void CSVCOL::ReadColumn(PGLOBAL g)
 /***********************************************************************/
 void CSVCOL::WriteColumn(PGLOBAL g)
   {
-  char   *p, buf[32];
+  char   *p, buf[64];
   int     flen;
   PTDBCSV tdbp = (PTDBCSV)To_Tdb;
 

storage/connect/tabmysql.cpp

@@ -1034,7 +1034,7 @@ int TDBMYSQL::WriteDB(PGLOBAL g)
   // Statement was not prepared, we must construct and execute
   // an insert query for each line to insert
   int  rc;
-  char buf[32];
+  char buf[64];
 
   strcpy(Qbuf, Query);
 

storage/connect/tabodbc.cpp

@@ -1066,7 +1066,7 @@ void ODBCCOL::ReadColumn(PGLOBAL g)
   } // endif Buf_Type
 
   if (g->Trace) {
-    char buf[32];
+    char buf[64];
 
     htrc("ODBC Column %s: rows=%d buf=%p type=%d value=%s\n",
       Name, tdbp->Rows, Bufp, Buf_Type, Value->GetCharString(buf));

storage/connect/tabpivot.cpp

@@ -95,7 +95,7 @@ PIVAID::PIVAID(const char *tab,   const char *src,  const char *picol,
 /***********************************************************************/
 PQRYRES PIVAID::MakePivotColumns(PGLOBAL g)
   {
-  char    *query, *colname, buf[32];
+  char    *query, *colname, buf[64];
   int      ndif, nblin, w = 0;
   PVAL     valp;
   PCOLRES *pcrp, crp, fncrp = NULL;
@@ -121,7 +121,7 @@ PQRYRES PIVAID::MakePivotColumns(PGLOBAL g)
     } // endif Exec
 
   // We must have a storage query to get pivot column values
-  Qryp = Myc.GetResult(g);
+  Qryp = Myc.GetResult(g, true);
   Myc.Close();
 
   if (!Fncol) {

storage/connect/tabvct.cpp

@@ -76,6 +76,8 @@
 char *strerror(int num);
 #endif   // UNIX
 
+extern "C" int  trace;
+
 /***********************************************************************/
 /*  Char VCT column blocks are right filled with blanks (blank = true) */
 /*  Conversion of block values allowed conditionally for insert only.  */
@@ -287,10 +289,9 @@ PCOL TDBVCT::MakeCol(PGLOBAL g, PCOLDEF cdp, PCOL cprec, int n)
 /***********************************************************************/
 bool TDBVCT::OpenDB(PGLOBAL g)
   {
-#ifdef DEBTRACE
- htrc("VCT OpenDB: tdbp=%p tdb=R%d use=%d key=%p mode=%d\n",
-  this, Tdb_No, Use, To_Key_Col, Mode);
-#endif
+  if (trace)
+    htrc("VCT OpenDB: tdbp=%p tdb=R%d use=%d key=%p mode=%d\n",
+         this, Tdb_No, Use, To_Key_Col, Mode);
 
   if (Use == USE_OPEN) {
     /*******************************************************************/
@@ -338,12 +339,10 @@ bool TDBVCT::OpenDB(PGLOBAL g)
 /***********************************************************************/
 int TDBVCT::ReadDB(PGLOBAL g)
   {
-#ifdef DEBTRACE
- fprintf(debug,
-  "VCT ReadDB: R%d Mode=%d CurBlk=%d CurNum=%d key=%p link=%p Kindex=%p\n",
-  GetTdb_No(), Mode, Txfp->CurBlk, Txfp->CurNum,
-  To_Key_Col, To_Link, To_Kindex);
-#endif
+  if (trace)
+    htrc("VCT ReadDB: R%d Mode=%d CurBlk=%d CurNum=%d key=%p link=%p Kindex=%p\n",
+         GetTdb_No(), Mode, Txfp->CurBlk, Txfp->CurNum,
+         To_Key_Col, To_Link, To_Kindex);
 
   if (To_Kindex) {
     /*******************************************************************/
@@ -518,15 +517,13 @@ void VCTCOL::ReadColumn(PGLOBAL g)
   {
   PTXF txfp = ((PTDBVCT)To_Tdb)->Txfp;
 
-#if defined(_DEBUG) || defined(DEBTRACE)
+#if defined(_DEBUG)
   assert (!To_Kcol);
 #endif
 
-#ifdef DEBTRACE
- fprintf(debug,
-   "VCT ReadColumn: col %s R%d coluse=%.4X status=%.4X buf_type=%d\n",
-  Name, To_Tdb->GetTdb_No(), ColUse, Status, Buf_Type);
-#endif
+  if (trace > 1)
+    htrc("VCT ReadColumn: col %s R%d coluse=%.4X status=%.4X buf_type=%d\n",
+         Name, To_Tdb->GetTdb_No(), ColUse, Status, Buf_Type);
 
   if (ColBlk != txfp->CurBlk)
     ReadBlock(g);
@@ -552,11 +549,9 @@ void VCTCOL::WriteColumn(PGLOBAL g)
   {
   PTXF txfp = ((PTDBVCT)To_Tdb)->Txfp;;
 
-#ifdef DEBTRACE
- fprintf(debug,
-   "VCT WriteColumn: col %s R%d coluse=%.4X status=%.4X buf_type=%d\n",
-  Name, To_Tdb->GetTdb_No(), ColUse, Status, Buf_Type);
-#endif
+  if (trace > 1)
+    htrc("VCT WriteColumn: col %s R%d coluse=%.4X status=%.4X buf_type=%d\n",
+         Name, To_Tdb->GetTdb_No(), ColUse, Status, Buf_Type);
 
   ColBlk = txfp->CurBlk;
   ColPos = txfp->CurNum;

storage/connect/user_connect.cc

@@ -47,8 +47,7 @@
 #include "user_connect.h"
 #include "mycat.h"
 
-extern "C" char  plgxini[];
-extern int xtrace;
+extern "C" int trace;
 
 /****************************************************************************/
 /*  Initialize the user_connect static member.                              */
@@ -149,7 +148,7 @@ bool user_connect::CheckCleanup(void)
     g->Alchecked = 0;
     last_query_id= thdp->query_id;
 
-    if (xtrace)
+    if (trace)
       printf("=====> Begin new query %llu\n", last_query_id);
 
     return true;

storage/connect/valblk.cpp

@@ -43,6 +43,8 @@
 #define CheckBlanks      assert(!Blanks);
 #define CheckParms(V, N) ChkIndx(N); ChkTyp(V);
 
+extern "C" int  trace;
+
 /***********************************************************************/
 /*  AllocValBlock: allocate a VALBLK according to type.                */
 /***********************************************************************/
@@ -51,10 +53,9 @@ PVBLK AllocValBlock(PGLOBAL g, void *mp, int type, int nval, int len,
   {
   PVBLK blkp;
 
-#ifdef DEBTRACE
- htrc("AVB: mp=%p type=%d nval=%d len=%d check=%u blank=%u\n",
-  mp, type, nval, len, check, blank);
-#endif
+  if (trace)
+    htrc("AVB: mp=%p type=%d nval=%d len=%d check=%u blank=%u\n",
+         mp, type, nval, len, check, blank);
 
   switch (type) {
     case TYPE_STRING:
@@ -546,7 +547,7 @@ int TYPBLK<TYPE>::Find(PVAL vp)
 template <class TYPE>
 int TYPBLK<TYPE>::GetMaxLength(void)
   {
-  char buf[32];
+  char buf[64];
   int i, n, m;
 
   for (i = n = 0; i < Nval; i++) {
@@ -737,13 +738,13 @@ void CHRBLK::SetValue(char *sp, uint len, int n)
   {
   char  *p = Chrp + n * Long;
 
-#if defined(_DEBUG) || defined(DEBTRACE)
+#if defined(_DEBUG)
   if (Check && (signed)len > Long) {
     PGLOBAL& g = Global;
     strcpy(g->Message, MSG(SET_STR_TRUNC));
     longjmp(g->jumper[g->jump_level], Type);
     } // endif Check
-#endif
+#endif   // _DEBUG
 
   if (sp)
     memcpy(p, sp, min((unsigned)Long, len));
@@ -786,13 +787,13 @@ void CHRBLK::SetValue(PVBLK pv, int n1, int n2)
 /***********************************************************************/
 void CHRBLK::SetValues(PVBLK pv, int k, int n)
   {
-#if defined(_DEBUG) || defined(DEBTRACE)
+#if defined(_DEBUG)
   if (Type != pv->GetType() || Long != ((CHRBLK*)pv)->Long) {
     PGLOBAL& g = Global;
     strcpy(g->Message, MSG(BLKTYPLEN_MISM));
     longjmp(g->jumper[g->jump_level], Type);
     } // endif Type
-#endif
+#endif   // _DEBUG
   char *p = ((CHRBLK*)pv)->Chrp;
 
   if (!k)

storage/connect/value.cpp

@@ -555,7 +555,7 @@ template <>
 bool TYPVAL<double>::SetValue_char(char *p, int n)
   {
   if (p) {
-    char buf[32];
+    char buf[64];
 
     for (; n > 0 && *p == ' '; p++) 
       n--;
@@ -957,7 +957,7 @@ bool TYPVAL<PSZ>::SetValue_pval(PVAL valp, bool chktype)
   if (chktype && (valp->GetType() != Type || valp->GetSize() > Len))
     return true;
 
-  char buf[32];
+  char buf[64];
 
   if (!(Null = valp->IsNull() && Nullable))
     strncpy(Strp, valp->GetCharString(buf), Len);
@@ -1126,7 +1126,7 @@ void TYPVAL<PSZ>::SetValue(ulonglong n)
 /***********************************************************************/
 void TYPVAL<PSZ>::SetValue(double f)
   {
-  char    *p, buf[32];
+  char    *p, buf[64];
   PGLOBAL& g = Global;
   int      k = sprintf(buf, "%lf", f);
 
@@ -1220,7 +1220,7 @@ bool TYPVAL<PSZ>::IsEqual(PVAL vp, bool chktype)
   else if (Null || vp->IsNull())
     return false;
 
-  char buf[32];
+  char buf[64];
 
   if (Ci || vp->IsCi())
     return !stricmp(Strp, vp->GetCharString(buf));
@@ -1351,7 +1351,7 @@ bool DECVAL::SetValue_pval(PVAL valp, bool chktype)
   if (chktype && (valp->GetType() != Type || valp->GetSize() > Len))
     return true;
 
-  char buf[32];
+  char buf[64];
 
   if (!(Null = valp->IsNull() && Nullable))
     strncpy(Strp, valp->GetCharString(buf), Len);
@@ -1450,7 +1450,7 @@ bool DECVAL::IsEqual(PVAL vp, bool chktype)
   else if (Null || vp->IsNull())
     return false;
 
-  char buf[32];
+  char buf[64];
 
   return !strcmp(Strp, vp->GetCharString(buf));
   } // end of IsEqual

storage/connect/xindex.cpp

@@ -60,6 +60,7 @@
 /*  DB static external variables.                                      */
 /***********************************************************************/
 extern MBLOCK Nmblk;                /* Used to initialize MBLOCK's     */
+extern "C" int  trace;
 
 /***********************************************************************/
 /*  Last two parameters are true to enable type checking, and last one */
@@ -267,10 +268,7 @@ int XINDEX::Qcompare(int *i1, int *i2)
     if ((k = kcp->Compare(*i1, *i2)))
       break;
 
-#ifdef DEBTRACE
-  num_comp++;
-#endif
-
+//num_comp++;
   return k;
   } // end of Qcompare
 
@@ -1801,10 +1799,7 @@ XINDXS::XINDXS(PTDBDOS tdbp, PIXDEF xdp, PXLOAD pxp, PCOL *cp, PXOB *xp)
 /***********************************************************************/
 int XINDXS::Qcompare(int *i1, int *i2)
   {
-#ifdef DEBTRACE
-  num_comp++;
-#endif
-
+//num_comp++;
   return To_KeyCol->Compare(*i1, *i2);
   } // end of Qcompare
 
@@ -2320,11 +2315,9 @@ bool XHUGE::Open(PGLOBAL g, char *filename, int id, MODE mode)
     return true;
     } // endif Hfile
 
-#ifdef DEBTRACE
- fprintf(debug,
- " access=%p share=%p creation=%d handle=%p fn=%s\n",
-  access, share, creation, Hfile, filename);
-#endif
+  if (trace)
+    htrc(" access=%p share=%p creation=%d handle=%p fn=%s\n",
+         access, share, creation, Hfile, filename);
 
   if (mode == MODE_INSERT) {
     /*******************************************************************/
@@ -2767,10 +2760,9 @@ bool KXYCOL::Init(PGLOBAL g, PCOL colp, int n, bool sm, int kln)
     Prefix = true;
     } // endif kln
 
-#ifdef DEBTRACE
- htrc("KCOL(%p) Init: col=%s n=%d type=%d sm=%d\n",
-  this, colp->GetName(), n, colp->GetResultType(), sm);
-#endif
+  if (trace)
+    htrc("KCOL(%p) Init: col=%s n=%d type=%d sm=%d\n",
+         this, colp->GetName(), n, colp->GetResultType(), sm);
 
   // Allocate the Value object used when moving items
   Type = colp->GetResultType();
@@ -2822,10 +2814,9 @@ BYTE* KXYCOL::MapInit(PGLOBAL g, PCOL colp, int *n, BYTE *m)
 
   Type = colp->GetResultType();
 
-#ifdef DEBTRACE
- htrc("MapInit(%p): colp=%p type=%d n=%d len=%d m=%p\n",
-  this, colp, Type, n[0], len, m);
-#endif
+ if (trace)
+   htrc("MapInit(%p): colp=%p type=%d n=%d len=%d m=%p\n",
+        this, colp, Type, n[0], len, m);
 
   // Allocate the Value object used when moving items
   Valp = AllocateValue(g, Type, len, prec, false, NULL);