- MRR + Block Indexing

modified: storage/connect/array.h 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/filter.cpp storage/connect/filter.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/plgdbutl.cpp 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/tabmysql.cpp storage/connect/tabmysql.h storage/connect/taboccur.h storage/connect/tabodbc.h storage/connect/tabsys.h storage/connect/tabtbl.h storage/connect/tabutil.h storage/connect/tabvct.cpp storage/connect/tabvct.h storage/connect/tabwmi.h 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
2025-08-08 11:22:35 +03:00 · 2014-03-20 12:05:47 +01:00
parent d67ad26b33 e5729127b8
commit 7b400a088d
60 changed files with 32618 additions and 33489 deletions
--- a/storage/connect/array.h
+++ b/storage/connect/array.h
@@ -51,7 +51,7 @@ class DllExport ARRAY : public XOBJECT, public CSORT { // Array descblock
  virtual int   Qcompare(int *, int *);
  virtual bool  Compare(PXOB) {assert(FALSE); return FALSE;}
  virtual bool  SetFormat(PGLOBAL, FORMAT&) {assert(FALSE); return FALSE;}
-  virtual int   CheckSpcCol(PTDB, int) {return 0;}
+//virtual int   CheckSpcCol(PTDB, int) {return 0;}
  virtual void  Print(PGLOBAL g, FILE *f, UINT n);
  virtual void  Print(PGLOBAL g, char *ps, UINT z);
          void  Empty(void);
--- a/storage/connect/colblk.cpp
+++ b/storage/connect/colblk.cpp
@@ -1,7 +1,7 @@
 /************* Colblk C++ Functions Source Code File (.CPP) ************/
-/*  Name: COLBLK.CPP  Version 2.0                                      */
+/*  Name: COLBLK.CPP  Version 2.1                                      */
 /*                                                                     */
-/*  (C) Copyright to the author Olivier BERTRAND          1998-2013    */
+/*  (C) Copyright to the author Olivier BERTRAND          1998-2014    */
 /*                                                                     */
 /*  This file contains the COLBLK class functions.                     */
 /***********************************************************************/
@@ -124,14 +124,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.                             */
@@ -156,15 +148,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    */
--- a/storage/connect/colblk.h
+++ b/storage/connect/colblk.h
@@ -36,15 +36,13 @@ class DllExport COLBLK : public XOBJECT {
  virtual int     GetAmType() {return TYPE_AM_ERROR;}
  virtual void    SetOk(void) {Status |= BUF_EMPTY;}
  virtual PTDB    GetTo_Tdb(void) {return To_Tdb;}
-#if defined(BLK_INDX)
  virtual int     GetClustered(void) {return 0;}
  virtual int     IsClustered(void) {return FALSE;}
-#endif   // BLK_INDX
          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;}
+          int     GetOpt(void) {return Opt;}
          ushort  GetColUse(ushort u) {return (ColUse & u);}
          ushort  GetStatus(void) {return Status;}
          ushort  GetStatus(ushort u) {return (Status & u);}
@@ -53,9 +51,7 @@ 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;}
@@ -69,10 +65,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) {}
@@ -80,10 +73,7 @@ class DllExport COLBLK : public XOBJECT {
  virtual void    WriteColumn(PGLOBAL g);
  virtual void    Print(PGLOBAL g, FILE *, uint);
  virtual void    Print(PGLOBAL g, char *, uint);
-#if defined(BLK_INDX)
  virtual bool    VarSize(void) {return false;}
-#endif   // BLK_INDX
-  virtual bool    IsColInside(PCOL colp) {return this == colp;}
          bool    InitValue(PGLOBAL g);

 protected:
@@ -160,8 +150,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:
@@ -181,8 +169,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:
@@ -206,8 +192,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:
--- a/storage/connect/connect.cc
+++ b/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;

--- a/storage/connect/connect.h
+++ b/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);
--- a/storage/connect/domdoc.h
+++ b/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);

--- a/storage/connect/filamap.cpp
+++ b/storage/connect/filamap.cpp
@@ -322,15 +322,12 @@ int MAPFAM::ReadBuffer(PGLOBAL g)
    /*******************************************************************/
    /*  Record file position in case of UPDATE or DELETE.              */
    /*******************************************************************/
-#if defined(BLK_INDX)
    int rc;

   next:
-#endif   // BLK_INDX
    Fpos = Mempos;
    CurBlk = (int)Rows++;

-#if defined(BLK_INDX)
    /*******************************************************************/
    /*  Check whether optimization on ROWID                            */
    /*  can be done, as well as for join as for local filtering.       */
@@ -345,7 +342,6 @@ int MAPFAM::ReadBuffer(PGLOBAL g)

        goto next;
      } // endswitch rc
-#endif   // BLK_INDX
  } else
    Placed = false;

@@ -513,11 +509,7 @@ MBKFAM::MBKFAM(PDOSDEF tdp) : MAPFAM(tdp)
  Block = tdp->GetBlock();
  Last = tdp->GetLast();
  Nrec = tdp->GetElemt();
-#if defined(BLK_INDX)
  BlkPos = tdp->GetTo_Pos();
-#else   // !BLK_INDX
-  BlkPos = NULL;
-#endif  // !BLK_INDX
  CurNum = Nrec;
  } // end of MBKFAM standard constructor

@@ -537,9 +529,7 @@ void MBKFAM::Reset(void)
 /***********************************************************************/
 int MBKFAM::Cardinality(PGLOBAL g)
  {
-  // Should not be called in this version
-  return (g) ? -1 : 0;
-//return (g) ? (int)((Block - 1) * Nrec + Last) : 1;
+  return (g) ? (int)((Block - 1) * Nrec + Last) : 1;
  } // end of Cardinality

 /***********************************************************************/
@@ -563,7 +553,6 @@ int MBKFAM::GetRowID(void)
 /***********************************************************************/
 int MBKFAM::ReadBuffer(PGLOBAL g)
  {
-#if defined(BLK_INDX)
  int len;

  /*********************************************************************/
@@ -607,10 +596,6 @@ int MBKFAM::ReadBuffer(PGLOBAL g)
  memcpy(Tdbp->GetLine(), Fpos, len);
  Tdbp->GetLine()[len] = '\0';
  return RC_OK;
-#else   // !BLK_POS
-  strcpy(g->Message, "This AM cannot be used in this version");
-  return RC_FX;
-#endif  // !BLK_POS
  } // end of ReadBuffer

 /***********************************************************************/
@@ -701,13 +686,10 @@ int MPXFAM::ReadBuffer(PGLOBAL g)
    /*******************************************************************/
    CurNum = 0;

-#if defined(BLK_INDX)
   next:
-#endif   // BLK_INDX
    if (++CurBlk >= Block)
      return RC_EF;

-#if defined(BLK_INDX)
    /*******************************************************************/
    /*  Before reading a new block, check whether block optimization   */
    /*  can be done, as well as for join as for local filtering.       */
@@ -718,7 +700,6 @@ int MPXFAM::ReadBuffer(PGLOBAL g)
      case RC_NF:
        goto next;
      } // endswitch rc
-#endif   // BLK_INDX

    Fpos = Mempos = Headlen + Memory + CurBlk * Blksize;
  } // endif's
--- a/storage/connect/filamap.h
+++ b/storage/connect/filamap.h
@@ -101,7 +101,6 @@ class DllExport MPXFAM : public MBKFAM {
  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);
--- a/storage/connect/filamdbf.h
+++ b/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
--- a/storage/connect/filamfix.cpp
+++ b/storage/connect/filamfix.cpp
@@ -168,13 +168,10 @@ int FIXFAM::ReadBuffer(PGLOBAL g)
      CurNum = 0;
      Tdbp->SetLine(To_Buf);

-#if defined(BLK_INDX)
   next:
-#endif   // BLK_INDX
      if (++CurBlk >= Block)
        return RC_EF;

-#if defined(BLK_INDX)
      /*****************************************************************/
      /*  Before reading a new block, check whether block indexing     */
      /*  can be done, as well as for join as for local filtering.     */
@@ -185,7 +182,6 @@ int FIXFAM::ReadBuffer(PGLOBAL g)
        case RC_NF:
          goto next;
        } // endswitch rc
-#endif   // BLK_INDX
     } // endif's

    if (OldBlk == CurBlk) {
@@ -1043,13 +1039,10 @@ int BGXFAM::ReadBuffer(PGLOBAL g)
      CurNum = 0;
      Tdbp->SetLine(To_Buf);

-#if defined(BLK_INDX)
     next:
-#endif   // BLK_INDX
      if (++CurBlk >= Block)
        return RC_EF;

-#if defined(BLK_INDX)
      /*****************************************************************/
      /*  Before reading a new block, check whether block optimization */
      /*  can be done, as well as for join as for local filtering.     */
@@ -1060,7 +1053,7 @@ int BGXFAM::ReadBuffer(PGLOBAL g)
        case RC_NF:
          goto next;
        } // endswitch rc
-#endif   // BLK_INDX
+
     } // endif's

    if (OldBlk == CurBlk) {
--- a/storage/connect/filamfix.h
+++ b/storage/connect/filamfix.h
@@ -1,7 +1,7 @@
 /************** FilAMFix H Declares Source Code File (.H) **************/
-/*  Name: FILAMFIX.H    Version 1.2                                    */
+/*  Name: FILAMFIX.H    Version 1.3                                    */
 /*                                                                     */
-/*  (C) Copyright to the author Olivier BERTRAND          2005 - 2012  */
+/*  (C) Copyright to the author Olivier BERTRAND          2005 - 2014  */
 /*                                                                     */
 /*  This file contains the FIX file access method classes declares.    */
 /***********************************************************************/
@@ -64,7 +64,6 @@ 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);
@@ -84,7 +83,6 @@ class BGXFAM : public FIXFAM {
  // 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
--- a/storage/connect/filamtxt.cpp
+++ b/storage/connect/filamtxt.cpp
@@ -241,14 +241,10 @@ int TXTFAM::MaxBlkSize(PGLOBAL g, int s)
  // Roughly estimate the table size as the sum of blocks
  // that can contain good rows
  for (size = 0, CurBlk = 0; CurBlk < Block; CurBlk++)
-#if defined(BLK_INDX)
    if ((rc = Tdbp->TestBlock(g)) == RC_OK)
      size += (CurBlk == blm1) ? last : Nrec;
    else if (rc == RC_EF)
      break;
-#else   // !BLK_INDX
-    size += (CurBlk == blm1) ? last : Nrec;
-#endif  // !BLK_INDX

  CurBlk = savcur;
  return size;
@@ -550,9 +546,7 @@ int DOSFAM::ReadBuffer(PGLOBAL g)
    /*******************************************************************/
    /*  Record file position in case of UPDATE or DELETE.              */
    /*******************************************************************/
-#if defined(BLK_INDX)
   next:
-#endif   // BLK_INDX
    if (RecordPos(g))
      return RC_FX;

@@ -561,7 +555,6 @@ int DOSFAM::ReadBuffer(PGLOBAL g)
     if (trace > 1)
      htrc("ReadBuffer: CurBlk=%d\n", CurBlk);

-#if defined(BLK_INDX)
   /*******************************************************************/
    /*  Check whether optimization on ROWID                            */
    /*  can be done, as well as for join as for local filtering.       */
@@ -576,7 +569,7 @@ int DOSFAM::ReadBuffer(PGLOBAL g)

        goto next;
      } // endswitch rc
-#endif   // BLK_INDX
+
  } else
    Placed = false;

@@ -1019,11 +1012,7 @@ BLKFAM::BLKFAM(PDOSDEF tdp) : DOSFAM(tdp)
  Last = tdp->GetLast();
  Nrec = tdp->GetElemt();
  Closing = false;
-#if defined(BLK_INDX)
  BlkPos = tdp->GetTo_Pos();
-#else   // !BLK_INDX
-  BlkPos = NULL;
-#endif  // !BLK_INDX
  CurLine = NULL;
  NxtLine = NULL;
  OutBuf = NULL;
@@ -1069,14 +1058,10 @@ int BLKFAM::MaxBlkSize(PGLOBAL g, int s)
  // Roughly estimate the table size as the sum of blocks
  // that can contain good rows
  for (size = 0, CurBlk = 0; CurBlk < Block; CurBlk++)
-#if defined(BLK_INDX)
    if ((rc = Tdbp->TestBlock(g)) == RC_OK)
      size += (CurBlk == Block - 1) ? Last : Nrec;
    else if (rc == RC_EF)
      break;
-#else   // !BLK_INDX
-    size += (CurBlk == Block - 1) ? Last : Nrec;
-#endif  // !BLK_INDX

  CurBlk = savcur;
  return size;
@@ -1187,7 +1172,6 @@ int BLKFAM::SkipRecord(PGLOBAL g, bool header)
 /***********************************************************************/
 int BLKFAM::ReadBuffer(PGLOBAL g)
  {
-#if defined(BLK_INDX)
  int i, n, rc = RC_OK;

  /*********************************************************************/
@@ -1291,10 +1275,6 @@ int BLKFAM::ReadBuffer(PGLOBAL g)
  // Store the current record file position for Delete and Update
  Fpos = BlkPos[CurBlk] + CurLine - To_Buf;
  return rc;
-#else   // !BLK_POS
-  strcpy(g->Message, "This AM cannot be used in this version");
-  return RC_FX;
-#endif  // !BLK_POS
  } // end of ReadBuffer

 /***********************************************************************/
--- a/storage/connect/filamvct.cpp
+++ b/storage/connect/filamvct.cpp
@@ -255,14 +255,10 @@ int VCTFAM::MaxBlkSize(PGLOBAL g, int s)
  // Roughly estimate the table size as the sum of blocks
  // that can contain good rows
  for (size = 0, CurBlk = 0; CurBlk < Block; CurBlk++)
-#if defined(BLK_INDX)
    if ((rc = Tdbp->TestBlock(g)) == RC_OK)
      size += (CurBlk == Block - 1) ? Last : Nrec;
    else if (rc == RC_EF)
      break;
-#else   // !BLK_INDX
-    size += (CurBlk == Block - 1) ? Last : Nrec;
-#endif  // !BLK_INDX

  CurBlk = savcur;
  return size;
@@ -579,13 +575,10 @@ int VCTFAM::ReadBuffer(PGLOBAL g)
    /*******************************************************************/
    CurNum = 0;

-#if defined(BLK_INDX)
   next:
-#endif   // BLK_INDX
    if (++CurBlk == Block)
      return RC_EF;                        // End of file

-#if defined(BLK_INDX)
    /*******************************************************************/
    /*  Before reading a new block, check whether block optimizing     */
    /*  can be done, as well as for join as for local filtering.       */
@@ -596,7 +589,6 @@ int VCTFAM::ReadBuffer(PGLOBAL g)
      case RC_NF:
        goto next;
      } // endswitch rc
-#endif   // BLK_INDX

    num_there++;
    } // endif CurNum
--- a/storage/connect/filamzip.cpp
+++ b/storage/connect/filamzip.cpp
@@ -1,11 +1,11 @@
 /*********** File AM Zip C++ Program Source Code File (.CPP) ***********/
 /* PROGRAM NAME: FILAMZIP                                              */
 /* -------------                                                       */
-/*  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:                                             */
 /* -----------------------                                             */
@@ -306,15 +306,12 @@ int ZIPFAM::ReadBuffer(PGLOBAL g)
    /*******************************************************************/
    /*  Record file position in case of UPDATE or DELETE.              */
    /*******************************************************************/
-#if defined(BLK_INDX)
   next:
-#endif   // BLK_INDX
    if (RecordPos(g))
      return RC_FX;

    CurBlk = Rows++;                        // Update RowID

-#if defined(BLK_INDX)
    /*******************************************************************/
    /*  Check whether optimization on ROWID                            */
    /*  can be done, as well as for join as for local filtering.       */
@@ -329,7 +326,7 @@ int ZIPFAM::ReadBuffer(PGLOBAL g)

        goto next;
      } // endswitch rc
-#endif   // BLK_INDX
+
  } else
    Placed = false;

@@ -423,11 +420,7 @@ ZBKFAM::ZBKFAM(PDOSDEF tdp) : ZIPFAM(tdp)
  CurLine = NULL;
  NxtLine = NULL;
  Closing = false;
-#if defined(BLK_INDX)
  BlkPos = tdp->GetTo_Pos();
-#else   // !BLK_INDX
-  BlkPos = NULL;
-#endif  // !BLK_INDX
  } // end of ZBKFAM standard constructor

 ZBKFAM::ZBKFAM(PZBKFAM txfp) : ZIPFAM(txfp)
@@ -448,14 +441,10 @@ int ZBKFAM::MaxBlkSize(PGLOBAL g, int s)
  // Roughly estimate the table size as the sum of blocks
  // that can contain good rows
  for (size = 0, CurBlk = 0; CurBlk < Block; CurBlk++)
-#if defined(BLK_INDX)
    if ((rc = Tdbp->TestBlock(g)) == RC_OK)
      size += (CurBlk == Block - 1) ? Last : Nrec;
    else if (rc == RC_EF)
      break;
-#else   // !BLK_INDX
-    size += (CurBlk == Block - 1) ? Last : Nrec;
-#endif  // !BLK_INDX

  CurBlk = savcur;
  return size;
@@ -540,7 +529,6 @@ int ZBKFAM::SkipRecord(PGLOBAL g, bool header)
 /***********************************************************************/
 int ZBKFAM::ReadBuffer(PGLOBAL g)
  {
-#if defined(BLK_INDX)
  int     n, skip, rc = RC_OK;

  /*********************************************************************/
@@ -615,10 +603,6 @@ int ZBKFAM::ReadBuffer(PGLOBAL g)
    rc = Zerror(g);

  return rc;
-#else   // !BLK_POS
-  strcpy(g->Message, "This AM cannot be used in this version");
-  return RC_FX;
-#endif  // !BLK_POS
  } // end of ReadBuffer

 /***********************************************************************/
@@ -830,7 +814,6 @@ int ZIXFAM::ReadBuffer(PGLOBAL g)
  CurNum = 0;
  Tdbp->SetLine(To_Buf);

-#if defined(BLK_INDX)
  int skip = 0;

 next:
@@ -856,7 +839,6 @@ int ZIXFAM::ReadBuffer(PGLOBAL g)
        return Zerror(g);

      } // endfor i
-#endif   // BLK_INDX

  if (!(n = gzread(Zfile, To_Buf, Buflen))) {
    rc = RC_EF;
@@ -903,7 +885,6 @@ int ZIXFAM::WriteBuffer(PGLOBAL g)
  return RC_OK;
  } // end of WriteBuffer

-#if defined(BLK_INDX)
 /* --------------------------- Class ZLBFAM -------------------------- */

 /***********************************************************************/
@@ -1420,5 +1401,5 @@ void ZLBFAM::Rewind(void)
 //OldBlk = -1;
 //Rbuf = 0;        commented out in case we reuse last read block
  } // end of Rewind
-#endif   // BLK_INDX
+
 /* ------------------------ End of ZipFam ---------------------------- */
--- a/storage/connect/filamzip.h
+++ b/storage/connect/filamzip.h
@@ -1,7 +1,7 @@
 /************** FilAmZip H Declares Source Code File (.H) **************/
-/*  Name: FILAMZIP.H    Version 1.1                                    */
+/*  Name: FILAMZIP.H    Version 1.2                                    */
 /*                                                                     */
-/*  (C) Copyright to the author Olivier BERTRAND          2005-2012    */
+/*  (C) Copyright to the author Olivier BERTRAND          2005-2014    */
 /*                                                                     */
 /*  This file contains the GZIP access method classes declares.        */
 /***********************************************************************/
@@ -122,7 +122,6 @@ class DllExport ZIXFAM : public ZBKFAM {
  // No additional Members
  }; // end of class ZIXFAM

-#if defined(BLK_INDX)
 /***********************************************************************/
 /*  This is the DOS/UNIX Access Method class declaration for PlugDB    */
 /*  fixed/variable files compressed using the zlib library functions.  */
@@ -166,6 +165,5 @@ class DllExport ZLBFAM : public BLKFAM {
  int      *Zlenp;            // Pointer to block length
  bool      Optimized;        // true when opt file is available
  }; // end of class ZLBFAM
-#endif   // BLK_INDX

 #endif // __FILAMZIP_H
--- a/storage/connect/filter.cpp
+++ b/storage/connect/filter.cpp
@@ -68,7 +68,7 @@ PPARM MakeParm(PGLOBAL g, PXOB xp)
 bool   PlugEvalLike(PGLOBAL, LPCSTR, LPCSTR, bool);
 //bool  ReadSubQuery(PGLOBAL, PSUBQ);
 //PSUBQ OpenSubQuery(PGLOBAL, PSQL);
-void   PlugCloseDB(PGLOBAL, PSQL);
+//void  PlugCloseDB(PGLOBAL, PSQL);
 BYTE   OpBmp(PGLOBAL g, OPVAL opc);
 PARRAY MakeValueArray(PGLOBAL g, PPARM pp);

@@ -201,6 +201,7 @@ FILTER::FILTER(PFIL fil1)
  Test[1] = fil1->Test[1];
  } // end of FILTER copy constructor

+#if 0
 /***********************************************************************/
 /*  Linearize:  Does the linearization of the filter tree:             */
 /*    Independent filters (not implied in OR/NOT) will be separated    */
@@ -388,7 +389,6 @@ int FILTER::RefNum(PSQL sqlp)
  return n;
  } // end of RefNum

-#if 0
 /***********************************************************************/
 /*  CheckSubQuery: see SUBQUERY::CheckSubQuery for comment.            */
 /***********************************************************************/
@@ -747,7 +747,6 @@ bool FILTER::CheckHaving(PGLOBAL g, PSQL sqlp)
  sqlp->SetOk(FALSE);
  return FALSE;
  } // end of CheckHaving
-#endif // 0

 /***********************************************************************/
 /*  Used while building a table index. This function split the filter  */
@@ -924,6 +923,7 @@ int FILTER::CheckSpcCol(PTDB tdbp, int n)

  return max(n1, n2);
  } // end of CheckSpcCol
+#endif // 0

 /***********************************************************************/
 /*  Reset the filter arguments to non evaluated yet.                   */
--- a/storage/connect/filter.h
+++ b/storage/connect/filter.h
@@ -53,25 +53,25 @@ class DllExport FILTER : public XOBJECT { /* Filter description block  */
  virtual bool   Init(PGLOBAL);
  virtual bool   Eval(PGLOBAL);
  virtual bool   SetFormat(PGLOBAL, FORMAT&) {return TRUE;}      // NUY
-  virtual int    CheckColumn(PGLOBAL g, PSQL sqlp, PXOB &xp, int &ag);
-  virtual int    RefNum(PSQL);
-  virtual PXOB   SetSelect(PGLOBAL, PSQL, bool) {return NULL;}   // NUY
+//virtual int    CheckColumn(PGLOBAL g, PSQL sqlp, PXOB &xp, int &ag);
+//virtual int    RefNum(PSQL);
+//virtual PXOB   SetSelect(PGLOBAL, PSQL, bool) {return NULL;}   // NUY
 //virtual PXOB   CheckSubQuery(PGLOBAL, PSQL);
-  virtual bool   CheckLocal(PTDB);
-  virtual int    CheckSpcCol(PTDB tdbp, int n);
+//virtual bool   CheckLocal(PTDB);
+//virtual int    CheckSpcCol(PTDB tdbp, int n);
  virtual void   Print(PGLOBAL g, FILE *f, UINT n);
  virtual void   Print(PGLOBAL g, char *ps, UINT z);
-          PFIL   Linearize(bool nosep);
-          PFIL   Link(PGLOBAL g, PFIL fil2);
-          PFIL   RemoveLastSep(void);
+//        PFIL   Linearize(bool nosep);
+//        PFIL   Link(PGLOBAL g, PFIL fil2);
+//        PFIL   RemoveLastSep(void);
 //        PFIL   SortJoin(PGLOBAL g);
 //        bool   FindJoinFilter(POPJOIN opj, PFIL fprec, bool teq,
 //               bool tek, bool tk2, bool tc2, bool tix, bool thx);
 //        bool   CheckHaving(PGLOBAL g, PSQL sqlp);
          bool   Convert(PGLOBAL g, bool having);
-          int    SplitFilter(PFIL *fp);
-          int    SplitFilter(PFIL *fp, PTDB tp, int n);
-          PFIL   LinkFilter(PGLOBAL g, PFIL fp2);
+//        int    SplitFilter(PFIL *fp);
+//        int    SplitFilter(PFIL *fp, PTDB tp, int n);
+//        PFIL   LinkFilter(PGLOBAL g, PFIL fp2);
 //        PFIL   Copy(PTABS t);

 protected:
--- a/storage/connect/global.h
+++ b/storage/connect/global.h
@@ -222,9 +222,7 @@ 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];
--- a/storage/connect/ha_connect.cc
+++ b/storage/connect/ha_connect.cc
@@ -332,10 +332,7 @@ DllExport LPCSTR PlugSetPath(LPSTR to, LPCSTR name, LPCSTR dir)
 */
 static const char *ha_connect_exts[]= {
  ".dos", ".fix", ".csv", ".bin", ".fmt", ".dbf", ".xml", ".ini", ".vec",
-  ".dnx", ".fnx", ".bnx", ".vnx", ".dbx",
-#if defined(BLK_INDX)
-  ".dop", ".fop", ".bop", ".vop",
-#endif   // BLK_INDX
+  ".dnx", ".fnx", ".bnx", ".vnx", ".dbx", ".dop", ".fop", ".bop", ".vop",
  NULL};

 /**
@@ -1358,20 +1355,14 @@ int ha_connect::MakeRecord(char *buf)
    if (bitmap_is_set(map, fp->field_index) || alter) {
      // This is a used field, fill the buffer with value
      for (colp= tdbp->GetColumns(); colp; colp= colp->GetNext())
-#if defined(MRRBKA_SUPPORT)
        if ((!mrr || colp->GetKcol()) &&
            !stricmp(colp->GetName(), (char*)fp->field_name))
          break;
-#else   // !MRRBKA_SUPPORT
-        if (!stricmp(colp->GetName(), (char*)fp->field_name))
-          break;
-#endif  // !MRRBKA_SUPPORT

      if (!colp) {
-#if defined(MRRBKA_SUPPORT)
        if (mrr)
          continue;
-#endif   // MRRBKA_SUPPORT
+
        htrc("Column %s not found\n", fp->field_name);
        dbug_tmp_restore_column_map(table->write_set, org_bitmap);
        DBUG_RETURN(HA_ERR_WRONG_IN_RECORD);
@@ -1656,7 +1647,6 @@ const char *ha_connect::GetValStr(OPVAL vop, bool neg)
 } // end of GetValStr


-#if defined(BLK_INDX)
 /***********************************************************************/
 /*  Check the WHERE condition and return a CONNECT filter.             */
 /***********************************************************************/
@@ -1837,7 +1827,6 @@ PFIL ha_connect::CondFilter(PGLOBAL g, Item *cond)

  return filp;
 } // end of CondFilter
-#endif   // BLK_INDX

 /***********************************************************************/
 /*  Check the WHERE condition and return a MYSQL/ODBC/WQL filter.      */
@@ -2094,19 +2083,12 @@ const COND *ha_connect::cond_push(const COND *cond)
  DBUG_ENTER("ha_connect::cond_push");

  if (tdbp) {
+    PGLOBAL& g= xp->g;
    AMT      tty= tdbp->GetAmType();
    bool     x= (tty == TYPE_AM_MYX || tty == TYPE_AM_XDBC);
    bool     b= (tty == TYPE_AM_WMI || tty == TYPE_AM_ODBC  ||
                 tty == TYPE_AM_TBL || tty == TYPE_AM_MYSQL ||
                 tty == TYPE_AM_PLG || x);
-#if defined(BLK_INDX)
-    bool go= true;
-#else   // !BLK_INDX)
-    bool go= b;
-#endif  // !BLK_INDX
-
-    if (go) {
-      PGLOBAL& g= xp->g;

    if (b) {
      PCFIL    filp= (PCFIL)PlugSubAlloc(g, NULL, sizeof(CONDFIL));
@@ -2129,12 +2111,8 @@ const COND *ha_connect::cond_push(const COND *cond)
      } else if (x && cond)
        tdbp->SetCondFil(filp);   // Wrong filter

-      } // endif b
-#if defined(BLK_INDX)
-        else
+    } else
      tdbp->SetFilter(CondFilter(g, (Item *)cond));
-#endif   // BLK_INDX
-      } // endif go

    } // endif tdbp

@@ -2230,14 +2208,14 @@ int ha_connect::open(const char *name, int mode, uint test_if_locked)
  // Try to set the database environment
  if (g) {
    rc= (CntCheckDB(g, this, name)) ? (-2) : 0;
-#if defined(MRRBKA_SUPPORT)
+
    if (g->Mrr) {
      // This should only happen for the mrr secondary handler
      mrr= true;
      g->Mrr= false;
    } else
      mrr= false;
-#endif   // MRRBKA_SUPPORT
+
  } else
    rc= HA_ERR_INTERNAL_ERROR;

@@ -2259,8 +2237,7 @@ int ha_connect::optimize(THD* thd, HA_CHECK_OPT* check_opt)
  tdbp= GetTDB(g);
  dup->Check |= CHK_OPT;

-  if (tdbp || (tdbp= GetTDB(g))) {
-#if defined(BLK_INDX)
+  if (tdbp) {
    bool b= ((PTDBASE)tdbp)->GetDef()->Indexable();

    if ((rc= ((PTDBASE)tdbp)->ResetTableOpt(g, true, b))) {
@@ -2271,21 +2248,6 @@ int ha_connect::optimize(THD* thd, HA_CHECK_OPT* check_opt)
        rc= HA_ERR_INTERNAL_ERROR;

      } // endif rc
-#else   // !BLK_INDX
-    if (!((PTDBASE)tdbp)->GetDef()->Indexable()) {
-      sprintf(g->Message, "optimize: Table %s is not indexable", tdbp->GetName());
-      my_message(ER_INDEX_REBUILD, g->Message, MYF(0));
-      rc= HA_ERR_UNSUPPORTED;
-    } else if ((rc= ((PTDBASE)tdbp)->ResetTableOpt(g, false, true))) {
-      if (rc == RC_INFO) {
-        push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0, g->Message);
-        rc= 0;
-      } else
-        rc= HA_ERR_INTERNAL_ERROR;
-
-    } // endif's
-#endif  // !BLK_INDX
-

  } else
    rc= HA_ERR_INTERNAL_ERROR;
@@ -2531,9 +2493,7 @@ int ha_connect::index_end()
 {
  DBUG_ENTER("index_end");
  active_index= MAX_KEY;
-#if defined(MRRBKA_SUPPORT)
  ds_mrr.dsmrr_close();
-#endif   // MRRBKA_SUPPORT
  DBUG_RETURN(rnd_end());
 } // end of index_end

@@ -2800,9 +2760,7 @@ int ha_connect::rnd_end()
 //  if (tdbp && xp->last_query_id == valid_query_id)
 //    rc= CloseTable(xp->g);

-#if defined(MRRBKA_SUPPORT)
  ds_mrr.dsmrr_close();
-#endif   // MRRBKA_SUPPORT
  DBUG_RETURN(rc);
 } // end of rnd_end

@@ -5630,9 +5588,6 @@ bool ha_connect::check_if_incompatible_data(HA_CREATE_INFO *info,
  DBUG_RETURN(COMPATIBLE_DATA_NO);
 } // end of check_if_incompatible_data

-
-#if defined(MRRBKA_SUPPORT)
-//#error This is not implemented yet
 /****************************************************************************
 * CONNECT MRR implementation: use DS-MRR
   This is just copied from myisam
@@ -5709,7 +5664,7 @@ Item *ha_connect::idx_cond_push(uint keyno_arg, Item* idx_cond_arg)
  return NULL;
 }
 #endif // 0
-#endif   // MRRBKA_SUPPORT
+

 struct st_mysql_storage_engine connect_storage_engine=
 { MYSQL_HANDLERTON_INTERFACE_VERSION };
@@ -5724,10 +5679,10 @@ maria_declare_plugin(connect)
  PLUGIN_LICENSE_GPL,
  connect_init_func,                            /* Plugin Init */
  connect_done_func,                            /* Plugin Deinit */
-  0x0102,                                       /* version number (1.02) */
+  0x0103,                                       /* version number (1.03) */
  NULL,                                         /* status variables */
  NULL,                                         /* system variables */
-  "1.02",                                        /* string version */
+  "1.03",                                       /* string version */
  MariaDB_PLUGIN_MATURITY_BETA                  /* maturity */
 }
 maria_declare_plugin_end;
--- a/storage/connect/ha_connect.h
+++ b/storage/connect/ha_connect.h
@@ -1,4 +1,4 @@
-/* Copyright (C) Olivier Bertrand 2004 - 2013
+/* Copyright (C) Olivier Bertrand 2004 - 2014

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -122,8 +122,8 @@ 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 freq;
+  ulonglong opt;
  ulonglong fldlen;
  const char *dateformat;
  const char *fieldformat;
@@ -243,11 +243,7 @@ public:
  */
  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
@@ -336,9 +332,7 @@ public:
 virtual const COND *cond_push(const COND *cond);
 PCFIL CheckCond(PGLOBAL g, PCFIL filp, AMT tty, Item *cond);
 const char *GetValStr(OPVAL vop, bool neg);
-#if defined(BLK_INDX)
 PFIL  CondFilter(PGLOBAL g, Item *cond);
-#endif   // BLK_INDX

 /**
   Number of rows in table. It will only be called if
@@ -427,6 +421,9 @@ PFIL  CondFilter(PGLOBAL g, Item *cond);
  */
 //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
@@ -470,6 +467,28 @@ PFIL  CondFilter(PGLOBAL g, Item *cond);
                             enum thr_lock_type lock_type);     ///< required
  int optimize(THD* thd, HA_CHECK_OPT* check_opt);

+  /**
+   * 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;
+
 protected:
  bool check_privileges(THD *thd, PTOS options, char *dbn);
  MODE CheckMode(PGLOBAL g, THD *thd, MODE newmode, bool *chk, bool *cras);
@@ -502,28 +521,4 @@ public:
  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
--- a/storage/connect/myconn.h
+++ b/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);
--- a/storage/connect/plgcnx.h
+++ b/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 ---------------------------- */
--- a/storage/connect/plgdbsem.h
+++ b/storage/connect/plgdbsem.h
@@ -26,20 +26,15 @@

 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      */
-#if defined(BLK_INDX)
             TYPE_FILTER     = 55,    /* Filter Description Block      */
             TYPE_ARRAY      = 63,    /* General array type            */
-#endif   // BLK_INDX
             TYPE_PSZ        = 64,    /* Pointer to String ended by 0  */
             TYPE_SQL        = 65,    /* Pointer to SQL 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                     */
@@ -344,9 +339,7 @@ typedef class XTAB       *PTABLE;
 typedef class COLUMN     *PCOLUMN;
 typedef class XOBJECT    *PXOB;
 typedef class COLBLK     *PCOL;
-//pedef class TBX        *PTBX;
 typedef class TDB        *PTDB;
-typedef       void       *PSQL;          // Not used
 typedef class TDBASE     *PTDBASE;
 typedef class TDBDOS     *PTDBDOS;
 typedef class TDBFIX     *PTDBFIX;
@@ -378,9 +371,7 @@ typedef class COLDEF     *PCOLDEF;
 typedef class CONSTANT   *PCONST;
 typedef class VALUE      *PVAL;
 typedef class VALBLK     *PVBLK;
-#if defined(BLK_INDX)
 typedef class FILTER     *PFIL;
-#endif   // BLK_INDX

 typedef struct _fblock   *PFBLOCK;
 typedef struct _mblock   *PMBLOCK;
@@ -418,43 +409,26 @@ 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   */
-#if defined(BLK_INDX)
  int        Maxbmp;                   /* Maximum XDB2 bitmap size     */
-#endif   // BLK_INDX
  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;

 /***********************************************************************/
@@ -488,7 +462,6 @@ typedef struct _tabs {
  PTABADR P3;
  } TABS;

-#if defined(BLK_INDX)
 /***********************************************************************/
 /*  Argument of expression, function, filter etc. (Xobject)            */
 /***********************************************************************/
@@ -504,22 +477,6 @@ typedef struct _oper {             /* Operator                         */
  int     Mod;                     /* The modificator                  */
  } OPER, *POPER;

-#if 0
-/***********************************************************************/
-/*  Definitions and table of Scalar Functions.                         */
-/***********************************************************************/
-typedef struct _sfdsc {            /* Scalar function description block*/
-  char    Name[16];                /* Scalar function name             */
-  EVAL    EvalType;                /* Type of Init and Eval functions  */
-  OPVAL   Op;                      /* Equivalent operator number       */
-  int     R_Type;                  /* Result Type                      */
-  int     R_Length;                /* Result Length                    */
-  int     R_Prec;                  /* Result Precision                 */
-  int     Numarg;                  /* Number of arguments              */
-  } SFDSC, *PSFDSC;
-#endif // 0
-#endif   // BLK_INDX
-
 /***********************************************************************/
 /*  Following definitions are used to define table fields (columns).   */
 /***********************************************************************/
@@ -617,9 +574,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);
--- a/storage/connect/plgdbutl.cpp
+++ b/storage/connect/plgdbutl.cpp
@@ -374,18 +374,7 @@ PDBUSER PlgMakeUser(PGLOBAL g)
    } // endif dbuserp

  memset(dbuserp, 0, sizeof(DBUSERBLK));
-//dbuserp->Act2 = g->Activityp;
-//#if defined(UNIX)
-//  dbuserp->LineLen = 160;
-//#else
-//  dbuserp->LineLen = 78;
-//#endif
-//dbuserp->Maxres = MAXRES;
-//dbuserp->Maxlin = MAXLIN;
-#if defined(BLK_INDX)
  dbuserp->Maxbmp = MAXBMP;
-#endif   // BLK_INDX
-//dbuserp->AlgChoice = AMOD_AUTO;
  dbuserp->UseTemp = TMP_AUTO;
  dbuserp->Check = CHK_ALL;
  strcpy(dbuserp->Server, "CONNECT");
--- a/storage/connect/plugutil.c
+++ b/storage/connect/plugutil.c
@@ -2,11 +2,11 @@
 /*                                                                     */
 /* PROGRAM NAME: PLUGUTIL                                              */
 /* -------------                                                       */
-/*  Version 2.7                                                        */
+/*  Version 2.8                                                        */
 /*                                                                     */
 /* COPYRIGHT:                                                          */
 /* ----------                                                          */
-/*  (C) Copyright to the author Olivier BERTRAND          1993-2012    */
+/*  (C) Copyright to the author Olivier BERTRAND          1993-2014    */
 /*                                                                     */
 /* WHAT THIS PROGRAM DOES:                                             */
 /* -----------------------                                             */
@@ -153,9 +153,7 @@ 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, "");
--- a/storage/connect/preparse.h
+++ b/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
--- a/storage/connect/reldef.cpp
+++ b/storage/connect/reldef.cpp
@@ -1,11 +1,11 @@
 /************* RelDef CPP Program Source Code File (.CPP) **************/
 /* PROGRAM NAME: REFDEF                                                */
 /* -------------                                                       */
-/*  Version 1.3                                                        */
+/*  Version 1.4                                                        */
 /*                                                                     */
 /* COPYRIGHT:                                                          */
 /* ----------                                                          */
-/*  (C) Copyright to the author Olivier BERTRAND          2004-2012    */
+/*  (C) Copyright to the author Olivier BERTRAND          2004-2014    */
 /*                                                                     */
 /* WHAT THIS PROGRAM DOES:                                             */
 /* -----------------------                                             */
@@ -286,14 +286,8 @@ PTDB OEMDEF::GetTable(PGLOBAL g, MODE mode)
 #if defined(ZIP_SUPPORT)
      if (cmpr == 1)
        txfp = new(g) ZIPFAM(defp);
-      else {
-#if defined(BLK_INDX)
+      else
        txfp = new(g) ZLBFAM(defp);
-#else   // !BLK_INDX
-        strcpy(g->Message, "Compress 2 not supported yet");
-#endif  // !BLK_INDX
-        return NULL;
-      } // endelse
 #else   // !ZIP_SUPPORT
      strcpy(g->Message, "Compress not supported");
      return NULL;
@@ -375,7 +369,6 @@ COLCRT::COLCRT(void)
 /***********************************************************************/
 COLDEF::COLDEF(void) : COLCRT()
  {
-#if defined(BLK_INDX)
  To_Min = NULL;
  To_Max = NULL;
  To_Pos = NULL;
@@ -384,7 +377,6 @@ COLDEF::COLDEF(void) : COLCRT()
  To_Dval = NULL;
  Ndv = 0;
  Nbm = 0;
-#endif   // BLK_INDX
  Buf_Type = TYPE_ERROR;
  Clen = 0;
  Poff = 0;
--- a/storage/connect/reldef.h
+++ b/storage/connect/reldef.h
@@ -1,7 +1,7 @@
 /*************** RelDef H Declares Source Code File (.H) ***************/
-/*  Name: RELDEF.H  Version 1.3                                        */
+/*  Name: RELDEF.H  Version 1.4                                        */
 /*                                                                     */
-/*  (C) Copyright to the author Olivier BERTRAND          2004-2012    */
+/*  (C) Copyright to the author Olivier BERTRAND          2004-2014    */
 /*                                                                     */
 /*  This file contains the DEF classes definitions.                    */
 /***********************************************************************/
@@ -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);

@@ -190,7 +188,6 @@ class DllExport COLDEF : public COLCRT { /* Column description block
  int     GetClen(void) {return Clen;}
  int     GetType(void) {return Buf_Type;}
  int     GetPoff(void) {return Poff;}
-#if defined(BLK_INDX)
  void   *GetMin(void) {return To_Min;}
  void    SetMin(void *minp) {To_Min = minp;}
  void   *GetMax(void) {return To_Max;}
@@ -205,12 +202,10 @@ class DllExport COLDEF : public COLCRT { /* Column description block
  void    SetNdv(int ndv) {Ndv = ndv;}
  int     GetNbm(void) {return Nbm;}
  void    SetNbm(int nbm) {Nbm = nbm;}
-#endif   // BLK_INDX
  int     Define(PGLOBAL g, void *memp, PCOLINFO cfp, int poff);
  void    Define(PGLOBAL g, PCOL colp);

 protected:
-#if defined(BLK_INDX)
  void   *To_Min;              /* Point to array of block min values   */
  void   *To_Max;              /* Point to array of block max values   */
  int    *To_Pos;              /* Point to array of block positions    */
@@ -219,7 +214,6 @@ class DllExport COLDEF : public COLCRT { /* Column description block
  void   *To_Dval;             /* To array of column distinct values   */
  int     Ndv;                 /* Number of distinct values            */
  int     Nbm;                 /* Number of ULONG in bitmap (XDB2)     */
-#endif   // BLK_INDX
  int     Buf_Type;            /* Internal data type                   */
  int     Clen;                /* Internal data size in chars (bytes)  */
  int     Poff;                /* Calculated offset for Packed tables  */
--- a/storage/connect/tabcol.h
+++ b/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
--- a/storage/connect/tabdos.cpp
+++ b/storage/connect/tabdos.cpp
@@ -57,12 +57,8 @@
 #include "tabdos.h"
 #include "tabfix.h"
 #include "tabmul.h"
-#if defined(BLK_INDX)
 #include "array.h"
 #include "blkfil.h"
-//nclude "token.h"
-//#include "scalfnc.h"
-#endif   // BLK_INDX

 /***********************************************************************/
 /*  DB static variables.                                               */
@@ -70,7 +66,6 @@
 int num_read, num_there, num_eq[2];                 // Statistics
 extern "C" int  trace;

-#if defined(BLK_INDX)
 /***********************************************************************/
 /*  Size of optimize file header.                                      */
 /***********************************************************************/
@@ -82,7 +77,6 @@ extern "C" int  trace;
 /***********************************************************************/
 PVBLK AllocValBlock(PGLOBAL, void *, int, int, int len = 0, int prec = 0,
                    bool check = TRUE, bool blank = FALSE, bool un = FALSE);
-#endif   // BLK_INDX

 /* --------------------------- Class DOSDEF -------------------------- */

@@ -101,11 +95,9 @@ DOSDEF::DOSDEF(void)
  Huge = false;
  Accept = false;
  Eof = false;
-#if defined(BLK_INDX)
  To_Pos = NULL;
  Optimized = 0;
  AllocBlks = 0;
-#endif   // BLK_INDX
  Compressed = 0;
  Lrecl = 0;
  AvgLen = 0;
@@ -115,7 +107,6 @@ DOSDEF::DOSDEF(void)
  Maxerr = 0;
  ReadMode = 0;
  Ending = 0;
-//Mtime = 0;
  } // end of DOSDEF constructor

 /***********************************************************************/
@@ -161,97 +152,6 @@ bool DOSDEF::DefineAM(PGLOBAL g, LPCSTR am, int poff)
  return (Cat->GetIndexInfo(g, this) /*&& !Cat->GetCatFnc()*/);
  } // end of DefineAM

-#if 0
-#if defined(BLK_INDX)
-/***********************************************************************/
-/*  DeleteTableFile: Delete DOS/UNIX table files using platform API.   */
-/*  If the table file is protected (declared as read/only) we still    */
-/*  erase the the eventual optimize and index files but return TRUE.   */
-/***********************************************************************/
-bool DOSDEF::DeleteTableFile(PGLOBAL g)
-  {
-  char    filename[_MAX_PATH];
-  bool    rc, irc, orc = FALSE;
-  PIXDEF  pxd;
-  PCOLDEF cdp = NULL;
-
-  /*********************************************************************/
-  /*  Check for potential optimization. These tests are done           */
-  /*  because Optimized is set to 1 only after the first use of an     */
-  /*  optimized table and can be 0 if it has not been used yet.        */
-  /*********************************************************************/
-  if (!Optimized)
-    for (cdp = To_Cols; cdp; cdp = cdp->GetNext())
-      if (cdp->GetOpt())
-        break;
-
-  if (IsOptimized() || cdp || (Recfm == RECFM_VAR && Elemt > 1 && Block))
-    if (!GetOptFileName(g, filename))
-#if defined(WIN32)
-      orc = !DeleteFile(filename);
-#else    // UNIX
-      orc = remove(filename);
-#endif   // WIN32
-
-  // Now delete the table file itself if not protected
-  if (!IsReadOnly()) {
-    rc = Erase(filename);
-  } else
-    rc = true;
-
-  // Delete eventual index file(s)
-  if ((pxd = To_Indx)) {
-    To_Indx = NULL;                           // So file can be erase
-    irc = DeleteIndexFile(g, pxd);
-  } else
-    irc = false;
-
-  return rc || orc || irc;                    // Return TRUE if error
-  } // end of DeleteTableFile
-
-#else   // !BLK_INDX
-/***********************************************************************/
-/*  DeleteTableFile: Delete DOS/UNIX table files using platform API.   */
-/*  If the table file is protected (declared as read/only) we still    */
-/*  erase the the eventual optimize and index files but return true.   */
-/***********************************************************************/
-bool DOSDEF::DeleteTableFile(PGLOBAL g)
-  {
-  char    filename[_MAX_PATH];
-  bool    rc = false;
-
-  // Now delete the table file itself if not protected
-  if (!IsReadOnly()) {
-    rc = Erase(filename);
-  } else
-    rc =true;
-
-  return rc;                               // Return true if error
-  } // end of DeleteTableFile
-#endif  // !BLK_INDX
-
-/***********************************************************************/
-/*  Erase: This was made a separate routine because a strange thing    */
-/*  happened when DeleteTablefile was defined for the VCTDEF class:    */
-/*  when called from Catalog, the DOSDEF routine was still called even */
-/*  when the class was VCTDEF. It also minimizes the specific code.    */
-/***********************************************************************/
-bool DOSDEF::Erase(char *filename)
-  {
-  bool rc;
-
-  PlugSetPath(filename, Fn, GetPath());
-#if defined(WIN32)
-  rc = !DeleteFile(filename);
-#else    // UNIX
-  rc = remove(filename);
-#endif   // UNIX
-
-  return rc;                                  // Return true if error
-  } // end of Erase
-#endif // 0
-
-#if defined(BLK_INDX)
 /***********************************************************************/
 /*  Get the full path/name of the optization file.                     */
 /***********************************************************************/
@@ -308,7 +208,6 @@ void DOSDEF::RemoveOptValues(PGLOBAL g)

  Optimized = 0;
  } // end of RemoveOptValues
-#endif   // BLK_INDX

 /***********************************************************************/
 /*  DeleteIndexFile: Delete DOS/UNIX index file(s) using platform API. */
@@ -446,14 +345,9 @@ PTDB DOSDEF::GetTable(PGLOBAL g, MODE mode)
 #if defined(ZIP_SUPPORT)
      if (Compressed == 1)
        txfp = new(g) ZIPFAM(this);
-      else {
-#if defined(BLK_INDX)
+      else
        txfp = new(g) ZLBFAM(this);
-#else   // !BLK_INDX
-        strcpy(g->Message, "Compress 2 not supported yet");
-        return NULL;
-#endif  // !BLK_INDX
-      } // endelse
+
 #else   // !ZIP_SUPPORT
      sprintf(g->Message, MSG(NO_FEAT_SUPPORT), "ZIP");
      return NULL;
@@ -470,7 +364,6 @@ PTDB DOSDEF::GetTable(PGLOBAL g, MODE mode)

  if (Multiple)
    tdbp = new(g) TDBMUL(tdbp);
-#if defined(BLK_INDX)
  else
    /*******************************************************************/
    /*  For block tables, get eventually saved optimization values.    */
@@ -501,7 +394,6 @@ PTDB DOSDEF::GetTable(PGLOBAL g, MODE mode)
        } // endif Optimized

      } // endif Recfm
-#endif   // BLK_INDX

  return tdbp;
  } // end of GetTable
@@ -522,13 +414,11 @@ TDBDOS::TDBDOS(PDOSDEF tdp, PTXF txfp) : TDBASE(tdp)
  Ftype = tdp->Recfm;
  To_Line = NULL;
  Cardinal = -1;
-#if defined(BLK_INDX)
 //To_BlkIdx = NULL;
  To_BlkFil = NULL;
  SavFil = NULL;
 //Xeval = 0;
  Beval = 0;
-#endif   // BLK_INDX
  } // end of TDBDOS standard constructor

 TDBDOS::TDBDOS(PGLOBAL g, PTDBDOS tdbp) : TDBASE(tdbp)
@@ -539,13 +429,11 @@ TDBDOS::TDBDOS(PGLOBAL g, PTDBDOS tdbp) : TDBASE(tdbp)
  Ftype = tdbp->Ftype;
  To_Line = tdbp->To_Line;
  Cardinal = tdbp->Cardinal;
-#if defined(BLK_INDX)
 //To_BlkIdx = tdbp->To_BlkIdx;
  To_BlkFil = tdbp->To_BlkFil;
  SavFil = tdbp->SavFil;
 //Xeval = tdbp->Xeval;
  Beval = tdbp->Beval;
-#endif   // BLK_INDX
  } // end of TDBDOS copy constructor

 // Method
@@ -595,7 +483,6 @@ int TDBDOS::ResetTableOpt(PGLOBAL g, bool dop, bool dox)
  MaxSize = -1;                        // Size must be recalculated
  Cardinal = -1;                       // as well as Cardinality

-#if defined(BLK_INDX)
  PTXF xp = Txfp;

  To_Filter = NULL;                     // Disable filtering
@@ -628,7 +515,6 @@ int TDBDOS::ResetTableOpt(PGLOBAL g, bool dop, bool dox)
    Mode = MODE_ANY;                    // Just to be clean
    rc = MakeBlockValues(g);            // Redo optimization
    } // endif dop
-#endif   // BLK_INDX

  if (dox && (rc == RC_OK || rc == RC_INFO)) {
    // Remake eventual indexes
@@ -649,15 +535,12 @@ int TDBDOS::ResetTableOpt(PGLOBAL g, bool dop, bool dox)
      // ... or we should remake them.
      rc = MakeIndex(g, NULL, false);

-#if defined(BLK_INDX)
    rc = (rc == RC_INFO) ? prc : rc;
-#endif   // BLK_INDX
    } // endif dox

  return rc;
  } // end of ResetTableOpt

-#if defined(BLK_INDX)
 /***********************************************************************/
 /*  Calculate the block sizes so block I/O can be used and also the    */
 /*  Min/Max values for clustered/sorted table columns.                 */
@@ -1661,7 +1544,6 @@ int TDBDOS::TestBlock(PGLOBAL g)

  return rc;
  } // end of TestBlock
-#endif   // BLK_INDX

 /***********************************************************************/
 /*  Check whether we have to create/update permanent indexes.          */
@@ -1959,9 +1841,7 @@ bool TDBDOS::OpenDB(PGLOBAL g)
      /*****************************************************************/
      To_Kindex->Reset();

-#if defined(BLK_INDX)
    ResetBlockFilter(g);
-#endif   // BLK_INDX
    return false;
    } // endif use

@@ -1997,12 +1877,10 @@ bool TDBDOS::OpenDB(PGLOBAL g)

  Use = USE_OPEN;       // Do it now in case we are recursively called

-#if defined(BLK_INDX)
  /*********************************************************************/
  /*  Allocate the block filter tree if evaluation is possible.        */
  /*********************************************************************/
  To_BlkFil = InitBlockFilter(g, To_Filter);
-#endif   // BLK_INDX

  /*********************************************************************/
  /*  Allocate the line buffer plus a null character.                  */
@@ -2161,8 +2039,6 @@ DOSCOL::DOSCOL(PGLOBAL g, PCOLDEF cdp, PTDB tp, PCOL cp, int i, PSZ am)
  Deplac = cdp->GetOffset();
  Long = cdp->GetLong();
  To_Val = NULL;
-
-#if defined(BLK_INDX)
  Clustered = 0;
  Sorted = 0;
  Ndv = 0;                // Currently used only for XDB2
@@ -2196,7 +2072,6 @@ DOSCOL::DOSCOL(PGLOBAL g, PCOLDEF cdp, PTDB tp, PCOL cp, int i, PSZ am)
    } // endif Clustered

    } // endif Opt
-#endif   // BLK_INDX

  OldVal = NULL;                  // Currently used only in MinMax
  Ldz = false;
@@ -2239,7 +2114,6 @@ DOSCOL::DOSCOL(DOSCOL *col1, PTDB tdbp) : COLBLK(col1, tdbp)
  Dcm = col1->Dcm;
  OldVal = col1->OldVal;
  Buf = col1->Buf;
-#if defined(BLK_INDX)
  Clustered = col1->Clustered;
  Sorted = col1->Sorted;
  Min = col1->Min;
@@ -2248,10 +2122,8 @@ DOSCOL::DOSCOL(DOSCOL *col1, PTDB tdbp) : COLBLK(col1, tdbp)
  Dval = col1->Dval;
  Ndv = col1->Ndv;
  Nbm = col1->Nbm;
-#endif   // BLK_INDX
  } // end of DOSCOL copy constructor

-#if defined(BLK_INDX)
 /***********************************************************************/
 /*  VarSize: This function tells UpdateDB whether or not the block     */
 /*  optimization file must be redone if this column is updated, even   */
@@ -2273,7 +2145,6 @@ bool DOSCOL::VarSize(void)
    return false;

  } // end VarSize
-#endif   // BLK_INDX

 /***********************************************************************/
 /*  SetBuffer: prepare a column block for write operation.             */
@@ -2558,7 +2429,6 @@ void DOSCOL::WriteColumn(PGLOBAL g)

  } // end of WriteColumn

-#if defined(BLK_INDX)
 /***********************************************************************/
 /*  SetMinMax: Calculate minimum and maximum values for one block.     */
 /*  Note: TYPE_STRING is stored and processed with zero ended strings  */
@@ -2696,7 +2566,6 @@ bool DOSCOL::AddDistinctValue(PGLOBAL g)

  return FALSE;
  } // end of AddDistinctValue
-#endif   // BLK_INDX

 /***********************************************************************/
 /*  Make file output of a Dos column descriptor block.                 */
--- a/storage/connect/tabdos.h
+++ b/storage/connect/tabdos.h
@@ -12,16 +12,12 @@
 #include "xtable.h"                       // Table  base class declares
 #include "colblk.h"                       // Column base class declares
 #include "xindex.h"
-#if defined(BLK_INDX)
 #include "filter.h"
-#endif   // BLK_INDX

 //pedef struct _tabdesc   *PTABD;         // For friend setting
 typedef class TXTFAM      *PTXF;
-#if defined(BLK_INDX)
 typedef class BLOCKFILTER *PBF;
 typedef class BLOCKINDEX  *PBX;
-#endif   // BLK_INDX

 /***********************************************************************/
 /*  DOS table.                                                         */
@@ -54,25 +50,20 @@ class DllExport DOSDEF : public TABDEF {  /* Logical table description */
  bool    GetEof(void) {return Eof;}
  int     GetBlksize(void) {return Blksize;}
  int     GetEnding(void) {return Ending;}
-#if defined(BLK_INDX)
  bool    IsOptimized(void) {return (Optimized == 1);}
  void    SetOptimized(int opt) {Optimized = opt;}
  void    SetAllocBlks(int blks) {AllocBlks = blks;}
  int     GetAllocBlks(void) {return AllocBlks;}
  int    *GetTo_Pos(void) {return To_Pos;}
-#endif   // BLK_INDX

  // 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);
  virtual PTDB GetTable(PGLOBAL g, MODE mode);
          bool InvalidateIndex(PGLOBAL g);
-#if defined(BLK_INDX)
          bool GetOptFileName(PGLOBAL g, char *filename);
          void RemoveOptValues(PGLOBAL g);
-#endif   // BLK_INDX

 protected:
 //virtual bool Erase(char *filename);
@@ -87,11 +78,9 @@ 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 */
-#if defined(BLK_INDX)
  int    *To_Pos;             /* To array of block starting positions  */
  int     Optimized;          /* 0: No, 1:Yes, 2:Redo optimization     */
  int     AllocBlks;          /* Number of suballocated opt blocks     */
-#endif   // BLK_INDX
  int     Compressed;         /* 0: No, 1: gz, 2:zlib compressed file  */
  int     Lrecl;              /* Size of biggest record                */
  int     AvgLen;             /* Average size of records               */
@@ -109,14 +98,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
@@ -132,7 +119,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();}
@@ -148,17 +134,14 @@ 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 dop, bool dox);
-#if defined(BLK_INDX)
  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);
-#endif   // BLK_INDX
  virtual void  PrintAM(FILE *f, char *m);

  // Database routines
@@ -186,30 +169,24 @@ class DllExport TDBDOS : public TDBASE {

  // Optimization routines
          int   MakeIndex(PGLOBAL g, PIXDEF pxdf, bool add);
-#if defined(BLK_INDX)
          void  ResetBlockFilter(PGLOBAL g);
          bool  GetDistinctColumnValues(PGLOBAL g, int nrec);

 protected:
          PBF    CheckBlockFilari(PGLOBAL g, PXOB *arg, int op, bool *cnv);
-#endif   // BLK_INDX

  // Members
  PTXF    Txfp;              // To the File access method class
-#if defined(BLK_INDX)
 //PBX     To_BlkIdx;         // To index test block
  PBF     To_BlkFil;         // To evaluation block filter
  PFIL    SavFil;            // Saved hidden filter
-#endif   // BLK_INDX
  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
-#if defined(BLK_INDX)
 //int     Xeval;             // BlockTest return value
  int     Beval;             // BlockEval return value
-#endif   // BLK_INDX
  }; // end of class TDBDOS

 /***********************************************************************/
@@ -228,7 +205,6 @@ class DllExport DOSCOL : public COLBLK {
  // Implementation
  virtual int    GetAmType(void) {return TYPE_AM_DOS;}
  virtual void   SetTo_Val(PVAL valp) {To_Val = valp;}
-#if defined(BLK_INDX)
  virtual int    GetClustered(void) {return Clustered;}
  virtual int    IsClustered(void) {return (Clustered &&
                 ((PDOSDEF)(((PTDBDOS)To_Tdb)->To_Def))->IsOptimized());}
@@ -239,35 +215,28 @@ class DllExport DOSCOL : public COLBLK {
  virtual int    GetNbm(void) {return Nbm;}
  virtual PVBLK  GetBmap(void) {return Bmap;}
  virtual PVBLK  GetDval(void) {return Dval;}
-#endif   // BLK_INDX

  // Methods
-#if defined(BLK_INDX)
  virtual bool   VarSize(void);
-#endif   // BLK_INDX
  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:
-#if defined(BLK_INDX)
  virtual bool   SetMinMax(PGLOBAL g);
  virtual bool   SetBitMap(PGLOBAL g);
          bool   CheckSorted(PGLOBAL g);
          bool   AddDistinctValue(PGLOBAL g);
-#endif   // BLK_INDX

  // Default constructor not to be used
  DOSCOL(void) {}

  // Members
-#if defined(BLK_INDX)
  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
-#endif   // BLK_INDX
  PVAL  To_Val;       // To value used for Update/Insert
  PVAL  OldVal;       // The previous value of the object.
  char *Buf;          // Buffer used in write operations
@@ -275,12 +244,10 @@ class DllExport DOSCOL : public COLBLK {
  bool  Nod;          // True if no decimal point
  int   Dcm;          // Last Dcm digits are decimals
  int   Deplac;       // Offset in dos_buf
-#if defined(BLK_INDX)
  int   Clustered;    // 0:No 1:Yes
  int   Sorted;       // 0:No 1:Asc (2:Desc - NIY)
  int   Ndv;          // Number of distinct values
  int   Nbm;          // Number of uint in bitmap
-#endif   // BLK_INDX
  }; // end of class DOSCOL

 #endif // __TABDOS_H
--- a/storage/connect/tabfix.cpp
+++ b/storage/connect/tabfix.cpp
@@ -45,10 +45,8 @@
 #include "filamfix.h"
 #include "filamdbf.h"
 #include "tabfix.h"      // TDBFIX, FIXCOL classes declares
-#if defined(BLK_INDX)
 #include "array.h"
 #include "blkfil.h"
-#endif   // BLK_INDX

 /***********************************************************************/
 /*  DB static variables.                                               */
@@ -129,7 +127,6 @@ PCOL TDBFIX::MakeCol(PGLOBAL g, PCOLDEF cdp, PCOL cprec, int n)
 /***********************************************************************/
 int TDBFIX::ResetTableOpt(PGLOBAL g, bool dop, bool dox)
  {
-#if defined(BLK_INDX)
  int prc, rc = RC_OK;

  To_Filter = NULL;                     // Disable filtering
@@ -169,10 +166,6 @@ int TDBFIX::ResetTableOpt(PGLOBAL g, bool dop, bool dox)
    } // endif dox

  return rc;
-#else   // !BLK_INDX    
-  RestoreNrec();                        // May have been modified
-  return TDBDOS::ResetTableOpt(g, dop, dox);
-#endif  // !BLK_INDX
  } // end of ResetTableOpt

 /***********************************************************************/
@@ -211,14 +204,14 @@ int TDBFIX::GetMaxSize(PGLOBAL g)
  {
  if (MaxSize < 0) {
    MaxSize = Cardinality(g);
-#if defined(BLK_INDX)
+
    if (MaxSize > 0 && (To_BlkFil = InitBlockFilter(g, To_Filter))
                    && !To_BlkFil->Correlated()) {
      // Use BlockTest to reduce the estimated size
      MaxSize = Txfp->MaxBlkSize(g, MaxSize);
      ResetBlockFilter(g);
      } // endif To_BlkFil
-#endif   // BLK_INDX
+
    } // endif MaxSize

  return MaxSize;
@@ -301,9 +294,7 @@ bool TDBFIX::OpenDB(PGLOBAL g)
    else
      Txfp->Rewind();       // see comment in Work.log

-#if defined(BLK_INDX)
    ResetBlockFilter(g);
-#endif   // BLK_INDX
    return false;
    } // endif use

@@ -335,12 +326,10 @@ bool TDBFIX::OpenDB(PGLOBAL g)
  /*********************************************************************/
  To_Line = Txfp->GetBuf();                       // For WriteDB

-#if defined(BLK_INDX)
  /*********************************************************************/
  /*  Allocate the block filter tree if evaluation is possible.        */
  /*********************************************************************/
  To_BlkFil = InitBlockFilter(g, To_Filter);
-#endif   // BLK_INDX

  if (trace)
    htrc("OpenDos: R%hd mode=%d\n", Tdb_No, Mode);
--- a/storage/connect/tabfmt.cpp
+++ b/storage/connect/tabfmt.cpp
@@ -1,11 +1,11 @@
 /************* TabFmt C++ Program Source Code File (.CPP) **************/
 /* PROGRAM NAME: TABFMT                                                */
 /* -------------                                                       */
-/*  Version 3.8                                                        */
+/*  Version 3.9                                                        */
 /*                                                                     */
 /* COPYRIGHT:                                                          */
 /* ----------                                                          */
-/*  (C) Copyright to the author Olivier BERTRAND          2001 - 2013  */
+/*  (C) Copyright to the author Olivier BERTRAND          2001 - 2014  */
 /*                                                                     */
 /* WHAT THIS PROGRAM DOES:                                             */
 /* -----------------------                                             */
@@ -458,14 +458,9 @@ PTDB CSVDEF::GetTable(PGLOBAL g, MODE mode)
 #if defined(ZIP_SUPPORT)
      if (Compressed == 1)
        txfp = new(g) ZIPFAM(this);
-      else {
-#if defined(BLK_INDX)
+      else
        txfp = new(g) ZLBFAM(this);
-#else   // !BLK_INDX
-        strcpy(g->Message, "Compress 2 not supported yet");
-        return NULL;
-#endif  // !BLK_INDX
-        } // endelse
+
 #else   // !ZIP_SUPPORT
        strcpy(g->Message, "Compress not supported");
        return NULL;
@@ -1275,7 +1270,6 @@ CSVCOL::CSVCOL(CSVCOL *col1, PTDB tdbp) : DOSCOL(col1, tdbp)
  Fldnum = col1->Fldnum;
  } // end of CSVCOL copy constructor

-#if defined(BLK_INDX)
 /***********************************************************************/
 /*  VarSize: This function tells UpdateDB whether or not the block     */
 /*  optimization file must be redone if this column is updated, even   */
@@ -1294,7 +1288,6 @@ bool CSVCOL::VarSize(void)
    return false;

  } // end VarSize
-#endif   // BLK_INDX

 /***********************************************************************/
 /*  ReadColumn: call DOSCOL::ReadColumn after having set the offet     */
--- a/storage/connect/tabfmt.h
+++ b/storage/connect/tabfmt.h
@@ -1,14 +1,13 @@
 /*************** TabFmt H Declares Source Code File (.H) ***************/
-/*  Name: TABFMT.H    Version 2.3                                      */
+/*  Name: TABFMT.H    Version 2.4                                      */
 /*                                                                     */
-/*  (C) Copyright to the author Olivier BERTRAND          2001-2013    */
+/*  (C) Copyright to the author Olivier BERTRAND          2001-2014    */
 /*                                                                     */
 /*  This file contains the CSV and FMT classes declares.               */
 /***********************************************************************/
 #include "xtable.h"                     // Base class declares
 #include "tabdos.h"

-//pedef struct _tabdesc  *PTABD;        // For friend setting
 typedef class  TDBFMT    *PTDBFMT;

 /***********************************************************************/
@@ -112,12 +111,9 @@ class CSVCOL : public DOSCOL {
  virtual int    GetAmType() {return TYPE_AM_CSV;}

  // Methods
-#if defined(BLK_INDX)
  virtual bool   VarSize(void);
-#endif   // BLK_INDX
  virtual void   ReadColumn(PGLOBAL g);
  virtual void   WriteColumn(PGLOBAL g);
-//        void   Print(FILE *, uint);

 protected:
  // Default constructor not to be used
--- a/storage/connect/table.cpp
+++ b/storage/connect/table.cpp
@@ -45,9 +45,7 @@ TDB::TDB(PTABDEF tdp) : Tdb_No(++Tnum)
  {
  Use = USE_NO;
  To_Orig = NULL;
-#if defined(BLK_INDX)
  To_Filter = NULL;
-#endif   // BLK_FILTER
  To_CondFil = NULL;
  Next = NULL;
  Name = (tdp) ? tdp->GetName() : NULL;
@@ -61,9 +59,7 @@ TDB::TDB(PTDB tdbp) : Tdb_No(++Tnum)
  {
  Use = tdbp->Use;
  To_Orig = tdbp;
-#if defined(BLK_INDX)
  To_Filter = NULL;
-#endif   // BLK_FILTER
  To_CondFil = NULL;
  Next = NULL;
  Name = tdbp->Name;
@@ -73,92 +69,6 @@ TDB::TDB(PTDB 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

 /***********************************************************************/
--- a/storage/connect/tabmysql.h
+++ b/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
--- a/storage/connect/taboccur.h
+++ b/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
--- a/storage/connect/tabodbc.h
+++ b/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);
--- a/storage/connect/tabsys.h
+++ b/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
--- a/storage/connect/tabtbl.h
+++ b/storage/connect/tabtbl.h
@@ -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, PCFIL 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);
--- a/storage/connect/tabutil.h
+++ b/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
--- a/storage/connect/tabvct.cpp
+++ b/storage/connect/tabvct.cpp
@@ -301,9 +301,7 @@ bool TDBVCT::OpenDB(PGLOBAL g)
      To_Kindex->Reset();

    Txfp->Rewind();
-#if defined(BLK_INDX)
    ResetBlockFilter(g);
-#endif   // BLK_INDX
    return false;
    } // endif Use

@@ -325,12 +323,10 @@ bool TDBVCT::OpenDB(PGLOBAL g)
  // This was not done in previous version
  Use = USE_OPEN;       // Do it now in case we are recursively called

-#if defined(BLK_INDX)
  /*********************************************************************/
  /*  Allocate the block filter tree if evaluation is possible.        */
  /*********************************************************************/
  To_BlkFil = InitBlockFilter(g, To_Filter);
-#endif   // BLK_INDX

  /*********************************************************************/
  /*  Reset buffer access according to indexing and to mode.           */
--- a/storage/connect/tabvct.h
+++ b/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
--- a/storage/connect/tabwmi.h
+++ b/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
--- a/storage/connect/tabxml.h
+++ b/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
--- a/storage/connect/user_connect.cc
+++ b/storage/connect/user_connect.cc
@@ -147,9 +147,7 @@ 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)
--- a/storage/connect/user_connect.h
+++ b/storage/connect/user_connect.h
@@ -63,7 +63,6 @@ public:
  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
--- a/storage/connect/valblk.cpp
+++ b/storage/connect/valblk.cpp
@@ -448,7 +448,6 @@ template <>
 uchar TYPBLK<uchar>::GetTypedValue(PVBLK blk, int n)
  {return blk->GetUTinyValue(n);}

-#if defined(BLK_INDX)
 /***********************************************************************/
 /*  Set one value in a block if val is less than the current value.    */
 /***********************************************************************/
@@ -478,7 +477,6 @@ void TYPBLK<TYPE>::SetMax(PVAL valp, int n)
    tmin = tval;

  } // end of SetMax
-#endif   // BLK_INDX

 #if 0
 /***********************************************************************/
@@ -812,7 +810,6 @@ void CHRBLK::SetValue(PVBLK pv, int n1, int n2)
  SetNull(n1, b);
  } // end of SetValue

-#if defined(BLK_INDX)
 /***********************************************************************/
 /*  Set one value in a block if val is less than the current value.    */
 /***********************************************************************/
@@ -842,7 +839,6 @@ void CHRBLK::SetMax(PVAL valp, int n)
    memcpy(bp, vp, Long);

  } // end of SetMax
-#endif   // BLK_INDX

 #if 0
 /***********************************************************************/
@@ -1166,7 +1162,6 @@ void STRBLK::SetValue(char *sp, uint len, int n)
  Strp[n] = p;
  } // end of SetValue

-#if defined(BLK_INDX)
 /***********************************************************************/
 /*  Set one value in a block if val is less than the current value.    */
 /***********************************************************************/
@@ -1194,7 +1189,6 @@ void STRBLK::SetMax(PVAL valp, int n)
    SetValue(valp, n);

  } // end of SetMax
-#endif   // BLK_INDX

 /***********************************************************************/
 /*  Move one value from i to j.                                        */
@@ -1335,7 +1329,6 @@ void DATBLK::SetValue(PSZ p, int n)

  } // end of SetValue

-#if defined(BLK_INDX)
 /* -------------------------- Class MBVALS --------------------------- */

 /***********************************************************************/
@@ -1379,7 +1372,6 @@ void MBVALS::Free(void)
  PlgDBfree(Mblk);
  Vblk = NULL;
  } // end of Free
-#endif   // BLK_INDX

 /* ------------------------- End of Valblk --------------------------- */

--- a/storage/connect/valblk.h
+++ b/storage/connect/valblk.h
@@ -22,7 +22,6 @@ DllExport PVBLK AllocValBlock(PGLOBAL, void*, int, int, int, int,
                                              bool, bool, bool);
 const char *GetFmt(int type, bool un = false);

-#if defined(BLK_INDX)
 /***********************************************************************/
 /*  DB static external variables.                                      */
 /***********************************************************************/
@@ -52,13 +51,11 @@ class MBVALS : public BLOCK {
  }; // end of class MBVALS

 typedef class MBVALS *PMBV;
-#endif   // BLK_INDX

 /***********************************************************************/
 /*  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);
@@ -111,14 +108,8 @@ 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 defined(BLK_INDX)
  virtual void   SetMin(PVAL valp, int n) = 0;
  virtual void   SetMax(PVAL valp, int n) = 0;
-#endif   // BLK_INDX
-#if 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;
@@ -153,12 +144,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];}
@@ -194,11 +183,8 @@ 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);
-#if defined(BLK_INDX)
  virtual void   SetMin(PVAL valp, int n);
  virtual void   SetMax(PVAL valp, int n);
-#endif   // BLK_INDX
  virtual void   Move(int i, int j);
  virtual int    CompVal(PVAL vp, int n);
  virtual int    CompVal(int i1, int i2);
@@ -249,11 +235,8 @@ 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);
-#if defined(BLK_INDX)
  virtual void   SetMin(PVAL valp, int n);
  virtual void   SetMax(PVAL valp, int n);
-#endif   // BLK_INDX
  virtual void   Move(int i, int j);
  virtual int    CompVal(PVAL vp, int n);
  virtual int    CompVal(int i1, int i2);
@@ -305,11 +288,8 @@ 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);
-#if defined(BLK_INDX)
  virtual void   SetMin(PVAL valp, int n);
  virtual void   SetMax(PVAL valp, int n);
-#endif   // BLK_INDX
  virtual void   Move(int i, int j);
  virtual int    CompVal(PVAL vp, int n);
  virtual int    CompVal(int i1, int i2);
--- a/storage/connect/value.cpp
+++ b/storage/connect/value.cpp
@@ -91,7 +91,6 @@ PSZ strlwr(PSZ s);
 }
 #endif   // !WIN32

-#if defined(BLK_INDX)
 /***********************************************************************/
 /*  Returns the bitmap representing the conditions that must not be    */
 /*  met when returning from TestValue for a given operator.            */
@@ -117,7 +116,6 @@ BYTE OpBmp(PGLOBAL g, OPVAL opc)

  return bt;
  } // end of OpBmp
-#endif   // BLK_INDX

 /***********************************************************************/
 /*  Get a long long number from its character representation.          */
@@ -306,7 +304,6 @@ const char *GetFmt(int type, bool un)
  return fmt;
  } // end of GetFmt

-#if defined(BLK_INDX)
 /***********************************************************************/
 /*  ConvertType: what this function does is to determine the type to   */
 /*  which should be converted a value so no precision would be lost.   */
@@ -353,7 +350,6 @@ int ConvertType(int target, int type, CONV kind, bool match)
    } // endswitch kind

  } // end of ConvertType
-#endif   // BLK_INDX

 /***********************************************************************/
 /*  AllocateConstant: allocates a constant Value.                      */
@@ -451,7 +447,6 @@ PVAL AllocateValue(PGLOBAL g, int type, int len, int prec,
  return valp;
  } // end of AllocateValue

-#if defined(BLK_INDX)
 /***********************************************************************/
 /*  Allocate a constant Value converted to newtype.                    */
 /*  Can also be used to copy a Value eventually converted.             */
@@ -519,7 +514,6 @@ PVAL AllocateValue(PGLOBAL g, PVAL valp, int newtype, int uns)
  valp->SetGlobal(g);
  return valp;
  } // end of AllocateValue
-#endif   // BLK_INDX

 /* -------------------------- Class VALUE ---------------------------- */

@@ -556,7 +550,6 @@ const char *VALUE::GetXfmt(void)
  return fmt;
  } // end of GetFmt

-#if defined(BLK_INDX)
 /***********************************************************************/
 /*  Returns a BYTE indicating the comparison between two values.       */
 /*  Bit 1 indicates equality, Bit 2 less than, and Bit3 greater than.  */
@@ -568,7 +561,6 @@ BYTE VALUE::TestValue(PVAL vp)

  return (n > 0) ? 0x04 : (n < 0) ? 0x02 : 0x01;
  } // end of TestValue
-#endif   // BLK_INDX

 /* -------------------------- Class TYPVAL ---------------------------- */

@@ -940,7 +932,6 @@ bool TYPVAL<TYPE>::IsEqual(PVAL vp, bool chktype)

  } // end of IsEqual

-#if defined(BLK_INDX)
 /***********************************************************************/
 /*  Compare values and returns 1, 0 or -1 according to comparison.     */
 /*  This function is used for evaluation of numeric filters.           */
@@ -958,7 +949,6 @@ int TYPVAL<TYPE>::CompareValue(PVAL vp)

  return (Tval > n) ? 1 : (Tval < n) ? (-1) : 0;
  } // end of CompareValue
-#endif   // BLK_INDX

 /***********************************************************************/
 /*  FormatValue: This function set vp (a STRING value) to the string   */
@@ -1410,7 +1400,6 @@ bool TYPVAL<PSZ>::IsEqual(PVAL vp, bool chktype)

  } // end of IsEqual

-#if defined(BLK_INDX)
 /***********************************************************************/
 /*  Compare values and returns 1, 0 or -1 according to comparison.     */
 /*  This function is used for evaluation of numeric filters.           */
@@ -1436,7 +1425,6 @@ int TYPVAL<PSZ>::CompareValue(PVAL vp)

  return (n > 0) ? 1 : (n < 0) ? -1 : 0;
  } // end of CompareValue
-#endif   // BLK_INDX

 /***********************************************************************/
 /*  FormatValue: This function set vp (a STRING value) to the string   */
@@ -1664,7 +1652,6 @@ bool DECVAL::IsEqual(PVAL vp, bool chktype)
  return !strcmp(Strp, vp->GetCharString(buf));
  } // end of IsEqual

-#if defined(BLK_INDX)
 /***********************************************************************/
 /*  Compare values and returns 1, 0 or -1 according to comparison.     */
 /*  This function is used for evaluation of numeric filters.           */
@@ -1681,7 +1668,6 @@ int DECVAL::CompareValue(PVAL vp)

  return (f > n) ? 1 : (f < n) ? (-1) : 0;
  } // end of CompareValue
-#endif   // BLK_INDX

 #if 0
 /***********************************************************************/
--- a/storage/connect/value.h
+++ b/storage/connect/value.h
@@ -46,10 +46,8 @@ DllExport char *GetFormatType(int);
 DllExport int   GetFormatType(char);
 DllExport bool  IsTypeChar(int type);
 DllExport bool  IsTypeNum(int type);
-#if defined(BLK_INDX)
 DllExport int   ConvertType(int, int, CONV, bool match = false);
 DllExport PVAL  AllocateValue(PGLOBAL, PVAL, int = TYPE_VOID, int = 0);
-#endif   // BLK_INDX
 DllExport PVAL  AllocateValue(PGLOBAL, int, int len = 0, int prec = 0,
                              bool uns = false, PSZ fmt = NULL);
 DllExport ulonglong CharToNumber(char *, int, ulonglong, bool,
@@ -97,11 +95,9 @@ class DllExport VALUE : public BLOCK {
  virtual bool   SetValue_pval(PVAL valp, bool chktype = false) = 0;
  virtual bool   SetValue_char(char *p, int n) = 0;
  virtual void   SetValue_psz(PSZ s) = 0;
-#if defined(BLK_INDX)
  virtual void   SetValue_bool(bool b) {assert(FALSE);}
  virtual int    CompareValue(PVAL vp) = 0;
  virtual BYTE   TestValue(PVAL vp);
-#endif   // BLK_INDX
  virtual void   SetValue(char c) {assert(false);}
  virtual void   SetValue(uchar c) {assert(false);}
  virtual void   SetValue(short i) {assert(false);}
@@ -170,10 +166,8 @@ class DllExport TYPVAL : public VALUE {
  virtual bool   SetValue_pval(PVAL valp, bool chktype);
  virtual bool   SetValue_char(char *p, int n);
  virtual void   SetValue_psz(PSZ s);
-#if defined(BLK_INDX)
  virtual void   SetValue_bool(bool b) {Tval = (b) ? 1 : 0;}
  virtual int    CompareValue(PVAL vp);
-#endif   // BLK_INDX
  virtual void   SetValue(char c) {Tval = (TYPE)c; Null = false;}
  virtual void   SetValue(uchar c) {Tval = (TYPE)c; Null = false;}
  virtual void   SetValue(short i) {Tval = (TYPE)i; Null = false;}
@@ -253,9 +247,7 @@ class DllExport TYPVAL<PSZ>: public VALUE {
  virtual void   SetValue(ulonglong n);
  virtual void   SetValue(double f);
  virtual void   SetBinValue(void *p);
-#if defined(BLK_INDX)
  virtual int    CompareValue(PVAL vp);
-#endif   // BLK_INDX
  virtual bool   GetBinValue(void *buf, int buflen, bool go);
  virtual char  *ShowValue(char *buf, int);
  virtual char  *GetCharString(char *p);
@@ -285,20 +277,10 @@ 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);
-#if defined(BLK_INDX)
  virtual int    CompareValue(PVAL vp);
-#endif   // BLK_INDX
-//virtual bool   FormatValue(PVAL vp, char *fmt);
-//virtual bool   SetConstFormat(PGLOBAL, FORMAT&);

  // Members
  }; // end of class DECVAL
@@ -327,15 +309,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 *);

--- a/storage/connect/xindex.cpp
+++ b/storage/connect/xindex.cpp
@@ -1792,7 +1792,7 @@ 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() == 2;
  } // end of XINDXS constructor

 /***********************************************************************/
@@ -2797,7 +2797,7 @@ 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() == 2;

 //SetNulls(colp->IsNullable()); for when null columns will be indexable
  return false;
--- a/storage/connect/xindex.h
+++ b/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

--- a/storage/connect/xobject.cpp
+++ b/storage/connect/xobject.cpp
@@ -1,7 +1,7 @@
 /************ Xobject C++ Functions Source Code File (.CPP) ************/
-/*  Name: XOBJECT.CPP  Version 2.2                                     */
+/*  Name: XOBJECT.CPP  Version 2.3                                     */
 /*                                                                     */
-/*  (C) Copyright to the author Olivier BERTRAND          1998-2012    */
+/*  (C) Copyright to the author Olivier BERTRAND          1998-2014    */
 /*                                                                     */
 /*  This file contains base XOBJECT class functions.                   */
 /*  Also here is the implementation of the CONSTANT class.             */
@@ -109,7 +109,6 @@ int CONSTANT::GetLengthEx(void)
  return Value->GetValLen();
  } // end of GetLengthEx

-#if defined(BLK_INDX)
 /***********************************************************************/
 /*  Convert a constant to the given type.                              */
 /***********************************************************************/
@@ -120,7 +119,6 @@ void CONSTANT::Convert(PGLOBAL g, int newtype)
      longjmp(g->jumper[g->jump_level], TYPE_CONST);

  } // end of Convert
-#endif   // BLK_INDX

 /***********************************************************************/
 /*  Compare: returns true if this object is equivalent to xp.          */
--- a/storage/connect/xobject.h
+++ b/storage/connect/xobject.h
@@ -1,7 +1,7 @@
 /*************** Xobject H Declares Source Code File (.H) **************/
-/*  Name: XOBJECT.H    Version 2.3                                     */
+/*  Name: XOBJECT.H    Version 2.4                                     */
 /*                                                                     */
-/*  (C) Copyright to the author Olivier BERTRAND          1998-2012    */
+/*  (C) Copyright to the author Olivier BERTRAND          1998-2014    */
 /*                                                                     */
 /*  This file contains the XOBJECT and derived classes declares.       */
 /***********************************************************************/
@@ -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(PTDB 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,14 +110,8 @@ 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;}
-#if defined(BLK_INDX)
          void   Convert(PGLOBAL g, int newtype);
-#endif   // BLK_INDX
-//        bool   Rephrase(PGLOBAL g, PSZ work);
          void   SetValue(PVAL vp) {Value = vp;}
-  virtual bool   VerifyColumn(PTDB 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
--- a/storage/connect/xtable.h
+++ b/storage/connect/xtable.h
@@ -62,10 +62,8 @@ class DllExport TDB: public BLOCK {     // Table Descriptor Block.
  inline  PCOL   GetColumns(void) {return Columns;}
  inline  int    GetDegree(void) {return Degree;}
  inline  MODE   GetMode(void) {return Mode;}
-#if defined(BLK_INDX)
  inline  PFIL   GetFilter(void) {return To_Filter;}
  inline  void   SetFilter(PFIL fp) {To_Filter = fp;}
-#endif   // BLK_INDX
  inline  void   SetOrig(PTDB txp) {To_Orig = txp;}
  inline  void   SetUse(TUSE n) {Use = n;}
  inline  void   SetCondFil(PCFIL cfp) {To_CondFil = cfp;}
@@ -112,17 +110,11 @@ class DllExport TDB: public BLOCK {     // 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;
-#if defined(BLK_INDX)
  PFIL   To_Filter;
-#endif   // BLK_INDX
  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