diff --git a/storage/connect/connect.cc b/storage/connect/connect.cc
index cf11a22d32b..1433a5c6ce4 100644
--- a/storage/connect/connect.cc
+++ b/storage/connect/connect.cc
@@ -587,7 +587,8 @@ int CntCloseTable(PGLOBAL g, PTDB tdbp)
   tbxp= (TDBDOX*)tdbp;
   tbxp->SetKindex(NULL);
   tbxp->To_Key_Col= NULL;
-  rc= tbxp->ResetTableOpt(g, false, ((PTDBASE)tdbp)->GetDef()->Indexable());
+  rc= tbxp->ResetTableOpt(g, true, 
+                           ((PTDBASE)tdbp)->GetDef()->Indexable() == 1);
 
  err:
   if (trace > 1)
@@ -709,7 +710,7 @@ RCODE CntIndexRead(PGLOBAL g, PTDB ptdb, OPVAL op,
                    const void *key, int len, bool mrr)
   {
   char   *kp= (char*)key;
-  int     n;
+  int     n, x;
   short   lg;
   bool    rcb;
   RCODE   rc;
@@ -720,9 +721,18 @@ RCODE CntIndexRead(PGLOBAL g, PTDB ptdb, OPVAL op,
 
   if (!ptdb)
     return RC_FX;
-  if (!((PTDBASE)ptdb)->GetDef()->Indexable()) {
+  else
+    x= ((PTDBASE)ptdb)->GetDef()->Indexable();
+
+  if (!x) {
     sprintf(g->Message, "CntIndexRead: Table %s is not indexable", ptdb->GetName());
     return RC_FX;
+  } else if (x == 2) {
+    // Remote index
+    if (ptdb->ReadKey(g, op, key, len))
+      return RC_FX;
+
+    goto rnd;
   } else
     tdbp= (PTDBDOX)ptdb;
 
@@ -782,8 +792,9 @@ RCODE CntIndexRead(PGLOBAL g, PTDB ptdb, OPVAL op,
   xbp->SetOp(op);
   xbp->SetNth(0);
 
-  if ((rc= (RCODE)tdbp->ReadDB(g)) == RC_OK)
-    rc= EvalColumns(g, tdbp, mrr);
+ rnd:
+  if ((rc= (RCODE)ptdb->ReadDB(g)) == RC_OK)
+    rc= EvalColumns(g, ptdb, mrr);
 
   return rc;
   } // end of CntIndexRead
@@ -795,7 +806,7 @@ int CntIndexRange(PGLOBAL g, PTDB ptdb, const uchar* *key, uint *len,
                    bool *incl, key_part_map *kmap)
   {
   const uchar *p, *kp;
-  int     i, n, k[2];
+  int     i, n, x, k[2];
   short   lg;
   bool    b, rcb;
   PVAL    valp;
@@ -805,10 +816,16 @@ int CntIndexRange(PGLOBAL g, PTDB ptdb, const uchar* *key, uint *len,
 
   if (!ptdb)
     return -1;
-  else if (!((PTDBASE)ptdb)->GetDef()->Indexable()) {
+
+  x= ((PTDBASE)ptdb)->GetDef()->Indexable();
+
+  if (!x) {
     sprintf(g->Message, "CntIndexRange: Table %s is not indexable", ptdb->GetName());
     DBUG_PRINT("Range", ("%s", g->Message));
     return -1;
+  } else if (x == 2) {
+    // Remote index
+    return 2;
   } else
     tdbp= (PTDBDOX)ptdb;
 
diff --git a/storage/connect/ha_connect.cc b/storage/connect/ha_connect.cc
index 8290d1d765c..2a3f83c10d6 100644
--- a/storage/connect/ha_connect.cc
+++ b/storage/connect/ha_connect.cc
@@ -1243,9 +1243,10 @@ PTDB ha_connect::GetTDB(PGLOBAL g)
   if (!xp->CheckQuery(valid_query_id) && tdbp
                       && !stricmp(tdbp->GetName(), table_name)
                       && (tdbp->GetMode() == xmod
+                       || (tdbp->GetMode() == MODE_READ && xmod == MODE_READX)
                        || tdbp->GetAmType() == TYPE_AM_XML)) {
     tp= tdbp;
-//  tp->SetMode(xmod);
+    tp->SetMode(xmod);
   } else if ((tp= CntGetTDB(g, table_name, xmod, this))) {
     valid_query_id= xp->last_query_id;
     tp->SetMode(xmod);
@@ -1642,6 +1643,88 @@ int ha_connect::CheckRecord(PGLOBAL g, const uchar *oldbuf, uchar *newbuf)
 } // end of dummy CheckRecord
 
 
+/***********************************************************************/
+/*  Return the where clause for remote indexed read.                   */
+/***********************************************************************/
+bool ha_connect::MakeKeyWhere(PGLOBAL g, char *qry, OPVAL op, char *q, 
+                                         const void *key, int klen)
+{
+  const uchar   *ptr;
+  uint           rem, len, stlen; //, prtlen;
+  bool           nq, b= false;
+  Field         *fp;
+  KEY           *kfp;
+  KEY_PART_INFO *kpart;
+
+  if (active_index == MAX_KEY)
+    return 0;
+
+  strcat(qry, " WHERE (");
+  kfp= &table->key_info[active_index];
+  rem= kfp->user_defined_key_parts,
+  len= klen,
+  ptr= (const uchar *)key;
+
+  for (kpart= kfp->key_part; rem; rem--, kpart++) {
+    fp= kpart->field;
+    stlen= kpart->store_length;
+//  prtlen= min(stlen, len);
+    nq= fp->str_needs_quotes();
+
+    if (b)
+      strcat(qry, " AND ");
+    else
+      b= true;
+
+    strcat(strncat(strcat(qry, q), fp->field_name, strlen(fp->field_name)), q);
+
+    switch (op) {
+      case OP_EQ:
+      case OP_GT:
+      case OP_GE:
+        strcat(qry, GetValStr(op, false));
+        break;
+      default:
+        strcat(qry, " ??? ");
+      } // endwitch op
+
+    if (nq)
+      strcat(qry, "'");
+
+    if (kpart->key_part_flag & HA_VAR_LENGTH_PART) {
+      String varchar;
+      uint   var_length= uint2korr(ptr);
+
+      varchar.set_quick((char*) ptr+HA_KEY_BLOB_LENGTH,
+                      var_length, &my_charset_bin);
+      strncat(qry, varchar.ptr(), varchar.length());
+    } else {
+      char   strbuff[MAX_FIELD_WIDTH];
+      String str(strbuff, sizeof(strbuff), kpart->field->charset()), *res;
+
+      res= fp->val_str(&str, ptr);
+      strncat(qry, res->ptr(), res->length());
+    } // endif flag
+
+    if (nq)
+      strcat(qry, "'");
+
+    if (stlen >= len)
+      break;
+
+    len-= stlen;
+
+    /* For nullable columns, null-byte is already skipped before, that is
+      ptr was incremented by 1. Since store_length still counts null-byte,
+      we need to subtract 1 from store_length. */
+    ptr+= stlen - test(kpart->null_bit);
+    } // endfor kpart
+
+  strcat(qry, ")");
+  return false;
+} // end of MakeKeyWhere
+
+
 /***********************************************************************/
 /*  Return the string representing an operator.                        */
 /***********************************************************************/
@@ -1948,7 +2031,7 @@ PCFIL ha_connect::CheckCond(PGLOBAL g, PCFIL filp, AMT tty, Item *cond)
 
         } else {
           p1= p2 + strlen(p2);
-          strcpy(p1, GetValStr(vop, FALSE));
+          strcpy(p1, GetValStr(vop, false));
           p2= p1 + strlen(p1);
         } // endif CheckCond
 
@@ -2311,7 +2394,7 @@ int ha_connect::optimize(THD* thd, HA_CHECK_OPT* check_opt)
   dup->Check |= CHK_OPT;
 
   if (tdbp) {
-    bool b= ((PTDBASE)tdbp)->GetDef()->Indexable();
+    bool b= (((PTDBASE)tdbp)->GetDef()->Indexable() == 1);
 
     if ((rc= ((PTDBASE)tdbp)->ResetTableOpt(g, true, b))) {
       if (rc == RC_INFO) {
@@ -2523,6 +2606,18 @@ int ha_connect::index_init(uint idx, bool sorted)
   if (xtrace)
     htrc("index_init: this=%p idx=%u sorted=%d\n", this, idx, sorted);
 
+  if (GetIndexType(GetRealType()) == 2) {
+    // This is a remote index
+    xmod= MODE_READX;
+
+    if (!(rc= rnd_init(0))) {
+      active_index= idx;
+      indexing= 2;         // TO DO: mul?
+      } //endif rc
+
+    DBUG_RETURN(rc);
+    } // endif index type
+
   if ((rc= rnd_init(0)))
     return rc;
 
@@ -3040,12 +3135,16 @@ int ha_connect::info(uint flag)
       if (cat && table)
         cat->SetDataPath(g, table->s->db.str);
       else
-        return HA_ERR_INTERNAL_ERROR;           // Should never happen
+        DBUG_RETURN(HA_ERR_INTERNAL_ERROR);       // Should never happen
 
       tdbp= GetTDB(g);
       } // endif tdbp
 
     valid_info= CntInfo(g, tdbp, &xinfo);
+
+    if (((signed)xinfo.records) < 0)
+      DBUG_RETURN(HA_ERR_INITIALIZATION);  // Error in Cardinality
+
     } // endif valid_info
 
   if (flag & HA_STATUS_VARIABLE) {
@@ -3305,7 +3404,7 @@ MODE ha_connect::CheckMode(PGLOBAL g, THD *thd,
         newmode= MODE_ALTER;
         break;
       default:
-        htrc("Unsupported sql_command=%d", thd_sql_command(thd));
+        htrc("Unsupported sql_command=%d\n", thd_sql_command(thd));
         strcpy(g->Message, "CONNECT Unsupported command");
         my_message(ER_NOT_ALLOWED_COMMAND, g->Message, MYF(0));
         newmode= MODE_ERROR;
@@ -3350,7 +3449,7 @@ MODE ha_connect::CheckMode(PGLOBAL g, THD *thd,
         newmode= MODE_ALTER;
         break;
       default:
-        htrc("Unsupported sql_command=%d", thd_sql_command(thd));
+        htrc("Unsupported sql_command=%d\n", thd_sql_command(thd));
         strcpy(g->Message, "CONNECT Unsupported command");
         my_message(ER_NOT_ALLOWED_COMMAND, g->Message, MYF(0));
         newmode= MODE_ERROR;
@@ -3474,87 +3573,88 @@ int ha_connect::external_lock(THD *thd, int lock_type)
 //        DBUG_RETURN(HA_ERR_INTERNAL_ERROR);  causes assert error
           push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 0, g->Message);
           DBUG_RETURN(0);
-          } // endif Indexable
-
-        bool    oldsep= ((PCHK)g->Xchk)->oldsep;
-        bool    newsep= ((PCHK)g->Xchk)->newsep;
-        PTDBDOS tdp= (PTDBDOS)tdbp;
-
-        PDOSDEF ddp= (PDOSDEF)tdp->GetDef();
-        PIXDEF  xp, xp1, xp2, drp=NULL, adp= NULL;
-        PIXDEF  oldpix= ((PCHK)g->Xchk)->oldpix;
-        PIXDEF  newpix= ((PCHK)g->Xchk)->newpix;
-        PIXDEF *xlst, *xprc;
-
-        ddp->SetIndx(oldpix);
-
-        if (oldsep != newsep) {
-          // All indexes have to be remade
-          ddp->DeleteIndexFile(g, NULL);
-          oldpix= NULL;
-          ddp->SetIndx(NULL);
-          SetBooleanOption("Sepindex", newsep);
-        } else if (newsep) {
-          // Make the list of dropped indexes
-          xlst= &drp; xprc= &oldpix;
-
-          for (xp2= oldpix; xp2; xp2= xp) {
-            for (xp1= newpix; xp1; xp1= xp1->Next)
-              if (IsSameIndex(xp1, xp2))
-                break;        // Index not to drop
-
-            xp= xp2->GetNext();
-
-            if (!xp1) {
-              *xlst= xp2;
-              *xprc= xp;
-              *(xlst= &xp2->Next)= NULL;
-            } else
-              xprc= &xp2->Next;
-
-            } // endfor xp2
-
-          if (drp) {
-            // Here we erase the index files
-            ddp->DeleteIndexFile(g, drp);
-            } // endif xp1
-
-        } else if (oldpix) {
-          // TODO: optimize the case of just adding new indexes
-          if (!newpix)
+        } else if (((PTDBASE)tdbp)->GetDef()->Indexable() == 1) {
+          bool    oldsep= ((PCHK)g->Xchk)->oldsep;
+          bool    newsep= ((PCHK)g->Xchk)->newsep;
+          PTDBDOS tdp= (PTDBDOS)tdbp;
+      
+          PDOSDEF ddp= (PDOSDEF)tdp->GetDef();
+          PIXDEF  xp, xp1, xp2, drp=NULL, adp= NULL;
+          PIXDEF  oldpix= ((PCHK)g->Xchk)->oldpix;
+          PIXDEF  newpix= ((PCHK)g->Xchk)->newpix;
+          PIXDEF *xlst, *xprc; 
+      
+          ddp->SetIndx(oldpix);
+      
+          if (oldsep != newsep) {
+            // All indexes have to be remade
             ddp->DeleteIndexFile(g, NULL);
-
-          oldpix= NULL;     // To remake all indexes
-          ddp->SetIndx(NULL);
-        } // endif sepindex
-
-        // Make the list of new created indexes
-        xlst= &adp; xprc= &newpix;
-
-        for (xp1= newpix; xp1; xp1= xp) {
-          for (xp2= oldpix; xp2; xp2= xp2->Next)
-            if (IsSameIndex(xp1, xp2))
-              break;        // Index already made
-
-          xp= xp1->Next;
-
-          if (!xp2) {
-            *xlst= xp1;
-            *xprc= xp;
-            *(xlst= &xp1->Next)= NULL;
-          } else
-            xprc= &xp1->Next;
-
-          } // endfor xp1
-
-        if (adp)
-          // Here we do make the new indexes
-          if (tdp->MakeIndex(g, adp, true) == RC_FX) {
-            // Make it a warning to avoid crash
-            push_warning(thd, Sql_condition::WARN_LEVEL_WARN,
-                              0, g->Message);
-            rc= 0;
-            } // endif MakeIndex
+            oldpix= NULL;
+            ddp->SetIndx(NULL);
+            SetBooleanOption("Sepindex", newsep);
+          } else if (newsep) {
+            // Make the list of dropped indexes
+            xlst= &drp; xprc= &oldpix;
+      
+            for (xp2= oldpix; xp2; xp2= xp) {
+              for (xp1= newpix; xp1; xp1= xp1->Next)
+                if (IsSameIndex(xp1, xp2))
+                  break;        // Index not to drop
+      
+              xp= xp2->GetNext();
+      
+              if (!xp1) {
+                *xlst= xp2;
+                *xprc= xp;
+                *(xlst= &xp2->Next)= NULL;
+              } else
+                xprc= &xp2->Next;
+      
+              } // endfor xp2
+      
+            if (drp) {
+              // Here we erase the index files
+              ddp->DeleteIndexFile(g, drp);
+              } // endif xp1
+      
+          } else if (oldpix) {
+            // TODO: optimize the case of just adding new indexes
+            if (!newpix)
+              ddp->DeleteIndexFile(g, NULL);
+      
+            oldpix= NULL;     // To remake all indexes
+            ddp->SetIndx(NULL);
+          } // endif sepindex
+      
+          // Make the list of new created indexes
+          xlst= &adp; xprc= &newpix;
+      
+          for (xp1= newpix; xp1; xp1= xp) {
+            for (xp2= oldpix; xp2; xp2= xp2->Next)
+              if (IsSameIndex(xp1, xp2))
+                break;        // Index already made
+      
+            xp= xp1->Next;
+      
+            if (!xp2) {
+              *xlst= xp1;
+              *xprc= xp;
+              *(xlst= &xp1->Next)= NULL;
+            } else
+              xprc= &xp1->Next;
+      
+            } // endfor xp1
+      
+          if (adp)
+            // Here we do make the new indexes
+            if (tdp->MakeIndex(g, adp, true) == RC_FX) {
+              // Make it a warning to avoid crash
+              push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 
+                                0, g->Message);
+              rc= 0;
+              } // endif MakeIndex
+      
+        } // endif indexable
 
         } // endif Tdbp
 
@@ -5276,7 +5376,7 @@ int ha_connect::create(const char *name, TABLE *table_arg,
         sprintf(g->Message, "Table type %s is not indexable", options->type);
         my_message(ER_UNKNOWN_ERROR, g->Message, MYF(0));
         rc= HA_ERR_UNSUPPORTED;
-      } // endif Indexable
+      } // endif index type
 
       } // endif xdp
 
@@ -5285,62 +5385,6 @@ int ha_connect::create(const char *name, TABLE *table_arg,
     my_message(ER_UNKNOWN_ERROR,
                "CONNECT index modification should be in-place", MYF(0));
     DBUG_RETURN(HA_ERR_UNSUPPORTED);
-#if 0
-    PIXDEF xdp= GetIndexInfo();
-    PCHK   xcp= (PCHK)g->Xchk;
-
-    if (xdp) {
-      if (!IsTypeIndexable(type)) {
-        g->Xchk= NULL;
-        sprintf(g->Message, "Table type %s is not indexable", options->type);
-        my_message(ER_UNKNOWN_ERROR, g->Message, MYF(0));
-        rc= HA_ERR_INTERNAL_ERROR;
-      } else {
-        xcp->newpix= xdp;
-        xcp->newsep= GetBooleanOption("Sepindex", false);
-      } // endif Indexable
-
-    } else if (!xcp->oldpix)
-      g->Xchk= NULL;
-
-    if (xtrace && g->Xchk)
-      htrc("oldsep=%d newsep=%d oldpix=%p newpix=%p\n",
-              xcp->oldsep, xcp->newsep, xcp->oldpix, xcp->newpix);
-
-//  if (g->Xchk &&
-//      (sqlcom != SQLCOM_CREATE_INDEX && sqlcom != SQLCOM_DROP_INDEX)) {
-    if (g->Xchk) {
-      PIXDEF xp1, xp2;
-      bool   b= false;        // true if index changes
-
-      if (xcp->oldsep == xcp->newsep) {
-        for (xp1= xcp->newpix, xp2= xcp->oldpix;
-             xp1 || xp2;
-             xp1= xp1->Next, xp2= xp2->Next)
-          if (!xp1 || !xp2 || !IsSameIndex(xp1, xp2)) {
-            b= true;
-            break;
-            } // endif xp1
-
-      } else
-        b= true;
-
-      if (!b)
-        g->Xchk= NULL;
-
-#if 0
-      if (b) {
-        // CONNECT does not support indexing via ALTER TABLE
-        my_message(ER_UNKNOWN_ERROR,
-           "CONNECT does not support index modification via ALTER TABLE",
-           MYF(0));
-        DBUG_RETURN(HA_ERR_UNSUPPORTED);
-        } // endif b
-#endif // 0
-
-      } // endif Xchk
-
-#endif // 0
   } // endif Xchk
 
   table= st;
diff --git a/storage/connect/ha_connect.h b/storage/connect/ha_connect.h
index fac7560ddd6..6320d711f9f 100644
--- a/storage/connect/ha_connect.h
+++ b/storage/connect/ha_connect.h
@@ -213,6 +213,8 @@ public:
   int      CheckRecord(PGLOBAL g, const uchar *oldbuf, uchar *newbuf);
   int      ReadIndexed(uchar *buf, OPVAL op, const uchar* key= NULL,
                                              uint key_len= 0);
+  bool     MakeKeyWhere(PGLOBAL g, char *qry, OPVAL op, char *q,
+                                   const void *key, int klen);
 
   /** @brief
     The name that will be used for display purposes.
diff --git a/storage/connect/mycat.cc b/storage/connect/mycat.cc
index 7a6f317526a..10b12c0809b 100644
--- a/storage/connect/mycat.cc
+++ b/storage/connect/mycat.cc
@@ -275,9 +275,10 @@ int GetIndexType(TABTYPE type)
       xtyp= 1;
       break;
     case TAB_MYSQL:
+//  case TAB_ODBC:
+      xtyp= 2;
+      break;
     case TAB_ODBC:
-//      xtyp= 2;     Remote indexes not implemented yet
-//      break;
     default:
       xtyp= 0;
       break;
diff --git a/storage/connect/plgdbsem.h b/storage/connect/plgdbsem.h
index 0075b8ae5cc..d37b275ebed 100644
--- a/storage/connect/plgdbsem.h
+++ b/storage/connect/plgdbsem.h
@@ -160,6 +160,7 @@ enum ALGMOD {AMOD_AUTO =  0,          /* PLG chooses best algorithm    */
 enum MODE {MODE_ERROR   = -1,         /* Invalid mode                  */
            MODE_ANY     =  0,         /* Unspecified mode              */
            MODE_READ    = 10,         /* Input/Output mode             */
+           MODE_READX   = 11,         /* Read indexed mode             */
            MODE_WRITE   = 20,         /* Input/Output mode             */
            MODE_UPDATE  = 30,         /* Input/Output mode             */
            MODE_INSERT  = 40,         /* Input/Output mode             */
diff --git a/storage/connect/reldef.h b/storage/connect/reldef.h
index f9f49787d75..ed4a7d9dcac 100644
--- a/storage/connect/reldef.h
+++ b/storage/connect/reldef.h
@@ -31,6 +31,7 @@ class DllExport RELDEF : public BLOCK {      // Relation definition block
   PSZ     GetName(void) {return Name;}
   PSZ     GetDB(void) {return (PSZ)Database;}
   PCOLDEF GetCols(void) {return To_Cols;}
+  PHC     GetHandler(void) {return Hc;}
   void    SetCols(PCOLDEF pcd) {To_Cols = pcd;}
   PCATLG  GetCat(void) {return Cat;}
   virtual const char *GetType(void) = 0;
@@ -45,7 +46,7 @@ class DllExport RELDEF : public BLOCK {      // Relation definition block
   int     GetSizeCatInfo(PSZ what, PSZ sdef);
   int     GetCharCatInfo(PSZ what, PSZ sdef, char *buf, int size);
   char   *GetStringCatInfo(PGLOBAL g, PSZ what, PSZ sdef);
-  virtual bool Indexable(void) {return false;}
+  virtual int  Indexable(void) {return 0;}
   virtual bool Define(PGLOBAL g, PCATLG cat, LPCSTR name, LPCSTR am) = 0;
   virtual PTDB GetTable(PGLOBAL g, MODE mode) = 0;
 
diff --git a/storage/connect/tabdos.h b/storage/connect/tabdos.h
index a175cc32ec9..17220a52962 100644
--- a/storage/connect/tabdos.h
+++ b/storage/connect/tabdos.h
@@ -1,253 +1,253 @@
-/*************** TabDos H Declares Source Code File (.H) ***************/
-/*  Name: TABDOS.H    Version 3.3                                      */
-/*                                                                     */
-/*  (C) Copyright to the author Olivier BERTRAND          1999-2014    */
-/*                                                                     */
-/*  This file contains the DOS classes declares.                       */
-/***********************************************************************/
-
-#ifndef __TABDOS_H
-#define __TABDOS_H
-
-#include "xtable.h"                       // Table  base class declares
-#include "colblk.h"                       // Column base class declares
-#include "xindex.h"
-#include "filter.h"
-
-//pedef struct _tabdesc   *PTABD;         // For friend setting
-typedef class TXTFAM      *PTXF;
-typedef class BLOCKFILTER *PBF;
-typedef class BLOCKINDEX  *PBX;
-
-/***********************************************************************/
-/*  DOS table.                                                         */
-/***********************************************************************/
-class DllExport DOSDEF : public TABDEF {  /* Logical table description */
-  friend class OEMDEF;
-  friend class TDBDOS;
-  friend class TDBFIX;
-  friend class TXTFAM;
-  friend class DBFBASE;
- public:
-  // Constructor
-  DOSDEF(void);
-
-  // Implementation
-  virtual AMT         GetDefType(void) {return TYPE_AM_DOS;}
-  virtual const char *GetType(void) {return "DOS";}
-  virtual PIXDEF      GetIndx(void) {return To_Indx;}
-  virtual void        SetIndx(PIXDEF xdp) {To_Indx = xdp;}
-  virtual bool        IsHuge(void) {return Huge;}
-  PSZ     GetFn(void) {return Fn;}
-  PSZ     GetOfn(void) {return Ofn;}
-  void    SetBlock(int block) {Block = block;}
-  int     GetBlock(void) {return Block;}
-  int     GetLast(void) {return Last;}
-  void    SetLast(int last) {Last = last;}
-  int     GetLrecl(void) {return Lrecl;}
-  void    SetLrecl(int lrecl) {Lrecl = lrecl;}
-  bool    GetPadded(void) {return Padded;}
-  bool    GetEof(void) {return Eof;}
-  int     GetBlksize(void) {return Blksize;}
-  int     GetEnding(void) {return Ending;}
-  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;}
-
-  // Methods
-  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);
-          bool GetOptFileName(PGLOBAL g, char *filename);
-          void RemoveOptValues(PGLOBAL g);
-
- protected:
-//virtual bool Erase(char *filename);
-
-  // Members
-  PSZ     Fn;                 /* Path/Name of corresponding file       */
-  PSZ     Ofn;                /* Base Path/Name of matching index files*/
-  PIXDEF  To_Indx;            /* To index definitions blocks           */
-  RECFM   Recfm;              /* 0:VAR, 1:FIX, 2:BIN, 3:VCT, 6:DBF     */
-  bool    Mapped;             /* 0: disk file, 1: memory mapped file   */
-  bool    Padded;             /* true for padded table file            */
-  bool    Huge;               /* true for files larger than 2GB        */
-  bool    Accept;             /* true if wrong lines are accepted (DBF)*/
-  bool    Eof;                /* true if an EOF (0xA) character exists */
-  int    *To_Pos;             /* To array of block starting positions  */
-  int     Optimized;          /* 0: No, 1:Yes, 2:Redo optimization     */
-  int     AllocBlks;          /* Number of suballocated opt blocks     */
-  int     Compressed;         /* 0: No, 1: gz, 2:zlib compressed file  */
-  int     Lrecl;              /* Size of biggest record                */
-  int     AvgLen;             /* Average size of records               */
-  int     Block;              /* Number de blocks of FIX/VCT tables    */
-  int     Last;               /* Number of elements of last block      */
-  int     Blksize;            /* Size of padded blocks                 */
-  int     Maxerr;             /* Maximum number of bad records (DBF)   */
-  int     ReadMode;           /* Specific to DBF                       */
-  int     Ending;             /* Length of end of lines                */
-  }; // end of DOSDEF
-
-/***********************************************************************/
-/*  This is the DOS/UNIX Access Method class declaration for files     */
-/*  that are standard files with columns starting at fixed offset.     */
-/*  The last column (and record) is of variable length.                */
-/***********************************************************************/
-class DllExport TDBDOS : public TDBASE {
-  friend class XINDEX;
-  friend class DOSCOL;
-  friend class MAPCOL;
-  friend class TXTFAM;
-  friend class DOSFAM;
-  friend class VCTCOL;
-  friend RCODE CntDeleteRow(PGLOBAL, PTDB, bool);
- public:
-  // Constructors
-  TDBDOS(PDOSDEF tdp, PTXF txfp);
-  TDBDOS(PGLOBAL g, PTDBDOS tdbp);
-
-  // Inline functions
-  inline  void  SetTxfp(PTXF txfp) {Txfp = txfp; Txfp->SetTdbp(this);}
-  inline  PTXF  GetTxfp(void) {return Txfp;}
-  inline  char *GetLine(void) {return To_Line;}
-  inline  int   GetCurBlk(void) {return Txfp->GetCurBlk();}
-  inline  void  SetLine(char *toline) {To_Line = toline;}
-  inline  void  IncLine(int inc) {To_Line += inc;}
-  inline  bool  IsRead(void) {return Txfp->IsRead;}
-  inline  PXOB *GetLink(void) {return To_Link;}
-
-  // Implementation
-  virtual AMT   GetAmType(void) {return Txfp->GetAmType();}
-  virtual PSZ   GetFile(PGLOBAL g) {return Txfp->To_File;}
-  virtual void  SetFile(PGLOBAL g, PSZ fn) {Txfp->To_File = fn;}
-  virtual RECFM GetFtype(void) {return Ftype;}
-  virtual bool  SkipHeader(PGLOBAL g) {return false;}
-  virtual void  RestoreNrec(void) {Txfp->SetNrec(1);}
-  virtual PTDB  Duplicate(PGLOBAL g)
-                {return (PTDB)new(g) TDBDOS(g, this);}
-
-  // Methods
-  virtual PTDB  CopyOne(PTABS t);
-  virtual void  ResetDB(void) {Txfp->Reset();}
-  virtual bool  IsUsingTemp(PGLOBAL g);
-  virtual void  ResetSize(void) {MaxSize = Cardinal = -1;}
-  virtual int   ResetTableOpt(PGLOBAL g, bool dop, bool dox);
-  virtual int   MakeBlockValues(PGLOBAL g);
-  virtual bool  SaveBlockValues(PGLOBAL g);
-  virtual bool  GetBlockValues(PGLOBAL g);
-  virtual PBF   InitBlockFilter(PGLOBAL g, PFIL filp);
-//virtual PBX   InitBlockIndex(PGLOBAL g);
-  virtual int   TestBlock(PGLOBAL g);
-  virtual void  PrintAM(FILE *f, char *m);
-
-  // Database routines
-  virtual PCOL  MakeCol(PGLOBAL g, PCOLDEF cdp, PCOL cprec, int n);
-  virtual char *GetOpenMode(PGLOBAL g, char *opmode) {return NULL;}
-  virtual int   GetFileLength(PGLOBAL g) {return Txfp->GetFileLength(g);}
-  virtual int   GetProgMax(PGLOBAL g);
-  virtual int   GetProgCur(void);
-  virtual int   GetAffectedRows(void) {return Txfp->GetDelRows();}
-  virtual int   GetRecpos(void) {return Txfp->GetPos();}
-  virtual bool  SetRecpos(PGLOBAL g, int recpos)
-                {return Txfp->SetPos(g, recpos);}
-  virtual int   RowNumber(PGLOBAL g, bool b = false);
-  virtual int   Cardinality(PGLOBAL g);
-  virtual int   GetMaxSize(PGLOBAL g);
-  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);
-  virtual int   ReadBuffer(PGLOBAL g) {return Txfp->ReadBuffer(g);}
-
-  // Specific routine
-  virtual int  EstimatedLength(PGLOBAL g);
-
-  // Optimization routines
-          int   MakeIndex(PGLOBAL g, PIXDEF pxdf, bool add);
-          void  ResetBlockFilter(PGLOBAL g);
-          bool  GetDistinctColumnValues(PGLOBAL g, int nrec);
-
- protected:
-          PBF    CheckBlockFilari(PGLOBAL g, PXOB *arg, int op, bool *cnv);
-
-  // Members
-  PTXF    Txfp;              // To the File access method class
-//PBX     To_BlkIdx;         // To index test block
-  PBF     To_BlkFil;         // To evaluation block filter
-  PFIL    SavFil;            // Saved hidden filter
-  char   *To_Line;           // Points to current processed line
-  int     Cardinal;           // Table Cardinality
-  RECFM   Ftype;             // File type: 0-var 1-fixed 2-binary (VCT)
-  int     Lrecl;             // Logical Record Length
-  int     AvgLen;            // Logical Record Average Length
-//int     Xeval;             // BlockTest return value
-  int     Beval;             // BlockEval return value
-  }; // end of class TDBDOS
-
-/***********************************************************************/
-/*  Class DOSCOL: DOS access method column descriptor.                 */
-/*  This A.M. is used for text file tables under operating systems     */
-/*  DOS, OS2, UNIX, WIN16 and WIN32.                                   */
-/***********************************************************************/
-class DllExport DOSCOL : public COLBLK {
-  friend class TDBDOS;
-  friend class TDBFIX;
- public:
-  // Constructors
-  DOSCOL(PGLOBAL g, PCOLDEF cdp, PTDB tp, PCOL cp, int i, PSZ am = "DOS");
-  DOSCOL(DOSCOL *colp, PTDB tdbp); // Constructor used in copy process
-
-  // Implementation
-  virtual int    GetAmType(void) {return TYPE_AM_DOS;}
-  virtual void   SetTo_Val(PVAL valp) {To_Val = valp;}
-  virtual int    GetClustered(void) {return Clustered;}
-  virtual int    IsClustered(void) {return (Clustered &&
-                 ((PDOSDEF)(((PTDBDOS)To_Tdb)->To_Def))->IsOptimized());}
-  virtual int    IsSorted(void) {return Sorted;}
-  virtual PVBLK  GetMin(void) {return Min;}
-  virtual PVBLK  GetMax(void) {return Max;}
-  virtual int    GetNdv(void) {return Ndv;}
-  virtual int    GetNbm(void) {return Nbm;}
-  virtual PVBLK  GetBmap(void) {return Bmap;}
-  virtual PVBLK  GetDval(void) {return Dval;}
-
-  // Methods
-  virtual bool   VarSize(void);
-  virtual bool   SetBuffer(PGLOBAL g, PVAL value, bool ok, bool check);
-  virtual void   ReadColumn(PGLOBAL g);
-  virtual void   WriteColumn(PGLOBAL g);
-  virtual void   Print(PGLOBAL g, FILE *, uint);
-
- protected:
-  virtual bool   SetMinMax(PGLOBAL g);
-  virtual bool   SetBitMap(PGLOBAL g);
-          bool   CheckSorted(PGLOBAL g);
-          bool   AddDistinctValue(PGLOBAL g);
-
-  // Default constructor not to be used
-  DOSCOL(void) {}
-
-  // Members
-  PVBLK Min;          // Array of block min values
-  PVBLK Max;          // Array of block max values
-  PVBLK Bmap;         // Array of block bitmap values
-  PVBLK Dval;         // Array of column distinct values
-  PVAL  To_Val;       // To value used for Update/Insert
-  PVAL  OldVal;       // The previous value of the object.
-  char *Buf;          // Buffer used in write operations
-  bool  Ldz;          // True if field contains leading zeros
-  bool  Nod;          // True if no decimal point
-  int   Dcm;          // Last Dcm digits are decimals
-  int   Deplac;       // Offset in dos_buf
-  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
-  }; // end of class DOSCOL
-
-#endif // __TABDOS_H
+/*************** TabDos H Declares Source Code File (.H) ***************/
+/*  Name: TABDOS.H    Version 3.3                                      */
+/*                                                                     */
+/*  (C) Copyright to the author Olivier BERTRAND          1999-2014    */
+/*                                                                     */
+/*  This file contains the DOS classes declares.                       */
+/***********************************************************************/
+
+#ifndef __TABDOS_H
+#define __TABDOS_H
+
+#include "xtable.h"                       // Table  base class declares
+#include "colblk.h"                       // Column base class declares
+#include "xindex.h"
+#include "filter.h"
+
+//pedef struct _tabdesc   *PTABD;         // For friend setting
+typedef class TXTFAM      *PTXF;
+typedef class BLOCKFILTER *PBF;
+typedef class BLOCKINDEX  *PBX;
+
+/***********************************************************************/
+/*  DOS table.                                                         */
+/***********************************************************************/
+class DllExport DOSDEF : public TABDEF {  /* Logical table description */
+  friend class OEMDEF;
+  friend class TDBDOS;
+  friend class TDBFIX;
+  friend class TXTFAM;
+  friend class DBFBASE;
+ public:
+  // Constructor
+  DOSDEF(void);
+
+  // Implementation
+  virtual AMT         GetDefType(void) {return TYPE_AM_DOS;}
+  virtual const char *GetType(void) {return "DOS";}
+  virtual PIXDEF      GetIndx(void) {return To_Indx;}
+  virtual void        SetIndx(PIXDEF xdp) {To_Indx = xdp;}
+  virtual bool        IsHuge(void) {return Huge;}
+  PSZ     GetFn(void) {return Fn;}
+  PSZ     GetOfn(void) {return Ofn;}
+  void    SetBlock(int block) {Block = block;}
+  int     GetBlock(void) {return Block;}
+  int     GetLast(void) {return Last;}
+  void    SetLast(int last) {Last = last;}
+  int     GetLrecl(void) {return Lrecl;}
+  void    SetLrecl(int lrecl) {Lrecl = lrecl;}
+  bool    GetPadded(void) {return Padded;}
+  bool    GetEof(void) {return Eof;}
+  int     GetBlksize(void) {return Blksize;}
+  int     GetEnding(void) {return Ending;}
+  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;}
+
+  // Methods
+  virtual int  Indexable(void) {return (Compressed != 1) ? 1 : 0;}
+  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);
+          bool GetOptFileName(PGLOBAL g, char *filename);
+          void RemoveOptValues(PGLOBAL g);
+
+ protected:
+//virtual bool Erase(char *filename);
+
+  // Members
+  PSZ     Fn;                 /* Path/Name of corresponding file       */
+  PSZ     Ofn;                /* Base Path/Name of matching index files*/
+  PIXDEF  To_Indx;            /* To index definitions blocks           */
+  RECFM   Recfm;              /* 0:VAR, 1:FIX, 2:BIN, 3:VCT, 6:DBF     */
+  bool    Mapped;             /* 0: disk file, 1: memory mapped file   */
+  bool    Padded;             /* true for padded table file            */
+  bool    Huge;               /* true for files larger than 2GB        */
+  bool    Accept;             /* true if wrong lines are accepted (DBF)*/
+  bool    Eof;                /* true if an EOF (0xA) character exists */
+  int    *To_Pos;             /* To array of block starting positions  */
+  int     Optimized;          /* 0: No, 1:Yes, 2:Redo optimization     */
+  int     AllocBlks;          /* Number of suballocated opt blocks     */
+  int     Compressed;         /* 0: No, 1: gz, 2:zlib compressed file  */
+  int     Lrecl;              /* Size of biggest record                */
+  int     AvgLen;             /* Average size of records               */
+  int     Block;              /* Number de blocks of FIX/VCT tables    */
+  int     Last;               /* Number of elements of last block      */
+  int     Blksize;            /* Size of padded blocks                 */
+  int     Maxerr;             /* Maximum number of bad records (DBF)   */
+  int     ReadMode;           /* Specific to DBF                       */
+  int     Ending;             /* Length of end of lines                */
+  }; // end of DOSDEF
+
+/***********************************************************************/
+/*  This is the DOS/UNIX Access Method class declaration for files     */
+/*  that are standard files with columns starting at fixed offset.     */
+/*  The last column (and record) is of variable length.                */
+/***********************************************************************/
+class DllExport TDBDOS : public TDBASE {
+  friend class XINDEX;
+  friend class DOSCOL;
+  friend class MAPCOL;
+  friend class TXTFAM;
+  friend class DOSFAM;
+  friend class VCTCOL;
+  friend RCODE CntDeleteRow(PGLOBAL, PTDB, bool);
+ public:
+  // Constructors
+  TDBDOS(PDOSDEF tdp, PTXF txfp);
+  TDBDOS(PGLOBAL g, PTDBDOS tdbp);
+
+  // Inline functions
+  inline  void  SetTxfp(PTXF txfp) {Txfp = txfp; Txfp->SetTdbp(this);}
+  inline  PTXF  GetTxfp(void) {return Txfp;}
+  inline  char *GetLine(void) {return To_Line;}
+  inline  int   GetCurBlk(void) {return Txfp->GetCurBlk();}
+  inline  void  SetLine(char *toline) {To_Line = toline;}
+  inline  void  IncLine(int inc) {To_Line += inc;}
+  inline  bool  IsRead(void) {return Txfp->IsRead;}
+  inline  PXOB *GetLink(void) {return To_Link;}
+
+  // Implementation
+  virtual AMT   GetAmType(void) {return Txfp->GetAmType();}
+  virtual PSZ   GetFile(PGLOBAL g) {return Txfp->To_File;}
+  virtual void  SetFile(PGLOBAL g, PSZ fn) {Txfp->To_File = fn;}
+  virtual RECFM GetFtype(void) {return Ftype;}
+  virtual bool  SkipHeader(PGLOBAL g) {return false;}
+  virtual void  RestoreNrec(void) {Txfp->SetNrec(1);}
+  virtual PTDB  Duplicate(PGLOBAL g)
+                {return (PTDB)new(g) TDBDOS(g, this);}
+
+  // Methods
+  virtual PTDB  CopyOne(PTABS t);
+  virtual void  ResetDB(void) {Txfp->Reset();}
+  virtual bool  IsUsingTemp(PGLOBAL g);
+  virtual void  ResetSize(void) {MaxSize = Cardinal = -1;}
+  virtual int   ResetTableOpt(PGLOBAL g, bool dop, bool dox);
+  virtual int   MakeBlockValues(PGLOBAL g);
+  virtual bool  SaveBlockValues(PGLOBAL g);
+  virtual bool  GetBlockValues(PGLOBAL g);
+  virtual PBF   InitBlockFilter(PGLOBAL g, PFIL filp);
+//virtual PBX   InitBlockIndex(PGLOBAL g);
+  virtual int   TestBlock(PGLOBAL g);
+  virtual void  PrintAM(FILE *f, char *m);
+
+  // Database routines
+  virtual PCOL  MakeCol(PGLOBAL g, PCOLDEF cdp, PCOL cprec, int n);
+  virtual char *GetOpenMode(PGLOBAL g, char *opmode) {return NULL;}
+  virtual int   GetFileLength(PGLOBAL g) {return Txfp->GetFileLength(g);}
+  virtual int   GetProgMax(PGLOBAL g);
+  virtual int   GetProgCur(void);
+  virtual int   GetAffectedRows(void) {return Txfp->GetDelRows();}
+  virtual int   GetRecpos(void) {return Txfp->GetPos();}
+  virtual bool  SetRecpos(PGLOBAL g, int recpos)
+                {return Txfp->SetPos(g, recpos);}
+  virtual int   RowNumber(PGLOBAL g, bool b = false);
+  virtual int   Cardinality(PGLOBAL g);
+  virtual int   GetMaxSize(PGLOBAL g);
+  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);
+  virtual int   ReadBuffer(PGLOBAL g) {return Txfp->ReadBuffer(g);}
+
+  // Specific routine
+  virtual int   EstimatedLength(PGLOBAL g);
+
+  // Optimization routines
+  virtual int   MakeIndex(PGLOBAL g, PIXDEF pxdf, bool add);
+          void  ResetBlockFilter(PGLOBAL g);
+          bool  GetDistinctColumnValues(PGLOBAL g, int nrec);
+
+ protected:
+          PBF   CheckBlockFilari(PGLOBAL g, PXOB *arg, int op, bool *cnv);
+
+  // Members
+  PTXF    Txfp;              // To the File access method class
+//PBX     To_BlkIdx;         // To index test block
+  PBF     To_BlkFil;         // To evaluation block filter
+  PFIL    SavFil;            // Saved hidden filter
+  char   *To_Line;           // Points to current processed line
+  int     Cardinal;          // Table Cardinality
+  RECFM   Ftype;             // File type: 0-var 1-fixed 2-binary (VCT)
+  int     Lrecl;             // Logical Record Length
+  int     AvgLen;            // Logical Record Average Length
+//int     Xeval;             // BlockTest return value
+  int     Beval;             // BlockEval return value
+  }; // end of class TDBDOS
+
+/***********************************************************************/
+/*  Class DOSCOL: DOS access method column descriptor.                 */
+/*  This A.M. is used for text file tables under operating systems     */
+/*  DOS, OS2, UNIX, WIN16 and WIN32.                                   */
+/***********************************************************************/
+class DllExport DOSCOL : public COLBLK {
+  friend class TDBDOS;
+  friend class TDBFIX;
+ public:
+  // Constructors
+  DOSCOL(PGLOBAL g, PCOLDEF cdp, PTDB tp, PCOL cp, int i, PSZ am = "DOS");
+  DOSCOL(DOSCOL *colp, PTDB tdbp); // Constructor used in copy process
+
+  // Implementation
+  virtual int    GetAmType(void) {return TYPE_AM_DOS;}
+  virtual void   SetTo_Val(PVAL valp) {To_Val = valp;}
+  virtual int    GetClustered(void) {return Clustered;}
+  virtual int    IsClustered(void) {return (Clustered &&
+                 ((PDOSDEF)(((PTDBDOS)To_Tdb)->To_Def))->IsOptimized());}
+  virtual int    IsSorted(void) {return Sorted;}
+  virtual PVBLK  GetMin(void) {return Min;}
+  virtual PVBLK  GetMax(void) {return Max;}
+  virtual int    GetNdv(void) {return Ndv;}
+  virtual int    GetNbm(void) {return Nbm;}
+  virtual PVBLK  GetBmap(void) {return Bmap;}
+  virtual PVBLK  GetDval(void) {return Dval;}
+
+  // Methods
+  virtual bool   VarSize(void);
+  virtual bool   SetBuffer(PGLOBAL g, PVAL value, bool ok, bool check);
+  virtual void   ReadColumn(PGLOBAL g);
+  virtual void   WriteColumn(PGLOBAL g);
+  virtual void   Print(PGLOBAL g, FILE *, uint);
+
+ protected:
+  virtual bool   SetMinMax(PGLOBAL g);
+  virtual bool   SetBitMap(PGLOBAL g);
+          bool   CheckSorted(PGLOBAL g);
+          bool   AddDistinctValue(PGLOBAL g);
+
+  // Default constructor not to be used
+  DOSCOL(void) {}
+
+  // Members
+  PVBLK Min;          // Array of block min values
+  PVBLK Max;          // Array of block max values
+  PVBLK Bmap;         // Array of block bitmap values
+  PVBLK Dval;         // Array of column distinct values
+  PVAL  To_Val;       // To value used for Update/Insert
+  PVAL  OldVal;       // The previous value of the object.
+  char *Buf;          // Buffer used in write operations
+  bool  Ldz;          // True if field contains leading zeros
+  bool  Nod;          // True if no decimal point
+  int   Dcm;          // Last Dcm digits are decimals
+  int   Deplac;       // Offset in dos_buf
+  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
+  }; // end of class DOSCOL
+
+#endif // __TABDOS_H
diff --git a/storage/connect/tabmysql.cpp b/storage/connect/tabmysql.cpp
index 56df9edc980..d122b1c3c2d 100644
--- a/storage/connect/tabmysql.cpp
+++ b/storage/connect/tabmysql.cpp
@@ -61,6 +61,7 @@
 #include "tabmysql.h"
 #include "valblk.h"
 #include "tabutil.h"
+#include "ha_connect.h"
 
 #if defined(_CONSOLE)
 void PrintResult(PGLOBAL, PSEM, PQRYRES);
@@ -481,16 +482,16 @@ PCOL TDBMYSQL::MakeCol(PGLOBAL g, PCOLDEF cdp, PCOL cprec, int n)
 /*  Note: when implementing EOM filtering, column only used in local   */
 /*  filter should be removed from column list.                         */
 /***********************************************************************/
-bool TDBMYSQL::MakeSelect(PGLOBAL g)
+bool TDBMYSQL::MakeSelect(PGLOBAL g, bool mx)
   {
   char   *tk = "`";
-  int     rank = 0;
-  bool    b = FALSE;
+  int     len = 0, rank = 0;
+  bool    b = false;
   PCOL    colp;
 //PDBUSER dup = PlgGetUser(g);
 
   if (Query)
-    return FALSE;        // already done
+    return false;        // already done
 
   if (Srcdef) {
     Query = Srcdef;
@@ -506,12 +507,12 @@ bool TDBMYSQL::MakeSelect(PGLOBAL g)
       if (!colp->IsSpecial()) {
 //      if (colp->IsSpecial()) {
 //        strcpy(g->Message, MSG(NO_SPEC_COL));
-//        return TRUE;
+//        return true;
 //      } else {
         if (b)
           strcat(Query, ", ");
         else
-          b = TRUE;
+          b = true;
 
         strcat(strcat(strcat(Query, tk), colp->GetName()), tk);
         ((PMYCOL)colp)->Rank = rank++;
@@ -526,16 +527,24 @@ bool TDBMYSQL::MakeSelect(PGLOBAL g)
   } // endif ncol
 
   strcat(strcat(strcat(strcat(Query, " FROM "), tk), Tabname), tk);
+  len = strlen(Query);
 
-  if (To_CondFil)
-    strcat(strcat(Query, " WHERE "), To_CondFil->Body);
+  if (To_CondFil) {
+    if (!mx) {
+      strcat(strcat(Query, " WHERE "), To_CondFil->Body);
+      len = strlen(Query) + 1;
+    } else
+      len += (strlen(To_CondFil->Body) + 256);
+
+  } else
+    len += (mx ? 256 : 1);
 
   if (trace)
     htrc("Query=%s\n", Query);
 
   // Now we know how much to suballocate
-  PlugSubAlloc(g, NULL, strlen(Query) + 1);
-  return FALSE;
+  PlugSubAlloc(g, NULL, len);
+  return false;
   } // end of MakeSelect
 
 /***********************************************************************/
@@ -833,9 +842,9 @@ bool TDBMYSQL::OpenDB(PGLOBAL g)
   /*********************************************************************/
   /*  Allocate whatever is used for getting results.                   */
   /*********************************************************************/
-  if (Mode == MODE_READ) {
-    if (!MakeSelect(g))
-      m_Rc = Myc.ExecSQL(g, Query);
+  if (Mode == MODE_READ || Mode == MODE_READX) {
+    MakeSelect(g, Mode == MODE_READX);
+    m_Rc = (Mode == MODE_READ) ? Myc.ExecSQL(g, Query) : RC_OK;
 
 #if 0
     if (!Myc.m_Res || !Myc.m_Fields) {
@@ -994,6 +1003,36 @@ int TDBMYSQL::SendCommand(PGLOBAL g)
 
   } // end of SendCommand
 
+/***********************************************************************/
+/*  Data Base indexed read routine for MYSQL access method.            */
+/***********************************************************************/
+bool TDBMYSQL::ReadKey(PGLOBAL g, OPVAL op, const void *key, int len)
+{
+  int  oldlen = strlen(Query);
+  bool rc;
+
+  if (op == OP_NEXT)
+    return false;
+  else if (op == OP_FIRST) {
+    if (To_CondFil)
+      strcat(strcat(Query, " WHERE "), To_CondFil->Body);
+
+  } else {
+    if (Myc.m_Res)
+      Myc.FreeResult();
+
+    rc = To_Def->GetHandler()->MakeKeyWhere(g, Query, op, "`", key, len);
+
+    if (To_CondFil)
+      strcat(strcat(strcat(Query, " AND ("), To_CondFil->Body), ")");
+
+  } // endif's op
+
+  m_Rc = Myc.ExecSQL(g, Query);
+  Query[oldlen] = 0;
+  return false;
+} // end of ReadKey
+
 /***********************************************************************/
 /*  Data Base read routine for MYSQL access method.                    */
 /***********************************************************************/
@@ -1452,7 +1491,7 @@ bool TDBMYEXC::OpenDB(PGLOBAL g)
 
   Use = USE_OPEN;       // Do it now in case we are recursively called
 
-  if (Mode != MODE_READ) {
+  if (Mode != MODE_READ && Mode != MODE_READX) {
     strcpy(g->Message, "No INSERT/DELETE/UPDATE of MYSQL EXEC tables");
     return true;
     } // endif Mode
diff --git a/storage/connect/tabmysql.h b/storage/connect/tabmysql.h
index 2ecfe800f88..0387fcc7da9 100644
--- a/storage/connect/tabmysql.h
+++ b/storage/connect/tabmysql.h
@@ -39,6 +39,7 @@ class MYSQLDEF : public TABDEF           {/* Logical table description */
   inline  int  GetPortnumber(void) {return Portnumber;}
 
   // Methods
+  virtual int  Indexable(void) {return 2;}
   virtual bool DefineAM(PGLOBAL g, LPCSTR am, int poff);
   virtual PTDB GetTable(PGLOBAL g, MODE m);
           bool ParseURL(PGLOBAL g, char *url, bool b = true);
@@ -96,6 +97,7 @@ class TDBMYSQL : public TDBASE {
   virtual int  WriteDB(PGLOBAL g);
   virtual int  DeleteDB(PGLOBAL g, int irc);
   virtual void CloseDB(PGLOBAL g);
+  virtual bool ReadKey(PGLOBAL g, OPVAL op, const void *key, int len);
 
   // Specific routines
           bool SetColumnRanks(PGLOBAL g);
@@ -104,7 +106,7 @@ class TDBMYSQL : public TDBASE {
 
  protected:
   // Internal functions
-  bool MakeSelect(PGLOBAL g);
+  bool MakeSelect(PGLOBAL g, bool mx);
   bool MakeInsert(PGLOBAL g);
   int  BindColumns(PGLOBAL g);
   int  MakeCommand(PGLOBAL g);
diff --git a/storage/connect/tabodbc.cpp b/storage/connect/tabodbc.cpp
index 10ac1fda211..4231c5550e0 100644
--- a/storage/connect/tabodbc.cpp
+++ b/storage/connect/tabodbc.cpp
@@ -752,7 +752,7 @@ bool TDBODBC::OpenDB(PGLOBAL g)
   /*********************************************************************/
   /*  Make the command and allocate whatever is used for getting results.                   */
   /*********************************************************************/
-  if (Mode == MODE_READ) {
+  if (Mode == MODE_READ || Mode == MODE_READX) {
     if ((Query = MakeSQL(g, false))) {
       for (PODBCCOL colp = (PODBCCOL)Columns; colp;
                     colp = (PODBCCOL)colp->GetNext())
@@ -1315,7 +1315,7 @@ bool TDBXDBC::OpenDB(PGLOBAL g)
 
   Use = USE_OPEN;       // Do it now in case we are recursively called
 
-  if (Mode != MODE_READ) {
+  if (Mode != MODE_READ && Mode != MODE_READX) {
     strcpy(g->Message, "No INSERT/DELETE/UPDATE of XDBC tables");
     return true;
     } // endif Mode
diff --git a/storage/connect/tabodbc.h b/storage/connect/tabodbc.h
index 34c2bb8cfc7..5db8cbb8cff 100644
--- a/storage/connect/tabodbc.h
+++ b/storage/connect/tabodbc.h
@@ -90,6 +90,7 @@ class TDBODBC : public TDBASE {
   virtual void ResetSize(void);
   virtual int  GetAffectedRows(void) {return AftRows;}
   virtual PSZ  GetServer(void) {return "ODBC";}
+  virtual int  Indexable(void) {return 2;}
 
   // Database routines
   virtual PCOL MakeCol(PGLOBAL g, PCOLDEF cdp, PCOL cprec, int n);
@@ -100,6 +101,8 @@ class TDBODBC : public TDBASE {
   virtual int  WriteDB(PGLOBAL g);
   virtual int  DeleteDB(PGLOBAL g, int irc);
   virtual void CloseDB(PGLOBAL g);
+  virtual bool ReadKey(PGLOBAL g, OPVAL op, const void *key, int len)
+                      {return true;}
 
  protected:
   // Internal functions
diff --git a/storage/connect/xindex.cpp b/storage/connect/xindex.cpp
index a7576eab9cd..55e0a08b5c2 100755
--- a/storage/connect/xindex.cpp
+++ b/storage/connect/xindex.cpp
@@ -79,7 +79,7 @@ int PlgMakeIndex(PGLOBAL g, PSZ name, PIXDEF pxdf, bool add)
   {
   int     rc;
   PTABLE  tablep;
-  PTDBDOS tdbp;
+  PTDBASE tdbp;
   PCATLG  cat = PlgGetCatalog(g, true);
 
   /*********************************************************************/
@@ -87,13 +87,13 @@ int PlgMakeIndex(PGLOBAL g, PSZ name, PIXDEF pxdf, bool add)
   /*********************************************************************/
   tablep = new(g) XTAB(name);
 
-  if (!(tdbp = (PTDBDOS)cat->GetTable(g, tablep)))
+  if (!(tdbp = (PTDBASE)cat->GetTable(g, tablep)))
     rc = RC_NF;
   else if (!tdbp->GetDef()->Indexable()) {
     sprintf(g->Message, MSG(TABLE_NO_INDEX), name);
     rc = RC_NF;
   } else if ((rc = tdbp->MakeIndex(g, pxdf, add)) == RC_INFO)
-    rc = RC_OK;            // No index
+    rc = RC_OK;            // No or remote index
 
   return rc;
   } // end of PlgMakeIndex
diff --git a/storage/connect/xtable.h b/storage/connect/xtable.h
index 443f1e51a5b..daaa40f2224 100644
--- a/storage/connect/xtable.h
+++ b/storage/connect/xtable.h
@@ -1,259 +1,264 @@
-/**************** Table H Declares Source Code File (.H) ***************/
-/*  Name: TABLE.H    Version 2.3                                       */
-/*                                                                     */
-/*  (C) Copyright to the author Olivier BERTRAND          1999-2014    */
-/*                                                                     */
-/*  This file contains the TBX, OPJOIN and TDB class definitions.      */
-/***********************************************************************/
-#if !defined(TABLE_DEFINED)
-#define      TABLE_DEFINED
-
-
-/***********************************************************************/
-/*  Include required application header files                          */
-/*  block.h      is header containing Block    global declarations.    */
-/***********************************************************************/
-#include "assert.h"
-#include "block.h"
-#include "colblk.h"
-#include "m_ctype.h"
-
-typedef class CMD *PCMD;
-
-// Commands executed by XDBC and MYX tables
-class CMD : public BLOCK {
- public:
-  // Constructor
-  CMD(PGLOBAL g, char *cmd) {
-    Cmd = (char*)PlugSubAlloc(g, NULL, strlen(cmd) + 1);
-    strcpy(Cmd, cmd); Next = NULL; }
-
-  // Members
-  PCMD  Next;
-  char *Cmd;
-}; // end of class CMD
-
-// Condition filter structure
-typedef struct _cond_filter {
-  char  *Body;
-  OPVAL  Op;
-  PCMD   Cmds;
-} CONDFIL, *PCFIL;
-
-typedef class TDBCAT *PTDBCAT;
-typedef class CATCOL *PCATCOL;
-
-/***********************************************************************/
-/*  Definition of class TDB with all its method functions.             */
-/***********************************************************************/
-class DllExport TDB: public BLOCK {     // Table Descriptor Block.
- public:
-  // Constructors
-  TDB(PTABDEF tdp = NULL);
-  TDB(PTDB tdbp);
-
-  // Implementation
-  static  void   SetTnum(int n) {Tnum = n;}
-  inline  PTDB   GetOrig(void) {return To_Orig;}
-  inline  TUSE   GetUse(void) {return Use;}
-  inline  PCFIL  GetCondFil(void) {return To_CondFil;}
-  inline  LPCSTR GetName(void) {return Name;}
-  inline  PTABLE GetTable(void) {return To_Table;}
-  inline  PCOL   GetColumns(void) {return Columns;}
-  inline  int    GetDegree(void) {return Degree;}
-  inline  MODE   GetMode(void) {return Mode;}
-  inline  PFIL   GetFilter(void) {return To_Filter;}
-  inline  void   SetFilter(PFIL fp) {To_Filter = fp;}
-  inline  void   SetOrig(PTDB txp) {To_Orig = txp;}
-  inline  void   SetUse(TUSE n) {Use = n;}
-  inline  void   SetCondFil(PCFIL cfp) {To_CondFil = cfp;}
-  inline  void   SetNext(PTDB tdbp) {Next = tdbp;}
-  inline  void   SetName(LPCSTR name) {Name = name;}
-  inline  void   SetTable(PTABLE tablep) {To_Table = tablep;}
-  inline  void   SetColumns(PCOL colp) {Columns = colp;}
-  inline  void   SetDegree(int degree) {Degree = degree;}
-  inline  void   SetMode(MODE mode) {Mode = mode;}
-
-  //Properties
-  virtual AMT    GetAmType(void) {return TYPE_AM_ERROR;}
-  virtual int    GetTdb_No(void) {return Tdb_No;}
-  virtual PTDB   GetNext(void) {return Next;}
-  virtual PCATLG GetCat(void) {return NULL;}
-
-  // Methods
-  virtual bool   IsSame(PTDB tp) {return tp == this;}
-  virtual bool   GetBlockValues(PGLOBAL g) {return false;}
-  virtual int    Cardinality(PGLOBAL g) {return (g) ? -1 : 0;}
-  virtual int    GetMaxSize(PGLOBAL) = 0;
-  virtual int    GetProgMax(PGLOBAL) = 0;
-  virtual int    GetProgCur(void) = 0;
-  virtual int    RowNumber(PGLOBAL g, bool b = false);
-  virtual bool   IsReadOnly(void) {return true;}
-  virtual const CHARSET_INFO *data_charset() {return NULL;}
-  virtual PTDB   Duplicate(PGLOBAL g) {return NULL;}
-  virtual PTDB   CopyOne(PTABS t) {return this;}
-  virtual PTDB   Copy(PTABS t);
-  virtual void   PrintAM(FILE *f, char *m)
-                  {fprintf(f, "%s AM(%d)\n",  m, GetAmType());}
-  virtual void   Print(PGLOBAL g, FILE *f, uint n);
-  virtual void   Print(PGLOBAL g, char *ps, uint z);
-  virtual PSZ    GetServer(void) = 0;
-  virtual int    GetBadLines(void) {return 0;}
-
-  // Database pure virtual routines
-  virtual PCOL   ColDB(PGLOBAL g, PSZ name, int num) = 0;
-  virtual void   MarkDB(PGLOBAL, PTDB) = 0;
-  virtual bool   OpenDB(PGLOBAL) = 0;
-  virtual int    ReadDB(PGLOBAL) = 0;
-  virtual int    WriteDB(PGLOBAL) = 0;
-  virtual int    DeleteDB(PGLOBAL, int) = 0;
-  virtual void   CloseDB(PGLOBAL) = 0;
-  virtual int    CheckWrite(PGLOBAL g) {return 0;}
-
- protected:
-  // Members
-  PTDB   To_Orig;      // Pointer to original if it is a copy
-  TUSE   Use;
-  PFIL   To_Filter;
-  PCFIL  To_CondFil;   // To condition filter structure
-  static int Tnum;     // Used to generate Tdb_no's
-  const  int Tdb_No;   // GetTdb_No() is always 0 for OPJOIN
-  PTDB   Next;         // Next in linearized queries
-  PTABLE To_Table;     // Points to the XTAB object
-  LPCSTR Name;         // Table name
-  PCOL   Columns;      // Points to the first column of the table
-  MODE   Mode;         // 10 Read, 30 Update, 40 Insert, 50 Delete
-  int    Degree;       // Number of columns
-  }; // end of class TDB
-
-/***********************************************************************/
-/*  This is the base class for all query tables (except decode).       */
-/***********************************************************************/
-class DllExport TDBASE : public TDB {
-  friend class INDEXDEF;
-  friend class XINDEX;
-  friend class XINDXS;
- public:
-  // Constructor
-  TDBASE(PTABDEF tdp = NULL);
-  TDBASE(PTDBASE tdbp);
-
-  // Implementation
-  inline  int     GetKnum(void) {return Knum;}
-  inline  PTABDEF GetDef(void) {return To_Def;}
-  inline  PKXBASE GetKindex(void) {return To_Kindex;}
-  inline  PCOL    GetSetCols(void) {return To_SetCols;}
-  inline  void    SetSetCols(PCOL colp) {To_SetCols = colp;}
-
-  // Properties
-  void    SetKindex(PKXBASE kxp);
-  PCOL    Key(int i) {return (To_Key_Col) ? To_Key_Col[i] : NULL;}
-
-  // Methods
-  virtual bool   IsUsingTemp(PGLOBAL g) {return false;}
-  virtual PCATLG GetCat(void);
-  virtual PSZ    GetPath(void);
-  virtual void   PrintAM(FILE *f, char *m);
-  virtual RECFM  GetFtype(void) {return RECFM_NAF;}
-  virtual int    GetAffectedRows(void) {return -1;}
-  virtual int    GetRecpos(void) = 0;
-  virtual bool   SetRecpos(PGLOBAL g, int recpos);
-  virtual bool   IsReadOnly(void) {return Read_Only;}
-  virtual bool   IsView(void) {return FALSE;}
-  virtual CHARSET_INFO *data_charset(void);
-  virtual int    GetProgMax(PGLOBAL g) {return GetMaxSize(g);}
-  virtual int    GetProgCur(void) {return GetRecpos();}
-  virtual PSZ    GetFile(PGLOBAL g) {return "Not a file";}
-  virtual int    GetRemote(void) {return 0;}
-  virtual void   SetFile(PGLOBAL g, PSZ fn) {}
-  virtual void   ResetDB(void) {}
-  virtual void   ResetSize(void) {MaxSize = -1;}
-  virtual void   RestoreNrec(void) {}
-  virtual int    ResetTableOpt(PGLOBAL g, bool dop, bool dox);
-  virtual PSZ    GetServer(void) {return "Current";}
-
-  // Database routines
-  virtual PCOL ColDB(PGLOBAL g, PSZ name, int num);
-  virtual PCOL MakeCol(PGLOBAL, PCOLDEF, PCOL, int)
-                      {assert(false); return NULL;}
-  virtual PCOL InsertSpecialColumn(PGLOBAL g, PCOL colp);
-  virtual PCOL InsertSpcBlk(PGLOBAL g, PCOLDEF cdp);
-  virtual void MarkDB(PGLOBAL g, PTDB tdb2);
-
- protected:
-  // Members
-  PTABDEF  To_Def;            // Points to catalog description block
-  PXOB    *To_Link;           // Points to column of previous relations
-  PCOL    *To_Key_Col;        // Points to key columns in current file
-  PKXBASE  To_Kindex;         // Points to table key index
-  PCOL     To_SetCols;        // Points to updated columns
-  int      MaxSize;            // Max size in number of lines
-  int      Knum;              // Size of key arrays
-  bool     Read_Only;         // True for read only tables
-  const CHARSET_INFO *m_data_charset;
-  }; // end of class TDBASE
-
-/***********************************************************************/
-/*  The abstract base class declaration for the catalog tables.        */
-/***********************************************************************/
-class DllExport TDBCAT : public TDBASE {
-  friend class CATCOL;
- public:
-  // Constructor
-  TDBCAT(PTABDEF tdp);
-
-  // Implementation
-  virtual AMT  GetAmType(void) {return TYPE_AM_CAT;}
-
-  // Methods
-  virtual int  GetRecpos(void) {return N;}
-  virtual int  GetProgCur(void) {return N;}
-  virtual int  RowNumber(PGLOBAL g, bool b = false) {return N + 1;}
-  virtual bool SetRecpos(PGLOBAL g, int recpos);
-
-  // Database routines
-  virtual PCOL MakeCol(PGLOBAL g, PCOLDEF cdp, PCOL cprec, int n);
-  virtual int  GetMaxSize(PGLOBAL g);
-  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);
-
- protected:
-  // Specific routines
-  virtual PQRYRES GetResult(PGLOBAL g) = 0;
-          bool Initialize(PGLOBAL g);
-          bool InitCol(PGLOBAL g);
-
-  // Members
-  PQRYRES Qrp;
-  int     N;                  // Row number
-  bool    Init;
-  }; // end of class TDBCAT
-
-/***********************************************************************/
-/*  Class CATCOL: ODBC info column.                                    */
-/***********************************************************************/
-class DllExport CATCOL : public COLBLK {
-  friend class TDBCAT;
- public:
-  // Constructors
-  CATCOL(PCOLDEF cdp, PTDB tdbp, int n);
-
-  // Implementation
-  virtual int  GetAmType(void) {return TYPE_AM_ODBC;}
-
-  // Methods
-  virtual void ReadColumn(PGLOBAL g);
-
- protected:
-  CATCOL(void) {}              // Default constructor not to be used
-
-  // Members
-  PTDBCAT Tdbp;                // Points to ODBC table block
-  PCOLRES Crp;                // The column data array
-  int     Flag;
-  }; // end of class CATCOL
-
-#endif  // TABLE_DEFINED
+/**************** Table H Declares Source Code File (.H) ***************/
+/*  Name: TABLE.H    Version 2.3                                       */
+/*                                                                     */
+/*  (C) Copyright to the author Olivier BERTRAND          1999-2014    */
+/*                                                                     */
+/*  This file contains the TBX, OPJOIN and TDB class definitions.      */
+/***********************************************************************/
+#if !defined(TABLE_DEFINED)
+#define      TABLE_DEFINED
+
+
+/***********************************************************************/
+/*  Include required application header files                          */
+/*  block.h      is header containing Block    global declarations.    */
+/***********************************************************************/
+#include "assert.h"
+#include "block.h"
+#include "colblk.h"
+#include "m_ctype.h"
+
+typedef class CMD *PCMD;
+
+// Commands executed by XDBC and MYX tables
+class CMD : public BLOCK {
+ public:
+  // Constructor
+  CMD(PGLOBAL g, char *cmd) {
+    Cmd = (char*)PlugSubAlloc(g, NULL, strlen(cmd) + 1);
+    strcpy(Cmd, cmd); Next = NULL; }
+
+  // Members
+  PCMD  Next;
+  char *Cmd;
+}; // end of class CMD
+
+// Condition filter structure
+typedef struct _cond_filter {
+  char  *Body;
+  OPVAL  Op;
+  PCMD   Cmds;
+} CONDFIL, *PCFIL;
+
+typedef class TDBCAT *PTDBCAT;
+typedef class CATCOL *PCATCOL;
+
+/***********************************************************************/
+/*  Definition of class TDB with all its method functions.             */
+/***********************************************************************/
+class DllExport TDB: public BLOCK {     // Table Descriptor Block.
+ public:
+  // Constructors
+  TDB(PTABDEF tdp = NULL);
+  TDB(PTDB tdbp);
+
+  // Implementation
+  static  void   SetTnum(int n) {Tnum = n;}
+  inline  PTDB   GetOrig(void) {return To_Orig;}
+  inline  TUSE   GetUse(void) {return Use;}
+  inline  PCFIL  GetCondFil(void) {return To_CondFil;}
+  inline  LPCSTR GetName(void) {return Name;}
+  inline  PTABLE GetTable(void) {return To_Table;}
+  inline  PCOL   GetColumns(void) {return Columns;}
+  inline  int    GetDegree(void) {return Degree;}
+  inline  MODE   GetMode(void) {return Mode;}
+  inline  PFIL   GetFilter(void) {return To_Filter;}
+  inline  void   SetFilter(PFIL fp) {To_Filter = fp;}
+  inline  void   SetOrig(PTDB txp) {To_Orig = txp;}
+  inline  void   SetUse(TUSE n) {Use = n;}
+  inline  void   SetCondFil(PCFIL cfp) {To_CondFil = cfp;}
+  inline  void   SetNext(PTDB tdbp) {Next = tdbp;}
+  inline  void   SetName(LPCSTR name) {Name = name;}
+  inline  void   SetTable(PTABLE tablep) {To_Table = tablep;}
+  inline  void   SetColumns(PCOL colp) {Columns = colp;}
+  inline  void   SetDegree(int degree) {Degree = degree;}
+  inline  void   SetMode(MODE mode) {Mode = mode;}
+
+  // Properties
+  virtual AMT    GetAmType(void) {return TYPE_AM_ERROR;}
+  virtual int    GetTdb_No(void) {return Tdb_No;}
+  virtual PTDB   GetNext(void) {return Next;}
+  virtual PCATLG GetCat(void) {return NULL;}
+
+  // Methods
+  virtual bool   IsSame(PTDB tp) {return tp == this;}
+  virtual bool   GetBlockValues(PGLOBAL g) {return false;}
+  virtual int    Cardinality(PGLOBAL g) {return (g) ? -1 : 0;}
+  virtual int    GetMaxSize(PGLOBAL) = 0;
+  virtual int    GetProgMax(PGLOBAL) = 0;
+  virtual int    GetProgCur(void) = 0;
+  virtual int    RowNumber(PGLOBAL g, bool b = false);
+  virtual bool   IsReadOnly(void) {return true;}
+  virtual const CHARSET_INFO *data_charset() {return NULL;}
+  virtual PTDB   Duplicate(PGLOBAL g) {return NULL;}
+  virtual PTDB   CopyOne(PTABS t) {return this;}
+  virtual PTDB   Copy(PTABS t);
+  virtual void   PrintAM(FILE *f, char *m)
+                  {fprintf(f, "%s AM(%d)\n",  m, GetAmType());}
+  virtual void   Print(PGLOBAL g, FILE *f, uint n);
+  virtual void   Print(PGLOBAL g, char *ps, uint z);
+  virtual PSZ    GetServer(void) = 0;
+  virtual int    GetBadLines(void) {return 0;}
+
+  // Database pure virtual routines
+  virtual PCOL   ColDB(PGLOBAL g, PSZ name, int num) = 0;
+  virtual void   MarkDB(PGLOBAL, PTDB) = 0;
+  virtual bool   OpenDB(PGLOBAL) = 0;
+  virtual int    ReadDB(PGLOBAL) = 0;
+  virtual int    WriteDB(PGLOBAL) = 0;
+  virtual int    DeleteDB(PGLOBAL, int) = 0;
+  virtual void   CloseDB(PGLOBAL) = 0;
+  virtual int    CheckWrite(PGLOBAL g) {return 0;}
+  virtual bool   ReadKey(PGLOBAL, OPVAL, const void *, int) = 0;
+
+ protected:
+  // Members
+  PTDB   To_Orig;      // Pointer to original if it is a copy
+  TUSE   Use;
+  PFIL   To_Filter;
+  PCFIL  To_CondFil;   // To condition filter structure
+  static int Tnum;     // Used to generate Tdb_no's
+  const  int Tdb_No;   // GetTdb_No() is always 0 for OPJOIN
+  PTDB   Next;         // Next in linearized queries
+  PTABLE To_Table;     // Points to the XTAB object
+  LPCSTR Name;         // Table name
+  PCOL   Columns;      // Points to the first column of the table
+  MODE   Mode;         // 10 Read, 30 Update, 40 Insert, 50 Delete
+  int    Degree;       // Number of columns
+  }; // end of class TDB
+
+/***********************************************************************/
+/*  This is the base class for all query tables (except decode).       */
+/***********************************************************************/
+class DllExport TDBASE : public TDB {
+  friend class INDEXDEF;
+  friend class XINDEX;
+  friend class XINDXS;
+ public:
+  // Constructor
+  TDBASE(PTABDEF tdp = NULL);
+  TDBASE(PTDBASE tdbp);
+
+  // Implementation
+  inline  int     GetKnum(void) {return Knum;}
+  inline  PTABDEF GetDef(void) {return To_Def;}
+  inline  PKXBASE GetKindex(void) {return To_Kindex;}
+  inline  PCOL    GetSetCols(void) {return To_SetCols;}
+  inline  void    SetSetCols(PCOL colp) {To_SetCols = colp;}
+
+  // Properties
+  void    SetKindex(PKXBASE kxp);
+  PCOL    Key(int i) {return (To_Key_Col) ? To_Key_Col[i] : NULL;}
+
+  // Methods
+  virtual bool   IsUsingTemp(PGLOBAL g) {return false;}
+  virtual PCATLG GetCat(void);
+  virtual PSZ    GetPath(void);
+  virtual void   PrintAM(FILE *f, char *m);
+  virtual RECFM  GetFtype(void) {return RECFM_NAF;}
+  virtual int    GetAffectedRows(void) {return -1;}
+  virtual int    GetRecpos(void) = 0;
+  virtual bool   SetRecpos(PGLOBAL g, int recpos);
+  virtual bool   IsReadOnly(void) {return Read_Only;}
+  virtual bool   IsView(void) {return FALSE;}
+  virtual CHARSET_INFO *data_charset(void);
+  virtual int    GetProgMax(PGLOBAL g) {return GetMaxSize(g);}
+  virtual int    GetProgCur(void) {return GetRecpos();}
+  virtual PSZ    GetFile(PGLOBAL g) {return "Not a file";}
+  virtual int    GetRemote(void) {return 0;}
+  virtual void   SetFile(PGLOBAL g, PSZ fn) {}
+  virtual void   ResetDB(void) {}
+  virtual void   ResetSize(void) {MaxSize = -1;}
+  virtual void   RestoreNrec(void) {}
+  virtual int    ResetTableOpt(PGLOBAL g, bool dop, bool dox);
+  virtual PSZ    GetServer(void) {return "Current";}
+
+  // Database routines
+  virtual PCOL ColDB(PGLOBAL g, PSZ name, int num);
+  virtual PCOL MakeCol(PGLOBAL, PCOLDEF, PCOL, int)
+                      {assert(false); return NULL;}
+  virtual PCOL InsertSpecialColumn(PGLOBAL g, PCOL colp);
+  virtual PCOL InsertSpcBlk(PGLOBAL g, PCOLDEF cdp);
+  virtual void MarkDB(PGLOBAL g, PTDB tdb2);
+  virtual int  MakeIndex(PGLOBAL g, PIXDEF pxdf, bool add)
+                {strcpy(g->Message, "Remote index"); return RC_INFO;}
+  virtual bool ReadKey(PGLOBAL g, OPVAL op, const void *key, int len)
+                      {assert(false); return true;}
+
+ protected:
+  // Members
+  PTABDEF  To_Def;            // Points to catalog description block
+  PXOB    *To_Link;           // Points to column of previous relations
+  PCOL    *To_Key_Col;        // Points to key columns in current file
+  PKXBASE  To_Kindex;         // Points to table key index
+  PCOL     To_SetCols;        // Points to updated columns
+  int      MaxSize;            // Max size in number of lines
+  int      Knum;              // Size of key arrays
+  bool     Read_Only;         // True for read only tables
+  const CHARSET_INFO *m_data_charset;
+  }; // end of class TDBASE
+
+/***********************************************************************/
+/*  The abstract base class declaration for the catalog tables.        */
+/***********************************************************************/
+class DllExport TDBCAT : public TDBASE {
+  friend class CATCOL;
+ public:
+  // Constructor
+  TDBCAT(PTABDEF tdp);
+
+  // Implementation
+  virtual AMT  GetAmType(void) {return TYPE_AM_CAT;}
+
+  // Methods
+  virtual int  GetRecpos(void) {return N;}
+  virtual int  GetProgCur(void) {return N;}
+  virtual int  RowNumber(PGLOBAL g, bool b = false) {return N + 1;}
+  virtual bool SetRecpos(PGLOBAL g, int recpos);
+
+  // Database routines
+  virtual PCOL MakeCol(PGLOBAL g, PCOLDEF cdp, PCOL cprec, int n);
+  virtual int  GetMaxSize(PGLOBAL g);
+  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);
+
+ protected:
+  // Specific routines
+  virtual PQRYRES GetResult(PGLOBAL g) = 0;
+          bool Initialize(PGLOBAL g);
+          bool InitCol(PGLOBAL g);
+
+  // Members
+  PQRYRES Qrp;
+  int     N;                  // Row number
+  bool    Init;
+  }; // end of class TDBCAT
+
+/***********************************************************************/
+/*  Class CATCOL: ODBC info column.                                    */
+/***********************************************************************/
+class DllExport CATCOL : public COLBLK {
+  friend class TDBCAT;
+ public:
+  // Constructors
+  CATCOL(PCOLDEF cdp, PTDB tdbp, int n);
+
+  // Implementation
+  virtual int  GetAmType(void) {return TYPE_AM_ODBC;}
+
+  // Methods
+  virtual void ReadColumn(PGLOBAL g);
+
+ protected:
+  CATCOL(void) {}              // Default constructor not to be used
+
+  // Members
+  PTDBCAT Tdbp;                // Points to ODBC table block
+  PCOLRES Crp;                // The column data array
+  int     Flag;
+  }; // end of class CATCOL
+
+#endif  // TABLE_DEFINED