database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-08-08 11:22:35 +03:00
Code Activity

- Resolving conflicts

Browse Source 
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/filamtxt.cpp
  storage/connect/filamzip.cpp
  storage/connect/ha_connect.cc
  storage/connect/mycat.cc
  storage/connect/myconn.cpp
  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
This commit is contained in:
Olivier Bertrand
2014-03-22 08:57:32 +01:00
parent 7b400a088d 31560c448a
commit 81ce7da7a7
28 changed files with 19075 additions and 19287 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
storage/connect/block.h
View File

@@ -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

26
storage/connect/colblk.cpp
View File

@@ -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. */
/***********************************************************************/ /***********************************************************************/
@@ -76,9 +78,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
@@ -116,10 +117,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
@@ -130,9 +130,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())
@@ -168,10 +167,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

1794
storage/connect/connect.cc
View File

File diff suppressed because it is too large Load Diff

4
storage/connect/csort.h
View File

@@ -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;

59
storage/connect/filamap.cpp
View File

@@ -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)
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
@@ -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)
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
@@ -383,20 +383,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
htrc("Fpos placed at file top=%p\n", Fpos); if (trace)
#endif htrc("Fpos placed at file top=%p\n", Fpos);
} // endif irc } // endif irc
if (Tpos == Spos) if (Tpos == Spos)
@@ -412,17 +411,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
/*******************************************************************/ /*******************************************************************/
@@ -450,9 +448,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),
@@ -484,10 +481,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
/***********************************************************************/ /***********************************************************************/

19
storage/connect/filamdbf.cpp
View File

@@ -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)
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

213
storage/connect/filamfix.cpp
View File

@@ -52,6 +52,7 @@
#define INVALID_SET_FILE_POINTER 0xFFFFFFFF #define INVALID_SET_FILE_POINTER 0xFFFFFFFF
#endif #endif
extern "C" int trace;
extern int num_read, num_there, num_eq[2]; // Statistics extern int num_read, num_there, num_eq[2]; // Statistics
/* --------------------------- Class FIXFAM -------------------------- */ /* --------------------------- Class FIXFAM -------------------------- */
@@ -241,9 +242,8 @@ int FIXFAM::ReadBuffer(PGLOBAL g)
return RC_FX; return RC_FX;
} // endif fseek } // endif fseek
#ifdef DEBTRACE if (trace > 1)
htrc("File position is now %d\n", ftell(Stream)); htrc("File position is now %d\n", ftell(Stream));
#endif
//long tell = ftell(Stream); not used //long tell = ftell(Stream); not used
@@ -266,9 +266,9 @@ int FIXFAM::ReadBuffer(PGLOBAL g)
sprintf(g->Message, MSG(READ_ERROR), To_File, _strerror(NULL)); sprintf(g->Message, MSG(READ_ERROR), To_File, _strerror(NULL));
#endif #endif
#ifdef DEBTRACE if (trace)
htrc("%s\n", g->Message); htrc("%s\n", g->Message);
#endif
return RC_FX; return RC_FX;
} // endelse } // endelse
@@ -283,11 +283,9 @@ int FIXFAM::ReadBuffer(PGLOBAL g)
/***********************************************************************/ /***********************************************************************/
int FIXFAM::WriteBuffer(PGLOBAL g) int FIXFAM::WriteBuffer(PGLOBAL g)
{ {
#ifdef DEBTRACE if (trace > 1)
fprintf(debug, htrc("FIX WriteDB: Mode=%d buf=%p line=%p Nrec=%d Rbuf=%d CurNum=%d\n",
"FIX WriteDB: Mode=%d buf=%p line=%p Nrec=%d Rbuf=%d CurNum=%d\n", Tdbp->GetMode(), To_Buf, Tdbp->GetLine(), Nrec, Rbuf, CurNum);
Tdbp->GetMode(), To_Buf, Tdbp->GetLine(), Nrec, Rbuf, CurNum);
#endif
if (Tdbp->GetMode() == MODE_INSERT) { if (Tdbp->GetMode() == MODE_INSERT) {
/*******************************************************************/ /*******************************************************************/
@@ -298,9 +296,8 @@ int FIXFAM::WriteBuffer(PGLOBAL g)
return RC_OK; // We write only full blocks return RC_OK; // We write only full blocks
} // endif CurNum } // endif CurNum
#ifdef DEBTRACE if (trace > 1)
htrc(" First line is '%.*s'\n", Lrecl - 2, To_Buf); htrc(" First line is '%.*s'\n", Lrecl - 2, To_Buf);
#endif
// Now start the writing process. // Now start the writing process.
if (fwrite(To_Buf, Lrecl, Rbuf, Stream) != (size_t)Rbuf) { if (fwrite(To_Buf, Lrecl, Rbuf, Stream) != (size_t)Rbuf) {
@@ -313,9 +310,8 @@ int FIXFAM::WriteBuffer(PGLOBAL g)
CurNum = 0; CurNum = 0;
Tdbp->SetLine(To_Buf); Tdbp->SetLine(To_Buf);
#ifdef DEBTRACE if (trace > 1)
htrc("write done\n"); htrc("write done\n");
#endif
} else { // Mode == MODE_UPDATE } else { // Mode == MODE_UPDATE
// T_Stream is the temporary stream or the table file stream itself // T_Stream is the temporary stream or the table file stream itself
@@ -353,20 +349,19 @@ int FIXFAM::DeleteRecords(PGLOBAL g, int irc)
/* file, and at the end erase all trailing records. */ /* file, and at the end erase all trailing records. */
/* This will be experimented. */ /* This will be experimented. */
/*********************************************************************/ /*********************************************************************/
#ifdef DEBTRACE if (trace > 1)
fprintf(debug, htrc("DOS DeleteDB: rc=%d UseTemp=%d Fpos=%d Tpos=%d Spos=%d\n",
"DOS DeleteDB: rc=%d UseTemp=%d Fpos=%d Tpos=%d Spos=%d\n", irc, UseTemp, Fpos, Tpos, Spos);
irc, UseTemp, Fpos, Tpos, Spos);
#endif
if (irc != RC_OK) { if (irc != RC_OK) {
/*******************************************************************/ /*******************************************************************/
/* EOF: position Fpos at the end-of-file position. */ /* EOF: position Fpos at the end-of-file position. */
/*******************************************************************/ /*******************************************************************/
Fpos = Tdbp->Cardinality(g); Fpos = Tdbp->Cardinality(g);
#ifdef DEBTRACE
htrc("Fpos placed at file end=%d\n", Fpos); if (trace > 1)
#endif htrc("Fpos placed at file end=%d\n", Fpos);
} else // Fpos is the deleted line position } else // Fpos is the deleted line position
Fpos = CurBlk * Nrec + CurNum; Fpos = CurBlk * Nrec + CurNum;
@@ -414,9 +409,8 @@ int FIXFAM::DeleteRecords(PGLOBAL g, int irc)
OldBlk = -2; // To force fseek to be executed on next block OldBlk = -2; // To force fseek to be executed on next block
} // endif moved } // endif moved
#ifdef DEBTRACE if (trace > 1)
htrc("after: Tpos=%d Spos=%d\n", Tpos, Spos); htrc("after: Tpos=%d Spos=%d\n", Tpos, Spos);
#endif
} else { } else {
/*******************************************************************/ /*******************************************************************/
@@ -464,9 +458,9 @@ int FIXFAM::DeleteRecords(PGLOBAL g, int irc)
close(h); close(h);
#ifdef DEBTRACE if (trace > 1)
htrc("done, h=%d irc=%d\n", h, irc); htrc("done, h=%d irc=%d\n", h, irc);
#endif
} // endif UseTemp } // endif UseTemp
} // endif irc } // endif irc
@@ -496,9 +490,8 @@ bool FIXFAM::MoveIntermediateLines(PGLOBAL g, bool *b)
req = (size_t)min(n, Dbflen); req = (size_t)min(n, Dbflen);
len = fread(DelBuf, Lrecl, req, Stream); len = fread(DelBuf, Lrecl, req, Stream);
#ifdef DEBTRACE if (trace > 1)
htrc("after read req=%d len=%d\n", req, len); htrc("after read req=%d len=%d\n", req, len);
#endif
if (len != req) { if (len != req) {
sprintf(g->Message, MSG(DEL_READ_ERROR), (int) req, (int) len); sprintf(g->Message, MSG(DEL_READ_ERROR), (int) req, (int) len);
@@ -516,16 +509,14 @@ bool FIXFAM::MoveIntermediateLines(PGLOBAL g, bool *b)
return true; return true;
} // endif } // endif
#ifdef DEBTRACE if (trace > 1)
htrc("after write pos=%d\n", ftell(Stream)); htrc("after write pos=%d\n", ftell(Stream));
#endif
Tpos += (int)req; Tpos += (int)req;
Spos += (int)req; Spos += (int)req;
#ifdef DEBTRACE if (trace > 1)
htrc("loop: Tpos=%d Spos=%d\n", Tpos, Spos); htrc("loop: Tpos=%d Spos=%d\n", Tpos, Spos);
#endif
*b = true; *b = true;
} // endfor n } // endfor n
@@ -574,10 +565,10 @@ void FIXFAM::CloseTableFile(PGLOBAL g)
rc = PlugCloseFile(g, To_Fb); rc = PlugCloseFile(g, To_Fb);
fin: fin:
#ifdef DEBTRACE if (trace)
htrc("FIX CloseTableFile: closing %s mode=%d wrc=%d rc=%d\n", htrc("FIX 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
@@ -641,9 +632,8 @@ int BGXFAM::BigRead(PGLOBAL g, HANDLE h, void *inbuf, int req)
DWORD nbr, drc, len = (DWORD)req; DWORD nbr, drc, len = (DWORD)req;
bool brc = ReadFile(h, inbuf, len, &nbr, NULL); bool brc = ReadFile(h, inbuf, len, &nbr, NULL);
#ifdef DEBTRACE if (trace > 1)
htrc("after read req=%d brc=%d nbr=%d\n", req, brc, nbr); htrc("after read req=%d brc=%d nbr=%d\n", req, brc, nbr);
#endif
if (!brc) { if (!brc) {
char buf[256]; // , *fn = (h == Hfile) ? To_File : "Tempfile"; char buf[256]; // , *fn = (h == Hfile) ? To_File : "Tempfile";
@@ -653,9 +643,10 @@ int BGXFAM::BigRead(PGLOBAL g, HANDLE h, void *inbuf, int req)
FORMAT_MESSAGE_IGNORE_INSERTS, NULL, drc, 0, FORMAT_MESSAGE_IGNORE_INSERTS, NULL, drc, 0,
(LPTSTR)buf, sizeof(buf), NULL); (LPTSTR)buf, sizeof(buf), NULL);
sprintf(g->Message, MSG(READ_ERROR), To_File, buf); sprintf(g->Message, MSG(READ_ERROR), To_File, buf);
#ifdef DEBTRACE
htrc("BIGREAD: %s\n", g->Message); if (trace > 1)
#endif htrc("BIGREAD: %s\n", g->Message);
rc = -1; rc = -1;
} else } else
rc = (int)nbr; rc = (int)nbr;
@@ -680,9 +671,8 @@ bool BGXFAM::BigWrite(PGLOBAL g, HANDLE h, void *inbuf, int req)
DWORD nbw, drc, len = (DWORD)req; DWORD nbw, drc, len = (DWORD)req;
bool brc = WriteFile(h, inbuf, len, &nbw, NULL); bool brc = WriteFile(h, inbuf, len, &nbw, NULL);
#ifdef DEBTRACE if (trace > 1)
htrc("after write req=%d brc=%d nbw=%d\n", req, brc, nbw); htrc("after write req=%d brc=%d nbw=%d\n", req, brc, nbw);
#endif
if (!brc || nbw != len) { if (!brc || nbw != len) {
char buf[256], *fn = (h == Hfile) ? To_File : "Tempfile"; char buf[256], *fn = (h == Hfile) ? To_File : "Tempfile";
@@ -698,10 +688,10 @@ bool BGXFAM::BigWrite(PGLOBAL g, HANDLE h, void *inbuf, int req)
sprintf(g->Message, MSG(WRITE_STRERROR), fn, buf); sprintf(g->Message, MSG(WRITE_STRERROR), fn, buf);
#ifdef DEBTRACE if (trace > 1)
htrc("BIGWRITE: nbw=%d len=%d errno=%d %s\n", htrc("BIGWRITE: nbw=%d len=%d errno=%d %s\n",
nbw, len, drc, g->Message); nbw, len, drc, g->Message);
#endif
rc = true; rc = true;
} // endif brc || nbw } // endif brc || nbw
#else // !WIN32 #else // !WIN32
@@ -712,10 +702,11 @@ bool BGXFAM::BigWrite(PGLOBAL g, HANDLE h, void *inbuf, int req)
const char *fn = (h == Hfile) ? To_File : "Tempfile"; const char *fn = (h == Hfile) ? To_File : "Tempfile";
sprintf(g->Message, MSG(WRITE_STRERROR), fn, strerror(errno)); sprintf(g->Message, MSG(WRITE_STRERROR), fn, strerror(errno));
#ifdef DEBTRACE
htrc("BIGWRITE: nbw=%d len=%d errno=%d %s\n", if (trace > 1)
nbw, len, errno, g->Message); htrc("BIGWRITE: nbw=%d len=%d errno=%d %s\n",
#endif nbw, len, errno, g->Message);
rc = true; rc = true;
} // endif nbr } // endif nbr
#endif // !WIN32 #endif // !WIN32
@@ -750,9 +741,8 @@ bool BGXFAM::OpenTableFile(PGLOBAL g)
PlugSetPath(filename, To_File, Tdbp->GetPath()); PlugSetPath(filename, To_File, Tdbp->GetPath());
#ifdef DEBTRACE if (trace)
htrc("OpenTableFile: filename=%s mode=%d\n", filename, mode); htrc("OpenTableFile: filename=%s mode=%d\n", filename, mode);
#endif
#if defined(WIN32) #if defined(WIN32)
DWORD rc, access, creation, share = 0; DWORD rc, access, creation, share = 0;
@@ -811,11 +801,9 @@ bool BGXFAM::OpenTableFile(PGLOBAL g)
} else } else
rc = 0; rc = 0;
#ifdef DEBTRACE if (trace > 1)
fprintf(debug, htrc(" rc=%d access=%p share=%p creation=%d handle=%p fn=%s\n",
" rc=%d access=%p share=%p creation=%d handle=%p fn=%s\n", rc, access, share, creation, Hfile, filename);
rc, access, share, creation, Hfile, filename);
#endif
if (mode == MODE_INSERT) if (mode == MODE_INSERT)
/*******************************************************************/ /*******************************************************************/
@@ -866,10 +854,9 @@ bool BGXFAM::OpenTableFile(PGLOBAL g)
} else } else
rc = 0; rc = 0;
#ifdef DEBTRACE if (trace > 1)
htrc(" rc=%d oflag=%p tmode=%p handle=%p fn=%s\n", htrc(" rc=%d oflag=%p tmode=%p handle=%p fn=%s\n",
rc, oflag, tmode, Hfile, filename); rc, oflag, tmode, Hfile, filename);
#endif
#endif // UNIX #endif // UNIX
@@ -951,14 +938,13 @@ int BGXFAM::Cardinality(PGLOBAL g)
if (Hfile == INVALID_HANDLE_VALUE) { if (Hfile == INVALID_HANDLE_VALUE) {
int h = open64(filename, O_RDONLY, 0); int h = open64(filename, O_RDONLY, 0);
#ifdef DEBTRACE if (trace)
htrc(" h=%d\n", h); htrc(" h=%d\n", h);
#endif
if (h == INVALID_HANDLE_VALUE) { if (h == INVALID_HANDLE_VALUE) {
#ifdef DEBTRACE if (trace)
htrc(" errno=%d ENOENT=%d\n", errno, ENOENT); htrc(" errno=%d ENOENT=%d\n", errno, ENOENT);
#endif
if (errno != ENOENT) { if (errno != ENOENT) {
sprintf(g->Message, MSG(OPEN_ERROR_IS), sprintf(g->Message, MSG(OPEN_ERROR_IS),
filename, strerror(errno)); filename, strerror(errno));
@@ -1000,10 +986,9 @@ int BGXFAM::Cardinality(PGLOBAL g)
} else } else
card = (int)(fsize / (BIGINT)Lrecl); // Fixed length file card = (int)(fsize / (BIGINT)Lrecl); // Fixed length file
#ifdef DEBTRACE if (trace)
htrc(" Computed max_K=%d fsize=%lf lrecl=%d\n", htrc(" Computed max_K=%d fsize=%lf lrecl=%d\n",
card, (double)fsize, Lrecl); card, (double)fsize, Lrecl);
#endif
// Set number of blocks for later use // Set number of blocks for later use
Block = (card + Nrec - 1) / Nrec; Block = (card + Nrec - 1) / Nrec;
@@ -1101,9 +1086,8 @@ int BGXFAM::ReadBuffer(PGLOBAL g)
if (BigSeek(g, Hfile, (BIGINT)Fpos * (BIGINT)Lrecl)) if (BigSeek(g, Hfile, (BIGINT)Fpos * (BIGINT)Lrecl))
return RC_FX; return RC_FX;
#ifdef DEBTRACE if (trace > 1)
htrc("File position is now %d\n", Fpos); htrc("File position is now %d\n", Fpos);
#endif
nbr = BigRead(g, Hfile, To_Buf, (Padded) ? Blksize : Lrecl * Nrec); nbr = BigRead(g, Hfile, To_Buf, (Padded) ? Blksize : Lrecl * Nrec);
@@ -1126,11 +1110,9 @@ int BGXFAM::ReadBuffer(PGLOBAL g)
/***********************************************************************/ /***********************************************************************/
int BGXFAM::WriteBuffer(PGLOBAL g) int BGXFAM::WriteBuffer(PGLOBAL g)
{ {
#ifdef DEBTRACE if (trace > 1)
fprintf(debug, htrc("BIG WriteDB: Mode=%d buf=%p line=%p Nrec=%d Rbuf=%d CurNum=%d\n",
"BIG WriteDB: Mode=%d buf=%p line=%p Nrec=%d Rbuf=%d CurNum=%d\n", Tdbp->GetMode(), To_Buf, Tdbp->GetLine(), Nrec, Rbuf, CurNum);
Tdbp->GetMode(), To_Buf, Tdbp->GetLine(), Nrec, Rbuf, CurNum);
#endif
if (Tdbp->GetMode() == MODE_INSERT) { if (Tdbp->GetMode() == MODE_INSERT) {
/*******************************************************************/ /*******************************************************************/
@@ -1141,9 +1123,8 @@ int BGXFAM::WriteBuffer(PGLOBAL g)
return RC_OK; // We write only full blocks return RC_OK; // We write only full blocks
} // endif CurNum } // endif CurNum
#ifdef DEBTRACE if (trace > 1)
htrc(" First line is '%.*s'\n", Lrecl - 2, To_Buf); htrc(" First line is '%.*s'\n", Lrecl - 2, To_Buf);
#endif
// Now start the writing process. // Now start the writing process.
if (BigWrite(g, Hfile, To_Buf, Lrecl * Rbuf)) if (BigWrite(g, Hfile, To_Buf, Lrecl * Rbuf))
@@ -1153,9 +1134,8 @@ int BGXFAM::WriteBuffer(PGLOBAL g)
CurNum = 0; CurNum = 0;
Tdbp->SetLine(To_Buf); Tdbp->SetLine(To_Buf);
#ifdef DEBTRACE if (trace > 1)
htrc("write done\n"); htrc("write done\n");
#endif
} else { // Mode == MODE_UPDATE } else { // Mode == MODE_UPDATE
// Tfile is the temporary file or the table file handle itself // Tfile is the temporary file or the table file handle itself
@@ -1190,20 +1170,19 @@ int BGXFAM::DeleteRecords(PGLOBAL g, int irc)
/* file, and at the end erase all trailing records. */ /* file, and at the end erase all trailing records. */
/* This will be experimented. */ /* This will be experimented. */
/*********************************************************************/ /*********************************************************************/
#ifdef DEBTRACE if (trace > 1)
fprintf(debug, htrc("BGX DeleteDB: rc=%d UseTemp=%d Fpos=%d Tpos=%d Spos=%d\n",
"BGX DeleteDB: rc=%d UseTemp=%d Fpos=%d Tpos=%d Spos=%d\n", irc, UseTemp, Fpos, Tpos, Spos);
irc, UseTemp, Fpos, Tpos, Spos);
#endif
if (irc != RC_OK) { if (irc != RC_OK) {
/*******************************************************************/ /*******************************************************************/
/* EOF: position Fpos at the end-of-file position. */ /* EOF: position Fpos at the end-of-file position. */
/*******************************************************************/ /*******************************************************************/
Fpos = Tdbp->Cardinality(g); Fpos = Tdbp->Cardinality(g);
#ifdef DEBTRACE
htrc("Fpos placed at file end=%d\n", Fpos); if (trace > 1)
#endif htrc("Fpos placed at file end=%d\n", Fpos);
} else // Fpos is the deleted line position } else // Fpos is the deleted line position
Fpos = CurBlk * Nrec + CurNum; Fpos = CurBlk * Nrec + CurNum;
@@ -1239,9 +1218,9 @@ int BGXFAM::DeleteRecords(PGLOBAL g, int irc)
return RC_FX; return RC_FX;
if (irc == RC_OK) { if (irc == RC_OK) {
#ifdef DEBTRACE if (trace)
assert(Spos == Fpos); assert(Spos == Fpos);
#endif
Spos++; // New start position is on next line Spos++; // New start position is on next line
if (moved) { if (moved) {
@@ -1251,9 +1230,8 @@ int BGXFAM::DeleteRecords(PGLOBAL g, int irc)
OldBlk = -2; // To force fseek to be executed on next block OldBlk = -2; // To force fseek to be executed on next block
} // endif moved } // endif moved
#ifdef DEBTRACE if (trace > 1)
htrc("after: Tpos=%d Spos=%d\n", Tpos, Spos); htrc("after: Tpos=%d Spos=%d\n", Tpos, Spos);
#endif
} else { } else {
/*******************************************************************/ /*******************************************************************/
@@ -1385,9 +1363,8 @@ bool BGXFAM::MoveIntermediateLines(PGLOBAL g, bool *b)
Tpos += (int)req; Tpos += (int)req;
Spos += (int)req; Spos += (int)req;
#ifdef DEBTRACE if (trace > 1)
htrc("loop: Tpos=%d Spos=%d\n", Tpos, Spos); htrc("loop: Tpos=%d Spos=%d\n", Tpos, Spos);
#endif
*b = true; *b = true;
} // endfor n } // endfor n
@@ -1435,10 +1412,10 @@ void BGXFAM::CloseTableFile(PGLOBAL g)
rc = PlugCloseFile(g, To_Fb); rc = PlugCloseFile(g, To_Fb);
fin: fin:
#ifdef DEBTRACE if (trace)
htrc("BGX CloseTableFile: closing %s mode=%d wrc=%d rc=%d\n", htrc("BGX CloseTableFile: closing %s mode=%d wrc=%d rc=%d\n",
To_File, mode, wrc, rc); To_File, mode, wrc, rc);
#endif
Hfile = INVALID_HANDLE_VALUE; // So we can know whether table is open Hfile = INVALID_HANDLE_VALUE; // So we can know whether table is open
} // end of CloseTableFile } // end of CloseTableFile

2886
storage/connect/filamtxt.cpp
View File

File diff suppressed because it is too large Load Diff

2807
storage/connect/filamzip.cpp
View File

File diff suppressed because it is too large Load Diff

11374
storage/connect/ha_connect.cc
View File

File diff suppressed because it is too large Load Diff

12
storage/connect/mycat.cc
View File

@@ -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)
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)
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)
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)
} // 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);

11
storage/connect/myconn.cpp
View File

@@ -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)
/***********************************************************************/ /***********************************************************************/
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)
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)
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;

32
storage/connect/myutil.cpp
View File

@@ -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)
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)
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)
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

6
storage/connect/osutil.c
View File

@@ -78,8 +78,8 @@ 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
if (drive) *drive = '\0'; 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); 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 */

1
storage/connect/plgdbsem.h
View File

@@ -531,6 +531,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)

192
storage/connect/plgdbutl.cpp
View File

@@ -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;
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)
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.
@@ -418,138 +380,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, */
@@ -1459,19 +1292,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
@@ -1482,10 +1313,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)
htrc("Done memp=%p used=%d free=%d\n", if (trace > 1)
memp, pph->To_Free, pph->FreeBlk); htrc("Done memp=%p used=%d free=%d\n",
#endif memp, pph->To_Free, pph->FreeBlk);
return (memp); return (memp);
} // end of PlgDBSubAlloc } // end of PlgDBSubAlloc

1097
storage/connect/plugutil.c
View File

File diff suppressed because it is too large Load Diff

868
storage/connect/reldef.cpp
View File

@@ -1,436 +1,432 @@
/************* RelDef CPP Program Source Code File (.CPP) **************/ /************* RelDef CPP Program Source Code File (.CPP) **************/
/* PROGRAM NAME: REFDEF */ /* PROGRAM NAME: REFDEF */
/* ------------- */ /* ------------- */
/* Version 1.4 */ /* Version 1.4 */
/* */ /* */
/* COPYRIGHT: */ /* COPYRIGHT: */
/* ---------- */ /* ---------- */
/* (C) Copyright to the author Olivier BERTRAND 2004-2014 */ /* (C) Copyright to the author Olivier BERTRAND 2004-2014 */
/* */ /* */
/* WHAT THIS PROGRAM DOES: */ /* WHAT THIS PROGRAM DOES: */
/* ----------------------- */ /* ----------------------- */
/* This program are the DB definition related routines. */ /* This program are the DB definition related routines. */
/* */ /* */
/***********************************************************************/ /***********************************************************************/
/***********************************************************************/ /***********************************************************************/
/* Include relevant MariaDB header file. */ /* Include relevant MariaDB header file. */
/***********************************************************************/ /***********************************************************************/
#include "my_global.h" #include "my_global.h"
#if defined(WIN32) #if defined(WIN32)
#include <sqlext.h> #include <sqlext.h>
#else #else
#include <dlfcn.h> // dlopen(), dlclose(), dlsym() ... #include <dlfcn.h> // dlopen(), dlclose(), dlsym() ...
#include "osutil.h" #include "osutil.h"
//#include "sqlext.h" //#include "sqlext.h"
#endif #endif
/***********************************************************************/ /***********************************************************************/
/* Include application header files */ /* Include application header files */
/* */ /* */
/* global.h is header containing all global declarations. */ /* global.h is header containing all global declarations. */
/* plgdbsem.h is header containing DB application declarations. */ /* plgdbsem.h is header containing DB application declarations. */
/* catalog.h is header containing DB description declarations. */ /* catalog.h is header containing DB description declarations. */
/***********************************************************************/ /***********************************************************************/
#include "global.h" #include "global.h"
#include "plgdbsem.h" #include "plgdbsem.h"
#include "mycat.h" #include "mycat.h"
#include "reldef.h" #include "reldef.h"
#include "colblk.h" #include "colblk.h"
#include "filamap.h" #include "filamap.h"
#include "filamfix.h" #include "filamfix.h"
#include "filamvct.h" #include "filamvct.h"
#if defined(ZIP_SUPPORT) #if defined(ZIP_SUPPORT)
#include "filamzip.h" #include "filamzip.h"
#endif // ZIP_SUPPORT #endif // ZIP_SUPPORT
#include "tabdos.h" #include "tabdos.h"
#include "valblk.h" #include "valblk.h"
#include "tabmul.h" #include "tabmul.h"
/***********************************************************************/
/* External static variables. */ /* --------------------------- Class RELDEF -------------------------- */
/***********************************************************************/
//extern "C" char plgini[]; /***********************************************************************/
/* RELDEF Constructor. */
/* --------------------------- Class RELDEF -------------------------- */ /***********************************************************************/
RELDEF::RELDEF(void)
/***********************************************************************/ {
/* RELDEF Constructor. */ Next = NULL;
/***********************************************************************/ To_Cols = NULL;
RELDEF::RELDEF(void) Name = NULL;
{ Database = NULL;
Next = NULL; Cat = NULL;
To_Cols = NULL; } // end of RELDEF constructor
Name = NULL;
Database = NULL; /* --------------------------- Class TABDEF -------------------------- */
Cat = NULL;
} // end of RELDEF constructor /***********************************************************************/
/* TABDEF Constructor. */
/* --------------------------- Class TABDEF -------------------------- */ /***********************************************************************/
TABDEF::TABDEF(void)
/***********************************************************************/ {
/* TABDEF Constructor. */ Schema = NULL;
/***********************************************************************/ Desc = NULL;
TABDEF::TABDEF(void) Catfunc = FNC_NO;
{ Card = 0;
Schema = NULL; Elemt = 0;
Desc = NULL; Sort = 0;
Catfunc = FNC_NO; Multiple = 0;
Card = 0; Degree = 0;
Elemt = 0; Pseudo = 0;
Sort = 0; Read_Only = false;
Multiple = 0; } // end of TABDEF constructor
Degree = 0;
Pseudo = 0; /***********************************************************************/
Read_Only = false; /* Define: initialize the table definition block from XDB file. */
} // end of TABDEF constructor /***********************************************************************/
bool TABDEF::Define(PGLOBAL g, PCATLG cat, LPCSTR name, LPCSTR am)
/***********************************************************************/ {
/* Define: initialize the table definition block from XDB file. */ int poff = 0;
/***********************************************************************/
bool TABDEF::Define(PGLOBAL g, PCATLG cat, LPCSTR name, LPCSTR am) Name = (PSZ)PlugSubAlloc(g, NULL, strlen(name) + 1);
{ strcpy(Name, name);
int poff = 0; Cat = cat;
Catfunc = GetFuncID(Cat->GetStringCatInfo(g, "Catfunc", NULL));
Name = (PSZ)PlugSubAlloc(g, NULL, strlen(name) + 1); Elemt = cat->GetIntCatInfo("Elements", 0);
strcpy(Name, name); Multiple = cat->GetIntCatInfo("Multiple", 0);
Cat = cat; Degree = cat->GetIntCatInfo("Degree", 0);
Catfunc = GetFuncID(Cat->GetStringCatInfo(g, "Catfunc", NULL)); Read_Only = cat->GetBoolCatInfo("ReadOnly", false);
Elemt = cat->GetIntCatInfo("Elements", 0); const char *data_charset_name= cat->GetStringCatInfo(g, "Data_charset", NULL);
Multiple = cat->GetIntCatInfo("Multiple", 0); m_data_charset= data_charset_name ?
Degree = cat->GetIntCatInfo("Degree", 0); get_charset_by_csname(data_charset_name, MY_CS_PRIMARY, 0):
Read_Only = cat->GetBoolCatInfo("ReadOnly", false); NULL;
const char *data_charset_name= cat->GetStringCatInfo(g, "Data_charset", NULL);
m_data_charset= data_charset_name ? // Get The column definitions
get_charset_by_csname(data_charset_name, MY_CS_PRIMARY, 0): if ((poff = cat->GetColCatInfo(g, this)) < 0)
NULL; return true;
// Get The column definitions // Do the definition of AM specific fields
if ((poff = cat->GetColCatInfo(g, this)) < 0) return DefineAM(g, am, poff);
return true; } // end of Define
// Do the definition of AM specific fields /* --------------------------- Class OEMDEF -------------------------- */
return DefineAM(g, am, poff);
} // end of Define /***********************************************************************/
/* GetXdef: get the external TABDEF from OEM module. */
/* --------------------------- Class OEMDEF -------------------------- */ /***********************************************************************/
PTABDEF OEMDEF::GetXdef(PGLOBAL g)
/***********************************************************************/ {
/* GetXdef: get the external TABDEF from OEM module. */ typedef PTABDEF (__stdcall *XGETDEF) (PGLOBAL, void *);
/***********************************************************************/ char c, getname[40] = "Get";
PTABDEF OEMDEF::GetXdef(PGLOBAL g) PTABDEF xdefp;
{ XGETDEF getdef = NULL;
typedef PTABDEF (__stdcall *XGETDEF) (PGLOBAL, void *); PCATLG cat = Cat;
char c, getname[40] = "Get";
PTABDEF xdefp; #if defined(WIN32)
XGETDEF getdef = NULL; // Is the DLL already loaded?
PCATLG cat = Cat; if (!Hdll && !(Hdll = GetModuleHandle(Module)))
// No, load the Dll implementing the function
#if defined(WIN32) if (!(Hdll = LoadLibrary(Module))) {
// Is the DLL already loaded? char buf[256];
if (!Hdll && !(Hdll = GetModuleHandle(Module))) DWORD rc = GetLastError();
// No, load the Dll implementing the function
if (!(Hdll = LoadLibrary(Module))) { sprintf(g->Message, MSG(DLL_LOAD_ERROR), rc, Module);
char buf[256]; FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
DWORD rc = GetLastError(); FORMAT_MESSAGE_IGNORE_INSERTS, NULL, rc, 0,
(LPTSTR)buf, sizeof(buf), NULL);
sprintf(g->Message, MSG(DLL_LOAD_ERROR), rc, Module); strcat(strcat(g->Message, ": "), buf);
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | return NULL;
FORMAT_MESSAGE_IGNORE_INSERTS, NULL, rc, 0, } // endif hDll
(LPTSTR)buf, sizeof(buf), NULL);
strcat(strcat(g->Message, ": "), buf); // The exported name is always in uppercase
return NULL; for (int i = 0; ; i++) {
} // endif hDll c = Subtype[i];
getname[i + 3] = toupper(c);
// The exported name is always in uppercase if (!c) break;
for (int i = 0; ; i++) { } // endfor i
c = Subtype[i];
getname[i + 3] = toupper(c); // Get the function returning an instance of the external DEF class
if (!c) break; if (!(getdef = (XGETDEF)GetProcAddress((HINSTANCE)Hdll, getname))) {
} // endfor i sprintf(g->Message, MSG(PROCADD_ERROR), GetLastError(), getname);
FreeLibrary((HMODULE)Hdll);
// Get the function returning an instance of the external DEF class return NULL;
if (!(getdef = (XGETDEF)GetProcAddress((HINSTANCE)Hdll, getname))) { } // endif getdef
sprintf(g->Message, MSG(PROCADD_ERROR), GetLastError(), getname); #else // !WIN32
FreeLibrary((HMODULE)Hdll); const char *error = NULL;
return NULL; // Is the library already loaded?
} // endif getdef // if (!Hdll && !(Hdll = ???))
#else // !WIN32 // Load the desired shared library
const char *error = NULL; if (!(Hdll = dlopen(Module, RTLD_LAZY))) {
// Is the library already loaded? error = dlerror();
// if (!Hdll && !(Hdll = ???)) sprintf(g->Message, MSG(SHARED_LIB_ERR), Module, SVP(error));
// Load the desired shared library return NULL;
if (!(Hdll = dlopen(Module, RTLD_LAZY))) { } // endif Hdll
error = dlerror();
sprintf(g->Message, MSG(SHARED_LIB_ERR), Module, SVP(error)); // The exported name is always in uppercase
return NULL; for (int i = 0; ; i++) {
} // endif Hdll c = Subtype[i];
getname[i + 3] = toupper(c);
// The exported name is always in uppercase if (!c) break;
for (int i = 0; ; i++) { } // endfor i
c = Subtype[i];
getname[i + 3] = toupper(c); // Get the function returning an instance of the external DEF class
if (!c) break; if (!(getdef = (XGETDEF)dlsym(Hdll, getname))) {
} // endfor i error = dlerror();
sprintf(g->Message, MSG(GET_FUNC_ERR), getname, SVP(error));
// Get the function returning an instance of the external DEF class dlclose(Hdll);
if (!(getdef = (XGETDEF)dlsym(Hdll, getname))) { return NULL;
error = dlerror(); } // endif getdef
sprintf(g->Message, MSG(GET_FUNC_ERR), getname, SVP(error)); #endif // !WIN32
dlclose(Hdll);
return NULL; // Just in case the external Get function does not set error messages
} // endif getdef sprintf(g->Message, MSG(DEF_ALLOC_ERROR), Subtype);
#endif // !WIN32
// Get the table definition block
// Just in case the external Get function does not set error messages if (!(xdefp = getdef(g, NULL)))
sprintf(g->Message, MSG(DEF_ALLOC_ERROR), Subtype); return NULL;
// Get the table definition block // Have the external class do its complete definition
if (!(xdefp = getdef(g, NULL))) if (!cat->Cbuf) {
return NULL; // Suballocate a temporary buffer for the entire column section
cat->Cblen = cat->GetSizeCatInfo("Colsize", "8K");
// Have the external class do its complete definition cat->Cbuf = (char*)PlugSubAlloc(g, NULL, cat->Cblen);
if (!cat->Cbuf) { } // endif Cbuf
// Suballocate a temporary buffer for the entire column section
cat->Cblen = cat->GetSizeCatInfo("Colsize", "8K"); // Here "OEM" should be replace by a more useful value
cat->Cbuf = (char*)PlugSubAlloc(g, NULL, cat->Cblen); if (xdefp->Define(g, cat, Name, "OEM"))
} // endif Cbuf return NULL;
// Here "OEM" should be replace by a more useful value // Ok, return external block
if (xdefp->Define(g, cat, Name, "OEM")) return xdefp;
return NULL; } // end of GetXdef
// Ok, return external block #if 0
return xdefp; /***********************************************************************/
} // end of GetXdef /* DeleteTableFile: Delete an OEM table file if applicable. */
/***********************************************************************/
#if 0 bool OEMDEF::DeleteTableFile(PGLOBAL g)
/***********************************************************************/ {
/* DeleteTableFile: Delete an OEM table file if applicable. */ if (!Pxdef)
/***********************************************************************/ Pxdef = GetXdef(g);
bool OEMDEF::DeleteTableFile(PGLOBAL g)
{ return (Pxdef) ? Pxdef->DeleteTableFile(g) : true;
if (!Pxdef) } // end of DeleteTableFile
Pxdef = GetXdef(g); #endif // 0
return (Pxdef) ? Pxdef->DeleteTableFile(g) : true; /***********************************************************************/
} // end of DeleteTableFile /* Define: initialize the table definition block from XDB file. */
#endif // 0 /***********************************************************************/
bool OEMDEF::DefineAM(PGLOBAL g, LPCSTR am, int poff)
/***********************************************************************/ {
/* Define: initialize the table definition block from XDB file. */ Module = Cat->GetStringCatInfo(g, "Module", "");
/***********************************************************************/ Subtype = Cat->GetStringCatInfo(g, "Subtype", Module);
bool OEMDEF::DefineAM(PGLOBAL g, LPCSTR am, int poff)
{ if (!*Module)
Module = Cat->GetStringCatInfo(g, "Module", ""); Module = Subtype;
Subtype = Cat->GetStringCatInfo(g, "Subtype", Module);
Desc = (char*)PlugSubAlloc(g, NULL, strlen(Module)
if (!*Module) + strlen(Subtype) + 3);
Module = Subtype; sprintf(Desc, "%s(%s)", Module, Subtype);
return false;
Desc = (char*)PlugSubAlloc(g, NULL, strlen(Module) } // end of DefineAM
+ strlen(Subtype) + 3);
sprintf(Desc, "%s(%s)", Module, Subtype); /***********************************************************************/
return false; /* GetTable: makes a new Table Description Block. */
} // end of DefineAM /***********************************************************************/
PTDB OEMDEF::GetTable(PGLOBAL g, MODE mode)
/***********************************************************************/ {
/* GetTable: makes a new Table Description Block. */ RECFM rfm;
/***********************************************************************/ PTDBASE tdbp = NULL;
PTDB OEMDEF::GetTable(PGLOBAL g, MODE mode)
{ // If define block not here yet, get it now
RECFM rfm; if (!Pxdef && !(Pxdef = GetXdef(g)))
PTDBASE tdbp = NULL; return NULL; // Error
// If define block not here yet, get it now /*********************************************************************/
if (!Pxdef && !(Pxdef = GetXdef(g))) /* Allocate a TDB of the proper type. */
return NULL; // Error /* Column blocks will be allocated only when needed. */
/*********************************************************************/
/*********************************************************************/ if (!(tdbp = (PTDBASE)Pxdef->GetTable(g, mode)))
/* Allocate a TDB of the proper type. */ return NULL;
/* Column blocks will be allocated only when needed. */ else
/*********************************************************************/ rfm = tdbp->GetFtype();
if (!(tdbp = (PTDBASE)Pxdef->GetTable(g, mode)))
return NULL; if (rfm == RECFM_NAF)
else return tdbp;
rfm = tdbp->GetFtype(); else if (rfm == RECFM_OEM) {
if (Multiple)
if (rfm == RECFM_NAF) tdbp = new(g) TDBMUL(tdbp); // No block optimization yet
return tdbp;
else if (rfm == RECFM_OEM) { return tdbp;
if (Multiple) } // endif OEM
tdbp = new(g) TDBMUL(tdbp); // No block optimization yet
/*********************************************************************/
return tdbp; /* The OEM table is based on a file type (currently DOS+ only) */
} // endif OEM /*********************************************************************/
assert (rfm == RECFM_VAR || rfm == RECFM_FIX ||
/*********************************************************************/ rfm == RECFM_BIN || rfm == RECFM_VCT);
/* The OEM table is based on a file type (currently DOS+ only) */
/*********************************************************************/ PTXF txfp = NULL;
assert (rfm == RECFM_VAR || rfm == RECFM_FIX || PDOSDEF defp = (PDOSDEF)Pxdef;
rfm == RECFM_BIN || rfm == RECFM_VCT); bool map = defp->Mapped && mode != MODE_INSERT &&
!(PlgGetUser(g)->UseTemp == TMP_FORCE &&
PTXF txfp = NULL; (mode == MODE_UPDATE || mode == MODE_DELETE));
PDOSDEF defp = (PDOSDEF)Pxdef; int cmpr = defp->Compressed;
bool map = defp->Mapped && mode != MODE_INSERT &&
!(PlgGetUser(g)->UseTemp == TMP_FORCE && /*********************************************************************/
(mode == MODE_UPDATE || mode == MODE_DELETE)); /* Allocate table and file processing class of the proper type. */
int cmpr = defp->Compressed; /* Column blocks will be allocated only when needed. */
/*********************************************************************/
/*********************************************************************/ if (!((PTDBDOS)tdbp)->GetTxfp()) {
/* Allocate table and file processing class of the proper type. */ if (cmpr) {
/* Column blocks will be allocated only when needed. */ #if defined(ZIP_SUPPORT)
/*********************************************************************/ if (cmpr == 1)
if (!((PTDBDOS)tdbp)->GetTxfp()) { txfp = new(g) ZIPFAM(defp);
if (cmpr) { else
#if defined(ZIP_SUPPORT) txfp = new(g) ZLBFAM(defp);
if (cmpr == 1) #else // !ZIP_SUPPORT
txfp = new(g) ZIPFAM(defp); strcpy(g->Message, "Compress not supported");
else return NULL;
txfp = new(g) ZLBFAM(defp); #endif // !ZIP_SUPPORT
#else // !ZIP_SUPPORT } else if (rfm == RECFM_VAR) {
strcpy(g->Message, "Compress not supported"); if (map)
return NULL; txfp = new(g) MAPFAM(defp);
#endif // !ZIP_SUPPORT else
} else if (rfm == RECFM_VAR) { txfp = new(g) DOSFAM(defp);
if (map)
txfp = new(g) MAPFAM(defp); } else if (rfm == RECFM_FIX || rfm == RECFM_BIN) {
else if (map)
txfp = new(g) DOSFAM(defp); txfp = new(g) MPXFAM(defp);
else
} else if (rfm == RECFM_FIX || rfm == RECFM_BIN) { txfp = new(g) FIXFAM(defp);
if (map)
txfp = new(g) MPXFAM(defp); } else if (rfm == RECFM_VCT) {
else assert (Pxdef->GetDefType() == TYPE_AM_VCT);
txfp = new(g) FIXFAM(defp);
if (map)
} else if (rfm == RECFM_VCT) { txfp = new(g) VCMFAM((PVCTDEF)defp);
assert (Pxdef->GetDefType() == TYPE_AM_VCT); else
txfp = new(g) VCTFAM((PVCTDEF)defp);
if (map)
txfp = new(g) VCMFAM((PVCTDEF)defp); } // endif's
else
txfp = new(g) VCTFAM((PVCTDEF)defp); ((PTDBDOS)tdbp)->SetTxfp(txfp);
} // endif Txfp
} // endif's
if (Multiple)
((PTDBDOS)tdbp)->SetTxfp(txfp); tdbp = new(g) TDBMUL(tdbp);
} // endif Txfp
return tdbp;
if (Multiple) } // end of GetTable
tdbp = new(g) TDBMUL(tdbp);
/* --------------------------- Class COLCRT -------------------------- */
return tdbp;
} // end of GetTable /***********************************************************************/
/* COLCRT Constructors. */
/* --------------------------- Class COLCRT -------------------------- */ /***********************************************************************/
COLCRT::COLCRT(PSZ name)
/***********************************************************************/ {
/* COLCRT Constructors. */ Next = NULL;
/***********************************************************************/ Name = name;
COLCRT::COLCRT(PSZ name) Desc = NULL;
{ Decode = NULL;
Next = NULL; Fmt = NULL;
Name = name; Offset = -1;
Desc = NULL; Long = -1;
Decode = NULL; Precision = -1;
Fmt = NULL; Freq = -1;
Offset = -1; Key = -1;
Long = -1; Scale = -1;
Precision = -1; Opt = -1;
Freq = -1; DataType = '*';
Key = -1; } // end of COLCRT constructor for table creation
Scale = -1;
Opt = -1; COLCRT::COLCRT(void)
DataType = '*'; {
} // end of COLCRT constructor for table creation Next = NULL;
Name = NULL;
COLCRT::COLCRT(void) Desc = NULL;
{ Decode = NULL;
Next = NULL; Fmt = NULL;
Name = NULL; Offset = 0;
Desc = NULL; Long = 0;
Decode = NULL; Precision = 0;
Fmt = NULL; Freq = 0;
Offset = 0; Key = 0;
Long = 0; Scale = 0;
Precision = 0; Opt = 0;
Freq = 0; DataType = '*';
Key = 0; } // end of COLCRT constructor for table & view definition
Scale = 0;
Opt = 0; /* --------------------------- Class COLDEF -------------------------- */
DataType = '*';
} // end of COLCRT constructor for table & view definition /***********************************************************************/
/* COLDEF Constructor. */
/* --------------------------- Class COLDEF -------------------------- */ /***********************************************************************/
COLDEF::COLDEF(void) : COLCRT()
/***********************************************************************/ {
/* COLDEF Constructor. */ To_Min = NULL;
/***********************************************************************/ To_Max = NULL;
COLDEF::COLDEF(void) : COLCRT() To_Pos = NULL;
{ Xdb2 = FALSE;
To_Min = NULL; To_Bmap = NULL;
To_Max = NULL; To_Dval = NULL;
To_Pos = NULL; Ndv = 0;
Xdb2 = FALSE; Nbm = 0;
To_Bmap = NULL; Buf_Type = TYPE_ERROR;
To_Dval = NULL; Clen = 0;
Ndv = 0; Poff = 0;
Nbm = 0; memset(&F, 0, sizeof(FORMAT));
Buf_Type = TYPE_ERROR; Flags = 0;
Clen = 0; } // end of COLDEF constructor
Poff = 0;
memset(&F, 0, sizeof(FORMAT)); /***********************************************************************/
Flags = 0; /* Define: initialize a column definition from a COLINFO structure. */
} // end of COLDEF constructor /***********************************************************************/
int COLDEF::Define(PGLOBAL g, void *memp, PCOLINFO cfp, int poff)
/***********************************************************************/ {
/* Define: initialize a column definition from a COLINFO structure. */ Name = (PSZ)PlugSubAlloc(g, memp, strlen(cfp->Name) + 1);
/***********************************************************************/ strcpy(Name, cfp->Name);
int COLDEF::Define(PGLOBAL g, void *memp, PCOLINFO cfp, int poff)
{ if (!(cfp->Flags & U_SPECIAL)) {
Name = (PSZ)PlugSubAlloc(g, memp, strlen(cfp->Name) + 1); Poff = poff;
strcpy(Name, cfp->Name); Buf_Type = cfp->Type;
if (!(cfp->Flags & U_SPECIAL)) { if ((Clen = GetTypeSize(Buf_Type, cfp->Length)) <= 0) {
Poff = poff; sprintf(g->Message, MSG(BAD_COL_TYPE), GetTypeName(Buf_Type), Name);
Buf_Type = cfp->Type; return -1;
} // endswitch
if ((Clen = GetTypeSize(Buf_Type, cfp->Length)) <= 0) {
sprintf(g->Message, MSG(BAD_COL_TYPE), GetTypeName(Buf_Type), Name); strcpy(F.Type, GetFormatType(Buf_Type));
return -1; F.Length = cfp->Length;
} // endswitch F.Prec = cfp->Scale;
Offset = (cfp->Offset < 0) ? poff : cfp->Offset;
strcpy(F.Type, GetFormatType(Buf_Type)); Precision = cfp->Precision;
F.Length = cfp->Length; Scale = cfp->Scale;
F.Prec = cfp->Scale; Long = cfp->Length;
Offset = (cfp->Offset < 0) ? poff : cfp->Offset; Opt = cfp->Opt;
Precision = cfp->Precision; Key = cfp->Key;
Scale = cfp->Scale; Freq = cfp->Freq;
Long = cfp->Length;
Opt = cfp->Opt; if (cfp->Remark && *cfp->Remark) {
Key = cfp->Key; Desc = (PSZ)PlugSubAlloc(g, memp, strlen(cfp->Remark) + 1);
Freq = cfp->Freq; strcpy(Desc, cfp->Remark);
} // endif Remark
if (cfp->Remark && *cfp->Remark) {
Desc = (PSZ)PlugSubAlloc(g, memp, strlen(cfp->Remark) + 1); if (cfp->Datefmt) {
strcpy(Desc, cfp->Remark); Decode = (PSZ)PlugSubAlloc(g, memp, strlen(cfp->Datefmt) + 1);
} // endif Remark strcpy(Decode, cfp->Datefmt);
} // endif Datefmt
if (cfp->Datefmt) {
Decode = (PSZ)PlugSubAlloc(g, memp, strlen(cfp->Datefmt) + 1); } // endif special
strcpy(Decode, cfp->Datefmt);
} // endif Datefmt if (cfp->Fieldfmt) {
Fmt = (PSZ)PlugSubAlloc(g, memp, strlen(cfp->Fieldfmt) + 1);
} // endif special strcpy(Fmt, cfp->Fieldfmt);
} // endif Fieldfmt
if (cfp->Fieldfmt) {
Fmt = (PSZ)PlugSubAlloc(g, memp, strlen(cfp->Fieldfmt) + 1); Flags = cfp->Flags;
strcpy(Fmt, cfp->Fieldfmt); return (Flags & (U_VIRTUAL|U_SPECIAL)) ? 0 : Long;
} // endif Fieldfmt } // end of Define
Flags = cfp->Flags; /* ------------------------- End of RelDef --------------------------- */
return (Flags & (U_VIRTUAL|U_SPECIAL)) ? 0 : Long;
} // end of Define
/* ------------------------- End of RelDef --------------------------- */

25
storage/connect/tabcol.cpp
View File

@@ -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)
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)
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)
{ {
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)
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
/***********************************************************************/ /***********************************************************************/

2858
storage/connect/tabfmt.cpp
View File

File diff suppressed because it is too large Load Diff

3240
storage/connect/tabmysql.cpp
View File

File diff suppressed because it is too large Load Diff

2
storage/connect/tabodbc.cpp
View File

@@ -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));

4
storage/connect/tabpivot.cpp
View File

@@ -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)
} // 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) {

37
storage/connect/tabvct.cpp
View File

@@ -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)
/***********************************************************************/ /***********************************************************************/
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) {
/*******************************************************************/ /*******************************************************************/
@@ -344,12 +345,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) {
/*******************************************************************/ /*******************************************************************/
@@ -524,15 +523,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);
@@ -558,11 +555,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;

321
storage/connect/user_connect.cc
View File

@@ -1,161 +1,160 @@
/* Copyright (C) Olivier Bertrand 2004 - 2012 /* Copyright (C) Olivier Bertrand 2004 - 2014
This program is free software; you can redistribute it and/or modify This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License. the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
/** /**
@file user_connect.cc @file user_connect.cc
@brief @brief
Implements the user_connect class. Implements the user_connect class.
@details @details
To support multi_threading, each query creates and use a PlugDB "user" To support multi_threading, each query creates and use a PlugDB "user"
that is a connection with its personnal memory allocation. that is a connection with its personnal memory allocation.
@note @note
*/ */
/****************************************************************************/ /****************************************************************************/
/* Author: Olivier Bertrand -- bertrandop@gmail.com -- 2004-2012 */ /* Author: Olivier Bertrand -- bertrandop@gmail.com -- 2004-2014 */
/****************************************************************************/ /****************************************************************************/
#ifdef USE_PRAGMA_IMPLEMENTATION #ifdef USE_PRAGMA_IMPLEMENTATION
#pragma implementation // gcc: Class implementation #pragma implementation // gcc: Class implementation
#endif #endif
#define DONT_DEFINE_VOID #define DONT_DEFINE_VOID
#define MYSQL_SERVER #define MYSQL_SERVER
#include "sql_class.h" #include "sql_class.h"
#undef OFFSET #undef OFFSET
#define NOPARSE #define NOPARSE
#include "osutil.h" #include "osutil.h"
#include "global.h" #include "global.h"
#include "plgdbsem.h" #include "plgdbsem.h"
#include "connect.h" #include "connect.h"
#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. */ /****************************************************************************/
/****************************************************************************/ PCONNECT user_connect::to_users= NULL;
PCONNECT user_connect::to_users= NULL;
/* -------------------------- class user_connect -------------------------- */
/* -------------------------- class user_connect -------------------------- */
/****************************************************************************/
/****************************************************************************/ /* Constructor. */
/* Constructor. */ /****************************************************************************/
/****************************************************************************/ user_connect::user_connect(THD *thd, const char *dbn)
user_connect::user_connect(THD *thd, const char *dbn) {
{ thdp= thd;
thdp= thd; next= NULL;
next= NULL; previous= NULL;
previous= NULL; g= NULL;
g= NULL; last_query_id= 0;
last_query_id= 0; count= 0;
count= 0;
// Statistics
// Statistics nrd= fnd= nfd= 0;
nrd= fnd= nfd= 0; tb1= 0;
tb1= 0; } // end of user_connect constructor
} // end of user_connect constructor
/****************************************************************************/
/****************************************************************************/ /* Destructor. */
/* Destructor. */ /****************************************************************************/
/****************************************************************************/ user_connect::~user_connect()
user_connect::~user_connect() {
{ // Terminate CONNECT and Plug-like environment, should return NULL
// Terminate CONNECT and Plug-like environment, should return NULL g= CntExit(g);
g= CntExit(g); } // end of user_connect destructor
} // end of user_connect destructor
/****************************************************************************/
/****************************************************************************/ /* Initialization. */
/* Initialization. */ /****************************************************************************/
/****************************************************************************/ bool user_connect::user_init()
bool user_connect::user_init() {
{ // Initialize Plug-like environment
// Initialize Plug-like environment PACTIVITY ap= NULL;
PACTIVITY ap= NULL; PDBUSER dup= NULL;
PDBUSER dup= NULL;
// Areasize= 64M because of VEC tables. Should be parameterisable
// Areasize= 64M because of VEC tables. Should be parameterisable g= PlugInit(NULL, 67108864);
g= PlugInit(NULL, 67108864); //g= PlugInit(NULL, 134217728); // 128M was because of old embedded tests
//g= PlugInit(NULL, 134217728); // 128M was because of old embedded tests
// Check whether the initialization is complete
// Check whether the initialization is complete if (!g || !g->Sarea || PlugSubSet(g, g->Sarea, g->Sarea_Size)
if (!g || !g->Sarea || PlugSubSet(g, g->Sarea, g->Sarea_Size) || !(dup= PlgMakeUser(g))) {
|| !(dup= PlgMakeUser(g))) { if (g)
if (g) printf("%s\n", g->Message);
printf("%s\n", g->Message);
int rc= PlugExit(g);
int rc= PlugExit(g); g= NULL;
g= NULL; free(dup);
free(dup); return true;
return true; } // endif g->
} // endif g->
dup->Catalog= new MYCAT(NULL);
dup->Catalog= new MYCAT(NULL);
ap= new ACTIVITY;
ap= new ACTIVITY; memset(ap, 0, sizeof(ACTIVITY));
memset(ap, 0, sizeof(ACTIVITY)); strcpy(ap->Ap_Name, "CONNECT");
strcpy(ap->Ap_Name, "CONNECT"); g->Activityp= ap;
g->Activityp= ap; g->Activityp->Aptr= dup;
g->Activityp->Aptr= dup; next= to_users;
next= to_users; to_users= this;
to_users= this;
if (next)
if (next) next->previous= this;
next->previous= this;
last_query_id= thdp->query_id;
last_query_id= thdp->query_id; count= 1;
count= 1; return false;
return false; } // end of user_init
} // end of user_init
void user_connect::SetHandler(ha_connect *hc)
void user_connect::SetHandler(ha_connect *hc) {
{ PDBUSER dup= (PDBUSER)g->Activityp->Aptr;
PDBUSER dup= (PDBUSER)g->Activityp->Aptr; MYCAT *mc= (MYCAT*)dup->Catalog;
MYCAT *mc= (MYCAT*)dup->Catalog; mc->SetHandler(hc);
mc->SetHandler(hc); }
}
/****************************************************************************/
/****************************************************************************/ /* Check whether we begin a new query and if so cleanup the previous one. */
/* Check whether we begin a new query and if so cleanup the previous one. */ /****************************************************************************/
/****************************************************************************/ bool user_connect::CheckCleanup(void)
bool user_connect::CheckCleanup(void) {
{ if (thdp->query_id > last_query_id) {
if (thdp->query_id > last_query_id) { PlugCleanup(g, true);
PlugCleanup(g, true); PlugSubSet(g, g->Sarea, g->Sarea_Size);
PlugSubSet(g, g->Sarea, g->Sarea_Size); g->Xchk = NULL;
g->Xchk = NULL; g->Createas = 0;
g->Createas = 0; g->Alchecked = 0;
g->Alchecked = 0; g->Mrr = 0;
g->Mrr = 0; last_query_id= thdp->query_id;
last_query_id= thdp->query_id;
if (trace)
if (xtrace) printf("=====> Begin new query %llu\n", last_query_id);
printf("=====> Begin new query %llu\n", last_query_id);
return true;
return true; } // endif query_id
} // endif query_id
return false;
return false; } // end of CheckCleanup
} // end of CheckCleanup

19
storage/connect/valblk.cpp
View File

@@ -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,
{ {
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:
@@ -576,7 +577,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++) {
@@ -767,13 +768,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));
@@ -846,13 +847,13 @@ void CHRBLK::SetMax(PVAL valp, int n)
/***********************************************************************/ /***********************************************************************/
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)

4410
storage/connect/value.cpp
View File

File diff suppressed because it is too large Load Diff

6038
storage/connect/xindex.cpp
View File

File diff suppressed because it is too large Load Diff