Fix some XML table type bugs:

- in DOMNODELIST::DropItem
  if (Listp == NULL || Listp->length <= n)
    return true;
is wrong, should be:
  if (Listp == NULL || Listp->length < n)
    return true;
- Crash in discovery with libxml2 in XMLColumns because:
            if (!tdp->Usedom)    // nl was destroyed
              vp->nl = vp->pn->GetChildElements(g);
is executed with vp->pn uninitialized. Fixed by adding:
          vp->pn = node;
line 264.
-In discovery with libxml2 some columns are not found.
Because list was not recovered properly, nodes being modified and not reallocated.
Fixed lines 214 and 277.
  modified:   storage/connect/domdoc.cpp
  modified:   storage/connect/tabxml.cpp

Add support for zipped table files
  modified:   storage/connect/domdoc.cpp
  modified:   storage/connect/domdoc.h
  modified:   storage/connect/filamap.cpp
  modified:   storage/connect/filamap.h
  modified:   storage/connect/filamzip.cpp
  modified:   storage/connect/filamzip.h
  modified:   storage/connect/ha_connect.cc
  modified:   storage/connect/libdoc.cpp
  modified:   storage/connect/plgdbutl.cpp
  modified:   storage/connect/plgxml.cpp
  modified:   storage/connect/plgxml.h
  modified:   storage/connect/tabdos.cpp
  modified:   storage/connect/tabdos.h
  modified:   storage/connect/tabfmt.cpp
  modified:   storage/connect/tabjson.cpp
  modified:   storage/connect/tabxml.cpp

storage/connect/domdoc.cpp

@@ -89,30 +89,43 @@ DOMDOC::DOMDOC(char *nsl, char *nsdf, char *enc, PFBLOCK fp)
 /******************************************************************/
 /*  Initialize XML parser and check library compatibility.        */
 /******************************************************************/
-bool DOMDOC::Initialize(PGLOBAL g)
+bool DOMDOC::Initialize(PGLOBAL g, char *entry, bool zipped)
-  {
+{
-  if (TestHr(g, CoInitialize(NULL)))
+	if (zipped && InitZip(g, entry))
+		return true;
+
+	if (TestHr(g, CoInitialize(NULL)))
     return true;
 
   if (TestHr(g, Docp.CreateInstance("msxml2.domdocument")))
     return true;
 
   return MakeNSlist(g);
-  } // end of Initialize
+} // end of Initialize
 
 /******************************************************************/
 /* Parse the XML file and construct node tree in memory.          */
 /******************************************************************/
-bool DOMDOC::ParseFile(char *fn)
+bool DOMDOC::ParseFile(PGLOBAL g, char *fn)
-  {
+{
-  // Load the document
+	bool b;
+
   Docp->async = false;
 
-  if (!(bool)Docp->load((_bstr_t)fn))
+	if (zip) {
+		// Parse an in memory document
+		char *xdoc = GetMemDoc(g, fn);
+
+		b = (xdoc) ? (bool)Docp->loadXML((_bstr_t)xdoc) : false;
+	} else
+		// Load the document
+		b = (bool)Docp->load((_bstr_t)fn);
+
+	if (!b)
     return true;
 
   return false;
-  } // end of ParseFile
+} // end of ParseFile
 
 /******************************************************************/
 /* Create or reuse an Xblock for this document.                   */
@@ -239,6 +252,7 @@ int DOMDOC::DumpDoc(PGLOBAL g, char *ofn)
 void DOMDOC::CloseDoc(PGLOBAL g, PFBLOCK xp)
   {
   CloseXMLFile(g, xp, false);
+	CloseZip();
   } // end of Close
 
 /* ----------------------- class DOMNODE ------------------------ */
@@ -616,13 +630,13 @@ PXNODE DOMNODELIST::GetItem(PGLOBAL g, int n, PXNODE np)
 /*  Reset the pointer on the deleted item.                        */
 /******************************************************************/
 bool DOMNODELIST::DropItem(PGLOBAL g, int n)
-  {
+{
-  if (Listp == NULL || Listp->length <= n)
+	if (Listp == NULL || Listp->length < n)
-    return true;
+		return true;
 
 //Listp->item[n] = NULL;  La propriété n'a pas de méthode 'set'
   return false;
-  }  // end of DeleteItem
+}  // end of DeleteItem
 
 /* ----------------------- class DOMATTR ------------------------ */
 

storage/connect/domdoc.h

@@ -37,8 +37,8 @@ class DOMDOC : public XMLDOCUMENT {
   virtual void   SetNofree(bool b) {}   // Only libxml2
 
   // Methods
-  virtual bool    Initialize(PGLOBAL g);
+	virtual bool    Initialize(PGLOBAL g, char *entry, bool zipped);
-  virtual bool    ParseFile(char *fn);
+  virtual bool    ParseFile(PGLOBAL g, char *fn);
   virtual bool    NewDoc(PGLOBAL g, char *ver);
   virtual void    AddComment(PGLOBAL g, char *com);
   virtual PXNODE  GetRoot(PGLOBAL g);

storage/connect/filamap.cpp

@@ -319,11 +319,13 @@ int MAPFAM::SkipRecord(PGLOBAL g, bool header)
 /***********************************************************************/
 int MAPFAM::ReadBuffer(PGLOBAL g)
   {
-  int len;
+  int rc, len;
 
   // Are we at the end of the memory
-  if (Mempos >= Top)
+	if (Mempos >= Top)
-    return RC_EF;
+		if ((rc = GetNext(g)) != RC_OK)
+			return rc;
+
 
   if (!Placed) {
     /*******************************************************************/
@@ -341,8 +343,10 @@ int MAPFAM::ReadBuffer(PGLOBAL g)
     /*******************************************************************/
     switch (Tdbp->TestBlock(g)) {
       case RC_EF:
-        return RC_EF;
+				if ((rc = GetNext(g)) != RC_OK)
-      case RC_NF:
+					return rc;
+
+			case RC_NF:
         // Skip this record
         if ((rc = SkipRecord(g, false)) != RC_OK)
           return rc;
@@ -569,7 +573,7 @@ int MBKFAM::GetRowID(void)
 /***********************************************************************/
 int MBKFAM::ReadBuffer(PGLOBAL g)
   {
-  int len;
+  int rc, len;
 
   /*********************************************************************/
   /*  Sequential block reading when Placed is not true.                */
@@ -577,8 +581,10 @@ int MBKFAM::ReadBuffer(PGLOBAL g)
   if (Placed) {
     Placed = false;
   } else if (Mempos >= Top) {        // Are we at the end of the memory
-    return RC_EF;
+		if ((rc = GetNext(g)) != RC_OK)
-  } else if (++CurNum < Nrec) {
+			return rc;
+
+	} else if (++CurNum < Nrec) {
     Fpos = Mempos;
   } else {
     /*******************************************************************/
@@ -588,7 +594,8 @@ int MBKFAM::ReadBuffer(PGLOBAL g)
 
    next:
     if (++CurBlk >= Block)
-      return RC_EF;
+			if ((rc = GetNext(g)) != RC_OK)
+				return rc;
 
     /*******************************************************************/
     /*  Before reading a new block, check whether block optimization   */
@@ -596,8 +603,11 @@ int MBKFAM::ReadBuffer(PGLOBAL g)
     /*******************************************************************/
     switch (Tdbp->TestBlock(g)) {
       case RC_EF:
-        return RC_EF;
+				if ((rc = GetNext(g)) != RC_OK)
-      case RC_NF:
+					return rc;
+
+				break;
+			case RC_NF:
         goto next;
       } // endswitch rc
 
@@ -697,14 +707,18 @@ int MPXFAM::InitDelete(PGLOBAL, int fpos, int)
 /***********************************************************************/
 int MPXFAM::ReadBuffer(PGLOBAL g)
   {
+	int rc;
+
   /*********************************************************************/
   /*  Sequential block reading when Placed is not true.                */
   /*********************************************************************/
   if (Placed) {
     Placed = false;
   } else if (Mempos >= Top) {        // Are we at the end of the memory
-    return RC_EF;
+		if ((rc = GetNext(g)) != RC_OK)
-  } else if (++CurNum < Nrec) {
+			return rc;
+
+	} else if (++CurNum < Nrec) {
     Fpos = Mempos;
   } else {
     /*******************************************************************/
@@ -714,7 +728,7 @@ int MPXFAM::ReadBuffer(PGLOBAL g)
 
    next:
     if (++CurBlk >= Block)
-      return RC_EF;
+			return GetNext(g);
 
     /*******************************************************************/
     /*  Before reading a new block, check whether block optimization   */
@@ -722,8 +736,11 @@ int MPXFAM::ReadBuffer(PGLOBAL g)
     /*******************************************************************/
     switch (Tdbp->TestBlock(g)) {
       case RC_EF:
-        return RC_EF;
+				if ((rc = GetNext(g)) != RC_OK)
-      case RC_NF:
+					return rc;
+
+				break;
+			case RC_NF:
         goto next;
       } // endswitch rc
 

storage/connect/filamap.h

@@ -41,7 +41,8 @@ class DllExport MAPFAM : public TXTFAM {
   virtual int   SkipRecord(PGLOBAL g, bool header);
   virtual bool  OpenTableFile(PGLOBAL g);
   virtual bool  DeferReading(void) {return false;}
-  virtual int   ReadBuffer(PGLOBAL g);
+	virtual int   GetNext(PGLOBAL g) {return RC_EF;}
+	virtual int   ReadBuffer(PGLOBAL g);
   virtual int   WriteBuffer(PGLOBAL g);
   virtual int   DeleteRecords(PGLOBAL g, int irc);
   virtual void  CloseTableFile(PGLOBAL g, bool abort);

storage/connect/filamzip.cpp

@@ -40,19 +40,21 @@
 //#include "tabzip.h"
 #include "filamzip.h"
 
-/* -------------------------- class ZIPFAM --------------------------- */
+/* -------------------------- class ZIPUTIL -------------------------- */
 
 /***********************************************************************/
 /*  Constructors.                                                      */
 /***********************************************************************/
-ZIPFAM::ZIPFAM(PDOSDEF tdp) : MAPFAM(tdp)
+ZIPUTIL::ZIPUTIL(PSZ tgt, bool mul)
 {
 	zipfile = NULL;
-//zfn = tdp->Fn;
+	target = tgt;
-	target = tdp->Entry;
+	fp = NULL;
-//*fn = 0;
+	memory = NULL;
+	size = 0;
 	entryopen = false;
-	multiple = (target && !(strchr(target, '*') || strchr(target, '?'))) ? 0 : 1;
+	multiple = mul;
+	memset(fn, 0, sizeof(fn));
 
 	// Init the case mapping table.
 #if defined(__WIN__)
@@ -60,29 +62,30 @@ ZIPFAM::ZIPFAM(PDOSDEF tdp) : MAPFAM(tdp)
 #else
 	for (int i = 0; i < 256; ++i) mapCaseTable[i] = i;
 #endif
-} // end of ZIPFAM standard constructor
+} // end of ZIPUTIL standard constructor
 
-ZIPFAM::ZIPFAM(PZIPFAM txfp) : MAPFAM(txfp)
+#if 0
+ZIPUTIL::ZIPUTIL(PZIPUTIL zutp)
 {
-	zipfile = txfp->zipfile;
+	zipfile = zutp->zipfile;
-//zfn = txfp->zfn;
+	target = zutp->target;
-	target = txfp->target;
+	fp = zutp->fp;
-//strcpy(fn, txfp->fn);
+	finfo = zutp->finfo;
-	finfo = txfp->finfo;
+	entryopen = zutp->entryopen;
-	entryopen = txfp->entryopen;
+	multiple = zutp->multiple;
-	multiple = txfp->multiple;
+	for (int i = 0; i < 256; ++i) mapCaseTable[i] = zutp->mapCaseTable[i];
-	for (int i = 0; i < 256; ++i) mapCaseTable[i] = txfp->mapCaseTable[i];
+} // end of ZIPUTIL copy constructor
-} // end of ZIPFAM copy constructor
+#endif // 0
 
 /***********************************************************************/
 /* This code is the copyright property of Alessandro Felice Cantatore. */
 /* http://xoomer.virgilio.it/acantato/dev/wildcard/wildmatch.html			 */
 /***********************************************************************/
-bool ZIPFAM::WildMatch(PSZ pat, PSZ str) {
+bool ZIPUTIL::WildMatch(PSZ pat, PSZ str) {
 	PSZ  s, p;
 	bool star = FALSE;
 
- loopStart:
+loopStart:
 	for (s = str, p = pat; *s; ++s, ++p) {
 		switch (*p) {
 		case '?':
@@ -102,31 +105,18 @@ bool ZIPFAM::WildMatch(PSZ pat, PSZ str) {
 	if (*p == '*') ++p;
 	return (!*p);
 
- starCheck:
+starCheck:
 	if (!star) return FALSE;
 	str++;
 	goto loopStart;
 }	// end of WildMatch
 
-/***********************************************************************/
-/*  ZIP GetFileLength: returns file size in number of bytes.           */
-/***********************************************************************/
-int ZIPFAM::GetFileLength(PGLOBAL g)
-{
-	int len = (entryopen) ? Top - Memory : 100;	 // not 0 to avoid ASSERT
-
-	if (trace)
-		htrc("Zipped file length=%d\n", len);
-
-	return len;
-} // end of GetFileLength
-
 /***********************************************************************/
 /*  open a zip file.																									 */
 /*  param: filename	path and the filename of the zip file to open.		 */
 /*  return:	true if open, false otherwise.														 */
 /***********************************************************************/
-bool ZIPFAM::open(PGLOBAL g, const char *filename)
+bool ZIPUTIL::open(PGLOBAL g, char *filename)
 {
 	if (!zipfile && !(zipfile = unzOpen64(filename)))
 		sprintf(g->Message, "Zipfile open error on %s", filename);
@@ -137,7 +127,7 @@ bool ZIPFAM::open(PGLOBAL g, const char *filename)
 /***********************************************************************/
 /*  Close the zip file.																								 */
 /***********************************************************************/
-void ZIPFAM::close()
+void ZIPUTIL::close()
 {
 	if (zipfile) {
 		closeEntry();
@@ -150,10 +140,9 @@ void ZIPFAM::close()
 /***********************************************************************/
 /*  Find next entry matching target pattern.                           */
 /***********************************************************************/
-int ZIPFAM::findEntry(PGLOBAL g, bool next)
+int ZIPUTIL::findEntry(PGLOBAL g, bool next)
 {
 	int  rc;
-	char fn[FILENAME_MAX];     	 // The current entry file name
 
 	do {
 		if (next) {
@@ -188,37 +177,53 @@ int ZIPFAM::findEntry(PGLOBAL g, bool next)
 
 	strcpy(g->Message, "FindNext logical error");
 	return RC_FX;
-}	// end of FindNext
+}	// end of FindEntry
+
+
+/***********************************************************************/
+/*  Get the next used entry.                                           */
+/***********************************************************************/
+int ZIPUTIL::nextEntry(PGLOBAL g)
+{
+	if (multiple) {
+		int rc;
+
+		closeEntry();
+
+		if ((rc = findEntry(g, true)) != RC_OK)
+			return rc;
+
+		if (openEntry(g))
+			return RC_FX;
+
+		return RC_OK;
+	} else
+		return RC_EF;
+
+} // end of nextEntry
+
 
 /***********************************************************************/
 /*  OpenTableFile: Open a DOS/UNIX table file from a ZIP file.         */
 /***********************************************************************/
-bool ZIPFAM::OpenTableFile(PGLOBAL g)
+bool ZIPUTIL::OpenTable(PGLOBAL g, MODE mode, char *fn)
 {
-	char    filename[_MAX_PATH];
-	MODE    mode = Tdbp->GetMode();
-  PFBLOCK fp;
-  PDBUSER dbuserp = (PDBUSER)g->Activityp->Aptr;
-
 	/*********************************************************************/
 	/*  The file will be decompressed into virtual memory.               */
 	/*********************************************************************/
-	if (mode == MODE_READ) {
+	if (mode == MODE_READ || mode == MODE_ANY) {
-		//  We used the file name relative to recorded datapath
+		bool b = open(g, fn);
-		PlugSetPath(filename, To_File, Tdbp->GetPath());
-
-		bool b = open(g, filename);
 
 		if (!b) {
 			int rc;
-			
+
 			if (target && *target) {
 				if (!multiple) {
 					rc = unzLocateFile(zipfile, target, 0);
 
 					if (rc == UNZ_END_OF_LIST_OF_FILE) {
-						sprintf(g->Message, "Target file %s not in %s", target, filename);
+						sprintf(g->Message, "Target file %s not in %s", target, fn);
-						return false;
+						return true;
 					} else if (rc != UNZ_OK) {
 						sprintf(g->Message, "unzLocateFile rc=%d", rc);
 						return true;
@@ -227,9 +232,9 @@ bool ZIPFAM::OpenTableFile(PGLOBAL g)
 				} else {
 					if ((rc = findEntry(g, false)) == RC_FX)
 						return true;
-					else if (rc == RC_NF) {
+					else if (rc == RC_EF) {
-						sprintf(g->Message, "No match of %s in %s", target, filename);
+						sprintf(g->Message, "No match of %s in %s", target, fn);
-						return false;
+						return true;
 					} // endif rc
 
 				} // endif multiple
@@ -239,25 +244,26 @@ bool ZIPFAM::OpenTableFile(PGLOBAL g)
 			if (openEntry(g))
 				return true;
 
-			if (Top > Memory)	{
+			if (size > 0)	{
 				/*******************************************************************/
 				/*  Link a Fblock. This make possible to automatically close it    */
 				/*  in case of error g->jump.                                      */
 				/*******************************************************************/
+				PDBUSER dbuserp = (PDBUSER)g->Activityp->Aptr;
+
 				fp = (PFBLOCK)PlugSubAlloc(g, NULL, sizeof(FBLOCK));
 				fp->Type = TYPE_FB_ZIP;
-				fp->Fname = PlugDup(g, filename);
+				fp->Fname = PlugDup(g, fn);
 				fp->Next = dbuserp->Openlist;
 				dbuserp->Openlist = fp;
 				fp->Count = 1;
-				fp->Length = Top - Memory;
+				fp->Length = size;
-				fp->Memory = Memory;
+				fp->Memory = memory;
 				fp->Mode = mode;
 				fp->File = this;
 				fp->Handle = NULL;
 			} // endif fp
 
-			To_Fb = fp;                               // Useful when closing
 		} else
 			return true;
 
@@ -267,65 +273,161 @@ bool ZIPFAM::OpenTableFile(PGLOBAL g)
 	}	// endif mode
 
 	return false;
-	} // end of OpenTableFile
+} // end of OpenTableFile
 
 /***********************************************************************/
 /*  Open target in zip file.						      												 */
 /***********************************************************************/
-bool ZIPFAM::openEntry(PGLOBAL g)
+bool ZIPUTIL::openEntry(PGLOBAL g)
 {
-	int  rc;
+	int rc;
-	uint size;
 
-	rc = unzGetCurrentFileInfo(zipfile, &finfo, 0, 0, 0, 0, 0, 0);
+	rc = unzGetCurrentFileInfo(zipfile, &finfo, fn, sizeof(fn),
+		NULL, 0, NULL, 0);
 
 	if (rc != UNZ_OK) {
 		sprintf(g->Message, "unzGetCurrentFileInfo64 rc=%d", rc);
 		return true;
 	} else if ((rc = unzOpenCurrentFile(zipfile)) != UNZ_OK) {
-		sprintf(g->Message, "unzOpenCurrentFile rc=%d", rc);
+		sprintf(g->Message, "unzOpen fn=%s rc=%d", fn, rc);
 		return true;
 	}	// endif rc
 
 	size = finfo.uncompressed_size;
-	Memory = new char[size];
+	memory = new char[size + 1];
 
-	if ((rc = unzReadCurrentFile(zipfile, Memory, size)) < 0) {
+	if ((rc = unzReadCurrentFile(zipfile, memory, size)) < 0) {
 		sprintf(g->Message, "unzReadCurrentFile rc = ", rc);
 		unzCloseCurrentFile(zipfile);
-		free(Memory);
+		free(memory);
+		memory = NULL;
 		entryopen = false;
 	} else {
-		// The pseudo "buffer" is here the entire real buffer
+		memory[size] = 0;    // Required by some table types (XML)
-		Fpos = Mempos = Memory;
-		Top = Memory + size;
-
-		if (trace)
-			htrc("Memory=%p size=%ud Top=%p\n", Memory, size, Top);
-
 		entryopen = true;
 	} // endif rc
 
+	if (trace)
+		htrc("Openning entry%s %s\n", fn, (entryopen) ? "oked" : "failed");
+
 	return !entryopen;
 }	// end of openEntry
 
 /***********************************************************************/
 /*  Close the zip file.																								 */
 /***********************************************************************/
-void ZIPFAM::closeEntry()
+void ZIPUTIL::closeEntry()
 {
 	if (entryopen) {
 		unzCloseCurrentFile(zipfile);
 		entryopen = false;
 	}	// endif entryopen
 
-	if (Memory) {
+	if (memory) {
-		free(Memory);
+		free(memory);
-		Memory = NULL;
+		memory = NULL;
-	}	// endif Memory
+	}	// endif memory
 
 }	// end of closeEntry
 
+/* -------------------------- class ZIPFAM --------------------------- */
+
+/***********************************************************************/
+/*  Constructors.                                                      */
+/***********************************************************************/
+ZIPFAM::ZIPFAM(PDOSDEF tdp) : MAPFAM(tdp)
+{
+	zutp = NULL;
+  target = tdp->GetEntry();
+	mul = tdp->GetMul();
+} // end of ZIPFAM standard constructor
+
+ZIPFAM::ZIPFAM(PZIPFAM txfp) : MAPFAM(txfp)
+{
+	zutp = txfp->zutp;
+	target = txfp->target;
+	mul = txfp->mul;
+} // end of ZIPFAM copy constructor
+
+ZIPFAM::ZIPFAM(PDOSDEF tdp, PZPXFAM txfp) : MAPFAM(tdp)
+{
+	zutp = txfp->zutp;
+	target = txfp->target;
+	mul = txfp->mul;
+} // end of ZIPFAM constructor used in ResetTableOpt
+
+/***********************************************************************/
+/*  ZIP GetFileLength: returns file size in number of bytes.           */
+/***********************************************************************/
+int ZIPFAM::GetFileLength(PGLOBAL g)
+{
+	int len = (zutp && zutp->entryopen) ? Top - Memory
+		                                  : TXTFAM::GetFileLength(g) * 3;
+
+	if (trace)
+		htrc("Zipped file length=%d\n", len);
+
+	return len;
+} // end of GetFileLength
+
+/***********************************************************************/
+/*  ZIP Cardinality: return the number of rows if possible.            */
+/***********************************************************************/
+int ZIPFAM::Cardinality(PGLOBAL g)
+{
+	if (!g)
+		return 1;
+
+	int card = -1;
+	int len = GetFileLength(g);
+
+	card = (len / (int)Lrecl) * 2;           // Estimated ???
+	return card;
+} // end of Cardinality
+
+/***********************************************************************/
+/*  OpenTableFile: Open a DOS/UNIX table file from a ZIP file.         */
+/***********************************************************************/
+bool ZIPFAM::OpenTableFile(PGLOBAL g)
+{
+	char    filename[_MAX_PATH];
+	MODE    mode = Tdbp->GetMode();
+
+	/*********************************************************************/
+	/*  Allocate the ZIP utility class.                                  */
+	/*********************************************************************/
+	zutp = new(g) ZIPUTIL(target, mul);
+
+	//  We used the file name relative to recorded datapath
+	PlugSetPath(filename, To_File, Tdbp->GetPath());
+
+	if (!zutp->OpenTable(g, mode, filename)) {
+		// The pseudo "buffer" is here the entire real buffer
+		Fpos = Mempos = Memory = zutp->memory;
+		Top = Memory + zutp->size;
+		To_Fb = zutp->fp;                           // Useful when closing
+	} else
+		return true;
+
+	return false;
+	} // end of OpenTableFile
+
+/***********************************************************************/
+/*  GetNext: go to next entry.                                         */
+/***********************************************************************/
+int ZIPFAM::GetNext(PGLOBAL g)
+{
+	int rc = zutp->nextEntry(g);
+
+	if (rc != RC_OK)
+		return rc;
+
+	Mempos = Memory = zutp->memory;
+	Top = Memory + zutp->size;
+	return RC_OK;
+} // end of GetNext
+
+#if 0
 /***********************************************************************/
 /*  ReadBuffer: Read one line for a ZIP file.                          */
 /***********************************************************************/
@@ -335,19 +437,12 @@ int ZIPFAM::ReadBuffer(PGLOBAL g)
 
 	// Are we at the end of the memory
 	if (Mempos >= Top) {
-		if (multiple) {
+		if ((rc = zutp->nextEntry(g)) != RC_OK)
-			closeEntry();
+			return rc;
 
-			if ((rc = findEntry(g, true)) != RC_OK)
+		Mempos = Memory = zutp->memory;
-				return rc;
+		Top = Memory + zutp->size;
-
+	}	// endif Mempos
-			if (openEntry(g))
-				return RC_FX;
-
-		} else
-			return RC_EF;
-
-	} // endif Mempos
 
 #if 0
 	if (!Placed) {
@@ -399,7 +494,6 @@ int ZIPFAM::ReadBuffer(PGLOBAL g)
 	return RC_OK;
 } // end of ReadBuffer
 
-#if 0
 /***********************************************************************/
 /*  Table file close routine for MAP access method.                    */
 /***********************************************************************/
@@ -414,89 +508,115 @@ void ZIPFAM::CloseTableFile(PGLOBAL g, bool)
 /***********************************************************************/
 /*  Constructors.                                                      */
 /***********************************************************************/
-ZPXFAM::ZPXFAM(PDOSDEF tdp) : ZIPFAM(tdp)
+ZPXFAM::ZPXFAM(PDOSDEF tdp) : MPXFAM(tdp)
 {
-	Lrecl = tdp->GetLrecl();
+	zutp = NULL;
+	target = tdp->GetEntry();
+	mul = tdp->GetMul();
+	//Lrecl = tdp->GetLrecl();
 } // end of ZPXFAM standard constructor
 
-ZPXFAM::ZPXFAM(PZPXFAM txfp) : ZIPFAM(txfp)
+ZPXFAM::ZPXFAM(PZPXFAM txfp) : MPXFAM(txfp)
 {
-	Lrecl = txfp->Lrecl;
+	zutp = txfp->zutp;
+	target = txfp->target;
+	mul = txfp->mul;
+//Lrecl = txfp->Lrecl;
 } // end of ZPXFAM copy constructor
 
 /***********************************************************************/
-/*  ReadBuffer: Read one line for a fixed ZIP file.                    */
+/*  ZIP GetFileLength: returns file size in number of bytes.           */
 /***********************************************************************/
-int ZPXFAM::ReadBuffer(PGLOBAL g)
+int ZPXFAM::GetFileLength(PGLOBAL g)
 {
-	int rc, len;
+	int len;
 
-	// Are we at the end of the memory
+	if (!zutp && OpenTableFile(g))
-	if (Mempos >= Top) {
+		return 0;
-		if (multiple) {
-			closeEntry();
 
-			if ((rc = findEntry(g, true)) != RC_OK)
+	if (zutp->entryopen)
-				return rc;
+		len = zutp->size;
+	else
+		len = 0;
 
-			if (openEntry(g))
+	return len;
-				return RC_FX;
+} // end of GetFileLength
 
+/***********************************************************************/
+/*  ZIP Cardinality: return the number of rows if possible.            */
+/***********************************************************************/
+int ZPXFAM::Cardinality(PGLOBAL g)
+{
+	if (!g)
+		return 1;
+
+	int card = -1;
+	int len = GetFileLength(g);
+
+	if (!(len % Lrecl))
+		card = len / (int)Lrecl;           // Fixed length file
+	else
+		sprintf(g->Message, MSG(NOT_FIXED_LEN), zutp->fn, len, Lrecl);
+
+	// Set number of blocks for later use
+	Block = (card > 0) ? (card + Nrec - 1) / Nrec : 0;
+	return card;
+} // end of Cardinality
+
+/***********************************************************************/
+/*  OpenTableFile: Open a DOS/UNIX table file from a ZIP file.         */
+/***********************************************************************/
+bool ZPXFAM::OpenTableFile(PGLOBAL g)
+{
+	// May have been already opened in GetFileLength
+	if (!zutp || !zutp->zipfile) {
+		char    filename[_MAX_PATH];
+		MODE    mode = Tdbp->GetMode();
+
+		/*********************************************************************/
+		/*  Allocate the ZIP utility class.                                  */
+		/*********************************************************************/
+		if (!zutp)
+			zutp = new(g)ZIPUTIL(target, mul);
+
+		//  We used the file name relative to recorded datapath
+		PlugSetPath(filename, To_File, Tdbp->GetPath());
+
+		if (!zutp->OpenTable(g, mode, filename)) {
+			// The pseudo "buffer" is here the entire real buffer
+			Memory = zutp->memory;
+			Fpos = Mempos = Memory + Headlen;
+			Top = Memory + zutp->size;
+			To_Fb = zutp->fp;                           // Useful when closing
 		} else
-			return RC_EF;
+			return true;
-
-	} // endif Mempos
-
-#if 0
-	if (!Placed) {
-		/*******************************************************************/
-		/*  Record file position in case of UPDATE or DELETE.              */
-		/*******************************************************************/
-		int rc;
-
-	next:
-		Fpos = Mempos;
-		CurBlk = (int)Rows++;
-
-		/*******************************************************************/
-		/*  Check whether optimization on ROWID                            */
-		/*  can be done, as well as for join as for local filtering.       */
-		/*******************************************************************/
-		switch (Tdbp->TestBlock(g)) {
-		case RC_EF:
-			return RC_EF;
-		case RC_NF:
-			// Skip this record
-			if ((rc = SkipRecord(g, false)) != RC_OK)
-				return rc;
-
-			goto next;
-		} // endswitch rc
 
 	} else
-		Placed = false;
+		Reset();
-#else
-	// Perhaps unuseful
-	Fpos = Mempos;
-	CurBlk = (int)Rows++;
-	Placed = false;
-#endif
 
-	// Immediately calculate next position (Used by DeleteDB)
+	return false;
-	Mempos += Lrecl;
+} // end of OpenTableFile
 
-	// Set caller line buffer
+/***********************************************************************/
-	len = Lrecl;
+/*  GetNext: go to next entry.                                         */
+/***********************************************************************/
+int ZPXFAM::GetNext(PGLOBAL g)
+{
+	int rc = zutp->nextEntry(g);
 
-	// Don't rely on ENDING setting
+	if (rc != RC_OK)
-	if (len > 0 && *(Mempos - 1) == '\n')
+			return rc;
-		len--;             // Line ends by LF
 
-	if (len > 0 && *(Mempos - 2) == '\r')
+	int len = zutp->size;
-		len--;             // Line ends by CRLF
 
-	memcpy(Tdbp->GetLine(), Fpos, len);
+	if (len % Lrecl) {
-	Tdbp->GetLine()[len] = '\0';
+		sprintf(g->Message, MSG(NOT_FIXED_LEN), zutp->fn, len, Lrecl);
+		return RC_FX;
+	}	// endif size
+
+	Memory = zutp->memory;
+	Top = Memory + len;
+	Rewind();
 	return RC_OK;
-} // end of ReadBuffer
+} // end of GetNext
 

storage/connect/filamzip.h

@@ -18,66 +18,100 @@ typedef class ZIPFAM *PZIPFAM;
 typedef class ZPXFAM *PZPXFAM;
 
 /***********************************************************************/
-/*  This is the ZIP file access method.                                */
+/*  This is the ZIP utility fonctions class.                           */
 /***********************************************************************/
-class DllExport ZIPFAM : public MAPFAM {
+class DllExport ZIPUTIL : public BLOCK {
 public:
 	// Constructor
-	ZIPFAM(PDOSDEF tdp);
+	ZIPUTIL(PSZ tgt, bool mul);
-	ZIPFAM(PZIPFAM txfp);
+//ZIPUTIL(ZIPUTIL *zutp);
 
 	// Implementation
-	virtual AMT  GetAmType(void) {return TYPE_AM_ZIP;}
+//PTXF Duplicate(PGLOBAL g) { return (PTXF) new(g)ZIPFAM(this); }
-  virtual PTXF Duplicate(PGLOBAL g) {return (PTXF) new(g) ZIPFAM(this);}
 
 	// Methods
-	virtual int  GetFileLength(PGLOBAL g);
+	virtual bool OpenTable(PGLOBAL g, MODE mode, char *fn);
-	virtual int  Cardinality(PGLOBAL g) {return (g) ? 10 : 1;}
+	bool open(PGLOBAL g, char *fn);
-//virtual int  MaxBlkSize(PGLOBAL g, int s) {return s;}
-	virtual bool OpenTableFile(PGLOBAL g);
-	virtual bool DeferReading(void) {return false;}
-  virtual int  ReadBuffer(PGLOBAL g);
-//virtual int  WriteBuffer(PGLOBAL g);
-//virtual int  DeleteRecords(PGLOBAL g, int irc);
-//virtual void CloseTableFile(PGLOBAL g, bool abort);
-	        void close(void);
-
-protected:
-	bool open(PGLOBAL g, const char *filename);
 	bool openEntry(PGLOBAL g);
+	void close(void);
 	void closeEntry(void);
 	bool WildMatch(PSZ pat, PSZ str);
 	int  findEntry(PGLOBAL g, bool next);
+	int  nextEntry(PGLOBAL g);
 
 	// Members
-	unzFile         zipfile;							   // The ZIP container file
+	unzFile         zipfile;							// The ZIP container file
-//PSZ             zfn;									   // The ZIP file name
+	PSZ             target;								// The target file name
-	PSZ             target;									 // The target file name
+	unz_file_info   finfo;								// The current file info
-	unz_file_info   finfo;									 // The current file info
+	PFBLOCK         fp;
-//char            fn[FILENAME_MAX];     	 // The current file name
+	char           *memory;
-	bool            entryopen;							 // True when open current entry
+	uint            size;
-	int             multiple;                // Multiple targets
+	int             multiple;             // Multiple targets
+	bool            entryopen;						// True when open current entry
+	char            fn[FILENAME_MAX];     // The current entry file name
 	char            mapCaseTable[256];
 }; // end of ZIPFAM
 
+/***********************************************************************/
+/*  This is the ZIP file access method.                                */
+/***********************************************************************/
+class DllExport ZIPFAM : public MAPFAM {
+	friend class ZPXFAM;
+public:
+	// Constructors
+	ZIPFAM(PDOSDEF tdp);
+	ZIPFAM(PZIPFAM txfp);
+	ZIPFAM(PDOSDEF tdp, PZPXFAM txfp);
+
+	// Implementation
+	virtual AMT  GetAmType(void) { return TYPE_AM_ZIP; }
+	virtual PTXF Duplicate(PGLOBAL g) { return (PTXF) new(g)ZIPFAM(this); }
+
+	// Methods
+	virtual int  Cardinality(PGLOBAL g);
+	virtual int  GetFileLength(PGLOBAL g);
+//virtual int  MaxBlkSize(PGLOBAL g, int s) {return s;}
+	virtual bool OpenTableFile(PGLOBAL g);
+	virtual bool DeferReading(void) { return false; }
+	virtual int  GetNext(PGLOBAL g);
+//virtual int  ReadBuffer(PGLOBAL g);
+//virtual int  WriteBuffer(PGLOBAL g);
+//virtual int  DeleteRecords(PGLOBAL g, int irc);
+//virtual void CloseTableFile(PGLOBAL g, bool abort);
+
+protected:
+	// Members
+	ZIPUTIL *zutp;
+	PSZ      target;
+	bool     mul;
+}; // end of ZIPFAM
+
 /***********************************************************************/
 /*  This is the fixed ZIP file access method.                          */
 /***********************************************************************/
-class DllExport ZPXFAM : public ZIPFAM {
+class DllExport ZPXFAM : public MPXFAM {
+	friend class ZIPFAM;
 public:
-	// Constructor
+	// Constructors
 	ZPXFAM(PDOSDEF tdp);
 	ZPXFAM(PZPXFAM txfp);
 
 	// Implementation
-	virtual PTXF Duplicate(PGLOBAL g) {return (PTXF) new(g) ZPXFAM(this);}
+	virtual AMT  GetAmType(void) { return TYPE_AM_ZIP; }
+	virtual PTXF Duplicate(PGLOBAL g) { return (PTXF) new(g)ZPXFAM(this); }
 
 	// Methods
-	virtual int  ReadBuffer(PGLOBAL g);
+	virtual int  GetFileLength(PGLOBAL g);
+	virtual int  Cardinality(PGLOBAL g);
+	virtual bool OpenTableFile(PGLOBAL g);
+	virtual int  GetNext(PGLOBAL g);
+//virtual int  ReadBuffer(PGLOBAL g);
 
 protected:
 	// Members
-	int Lrecl;
+	ZIPUTIL *zutp;
+	PSZ      target;
+	bool     mul;
 }; // end of ZPXFAM
 
 #endif // __FILAMZIP_H

storage/connect/ha_connect.cc

@@ -1242,8 +1242,10 @@ char *ha_connect::GetStringOption(char *opname, char *sdef)
 
   if (opval && (!stricmp(opname, "connect") 
              || !stricmp(opname, "tabname") 
-             || !stricmp(opname, "filename")))
+             || !stricmp(opname, "filename")
-    opval = GetRealString(opval);
+						 || !stricmp(opname, "optname")
+						 || !stricmp(opname, "entry")))
+						 opval = GetRealString(opval);
 
   if (!opval) {
     if (sdef && !strcmp(sdef, "*")) {

storage/connect/libdoc.cpp

@@ -1,6 +1,6 @@
 /******************************************************************/
 /*  Implementation of XML document processing using libxml2       */
-/*  Author: Olivier Bertrand                2007-2015             */
+/*  Author: Olivier Bertrand                2007-2016             */
 /******************************************************************/
 #include "my_global.h"
 #include <string.h>
@@ -68,8 +68,8 @@ class LIBXMLDOC : public XMLDOCUMENT {
   virtual void   SetNofree(bool b) {Nofreelist = b;}
 
   // Methods
-  virtual bool    Initialize(PGLOBAL g);
+	virtual bool    Initialize(PGLOBAL g, char *entry, bool zipped);
-  virtual bool    ParseFile(char *fn);
+  virtual bool    ParseFile(PGLOBAL g, char *fn);
   virtual bool    NewDoc(PGLOBAL g, char *ver);
   virtual void    AddComment(PGLOBAL g, char *com);
   virtual PXNODE  GetRoot(PGLOBAL g);
@@ -373,22 +373,33 @@ LIBXMLDOC::LIBXMLDOC(char *nsl, char *nsdf, char *enc, PFBLOCK fp)
 /******************************************************************/
 /*  Initialize XML parser and check library compatibility.        */
 /******************************************************************/
-bool LIBXMLDOC::Initialize(PGLOBAL g)
+bool LIBXMLDOC::Initialize(PGLOBAL g, char *entry, bool zipped)
-  {
+{
+	if (zipped && InitZip(g, entry))
+		return true;
+
   int n = xmlKeepBlanksDefault(1);
   return MakeNSlist(g);
-  } // end of Initialize
+} // end of Initialize
 
 /******************************************************************/
 /* Parse the XML file and construct node tree in memory.          */
 /******************************************************************/
-bool LIBXMLDOC::ParseFile(char *fn)
+bool LIBXMLDOC::ParseFile(PGLOBAL g, char *fn)
   {
   if (trace)
     htrc("ParseFile\n");
 
-  if ((Docp = xmlParseFile(fn))) {
+	if (zip) {
-    if (Docp->encoding)
+		// Parse an in memory document
+		char *xdoc = GetMemDoc(g, fn);
+
+		Docp = (xdoc) ? xmlParseDoc((const xmlChar *)xdoc) : NULL;
+	} else
+		Docp = xmlParseFile(fn);
+
+	if (Docp) {
+		if (Docp->encoding)
       Encoding = (char*)Docp->encoding;
 
     return false;
@@ -609,6 +620,7 @@ void LIBXMLDOC::CloseDoc(PGLOBAL g, PFBLOCK xp)
     } // endif xp
 
   CloseXML2File(g, xp, false);
+	CloseZip();
   } // end of Close
 
 /******************************************************************/

storage/connect/plgdbutl.cpp

@@ -939,7 +939,7 @@ int PlugCloseFile(PGLOBAL g __attribute__((unused)), PFBLOCK fp, bool all)
 #endif   // LIBXML2_SUPPORT
 #ifdef ZIP_SUPPORT
 		case TYPE_FB_ZIP:
-			((PZIPFAM)fp->File)->close();
+			((ZIPUTIL*)fp->File)->close();
 			fp->Memory = NULL;
 			fp->Mode = MODE_ANY;
 			fp->Count = 0;

storage/connect/plgxml.cpp

@@ -30,19 +30,51 @@ PXDOC GetLibxmlDoc(PGLOBAL g, char *nsl, char *nsdf,
 /*  XMLDOCUMENT constructor.                                      */
 /******************************************************************/
 XMLDOCUMENT::XMLDOCUMENT(char *nsl, char *nsdf, char *enc)
-  {
+{
-  Namespaces = NULL;
+#if defined(ZIP_SUPPORT)
+	zip = NULL;
+#else   // !ZIP_SUPPORT
+	zip = false;
+#endif  // !ZIP_SUPPORT
+	Namespaces = NULL;
   Encoding = enc;
   Nslist = nsl;
   DefNs = nsdf;
-  } // end of XMLDOCUMENT constructor
+} // end of XMLDOCUMENT constructor
+
+/******************************************************************/
+/*  Initialize zipped file processing.                            */
+/******************************************************************/
+bool XMLDOCUMENT::InitZip(PGLOBAL g, char *entry)
+{
+#if defined(ZIP_SUPPORT)
+	bool mul = (entry) ? strchr(entry, '*') || strchr(entry, '?') : false;
+	zip = new(g) ZIPUTIL(entry, mul);
+	return zip == NULL;
+#else   // !ZIP_SUPPORT
+	sprintf(g->Message, MSG(NO_FEAT_SUPPORT), "ZIP");
+	return true;
+#endif  // !ZIP_SUPPORT
+} // end of InitZip
+
+/******************************************************************/
+/*  Make the namespace structure list.                            */
+/******************************************************************/
+char* XMLDOCUMENT::GetMemDoc(PGLOBAL g, char *fn)
+{
+#if defined(ZIP_SUPPORT)
+	return (zip->OpenTable(g, MODE_ANY, fn)) ? NULL : zip->memory;
+#else   // !ZIP_SUPPORT
+	return NULL;
+#endif  // !ZIP_SUPPORT
+} // end of GetMemDoc
 
 /******************************************************************/
 /*  Make the namespace structure list.                            */
 /******************************************************************/
 bool XMLDOCUMENT::MakeNSlist(PGLOBAL g)
-  {
+{
-  char *prefix, *href, *next = Nslist;
+	char *prefix, *href, *next = Nslist;
   PNS   nsp, *ppns = &Namespaces;
 
   while (next) {
@@ -83,6 +115,19 @@ bool XMLDOCUMENT::MakeNSlist(PGLOBAL g)
   return false;
   } // end of MakeNSlist
 
+/******************************************************************/
+/*  Close ZIP file.                                               */
+/******************************************************************/
+void XMLDOCUMENT::CloseZip(void)
+{
+#if defined(ZIP_SUPPORT)
+	if (zip) {
+		zip->close();
+		zip = NULL;
+	}	// endif zip
+#endif   //	ZIP_SUPPORT
+} // end of CloseZip
+
 /******************************************************************/
 /*  XMLNODE constructor.                                          */
 /******************************************************************/

storage/connect/plgxml.h

@@ -1,3 +1,7 @@
+#if defined(ZIP_SUPPORT)
+#include "filamzip.h"
+#endif   //	ZIP_SUPPORT
+
 /******************************************************************/
 /*  Dual XML implementation base classes defines.                 */
 /******************************************************************/
@@ -72,8 +76,8 @@ class XMLDOCUMENT : public BLOCK {
   virtual void    SetNofree(bool b) = 0;
 
   // Methods
-  virtual bool    Initialize(PGLOBAL) = 0;
+	virtual bool    Initialize(PGLOBAL, char *, bool) = 0;
-  virtual bool    ParseFile(char *) = 0;
+  virtual bool    ParseFile(PGLOBAL, char *) = 0;
   virtual bool    NewDoc(PGLOBAL, char *) = 0;
   virtual void    AddComment(PGLOBAL, char *) = 0;
   virtual PXNODE  GetRoot(PGLOBAL) = 0;
@@ -91,8 +95,16 @@ class XMLDOCUMENT : public BLOCK {
 
   // Utility
   bool  MakeNSlist(PGLOBAL g);
+	bool  InitZip(PGLOBAL g, char *entry);
+	char *GetMemDoc(PGLOBAL g, char *fn);
+	void  CloseZip(void);
 
   // Members
+#if defined(ZIP_SUPPORT)
+	ZIPUTIL *zip;													 /* Used for zipped file  */
+#else   // !ZIP_SUPPORT
+	bool     zip;													 /* Always false          */
+#endif  //	!ZIP_SUPPORT
   PNS   Namespaces;                      /* To the namespaces     */
   char *Encoding;                        /* The document encoding */
   char *Nslist;                          /* Namespace list        */

storage/connect/tabdos.cpp

@@ -101,6 +101,7 @@ DOSDEF::DOSDEF(void)
   Recfm = RECFM_VAR;
   Mapped = false;
 	Zipped = false;
+	Mulentries = false;
 	Padded = false;
   Huge = false;
   Accept = false;
@@ -131,12 +132,13 @@ bool DOSDEF::DefineAM(PGLOBAL g, LPCSTR am, int)
              : (am && (*am == 'B' || *am == 'b')) ? "B"
              : (am && !stricmp(am, "DBF"))        ? "D" : "V";
 
-	if (*dfm != 'D')
+	if ((Zipped = GetBoolCatInfo("Zipped", false)))
-		Zipped = GetBoolCatInfo("Zipped", false);
+		Mulentries = ((Entry = GetStringCatInfo(g, "Entry", NULL)))
+			         ? strchr(Entry, '*') || strchr(Entry, '?')
+			         : GetBoolCatInfo("Mulentries", false);
 
   Desc = Fn = GetStringCatInfo(g, "Filename", NULL);
   Ofn = GetStringCatInfo(g, "Optname", Fn);
-	Entry = GetStringCatInfo(g, "Entry", NULL);
   GetCharCatInfo("Recfm", (PSZ)dfm, buf, sizeof(buf));
   Recfm = (toupper(*buf) == 'F') ? RECFM_FIX :
           (toupper(*buf) == 'B') ? RECFM_BIN :
@@ -344,14 +346,16 @@ PTDB DOSDEF::GetTable(PGLOBAL g, MODE mode)
   /*********************************************************************/
 	if (Zipped) {
 #if defined(ZIP_SUPPORT)
-		if (Recfm == RECFM_VAR)
+		if (Recfm == RECFM_VAR) {
-		  txfp = new(g) ZIPFAM(this);
+			txfp = new(g)ZIPFAM(this);
-		else
+			tdbp = new(g)TDBDOS(this, txfp);
-			txfp = new(g) ZPXFAM(this);
+		} else {
+			txfp = new(g)ZPXFAM(this);
+			tdbp = new(g)TDBFIX(this, txfp);
+		} // endif Recfm
 
-		tdbp = new(g) TDBDOS(this, txfp);
 #else   // !ZIP_SUPPORT
-		strcpy(g->Message, "ZIP not supported");
+		sprintf(g->Message, MSG(NO_FEAT_SUPPORT), "ZIP");
 		return NULL;
 #endif  // !ZIP_SUPPORT
 	} else if (Recfm == RECFM_DBF) {
@@ -559,7 +563,7 @@ int TDBDOS::ResetTableOpt(PGLOBAL g, bool dop, bool dox)
         Txfp->Reset();
         ((PZLBFAM)Txfp)->SetOptimized(false);
 #endif   // GZ_SUPPORT
-      } else if (Txfp->GetAmType() == TYPE_AM_BLK)
+			} else if (Txfp->GetAmType() == TYPE_AM_BLK)
         Txfp = new(g) DOSFAM((PDOSDEF)To_Def);
 
       Txfp->SetTdbp(this);
@@ -630,7 +634,12 @@ int TDBDOS::MakeBlockValues(PGLOBAL g)
   defp->SetOptimized(0);
 
   // Estimate the number of needed blocks
-  block = (int)((MaxSize + (int)nrec - 1) / (int)nrec);
+	if ((block = (int)((MaxSize + (int)nrec - 1) / (int)nrec)) < 2) {
+		// This may be wrong to do in some cases
+		defp->RemoveOptValues(g);
+		strcpy(g->Message, MSG(TABLE_NOT_OPT));
+		return RC_INFO;                   // Not to be optimized
+	}	// endif block
 
   // We have to use local variables because Txfp->CurBlk is set
   // to Rows+1 by unblocked variable length table access methods.
@@ -973,13 +982,14 @@ bool TDBDOS::GetBlockValues(PGLOBAL g)
   PCOLDEF    cdp;
   PDOSDEF    defp = (PDOSDEF)To_Def;
   PCATLG     cat = defp->GetCat();
+	PDBUSER    dup = PlgGetUser(g);
 
 #if 0
   if (Mode == MODE_INSERT && Txfp->GetAmType() == TYPE_AM_DOS)
     return false;
 #endif   // __WIN__
 
-  if (defp->Optimized)
+	if (defp->Optimized || !(dup->Check & CHK_OPT))
     return false;                   // Already done or to be redone
 
   if (Ftype == RECFM_VAR || defp->Compressed == 2) {

storage/connect/tabdos.h

@@ -28,7 +28,7 @@ class DllExport DOSDEF : public TABDEF {  /* Logical table description */
   friend class TDBFIX;
   friend class TXTFAM;
   friend class DBFBASE;
-	friend class ZIPFAM;
+	friend class ZIPUTIL;
  public:
   // Constructor
   DOSDEF(void);
@@ -41,7 +41,9 @@ class DllExport DOSDEF : public TABDEF {  /* Logical table description */
   virtual bool        IsHuge(void) {return Huge;}
   PSZ     GetFn(void) {return Fn;}
   PSZ     GetOfn(void) {return Ofn;}
-  void    SetBlock(int block) {Block = block;}
+	PSZ     GetEntry(void) {return Entry;}
+	bool    GetMul(void) {return Mulentries;}
+	void    SetBlock(int block) {Block = block;}
   int     GetBlock(void) {return Block;}
   int     GetLast(void) {return Last;}
   void    SetLast(int last) {Last = last;}
@@ -58,9 +60,9 @@ class DllExport DOSDEF : public TABDEF {  /* Logical table description */
   int    *GetTo_Pos(void) {return To_Pos;}
 
   // Methods
-  virtual int  Indexable(void)
+	virtual int  Indexable(void)
-          {return (!Multiple && !Zipped && Compressed != 1) ? 1 : 0;}
+  	{return (!Multiple && !Mulentries && Compressed != 1) ? 1 : 0;}
-  virtual bool DeleteIndexFile(PGLOBAL g, PIXDEF pxdf);
+	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);
@@ -78,6 +80,7 @@ class DllExport DOSDEF : public TABDEF {  /* Logical table description */
   RECFM   Recfm;              /* 0:VAR, 1:FIX, 2:BIN, 3:VCT, 6:DBF     */
   bool    Mapped;             /* 0: disk file, 1: memory mapped file   */
 	bool    Zipped;             /* true for zipped table file            */
+	bool    Mulentries;         /* true for multiple entries             */
 	bool    Padded;             /* true for padded table file            */
   bool    Huge;               /* true for files larger than 2GB        */
   bool    Accept;             /* true if wrong lines are accepted      */

storage/connect/tabfmt.cpp

@@ -177,9 +177,14 @@ PQRYRES CSVColumns(PGLOBAL g, char *dp, PTOS topt, bool info)
 		htrc("File %s Sep=%c Qot=%c Header=%d maxerr=%d\n",
 		SVP(tdp->Fn), tdp->Sep, tdp->Qot, tdp->Header, tdp->Maxerr);
 
-	if (tdp->Zipped)
+	if (tdp->Zipped) {
-		tdbp = new(g) TDBCSV(tdp, new(g) ZIPFAM(tdp));
+#if defined(ZIP_SUPPORT)
-	else
+		tdbp = new(g)TDBCSV(tdp, new(g)ZIPFAM(tdp));
+#else   // !ZIP_SUPPORT
+		sprintf(g->Message, MSG(NO_FEAT_SUPPORT), "ZIP");
+		return NULL;
+#endif  // !ZIP_SUPPORT
+	} else
 		tdbp = new(g) TDBCSV(tdp, new(g) DOSFAM(tdp));
 
 	tdbp->SetMode(MODE_READ);

storage/connect/tabjson.cpp

@@ -127,9 +127,14 @@ PQRYRES JSONColumns(PGLOBAL g, char *db, PTOS topt, bool info)
           tdp->Fn, tdp->Objname, tdp->Pretty, lvl);
 
   if (tdp->Pretty == 2) {
-		if (tdp->Zipped)
+		if (tdp->Zipped) {
-      tjsp = new(g) TDBJSON(tdp, new(g) ZIPFAM(tdp));
+#if defined(ZIP_SUPPORT)
-		else
+			tjsp = new(g) TDBJSON(tdp, new(g) ZIPFAM(tdp));
+#else   // !ZIP_SUPPORT
+			sprintf(g->Message, MSG(NO_FEAT_SUPPORT), "ZIP");
+			return NULL;
+#endif  // !ZIP_SUPPORT
+		} else
 		  tjsp = new(g) TDBJSON(tdp, new(g) MAPFAM(tdp));
 
     if (tjsp->MakeDocument(g))
@@ -144,9 +149,14 @@ PQRYRES JSONColumns(PGLOBAL g, char *db, PTOS topt, bool info)
 
     tdp->Ending = GetIntegerTableOption(g, topt, "Ending", CRLF);
 
-		if (tdp->Zipped)
+		if (tdp->Zipped) {
-			tjnp = new(g) TDBJSN(tdp, new(g) ZIPFAM(tdp));
+#if defined(ZIP_SUPPORT)
-		else
+			tjnp = new(g)TDBJSN(tdp, new(g)ZIPFAM(tdp));
+#else   // !ZIP_SUPPORT
+			sprintf(g->Message, MSG(NO_FEAT_SUPPORT), "ZIP");
+			return NULL;
+#endif  // !ZIP_SUPPORT
+		} else
 			tjnp = new(g) TDBJSN(tdp, new(g) DOSFAM(tdp));
 
     tjnp->SetMode(MODE_READ);
@@ -467,9 +477,14 @@ PTDB JSONDEF::GetTable(PGLOBAL g, MODE m)
 		((TDBJSN*)tdbp)->G = g;
 #endif
 	} else {
-		if (Zipped)
+		if (Zipped)	{
-			txfp = new(g) ZIPFAM(this);
+#if defined(ZIP_SUPPORT)
-		else
+			txfp = new(g)ZIPFAM(this);
+#else   // !ZIP_SUPPORT
+			sprintf(g->Message, MSG(NO_FEAT_SUPPORT), "ZIP");
+			return NULL;
+#endif  // !ZIP_SUPPORT
+		} else
 			txfp = new(g) MAPFAM(this);
 
     tdbp = new(g) TDBJSON(this, txfp);

storage/connect/tabxml.cpp

@@ -1,9 +1,9 @@
 /************* Tabxml C++ Program Source Code File (.CPP) **************/
 /* PROGRAM NAME: TABXML                                                */
 /* -------------                                                       */
-/*  Version 2.8                                                        */
+/*  Version 2.9                                                        */
 /*                                                                     */
-/*  Author Olivier BERTRAND          2007 - 2015                       */
+/*  Author Olivier BERTRAND          2007 - 2016                       */
 /*                                                                     */
 /*  This program are the XML tables classes using MS-DOM or libxml2.   */
 /***********************************************************************/
@@ -159,6 +159,8 @@ PQRYRES XMLColumns(PGLOBAL g, char *db, char *tab, PTOS topt, bool info)
   tdp->Fn = fn;
   tdp->Database = SetPath(g, db);
   tdp->Tabname = tab;
+	tdp->Zipped = GetBooleanTableOption(g, topt, "Zipped", false);
+	tdp->Entry = GetStringTableOption(g, topt, "Entry", NULL);
 
   if (!(op = GetStringTableOption(g, topt, "Xmlsup", NULL)))
 #if defined(__WIN__)
@@ -209,7 +211,8 @@ PQRYRES XMLColumns(PGLOBAL g, char *db, char *tab, PTOS topt, bool info)
 
     while (true) {
       if (!vp->atp &&
-          !(node = (vp->nl) ? vp->nl->GetItem(g, vp->k++, node) : NULL))
+				!(node = (vp->nl) ? vp->nl->GetItem(g, vp->k++, tdp->Usedom ? node : NULL)
+				                  : NULL))
         if (j) {
           vp = lvlp[--j];
 
@@ -259,7 +262,8 @@ PQRYRES XMLColumns(PGLOBAL g, char *db, char *tab, PTOS topt, bool info)
         if (j < lvl && ok) {
           vp = lvlp[j+1];
           vp->k = 0;
-          vp->atp = node->GetAttribute(g, NULL);
+					vp->pn = node;
+					vp->atp = node->GetAttribute(g, NULL);
           vp->nl = node->GetChildElements(g);
 
           if (tdp->Usedom && vp->nl->GetLength() == 1) {
@@ -270,7 +274,7 @@ PQRYRES XMLColumns(PGLOBAL g, char *db, char *tab, PTOS topt, bool info)
 
           if (vp->atp || vp->b) {
             if (!vp->atp)
-              node = vp->nl->GetItem(g, vp->k++, node);
+							node = vp->nl->GetItem(g, vp->k++, tdp->Usedom ? node : NULL);
 
 						strncat(fmt, colname, XLEN(fmt));
 						strncat(fmt, "/", XLEN(fmt));
@@ -429,11 +433,14 @@ XMLDEF::XMLDEF(void)
   DefNs = NULL;
   Attrib = NULL;
   Hdattr = NULL;
+	Entry = NULL;
   Coltype = 1;
   Limit = 0;
   Header = 0;
   Xpand = false;
   Usedom = false;
+	Zipped = false;
+	Mulentries = false;
   } // end of XMLDEF constructor
 
 /***********************************************************************/
@@ -512,7 +519,14 @@ bool XMLDEF::DefineAM(PGLOBAL g, LPCSTR am, int poff)
   // Get eventual table node attribute
   Attrib = GetStringCatInfo(g, "Attribute", NULL);
   Hdattr = GetStringCatInfo(g, "HeadAttr", NULL);
-  return false;
+
+	// Specific for zipped files
+	if ((Zipped = GetBoolCatInfo("Zipped", false)))
+		Mulentries = ((Entry = GetStringCatInfo(g, "Entry", NULL)))
+		? strchr(Entry, '*') || strchr(Entry, '?')
+		: GetBoolCatInfo("Mulentries", false);
+
+	return false;
   } // end of DefineAM
 
 /***********************************************************************/
@@ -552,6 +566,7 @@ TDBXML::TDBXML(PXMLDEF tdp) : TDBASE(tdp)
   Xfile = tdp->Fn;
   Enc = tdp->Encoding;
   Tabname = tdp->Tabname;
+#if 0 // why all these?
   Rowname = (tdp->Rowname) ? tdp->Rowname : NULL;
   Colname = (tdp->Colname) ? tdp->Colname : NULL;
   Mulnode = (tdp->Mulnode) ? tdp->Mulnode : NULL;
@@ -560,10 +575,22 @@ TDBXML::TDBXML(PXMLDEF tdp) : TDBASE(tdp)
   DefNs = (tdp->DefNs) ? tdp->DefNs : NULL;
   Attrib = (tdp->Attrib) ? tdp->Attrib : NULL;
   Hdattr = (tdp->Hdattr) ? tdp->Hdattr : NULL;
-  Coltype = tdp->Coltype;
+#endif // 0
+	Rowname = tdp->Rowname;
+	Colname = tdp->Colname;
+	Mulnode = tdp->Mulnode;
+	XmlDB = tdp->XmlDB;
+	Nslist = tdp->Nslist;
+	DefNs = tdp->DefNs;
+	Attrib = tdp->Attrib;
+	Hdattr = tdp->Hdattr;
+	Entry = tdp->Entry;
+	Coltype = tdp->Coltype;
   Limit = tdp->Limit;
   Xpand = tdp->Xpand;
-  Changed = false;
+	Zipped = tdp->Zipped;
+	Mulentries = tdp->Mulentries;
+	Changed = false;
   Checked = false;
   NextSame = false;
   NewRow = false;
@@ -605,10 +632,13 @@ TDBXML::TDBXML(PTDBXML tdbp) : TDBASE(tdbp)
   DefNs = tdbp->DefNs;
   Attrib = tdbp->Attrib;
   Hdattr = tdbp->Hdattr;
-  Coltype = tdbp->Coltype;
+	Entry = tdbp->Entry;
+	Coltype = tdbp->Coltype;
   Limit = tdbp->Limit;
   Xpand = tdbp->Xpand;
-  Changed = tdbp->Changed;
+	Zipped = tdbp->Zipped;
+	Mulentries = tdbp->Mulentries;
+	Changed = tdbp->Changed;
   Checked = tdbp->Checked;
   NextSame = tdbp->NextSame;
   NewRow = tdbp->NewRow;
@@ -686,7 +716,7 @@ int TDBXML::LoadTableFile(PGLOBAL g, char *filename)
   /*********************************************************************/
   /*  Firstly we check whether this file have been already loaded.     */
   /*********************************************************************/
-  if (Mode == MODE_READ || Mode == MODE_ANY)
+  if ((Mode == MODE_READ || Mode == MODE_ANY) && !Zipped) 
     for (fp = dup->Openlist; fp; fp = fp->Next)
       if (fp->Type == type && fp->Length && fp->Count)
         if (!stricmp(fp->Fname, filename))
@@ -708,7 +738,7 @@ int TDBXML::LoadTableFile(PGLOBAL g, char *filename)
       return RC_FX;
 
     // Initialize the implementation
-    if (Docp->Initialize(g)) {
+    if (Docp->Initialize(g, Entry, Zipped)) {
       sprintf(g->Message, MSG(INIT_FAILED), (Usedom) ? "DOM" : "libxml2");
       return RC_FX;
       } // endif init
@@ -717,7 +747,7 @@ int TDBXML::LoadTableFile(PGLOBAL g, char *filename)
       htrc("TDBXML: parsing %s rc=%d\n", filename, rc);
 
     // Parse the XML file
-    if (Docp->ParseFile(filename)) {
+    if (Docp->ParseFile(g, filename)) {
       // Does the file exist?
       int h= global_open(g, MSGID_NONE, filename, _O_RDONLY);
 

storage/connect/tabxml.h

@@ -1,7 +1,7 @@
 /*************** Tabxml H Declares Source Code File (.H) ***************/
-/*  Name: TABXML.H    Version 1.6                                      */
+/*  Name: TABXML.H    Version 1.7                                      */
 /*                                                                     */
-/*  (C) Copyright to the author Olivier BERTRAND          2007-2015    */
+/*  (C) Copyright to the author Olivier BERTRAND          2007-2016    */
 /*                                                                     */
 /*  This file contains the XML table classes declares.                 */
 /***********************************************************************/
@@ -42,12 +42,15 @@ class DllExport XMLDEF : public TABDEF {  /* Logical table description */
   char   *DefNs;                  /* Dummy name of default namespace   */
   char   *Attrib;                 /* Table node attributes             */
   char   *Hdattr;                 /* Header node attributes            */
-  int     Coltype;                /* Default column type               */
+	char   *Entry;						      /* Zip entry name or pattern				 */
+	int     Coltype;                /* Default column type               */
   int     Limit;                  /* Limit of multiple values          */
   int     Header;                 /* n first rows are header rows      */
   bool    Xpand;                  /* Put multiple tags in several rows */
   bool    Usedom;                 /* True: DOM, False: libxml2         */
-  }; // end of XMLDEF
+	bool    Zipped;                 /* True: Zipped XML file(s)          */
+	bool    Mulentries;             /* True: multiple entries in zip file*/
+}; // end of XMLDEF
 
 #if defined(INCLUDE_TDBXML)
 /***********************************************************************/
@@ -122,7 +125,9 @@ class DllExport TDBXML : public TDBASE {
   bool    Bufdone;                  // True when column buffers allocated
   bool    Nodedone;                 // True when column nodes allocated
   bool    Void;                     // True if the file does not exist
-  char   *Xfile;                    // The XML file
+	bool    Zipped;                   // True if Zipped XML file(s)
+	bool    Mulentries;               // True if multiple entries in zip file
+	char   *Xfile;                    // The XML file
   char   *Enc;                      // New XML table file encoding
   char   *Tabname;                  // Name of Table node
   char   *Rowname;                  // Name of first level nodes
@@ -133,7 +138,8 @@ class DllExport TDBXML : public TDBASE {
   char   *DefNs;                    // Dummy name of default namespace
   char   *Attrib;                   // Table node attribut(s)
   char   *Hdattr;                   // Header node attribut(s)
-  int     Coltype;                  // Default column type
+	char   *Entry;						        // Zip entry name or pattern
+	int     Coltype;                  // Default column type
   int     Limit;                    // Limit of multiple values
   int     Header;                   // n first rows are header rows
   int     Multiple;                 // If multiple files