Commit 6b63c5b2 authored by Olivier Bertrand's avatar Olivier Bertrand

- 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
parent e5729127
...@@ -38,10 +38,9 @@ typedef class BLOCK *PBLOCK; ...@@ -38,10 +38,9 @@ typedef class BLOCK *PBLOCK;
class DllExport BLOCK { class DllExport BLOCK {
public: public:
void * operator new(size_t size, PGLOBAL g, void *p = NULL) { void * operator new(size_t size, PGLOBAL g, void *p = NULL) {
#ifdef DEBTRACE // if (trace > 2)
if (debug != NULL) // htrc("New BLOCK: size=%d g=%p p=%p\n", size, g, p);
htrc("New BLOCK: size=%d g=%p p=%p\n", size, g, p);
#endif
return (PlugSubAlloc(g, p, size)); return (PlugSubAlloc(g, p, size));
} // end of new } // end of new
......
...@@ -23,6 +23,8 @@ ...@@ -23,6 +23,8 @@
#include "xindex.h" #include "xindex.h"
#include "xtable.h" #include "xtable.h"
extern "C" int trace;
/***********************************************************************/ /***********************************************************************/
/* COLBLK protected constructor. */ /* COLBLK protected constructor. */
/***********************************************************************/ /***********************************************************************/
...@@ -72,9 +74,8 @@ COLBLK::COLBLK(PCOL col1, PTDB tdbp) ...@@ -72,9 +74,8 @@ COLBLK::COLBLK(PCOL col1, PTDB tdbp)
//To_Orig = col1; //To_Orig = col1;
To_Tdb = tdbp; To_Tdb = tdbp;
#ifdef DEBTRACE if (trace > 1)
htrc(" copying COLBLK %s from %p to %p\n", Name, col1, this); htrc(" copying COLBLK %s from %p to %p\n", Name, col1, this);
#endif
if (tdbp) if (tdbp)
// Attach the new column to the table block // Attach the new column to the table block
...@@ -112,10 +113,9 @@ bool COLBLK::SetFormat(PGLOBAL g, FORMAT& fmt) ...@@ -112,10 +113,9 @@ bool COLBLK::SetFormat(PGLOBAL g, FORMAT& fmt)
{ {
fmt = Format; fmt = Format;
#ifdef DEBTRACE if (trace > 1)
htrc("COLBLK: %p format=%c(%d,%d)\n", htrc("COLBLK: %p format=%c(%d,%d)\n",
this, *fmt.Type, fmt.Length, fmt.Prec); this, *fmt.Type, fmt.Length, fmt.Prec);
#endif
return false; return false;
} // end of SetFormat } // end of SetFormat
...@@ -126,9 +126,8 @@ bool COLBLK::SetFormat(PGLOBAL g, FORMAT& fmt) ...@@ -126,9 +126,8 @@ bool COLBLK::SetFormat(PGLOBAL g, FORMAT& fmt)
/***********************************************************************/ /***********************************************************************/
bool COLBLK::Eval(PGLOBAL g) bool COLBLK::Eval(PGLOBAL g)
{ {
#ifdef DEBTRACE if (trace > 1)
htrc("Col Eval: %s status=%.4X\n", Name, Status); htrc("Col Eval: %s status=%.4X\n", Name, Status);
#endif
if (!GetStatus(BUF_READ)) { if (!GetStatus(BUF_READ)) {
// if (To_Tdb->IsNull()) // if (To_Tdb->IsNull())
...@@ -164,10 +163,9 @@ bool COLBLK::InitValue(PGLOBAL g) ...@@ -164,10 +163,9 @@ bool COLBLK::InitValue(PGLOBAL g)
AddStatus(BUF_READY); AddStatus(BUF_READY);
Value->SetNullable(Nullable); Value->SetNullable(Nullable);
#ifdef DEBTRACE if (trace > 1)
htrc(" colp=%p type=%d value=%p coluse=%.4X status=%.4X\n", htrc(" colp=%p type=%d value=%p coluse=%.4X status=%.4X\n",
this, Buf_Type, Value, ColUse, Status); this, Buf_Type, Value, ColUse, Status);
#endif
return false; return false;
} // end of InitValue } // end of InitValue
......
...@@ -51,7 +51,7 @@ ...@@ -51,7 +51,7 @@
/***********************************************************************/ /***********************************************************************/
/* DB static variables. */ /* DB static variables. */
/***********************************************************************/ /***********************************************************************/
extern int xtrace; extern "C" int trace;
/***********************************************************************/ /***********************************************************************/
/* Routines called internally by semantic routines. */ /* Routines called internally by semantic routines. */
...@@ -110,14 +110,14 @@ bool CntCheckDB(PGLOBAL g, PHC handler, const char *pathname) ...@@ -110,14 +110,14 @@ bool CntCheckDB(PGLOBAL g, PHC handler, const char *pathname)
bool rc= false; bool rc= false;
PDBUSER dbuserp= PlgGetUser(g); PDBUSER dbuserp= PlgGetUser(g);
if (xtrace) { if (trace) {
printf("CntCheckDB: dbuserp=%p\n", dbuserp); printf("CntCheckDB: dbuserp=%p\n", dbuserp);
} // endif xtrace } // endif trace
if (!dbuserp || !handler) if (!dbuserp || !handler)
return true; return true;
if (xtrace) if (trace)
printf("cat=%p oldhandler=%p newhandler=%p\n", dbuserp->Catalog, printf("cat=%p oldhandler=%p newhandler=%p\n", dbuserp->Catalog,
(dbuserp->Catalog) ? ((MYCAT*)dbuserp->Catalog)->GetHandler() : NULL, (dbuserp->Catalog) ? ((MYCAT*)dbuserp->Catalog)->GetHandler() : NULL,
handler); handler);
...@@ -149,7 +149,7 @@ bool CntCheckDB(PGLOBAL g, PHC handler, const char *pathname) ...@@ -149,7 +149,7 @@ bool CntCheckDB(PGLOBAL g, PHC handler, const char *pathname)
/*********************************************************************/ /*********************************************************************/
sprintf(g->Message, MSG(DATABASE_LOADED), "???"); sprintf(g->Message, MSG(DATABASE_LOADED), "???");
if (xtrace) if (trace)
printf("msg=%s\n", g->Message); printf("msg=%s\n", g->Message);
return rc; return rc;
...@@ -193,7 +193,7 @@ PTDB CntGetTDB(PGLOBAL g, LPCSTR name, MODE mode, PHC h) ...@@ -193,7 +193,7 @@ PTDB CntGetTDB(PGLOBAL g, LPCSTR name, MODE mode, PHC h)
PDBUSER dup= PlgGetUser(g); PDBUSER dup= PlgGetUser(g);
PCATLG cat= (dup) ? dup->Catalog : NULL; // Safe over longjmp 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); printf("CntGetTDB: name=%s mode=%d cat=%p\n", name, mode, cat);
if (!cat) if (!cat)
...@@ -213,7 +213,7 @@ PTDB CntGetTDB(PGLOBAL g, LPCSTR name, MODE mode, PHC h) ...@@ -213,7 +213,7 @@ PTDB CntGetTDB(PGLOBAL g, LPCSTR name, MODE mode, PHC h)
// Get table object from the catalog // Get table object from the catalog
tabp= new(g) XTAB(name); tabp= new(g) XTAB(name);
if (xtrace) if (trace)
printf("CntGetTDB: tabp=%p\n", tabp); printf("CntGetTDB: tabp=%p\n", tabp);
// Perhaps this should be made thread safe // Perhaps this should be made thread safe
...@@ -223,7 +223,7 @@ PTDB CntGetTDB(PGLOBAL g, LPCSTR name, MODE mode, PHC h) ...@@ -223,7 +223,7 @@ PTDB CntGetTDB(PGLOBAL g, LPCSTR name, MODE mode, PHC h)
printf("CntGetTDB: %s\n", g->Message); printf("CntGetTDB: %s\n", g->Message);
err: err:
if (xtrace) if (trace)
printf("Returning tdbp=%p mode=%d\n", tdbp, mode); printf("Returning tdbp=%p mode=%d\n", tdbp, mode);
g->jump_level--; g->jump_level--;
...@@ -243,7 +243,7 @@ bool CntOpenTable(PGLOBAL g, PTDB tdbp, MODE mode, char *c1, char *c2, ...@@ -243,7 +243,7 @@ bool CntOpenTable(PGLOBAL g, PTDB tdbp, MODE mode, char *c1, char *c2,
//PCOLUMN cp; //PCOLUMN cp;
PDBUSER dup= PlgGetUser(g); PDBUSER dup= PlgGetUser(g);
if (xtrace) if (trace)
printf("CntOpenTable: tdbp=%p mode=%d\n", tdbp, mode); printf("CntOpenTable: tdbp=%p mode=%d\n", tdbp, mode);
if (!tdbp) { if (!tdbp) {
...@@ -269,7 +269,7 @@ bool CntOpenTable(PGLOBAL g, PTDB tdbp, MODE mode, char *c1, char *c2, ...@@ -269,7 +269,7 @@ bool CntOpenTable(PGLOBAL g, PTDB tdbp, MODE mode, char *c1, char *c2,
} else for (p= c1; *p; p+= n) { } else for (p= c1; *p; p+= n) {
// Allocate only used column blocks // Allocate only used column blocks
if (xtrace) if (trace)
printf("Allocating column %s\n", p); printf("Allocating column %s\n", p);
// if (*p == '*') { // if (*p == '*') {
...@@ -337,7 +337,7 @@ bool CntOpenTable(PGLOBAL g, PTDB tdbp, MODE mode, char *c1, char *c2, ...@@ -337,7 +337,7 @@ bool CntOpenTable(PGLOBAL g, PTDB tdbp, MODE mode, char *c1, char *c2,
((PTDBASE)tdbp)->SetSetCols(tdbp->GetColumns()); ((PTDBASE)tdbp)->SetSetCols(tdbp->GetColumns());
// Now do open the physical table // Now do open the physical table
if (xtrace) if (trace)
printf("Opening table %s in mode %d tdbp=%p\n", printf("Opening table %s in mode %d tdbp=%p\n",
tdbp->GetName(), mode, tdbp); tdbp->GetName(), mode, tdbp);
...@@ -353,7 +353,7 @@ bool CntOpenTable(PGLOBAL g, PTDB tdbp, MODE mode, char *c1, char *c2, ...@@ -353,7 +353,7 @@ bool CntOpenTable(PGLOBAL g, PTDB tdbp, MODE mode, char *c1, char *c2,
} // endif del } // endif del
if (xtrace) if (trace)
printf("About to open the table: tdbp=%p\n", tdbp); printf("About to open the table: tdbp=%p\n", tdbp);
if (mode != MODE_ANY && mode != MODE_ALTER) { if (mode != MODE_ANY && mode != MODE_ALTER) {
...@@ -394,7 +394,7 @@ RCODE EvalColumns(PGLOBAL g, PTDB tdbp, bool mrr) ...@@ -394,7 +394,7 @@ RCODE EvalColumns(PGLOBAL g, PTDB tdbp, bool mrr)
// Save stack and allocation environment and prepare error return // Save stack and allocation environment and prepare error return
if (g->jump_level == MAX_JUMP) { if (g->jump_level == MAX_JUMP) {
if (xtrace) { if (trace) {
strcpy(g->Message, MSG(TOO_MANY_JUMPS)); strcpy(g->Message, MSG(TOO_MANY_JUMPS));
printf("EvalColumns: %s\n", g->Message); printf("EvalColumns: %s\n", g->Message);
} // endif } // endif
...@@ -403,7 +403,7 @@ RCODE EvalColumns(PGLOBAL g, PTDB tdbp, bool mrr) ...@@ -403,7 +403,7 @@ RCODE EvalColumns(PGLOBAL g, PTDB tdbp, bool mrr)
} // endif jump_level } // endif jump_level
if (setjmp(g->jumper[++g->jump_level]) != 0) { if (setjmp(g->jumper[++g->jump_level]) != 0) {
if (xtrace) if (trace)
printf("Error reading columns: %s\n", g->Message); printf("Error reading columns: %s\n", g->Message);
rc= RC_FX; rc= RC_FX;
...@@ -547,7 +547,7 @@ int CntCloseTable(PGLOBAL g, PTDB tdbp) ...@@ -547,7 +547,7 @@ int CntCloseTable(PGLOBAL g, PTDB tdbp)
if (!tdbp || tdbp->GetUse() != USE_OPEN) if (!tdbp || tdbp->GetUse() != USE_OPEN)
return rc; // Nothing to do return rc; // Nothing to do
if (xtrace) if (trace)
printf("CntCloseTable: tdbp=%p mode=%d\n", tdbp, tdbp->GetMode()); printf("CntCloseTable: tdbp=%p mode=%d\n", tdbp, tdbp->GetMode());
if (tdbp->GetMode() == MODE_DELETE && tdbp->GetUse() == USE_OPEN) if (tdbp->GetMode() == MODE_DELETE && tdbp->GetUse() == USE_OPEN)
...@@ -571,7 +571,7 @@ int CntCloseTable(PGLOBAL g, PTDB tdbp) ...@@ -571,7 +571,7 @@ int CntCloseTable(PGLOBAL g, PTDB tdbp)
g->jump_level--; g->jump_level--;
if (xtrace > 1) if (trace > 1)
printf("Table %s closed\n", tdbp->GetName()); printf("Table %s closed\n", tdbp->GetName());
//if (!((PTDBDOX)tdbp)->GetModified()) //if (!((PTDBDOX)tdbp)->GetModified())
...@@ -580,7 +580,7 @@ int CntCloseTable(PGLOBAL g, PTDB tdbp) ...@@ -580,7 +580,7 @@ int CntCloseTable(PGLOBAL g, PTDB tdbp)
if (tdbp->GetMode() == MODE_READ || tdbp->GetMode() == MODE_ANY) if (tdbp->GetMode() == MODE_READ || tdbp->GetMode() == MODE_ANY)
return 0; return 0;
if (xtrace > 1) if (trace > 1)
printf("About to reset indexes\n"); printf("About to reset indexes\n");
// Make all the eventual indexes // Make all the eventual indexes
...@@ -590,7 +590,7 @@ int CntCloseTable(PGLOBAL g, PTDB tdbp) ...@@ -590,7 +590,7 @@ int CntCloseTable(PGLOBAL g, PTDB tdbp)
rc= tbxp->ResetTableOpt(g, ((PTDBASE)tdbp)->GetDef()->Indexable()); rc= tbxp->ResetTableOpt(g, ((PTDBASE)tdbp)->GetDef()->Indexable());
err: err:
if (xtrace > 1) if (trace > 1)
printf("Done rc=%d\n", rc); printf("Done rc=%d\n", rc);
return (rc == RC_OK || rc == RC_INFO) ? 0 : 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, ...@@ -859,10 +859,10 @@ int CntIndexRange(PGLOBAL g, PTDB ptdb, const uchar* *key, uint *len,
} else } else
valp->SetBinValue((void*)p); valp->SetBinValue((void*)p);
if (xtrace) { if (trace) {
char bf[32]; char bf[32];
printf("i=%d n=%d key=%s\n", i, n, valp->GetCharString(bf)); printf("i=%d n=%d key=%s\n", i, n, valp->GetCharString(bf));
} // endif xtrace } // endif trace
p+= valp->GetClen(); p+= valp->GetClen();
...@@ -881,7 +881,7 @@ int CntIndexRange(PGLOBAL g, PTDB ptdb, const uchar* *key, uint *len, ...@@ -881,7 +881,7 @@ int CntIndexRange(PGLOBAL g, PTDB ptdb, const uchar* *key, uint *len,
xbp->SetNval(n); xbp->SetNval(n);
if (xtrace) if (trace)
printf("xbp=%p Nval=%d i=%d incl=%d\n", xbp, n, i, incl[i]); printf("xbp=%p Nval=%d i=%d incl=%d\n", xbp, n, i, incl[i]);
k[i]= xbp->Range(g, i + 1, 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, ...@@ -890,7 +890,7 @@ int CntIndexRange(PGLOBAL g, PTDB ptdb, const uchar* *key, uint *len,
} // endfor i } // endfor i
if (xtrace) if (trace)
printf("k1=%d k0=%d\n", k[1], k[0]); printf("k1=%d k0=%d\n", k[1], k[0]);
return k[1] - k[0]; return k[1] - k[0];
......
...@@ -22,9 +22,7 @@ ...@@ -22,9 +22,7 @@
#define THRESH 4 /* Threshold for insertion (was 4) */ #define THRESH 4 /* Threshold for insertion (was 4) */
#define MTHRESH 6 /* Threshold for median */ #define MTHRESH 6 /* Threshold for median */
#ifdef DEBTRACE //extern FILE *debug; /* Debug file */
extern FILE *debug; /* Debug file */
#endif
typedef int* const CPINT; typedef int* const CPINT;
......
...@@ -46,6 +46,8 @@ ...@@ -46,6 +46,8 @@
#include "filamap.h" #include "filamap.h"
#include "tabdos.h" #include "tabdos.h"
extern "C" int trace;
/* --------------------------- Class MAPFAM -------------------------- */ /* --------------------------- Class MAPFAM -------------------------- */
/***********************************************************************/ /***********************************************************************/
...@@ -89,9 +91,8 @@ int MAPFAM::GetFileLength(PGLOBAL g) ...@@ -89,9 +91,8 @@ int MAPFAM::GetFileLength(PGLOBAL g)
len = (To_Fb) ? To_Fb->Length : TXTFAM::GetFileLength(g); len = (To_Fb) ? To_Fb->Length : TXTFAM::GetFileLength(g);
#ifdef DEBTRACE if (trace)
htrc("Mapped file length=%d\n", len); htrc("Mapped file length=%d\n", len);
#endif
return len; return len;
} // end of GetFileLength } // end of GetFileLength
...@@ -128,9 +129,9 @@ bool MAPFAM::OpenTableFile(PGLOBAL g) ...@@ -128,9 +129,9 @@ bool MAPFAM::OpenTableFile(PGLOBAL g)
&& fp->Count && fp->Mode == mode) && fp->Count && fp->Mode == mode)
break; break;
#ifdef DEBTRACE if (trace)
htrc("Mapping file, fp=%p\n", fp); htrc("Mapping file, fp=%p\n", fp);
#endif
} else } else
fp = NULL; fp = NULL;
...@@ -166,9 +167,9 @@ bool MAPFAM::OpenTableFile(PGLOBAL g) ...@@ -166,9 +167,9 @@ bool MAPFAM::OpenTableFile(PGLOBAL g)
sprintf(g->Message, MSG(OPEN_MODE_ERROR), sprintf(g->Message, MSG(OPEN_MODE_ERROR),
"map", (int) rc, filename); "map", (int) rc, filename);
#ifdef DEBTRACE if (trace)
htrc("%s\n", g->Message); htrc("CreateFileMap: %s\n", g->Message);
#endif
return (mode == MODE_READ && rc == ENOENT) return (mode == MODE_READ && rc == ENOENT)
? PushWarning(g, Tdbp) : true; ? PushWarning(g, Tdbp) : true;
} // endif hFile } // endif hFile
...@@ -228,10 +229,9 @@ bool MAPFAM::OpenTableFile(PGLOBAL g) ...@@ -228,10 +229,9 @@ bool MAPFAM::OpenTableFile(PGLOBAL g)
Fpos = Mempos = Memory; Fpos = Mempos = Memory;
Top = Memory + len; Top = Memory + len;
#ifdef DEBTRACE if (trace)
htrc("fp=%p count=%d MapView=%p len=%d Top=%p\n", htrc("fp=%p count=%d MapView=%p len=%d Top=%p\n",
fp, fp->Count, Memory, len, Top); fp, fp->Count, Memory, len, Top);
#endif
return AllocateBuffer(g); // Useful for DBF files return AllocateBuffer(g); // Useful for DBF files
} // end of OpenTableFile } // end of OpenTableFile
...@@ -365,20 +365,19 @@ int MAPFAM::DeleteRecords(PGLOBAL g, int irc) ...@@ -365,20 +365,19 @@ int MAPFAM::DeleteRecords(PGLOBAL g, int irc)
{ {
int n; int n;
#ifdef DEBTRACE if (trace)
fprintf(debug, htrc("MAP DeleteDB: irc=%d mempos=%p tobuf=%p Tpos=%p Spos=%p\n",
"MAP DeleteDB: irc=%d mempos=%p tobuf=%p Tpos=%p Spos=%p\n",
irc, Mempos, To_Buf, Tpos, Spos); irc, Mempos, To_Buf, Tpos, Spos);
#endif
if (irc != RC_OK) { if (irc != RC_OK) {
/*******************************************************************/ /*******************************************************************/
/* EOF: position Fpos at the top of map position. */ /* EOF: position Fpos at the top of map position. */
/*******************************************************************/ /*******************************************************************/
Fpos = Top; Fpos = Top;
#ifdef DEBTRACE
if (trace)
htrc("Fpos placed at file top=%p\n", Fpos); htrc("Fpos placed at file top=%p\n", Fpos);
#endif
} // endif irc } // endif irc
if (Tpos == Spos) if (Tpos == Spos)
...@@ -394,17 +393,16 @@ int MAPFAM::DeleteRecords(PGLOBAL g, int irc) ...@@ -394,17 +393,16 @@ int MAPFAM::DeleteRecords(PGLOBAL g, int irc)
memmove(Tpos, Spos, n); memmove(Tpos, Spos, n);
Tpos += n; Tpos += n;
#ifdef DEBTRACE if (trace)
htrc("move %d bytes\n", n); htrc("move %d bytes\n", n);
#endif
} // endif n } // endif n
if (irc == RC_OK) { if (irc == RC_OK) {
Spos = Mempos; // New start position Spos = Mempos; // New start position
#ifdef DEBTRACE if (trace)
htrc("after: Tpos=%p Spos=%p\n", Tpos, Spos); htrc("after: Tpos=%p Spos=%p\n", Tpos, Spos);
#endif
} else if (To_Fb) { // Can be NULL for deleted files } else if (To_Fb) { // Can be NULL for deleted files
/*******************************************************************/ /*******************************************************************/
...@@ -432,9 +430,8 @@ int MAPFAM::DeleteRecords(PGLOBAL g, int irc) ...@@ -432,9 +430,8 @@ int MAPFAM::DeleteRecords(PGLOBAL g, int irc)
return RC_FX; return RC_FX;
} // endif } // endif
#ifdef DEBTRACE if (trace)
htrc("done, Tpos=%p newsize=%d drc=%d\n", Tpos, n, drc); htrc("done, Tpos=%p newsize=%d drc=%d\n", Tpos, n, drc);
#endif
if (!SetEndOfFile(fp->Handle)) { if (!SetEndOfFile(fp->Handle)) {
sprintf(g->Message, MSG(FUNCTION_ERROR), sprintf(g->Message, MSG(FUNCTION_ERROR),
...@@ -466,10 +463,10 @@ void MAPFAM::CloseTableFile(PGLOBAL g) ...@@ -466,10 +463,10 @@ void MAPFAM::CloseTableFile(PGLOBAL g)
PlugCloseFile(g, To_Fb); PlugCloseFile(g, To_Fb);
To_Fb = NULL; // To get correct file size in Cardinality To_Fb = NULL; // To get correct file size in Cardinality
#ifdef DEBTRACE if (trace)
htrc("MAP Close: closing %s count=%d\n", htrc("MAP Close: closing %s count=%d\n",
To_File, (To_Fb) ? To_Fb->Count : 0); To_File, (To_Fb) ? To_Fb->Count : 0);
#endif
} // end of CloseTableFile } // end of CloseTableFile
/***********************************************************************/ /***********************************************************************/
......
...@@ -485,16 +485,15 @@ bool DBFFAM::OpenTableFile(PGLOBAL g) ...@@ -485,16 +485,15 @@ bool DBFFAM::OpenTableFile(PGLOBAL g)
PlugSetPath(filename, To_File, Tdbp->GetPath()); PlugSetPath(filename, To_File, Tdbp->GetPath());
if (!(Stream = PlugOpenFile(g, filename, opmode))) { if (!(Stream = PlugOpenFile(g, filename, opmode))) {
#ifdef DEBTRACE if (trace)
htrc("%s\n", g->Message); htrc("%s\n", g->Message);
#endif
return (mode == MODE_READ && errno == ENOENT) return (mode == MODE_READ && errno == ENOENT)
? PushWarning(g, Tdbp) : true; ? PushWarning(g, Tdbp) : true;
} // endif Stream } // endif Stream
#ifdef DEBTRACE if (trace)
htrc("File %s is open in mode %s\n", filename, opmode); htrc("File %s is open in mode %s\n", filename, opmode);
#endif
To_Fb = dbuserp->Openlist; // Keep track of File block To_Fb = dbuserp->Openlist; // Keep track of File block
...@@ -853,10 +852,10 @@ void DBFFAM::CloseTableFile(PGLOBAL g) ...@@ -853,10 +852,10 @@ void DBFFAM::CloseTableFile(PGLOBAL g)
rc = PlugCloseFile(g, To_Fb); rc = PlugCloseFile(g, To_Fb);
fin: fin:
#ifdef DEBTRACE if (trace)
htrc("DBF CloseTableFile: closing %s mode=%d wrc=%d rc=%d\n", htrc("DBF CloseTableFile: closing %s mode=%d wrc=%d rc=%d\n",
To_File, mode, wrc, rc); To_File, mode, wrc, rc);
#endif
Stream = NULL; // So we can know whether table is open Stream = NULL; // So we can know whether table is open
} // end of CloseTableFile } // end of CloseTableFile
......
This diff is collapsed.
...@@ -62,6 +62,7 @@ ...@@ -62,6 +62,7 @@
/* DB static variables. */ /* DB static variables. */
/***********************************************************************/ /***********************************************************************/
extern int num_read, num_there, num_eq[]; // Statistics extern int num_read, num_there, num_eq[]; // Statistics
extern "C" int trace;
/* ------------------------------------------------------------------- */ /* ------------------------------------------------------------------- */
...@@ -203,9 +204,8 @@ bool ZIPFAM::AllocateBuffer(PGLOBAL g) ...@@ -203,9 +204,8 @@ bool ZIPFAM::AllocateBuffer(PGLOBAL g)
Buflen = Lrecl + 2; // Lrecl does not include CRLF Buflen = Lrecl + 2; // Lrecl does not include CRLF
//Buflen *= ((Mode == MODE_DELETE) ? DOS_BUFF_LEN : 1); NIY //Buflen *= ((Mode == MODE_DELETE) ? DOS_BUFF_LEN : 1); NIY
#ifdef DEBTRACE if (trace)
htrc("SubAllocating a buffer of %d bytes\n", Buflen); htrc("SubAllocating a buffer of %d bytes\n", Buflen);
#endif
To_Buf = (char*)PlugSubAlloc(g, NULL, Buflen); To_Buf = (char*)PlugSubAlloc(g, NULL, Buflen);
...@@ -331,9 +331,9 @@ int ZIPFAM::ReadBuffer(PGLOBAL g) ...@@ -331,9 +331,9 @@ int ZIPFAM::ReadBuffer(PGLOBAL g)
} else } else
rc = Zerror(g); rc = Zerror(g);
#ifdef DEBTRACE if (trace > 1)
htrc(" Read: '%s' rc=%d\n", To_Buf, rc); htrc(" Read: '%s' rc=%d\n", To_Buf, rc);
#endif
return rc; return rc;
} // end of ReadBuffer } // end of ReadBuffer
...@@ -373,9 +373,8 @@ void ZIPFAM::CloseTableFile(PGLOBAL g) ...@@ -373,9 +373,8 @@ void ZIPFAM::CloseTableFile(PGLOBAL g)
{ {
int rc = gzclose(Zfile); int rc = gzclose(Zfile);
#ifdef DEBTRACE if (trace)
htrc("ZIP CloseDB: closing %s rc=%d\n", To_File, rc); htrc("ZIP CloseDB: closing %s rc=%d\n", To_File, rc);
#endif
Zfile = NULL; // So we can know whether table is open Zfile = NULL; // So we can know whether table is open
//To_Fb->Count = 0; // Avoid double closing by PlugCloseAll //To_Fb->Count = 0; // Avoid double closing by PlugCloseAll
...@@ -599,9 +598,8 @@ void ZBKFAM::CloseTableFile(PGLOBAL g) ...@@ -599,9 +598,8 @@ void ZBKFAM::CloseTableFile(PGLOBAL g)
} else } else
rc = gzclose(Zfile); rc = gzclose(Zfile);
#ifdef DEBTRACE if (trace)
htrc("ZIP CloseDB: closing %s rc=%d\n", To_File, rc); htrc("ZIP CloseDB: closing %s rc=%d\n", To_File, rc);
#endif
Zfile = NULL; // So we can know whether table is open Zfile = NULL; // So we can know whether table is open
//To_Fb->Count = 0; // Avoid double closing by PlugCloseAll //To_Fb->Count = 0; // Avoid double closing by PlugCloseAll
......
This diff is collapsed.
...@@ -96,7 +96,7 @@ ...@@ -96,7 +96,7 @@
extern "C" HINSTANCE s_hModule; // Saved module handle extern "C" HINSTANCE s_hModule; // Saved module handle
#endif // !WIN32 #endif // !WIN32
extern int xtrace; extern "C" int trace;
PQRYRES OEMColumns(PGLOBAL g, PTOS topt, char *tab, char *db, bool info); PQRYRES OEMColumns(PGLOBAL g, PTOS topt, char *tab, char *db, bool info);
...@@ -716,7 +716,7 @@ bool MYCAT::GetIndexInfo(PGLOBAL g, PTABDEF defp) ...@@ -716,7 +716,7 @@ bool MYCAT::GetIndexInfo(PGLOBAL g, PTABDEF defp)
PRELDEF MYCAT::GetTableDesc(PGLOBAL g, LPCSTR name, PRELDEF MYCAT::GetTableDesc(PGLOBAL g, LPCSTR name,
LPCSTR type, PRELDEF *prp) LPCSTR type, PRELDEF *prp)
{ {
if (xtrace) if (trace)
printf("GetTableDesc: name=%s am=%s\n", name, SVP(type)); printf("GetTableDesc: name=%s am=%s\n", name, SVP(type));
// If not specified get the type of this table // If not specified get the type of this table
...@@ -735,7 +735,7 @@ PRELDEF MYCAT::MakeTableDesc(PGLOBAL g, LPCSTR name, LPCSTR am) ...@@ -735,7 +735,7 @@ PRELDEF MYCAT::MakeTableDesc(PGLOBAL g, LPCSTR name, LPCSTR am)
TABTYPE tc; TABTYPE tc;
PRELDEF tdp= NULL; PRELDEF tdp= NULL;
if (xtrace) if (trace)
printf("MakeTableDesc: name=%s am=%s\n", name, SVP(am)); 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) ...@@ -794,14 +794,14 @@ PTDB MYCAT::GetTable(PGLOBAL g, PTABLE tablep, MODE mode, LPCSTR type)
PTDB tdbp= NULL; PTDB tdbp= NULL;
LPCSTR name= tablep->GetName(); LPCSTR name= tablep->GetName();
if (xtrace) if (trace)
printf("GetTableDB: name=%s\n", name); printf("GetTableDB: name=%s\n", name);
// Look for the description of the requested table // Look for the description of the requested table
tdp= GetTableDesc(g, name, type); tdp= GetTableDesc(g, name, type);
if (tdp) { if (tdp) {
if (xtrace) if (trace)
printf("tdb=%p type=%s\n", tdp, tdp->GetType()); printf("tdb=%p type=%s\n", tdp, tdp->GetType());
if (tablep->GetQualifier()) if (tablep->GetQualifier())
...@@ -811,7 +811,7 @@ PTDB MYCAT::GetTable(PGLOBAL g, PTABLE tablep, MODE mode, LPCSTR type) ...@@ -811,7 +811,7 @@ PTDB MYCAT::GetTable(PGLOBAL g, PTABLE tablep, MODE mode, LPCSTR type)
} // endif tdp } // endif tdp
if (tdbp) { if (tdbp) {
if (xtrace) if (trace)
printf("tdbp=%p name=%s amtype=%d\n", tdbp, tdbp->GetName(), printf("tdbp=%p name=%s amtype=%d\n", tdbp, tdbp->GetName(),
tdbp->GetAmType()); tdbp->GetAmType());
tablep->SetTo_Tdb(tdbp); tablep->SetTo_Tdb(tdbp);
......
...@@ -295,7 +295,7 @@ PQRYRES SrcColumns(PGLOBAL g, const char *host, const char *db, ...@@ -295,7 +295,7 @@ PQRYRES SrcColumns(PGLOBAL g, const char *host, const char *db,
// Send the source command to MySQL // Send the source command to MySQL
if (myc.ExecSQL(g, query, &w) == RC_OK) if (myc.ExecSQL(g, query, &w) == RC_OK)
qrp = myc.GetResult(g); qrp = myc.GetResult(g, true);
myc.Close(); myc.Close();
return qrp; return qrp;
...@@ -676,7 +676,7 @@ MYSQL_FIELD *MYSQLC::GetNextField(void) ...@@ -676,7 +676,7 @@ MYSQL_FIELD *MYSQLC::GetNextField(void)
/***********************************************************************/ /***********************************************************************/
PQRYRES MYSQLC::GetResult(PGLOBAL g, bool pdb) PQRYRES MYSQLC::GetResult(PGLOBAL g, bool pdb)
{ {
char *fmt; char *fmt, v;
int n; int n;
bool uns; bool uns;
PCOLRES *pcrp, crp; PCOLRES *pcrp, crp;
...@@ -705,7 +705,6 @@ PQRYRES MYSQLC::GetResult(PGLOBAL g, bool pdb) ...@@ -705,7 +705,6 @@ PQRYRES MYSQLC::GetResult(PGLOBAL g, bool pdb)
qrp->Nblin = 0; qrp->Nblin = 0;
qrp->Cursor = 0; qrp->Cursor = 0;
//for (fld = mysql_fetch_field(m_Res); fld; //for (fld = mysql_fetch_field(m_Res); fld;
// fld = mysql_fetch_field(m_Res)) { // fld = mysql_fetch_field(m_Res)) {
for (fld = GetNextField(); fld; fld = GetNextField()) { for (fld = GetNextField(); fld; fld = GetNextField()) {
...@@ -718,17 +717,19 @@ PQRYRES MYSQLC::GetResult(PGLOBAL g, bool pdb) ...@@ -718,17 +717,19 @@ PQRYRES MYSQLC::GetResult(PGLOBAL g, bool pdb)
crp->Name = (char*)PlugSubAlloc(g, NULL, fld->name_length + 1); crp->Name = (char*)PlugSubAlloc(g, NULL, fld->name_length + 1);
strcpy(crp->Name, fld->name); 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", sprintf(g->Message, "Type %d not supported for column %s",
fld->type, crp->Name); fld->type, crp->Name);
return NULL; return NULL;
} else if (crp->Type == TYPE_DATE && !pdb) } else if (crp->Type == TYPE_DATE && !pdb)
// For direct MySQL connection, display the MySQL date string // For direct MySQL connection, display the MySQL date string
crp->Type = TYPE_STRING; crp->Type = TYPE_STRING;
else
crp->Var = v;
crp->Prec = (crp->Type == TYPE_DOUBLE || crp->Type == TYPE_DECIM) crp->Prec = (crp->Type == TYPE_DOUBLE || crp->Type == TYPE_DECIM)
? fld->decimals : 0; ? fld->decimals : 0;
crp->Length = fld->max_length; crp->Length = max(fld->length, fld->max_length);
crp->Clen = GetTypeSize(crp->Type, crp->Length); crp->Clen = GetTypeSize(crp->Type, crp->Length);
uns = (fld->flags & (UNSIGNED_FLAG | ZEROFILL_FLAG)) ? true : false; uns = (fld->flags & (UNSIGNED_FLAG | ZEROFILL_FLAG)) ? true : false;
......
...@@ -95,7 +95,7 @@ Warning 1105 This is an outward table, table data were not modified. ...@@ -95,7 +95,7 @@ Warning 1105 This is an outward table, table data were not modified.
SELECT * FROM t2; SELECT * FROM t2;
line line
<?xml version="1.0" encoding="UTF-8"?> <?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> <t1>
<row> <row>
<TH>c</TH> <TH>c</TH>
...@@ -131,7 +131,7 @@ t1 CREATE TABLE `t1` ( ...@@ -131,7 +131,7 @@ t1 CREATE TABLE `t1` (
SELECT * FROM t2; SELECT * FROM t2;
line line
<?xml version="1.0" encoding="UTF-8"?> <?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> <t1>
<row d="One"> <row d="One">
<c>1</c> <c>1</c>
......
...@@ -413,7 +413,7 @@ DROP TABLE t1; ...@@ -413,7 +413,7 @@ DROP TABLE t1;
SET @a=LOAD_FILE('MYSQLD_DATADIR/test/t1.xml'); SET @a=LOAD_FILE('MYSQLD_DATADIR/test/t1.xml');
SELECT CAST(@a AS CHAR CHARACTER SET latin1); SELECT CAST(@a AS CHAR CHARACTER SET latin1);
CAST(@a AS CHAR CHARACTER SET latin1) <?xml version="1.0" encoding="iso-8859-1"?> 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> <t1>
<line> <line>
<node>ÀÁÂÃ</node> <node>ÀÁÂÃ</node>
......
...@@ -58,12 +58,8 @@ int MYSQLtoPLG(char *typname, char *var) ...@@ -58,12 +58,8 @@ int MYSQLtoPLG(char *typname, char *var)
type = TYPE_ERROR; type = TYPE_ERROR;
if (var) { 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) { if (type == TYPE_DATE) {
// This is to make the difference between temporal values
if (!stricmp(typname, "date")) if (!stricmp(typname, "date"))
*var = 'D'; *var = 'D';
else if (!stricmp(typname, "datetime")) else if (!stricmp(typname, "datetime"))
...@@ -75,7 +71,11 @@ int MYSQLtoPLG(char *typname, char *var) ...@@ -75,7 +71,11 @@ int MYSQLtoPLG(char *typname, char *var)
else if (!stricmp(typname, "year")) else if (!stricmp(typname, "year"))
*var = 'Y'; *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 } // endif var
...@@ -200,7 +200,6 @@ int MYSQLtoPLG(int mytype, char *var) ...@@ -200,7 +200,6 @@ int MYSQLtoPLG(int mytype, char *var)
case MYSQL_TYPE_TINY_BLOB: case MYSQL_TYPE_TINY_BLOB:
case MYSQL_TYPE_MEDIUM_BLOB: case MYSQL_TYPE_MEDIUM_BLOB:
case MYSQL_TYPE_LONG_BLOB: case MYSQL_TYPE_LONG_BLOB:
if (var) *var = 'V';
case MYSQL_TYPE_STRING: case MYSQL_TYPE_STRING:
type = TYPE_STRING; type = TYPE_STRING;
break; break;
...@@ -208,6 +207,25 @@ int MYSQLtoPLG(int mytype, char *var) ...@@ -208,6 +207,25 @@ int MYSQLtoPLG(int mytype, char *var)
type = TYPE_ERROR; type = TYPE_ERROR;
} // endswitch mytype } // 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; return type;
} // end of MYSQLtoPLG } // end of MYSQLtoPLG
......
...@@ -78,7 +78,7 @@ void _splitpath(LPCSTR name, LPSTR drive, LPSTR dir, LPSTR fn, LPSTR ft) ...@@ -78,7 +78,7 @@ void _splitpath(LPCSTR name, LPSTR drive, LPSTR dir, LPSTR fn, LPSTR ft)
LPCSTR p2, p = name; LPCSTR p2, p = name;
#ifdef DEBTRACE #ifdef DEBTRACE
fprintf(debug,"SplitPath: name=%s [%s (%d)]\n", htrc("SplitPath: name=%s [%s (%d)]\n",
XSTR(name), XSTR(__FILE__), __LINE__); XSTR(name), XSTR(__FILE__), __LINE__);
#endif #endif
...@@ -100,7 +100,7 @@ void _splitpath(LPCSTR name, LPSTR drive, LPSTR dir, LPSTR fn, LPSTR ft) ...@@ -100,7 +100,7 @@ void _splitpath(LPCSTR name, LPSTR drive, LPSTR dir, LPSTR fn, LPSTR ft)
if (fn) strcpy(fn, p); if (fn) strcpy(fn, p);
#ifdef DEBTRACE #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__); XSTR(name), XSTR(drive), XSTR(dir), XSTR(fn), XSTR(ft), __FILE__, __LINE__);
#endif #endif
} /* end of _splitpath */ } /* end of _splitpath */
......
...@@ -512,6 +512,7 @@ typedef struct _colres { ...@@ -512,6 +512,7 @@ typedef struct _colres {
int Prec; /* Precision */ int Prec; /* Precision */
int Flag; /* Flag option value */ int Flag; /* Flag option value */
XFLD Fld; /* Type of field info */ XFLD Fld; /* Type of field info */
char Var; /* Type added information */
} COLRES; } COLRES;
#if defined(WIN32) && !defined(NOEX) #if defined(WIN32) && !defined(NOEX)
......
...@@ -80,9 +80,6 @@ extern pthread_mutex_t parmut; ...@@ -80,9 +80,6 @@ extern pthread_mutex_t parmut;
#endif // !WIN32 #endif // !WIN32
#endif // THREAD #endif // THREAD
#define PLGINI "plugdb.ini" /* Configuration settings file */
#define PLGXINI "plgcnx.ini" /* Configuration settings file */
/***********************************************************************/ /***********************************************************************/
/* DB static variables. */ /* DB static variables. */
/***********************************************************************/ /***********************************************************************/
...@@ -90,27 +87,13 @@ bool Initdone = false; ...@@ -90,27 +87,13 @@ bool Initdone = false;
bool plugin = false; // True when called by the XDB plugin handler bool plugin = false; // True when called by the XDB plugin handler
extern "C" { 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) #if defined(XMSG)
char msglang[16] = "ENGLISH"; // Default language char msglang[16] = "ENGLISH"; // Default language
#endif #endif
extern int trace;
extern char version[];
} // extern "C" } // extern "C"
extern "C" int trace;
extern "C" char version[];
// The debug trace used by the main thread // The debug trace used by the main thread
FILE *pfile = NULL; FILE *pfile = NULL;
...@@ -219,27 +202,6 @@ int global_open(GLOBAL *g, int msgid, const char *path, int flags, int mode) ...@@ -219,27 +202,6 @@ int global_open(GLOBAL *g, int msgid, const char *path, int flags, int mode)
return h; 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) DllExport void SetTrc(void)
{ {
// If tracing is on, debug must be initialized. // If tracing is on, debug must be initialized.
...@@ -427,138 +389,9 @@ char *PlgGetDataPath(PGLOBAL g) ...@@ -427,138 +389,9 @@ char *PlgGetDataPath(PGLOBAL g)
{ {
PCATLG cat = PlgGetCatalog(g, false); PCATLG cat = PlgGetCatalog(g, false);
//if (!cat)
// return GetIniString(g, NULL, "DataBase", "DataPath", "", plgini);
return (cat) ? cat->GetDataPath() : NULL; return (cat) ? cat->GetDataPath() : NULL;
} // end of PlgGetDataPath } // 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. */ /* Check the occurence and matching of a pattern against a string. */
/* Because this function is only used for catalog name checking, */ /* Because this function is only used for catalog name checking, */
...@@ -1468,19 +1301,17 @@ void *PlgDBSubAlloc(PGLOBAL g, void *memp, size_t size) ...@@ -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 */ size = ((size + 7) / 8) * 8; /* Round up size to multiple of 8 */
pph = (PPOOLHEADER)memp; pph = (PPOOLHEADER)memp;
#if defined(DEBTRACE) if (trace > 1)
htrc("PlgDBSubAlloc: memp=%p size=%d used=%d free=%d\n", htrc("PlgDBSubAlloc: memp=%p size=%d used=%d free=%d\n",
memp, size, pph->To_Free, pph->FreeBlk); memp, size, pph->To_Free, pph->FreeBlk);
#endif
if ((uint)size > pph->FreeBlk) { /* Not enough memory left in pool */ if ((uint)size > pph->FreeBlk) { /* Not enough memory left in pool */
sprintf(g->Message, sprintf(g->Message,
"Not enough memory in Work area for request of %d (used=%d free=%d)", "Not enough memory in Work area for request of %d (used=%d free=%d)",
(int) size, pph->To_Free, pph->FreeBlk); (int) size, pph->To_Free, pph->FreeBlk);
#if defined(DEBTRACE) if (trace)
htrc("%s\n", g->Message); htrc("%s\n", g->Message);
#endif
return NULL; return NULL;
} // endif size } // endif size
...@@ -1491,10 +1322,11 @@ void *PlgDBSubAlloc(PGLOBAL g, void *memp, size_t size) ...@@ -1491,10 +1322,11 @@ void *PlgDBSubAlloc(PGLOBAL g, void *memp, size_t size)
memp = MakePtr(memp, pph->To_Free); // Points to suballocated block memp = MakePtr(memp, pph->To_Free); // Points to suballocated block
pph->To_Free += size; // New offset of pool free block pph->To_Free += size; // New offset of pool free block
pph->FreeBlk -= size; // New size of pool free block pph->FreeBlk -= size; // New size of pool free block
#if defined(DEBTRACE)
if (trace > 1)
htrc("Done memp=%p used=%d free=%d\n", htrc("Done memp=%p used=%d free=%d\n",
memp, pph->To_Free, pph->FreeBlk); memp, pph->To_Free, pph->FreeBlk);
#endif
return (memp); return (memp);
} // end of PlgDBSubAlloc } // end of PlgDBSubAlloc
......
...@@ -37,8 +37,6 @@ ...@@ -37,8 +37,6 @@
/* IBM Linker */ /* IBM Linker */
/* */ /* */
/***********************************************************************/ /***********************************************************************/
//efine DEBTRACE 3
//efine DEBTRACE2
/***********************************************************************/ /***********************************************************************/
/* */ /* */
...@@ -83,7 +81,6 @@ ...@@ -83,7 +81,6 @@
extern HINSTANCE s_hModule; /* Saved module handle */ extern HINSTANCE s_hModule; /* Saved module handle */
#endif // WIN32 #endif // WIN32
extern char plgini[];
extern int trace; extern int trace;
#if defined(XMSG) #if defined(XMSG)
......
...@@ -47,10 +47,6 @@ ...@@ -47,10 +47,6 @@
#include "valblk.h" #include "valblk.h"
#include "tabmul.h" #include "tabmul.h"
/***********************************************************************/
/* External static variables. */
/***********************************************************************/
//extern "C" char plgini[];
/* --------------------------- Class RELDEF -------------------------- */ /* --------------------------- Class RELDEF -------------------------- */
......
...@@ -22,6 +22,8 @@ ...@@ -22,6 +22,8 @@
#include "xtable.h" #include "xtable.h"
#include "tabcol.h" #include "tabcol.h"
extern "C" int trace;
/***********************************************************************/ /***********************************************************************/
/* XTAB public constructor. */ /* XTAB public constructor. */
/***********************************************************************/ /***********************************************************************/
...@@ -33,9 +35,9 @@ XTAB::XTAB(LPCSTR name, LPCSTR srcdef) : Name(name) ...@@ -33,9 +35,9 @@ XTAB::XTAB(LPCSTR name, LPCSTR srcdef) : Name(name)
Schema = NULL; Schema = NULL;
Qualifier = NULL; Qualifier = NULL;
#ifdef DEBTRACE if (trace)
htrc(" making new TABLE %s %s\n", Name, Srcdef); htrc("XTAB: making new TABLE %s %s\n", Name, Srcdef);
#endif
} // end of XTAB constructor } // end of XTAB constructor
/***********************************************************************/ /***********************************************************************/
...@@ -49,9 +51,9 @@ XTAB::XTAB(PTABLE tp) : Name(tp->Name) ...@@ -49,9 +51,9 @@ XTAB::XTAB(PTABLE tp) : Name(tp->Name)
Schema = tp->Schema; Schema = tp->Schema;
Qualifier = tp->Qualifier; Qualifier = tp->Qualifier;
#ifdef DEBTRACE if (trace)
htrc(" making copy TABLE %s %s\n", Name, Srcdef); htrc(" making copy TABLE %s %s\n", Name, Srcdef);
#endif
} // end of XTAB constructor } // end of XTAB constructor
/***********************************************************************/ /***********************************************************************/
...@@ -61,9 +63,8 @@ PTABLE XTAB::Link(PTABLE tab2) ...@@ -61,9 +63,8 @@ PTABLE XTAB::Link(PTABLE tab2)
{ {
PTABLE tabp; PTABLE tabp;
#ifdef DEBTRACE if (trace)
htrc("Linking tables %s... to %s\n", Name, tab2->Name); htrc("Linking tables %s... to %s\n", Name, tab2->Name);
#endif
for (tabp = this; tabp->Next; tabp = tabp->Next) ; for (tabp = this; tabp->Next; tabp = tabp->Next) ;
...@@ -118,9 +119,9 @@ COLUMN::COLUMN(LPCSTR name) : Name(name) ...@@ -118,9 +119,9 @@ COLUMN::COLUMN(LPCSTR name) : Name(name)
To_Col = NULL; To_Col = NULL;
Qualifier = NULL; Qualifier = NULL;
#ifdef DEBTRACE if (trace)
htrc(" making new COLUMN %s\n", Name); htrc(" making new COLUMN %s\n", Name);
#endif
} // end of COLUMN constructor } // end of COLUMN constructor
/***********************************************************************/ /***********************************************************************/
......
...@@ -1333,7 +1333,7 @@ void CSVCOL::ReadColumn(PGLOBAL g) ...@@ -1333,7 +1333,7 @@ void CSVCOL::ReadColumn(PGLOBAL g)
/***********************************************************************/ /***********************************************************************/
void CSVCOL::WriteColumn(PGLOBAL g) void CSVCOL::WriteColumn(PGLOBAL g)
{ {
char *p, buf[32]; char *p, buf[64];
int flen; int flen;
PTDBCSV tdbp = (PTDBCSV)To_Tdb; PTDBCSV tdbp = (PTDBCSV)To_Tdb;
......
...@@ -1034,7 +1034,7 @@ int TDBMYSQL::WriteDB(PGLOBAL g) ...@@ -1034,7 +1034,7 @@ int TDBMYSQL::WriteDB(PGLOBAL g)
// Statement was not prepared, we must construct and execute // Statement was not prepared, we must construct and execute
// an insert query for each line to insert // an insert query for each line to insert
int rc; int rc;
char buf[32]; char buf[64];
strcpy(Qbuf, Query); strcpy(Qbuf, Query);
......
...@@ -1066,7 +1066,7 @@ void ODBCCOL::ReadColumn(PGLOBAL g) ...@@ -1066,7 +1066,7 @@ void ODBCCOL::ReadColumn(PGLOBAL g)
} // endif Buf_Type } // endif Buf_Type
if (g->Trace) { if (g->Trace) {
char buf[32]; char buf[64];
htrc("ODBC Column %s: rows=%d buf=%p type=%d value=%s\n", htrc("ODBC Column %s: rows=%d buf=%p type=%d value=%s\n",
Name, tdbp->Rows, Bufp, Buf_Type, Value->GetCharString(buf)); Name, tdbp->Rows, Bufp, Buf_Type, Value->GetCharString(buf));
......
...@@ -95,7 +95,7 @@ PIVAID::PIVAID(const char *tab, const char *src, const char *picol, ...@@ -95,7 +95,7 @@ PIVAID::PIVAID(const char *tab, const char *src, const char *picol,
/***********************************************************************/ /***********************************************************************/
PQRYRES PIVAID::MakePivotColumns(PGLOBAL g) PQRYRES PIVAID::MakePivotColumns(PGLOBAL g)
{ {
char *query, *colname, buf[32]; char *query, *colname, buf[64];
int ndif, nblin, w = 0; int ndif, nblin, w = 0;
PVAL valp; PVAL valp;
PCOLRES *pcrp, crp, fncrp = NULL; PCOLRES *pcrp, crp, fncrp = NULL;
...@@ -121,7 +121,7 @@ PQRYRES PIVAID::MakePivotColumns(PGLOBAL g) ...@@ -121,7 +121,7 @@ PQRYRES PIVAID::MakePivotColumns(PGLOBAL g)
} // endif Exec } // endif Exec
// We must have a storage query to get pivot column values // We must have a storage query to get pivot column values
Qryp = Myc.GetResult(g); Qryp = Myc.GetResult(g, true);
Myc.Close(); Myc.Close();
if (!Fncol) { if (!Fncol) {
......
...@@ -76,6 +76,8 @@ ...@@ -76,6 +76,8 @@
char *strerror(int num); char *strerror(int num);
#endif // UNIX #endif // UNIX
extern "C" int trace;
/***********************************************************************/ /***********************************************************************/
/* Char VCT column blocks are right filled with blanks (blank = true) */ /* Char VCT column blocks are right filled with blanks (blank = true) */
/* Conversion of block values allowed conditionally for insert only. */ /* Conversion of block values allowed conditionally for insert only. */
...@@ -287,10 +289,9 @@ PCOL TDBVCT::MakeCol(PGLOBAL g, PCOLDEF cdp, PCOL cprec, int n) ...@@ -287,10 +289,9 @@ PCOL TDBVCT::MakeCol(PGLOBAL g, PCOLDEF cdp, PCOL cprec, int n)
/***********************************************************************/ /***********************************************************************/
bool TDBVCT::OpenDB(PGLOBAL g) bool TDBVCT::OpenDB(PGLOBAL g)
{ {
#ifdef DEBTRACE if (trace)
htrc("VCT OpenDB: tdbp=%p tdb=R%d use=%d key=%p mode=%d\n", htrc("VCT OpenDB: tdbp=%p tdb=R%d use=%d key=%p mode=%d\n",
this, Tdb_No, Use, To_Key_Col, Mode); this, Tdb_No, Use, To_Key_Col, Mode);
#endif
if (Use == USE_OPEN) { if (Use == USE_OPEN) {
/*******************************************************************/ /*******************************************************************/
...@@ -338,12 +339,10 @@ bool TDBVCT::OpenDB(PGLOBAL g) ...@@ -338,12 +339,10 @@ bool TDBVCT::OpenDB(PGLOBAL g)
/***********************************************************************/ /***********************************************************************/
int TDBVCT::ReadDB(PGLOBAL g) int TDBVCT::ReadDB(PGLOBAL g)
{ {
#ifdef DEBTRACE if (trace)
fprintf(debug, htrc("VCT ReadDB: R%d Mode=%d CurBlk=%d CurNum=%d key=%p link=%p Kindex=%p\n",
"VCT ReadDB: R%d Mode=%d CurBlk=%d CurNum=%d key=%p link=%p Kindex=%p\n",
GetTdb_No(), Mode, Txfp->CurBlk, Txfp->CurNum, GetTdb_No(), Mode, Txfp->CurBlk, Txfp->CurNum,
To_Key_Col, To_Link, To_Kindex); To_Key_Col, To_Link, To_Kindex);
#endif
if (To_Kindex) { if (To_Kindex) {
/*******************************************************************/ /*******************************************************************/
...@@ -518,15 +517,13 @@ void VCTCOL::ReadColumn(PGLOBAL g) ...@@ -518,15 +517,13 @@ void VCTCOL::ReadColumn(PGLOBAL g)
{ {
PTXF txfp = ((PTDBVCT)To_Tdb)->Txfp; PTXF txfp = ((PTDBVCT)To_Tdb)->Txfp;
#if defined(_DEBUG) || defined(DEBTRACE) #if defined(_DEBUG)
assert (!To_Kcol); assert (!To_Kcol);
#endif #endif
#ifdef DEBTRACE if (trace > 1)
fprintf(debug, htrc("VCT ReadColumn: col %s R%d coluse=%.4X status=%.4X buf_type=%d\n",
"VCT ReadColumn: col %s R%d coluse=%.4X status=%.4X buf_type=%d\n",
Name, To_Tdb->GetTdb_No(), ColUse, Status, Buf_Type); Name, To_Tdb->GetTdb_No(), ColUse, Status, Buf_Type);
#endif
if (ColBlk != txfp->CurBlk) if (ColBlk != txfp->CurBlk)
ReadBlock(g); ReadBlock(g);
...@@ -552,11 +549,9 @@ void VCTCOL::WriteColumn(PGLOBAL g) ...@@ -552,11 +549,9 @@ void VCTCOL::WriteColumn(PGLOBAL g)
{ {
PTXF txfp = ((PTDBVCT)To_Tdb)->Txfp;; PTXF txfp = ((PTDBVCT)To_Tdb)->Txfp;;
#ifdef DEBTRACE if (trace > 1)
fprintf(debug, htrc("VCT WriteColumn: col %s R%d coluse=%.4X status=%.4X buf_type=%d\n",
"VCT WriteColumn: col %s R%d coluse=%.4X status=%.4X buf_type=%d\n",
Name, To_Tdb->GetTdb_No(), ColUse, Status, Buf_Type); Name, To_Tdb->GetTdb_No(), ColUse, Status, Buf_Type);
#endif
ColBlk = txfp->CurBlk; ColBlk = txfp->CurBlk;
ColPos = txfp->CurNum; ColPos = txfp->CurNum;
......
...@@ -47,8 +47,7 @@ ...@@ -47,8 +47,7 @@
#include "user_connect.h" #include "user_connect.h"
#include "mycat.h" #include "mycat.h"
extern "C" char plgxini[]; extern "C" int trace;
extern int xtrace;
/****************************************************************************/ /****************************************************************************/
/* Initialize the user_connect static member. */ /* Initialize the user_connect static member. */
...@@ -149,7 +148,7 @@ bool user_connect::CheckCleanup(void) ...@@ -149,7 +148,7 @@ bool user_connect::CheckCleanup(void)
g->Alchecked = 0; g->Alchecked = 0;
last_query_id= thdp->query_id; last_query_id= thdp->query_id;
if (xtrace) if (trace)
printf("=====> Begin new query %llu\n", last_query_id); printf("=====> Begin new query %llu\n", last_query_id);
return true; return true;
......
...@@ -43,6 +43,8 @@ ...@@ -43,6 +43,8 @@
#define CheckBlanks assert(!Blanks); #define CheckBlanks assert(!Blanks);
#define CheckParms(V, N) ChkIndx(N); ChkTyp(V); #define CheckParms(V, N) ChkIndx(N); ChkTyp(V);
extern "C" int trace;
/***********************************************************************/ /***********************************************************************/
/* AllocValBlock: allocate a VALBLK according to type. */ /* AllocValBlock: allocate a VALBLK according to type. */
/***********************************************************************/ /***********************************************************************/
...@@ -51,10 +53,9 @@ PVBLK AllocValBlock(PGLOBAL g, void *mp, int type, int nval, int len, ...@@ -51,10 +53,9 @@ PVBLK AllocValBlock(PGLOBAL g, void *mp, int type, int nval, int len,
{ {
PVBLK blkp; PVBLK blkp;
#ifdef DEBTRACE if (trace)
htrc("AVB: mp=%p type=%d nval=%d len=%d check=%u blank=%u\n", htrc("AVB: mp=%p type=%d nval=%d len=%d check=%u blank=%u\n",
mp, type, nval, len, check, blank); mp, type, nval, len, check, blank);
#endif
switch (type) { switch (type) {
case TYPE_STRING: case TYPE_STRING:
...@@ -546,7 +547,7 @@ int TYPBLK<TYPE>::Find(PVAL vp) ...@@ -546,7 +547,7 @@ int TYPBLK<TYPE>::Find(PVAL vp)
template <class TYPE> template <class TYPE>
int TYPBLK<TYPE>::GetMaxLength(void) int TYPBLK<TYPE>::GetMaxLength(void)
{ {
char buf[32]; char buf[64];
int i, n, m; int i, n, m;
for (i = n = 0; i < Nval; i++) { for (i = n = 0; i < Nval; i++) {
...@@ -737,13 +738,13 @@ void CHRBLK::SetValue(char *sp, uint len, int n) ...@@ -737,13 +738,13 @@ void CHRBLK::SetValue(char *sp, uint len, int n)
{ {
char *p = Chrp + n * Long; char *p = Chrp + n * Long;
#if defined(_DEBUG) || defined(DEBTRACE) #if defined(_DEBUG)
if (Check && (signed)len > Long) { if (Check && (signed)len > Long) {
PGLOBAL& g = Global; PGLOBAL& g = Global;
strcpy(g->Message, MSG(SET_STR_TRUNC)); strcpy(g->Message, MSG(SET_STR_TRUNC));
longjmp(g->jumper[g->jump_level], Type); longjmp(g->jumper[g->jump_level], Type);
} // endif Check } // endif Check
#endif #endif // _DEBUG
if (sp) if (sp)
memcpy(p, sp, min((unsigned)Long, len)); memcpy(p, sp, min((unsigned)Long, len));
...@@ -786,13 +787,13 @@ void CHRBLK::SetValue(PVBLK pv, int n1, int n2) ...@@ -786,13 +787,13 @@ void CHRBLK::SetValue(PVBLK pv, int n1, int n2)
/***********************************************************************/ /***********************************************************************/
void CHRBLK::SetValues(PVBLK pv, int k, int n) 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) { if (Type != pv->GetType() || Long != ((CHRBLK*)pv)->Long) {
PGLOBAL& g = Global; PGLOBAL& g = Global;
strcpy(g->Message, MSG(BLKTYPLEN_MISM)); strcpy(g->Message, MSG(BLKTYPLEN_MISM));
longjmp(g->jumper[g->jump_level], Type); longjmp(g->jumper[g->jump_level], Type);
} // endif Type } // endif Type
#endif #endif // _DEBUG
char *p = ((CHRBLK*)pv)->Chrp; char *p = ((CHRBLK*)pv)->Chrp;
if (!k) if (!k)
......
...@@ -555,7 +555,7 @@ template <> ...@@ -555,7 +555,7 @@ template <>
bool TYPVAL<double>::SetValue_char(char *p, int n) bool TYPVAL<double>::SetValue_char(char *p, int n)
{ {
if (p) { if (p) {
char buf[32]; char buf[64];
for (; n > 0 && *p == ' '; p++) for (; n > 0 && *p == ' '; p++)
n--; n--;
...@@ -957,7 +957,7 @@ bool TYPVAL<PSZ>::SetValue_pval(PVAL valp, bool chktype) ...@@ -957,7 +957,7 @@ bool TYPVAL<PSZ>::SetValue_pval(PVAL valp, bool chktype)
if (chktype && (valp->GetType() != Type || valp->GetSize() > Len)) if (chktype && (valp->GetType() != Type || valp->GetSize() > Len))
return true; return true;
char buf[32]; char buf[64];
if (!(Null = valp->IsNull() && Nullable)) if (!(Null = valp->IsNull() && Nullable))
strncpy(Strp, valp->GetCharString(buf), Len); strncpy(Strp, valp->GetCharString(buf), Len);
...@@ -1126,7 +1126,7 @@ void TYPVAL<PSZ>::SetValue(ulonglong n) ...@@ -1126,7 +1126,7 @@ void TYPVAL<PSZ>::SetValue(ulonglong n)
/***********************************************************************/ /***********************************************************************/
void TYPVAL<PSZ>::SetValue(double f) void TYPVAL<PSZ>::SetValue(double f)
{ {
char *p, buf[32]; char *p, buf[64];
PGLOBAL& g = Global; PGLOBAL& g = Global;
int k = sprintf(buf, "%lf", f); int k = sprintf(buf, "%lf", f);
...@@ -1220,7 +1220,7 @@ bool TYPVAL<PSZ>::IsEqual(PVAL vp, bool chktype) ...@@ -1220,7 +1220,7 @@ bool TYPVAL<PSZ>::IsEqual(PVAL vp, bool chktype)
else if (Null || vp->IsNull()) else if (Null || vp->IsNull())
return false; return false;
char buf[32]; char buf[64];
if (Ci || vp->IsCi()) if (Ci || vp->IsCi())
return !stricmp(Strp, vp->GetCharString(buf)); return !stricmp(Strp, vp->GetCharString(buf));
...@@ -1351,7 +1351,7 @@ bool DECVAL::SetValue_pval(PVAL valp, bool chktype) ...@@ -1351,7 +1351,7 @@ bool DECVAL::SetValue_pval(PVAL valp, bool chktype)
if (chktype && (valp->GetType() != Type || valp->GetSize() > Len)) if (chktype && (valp->GetType() != Type || valp->GetSize() > Len))
return true; return true;
char buf[32]; char buf[64];
if (!(Null = valp->IsNull() && Nullable)) if (!(Null = valp->IsNull() && Nullable))
strncpy(Strp, valp->GetCharString(buf), Len); strncpy(Strp, valp->GetCharString(buf), Len);
...@@ -1450,7 +1450,7 @@ bool DECVAL::IsEqual(PVAL vp, bool chktype) ...@@ -1450,7 +1450,7 @@ bool DECVAL::IsEqual(PVAL vp, bool chktype)
else if (Null || vp->IsNull()) else if (Null || vp->IsNull())
return false; return false;
char buf[32]; char buf[64];
return !strcmp(Strp, vp->GetCharString(buf)); return !strcmp(Strp, vp->GetCharString(buf));
} // end of IsEqual } // end of IsEqual
......
...@@ -60,6 +60,7 @@ ...@@ -60,6 +60,7 @@
/* DB static external variables. */ /* DB static external variables. */
/***********************************************************************/ /***********************************************************************/
extern MBLOCK Nmblk; /* Used to initialize MBLOCK's */ extern MBLOCK Nmblk; /* Used to initialize MBLOCK's */
extern "C" int trace;
/***********************************************************************/ /***********************************************************************/
/* Last two parameters are true to enable type checking, and last one */ /* Last two parameters are true to enable type checking, and last one */
...@@ -267,10 +268,7 @@ int XINDEX::Qcompare(int *i1, int *i2) ...@@ -267,10 +268,7 @@ int XINDEX::Qcompare(int *i1, int *i2)
if ((k = kcp->Compare(*i1, *i2))) if ((k = kcp->Compare(*i1, *i2)))
break; break;
#ifdef DEBTRACE //num_comp++;
num_comp++;
#endif
return k; return k;
} // end of Qcompare } // end of Qcompare
...@@ -1801,10 +1799,7 @@ XINDXS::XINDXS(PTDBDOS tdbp, PIXDEF xdp, PXLOAD pxp, PCOL *cp, PXOB *xp) ...@@ -1801,10 +1799,7 @@ XINDXS::XINDXS(PTDBDOS tdbp, PIXDEF xdp, PXLOAD pxp, PCOL *cp, PXOB *xp)
/***********************************************************************/ /***********************************************************************/
int XINDXS::Qcompare(int *i1, int *i2) int XINDXS::Qcompare(int *i1, int *i2)
{ {
#ifdef DEBTRACE //num_comp++;
num_comp++;
#endif
return To_KeyCol->Compare(*i1, *i2); return To_KeyCol->Compare(*i1, *i2);
} // end of Qcompare } // end of Qcompare
...@@ -2320,11 +2315,9 @@ bool XHUGE::Open(PGLOBAL g, char *filename, int id, MODE mode) ...@@ -2320,11 +2315,9 @@ bool XHUGE::Open(PGLOBAL g, char *filename, int id, MODE mode)
return true; return true;
} // endif Hfile } // endif Hfile
#ifdef DEBTRACE if (trace)
fprintf(debug, htrc(" access=%p share=%p creation=%d handle=%p fn=%s\n",
" access=%p share=%p creation=%d handle=%p fn=%s\n",
access, share, creation, Hfile, filename); access, share, creation, Hfile, filename);
#endif
if (mode == MODE_INSERT) { if (mode == MODE_INSERT) {
/*******************************************************************/ /*******************************************************************/
...@@ -2767,10 +2760,9 @@ bool KXYCOL::Init(PGLOBAL g, PCOL colp, int n, bool sm, int kln) ...@@ -2767,10 +2760,9 @@ bool KXYCOL::Init(PGLOBAL g, PCOL colp, int n, bool sm, int kln)
Prefix = true; Prefix = true;
} // endif kln } // endif kln
#ifdef DEBTRACE if (trace)
htrc("KCOL(%p) Init: col=%s n=%d type=%d sm=%d\n", htrc("KCOL(%p) Init: col=%s n=%d type=%d sm=%d\n",
this, colp->GetName(), n, colp->GetResultType(), sm); this, colp->GetName(), n, colp->GetResultType(), sm);
#endif
// Allocate the Value object used when moving items // Allocate the Value object used when moving items
Type = colp->GetResultType(); Type = colp->GetResultType();
...@@ -2822,10 +2814,9 @@ BYTE* KXYCOL::MapInit(PGLOBAL g, PCOL colp, int *n, BYTE *m) ...@@ -2822,10 +2814,9 @@ BYTE* KXYCOL::MapInit(PGLOBAL g, PCOL colp, int *n, BYTE *m)
Type = colp->GetResultType(); Type = colp->GetResultType();
#ifdef DEBTRACE if (trace)
htrc("MapInit(%p): colp=%p type=%d n=%d len=%d m=%p\n", htrc("MapInit(%p): colp=%p type=%d n=%d len=%d m=%p\n",
this, colp, Type, n[0], len, m); this, colp, Type, n[0], len, m);
#endif
// Allocate the Value object used when moving items // Allocate the Value object used when moving items
Valp = AllocateValue(g, Type, len, prec, false, NULL); Valp = AllocateValue(g, Type, len, prec, false, NULL);
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment