- NOTE: an experimental implementation of MRR was done but not kept

  in this version. Sure enough, it never caused any improvement in
  the execution speed and rather caused a small increase of execution
  time. This is probably because values are sorted by rowid in each
  range of CONNECT indexes. This could be reconsidered if a customer
  have a need for processing very big files.

- Fix a bug in ha_connect::CheckCond. The negated form of BETWEEN and
  IS NULL operators was not recognized.
modified:
  storage/connect/ha_connect.cc

- Add long jump initialization in CntReadNext. This was causing a server
  crash when an error occured in a ReadColumn.
modified:
  storage/connect/connect.cc

- General cleanup of CONNECT source code eliminating all code not used by
  CONNECT, including the MRR test code (saved separately).
modified:
  storage/connect/catalog.h
  storage/connect/colblk.cpp
  storage/connect/colblk.h
  storage/connect/connect.cc
  storage/connect/connect.h
  storage/connect/domdoc.h
  storage/connect/filamap.cpp
  storage/connect/filamap.h
  storage/connect/filamdbf.h
  storage/connect/filamfix.cpp
  storage/connect/filamfix.h
  storage/connect/filamtxt.cpp
  storage/connect/filamtxt.h
  storage/connect/filamvct.cpp
  storage/connect/filamvct.h
  storage/connect/filamzip.cpp
  storage/connect/filamzip.h
  storage/connect/global.h
  storage/connect/ha_connect.cc
  storage/connect/ha_connect.h
  storage/connect/myconn.h
  storage/connect/plgcnx.h
  storage/connect/plgdbsem.h
  storage/connect/plugutil.c
  storage/connect/preparse.h
  storage/connect/reldef.cpp
  storage/connect/reldef.h
  storage/connect/tabcol.h
  storage/connect/tabdos.cpp
  storage/connect/tabdos.h
  storage/connect/tabfix.cpp
  storage/connect/tabfmt.cpp
  storage/connect/tabfmt.h
  storage/connect/table.cpp
  storage/connect/tabmac.h
  storage/connect/tabmul.h
  storage/connect/tabmysql.cpp
  storage/connect/tabmysql.h
  storage/connect/taboccur.h
  storage/connect/tabodbc.cpp
  storage/connect/tabodbc.h
  storage/connect/tabsys.cpp
  storage/connect/tabsys.h
  storage/connect/tabtbl.cpp
  storage/connect/tabtbl.h
  storage/connect/tabutil.h
  storage/connect/tabvct.cpp
  storage/connect/tabvct.h
  storage/connect/tabwmi.cpp
  storage/connect/tabwmi.h
  storage/connect/tabxml.cpp
  storage/connect/tabxml.h
  storage/connect/user_connect.cc
  storage/connect/user_connect.h
  storage/connect/valblk.cpp
  storage/connect/valblk.h
  storage/connect/value.cpp
  storage/connect/value.h
  storage/connect/xindex.cpp
  storage/connect/xindex.h
  storage/connect/xobject.cpp
  storage/connect/xobject.h
  storage/connect/xtable.h

storage/connect/catalog.h

@@ -43,7 +43,6 @@ typedef struct _colinfo {
   int    Key;
   int    Precision;
   int    Scale;
-  int    Opt;
   char  *Remark;
   char  *Datefmt;
   char  *Fieldfmt;

storage/connect/colblk.cpp

@@ -36,7 +36,6 @@ COLBLK::COLBLK(PCOLDEF cdp, PTDB tdbp, int i)
   if ((Cdp = cdp)) {
     Name = cdp->Name;
     Format = cdp->F;
-    Opt = cdp->Opt;
     Long = cdp->Long;
     Precision = cdp->Precision;
     Buf_Type = cdp->Buf_Type;
@@ -46,7 +45,6 @@ COLBLK::COLBLK(PCOLDEF cdp, PTDB tdbp, int i)
   } else {
     Name = NULL;
     memset(&Format, 0, sizeof(FORMAT));
-    Opt = 0;
     Long = 0;
     Precision = 0;
     Buf_Type = TYPE_ERROR;
@@ -122,14 +120,6 @@ bool COLBLK::SetFormat(PGLOBAL g, FORMAT& fmt)
   return false;
   } // end of SetFormat
 
-/***********************************************************************/
-/*  CheckColumn:  a column descriptor is found, say it by returning 1. */
-/***********************************************************************/
-int COLBLK::CheckColumn(PGLOBAL g, PSQL sqlp, PXOB &p, int &ag)
-  {
-  return 1;
-  } // end of CheckColumn
-
 /***********************************************************************/
 /*  Eval:  get the column value from the last read record or from a    */
 /*  matching Index column if there is one.                             */
@@ -154,15 +144,6 @@ bool COLBLK::Eval(PGLOBAL g)
   return false;
   } // end of Eval
 
-/***********************************************************************/
-/*  CheckSort:                                                         */
-/*  Used to check that a table is involved in the sort list items.     */
-/***********************************************************************/
-bool COLBLK::CheckSort(PTDB tdbp)
-  {
-  return (tdbp == To_Tdb);
-  } // end of CheckSort
-
 /***********************************************************************/
 /*  InitValue: prepare a column block for read operation.              */
 /*  Now we use Format.Length for the len parameter to avoid strings    */

storage/connect/colblk.h

@@ -39,7 +39,6 @@ class DllExport COLBLK : public XOBJECT {
           PCOL    GetNext(void) {return Next;}
           PSZ     GetName(void) {return Name;}
           int     GetIndex(void) {return Index;}
-          int     GetOpt(void) {return Opt;}
           ushort  GetColUse(void) {return ColUse;}
           ushort  GetColUse(ushort u) {return (ColUse & u);}
           ushort  GetStatus(void) {return Status;}
@@ -49,9 +48,6 @@ class DllExport COLBLK : public XOBJECT {
           void    AddColUse(ushort u) {ColUse |= u;}
           void    AddStatus(ushort u) {Status |= u;}
           void    SetNext(PCOL cp) {Next = cp;}
-#if defined(MRRBKA_SUPPORT)
-          PXCOL   GetKcol(void) {return To_Kcol;}
-#endif   // MRRBKA_SUPPORT
           void    SetKcol(PXCOL kcp) {To_Kcol = kcp;}
           PCOLDEF GetCdp(void) {return Cdp;}
           PSZ     GetDomain(void) {return (Cdp) ? Cdp->Decode : NULL;}
@@ -65,10 +61,7 @@ class DllExport COLBLK : public XOBJECT {
   virtual void    Reset(void);
   virtual bool    Compare(PXOB xp);
   virtual bool    SetFormat(PGLOBAL, FORMAT&);
-  virtual int     CheckColumn(PGLOBAL g, PSQL sqlp, PXOB &xp, int &ag);
   virtual bool    IsSpecial(void) {return false;}
-  virtual int     CheckSpcCol(PTDB tdbp, int n) {return 2;}
-  virtual bool    CheckSort(PTDB tdbp);
   virtual bool    Eval(PGLOBAL g);
   virtual bool    SetBuffer(PGLOBAL g, PVAL value, bool ok, bool check);
   virtual void    SetTo_Val(PVAL valp) {}
@@ -76,8 +69,6 @@ class DllExport COLBLK : public XOBJECT {
   virtual void    WriteColumn(PGLOBAL g);
   virtual void    Print(PGLOBAL g, FILE *, uint);
   virtual void    Print(PGLOBAL g, char *, uint);
-  virtual bool    VarSize(void) {return false;}
-  virtual bool    IsColInside(PCOL colp) {return this == colp;}
           bool    InitValue(PGLOBAL g);
 
  protected:
@@ -90,7 +81,6 @@ class DllExport COLBLK : public XOBJECT {
   bool    Nullable;            // True if nullable
   bool    Unsigned;            // True if unsigned
   int     Index;               // Column number in table
-  int     Opt;                 // Cluster/sort information
   int     Buf_Type;            // Data type
   int     Long;                // Internal length in table
   int     Precision;           // Column length (as for ODBC)
@@ -153,8 +143,6 @@ class DllExport FIDBLK : public SPCBLK {
 
   // Methods
   virtual void Reset(void) {}       // This is a pseudo constant column
-  virtual int  CheckSpcCol(PTDB tdbp, int n) 
-  {return (n == 2 && tdbp == To_Tdb) ? 1 : 2;}
   virtual void ReadColumn(PGLOBAL g);
 
  protected:
@@ -174,8 +162,6 @@ class DllExport TIDBLK : public SPCBLK {
 
   // Methods
   virtual void Reset(void) {}       // This is a pseudo constant column
-  virtual int  CheckSpcCol(PTDB tdbp, int n)
-              {return (n == 3 && tdbp == To_Tdb) ? 1 : 2;}
   virtual void ReadColumn(PGLOBAL g);
 
  protected:
@@ -199,8 +185,6 @@ class DllExport SIDBLK : public SPCBLK {
 
   // Methods
   virtual void Reset(void) {}       // This is a pseudo constant column
-  virtual int  CheckSpcCol(PTDB tdbp, int n)
-              {return (n == 3 && tdbp == To_Tdb) ? 1 : 2;}
   virtual void ReadColumn(PGLOBAL g);
 
  protected:

storage/connect/connect.cc

@@ -415,11 +415,7 @@ RCODE EvalColumns(PGLOBAL g, PTDB tdbp, bool mrr)
       colp->Reset();
 
       // Virtual columns are computed by MariaDB
-#if defined(MRRBKA_SUPPORT)
-      if (!colp->GetColUse(U_VIRTUAL) && (!mrr || colp->GetKcol()))
-#else   // !MRRBKA_SUPPORT
       if (!colp->GetColUse(U_VIRTUAL))
-#endif  // !MRRBKA_SUPPORT
         if (colp->Eval(g))
           rc= RC_FX;
 
@@ -433,7 +429,7 @@ RCODE EvalColumns(PGLOBAL g, PTDB tdbp, bool mrr)
 /***********************************************************************/
 /*  ReadNext: Read next record sequentially.                           */
 /***********************************************************************/
-RCODE  CntReadNext(PGLOBAL g, PTDB tdbp)
+RCODE CntReadNext(PGLOBAL g, PTDB tdbp)
   {
   RCODE rc;
 
@@ -449,8 +445,21 @@ RCODE  CntReadNext(PGLOBAL g, PTDB tdbp)
     ((PTDBASE)tdbp)->SetKindex(NULL);
     } // endif index
 
+  // Save stack and allocation environment and prepare error return
+  if (g->jump_level == MAX_JUMP) {
+    strcpy(g->Message, MSG(TOO_MANY_JUMPS));
+    return RC_FX;
+    } // endif jump_level
+
+  if ((setjmp(g->jumper[++g->jump_level])) != 0) {
+    rc= RC_FX;
+    goto err;
+    } // endif rc
+
   while ((rc= (RCODE)tdbp->ReadDB(g)) == RC_NF) ;
-  
+
+ err:
+  g->jump_level--;
   return (rc != RC_OK) ? rc : EvalColumns(g, tdbp);
   } // end of CntReadNext
 
@@ -572,7 +581,7 @@ int CntCloseTable(PGLOBAL g, PTDB tdbp)
     return 0;
 
   if (xtrace > 1)
-    printf("About to reset opt\n");
+    printf("About to reset indexes\n");
 
   // Make all the eventual indexes
   tbxp= (TDBDOX*)tdbp;

storage/connect/connect.h

@@ -17,7 +17,6 @@
 /*  Name: CONNECT.H    Version 2.4                                     */
 /*  This file contains the some based classes declares.                */
 /***********************************************************************/
-//#include "xtable.h"                     // Base class declares
 #include "filamtxt.h"
 #include "tabdos.h"
 
@@ -52,8 +51,6 @@ PGLOBAL CntExit(PGLOBAL g);
 /*  These classes purpose is chiefly to access protected items!        */
 /***********************************************************************/
 class DOXDEF: public DOSDEF {
-//friend class TDBDOX;
-//friend int MakeIndex(PGLOBAL, PTDB, PIXDEF);
   friend int CntIndexInit(PGLOBAL, PTDB, int);
   }; // end of class DOXDEF
 
@@ -74,10 +71,7 @@ class TDBDOX: public TDBDOS {
 class XKPDEF: public KPARTDEF {
   friend class TDBDOX;
   friend class ha_connect;
-//friend int CntMakeIndex(PGLOBAL, const char *, PIXDEF);
   friend int CntIndexInit(PGLOBAL, PTDB, int);
  public:
   XKPDEF(const char *name, int n) : KPARTDEF((PSZ)name, n) {}
   }; // end of class XKPDEF
-
-//RCODE CheckRecord(PGLOBAL g, PTDB tdbp, char *oldbuf, char *newbuf);

storage/connect/domdoc.h

@@ -20,7 +20,6 @@ typedef struct _xblock {          /* Loaded XML file block        */
   short              Type;        /* TYPE_FB_XML                  */
   int                Retcode;     /* Return code from Load        */
   MSXML2::IXMLDOMDocumentPtr Docp;/* Document interface pointer   */
-//IXMLDOMNodeListPtr Nlist;
   } XBLOCK, *PXBLOCK;
 
 /******************************************************************/
@@ -123,9 +122,6 @@ class DOMATTR : public XMLATTRIBUTE {
   friend class DOMDOC;
   friend class DOMNODE;
  public:
-  // Properties
-//virtual char *GetText(void);
-
   // Methods
   virtual bool  SetText(PGLOBAL g, char *txtp, int len);
 

storage/connect/filamap.cpp

@@ -322,8 +322,8 @@ int MAPFAM::ReadBuffer(PGLOBAL g)
     /*******************************************************************/
     /*  Record file position in case of UPDATE or DELETE.              */
     /*******************************************************************/
-    Fpos = Mempos;
-    CurBlk = (int)Rows++;
+		Fpos = Mempos;
+		CurBlk = (int)Rows++;
   } else
     Placed = false;
 
@@ -491,7 +491,7 @@ MBKFAM::MBKFAM(PDOSDEF tdp) : MAPFAM(tdp)
   Block = tdp->GetBlock();
   Last = tdp->GetLast();
   Nrec = tdp->GetElemt();
-  BlkPos = tdp->GetTo_Pos();
+  BlkPos = NULL;
   CurNum = Nrec;
   } // end of MBKFAM standard constructor
 
@@ -537,37 +537,8 @@ int MBKFAM::GetRowID(void)
 /***********************************************************************/
 int MBKFAM::ReadBuffer(PGLOBAL g)
   {
-  int len;
-
-  /*********************************************************************/
-  /*  Sequential block reading when Placed is not true.                */
-  /*********************************************************************/
-  if (Placed) {
-    Placed = false;
-  } else if (Mempos >= Top) {        // Are we at the end of the memory
-    return RC_EF;
-  } else if (++CurNum < Nrec) {                                           
-    Fpos = Mempos;
-  } else {                                                            
-    /*******************************************************************/
-    /*  New block.                                                     */
-    /*******************************************************************/
-    CurNum = 0;                                                       
-                                                                       
-    if (++CurBlk >= Block)                                           
-      return RC_EF;                                                   
-                                                                       
-    Fpos = Mempos = Memory + BlkPos[CurBlk];
-  } // endif's
-
-  // Immediately calculate next position (Used by DeleteDB)
-  while (*Mempos++ != '\n') ;        // What about Unix ???
-
-  // Set caller line buffer
-  len = (Mempos - Fpos) - Ending;
-  memcpy(Tdbp->GetLine(), Fpos, len);
-  Tdbp->GetLine()[len] = '\0';
-  return RC_OK;
+  strcpy(g->Message, "This AM cannot be used in this version");
+  return RC_FX;
   } // end of ReadBuffer
 
 /***********************************************************************/
@@ -657,7 +628,7 @@ int MPXFAM::ReadBuffer(PGLOBAL g)
     /*  New block.                                                     */
     /*******************************************************************/
     CurNum = 0;                                                       
-                                                                       
+
     if (++CurBlk >= Block)                                           
       return RC_EF;                                                   
                                                                        

storage/connect/filamap.h

@@ -33,7 +33,6 @@ class DllExport MAPFAM : public TXTFAM {
   virtual void  Reset(void);
   virtual int   GetFileLength(PGLOBAL g);
   virtual int   Cardinality(PGLOBAL g) {return (g) ? -1 : 0;}
-  virtual int   MaxBlkSize(PGLOBAL g, int s) {return s;}
   virtual int   GetRowID(void);
   virtual bool  RecordPos(PGLOBAL g);
   virtual bool  SetPos(PGLOBAL g, int recpos); 
@@ -66,18 +65,16 @@ class DllExport MBKFAM : public MAPFAM {
   MBKFAM(PMAPFAM tmfp) : MAPFAM(tmfp) {}
 
   // Implementation
-  virtual PTXF  Duplicate(PGLOBAL g)
+  virtual PTXF Duplicate(PGLOBAL g)
                   {return (PTXF)new(g) MBKFAM(this);}
 
   // Methods
-  virtual void  Reset(void);
+  virtual void Reset(void);
   virtual int  Cardinality(PGLOBAL g);
-  virtual int  MaxBlkSize(PGLOBAL g, int s) 
-                {return TXTFAM::MaxBlkSize(g, s);}
   virtual int  GetRowID(void);
-  virtual int   SkipRecord(PGLOBAL g, bool header);
-  virtual int   ReadBuffer(PGLOBAL g);
-  virtual void  Rewind(void);
+  virtual int  SkipRecord(PGLOBAL g, bool header);
+  virtual int  ReadBuffer(PGLOBAL g);
+  virtual void Rewind(void);
 
  protected:
   // No additional members
@@ -99,9 +96,6 @@ class DllExport MPXFAM : public MBKFAM {
 
   // Methods
   virtual int   Cardinality(PGLOBAL g) {return TXTFAM::Cardinality(g);}
-  virtual int   MaxBlkSize(PGLOBAL g, int s) 
-                {return TXTFAM::MaxBlkSize(g, s);}
-//virtual int   GetRowID(void);
   virtual bool  SetPos(PGLOBAL g, int recpos); 
   virtual bool  DeferReading(void) {return false;}
   virtual int   ReadBuffer(PGLOBAL g);

storage/connect/filamdbf.h

@@ -43,7 +43,6 @@ class DllExport DBFBASE {
   int  Nerr;                        /*  Number of bad records                */
   int  Maxerr;                      /*  Maximum number of bad records        */
   int  ReadMode;                    /*  1: ALL 2: DEL 0: NOT DEL            */
-//PSZ  Defpath;                      /*  Default data path                   */
   }; // end of class DBFBASE
 
 /****************************************************************************/
@@ -63,22 +62,18 @@ class DllExport DBFFAM : public FIXFAM, public DBFBASE {
   // Methods
   virtual int  GetNerr(void) {return Nerr;}
   virtual int  Cardinality(PGLOBAL g);
-//virtual int  GetRowID(void);              // Temporarily suppressed
   virtual bool OpenTableFile(PGLOBAL g);
   virtual bool AllocateBuffer(PGLOBAL g);
   virtual void ResetBuffer(PGLOBAL g);
   virtual int  ReadBuffer(PGLOBAL g);
-//virtual int  WriteBuffer(PGLOBAL g);
   virtual int  DeleteRecords(PGLOBAL g, int irc);
   virtual void CloseTableFile(PGLOBAL g);
   virtual void Rewind(void);
 
  protected:
-  // Members
   virtual bool CopyHeader(PGLOBAL g);
 
-//int  Records;                       in TXTFAM
-//int  Headlen;                       in TXTFAM
+  // Members
   }; // end of class DBFFAM
 
 /****************************************************************************/
@@ -100,17 +95,13 @@ class DllExport DBMFAM : public MPXFAM, public DBFBASE {
   // Methods
   virtual int  GetNerr(void) {return Nerr;}
   virtual int  Cardinality(PGLOBAL g);
-//virtual int  GetRowID(void);              // Temporarily suppressed
   virtual bool AllocateBuffer(PGLOBAL g);
   virtual int  ReadBuffer(PGLOBAL g);
-//virtual int  WriteBuffer(PGLOBAL g);
   virtual int  DeleteRecords(PGLOBAL g, int irc);
   virtual void Rewind(void);
 
  protected:
   // Members
-//int  Records;                       in TXTFAM
-//int  Headlen;                       in TXTFAM
   }; // end of class DBFFAM
 
 #endif // __FILAMDBF_H

storage/connect/filamfix.cpp

 /*********** File AM Fix C++ Program Source Code File (.CPP) ***********/
 /* PROGRAM NAME: FILAMFIX                                              */
 /* -------------                                                       */
-/*  Version 1.4                                                        */
+/*  Version 1.5                                                        */
 /*                                                                     */
 /* COPYRIGHT:                                                          */
 /* ----------                                                          */
-/*  (C) Copyright to the author Olivier BERTRAND          2005-2013    */
+/*  (C) Copyright to the author Olivier BERTRAND          2005-2014    */
 /*                                                                     */
 /* WHAT THIS PROGRAM DOES:                                             */
 /* -----------------------                                             */

storage/connect/filamfix.h

@@ -31,18 +31,16 @@ class DllExport FIXFAM : public BLKFAM {
 
   // Methods
   virtual int  Cardinality(PGLOBAL g) {return TXTFAM::Cardinality(g);}
-  virtual int  MaxBlkSize(PGLOBAL g, int s) 
-                {return TXTFAM::MaxBlkSize(g, s);}
-  virtual bool  AllocateBuffer(PGLOBAL g);
-  virtual void  ResetBuffer(PGLOBAL g);
-  virtual int   ReadBuffer(PGLOBAL g);
-  virtual int   WriteBuffer(PGLOBAL g);
-  virtual int    DeleteRecords(PGLOBAL g, int irc);
-  virtual void  CloseTableFile(PGLOBAL g);
+  virtual bool AllocateBuffer(PGLOBAL g);
+  virtual void ResetBuffer(PGLOBAL g);
+  virtual int  ReadBuffer(PGLOBAL g);
+  virtual int  WriteBuffer(PGLOBAL g);
+  virtual int  DeleteRecords(PGLOBAL g, int irc);
+  virtual void CloseTableFile(PGLOBAL g);
 
  protected:
-  virtual bool  CopyHeader(PGLOBAL g) {return false;}
-  virtual bool  MoveIntermediateLines(PGLOBAL g, bool *b);
+  virtual bool CopyHeader(PGLOBAL g) {return false;}
+  virtual bool MoveIntermediateLines(PGLOBAL g, bool *b);
 
   // No additional members
   }; // end of class FIXFAM
@@ -64,12 +62,11 @@ class BGXFAM : public FIXFAM {
                   {return (PTXF)new(g) BGXFAM(this);}
 
   // Methods
-//virtual void  Reset(void);
   virtual int   Cardinality(PGLOBAL g);
   virtual bool  OpenTableFile(PGLOBAL g);
   virtual int   ReadBuffer(PGLOBAL g);
   virtual int   WriteBuffer(PGLOBAL g);
-  virtual int    DeleteRecords(PGLOBAL g, int irc);
+  virtual int   DeleteRecords(PGLOBAL g, int irc);
   virtual void  CloseTableFile(PGLOBAL g);
   virtual void  Rewind(void);
 
@@ -78,13 +75,12 @@ class BGXFAM : public FIXFAM {
                                           , int org = FILE_BEGIN);
           int  BigRead(PGLOBAL g, HANDLE h, void *inbuf, int req);
           bool BigWrite(PGLOBAL g, HANDLE h, void *inbuf, int req);
-  virtual  bool OpenTempFile(PGLOBAL g);
+  virtual bool OpenTempFile(PGLOBAL g);
   virtual bool MoveIntermediateLines(PGLOBAL g, bool *b = NULL);
 
   // Members
   HANDLE  Hfile;               // Handle(descriptor) to big file
   HANDLE  Tfile;               // Handle(descriptor) to big temp file
-//BIGINT  Xpos;                // Current file position
   }; // end of class BGXFAM
 
 #endif // __FILAMFIX_H

storage/connect/filamtxt.cpp

@@ -228,25 +228,6 @@ int TXTFAM::Cardinality(PGLOBAL g)
 
   } // end of Cardinality
 
-/***********************************************************************/
-/*  Use BlockTest to reduce the table estimated size.                  */
-/*  Note: This function is meant only for fixed length files but is    */
-/*  placed here to be available to FIXFAM and MPXFAM classes.          */
-/***********************************************************************/
-int TXTFAM::MaxBlkSize(PGLOBAL g, int s)
-  {
-  int  savcur = CurBlk, blm1 = Block - 1;
-  int size, last = s - blm1 * Nrec;
-
-  // Roughly estimate the table size as the sum of blocks
-  // that can contain good rows
-  for (size = 0, CurBlk = 0; CurBlk < Block; CurBlk++)
-    size += (CurBlk == blm1) ? last : Nrec;
-
-  CurBlk = savcur;
-  return size;
-  } // end of MaxBlkSize
-
 /* --------------------------- Class DOSFAM -------------------------- */
 
 /***********************************************************************/
@@ -313,15 +294,6 @@ int DOSFAM::Cardinality(PGLOBAL g)
   return (g) ? -1 : 0;
   } // end of Cardinality
 
-/***********************************************************************/
-/*  Use BlockTest to reduce the table estimated size.                  */
-/*  Note: This function is not really implemented yet.                 */
-/***********************************************************************/
-int DOSFAM::MaxBlkSize(PGLOBAL g, int s)
-  {
-  return s;
-  } // end of MaxBlkSize
-
 /***********************************************************************/
 /*  OpenTableFile: Open a DOS/UNIX table file using C standard I/Os.   */
 /***********************************************************************/
@@ -993,7 +965,7 @@ BLKFAM::BLKFAM(PDOSDEF tdp) : DOSFAM(tdp)
   Last = tdp->GetLast();
   Nrec = tdp->GetElemt();
   Closing = false;
-  BlkPos = tdp->GetTo_Pos();
+  BlkPos = NULL;
   CurLine = NULL;
   NxtLine = NULL;
   OutBuf = NULL;
@@ -1028,23 +1000,6 @@ int BLKFAM::Cardinality(PGLOBAL g)
 //return (g) ? (int)((Block - 1) * Nrec + Last) : 1;
   } // end of Cardinality
 
-/***********************************************************************/
-/*  Use BlockTest to reduce the table estimated size.                  */
-/***********************************************************************/
-int BLKFAM::MaxBlkSize(PGLOBAL g, int s)
-  {
-  int  savcur = CurBlk;
-  int size;
-
-  // Roughly estimate the table size as the sum of blocks
-  // that can contain good rows
-  for (size = 0, CurBlk = 0; CurBlk < Block; CurBlk++)
-    size += (CurBlk == Block - 1) ? Last : Nrec;
-
-  CurBlk = savcur;
-  return size;
-  } // end of MaxBlkSize
-
 /***********************************************************************/
 /*  Allocate the line buffer. For mode Delete or when a temp file is   */
 /*  used another big buffer has to be allocated because is it used     */
@@ -1150,97 +1105,8 @@ int BLKFAM::SkipRecord(PGLOBAL g, bool header)
 /***********************************************************************/
 int BLKFAM::ReadBuffer(PGLOBAL g)
   {
-  int i, n, rc = RC_OK;
-
-  /*********************************************************************/
-  /*  Sequential reading when Placed is not true.                      */
-  /*********************************************************************/
-  if (Placed) {
-    Placed = false;
-  } else if (++CurNum < Rbuf) {
-    CurLine = NxtLine;
-
-    // Get the position of the next line in the buffer
-    while (*NxtLine++ != '\n') ;
-
-    // Set caller line buffer
-    n = NxtLine - CurLine - Ending;
-    memcpy(Tdbp->GetLine(), CurLine, n);
-    Tdbp->GetLine()[n] = '\0';
-    goto fin;
-  } else if (Rbuf < Nrec && CurBlk != -1) {
-    return RC_EF;
-  } else {
-    /*******************************************************************/
-    /*  New block.                                                     */
-    /*******************************************************************/
-    CurNum = 0;
-
-    if (++CurBlk >= Block)
-      return RC_EF;
-
-  } // endif's
-
-  if (OldBlk == CurBlk)
-    goto ok;         // Block is already there
-
-  // fseek is required only in non sequential reading
-  if (CurBlk != OldBlk + 1)
-    if (fseek(Stream, BlkPos[CurBlk], SEEK_SET)) {
-      sprintf(g->Message, MSG(FSETPOS_ERROR), BlkPos[CurBlk]);
-      return RC_FX;
-      } // endif fseek
-
-  // Calculate the length of block to read
-  BlkLen = BlkPos[CurBlk + 1] - BlkPos[CurBlk];
-
-  if (trace)
-    htrc("File position is now %d\n", ftell(Stream));
-
-  // Read the entire next block
-  n = fread(To_Buf, 1, (size_t)BlkLen, Stream);
-
-  if (n == BlkLen) {
-//  ReadBlks++;
-    num_read++;
-    Rbuf = (CurBlk == Block - 1) ? Last : Nrec;
-
-   ok:
-    rc = RC_OK;
-
-    // Get the position of the current line
-    for (i = 0, CurLine = To_Buf; i < CurNum; i++)
-      while (*CurLine++ != '\n') ;      // What about Unix ???
-
-    // Now get the position of the next line
-    for (NxtLine = CurLine; *NxtLine++ != '\n';) ;
-
-    // Set caller line buffer
-    n = NxtLine - CurLine - Ending;
-    memcpy(Tdbp->GetLine(), CurLine, n);
-    Tdbp->GetLine()[n] = '\0';
-  } else if (feof(Stream)) {
-    rc = RC_EF;
-  } else {
-#if defined(UNIX)
-    sprintf(g->Message, MSG(READ_ERROR), To_File, strerror(errno));
-#else
-    sprintf(g->Message, MSG(READ_ERROR), To_File, _strerror(NULL));
-#endif
-
-    if (trace)
-      htrc("%s\n", g->Message);
-
-    return RC_FX;
-  } // endelse
-
-  OldBlk = CurBlk;         // Last block actually read
-  IsRead = true;           // Is read indeed
-
- fin:
-  // Store the current record file position for Delete and Update
-  Fpos = BlkPos[CurBlk] + CurLine - To_Buf;
-  return rc;
+  strcpy(g->Message, "This AM cannot be used in this version");
+  return RC_FX;
   } // end of ReadBuffer
 
 /***********************************************************************/

storage/connect/filamtxt.h

@@ -39,10 +39,10 @@ class DllExport TXTFAM : public BLOCK {
   virtual int   GetNextPos(void) = 0;
   virtual PTXF  Duplicate(PGLOBAL g) = 0;
   virtual bool  GetUseTemp(void) {return false;}
-  virtual  int   GetDelRows(void) {return DelRows;}
+  virtual int   GetDelRows(void) {return DelRows;}
           int   GetCurBlk(void) {return CurBlk;}
           void  SetTdbp(PTDBDOS tdbp) {Tdbp = tdbp;}
-          int    GetBlock(void) {return Block;}
+          int   GetBlock(void) {return Block;}
           void  SetBlkPos(int *bkp) {BlkPos = bkp;}
           void  SetNrec(int n) {Nrec = n;}
           char *GetBuf(void) {return To_Buf;}
@@ -53,7 +53,6 @@ class DllExport TXTFAM : public BLOCK {
   virtual void  Reset(void);
   virtual int   GetFileLength(PGLOBAL g);
   virtual int   Cardinality(PGLOBAL g);
-  virtual int   MaxBlkSize(PGLOBAL g, int s);
   virtual bool  AllocateBuffer(PGLOBAL g) {return false;}
   virtual void  ResetBuffer(PGLOBAL g) {}
   virtual int   GetNerr(void) {return 0;}
@@ -71,19 +70,19 @@ class DllExport TXTFAM : public BLOCK {
 
  protected:
   // Members
-  PTDBDOS Tdbp;               // To table class
+  PTDBDOS Tdbp;              // To table class
   PSZ     To_File;           // Points to table file name
   PFBLOCK To_Fb;             // Pointer to file block
-  bool    Placed;             // true if Recpos was externally set
+  bool    Placed;            // true if Recpos was externally set
   bool    IsRead;            // false for deferred reading
   bool    Blocked;           // true if using blocked I/O
   char   *To_Buf;            // Points to I/O buffer
   void   *DelBuf;            // Buffer used to move lines in Delete
   int    *BlkPos;            // To array of block positions
-  int     BlkLen;             // Current block length
+  int     BlkLen;            // Current block length
   int     Buflen;            // Buffer length
   int     Dbflen;            // Delete buffer length
-  int     Rows;               // Number of rows read so far
+  int     Rows;              // Number of rows read so far
   int     DelRows;           // Number of deleted rows
   int     Headlen;           // Number of bytes in header
   int     Lrecl;             // Logical Record Length
@@ -93,14 +92,14 @@ class DllExport TXTFAM : public BLOCK {
   int     OldBlk;            // Index of last read block
   int     CurBlk;            // Index of current block
   int     CurNum;            // Current buffer line number
-  int     ReadBlks;           // Number of blocks read (selected)
+  int     ReadBlks;          // Number of blocks read (selected)
   int     Rbuf;              // Number of lines read in buffer
   int     Modif;             // Number of modified lines in block
   int     Blksize;           // Size of padded blocks
-  int     Ending;             // Length of line end
-  bool    Padded;             // true if fixed size blocks are padded
+  int     Ending;            // Length of line end
+  bool    Padded;            // true if fixed size blocks are padded
   bool    Eof;               // true if an EOF (0xA) character exists
-  char   *CrLf;               // End of line character(s)
+  char   *CrLf;              // End of line character(s)
   }; // end of class TXTFAM
 
 /***********************************************************************/
@@ -125,7 +124,6 @@ class DllExport DOSFAM : public TXTFAM {
   virtual void  Reset(void);
   virtual int   GetFileLength(PGLOBAL g);
   virtual int   Cardinality(PGLOBAL g);
-  virtual int   MaxBlkSize(PGLOBAL g, int s);
   virtual bool  AllocateBuffer(PGLOBAL g);
   virtual int   GetRowID(void);
   virtual bool  RecordPos(PGLOBAL g);
@@ -134,7 +132,7 @@ class DllExport DOSFAM : public TXTFAM {
   virtual bool  OpenTableFile(PGLOBAL g);
   virtual int   ReadBuffer(PGLOBAL g);
   virtual int   WriteBuffer(PGLOBAL g);
-  virtual int    DeleteRecords(PGLOBAL g, int irc);
+  virtual int   DeleteRecords(PGLOBAL g, int irc);
   virtual void  CloseTableFile(PGLOBAL g);
   virtual void  Rewind(void);
 
@@ -174,7 +172,6 @@ class DllExport BLKFAM : public DOSFAM {
   // Methods
   virtual void  Reset(void);
   virtual int   Cardinality(PGLOBAL g);
-  virtual int   MaxBlkSize(PGLOBAL g, int s);
   virtual bool  AllocateBuffer(PGLOBAL g);
   virtual int   GetRowID(void);
   virtual bool  RecordPos(PGLOBAL g);

storage/connect/filamvct.cpp

@@ -244,23 +244,6 @@ bool VCTFAM::SetBlockInfo(PGLOBAL g)
   return rc;
   } // end of SetBlockInfo
 
-/***********************************************************************/
-/*  Use BlockTest to reduce the table estimated size.                  */
-/***********************************************************************/
-int VCTFAM::MaxBlkSize(PGLOBAL g, int s)
-  {
-  int  savcur = CurBlk;
-  int size;
-
-  // Roughly estimate the table size as the sum of blocks
-  // that can contain good rows
-  for (size = 0, CurBlk = 0; CurBlk < Block; CurBlk++)
-    size += (CurBlk == Block - 1) ? Last : Nrec;
-
-  CurBlk = savcur;
-  return size;
-  } // end of MaxBlkSize
-
 /***********************************************************************/
 /*  VCT Cardinality: returns table cardinality in number of rows.      */
 /*  This function can be called with a null argument to test the       */

storage/connect/filamvct.h

@@ -40,7 +40,6 @@ class DllExport VCTFAM : public FIXFAM {
 
   // Methods
   virtual void Reset(void);
-  virtual int  MaxBlkSize(PGLOBAL g, int s);
   virtual bool AllocateBuffer(PGLOBAL g);
   virtual bool InitInsert(PGLOBAL g);
   virtual void ResetBuffer(PGLOBAL g) {}
@@ -74,11 +73,11 @@ class DllExport VCTFAM : public FIXFAM {
   char   *Colfn;            // Pattern for column file names (VER)
   char   *Tempat;           // Pattern for temp file names (VER)
   int    *Clens;            // Pointer to col size array
-  int    *Deplac;            // Pointer to col start position array
+  int    *Deplac;           // Pointer to col start position array
   bool   *Isnum;            // Pointer to buffer type isnum result
   bool    AddBlock;         // True when adding new blocks on Insert
   bool    Split;            // true: split column file vector format
-  int     Header;            // 0: no, 1: separate, 2: in data file
+  int     Header;           // 0: no, 1: separate, 2: in data file
   int     MaxBlk;           // Max number of blocks (True vector format)
   int     Bsize;            // Because Nrec can be modified
   int     Ncol;             // The number of columns;
@@ -164,7 +163,7 @@ class DllExport VECFAM : public VCTFAM {
   FILE*   *T_Streams;           // Points to temp file structure array
   PFBLOCK *To_Fbs;              // Pointer to file block array
   PFBLOCK *T_Fbs;               // Pointer to temp file block array
-  void*   *To_Bufs;              // Pointer to col val block array
+  void*   *To_Bufs;             // Pointer to col val block array
   bool     InitUpdate;          // Used to initialize updating
   }; // end of class VECFAM
 
@@ -189,7 +188,7 @@ class DllExport VMPFAM : public VCMFAM {
 
   // Database routines
   virtual bool OpenTableFile(PGLOBAL g);
-  virtual int   DeleteRecords(PGLOBAL g, int irc);
+  virtual int  DeleteRecords(PGLOBAL g, int irc);
   virtual void CloseTableFile(PGLOBAL g);
 
  protected:
@@ -220,7 +219,7 @@ class BGVFAM : public VCTFAM {
   // Database routines
   virtual bool OpenTableFile(PGLOBAL g);
   virtual int  WriteBuffer(PGLOBAL g);
-  virtual int   DeleteRecords(PGLOBAL g, int irc);
+  virtual int  DeleteRecords(PGLOBAL g, int irc);
   virtual void CloseTableFile(PGLOBAL g);
   virtual void Rewind(void);
 
@@ -233,11 +232,11 @@ class BGVFAM : public VCTFAM {
           bool BigRead(PGLOBAL g, HANDLE h, void *inbuf, int req);
           bool BigWrite(PGLOBAL g, HANDLE h, void *inbuf, int req);
   virtual bool MakeEmptyFile(PGLOBAL g, char *fn);
-  virtual  bool OpenTempFile(PGLOBAL g);
+  virtual bool OpenTempFile(PGLOBAL g);
   virtual bool MoveIntermediateLines(PGLOBAL g, bool *b = NULL);
   virtual bool CleanUnusedSpace(PGLOBAL g);
-  virtual  bool SetBlockInfo(PGLOBAL g);
-  virtual  int  GetBlockInfo(PGLOBAL g);
+  virtual bool SetBlockInfo(PGLOBAL g);
+  virtual int  GetBlockInfo(PGLOBAL g);
 
   // Members
   HANDLE  Hfile;                // Handle to big file

storage/connect/filamzip.cpp

@@ -403,7 +403,7 @@ ZBKFAM::ZBKFAM(PDOSDEF tdp) : ZIPFAM(tdp)
   CurLine = NULL;
   NxtLine = NULL;
   Closing = false;
-  BlkPos = tdp->GetTo_Pos();
+  BlkPos = NULL;
   } // end of ZBKFAM standard constructor
 
 ZBKFAM::ZBKFAM(PZBKFAM txfp) : ZIPFAM(txfp)
@@ -413,23 +413,6 @@ ZBKFAM::ZBKFAM(PZBKFAM txfp) : ZIPFAM(txfp)
   Closing = txfp->Closing;
   } // end of ZBKFAM copy constructor
 
-/***********************************************************************/
-/*  Use BlockTest to reduce the table estimated size.                  */
-/***********************************************************************/
-int ZBKFAM::MaxBlkSize(PGLOBAL g, int s)
-  {
-  int  savcur = CurBlk;
-  int size;
-
-  // Roughly estimate the table size as the sum of blocks
-  // that can contain good rows
-  for (size = 0, CurBlk = 0; CurBlk < Block; CurBlk++)
-    size += (CurBlk == Block - 1) ? Last : Nrec;
-
-  CurBlk = savcur;
-  return size;
-  } // end of MaxBlkSize
-
 /***********************************************************************/
 /*  ZBK Cardinality: returns table cardinality in number of rows.      */
 /*  This function can be called with a null argument to test the       */
@@ -509,56 +492,8 @@ int ZBKFAM::SkipRecord(PGLOBAL g, bool header)
 /***********************************************************************/
 int ZBKFAM::ReadBuffer(PGLOBAL g)
   {
-  int     n, rc = RC_OK;
-
-  /*********************************************************************/
-  /*  Sequential reading when Placed is not true.                      */
-  /*********************************************************************/
-  if (++CurNum < Rbuf) {
-    CurLine = NxtLine;
-
-    // Get the position of the next line in the buffer
-    while (*NxtLine++ != '\n') ;
-
-    // Set caller line buffer
-    n = NxtLine - CurLine - Ending;
-    memcpy(Tdbp->GetLine(), CurLine, n);
-    Tdbp->GetLine()[n] = '\0';
-    return RC_OK;
-  } else if (Rbuf < Nrec && CurBlk != -1)
-    return RC_EF;
-
-  /*********************************************************************/
-  /*  New block.                                                       */
-  /*********************************************************************/
-  CurNum = 0;
-
-  if (++CurBlk >= Block)
-    return RC_EF;
-
-  BlkLen = BlkPos[CurBlk + 1] - BlkPos[CurBlk];
-
-  if (!(n = gzread(Zfile, To_Buf, BlkLen))) {
-    rc = RC_EF;
-  } else if (n > 0) {
-    // Get the position of the current line
-    CurLine = To_Buf;
-
-    // Now get the position of the next line
-    for (NxtLine = CurLine; *NxtLine++ != '\n';) ;
-
-    // Set caller line buffer
-    n = NxtLine - CurLine - Ending;
-    memcpy(Tdbp->GetLine(), CurLine, n);
-    Tdbp->GetLine()[n] = '\0';
-    Rbuf = (CurBlk == Block - 1) ? Last : Nrec;
-    IsRead = true;
-    rc = RC_OK;
-    num_read++;
-  } else
-    rc = Zerror(g);
-
-  return rc;
+  strcpy(g->Message, "This AM cannot be used in this version");
+  return RC_FX;
   } // end of ReadBuffer
 
 /***********************************************************************/
@@ -770,9 +705,6 @@ int ZIXFAM::ReadBuffer(PGLOBAL g)
   CurNum = 0;
   Tdbp->SetLine(To_Buf);
 
-//if (++CurBlk >= Block)
-//  return RC_EF;
-
   if (!(n = gzread(Zfile, To_Buf, Buflen))) {
     rc = RC_EF;
   } else if (n > 0) {

storage/connect/filamzip.h

@@ -38,7 +38,6 @@ class DllExport ZIPFAM : public TXTFAM {
   virtual void Reset(void);
   virtual int  GetFileLength(PGLOBAL g);
   virtual int  Cardinality(PGLOBAL g) {return (g) ? -1 : 0;}
-  virtual int  MaxBlkSize(PGLOBAL g, int s) {return s;}
   virtual bool AllocateBuffer(PGLOBAL g);
   virtual int  GetRowID(void);
   virtual bool RecordPos(PGLOBAL g);
@@ -78,7 +77,6 @@ class DllExport ZBKFAM : public ZIPFAM {
 
   // Methods
   virtual int  Cardinality(PGLOBAL g);
-  virtual int  MaxBlkSize(PGLOBAL g, int s);
   virtual bool AllocateBuffer(PGLOBAL g);
   virtual int  GetRowID(void);
   virtual bool RecordPos(PGLOBAL g);
@@ -122,7 +120,7 @@ class DllExport ZIXFAM : public ZBKFAM {
   // No additional Members
   }; // end of class ZIXFAM
 
-#ifdef NOT_USED
+#if 0
 /***********************************************************************/
 /*  This is the DOS/UNIX Access Method class declaration for PlugDB    */
 /*  fixed/variable files compressed using the zlib library functions.  */
@@ -166,6 +164,6 @@ class DllExport ZLBFAM : public BLKFAM {
   int      *Zlenp;            // Pointer to block length
   bool      Optimized;        // true when opt file is available
   }; // end of class ZLBFAM
-#endif // NOT_USED
+#endif // 0
 
 #endif // __FILAMZIP_H

storage/connect/global.h

@@ -222,9 +222,6 @@ typedef struct _global {            /* Global structure                */
   int       Createas;               /* To pass info to created table   */
   void     *Xchk;                   /* indexes in create/alter         */
   short     Alchecked;              /* Checked for ALTER               */
-#if defined(MRRBKA_SUPPORT)
-  short     Mrr;                    /* True when doing mrr             */
-#endif   // MRRBKA_SUPPORT
   short     Trace;
   int       jump_level;
   jmp_buf   jumper[MAX_JUMP + 2];

storage/connect/ha_connect.h

@@ -122,8 +122,6 @@ struct ha_table_option_struct {
 struct ha_field_option_struct
 {
   ulonglong offset;
-  ulonglong freq;      // Not used by this version
-  ulonglong opt;       // Not used by this version
   ulonglong fldlen;
   const char *dateformat;
   const char *fieldformat;
@@ -243,11 +241,7 @@ class ha_connect: public handler
   */
   ulong index_flags(uint inx, uint part, bool all_parts) const
   {
-    return HA_READ_NEXT | HA_READ_RANGE | HA_READ_ORDER
-#if defined(MRRBKA_SUPPORT)
-         | HA_KEYREAD_ONLY
-#endif   // MRRBKA_SUPPORT
-      ;
+    return HA_READ_NEXT | HA_READ_RANGE | HA_READ_ORDER | HA_KEYREAD_ONLY;
   } // end of index_flags
 
   /** @brief
@@ -334,7 +328,7 @@ class ha_connect: public handler
    condition stack.
  */ 
 virtual const COND *cond_push(const COND *cond);
-PFIL  CheckCond(PGLOBAL g, PFIL filp, AMT tty, Item *cond);
+PCFIL CheckCond(PGLOBAL g, PCFIL filp, AMT tty, Item *cond);
 const char *GetValStr(OPVAL vop, bool neg);
 
  /**
@@ -424,6 +418,9 @@ const char *GetValStr(OPVAL vop, bool neg);
   */
 //int index_last(uchar *buf);
 
+  /* Index condition pushdown implementation */
+//Item *idx_cond_push(uint keyno, Item* idx_cond);
+
   /** @brief
     Unlike index_init(), rnd_init() can be called two consecutive times
     without rnd_end() in between (it only makes sense if scan=1). In this
@@ -499,28 +496,4 @@ const char *GetValStr(OPVAL vop, bool neg);
   char   *index_file_name;
   uint    int_table_flags;            // Inherited from MyISAM
   bool    enable_activate_all_index;  // Inherited from MyISAM
-
-#if defined(MRRBKA_SUPPORT)
-  /**
-   * Multi Range Read interface
-   */
-  int multi_range_read_init(RANGE_SEQ_IF *seq, void *seq_init_param,
-                            uint n_ranges, uint mode, HANDLER_BUFFER *buf);
-  int multi_range_read_next(range_id_t *range_info);
-  ha_rows multi_range_read_info_const(uint keyno, RANGE_SEQ_IF *seq,
-                                      void *seq_init_param, 
-                                      uint n_ranges, uint *bufsz,
-                                      uint *flags, Cost_estimate *cost);
-  ha_rows multi_range_read_info(uint keyno, uint n_ranges, uint keys,
-                                uint key_parts, uint *bufsz, 
-                                uint *flags, Cost_estimate *cost);
-  int multi_range_read_explain_info(uint mrr_mode, char *str, size_t size);
-
-  int reset(void) {ds_mrr.dsmrr_close(); return 0;}
-
-  /* Index condition pushdown implementation */
-//  Item *idx_cond_push(uint keyno, Item* idx_cond);
-private:
-  DsMrr_impl ds_mrr;
-#endif   // MRRBKA_SUPPORT
 };  // end of ha_connect class definition

storage/connect/myconn.h

@@ -63,15 +63,10 @@ class DllItem MYSQLC {
   bool   Connected(void);
 
   // Methods
-//  int     GetCurPos(void) {return (m_Res) ? N : 0;}
-//  int     GetProgCur(void) {return N;}
   int     GetResultSize(PGLOBAL g, PSZ sql);
   int     Open(PGLOBAL g, const char *host, const char *db,
                           const char *user= "root", const char *pwd= "*",
                           int pt= 0);
-//ulong   GetThreadID(void);
-//ulong   ServerVersion(void);
-//const char *ServerInfo(void);
   int     KillQuery(ulong id);
   int     ExecSQL(PGLOBAL g, const char *query, int *w = NULL);
   int     ExecSQLcmd(PGLOBAL g, const char *query, int *w);
@@ -87,7 +82,6 @@ class DllItem MYSQLC {
   void    Rewind(void);
   void    FreeResult(void);
   void    Close(void);
-//void    DiscardResults(void);
 
  protected:
   MYSQL_FIELD *GetNextField(void);

storage/connect/plgcnx.h

@@ -62,146 +62,6 @@ enum INFO {INDX_RC,                  /* Index of PlugDB return code field */
            INDX_SIZE,                /* Index of returned data size field */
            INDX_MAX};                /* Size of info array                */
 
-#ifdef NOT_USED
-/**************************************************************************/
-/*  Internal message types.                                               */
-/**************************************************************************/
-enum MSGTYP {MST_OPEN      = 10,     /* Code for old connecting message   */
-             MST_COMMAND   = 11,     /* Code for send command message     */
-             MST_RESULT    = 12,     /* Code for get result message       */
-             MST_CLOSE     = 13,     /* Code for disconnecting message    */
-             MST_PROGRESS  = 14,     /* Code for progress message         */
-             MST_CANCEL    = 15,     /* Code for cancel message           */
-             MST_PROCESSED = 16,     /* Code for already processed msg    */
-             MST_ERROR     = 17,     /* Code for get error message        */
-             MST_CHAR      = 18,     /* Code for get char value message   */
-             MST_LONG      = 19,     /* Code for get int value message   */
-             MST_COLUMN    = 20,     /* Code for get col  value message   */
-             MST_MESSAGE   = 21,     /* Code for get message    message   */
-             MST_HEADER    = 22,     /* Code for get header     message   */
-             MST_SOCKET    = 23,     /* Code for socket error   message   */
-             MST_SHUTDOWN  = 24,     /* Code for shutdown       message   */
-             MST_SOCKPROG  = 25,     /* Code for socket progress message  */
-             MST_POST      = 26,     /* Code for post command message     */
-             MST_NEW_OPEN  = 27,     /* Code for new connecting message   */
-             MST_PROG_NUM  =  5};    /* Num of integers in progress msg   */
-
-/**************************************************************************/
-/*  Vendors.                                                              */
-/**************************************************************************/
-enum VENDOR {VDR_UNKNOWN   = -2,     /* Not known or not connected        */
-             VDR_PlugDB    = -1,     /* PlugDB                           */
-             VDR_OTHER     =  0};    /* OEM                               */
-
-/**************************************************************************/
-/*  Attribute keys of Result Description structure (arranged by type).    */
-/**************************************************************************/
-enum CKEYS {K_ProgMsg, K_Lang, K_ActiveDB, K_Cmax};
-enum LKEYS {K_NBcol, K_NBlin, K_CurPos, K_RC, K_Result, K_Elapsed,
-            K_Continued, K_Maxsize, K_Affrows, K_Lmax, K_Maxcol,
-            K_Maxres, K_Maxlin, K_NBparm};
-enum NKEYS {K_Type, K_Length, K_Prec, K_DataLen, K_Unsigned, K_Nmax};
-
-/**************************************************************************/
-/*  Result description structures.                                        */
-/**************************************************************************/
-typedef struct _MsgTagAttr {
-  bool   fSupplied;
-  char   Attr[MAXMESSAGE];
-  } MTAG, *PMTAG;
-
-typedef struct _CharTagAttr {
-  bool   fSupplied;
-  char   Attr[MAXDBNAME];
-  } CTAG, *PCTAG;
-
-typedef struct _LongTagAttr {
-  bool   fSupplied;
-  int   Attr;
-  } LTAG, *PLTAG;
-
-typedef struct _ColVar {
-  LTAG   Lat[K_Nmax];
-  CTAG   Cat;
-  } COLVAR, *LPCOLVAR;
-
-typedef struct _ResDesc {
-  int   Maxcol;                                 /* Max number of columns */
-  int   Colnum;                                 /* Number of columns     */
-  MTAG   Mat;                                    /* Message               */
-  CTAG   Cat[K_Cmax];                            /* Character attributes  */
-  LTAG   Lat[K_Lmax];                            /* Long int  attributes  */
-  COLVAR Col[1];                                 /* Column    attributes  */
-  } RDESC, *PRDESC;
-
-/**************************************************************************/
-/*  Exported PlugDB client functions in Plgcnx DLL.                       */
-/**************************************************************************/
-#if !defined(CNXFUNC)
-#if defined(UNIX) || defined(UNIV_LINUX)
-#undef __stdcall
-#define __stdcall
-#endif
-
-#if defined(NOLIB)                         /* Dynamic link of plgcnx.dll  */
-#define CNXFUNC(f)    (__stdcall *f)
-#else      /* LIB */                       /* Static link with plgcnx.lib */
-#define CNXFUNC(f)    __stdcall f
-#endif
-#endif
-
-#if !defined(CNXKEY)
-#define CNXKEY         uint
-#endif
-
-#if !defined(XTRN)
-#define XTRN
-#endif
-
-//#if !defined(NO_FUNC)
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-XTRN int CNXFUNC(PLGConnect)     (CNXKEY *, const char *, bool);
-XTRN int CNXFUNC(PLGSendCommand) (CNXKEY, const char *, void *, int, int *);
-XTRN int CNXFUNC(PLGGetResult)   (CNXKEY, void *, int, int *, bool);
-XTRN int CNXFUNC(PLGDisconnect)  (CNXKEY);
-XTRN int CNXFUNC(PLGGetErrorMsg) (CNXKEY, char *, int, int *);
-XTRN bool CNXFUNC(PLGGetCharValue)(CNXKEY, char *, int, int);
-XTRN bool CNXFUNC(PLGGetIntValue)(CNXKEY, int *, int);
-XTRN bool CNXFUNC(PLGGetColValue) (CNXKEY, int *, int, int);
-XTRN bool CNXFUNC(PLGGetMessage)  (CNXKEY, char *, int);
-XTRN bool CNXFUNC(PLGGetHeader)   (CNXKEY, char *, int, int, int);
-
-#ifdef __cplusplus
-}
-#endif
-//#endif /* !NO_FUNC */
-
-/**************************************************************************/
-/*  Convenience function Definitions                                      */
-/**************************************************************************/
-#define PLGPostCommand(T,C)    PLGSendCommand(T,C,NULL,0,NULL)
-#if defined(FNCMAC)
-#define PLGGetProgMsg(T,C,S)   PLGGetCharValue(T,C,S,K_ProgMsg)
-#define PLGGetLangID(T,C,S)    PLGGetCharValue(T,C,S,K_Lang)
-#define PLGGetActiveDB(T,C,S)  PLGGetCharValue(T,C,S,K_ActiveDB)
-#define PLGGetCursorPos(T,L)   PLGGetIntValue(T,L,K_CurPos)
-#define PLGGetResultType(T,L)  PLGGetIntValue(T,L,K_Result)
-#define PLGGetNBcol(T,L)       PLGGetIntValue(T,L,K_NBcol)
-#define PLGGetNBlin(T,L)       PLGGetIntValue(T,L,K_NBlin)
-#define PLGGetRetCode(T,L)     PLGGetIntValue(T,L,K_RC)
-#define PLGGetElapsed(T,L)     PLGGetIntValue(T,L,K_Elapsed)
-#define PLGGetContinued(T,L)   PLGGetIntValue(T,L,K_Continued)
-#define PLGGetMaxSize(T,L)     PLGGetIntValue(T,L,K_Maxsize)
-#define PLGGetLength(T,L,C)    PLGGetColValue(T,L,K_Length,C)
-#define PLGGetDataSize(T,L,C)  PLGGetColValue(T,L,K_DataLen,C)
-#define PLGGetDecimal(T,L,C)   PLGGetColValue(T,L,K_Prec,C)
-#define PLGGetType(T,L,C)      PLGGetColValue(T,L,K_Type,C)
-#endif  /* FNCMAC */
-#endif // NOT_USED
-
 #endif  /* !_PLGCNX_H */
 
 /* ------------------------- End of Plgcnx.h ---------------------------- */

storage/connect/plgdbsem.h

@@ -26,7 +26,6 @@
 
 enum BLKTYP {TYPE_TABLE      = 50,    /* Table Name/Srcdef/... Block   */
              TYPE_COLUMN     = 51,    /* Column Name/Qualifier Block   */
-//           TYPE_OPVAL      = 52,    /* Operator value (OPVAL)        */
              TYPE_TDB        = 53,    /* Table Description Block       */
              TYPE_COLBLK     = 54,    /* Column Description Block      */
              TYPE_PSZ        = 64,    /* Pointer to String ended by 0  */
@@ -34,8 +33,6 @@ enum BLKTYP {TYPE_TABLE      = 50,    /* Table Name/Srcdef/... Block   */
              TYPE_XOBJECT    = 69,    /* Extended DB object            */
              TYPE_COLCRT     = 71,    /* Column creation block         */
              TYPE_CONST      = 72,    /* Constant                      */
-//           TYPE_INDEXDEF   = 73,    /* Index definition block        */
-//           TYPE_OPER       = 74,    /* Operator block (OPER)         */
 
 /*-------------------- type tokenized string --------------------------*/
              TYPE_DATE       =  8,    /* Timestamp                     */
@@ -144,21 +141,19 @@ enum RECFM {RECFM_NAF   =    -2,      /* Not a file                    */
             RECFM_PLG   =     5,      /* Table accessed via PLGconn    */
             RECFM_DBF   =     6};     /* DBase formatted file          */
 
-#if 0
 enum MISC {DB_TABNO     =     1,      /* DB routines in Utility Table  */
            MAX_MULT_KEY =    10,      /* Max multiple key number       */
            NAM_LEN      =   128,      /* Length of col and tab names   */
            ARRAY_SIZE   =    50,      /* Default array block size      */
-           MAXRES       =   500,      /* Default maximum result lines  */
-           MAXLIN       = 10000,      /* Default maximum data lines    */
+//         MAXRES       =   500,      /* Default maximum result lines  */
+//         MAXLIN       = 10000,      /* Default maximum data lines    */
            MAXBMP       =    32};     /* Default XDB2 max bitmap size  */
 
+#if 0
 enum ALGMOD {AMOD_AUTO =  0,          /* PLG chooses best algorithm    */
              AMOD_SQL  =  1,          /* Use SQL algorithm             */
              AMOD_QRY  =  2};         /* Use QUERY algorithm           */
-#else   // !0
-#define    NAM_LEN          128
-#endif // !0
+#endif // 0
 
 enum MODE {MODE_ERROR   = -1,         /* Invalid mode                  */
            MODE_ANY     =  0,         /* Unspecified mode              */
@@ -342,9 +337,7 @@ typedef class XTAB       *PTABLE;
 typedef class COLUMN     *PCOLUMN;
 typedef class XOBJECT    *PXOB;
 typedef class COLBLK     *PCOL;
-typedef class TBX        *PTBX;
 typedef class TDB        *PTDB;
-typedef       void       *PSQL;          // Not used
 typedef class TDBASE     *PTDBASE;
 typedef class TDBDOS     *PTDBDOS;
 typedef class TDBFIX     *PTDBFIX;
@@ -413,41 +406,25 @@ typedef struct _mblock {               /* Memory block                 */
 /*  The QUERY application User Block.                                  */
 /***********************************************************************/
 typedef struct {                       /* User application block       */
-//void      *Act2;                     /* RePoint to activity block    */
-//short      LineLen;                  /* Current output line len      */
   NAME       Name;                     /* User application name        */
-//NAME       Password;                 /* User application password    */
-//PSZ        UserFile;                 /* User application filename    */
   char       Server[17];               /* Server name                  */
   char       DBName[17];               /* Current database name        */
-//char       Host[65];                 /* Caller's host name           */
-//char       User[17];                 /* Caller's user name           */
-//uint       Granted;                  /* Grant bitmap                 */
   PCATLG     Catalog;                  /* To CATALOG class             */
   PQRYRES    Result;                   /* To query result blocks       */
   PFBLOCK    Openlist;                 /* To file/map open list        */
   PMBLOCK    Memlist;                  /* To memory block list         */
   PXUSED     Xlist;                    /* To used index list           */
-//int        Maxres;                   /* Result Max nb of lines       */
-//int        Maxtmp;                   /* Intermediate tables Maxres   */
-//int        Maxlin;                   /* Query Max nb of data lines   */
-//int        Maxbmp;                   /* Maximum XDB2 bitmap size     */
   int        Check;                    /* General level of checking    */
   int        Numlines;                 /* Number of lines involved     */
-//ALGMOD     AlgChoice;                /* Choice of algorithm mode     */
-//AREADEF    DescArea;                 /* Table desc. area size        */
   USETEMP    UseTemp;                  /* Use temporary file           */
-//int        Curtype;                  /* 0: static else: dynamic      */
   int        Vtdbno;                   /* Used for TDB number setting  */
   bool       Remote;                   /* true: if remotely called     */
-//bool       NotFinal;                 /* true: for intermediate table */
   bool       Proginfo;                 /* true: return progress info   */
   bool       Subcor;                   /* Used for Progress info       */
   size_t     ProgMax;                  /* Used for Progress info       */
   size_t     ProgCur;                  /* Used for Progress info       */
   size_t     ProgSav;                  /* Used for Progress info       */
   LPCSTR     Step;                     /* Execution step name          */
-//char       Work[_MAX_PATH];          /* Local work path              */
   } DBUSERBLK, *PDBUSER;
 
 /***********************************************************************/
@@ -578,9 +555,6 @@ DllExport void    PlgDBfree(MBLOCK&);
 DllExport void   *PlgDBSubAlloc(PGLOBAL g, void *memp, size_t size);
 DllExport void   *PlgDBalloc(PGLOBAL, void *, MBLOCK&);
 DllExport void   *PlgDBrealloc(PGLOBAL, void *, MBLOCK&, size_t);
-//lExport PSZ     GetIniString(PGLOBAL, void *, LPCSTR, LPCSTR, LPCSTR, LPCSTR);
-//lExport int     GetIniSize(char *, char *, char *, char *);
-//lExport bool    WritePrivateProfileInt(LPCSTR, LPCSTR, int, LPCSTR);
 DllExport void    NewPointer(PTABS, void *, void *);
 DllExport char    *GetIni(int n= 0);
 DllExport void    SetTrc(void);

storage/connect/plugutil.c

@@ -153,9 +153,6 @@ PGLOBAL PlugInit(LPCSTR Language, uint worksize)
     g->Trace = 0;
     g->Createas = 0;
     g->Alchecked = 0;
-#if defined(MRRBKA_SUPPORT)
-    g->Mrr = 0;
-#endif   // MRRBKA_SUPPORT
     g->Activityp = g->ActivityStart = NULL;
     g->Xchk = NULL;
     strcpy(g->Message, "");

storage/connect/preparse.h

@@ -3,31 +3,6 @@
 
 #include "checklvl.h"
 
-/***********************************************************************/
-/*  Struct of variables used by the SQL pre-parsers.                   */
-/***********************************************************************/
-typedef struct _prepar {
-  struct _prepar *Next;
-  char *Debinp;           // Start of input buffer
-  char *Endinp;           // End of input buffer
-  char *Pluginp;          // Points on current parsing position
-  char *Plugbuf;          // Start of output buffer
-  char *Plugptr;          // Current output position
-  char *Debchar;          // Next/current start of command
-  char *Debselp;          // Beginning of selection
-  char *Debline;          // Start of current line
-  char *Plugpar[32];      // Parameters
-  int   Numparms;         // Number of defined parameters
-  int   Nprms;            // Number of ODBC parameters
-  int   Lines;            // Line number
-  int   Chars;            // Index of selection start in line
-  int   Endchars;         // Index of selection end in line
-  int   Frinp, Frbuf;     // 0: no, 1: free, 2: delete Debinp/Plugbuf
-  int   Outsize;          // Size of output buffer
-  FILE *Argfile;          // File containing arguments
-  int   Addargs;          // 1 if arguments are added to the list
-  } PREPAR, *PPREP;
-
 /***********************************************************************/
 /*  Struct of variables used by the date format pre-parser.            */
 /***********************************************************************/
@@ -49,8 +24,6 @@ typedef struct _datpar {
 extern "C" {
 #endif
 
-int sqlflex(PPREP pp);
-int sqpflex(PPREP pp);
 int fmdflex(PDTP pp);
 
 #ifdef __cplusplus

storage/connect/reldef.cpp

@@ -204,6 +204,7 @@ PTABDEF OEMDEF::GetXdef(PGLOBAL g)
   return xdefp;
   } // end of GetXdef
 
+#if 0
 /***********************************************************************/
 /*  DeleteTableFile: Delete an OEM table file if applicable.           */
 /***********************************************************************/
@@ -214,6 +215,7 @@ bool OEMDEF::DeleteTableFile(PGLOBAL g)
 
   return (Pxdef) ? Pxdef->DeleteTableFile(g) : true;
   } // end of DeleteTableFile
+#endif // 0
 
 /***********************************************************************/
 /*  Define: initialize the table definition block from XDB file.       */
@@ -286,7 +288,6 @@ PTDB OEMDEF::GetTable(PGLOBAL g, MODE mode)
         txfp = new(g) ZIPFAM(defp);
       else {
         strcpy(g->Message, "Compress 2 not supported yet");
-//      txfp = new(g) ZLBFAM(defp);
         return NULL;
       } // endelse
 #else   // !ZIP_SUPPORT
@@ -341,7 +342,6 @@ COLCRT::COLCRT(PSZ name)
   Precision = -1;
   Key = -1;
   Scale = -1;
-  Opt = -1;
   DataType = '*';
   } // end of COLCRT constructor for table creation
 
@@ -357,7 +357,6 @@ COLCRT::COLCRT(void)
   Precision = 0;
   Key = 0;
   Scale = 0;
-  Opt = 0;
   DataType = '*';
   } // end of COLCRT constructor for table & view definition
 
@@ -399,9 +398,7 @@ int COLDEF::Define(PGLOBAL g, void *memp, PCOLINFO cfp, int poff)
     Precision = cfp->Precision;
     Scale = cfp->Scale;
     Long = cfp->Length;
-    Opt = cfp->Opt;
     Key = cfp->Key;
-//  Freq = cfp->Freq;
 
     if (cfp->Remark && *cfp->Remark) {
       Desc = (PSZ)PlugSubAlloc(g, memp, strlen(cfp->Remark) + 1);

storage/connect/reldef.h

@@ -38,7 +38,6 @@ class DllExport RELDEF : public BLOCK {      // Relation definition block
   void    SetCat(PCATLG cat) { Cat=cat; }
 
   // Methods
-  virtual bool DeleteTableFile(PGLOBAL g) {return true;}
   virtual bool Indexable(void) {return false;}
   virtual bool Define(PGLOBAL g, PCATLG cat, LPCSTR name, LPCSTR am) = 0;
   virtual PTDB GetTable(PGLOBAL g, MODE mode) = 0;
@@ -116,7 +115,6 @@ class DllExport OEMDEF : public TABDEF {                  /* OEM table */
   virtual AMT  GetDefType(void) {return TYPE_AM_OEM;}
 
   // Methods
-  virtual bool DeleteTableFile(PGLOBAL g);
   virtual bool DefineAM(PGLOBAL g, LPCSTR am, int poff);
   virtual PTDB GetTable(PGLOBAL g, MODE mode);
 
@@ -147,7 +145,6 @@ class DllExport COLCRT : public BLOCK { /* Column description block
   PSZ  GetName(void) {return Name;}
   PSZ  GetDecode(void) {return Decode;}
   PSZ  GetFmt(void) {return Fmt;}
-  int  GetOpt(void) {return Opt;}
   int  GetLong(void) {return Long;}
   int  GetPrecision(void) {return Precision;}
   int  GetOffset(void) {return Offset;}
@@ -164,7 +161,6 @@ class DllExport COLCRT : public BLOCK { /* Column description block
   int     Key;                /* Key (greater than 1 if multiple)      */
   int     Precision;          /* Logical column length                 */
   int     Scale;              /* Decimals for float/decimal values     */
-  int     Opt;                /* 0:Not 1:clustered 2:sorted-asc 3:desc */
   char    DataType;           /* Internal data type (C, N, F, T)       */
   }; // end of COLCRT
 

storage/connect/tabcol.h

@@ -85,8 +85,6 @@ class DllExport COLUMN: public XOBJECT {  // Column Name/Qualifier block.
   virtual bool   Compare(PXOB) {assert(false); return false;}
   virtual bool   SetFormat(PGLOBAL, FORMAT&);
   virtual bool   Eval(PGLOBAL) {assert(false); return true;}
-  virtual int    CheckSpcCol(PTDB, int) {assert(false); return 2;}
-  virtual bool   CheckSort(PTDB) {assert(false); return false;}
 
  private:
   // Members

storage/connect/tabdos.h

 /*************** TabDos H Declares Source Code File (.H) ***************/
-/*  Name: TABDOS.H    Version 3.2                                      */
+/*  Name: TABDOS.H    Version 3.3                                      */
 /*                                                                     */
-/*  (C) Copyright to the author Olivier BERTRAND          1999-2012    */
+/*  (C) Copyright to the author Olivier BERTRAND          1999-2014    */
 /*                                                                     */
 /*  This file contains the DOS classes declares.                       */
 /***********************************************************************/
@@ -34,6 +34,7 @@ class DllExport DOSDEF : public TABDEF {  /* Logical table description */
   virtual const char *GetType(void) {return "DOS";}
   virtual PIXDEF      GetIndx(void) {return To_Indx;}
   virtual void        SetIndx(PIXDEF xdp) {To_Indx = xdp;}
+  virtual bool        IsHuge(void) {return Huge;}
   PSZ     GetFn(void) {return Fn;}
   PSZ     GetOfn(void) {return Ofn;}
   void    SetBlock(int block) {Block = block;}
@@ -46,11 +47,8 @@ class DllExport DOSDEF : public TABDEF {  /* Logical table description */
   bool    GetEof(void) {return Eof;}
   int     GetBlksize(void) {return Blksize;}
   int     GetEnding(void) {return Ending;}
-  int    *GetTo_Pos(void) {return To_Pos;}
-  virtual bool IsHuge(void) {return Huge;}
 
   // Methods
-  virtual bool DeleteTableFile(PGLOBAL g);
   virtual bool Indexable(void) {return Compressed != 1;}
   virtual bool DeleteIndexFile(PGLOBAL g, PIXDEF pxdf);
   virtual bool DefineAM(PGLOBAL g, LPCSTR am, int poff);
@@ -58,7 +56,7 @@ class DllExport DOSDEF : public TABDEF {  /* Logical table description */
           bool InvalidateIndex(PGLOBAL g);
 
  protected:
-  virtual bool Erase(char *filename);
+//virtual bool Erase(char *filename);
 
   // Members
   PSZ     Fn;                 /* Path/Name of corresponding file       */
@@ -70,7 +68,6 @@ class DllExport DOSDEF : public TABDEF {  /* Logical table description */
   bool    Huge;               /* true for files larger than 2GB        */
   bool    Accept;             /* true if wrong lines are accepted (DBF)*/
   bool    Eof;                /* true if an EOF (0xA) character exists */
-  int    *To_Pos;              /* To array of block starting positions  */
   int     Compressed;         /* 0: No, 1: gz, 2:zlib compressed file  */
   int     Lrecl;              /* Size of biggest record                */
   int     AvgLen;             /* Average size of records               */
@@ -88,14 +85,12 @@ class DllExport DOSDEF : public TABDEF {  /* Logical table description */
 /*  The last column (and record) is of variable length.                */
 /***********************************************************************/
 class DllExport TDBDOS : public TDBASE {
-//friend class KINDEX;
   friend class XINDEX;
   friend class DOSCOL;
   friend class MAPCOL;
   friend class TXTFAM;
   friend class DOSFAM;
   friend class VCTCOL;
-//friend class TDBMUL;
   friend RCODE CntDeleteRow(PGLOBAL, PTDB, bool);
  public:
   // Constructors
@@ -111,7 +106,6 @@ class DllExport TDBDOS : public TDBASE {
   inline  void  IncLine(int inc) {To_Line += inc;}
   inline  bool  IsRead(void) {return Txfp->IsRead;}
   inline  PXOB *GetLink(void) {return To_Link;}
-//inline  PCOL *GetKeyCol(void) {return To_Key_Col;}
 
   // Implementation
   virtual AMT   GetAmType(void) {return Txfp->GetAmType();}
@@ -127,15 +121,8 @@ class DllExport TDBDOS : public TDBASE {
   virtual PTDB  CopyOne(PTABS t);
   virtual void  ResetDB(void) {Txfp->Reset();}
   virtual bool  IsUsingTemp(PGLOBAL g);
-//virtual bool  NeedIndexing(PGLOBAL g);
   virtual void  ResetSize(void) {MaxSize = Cardinal = -1;}
   virtual int   ResetTableOpt(PGLOBAL g, bool dox);
-//virtual int   MakeBlockValues(PGLOBAL g);
-//virtual bool  SaveBlockValues(PGLOBAL g);
-//virtual bool  GetBlockValues(PGLOBAL g);
-//virtual PBF   InitBlockFilter(PGLOBAL g, PFIL filp);
-//virtual PBX   InitBlockIndex(PGLOBAL g);
-//virtual int   TestBlock(PGLOBAL g);
   virtual void  PrintAM(FILE *f, char *m);
 
   // Database routines
@@ -162,25 +149,16 @@ class DllExport TDBDOS : public TDBASE {
   virtual int  EstimatedLength(PGLOBAL g);
 
   // Optimization routines
-//        void  ResetBlockFilter(PGLOBAL g);
-          int    MakeIndex(PGLOBAL g, PIXDEF pxdf, bool add);
-//        bool  GetDistinctColumnValues(PGLOBAL g, int nrec);
+          int   MakeIndex(PGLOBAL g, PIXDEF pxdf, bool add);
 
  protected:
-//        PBF    CheckBlockFilari(PGLOBAL g, PXOB *arg, int op, bool *cnv);
-
   // Members
   PTXF    Txfp;              // To the File access method class
-//PBX     To_BlkIdx;         // To index test block
-//PBF     To_BlkFil;         // To evaluation block filter
-//PFIL    SavFil;            // Saved hidden filter
   char   *To_Line;           // Points to current processed line
   int     Cardinal;           // Table Cardinality
   RECFM   Ftype;             // File type: 0-var 1-fixed 2-binary (VCT)
   int     Lrecl;             // Logical Record Length
   int     AvgLen;            // Logical Record Average Length
-//int     Xeval;             // BlockTest return value
-//int     Beval;             // BlockEval return value
   }; // end of class TDBDOS
 
 /***********************************************************************/
@@ -198,50 +176,27 @@ class DllExport DOSCOL : public COLBLK {
 
   // Implementation
   virtual int    GetAmType(void) {return TYPE_AM_DOS;}
-//virtual int    GetClustered(void) {return Clustered;}
-//virtual int    IsClustered(void) {return (Clustered &&
-//               ((PDOSDEF)(((PTDBDOS)To_Tdb)->To_Def))->IsOptimized());}
-//virtual int    IsSorted(void) {return Sorted;}
   virtual void   SetTo_Val(PVAL valp) {To_Val = valp;}
-//virtual PVBLK  GetMin(void) {return Min;}
-//virtual PVBLK  GetMax(void) {return Max;}
-//virtual int    GetNdv(void) {return Ndv;}
-//virtual int    GetNbm(void) {return Nbm;}
-//virtual PVBLK  GetBmap(void) {return Bmap;}
-//virtual PVBLK  GetDval(void) {return Dval;}
 
   // Methods
-  virtual bool   VarSize(void);
   virtual bool   SetBuffer(PGLOBAL g, PVAL value, bool ok, bool check);
   virtual void   ReadColumn(PGLOBAL g);
   virtual void   WriteColumn(PGLOBAL g);
   virtual void   Print(PGLOBAL g, FILE *, uint);
 
  protected:
-//virtual bool   SetMinMax(PGLOBAL g);
-//virtual  bool   SetBitMap(PGLOBAL g);
-//        bool   CheckSorted(PGLOBAL g);
-//        bool   AddDistinctValue(PGLOBAL g);
 
   // Default constructor not to be used
   DOSCOL(void) {}
 
   // Members
-//PVBLK Min;          // Array of block min values
-//PVBLK Max;          // Array of block max values
-//PVBLK Bmap;         // Array of block bitmap values
-//PVBLK Dval;         // Array of column distinct values
   PVAL  To_Val;       // To value used for Update/Insert
   PVAL  OldVal;       // The previous value of the object.
   char *Buf;          // Buffer used in write operations
   bool  Ldz;          // True if field contains leading zeros
   bool  Nod;          // True if no decimal point
   int   Dcm;          // Last Dcm digits are decimals
-//int   Clustered;    // 0:No 1:Yes
-//int   Sorted;       // 0:No 1:Asc (2:Desc - NIY)
   int   Deplac;       // Offset in dos_buf
-//int    Ndv;          // Number of distinct values
-//int   Nbm;          // Number of uint in bitmap
   }; // end of class DOSCOL
 
 #endif // __TABDOS_H

storage/connect/tabfix.cpp

 /************* TabFix C++ Program Source Code File (.CPP) **************/
 /* PROGRAM NAME: TABFIX                                                */
 /* -------------                                                       */
-/*  Version 4.8                                                        */
+/*  Version 4.9                                                        */
 /*                                                                     */
 /* COPYRIGHT:                                                          */
 /* ----------                                                          */
-/*  (C) Copyright to the author Olivier BERTRAND          1998-2012    */
+/*  (C) Copyright to the author Olivier BERTRAND          1998-2014    */
 /*                                                                     */
 /* WHAT THIS PROGRAM DOES:                                             */
 /* -----------------------                                             */

storage/connect/tabfmt.cpp

@@ -460,7 +460,6 @@ PTDB CSVDEF::GetTable(PGLOBAL g, MODE mode)
         txfp = new(g) ZIPFAM(this);
       else {
         strcpy(g->Message, "Compress 2 not supported yet");
-//      txfp = new(g) ZLBFAM(defp);
         return NULL;
         } // endelse
 #else   // !ZIP_SUPPORT
@@ -1272,25 +1271,6 @@ CSVCOL::CSVCOL(CSVCOL *col1, PTDB tdbp) : DOSCOL(col1, tdbp)
   Fldnum = col1->Fldnum;
   } // end of CSVCOL copy constructor
 
-/***********************************************************************/
-/*  VarSize: This function tells UpdateDB whether or not the block     */
-/*  optimization file must be redone if this column is updated, even   */
-/*  it is not sorted or clustered. This applies to a blocked table,    */
-/*  because if it is updated using a temporary file, the block size    */
-/*  may be modified.                                                   */
-/***********************************************************************/
-bool CSVCOL::VarSize(void)
-  {
-  PTXF txfp = ((PTDBCSV)To_Tdb)->Txfp;
-
-  if (txfp->IsBlocked() && txfp->GetUseTemp())
-    // Blocked table using a temporary file
-    return true;
-  else
-    return false;
-
-  } // end VarSize
-
 /***********************************************************************/
 /*  ReadColumn: call DOSCOL::ReadColumn after having set the offet     */
 /*  and length of the field to read as calculated by TDBCSV::ReadDB.   */

storage/connect/tabfmt.h

@@ -8,7 +8,6 @@
 #include "xtable.h"                     // Base class declares
 #include "tabdos.h"
 
-//pedef struct _tabdesc  *PTABD;        // For friend setting
 typedef class  TDBFMT    *PTDBFMT;
 
 /***********************************************************************/
@@ -90,8 +89,8 @@ class TDBCSV : public TDBDOS {
   int   Nerr;              // Number of bad records
   int   Maxerr;            // Maximum number of bad records
   int   Quoted;            // Quoting level for quoted fields
-  bool  Accept;             // true if bad lines are accepted
-  bool  Header;             // true if first line contains column headers
+  bool  Accept;            // true if bad lines are accepted
+  bool  Header;            // true if first line contains column headers
   char  Sep;               // Separator
   char  Qot;               // Quoting character
   }; // end of class TDBCSV
@@ -112,10 +111,8 @@ class CSVCOL : public DOSCOL {
   virtual int    GetAmType() {return TYPE_AM_CSV;}
 
   // Methods
-  virtual bool   VarSize(void);
   virtual void   ReadColumn(PGLOBAL g);
   virtual void   WriteColumn(PGLOBAL g);
-//        void   Print(FILE *, uint);
 
  protected:
   // Default constructor not to be used

storage/connect/table.cpp

@@ -36,27 +36,6 @@ extern "C" int trace;       // The general trace value
 void NewPointer(PTABS, void *, void *);
 void AddPointer(PTABS, void *);
 
-/* ---------------------------- class TBX ---------------------------- */
-
-/***********************************************************************/
-/*  TBX public constructors.                                           */
-/***********************************************************************/
-TBX::TBX(void)
-  {
-  Use = USE_NO;
-  To_Orig = NULL;
-  To_Filter = NULL;
-  } // end of TBX constructor
-
-TBX::TBX(PTBX txp)
-  {
-  Use = txp->Use;
-  To_Orig = txp;
-  To_Filter = NULL;
-  } // end of TBX copy constructor
-
-// Methods
-
 /* ---------------------------- class TDB ---------------------------- */
 
 /***********************************************************************/
@@ -64,6 +43,9 @@ TBX::TBX(PTBX txp)
 /***********************************************************************/
 TDB::TDB(PTABDEF tdp) : Tdb_No(++Tnum)
   {
+  Use = USE_NO;
+  To_Orig = NULL;
+  To_CondFil = NULL;
   Next = NULL;
   Name = (tdp) ? tdp->GetName() : NULL;
   To_Table = NULL;
@@ -72,8 +54,11 @@ TDB::TDB(PTABDEF tdp) : Tdb_No(++Tnum)
   Mode = MODE_READ;
   } // end of TDB standard constructor
 
-TDB::TDB(PTDB tdbp) : TBX(tdbp), Tdb_No(++Tnum)
+TDB::TDB(PTDB tdbp) : Tdb_No(++Tnum)
   {
+  Use = tdbp->Use;
+  To_Orig = tdbp;
+  To_CondFil = NULL;
   Next = NULL;
   Name = tdbp->Name;
   To_Table = tdbp->To_Table;
@@ -82,92 +67,6 @@ TDB::TDB(PTDB tdbp) : TBX(tdbp), Tdb_No(++Tnum)
   Mode = tdbp->Mode;
   } // end of TDB copy constructor
 
-/***********************************************************************/
-/*  OpenTable: Call AM open routine.                                   */
-/***********************************************************************/
-bool TDB::OpenTable(PGLOBAL g, PSQL sqlp, MODE mode)
-  {
-  if (trace)
-    htrc("Open Tdb_No=%d use=%d type=%d tdb.Mode=%d mode=%d\n",
-               Tdb_No, Use, GetAmType(), Mode, mode);
-
-  switch (Use) {
-    case USE_LIN:
-      /*****************************************************************/
-      /*  If table is read/only, only MODE_READ is allowed.            */
-      /*****************************************************************/
-      if (IsReadOnly() && mode != MODE_READ) {
-        strcpy(g->Message, MSG(READ_ONLY));
-        return true;
-        } // endif ReadOnly
-
-      /*****************************************************************/
-      /*  This could be done in any order.                             */
-      /*  Note: for not Read only first table in open in that mode.    */
-      /*****************************************************************/
-      if (Next)
-        Next->OpenTable(g, sqlp, MODE_READ);
-
-      Mode = mode;
-
-      /*****************************************************************/
-      /*  Pre-opening is done, allocate select buffers now.            */
-      /*****************************************************************/
-      Use = USE_READY;
-      break;
-
-    case USE_READY:
-      /*****************************************************************/
-      /*  This is to open files in reverse order.                      */
-      /*****************************************************************/
-      if (Next)
-        if (Next->OpenTable(g, sqlp, mode))
-          return true;
-
-      /*****************************************************************/
-      /*  This was moved after filter conversion so filtering can be   */
-      /*  done when making index tables for DOS files.                 */
-      /*  Also it was moved after allocating select buffers so some    */
-      /*  data can be pre-read during open to allow storage sorting.   */
-      /*****************************************************************/
-      if (OpenDB(g))                       // Do open the table file
-        return true;
-
-      Use = USE_OPEN;
-      break;
-
-    case USE_OPEN:
-      /*****************************************************************/
-      /*  Table is already open.                                       */
-      /*  Call open routine that will just "rewind" the files.         */
-      /*****************************************************************/
-      if (OpenDB(g))                       // Rewind the table file
-        return true;
-
-      break;
-
-    default:
-      sprintf(g->Message, MSG(TDB_USE_ERROR), Use);
-      return true;
-    } // endswitch Use
-
-  return false;
-  } // end of OpenTable
-
-/***********************************************************************/
-/*  CloseTable: Close a table of any AM type.                          */
-/***********************************************************************/
-void TDB::CloseTable(PGLOBAL g)
-  {
-  if (trace)
-    htrc("CloseTable: tdb_no %d use=%d amtype=%d am.Mode=%d\n",
-                      Tdb_No, Use, GetAmType(), Mode);
-
-  CloseDB(g);
-  Use = USE_READY;              // x'7FFD'
-  Mode = MODE_ANY;
-  } // end of CloseTable
-
 // Methods
 
 /***********************************************************************/
@@ -179,7 +78,7 @@ int TDB::RowNumber(PGLOBAL g, bool b)
   return 0;
   } // end of RowNumber
 
-PTBX TDB::Copy(PTABS t)
+PTDB TDB::Copy(PTABS t)
   {
   PTDB    tp, tdb1, tdb2 = NULL, outp = NULL;
 //PGLOBAL g = t->G;        // Is this really useful ???

storage/connect/tabmac.h

@@ -31,7 +31,7 @@ class DllExport MACDEF : public TABDEF {  /* Logical table description */
   // Methods
   virtual bool DefineAM(PGLOBAL g, LPCSTR am, int poff);
   virtual PTDB GetTable(PGLOBAL g, MODE m);
-  virtual bool DeleteTableFile(PGLOBAL g) {return true;}
+//virtual bool DeleteTableFile(PGLOBAL g) {return true;}
 
  protected:
   // Members

storage/connect/tabmul.h

@@ -38,7 +38,7 @@ class DllExport TDBMUL : public TDBASE {
   // Methods
   virtual void ResetDB(void);
   virtual PTDB CopyOne(PTABS t);
-  virtual bool IsSame(PTBX tp) {return tp == (PTBX)Tdbp;}
+  virtual bool IsSame(PTDB tp) {return tp == (PTDB)Tdbp;}
   virtual PSZ  GetFile(PGLOBAL g) {return Tdbp->GetFile(g);}
   virtual int  GetRecpos(void) {return 0;}
   virtual PCOL ColDB(PGLOBAL g, PSZ name, int num);

storage/connect/tabmysql.cpp

@@ -527,8 +527,8 @@ bool TDBMYSQL::MakeSelect(PGLOBAL g)
 
   strcat(strcat(strcat(strcat(Query, " FROM "), tk), Tabname), tk);
 
-  if (To_Filter)
-    strcat(strcat(Query, " WHERE "), To_Filter->Body);
+  if (To_CondFil)
+    strcat(strcat(Query, " WHERE "), To_CondFil->Body);
 
   if (trace)
     htrc("Query=%s\n", Query);
@@ -1135,7 +1135,6 @@ MYSQLCOL::MYSQLCOL(MYSQL_FIELD *fld, PTDB tdbp, int i, PSZ am)
         : COLBLK(NULL, tdbp, i)
   {
   Name = fld->name;
-  Opt = 0;
   Precision = Long = fld->length;
   Buf_Type = MYSQLtoPLG(fld->type);
   strcpy(Format.Type, GetFormatType(Buf_Type));
@@ -1395,11 +1394,11 @@ PCMD TDBMYEXC::MakeCMD(PGLOBAL g)
   {
   PCMD xcmd = NULL;
 
-  if (To_Filter) {
+  if (To_CondFil) {
     if (Cmdcol) {
-      if (!stricmp(Cmdcol, To_Filter->Body) &&
-          (To_Filter->Op == OP_EQ || To_Filter->Op == OP_IN)) {
-        xcmd = To_Filter->Cmds;
+      if (!stricmp(Cmdcol, To_CondFil->Body) &&
+          (To_CondFil->Op == OP_EQ || To_CondFil->Op == OP_IN)) {
+        xcmd = To_CondFil->Cmds;
       } else
         strcpy(g->Message, "Invalid command specification filter");
 

storage/connect/tabmysql.h

@@ -185,14 +185,7 @@ class TDBMYEXC : public TDBMYSQL {
 
   // Methods
   virtual PTDB CopyOne(PTABS t);
-//virtual int  GetAffectedRows(void) {return AftRows;}
-//virtual int  GetRecpos(void) {return N;}
-//virtual int  GetProgMax(PGLOBAL g);
-//virtual void ResetDB(void) {N = 0;}
-//virtual int  RowNumber(PGLOBAL g, bool b = FALSE);
   virtual bool IsView(void) {return Isview;}
-//virtual PSZ  GetServer(void) {return Server;}
-//        void SetDatabase(LPCSTR db) {Database = (char*)db;}
 
   // Database routines
   virtual PCOL MakeCol(PGLOBAL g, PCOLDEF cdp, PCOL cprec, int n);
@@ -200,20 +193,10 @@ class TDBMYEXC : public TDBMYSQL {
   virtual bool OpenDB(PGLOBAL g);
   virtual int  ReadDB(PGLOBAL g);
   virtual int  WriteDB(PGLOBAL g);
-//virtual int  DeleteDB(PGLOBAL g, int irc);
-//virtual void CloseDB(PGLOBAL g);
-
-  // Specific routines
-//        bool SetColumnRanks(PGLOBAL g);
-//        PCOL MakeFieldColumn(PGLOBAL g, char *name);
-//        PSZ  FindFieldColumn(char *name);
 
  protected:
   // Internal functions
   PCMD MakeCMD(PGLOBAL g);
-//bool MakeSelect(PGLOBAL g);
-//bool MakeInsert(PGLOBAL g);
-//int  BindColumns(PGLOBAL g);
 
   // Members
   PCMD     Cmdlist;           // The commands to execute
@@ -237,15 +220,9 @@ class MYXCOL : public MYSQLCOL {
   MYXCOL(MYSQL_FIELD *fld, PTDB tdbp, int i,  PSZ am = "MYSQL");
   MYXCOL(MYXCOL *colp, PTDB tdbp);   // Constructor used in copy process
 
-  // Implementation
-//virtual int  GetAmType(void) {return TYPE_AM_MYSQL;}
-//        void InitBind(PGLOBAL g);
-
   // Methods
-//virtual bool SetBuffer(PGLOBAL g, PVAL value, bool ok, bool check);
   virtual void ReadColumn(PGLOBAL g);
   virtual void WriteColumn(PGLOBAL g);
-//        bool FindRank(PGLOBAL g);
 
  protected:
   // Default constructor not to be used

storage/connect/taboccur.h

@@ -68,7 +68,6 @@ class TDBOCCUR : public TDBPRX {
 
  protected:
   // Members
-//PTDBASE   Tdbp;										// To the source table or view
   LPCSTR    Tabname;								// Name of source table
 	char     *Colist;                 // Source column list
 	char     *Xcolumn;								// Occurence column name

storage/connect/tabodbc.cpp

@@ -408,7 +408,7 @@ char *TDBODBC::MakeSQL(PGLOBAL g, bool cnt)
 
   // Below 14 is length of 'select ' + length of ' from ' + 1
   len = (strlen(colist) + strlen(buf) + 14);
-  len += (To_Filter ? strlen(To_Filter->Body) + 7 : 0);
+  len += (To_CondFil ? strlen(To_CondFil->Body) + 7 : 0);
 
   if (Catalog && *Catalog)
     catp = Catalog;
@@ -441,8 +441,8 @@ char *TDBODBC::MakeSQL(PGLOBAL g, bool cnt)
 
   strcat(sql, tabname);
 
-  if (To_Filter)
-    strcat(strcat(sql, " WHERE "), To_Filter->Body);
+  if (To_CondFil)
+    strcat(strcat(sql, " WHERE "), To_CondFil->Body);
 
   return sql;
   } // end of MakeSQL
@@ -1229,11 +1229,11 @@ PCMD TDBXDBC::MakeCMD(PGLOBAL g)
   {
   PCMD xcmd = NULL;
 
-  if (To_Filter) {
+  if (To_CondFil) {
     if (Cmdcol) {
-      if (!stricmp(Cmdcol, To_Filter->Body) &&
-          (To_Filter->Op == OP_EQ || To_Filter->Op == OP_IN)) {
-        xcmd = To_Filter->Cmds;
+      if (!stricmp(Cmdcol, To_CondFil->Body) &&
+          (To_CondFil->Op == OP_EQ || To_CondFil->Op == OP_IN)) {
+        xcmd = To_CondFil->Cmds;
       } else
         strcpy(g->Message, "Invalid command specification filter");
 

storage/connect/tabodbc.h

@@ -158,7 +158,6 @@ class ODBCCOL : public COLBLK {
 //        PVBLK   GetBlkp(void) {return Blkp;}
 
   // Methods
-//virtual bool   CheckLocal(PTDB tdbp);
   virtual bool   SetBuffer(PGLOBAL g, PVAL value, bool ok, bool check);
   virtual void   ReadColumn(PGLOBAL g);
   virtual void   WriteColumn(PGLOBAL g);

storage/connect/tabsys.cpp

@@ -113,6 +113,7 @@ PTDB INIDEF::GetTable(PGLOBAL g, MODE m)
   return tdbp;
   } // end of GetTable
 
+#if 0
 /***********************************************************************/
 /*  DeleteTableFile: Delete INI table files using platform API.        */
 /***********************************************************************/
@@ -134,6 +135,7 @@ bool INIDEF::DeleteTableFile(PGLOBAL g)
 
   return rc;                                  // Return true if error
   } // end of DeleteTableFile
+#endif // 0
 
 /* ------------------------------------------------------------------- */
 

storage/connect/tabsys.h

@@ -32,7 +32,6 @@ class DllExport INIDEF : public TABDEF {      /* INI table description */
   // Methods
   virtual bool DefineAM(PGLOBAL g, LPCSTR am, int poff);
   virtual PTDB GetTable(PGLOBAL g, MODE m);
-  virtual bool DeleteTableFile(PGLOBAL g);
 
  protected:
   // Members

storage/connect/tabtbl.cpp

 /************* TabTbl C++ Program Source Code File (.CPP) **************/
 /* PROGRAM NAME: TABTBL                                                */
 /* -------------                                                       */
-/*  Version 1.6                                                        */
+/*  Version 1.7                                                        */
 /*                                                                     */
 /* COPYRIGHT:                                                          */
 /* ----------                                                          */
-/*  (C) Copyright to PlugDB Software Development          2008-2013    */
+/*  (C) Copyright to PlugDB Software Development          2008-2014    */
 /*  Author: Olivier BERTRAND                                           */
 /*                                                                     */
 /* WHAT THIS PROGRAM DOES:                                             */
@@ -66,7 +66,6 @@
 #include "global.h"      // global declarations
 #include "plgdbsem.h"    // DB application declarations
 #include "reldef.h"      // DB definition declares
-//#include "filter.h"      // FILTER classes dcls
 #include "filamtxt.h"
 #include "tabcol.h"
 #include "tabdos.h"      // TDBDOS and DOSCOL class dcls
@@ -245,7 +244,7 @@ bool TDBTBL::InitTableList(PGLOBAL g)
 //  PlugSetPath(filename, Tdbp->GetFile(g), Tdbp->GetPath());
 
   for (n = 0, tp = tdp->Tablep; tp; tp = tp->GetNext()) {
-    if (TestFil(g, To_Filter, tp)) {
+    if (TestFil(g, To_CondFil, tp)) {
       tabp = new(g) XTAB(tp);
 
       if (tabp->GetSrc()) {
@@ -286,14 +285,14 @@ bool TDBTBL::InitTableList(PGLOBAL g)
   hc->get_table()->s->connect_string.length = sln;
 
 //NumTables = n;
-  To_Filter = NULL;        // To avoid doing it several times
+  To_CondFil = NULL;        // To avoid doing it several times
   return FALSE;
   } // end of InitTableList
 
 /***********************************************************************/
 /*  Test the tablename against the pseudo "local" filter.              */
 /***********************************************************************/
-bool TDBTBL::TestFil(PGLOBAL g, PFIL filp, PTABLE tabp)
+bool TDBTBL::TestFil(PGLOBAL g, PCFIL filp, PTABLE tabp)
   {
   char *body, *fil, op[8], tn[NAME_LEN];
   bool  neg;
@@ -421,12 +420,12 @@ bool TDBTBL::OpenDB(PGLOBAL g)
     } // endif use
 
   /*********************************************************************/
-  /*  When GetMaxsize was called, To_Filter was not set yet.           */
+  /*  When GetMaxsize was called, To_CondFil was not set yet.          */
   /*********************************************************************/
-  if (To_Filter && Tablist) {
+  if (To_CondFil && Tablist) {
     Tablist = NULL;
     Nbc = 0;
-    } // endif To_Filter
+    } // endif To_CondFil
 
   /*********************************************************************/
   /*  Open the first table of the list.                                */
@@ -661,12 +660,12 @@ bool TDBTBM::OpenDB(PGLOBAL g)
 
 #if 0
   /*********************************************************************/
-  /*  When GetMaxsize was called, To_Filter was not set yet.           */
+  /*  When GetMaxsize was called, To_CondFil was not set yet.          */
   /*********************************************************************/
-  if (To_Filter && Tablist) {
+  if (To_CondFil && Tablist) {
     Tablist = NULL;
     Nbc = 0;
-    } // endif To_Filter
+    } // endif To_CondFil
 #endif // 0
 
   /*********************************************************************/

storage/connect/tabtbl.h

@@ -87,7 +87,7 @@ class DllExport TDBTBL : public TDBPRX {
  protected:
   // Internal functions
   bool  InitTableList(PGLOBAL g);
-  bool  TestFil(PGLOBAL g, PFIL filp, PTABLE tabp);
+  bool  TestFil(PGLOBAL g, PCFIL filp, PTABLE tabp);
 
   // Members
   PTABLE  Tablist;              // Points to the table list
@@ -133,26 +133,17 @@ class DllExport TDBTBM : public TDBTBL {
   // Constructor
   TDBTBM(PTBLDEF tdp = NULL);
 
-  // Implementation
-//virtual AMT  GetAmType(void) {return TYPE_AM_TBL;}
-
   // Methods
   virtual void ResetDB(void);
-//virtual int  GetRecpos(void) {return Rows;}
-//virtual int  GetBadLines(void) {return (int)Nbc;}
 
   // Database routines
-//virtual PCOL MakeCol(PGLOBAL g, PCOLDEF cdp, PCOL cprec, int n);
   virtual int  GetMaxSize(PGLOBAL g) {return 10;} // Temporary
   virtual int  RowNumber(PGLOBAL g, bool b = FALSE);
-//virtual PCOL InsertSpecialColumn(PGLOBAL g, PCOL scp);
   virtual bool OpenDB(PGLOBAL g);
   virtual int  ReadDB(PGLOBAL g);
 
  protected:
   // Internal functions
-//bool  InitTableList(PGLOBAL g);
-//bool  TestFil(PGLOBAL g, PFIL filp, PTABLE tabp);
   bool  OpenTables(PGLOBAL g);
   int   ReadNextRemote(PGLOBAL g);
 
@@ -165,5 +156,4 @@ class DllExport TDBTBM : public TDBTBL {
   int   Nlc;                  // Number of local connections
   }; // end of class TDBTBM
 
-
 pthread_handler_t ThreadOpen(void *p);

storage/connect/tabutil.h

@@ -54,7 +54,6 @@ class DllExport PRXDEF : public TABDEF {  /* Logical table description */
 /*  This is the class declaration for the XCSV table.                  */
 /***********************************************************************/
 class DllExport TDBPRX : public TDBASE {
-//friend class MULINDX;
   friend class PRXDEF;
   friend class PRXCOL;
  public:
@@ -126,8 +125,6 @@ class TDBTBC : public TDBCAT {
  public:
   // Constructors
   TDBTBC(PPRXDEF tdp);
-//TDBTBC(PTBLDEF tdp);
-//TDBTBC(PXCLDEF tdp);
 
  protected:
 	// Specific routines

storage/connect/tabvct.cpp

 /************* TabVct C++ Program Source Code File (.CPP) **************/
 /* PROGRAM NAME: TABVCT                                                */
 /* -------------                                                       */
-/*  Version 3.7                                                        */
+/*  Version 3.8                                                        */
 /*                                                                     */
 /* COPYRIGHT:                                                          */
 /* ----------                                                          */
-/*  (C) Copyright to the author Olivier BERTRAND          1999-2012    */
+/*  (C) Copyright to the author Olivier BERTRAND          1999-2014    */
 /*                                                                     */
 /* WHAT THIS PROGRAM DOES:                                             */
 /* -----------------------                                             */
@@ -118,6 +118,7 @@ bool VCTDEF::DefineAM(PGLOBAL g, LPCSTR am, int poff)
   return false;
   } // end of DefineAM
 
+#if 0
 /***********************************************************************/
 /*  Erase: This was made a separate routine because a strange thing    */
 /*  happened when DeleteTablefile was defined for the VCTDEF class:    */
@@ -157,6 +158,7 @@ bool VCTDEF::Erase(char *filename)
 
   return rc;                                  // Return true if error
   } // end of Erase
+#endif // 0
 
 /***********************************************************************/
 /*  Prepare the column file name pattern for a split table.            */
@@ -231,7 +233,8 @@ PTDB VCTDEF::GetTable(PGLOBAL g, MODE mode)
   /*********************************************************************/
   if (mode != MODE_INSERT)
     if (tdbp->GetBlockValues(g))
-      return NULL;
+      PushWarning(g, (PTDBASE)tdbp);
+//    return NULL;            // causes a crash when deleting index
 
   return tdbp;
   } // end of GetTable

storage/connect/tabvct.h

@@ -36,8 +36,6 @@ class DllExport VCTDEF : public DOSDEF {  /* Logical table description */
   virtual PTDB GetTable(PGLOBAL g, MODE mode);
 
  protected:
-  // Specific file erase routine for vertical tables
-  virtual bool Erase(char *filename);
           int  MakeFnPattern(char *fpat);
 
   // Members

storage/connect/tabwmi.cpp

@@ -14,7 +14,7 @@
 #include "reldef.h"
 #include "xtable.h"
 #include "colblk.h"
-#include "filter.h"
+//#include "filter.h"
 //#include "xindex.h"
 #include "tabwmi.h"
 #include "valblk.h"
@@ -480,8 +480,8 @@ bool TDBWMI::Initialize(PGLOBAL g)
 /***********************************************************************/
 void TDBWMI::DoubleSlash(PGLOBAL g)
   {
-  if (To_Filter && strchr(To_Filter->Body, '\\')) {
-    char *body = To_Filter->Body;
+  if (To_CondFil && strchr(To_CondFil->Body, '\\')) {
+    char *body = To_CondFil->Body;
     char *buf = (char*)PlugSubAlloc(g, NULL, strlen(body) * 2);
     int   i = 0, k = 0;
 
@@ -492,8 +492,8 @@ void TDBWMI::DoubleSlash(PGLOBAL g)
       buf[k++] = body[i];
       } while (body[i++]);
 
-    To_Filter->Body = buf;
-    } // endif To_Filter
+    To_CondFil->Body = buf;
+    } // endif To_CondFil
 
   } // end of DoubleSlash
 
@@ -540,13 +540,13 @@ char *TDBWMI::MakeWQL(PGLOBAL g)
 
   // Below 14 is length of 'select ' + length of ' from ' + 1
   len = (strlen(colist) + strlen(Wclass) + 14);
-  len += (To_Filter ? strlen(To_Filter->Body) + 7 : 0);
+  len += (To_CondFil ? strlen(To_CondFil->Body) + 7 : 0);
   wql = (char*)PlugSubAlloc(g, NULL, len);
   strcat(strcat(strcpy(wql, "SELECT "), colist), " FROM ");
   strcat(wql, Wclass);
 
-  if (To_Filter)
-    strcat(strcat(wql, " WHERE "), To_Filter->Body);
+  if (To_CondFil)
+    strcat(strcat(wql, " WHERE "), To_CondFil->Body);
 
   return wql;
   } // end of MakeWQL
@@ -659,8 +659,8 @@ bool TDBWMI::OpenDB(PGLOBAL g)
     return true;
     } // endif Mode
 
-  if (!To_Filter && !stricmp(Wclass, "CIM_Datafile")
-                 && !stricmp(Nspace, "root\\cimv2")) {
+  if (!To_CondFil && !stricmp(Wclass, "CIM_Datafile")
+                  && !stricmp(Nspace, "root\\cimv2")) {
     strcpy(g->Message, 
       "Would last forever when not filtered, use DIR table instead");
     return true;

storage/connect/tabwmi.h

@@ -48,7 +48,6 @@ class WMIDEF : public TABDEF {            /* Logical table description */
   // Methods
   virtual bool DefineAM(PGLOBAL g, LPCSTR am, int poff);
   virtual PTDB GetTable(PGLOBAL g, MODE m);
-  virtual bool DeleteTableFile(PGLOBAL g) {return true;}
 
  protected:
   // Members

storage/connect/tabxml.cpp

@@ -187,6 +187,7 @@ PTDB XMLDEF::GetTable(PGLOBAL g, MODE m)
   return tdbp;
   } // end of GetTable
 
+#if 0
 /***********************************************************************/
 /*  DeleteTableFile: Delete XML table files using platform API.        */
 /***********************************************************************/
@@ -208,6 +209,7 @@ bool XMLDEF::DeleteTableFile(PGLOBAL g)
 
   return rc;                                  // Return true if error
   } // end of DeleteTableFile
+#endif // 0
 
 /* ------------------------- TDBXML Class ---------------------------- */
 

storage/connect/tabxml.h

@@ -10,9 +10,6 @@ typedef class XMLDEF *PXMLDEF;
 typedef class TDBXML *PTDBXML;
 typedef class XMLCOL *PXMLCOL;
 
-// These functions are exported from the Extended.dll
-//PTABDEF __stdcall GetXML(PGLOBAL g, void *memp);
-
 /* --------------------------- XML classes --------------------------- */
 
 /***********************************************************************/
@@ -30,7 +27,6 @@ class DllExport XMLDEF : public TABDEF {  /* Logical table description */
   // Methods
   virtual bool DefineAM(PGLOBAL g, LPCSTR am, int poff);
   virtual PTDB GetTable(PGLOBAL g, MODE m);
-  virtual bool DeleteTableFile(PGLOBAL g);
 
  protected:
   // Members
@@ -53,7 +49,6 @@ class DllExport XMLDEF : public TABDEF {  /* Logical table description */
   }; // end of XMLDEF
 
 #if defined(INCLUDE_TDBXML)
-
 /***********************************************************************/
 /*  This is the class declaration for the simple XML tables.           */
 /***********************************************************************/
@@ -242,5 +237,4 @@ class XPOSCOL : public XMLCOLX {
   virtual void ReadColumn(PGLOBAL g);
   virtual void WriteColumn(PGLOBAL g);
   }; // end of class XPOSCOL
-
 #endif // INCLUDE_TDBXML

storage/connect/user_connect.cc

@@ -147,9 +147,6 @@ bool user_connect::CheckCleanup(void)
     g->Xchk = NULL;
     g->Createas = 0;
     g->Alchecked = 0;
-#if defined(MRRBKA_SUPPORT)
-    g->Mrr = 0;
-#endif   // MRRBKA_SUPPORT
     last_query_id= thdp->query_id;
 
     if (xtrace)

storage/connect/user_connect.h

@@ -63,11 +63,10 @@ class user_connect
   PCONNECT     next;                    // Next user in chain
   PCONNECT     previous;                // Previous user in chain
   PGLOBAL      g;                       // The common handle to CONNECT
-//char         dbname[32];              // The DBCONNECT database
   query_id_t   last_query_id;           // the latest user query id
   int          count;                   // if used by several handlers
   // Statistics
   ulong        nrd, fnd, nfd;
-  ulonglong tb1;
+  ulonglong    tb1;
 }; // end of user_connect class definition
 

storage/connect/valblk.cpp

@@ -40,7 +40,8 @@
 #include "plgdbsem.h"
 #include "valblk.h"
 
-#define CheckBlanks     assert(!Blanks);
+#define CheckBlanks      assert(!Blanks);
+#define CheckParms(V, N) ChkIndx(N); ChkTyp(V);
 
 /***********************************************************************/
 /*  AllocValBlock: allocate a VALBLK according to type.                */

storage/connect/valblk.h

@@ -26,7 +26,6 @@ const char *GetFmt(int type, bool un = false);
 /*  Class VALBLK represent a base class for variable blocks.           */
 /***********************************************************************/
 class VALBLK : public BLOCK {
-//friend void SemColData(PGLOBAL g, PSEM semp);
  public:
   // Constructors
   VALBLK(void *mp, int type, int nval, bool un = false);
@@ -79,12 +78,6 @@ class VALBLK : public BLOCK {
   virtual void   SetValue(char *sp, uint len, int n) {assert(false);}
   virtual void   SetValue(PVAL valp, int n) = 0;
   virtual void   SetValue(PVBLK pv, int n1, int n2) = 0;
-#if 0
-  virtual void   SetMin(PVAL valp, int n) = 0;
-  virtual void   SetMax(PVAL valp, int n) = 0;
-  virtual void   SetValues(PVBLK pv, int i, int n) = 0;
-  virtual void   AddMinus1(PVBLK pv, int n1, int n2) {assert(false);}
-#endif // 0
   virtual void   Move(int i, int j) = 0;
   virtual int    CompVal(PVAL vp, int n) = 0;
   virtual int    CompVal(int i1, int i2) = 0;
@@ -119,12 +112,10 @@ class TYPBLK : public VALBLK {
  public:
   // Constructors
   TYPBLK(void *mp, int size, int type, int prec = 0, bool un = false);
-//TYPBLK(void *mp, int size, int prec, int type);
 
   // Implementation
   virtual void   Init(PGLOBAL g, bool check);
   virtual int    GetVlen(void) {return sizeof(TYPE);}
-//virtual PSZ    GetCharValue(int n);
   virtual char   GetTinyValue(int n) {return (char)Typp[n];}
   virtual uchar  GetUTinyValue(int n) {return (uchar)Typp[n];}
   virtual short  GetShortValue(int n) {return (short)Typp[n];}
@@ -160,7 +151,6 @@ class TYPBLK : public VALBLK {
                   {Typp[n] = (TYPE)cval; SetNull(n, false);}
   virtual void   SetValue(PVAL valp, int n);
   virtual void   SetValue(PVBLK pv, int n1, int n2);
-//virtual void   SetValues(PVBLK pv, int k, int n);
   virtual void   Move(int i, int j);
   virtual int    CompVal(PVAL vp, int n);
   virtual int    CompVal(int i1, int i2);
@@ -211,7 +201,6 @@ class CHRBLK : public VALBLK {
   virtual void   SetValue(char *sp, uint len, int n);
   virtual void   SetValue(PVAL valp, int n);
   virtual void   SetValue(PVBLK pv, int n1, int n2);
-//virtual void   SetValues(PVBLK pv, int k, int n);
   virtual void   Move(int i, int j);
   virtual int    CompVal(PVAL vp, int n);
   virtual int    CompVal(int i1, int i2);
@@ -263,7 +252,6 @@ class STRBLK : public VALBLK {
   virtual void   SetValue(char *sp, uint len, int n);
   virtual void   SetValue(PVAL valp, int n);
   virtual void   SetValue(PVBLK pv, int n1, int n2);
-//virtual void   SetValues(PVBLK pv, int k, int n);
   virtual void   Move(int i, int j);
   virtual int    CompVal(PVAL vp, int n);
   virtual int    CompVal(int i1, int i2);

storage/connect/value.cpp

@@ -83,6 +83,7 @@ int DTVAL::Shift = 0;
 /*  Routines called externally.                                        */
 /***********************************************************************/
 bool PlugEvalLike(PGLOBAL, LPCSTR, LPCSTR, bool);
+
 #if !defined(WIN32)
 extern "C" {
 PSZ strupr(PSZ s);
@@ -277,55 +278,6 @@ const char *GetFmt(int type, bool un)
   return fmt;
   } // end of GetFmt
 
-#if 0
-/***********************************************************************/
-/*  ConvertType: what this function does is to determine the type to   */
-/*  which should be converted a value so no precision would be lost.   */
-/*  This can be a numeric type if num is true or non numeric if false. */
-/*  Note: this is an ultra simplified version of this function that    */
-/*  should become more and more complex as new types are added.        */
-/*  Not evaluated types (TYPE_VOID or TYPE_UNDEF) return false from    */
-/*  IsType... functions so match does not prevent correct setting.     */
-/***********************************************************************/
-int ConvertType(int target, int type, CONV kind, bool match)
-  {
-  switch (kind) {
-    case CNV_CHAR:
-      if (match && (!IsTypeChar(target) || !IsTypeChar(type)))
-        return TYPE_ERROR;
-
-      return TYPE_STRING;
-    case CNV_NUM:
-      if (match && (!IsTypeNum(target) || !IsTypeNum(type)))
-        return TYPE_ERROR;
-
-      return (target == TYPE_DOUBLE || type == TYPE_DOUBLE) ? TYPE_DOUBLE
-           : (target == TYPE_DATE   || type == TYPE_DATE)   ? TYPE_DATE
-           : (target == TYPE_BIGINT || type == TYPE_BIGINT) ? TYPE_BIGINT
-           : (target == TYPE_INT    || type == TYPE_INT)    ? TYPE_INT
-           : (target == TYPE_SHORT  || type == TYPE_SHORT)  ? TYPE_SHORT
-                                                            : TYPE_TINY;
-    default:
-      if (target == TYPE_ERROR || target == type)
-        return type;
-
-      if (match && ((IsTypeChar(target) && !IsTypeChar(type)) ||
-                    (IsTypeNum(target) && !IsTypeNum(type))))
-        return TYPE_ERROR;
-
-      return (target == TYPE_DOUBLE || type == TYPE_DOUBLE) ? TYPE_DOUBLE
-           : (target == TYPE_DATE   || type == TYPE_DATE)   ? TYPE_DATE
-           : (target == TYPE_BIGINT || type == TYPE_BIGINT) ? TYPE_BIGINT
-           : (target == TYPE_INT    || type == TYPE_INT)    ? TYPE_INT
-           : (target == TYPE_SHORT  || type == TYPE_SHORT)  ? TYPE_SHORT
-           : (target == TYPE_STRING || type == TYPE_STRING) ? TYPE_STRING
-           : (target == TYPE_TINY   || type == TYPE_TINY)   ? TYPE_TINY
-                                                            : TYPE_ERROR;
-    } // endswitch kind
-
-  } // end of ConvertType
-#endif // 0
-
 /***********************************************************************/
 /*  AllocateConstant: allocates a constant Value.                      */
 /***********************************************************************/
@@ -422,76 +374,6 @@ PVAL AllocateValue(PGLOBAL g, int type, int len, int prec,
   return valp;
   } // end of AllocateValue
 
-#if 0
-/***********************************************************************/
-/*  Allocate a constant Value converted to newtype.                    */
-/*  Can also be used to copy a Value eventually converted.             */
-/***********************************************************************/
-PVAL AllocateValue(PGLOBAL g, PVAL valp, int newtype, int uns)
-  {
-  PSZ  p, sp;
-  bool un = (uns < 0) ? false : (uns > 0) ? true : valp->IsUnsigned();
-
-  if (newtype == TYPE_VOID)  // Means allocate a value of the same type
-    newtype = valp->GetType();
-
-  switch (newtype) {
-    case TYPE_STRING:
-      p = (PSZ)PlugSubAlloc(g, NULL, 1 + valp->GetValLen());
-
-      if ((sp = valp->GetCharString(p)) != p)
-        strcpy (p, sp);
-
-      valp = new(g) TYPVAL<PSZ>(g, p, valp->GetValLen(), valp->GetValPrec());
-      break;
-    case TYPE_SHORT:
-      if (un)
-        valp = new(g) TYPVAL<ushort>(valp->GetUShortValue(), 
-                                     TYPE_SHORT, 0, true);
-      else
-        valp = new(g) TYPVAL<short>(valp->GetShortValue(), TYPE_SHORT);
-
-      break;
-    case TYPE_INT: 
-      if (un)
-        valp = new(g) TYPVAL<uint>(valp->GetUIntValue(), TYPE_INT, 0, true);
-      else
-        valp = new(g) TYPVAL<int>(valp->GetIntValue(), TYPE_INT);
-
-      break;
-    case TYPE_BIGINT: 
-      if (un)
-        valp = new(g) TYPVAL<ulonglong>(valp->GetUBigintValue(), 
-                                        TYPE_BIGINT, 0, true);
-      else
-        valp = new(g) TYPVAL<longlong>(valp->GetBigintValue(), TYPE_BIGINT);
-
-      break;
-    case TYPE_DATE:
-      valp = new(g) DTVAL(g, valp->GetIntValue());
-      break;
-    case TYPE_DOUBLE:
-      valp = new(g) TYPVAL<double>(valp->GetFloatValue(), TYPE_DOUBLE,
-                                   valp->GetValPrec());
-      break;
-    case TYPE_TINY:  
-      if (un)
-        valp = new(g) TYPVAL<uchar>(valp->GetUTinyValue(), 
-                                    TYPE_TINY, 0, true);
-      else
-        valp = new(g) TYPVAL<char>(valp->GetTinyValue(), TYPE_TINY);
-
-      break;
-    default:
-      sprintf(g->Message, MSG(BAD_VALUE_TYPE), newtype);
-      return NULL;
-    } // endswitch type
-
-  valp->SetGlobal(g);
-  return valp;
-  } // end of AllocateValue
-#endif // 0
-
 /* -------------------------- Class VALUE ---------------------------- */
 
 /***********************************************************************/

storage/connect/value.h

@@ -46,8 +46,6 @@ DllExport char *GetFormatType(int);
 DllExport int   GetFormatType(char);
 DllExport bool  IsTypeChar(int type);
 DllExport bool  IsTypeNum(int type);
-//lExport int   ConvertType(int, int, CONV, bool match = false);
-//lExport PVAL  AllocateValue(PGLOBAL, PVAL, int = TYPE_VOID, int = 0);
 DllExport PVAL  AllocateValue(PGLOBAL, int, int len = 0, int prec = 0,
                               bool uns = false, PSZ fmt = NULL);
 DllExport ulonglong CharToNumber(char *, int, ulonglong, bool, 
@@ -271,17 +269,9 @@ class DllExport DECVAL: public TYPVAL<PSZ> {
   virtual int    GetValPrec() {return Prec;}
 
   // Methods
-//virtual bool   SetValue_pval(PVAL valp, bool chktype);
-//virtual bool   SetValue_char(char *p, int n);
-//virtual void   SetValue_psz(PSZ s);
-//virtual void   SetValue_pvblk(PVBLK blk, int n);
-//virtual void   SetBinValue(void *p);
   virtual bool   GetBinValue(void *buf, int buflen, bool go);
   virtual char  *ShowValue(char *buf, int);
-//virtual char  *GetCharString(char *p);
   virtual bool   IsEqual(PVAL vp, bool chktype);
-//virtual bool   FormatValue(PVAL vp, char *fmt);
-//virtual bool   SetConstFormat(PGLOBAL, FORMAT&);
 
   // Members
   }; // end of class DECVAL
@@ -310,15 +300,12 @@ class DllExport DTVAL : public TYPVAL<int> {
           bool   SetFormat(PGLOBAL g, PSZ fmt, int len, int year = 0);
           bool   SetFormat(PGLOBAL g, PVAL valp);
           bool   IsFormatted(void) {return Pdtp != NULL;}
-//        bool   GetTmMember(OPVAL op, int& mval);
-//        bool   DateDiff(DTVAL *dtp, OPVAL op, int& tdif);
           bool   MakeTime(struct tm *ptm);
   static  void   SetTimeShift(void);
   static  int    GetShift(void) {return Shift;}
 
   // Methods
           bool   MakeDate(PGLOBAL g, int *val, int nval);
-//        bool   WeekNum(PGLOBAL g, int& nval);
 
   struct  tm    *GetGmTime(struct tm *);
 

storage/connect/xindex.cpp

@@ -1792,7 +1792,8 @@ int XINDEX::FastFind(int nv)
 XINDXS::XINDXS(PTDBDOS tdbp, PIXDEF xdp, PXLOAD pxp, PCOL *cp, PXOB *xp)
       : XINDEX(tdbp, xdp, pxp, cp, xp)
   {
-  Srtd = To_Cols[0]->GetOpt() < 0;          // ?????
+//Srtd = To_Cols[0]->GetOpt() < 0;          // ?????
+  Srtd = false;
   } // end of XINDXS constructor
 
 /***********************************************************************/
@@ -2797,7 +2798,8 @@ bool KXYCOL::Init(PGLOBAL g, PCOL colp, int n, bool sm, int kln)
 
   // Store this information to avoid sorting when already done
   if (Asc)
-    IsSorted = colp->GetOpt() < 0;
+//  IsSorted = colp->GetOpt() < 0;
+    IsSorted = false;
 
 //SetNulls(colp->IsNullable()); for when null columns will be indexable
   return false;

storage/connect/xindex.h

@@ -98,12 +98,6 @@ class DllExport INDEXDEF : public BLOCK { /* Index description block   */
   void    SetNParts(uint np) {Nparts = (signed)np;}
   void    SetMaxSame(int mxs) {MaxSame = mxs;}
   void    SetMxsame(PXINDEX x);
-//int     GetOffset(void) {return Offset;}
-//void    SetOffset(int off) {Offset = off;}
-//int     GetOffhigh(void) {return Offhigh;}
-//void    SetOffhigh(int hof) {Offhigh = hof;}
-//int     GetSize(void) {return Size;}
-//void    SetSize(int size) {Size = size;}
   int     GetMaxSame(void) {return MaxSame;}
   bool    Define(PGLOBAL g, void *memp, PTABDEF dfp, LPCSTR p);
   PIXDEF  GetIndexOf(PCOL colp, bool hd = false);
@@ -123,9 +117,6 @@ class DllExport INDEXDEF : public BLOCK { /* Index description block   */
   bool    AutoInc;            /* true if unique key in auto increment  */
   int     Nparts;             /* Number of key parts                   */
   int     ID;                 /* Index ID number                       */
-//int     Offset;             /* Offset in index file                  */
-//int     Offhigh;            /* Offset high in big index file         */
-//int     Size;               /* Size of index file                    */
   int     MaxSame;            /* Max number of same values             */
   }; // end of INDEXDEF
 
@@ -253,9 +244,6 @@ class DllExport XINDEX : public XXBASE {
   virtual int  GetCurPos(void) {return (Pex) ? Pex[Cur_K] : Cur_K;}
   virtual void SetNval(int n) {Nval = n;}
           int  GetMaxSame(void) {return MaxSame;}
-//        int  GetDefoff(void) {return Defoff;}
-//        int  GetDefhigh(void) {return Defhigh;}
-//        int  GetSize(void) {return Size;}
 
   // Methods
   virtual void Reset(void);
@@ -288,9 +276,6 @@ class DllExport XINDEX : public XXBASE {
   int     Nk;               // The number of indexed columns
   int     Nval;             // The number of used columns
   int     Incr;             // Increment of record position
-//int     Defoff;           // Offset of definition in index file
-//int     Defhigh;          // High order of offset big value
-//int     Size;             // Size of definition in index file
   int     MaxSame;          // Max number of same values
   }; // end of class XINDEX
 

storage/connect/xobject.cpp

@@ -109,19 +109,6 @@ int CONSTANT::GetLengthEx(void)
   return Value->GetValLen();
   } // end of GetLengthEx
 
-#if 0
-/***********************************************************************/
-/*  Convert a constant to the given type.                              */
-/***********************************************************************/
-void CONSTANT::Convert(PGLOBAL g, int newtype)
-  {
-  if (Value->GetType() != newtype)
-    if (!(Value = AllocateValue(g, Value, newtype)))
-      longjmp(g->jumper[g->jump_level], TYPE_CONST);
-
-  } // end of Convert
-#endif // 0
-
 /***********************************************************************/
 /*  Compare: returns true if this object is equivalent to xp.          */
 /***********************************************************************/

storage/connect/xobject.h

@@ -60,17 +60,6 @@ class DllExport XOBJECT : public BLOCK {
   virtual bool   Init(PGLOBAL) {return false;}
   virtual bool   Eval(PGLOBAL) {return false;}
   virtual bool   SetFormat(PGLOBAL, FORMAT&) = 0;
-  virtual int    CheckColumn(PGLOBAL, PSQL, PXOB &, int &) {return 0;}
-  virtual int    RefNum(PSQL) {return 0;}
-  virtual void   AddTdb(PSQL, PTDB *, int&) {}
-  virtual PXOB   SetSelect(PGLOBAL, PSQL, bool) {return this;}
-  virtual PXOB   CheckSubQuery(PGLOBAL, PSQL) {return this;}
-  virtual bool   CheckLocal(PTDB) {return true;}
-  virtual int    CheckSpcCol(PTDB, int) {return 2;}
-  virtual bool   CheckSort(PTDB) {return false;}
-  virtual bool   VerifyColumn(PTBX txp) {return false;}
-  virtual bool   VerifyTdb(PTDB& tdbp) {return false;}
-  virtual bool   IsColInside(PCOL colp) {return false;}
 
  protected:
   PVAL Value;    // The current value of the object.
@@ -97,7 +86,6 @@ class DllExport XVOID : public XOBJECT {
   // Methods
   virtual bool   Compare(PXOB xp) {return xp->GetType() == TYPE_VOID;}
   virtual bool   SetFormat(PGLOBAL, FORMAT&) {return true;}
-  virtual int    CheckSpcCol(PTDB, int) {return 0;}
   }; // end of class XVOID
 
 
@@ -122,12 +110,7 @@ class DllExport CONSTANT : public XOBJECT {
   virtual bool   Compare(PXOB xp);
   virtual bool   SetFormat(PGLOBAL g, FORMAT& fmt)
                  {return Value->SetConstFormat(g, fmt);}
-  virtual int    CheckSpcCol(PTDB, int) {return 1;}
-//        void   Convert(PGLOBAL g, int newtype);
-//        bool   Rephrase(PGLOBAL g, PSZ work);
           void   SetValue(PVAL vp) {Value = vp;}
-  virtual bool   VerifyColumn(PTBX txp) {return true;}
-  virtual bool   VerifyTdb(PTDB& tdbp) {return true;}
   virtual void   Print(PGLOBAL g, FILE *, uint);
   virtual void   Print(PGLOBAL g, char *, uint);
   }; // end of class CONSTANT

storage/connect/xtable.h

@@ -33,58 +33,20 @@ class CMD : public BLOCK {
   char *Cmd;
 }; // end of class CMD
 
-// Filter passed all tables
-typedef struct _filter {
+// Condition filter structure
+typedef struct _cond_filter {
   char  *Body;
   OPVAL  Op;
   PCMD   Cmds;
-} FILTER, *PFIL;
+} CONDFIL, *PCFIL;
 
 typedef class TDBCAT *PTDBCAT;
 typedef class CATCOL *PCATCOL;
 
-/***********************************************************************/
-/*  Definition of class TBX (pure virtual class for TDB and OPJOIN)    */
-/***********************************************************************/
-class DllExport TBX: public BLOCK { // Base class for OPJOIN and TDB classes.
- public:
-  // Constructors
-  TBX(void);
-  TBX(PTBX txp);
-
-  // Implementation
-  inline  PTBX  GetOrig(void) {return To_Orig;}
-  inline  TUSE  GetUse(void) {return Use;}
-  inline  void  SetUse(TUSE n) {Use = n;}
-  inline  PFIL  GetFilter(void) {return To_Filter;}
-  inline  void  SetOrig(PTBX txp) {To_Orig = txp;}
-  inline  void  SetFilter(PFIL fp) {To_Filter = fp;}
-
-  // Methods
-  virtual bool IsSame(PTBX tp) {return tp == this;}
-  virtual int  GetTdb_No(void) = 0;   // Convenience during conversion
-  virtual PTDB GetNext(void) = 0;
-  virtual int  Cardinality(PGLOBAL) = 0;
-  virtual int  GetMaxSize(PGLOBAL) = 0;
-  virtual int  GetProgMax(PGLOBAL) = 0;
-  virtual int  GetProgCur(void) = 0;
-  virtual int  GetBadLines(void) {return 0;}
-  virtual PTBX Copy(PTABS t) = 0;
-
- protected:
-//virtual void PrepareFilters(PGLOBAL g) = 0;
-
- protected:
-  // Members
-  PTBX  To_Orig;      // Pointer to original if it is a copy
-  PFIL  To_Filter;
-  TUSE  Use;
-  }; // end of class TBX
-
 /***********************************************************************/
 /*  Definition of class TDB with all its method functions.             */
 /***********************************************************************/
-class DllExport TDB: public TBX {     // Table Descriptor Block.
+class DllExport TDB: public BLOCK {     // Table Descriptor Block.
  public:
   // Constructors
   TDB(PTABDEF tdp = NULL);
@@ -92,11 +54,17 @@ class DllExport TDB: public TBX {     // Table Descriptor Block.
 
   // Implementation
   static  void   SetTnum(int n) {Tnum = n;}
+  inline  PTDB   GetOrig(void) {return To_Orig;}
+  inline  TUSE   GetUse(void) {return Use;}
+  inline  PCFIL  GetCondFil(void) {return To_CondFil;}
   inline  LPCSTR GetName(void) {return Name;}
   inline  PTABLE GetTable(void) {return To_Table;}
   inline  PCOL   GetColumns(void) {return Columns;}
   inline  int    GetDegree(void) {return Degree;}
   inline  MODE   GetMode(void) {return Mode;}
+  inline  void   SetOrig(PTDB txp) {To_Orig = txp;}
+  inline  void   SetUse(TUSE n) {Use = n;}
+  inline  void   SetCondFil(PCFIL cfp) {To_CondFil = cfp;}
   inline  void   SetNext(PTDB tdbp) {Next = tdbp;}
   inline  void   SetName(LPCSTR name) {Name = name;}
   inline  void   SetTable(PTABLE tablep) {To_Table = tablep;}
@@ -105,25 +73,30 @@ class DllExport TDB: public TBX {     // Table Descriptor Block.
   inline  void   SetMode(MODE mode) {Mode = mode;}
 
   //Properties
+  virtual AMT    GetAmType(void) {return TYPE_AM_ERROR;}
   virtual int    GetTdb_No(void) {return Tdb_No;}
   virtual PTDB   GetNext(void) {return Next;}
   virtual PCATLG GetCat(void) {return NULL;}
 
   // Methods
-  virtual AMT    GetAmType(void) {return TYPE_AM_ERROR;}
+  virtual bool   IsSame(PTDB tp) {return tp == this;}
   virtual bool   GetBlockValues(PGLOBAL g) {return false;}
   virtual int    Cardinality(PGLOBAL g) {return (g) ? -1 : 0;}
+  virtual int    GetMaxSize(PGLOBAL) = 0;
+  virtual int    GetProgMax(PGLOBAL) = 0;
+  virtual int    GetProgCur(void) = 0;
   virtual int    RowNumber(PGLOBAL g, bool b = false);
   virtual bool   IsReadOnly(void) {return true;}
-  virtual const CHARSET_INFO *data_charset() { return NULL; }
+  virtual const CHARSET_INFO *data_charset() {return NULL;}
   virtual PTDB   Duplicate(PGLOBAL g) {return NULL;}
   virtual PTDB   CopyOne(PTABS t) {return this;}
-  virtual PTBX   Copy(PTABS t);
+  virtual PTDB   Copy(PTABS t);
   virtual void   PrintAM(FILE *f, char *m) 
                   {fprintf(f, "%s AM(%d)\n",  m, GetAmType());}
   virtual void   Print(PGLOBAL g, FILE *f, uint n);
   virtual void   Print(PGLOBAL g, char *ps, uint z);
   virtual PSZ    GetServer(void) = 0;
+  virtual int    GetBadLines(void) {return 0;}
 
   // Database pure virtual routines
   virtual PCOL   ColDB(PGLOBAL g, PSZ name, int num) = 0;
@@ -135,12 +108,11 @@ class DllExport TDB: public TBX {     // Table Descriptor Block.
   virtual void   CloseDB(PGLOBAL) = 0;
   virtual int    CheckWrite(PGLOBAL g) {return 0;}
 
-  // Database routines
-  bool OpenTable(PGLOBAL g, PSQL sqlp, MODE mode);
-  void CloseTable(PGLOBAL g);
-
  protected:
   // Members
+  PTDB   To_Orig;      // Pointer to original if it is a copy
+  TUSE   Use;
+  PCFIL  To_CondFil;   // To condition filter structure
   static int Tnum;     // Used to generate Tdb_no's
   const  int Tdb_No;   // GetTdb_No() is always 0 for OPJOIN
   PTDB   Next;         // Next in linearized queries