- Implementation of the Json BJSON representation.

  VAL structures replace VALUE classes in binary trees.
  These parsed binary trees are swapped and saved on file
  Swapping is to replace pointers by offsets to make it portable.
  In restoring, class pointers to functions are realloced on place.
  Making BJSON files is done by the new UDF function jfile_bjson.
  modified:   storage/connect/block.h
  modified:   storage/connect/filamtxt.cpp
  modified:   storage/connect/filamtxt.h
  modified:   storage/connect/global.h
  modified:   storage/connect/json.cpp
  modified:   storage/connect/json.h
  modified:   storage/connect/jsonudf.cpp
  modified:   storage/connect/jsonudf.h
  modified:   storage/connect/tabjson.cpp
  modified:   storage/connect/tabjson.h
  modified:   storage/connect/value.h

- Make file (record) length and map memory possibly larger than MAX_INT
  modified:   storage/connect/filamap.cpp
  modified:   storage/connect/filamvct.cpp
  modified:   storage/connect/maputil.cpp
  modified:   storage/connect/maputil.h
  modified:   storage/connect/tabdos.cpp
  modified:   storage/connect/xindex.cpp

- Make column length as bytes (not characters)
  This when making column definitions
  modified:   storage/connect/ha_connect.cc

- Change the message when making index fails
  modified:   storage/connect/ha_connect.cc

- Update tests and results to reflect recent changes
  modified:   storage/connect/mysql-test/connect/r/alter_xml.result
  modified:   storage/connect/mysql-test/connect/r/alter_xml2.result
  modified:   storage/connect/mysql-test/connect/r/jdbc_oracle.result
  modified:   storage/connect/mysql-test/connect/r/json.result
  modified:   storage/connect/mysql-test/connect/r/json_java_2.result
  modified:   storage/connect/mysql-test/connect/r/json_java_3.result
  modified:   storage/connect/mysql-test/connect/r/json_mongo_c.result
  modified:   storage/connect/mysql-test/connect/r/mongo_c.result
  modified:   storage/connect/mysql-test/connect/r/mongo_java_2.result
  modified:   storage/connect/mysql-test/connect/r/mongo_java_3.result
  modified:   storage/connect/mysql-test/connect/r/odbc_oracle.result
  modified:   storage/connect/mysql-test/connect/r/xml.result
  modified:   storage/connect/mysql-test/connect/r/xml2.result
  modified:   storage/connect/mysql-test/connect/r/xml2_html.result
  modified:   storage/connect/mysql-test/connect/r/xml2_mult.result
  modified:   storage/connect/mysql-test/connect/r/xml2_zip.result
  modified:   storage/connect/mysql-test/connect/r/xml_html.result
  modified:   storage/connect/mysql-test/connect/r/xml_mult.result
  modified:   storage/connect/mysql-test/connect/r/xml_zip.result
  modified:   storage/connect/mysql-test/connect/t/alter_xml.test
  modified:   storage/connect/mysql-test/connect/t/alter_xml2.test
  modified:   storage/connect/mysql-test/connect/t/jdbc_oracle.test
  modified:   storage/connect/mysql-test/connect/t/json.test
  modified:   storage/connect/mysql-test/connect/t/mongo_test.inc
  modified:   storage/connect/mysql-test/connect/t/odbc_oracle.test
  modified:   storage/connect/mysql-test/connect/t/xml.test
  modified:   storage/connect/mysql-test/connect/t/xml2.test
  modified:   storage/connect/mysql-test/connect/t/xml2_html.test
  modified:   storage/connect/mysql-test/connect/t/xml2_mult.test
  modified:   storage/connect/mysql-test/connect/t/xml2_zip.test
  modified:   storage/connect/mysql-test/connect/t/xml_html.test
  modified:   storage/connect/mysql-test/connect/t/xml_mult.test
  modified:   storage/connect/mysql-test/connect/t/xml_zip.test

- Typo
  modified:   storage/connect/value.cpp

52 files changed, 2668 insertions, 1595 deletions

diff --git a/storage/connect/block.h b/storage/connect/block.h
index 2ca9586ee3f..479bee373fa 100644
--- a/storage/connect/block.h
+++ b/storage/connect/block.h
@@ -1,19 +1,19 @@
 /**************** Block H Declares Source Code File (.H) ***************/
-/*  Name: BLOCK.H     Version 2.0                                      */
+/*  Name: BLOCK.H     Version 2.1                                      */
 /*                                                                     */
-/*  (C) Copyright to the author Olivier BERTRAND          1998         */
+/*  (C) Copyright to the author Olivier BERTRAND          1998 - 2020  */
 /*                                                                     */
 /*  This file contains the BLOCK pure virtual class definition.        */
 /*---------------------------------------------------------------------*/
 /*  Note: one of the main purpose of this base class is to take care   */
-/*  of the very specific way Plug handles memory allocation.           */
+/*  of the very specific way Connect handles memory allocation.        */
 /*  Instead of allocating small chunks of storage via new or malloc    */
-/*  Plug works in its private memory pool in which it does the sub-    */
+/*  Connect works in its private memory pool in which it does the sub- */
 /*  allocation using the function PlugSubAlloc. These are never freed  */
 /*  separately but when a transaction is terminated, the entire pool   */
 /*  is set to empty, resulting in a very fast and efficient allocate   */
 /*  process, no garbage collection problem, and an automatic recovery  */
-/*  procedure (via LongJump) when the memory is exhausted.             */
+/*  procedure (via throw) when the memory is exhausted.                */
 /*  For this to work new must be given two parameters, first the       */
 /*  global pointer of the Plug application, and an optional pointer to */
 /*  the memory pool to use, defaulting to NULL meaning using the Plug  */
@@ -30,6 +30,8 @@
 #define DllExport
 #endif  // !__WIN__
 
+typedef class JSON *PJSON;
+
 /***********************************************************************/
 /*  Definition of class BLOCK with its method function new.            */
 /***********************************************************************/
@@ -37,21 +39,26 @@ typedef class BLOCK *PBLOCK;
 
 class DllExport BLOCK {
  public:
-  void * operator new(size_t size, PGLOBAL g, void *p = NULL) {
-	  xtrc(256, "New BLOCK: size=%d g=%p p=%p\n", size, g, p);
-    return (PlugSubAlloc(g, p, size));
-    } // end of new
+  void *operator new(size_t size, PGLOBAL g, void *mp = NULL) {
+	  xtrc(256, "New BLOCK: size=%d g=%p p=%p\n", size, g, mp);
+		return PlugSubAlloc(g, mp, size);
+  } // end of new
+
+	void* operator new(size_t size, size_t mp) {
+		xtrc(256, "Realloc at: mp=%zd\n", mp);
+		return (void*)mp;
+	} // end of new
 
-  virtual void Printf(PGLOBAL, FILE *, uint) {}   // Produce file desc
+	virtual void Printf(PGLOBAL, FILE *, uint) {}   // Produce file desc
   virtual void Prints(PGLOBAL, char *, uint) {}   // Produce string desc
   
 #if !defined(__BORLANDC__)
   // Avoid warning C4291 by defining a matching dummy delete operator
-  void operator delete(void *, PGLOBAL, void *) {}
-  void operator delete(void *, size_t) {}
+  void operator delete(void*, PGLOBAL, void *) {}
+	//void operator delete(void*, size_t) {}
 #endif
   virtual ~BLOCK() {}
 
-  }; // end of class BLOCK
+}; // end of class BLOCK
 
 #endif   // !BLOCK_DEFINED
diff --git a/storage/connect/filamap.cpp b/storage/connect/filamap.cpp
index 6e71e1bf2cd..66cf081e5af 100644
--- a/storage/connect/filamap.cpp
+++ b/storage/connect/filamap.cpp
@@ -102,7 +102,7 @@ int MAPFAM::GetFileLength(PGLOBAL g)
 bool MAPFAM::OpenTableFile(PGLOBAL g)
   {
   char    filename[_MAX_PATH];
-  int     len;
+  size_t  len;
   MODE    mode = Tdbp->GetMode();
   PFBLOCK fp;
   PDBUSER dbuserp = (PDBUSER)g->Activityp->Aptr;
@@ -174,9 +174,9 @@ bool MAPFAM::OpenTableFile(PGLOBAL g)
       } // endif hFile
 
     /*******************************************************************/
-    /*  Get the file size (assuming file is smaller than 4 GB)         */
+    /*  Get the file size.                                             */
     /*******************************************************************/
-    len = mm.lenL;
+    len = (size_t)mm.sz.QuadPart;
     Memory = (char *)mm.memory;
 
     if (!len) {              // Empty or deleted file
diff --git a/storage/connect/filamtxt.cpp b/storage/connect/filamtxt.cpp
index ca48fc765a1..28a6894325b 100644
--- a/storage/connect/filamtxt.cpp
+++ b/storage/connect/filamtxt.cpp
@@ -1,11 +1,11 @@
 /*********** File AM Txt C++ Program Source Code File (.CPP) ***********/
 /* PROGRAM NAME: FILAMTXT                                              */
 /* -------------                                                       */
-/*  Version 1.7                                                        */
+/*  Version 1.8                                                        */
 /*                                                                     */
 /* COPYRIGHT:                                                          */
 /* ----------                                                          */
-/*  (C) Copyright to the author Olivier BERTRAND          2005-2017    */
+/*  (C) Copyright to the author Olivier BERTRAND          2005-2020    */
 /*                                                                     */
 /* WHAT THIS PROGRAM DOES:                                             */
 /* -----------------------                                             */
@@ -48,6 +48,7 @@
 #include "plgdbsem.h"
 #include "filamtxt.h"
 #include "tabdos.h"
+#include "tabjson.h"
 
 #if defined(UNIX) || defined(UNIV_LINUX)
 #include "osutil.h"
@@ -1662,3 +1663,252 @@ void BLKFAM::Rewind(void)
 //Rbuf = 0;        commented out in case we reuse last read block
   } // end of Rewind
 
+/* --------------------------- Class BINFAM -------------------------- */
+
+/***********************************************************************/
+/*  BIN GetFileLength: returns file size in number of bytes.           */
+/***********************************************************************/
+int BINFAM::GetFileLength(PGLOBAL g) {
+	int len;
+
+	if (!BStream)
+		len = TXTFAM::GetFileLength(g);
+	else
+		if ((len = _filelength(_fileno(BStream))) < 0)
+			sprintf(g->Message, MSG(FILELEN_ERROR), "_filelength", To_File);
+
+	xtrc(1, "File length=%d\n", len);
+	return len;
+} // end of GetFileLength
+
+/***********************************************************************/
+/*  Cardinality: returns table cardinality in number of rows.          */
+/*  This function can be called with a null argument to test the       */
+/*  availability of Cardinality implementation (1 yes, 0 no).          */
+/***********************************************************************/
+int BINFAM::Cardinality(PGLOBAL g) {
+	return (g) ? -1 : 0;
+} // end of Cardinality
+
+/***********************************************************************/
+/*  OpenTableFile: Open a DOS/UNIX table file using C standard I/Os.   */
+/***********************************************************************/
+bool BINFAM::OpenTableFile(PGLOBAL g) {
+	char    opmode[4], filename[_MAX_PATH];
+	MODE    mode = Tdbp->GetMode();
+	PDBUSER dbuserp = PlgGetUser(g);
+
+	switch (mode) {
+	case MODE_READ:
+		strcpy(opmode, "rb");
+		break;
+	case MODE_WRITE:
+		strcpy(opmode, "wb");
+		break;
+	default:
+		sprintf(g->Message, MSG(BAD_OPEN_MODE), mode);
+		return true;
+	} // endswitch Mode
+
+	// Now open the file stream
+	PlugSetPath(filename, To_File, Tdbp->GetPath());
+
+	if (!(BStream = PlugOpenFile(g, filename, opmode))) {
+		if (trace(1))
+			htrc("%s\n", g->Message);
+
+		return (mode == MODE_READ && errno == ENOENT)
+			? PushWarning(g, Tdbp) : true;
+	} // endif BStream
+
+	if (trace(1))
+		htrc("File %s open BStream=%p mode=%s\n", filename, BStream, opmode);
+
+	To_Fb = dbuserp->Openlist;     // Keep track of File block
+
+	/*********************************************************************/
+	/*  Allocate the line buffer.                                        */
+	/*********************************************************************/
+	return AllocateBuffer(g);
+} // end of OpenTableFile
+
+/***********************************************************************/
+/*  Allocate the line buffer. For mode Delete a bigger buffer has to   */
+/*  be allocated because is it also used to move lines into the file.  */
+/***********************************************************************/
+bool BINFAM::AllocateBuffer(PGLOBAL g) {
+	MODE mode = Tdbp->GetMode();
+
+	// Lrecl is Ok
+	Buflen = Lrecl;
+
+	if (trace(1))
+		htrc("SubAllocating a buffer of %d bytes\n", Buflen);
+
+	To_Buf = (char*)PlugSubAlloc(g, NULL, Buflen);
+	return false;
+} // end of AllocateBuffer
+
+/***********************************************************************/
+/*  GetRowID: return the RowID of last read record.                    */
+/***********************************************************************/
+int BINFAM::GetRowID(void) {
+	return Rows;
+} // end of GetRowID
+
+/***********************************************************************/
+/*  GetPos: return the position of last read record.                   */
+/***********************************************************************/
+int BINFAM::GetPos(void) {
+	return Fpos;
+} // end of GetPos
+
+/***********************************************************************/
+/*  GetNextPos: return the position of next record.                    */
+/***********************************************************************/
+int BINFAM::GetNextPos(void) {
+	return ftell(BStream);
+} // end of GetNextPos
+
+/***********************************************************************/
+/*  SetPos: Replace the table at the specified position.               */
+/***********************************************************************/
+bool BINFAM::SetPos(PGLOBAL g, int pos) {
+	Fpos = pos;
+
+	if (fseek(BStream, Fpos, SEEK_SET)) {
+		sprintf(g->Message, MSG(FSETPOS_ERROR), Fpos);
+		return true;
+	} // endif
+
+	Placed = true;
+	return false;
+} // end of SetPos
+
+/***********************************************************************/
+/*  Record file position in case of UPDATE or DELETE.                  */
+/***********************************************************************/
+bool BINFAM::RecordPos(PGLOBAL g) {
+	if ((Fpos = ftell(BStream)) < 0) {
+		sprintf(g->Message, MSG(FTELL_ERROR), 0, strerror(errno));
+		//  strcat(g->Message, " (possible wrong ENDING option value)");
+		return true;
+	} // endif Fpos
+
+	return false;
+} // end of RecordPos
+
+/***********************************************************************/
+/*  ReadBuffer: Read one line for a text file.                         */
+/***********************************************************************/
+int BINFAM::ReadBuffer(PGLOBAL g) {
+	int rc;
+
+	if (!BStream)
+		return RC_EF;
+
+	xtrc(2, "ReadBuffer: Tdbp=%p To_Line=%p Placed=%d\n",
+					Tdbp, Tdbp->GetLine(), Placed);
+
+	if (!Placed) {
+		/*******************************************************************/
+		/*  Record file position in case of UPDATE or DELETE.              */
+		/*******************************************************************/
+		if (RecordPos(g))
+			return RC_FX;
+
+		CurBlk = (int)Rows++;
+		xtrc(2, "ReadBuffer: CurBlk=%d\n", CurBlk);
+	} else
+		Placed = false;
+
+	xtrc(2, " About to read: bstream=%p To_Buf=%p Buflen=%d\n",
+						BStream, To_Buf, Buflen);
+
+	// Read the prefix giving the row length
+	if (!fread(&Recsize, sizeof(size_t), 1, BStream)) {
+		if (!feof(BStream)) {
+			strcpy(g->Message, "Error reading line prefix\n");
+			return RC_FX;
+		} else
+			return RC_EF;
+
+	} else if (Recsize > Buflen) {
+		sprintf(g->Message, "Record too big (Recsize=%zd Buflen=%d)\n", Recsize, Buflen);
+		return RC_FX;
+	}	// endif Recsize
+
+	if (fread(To_Buf, Recsize, 1, BStream)) {
+		xtrc(2, " Read: To_Buf=%p Recsize=%zd\n", To_Buf, Recsize);
+		// memcpy(Tdbp->GetLine(), To_Buf, Recsize);
+		num_read++;
+		rc = RC_OK;
+	} else if (feof(BStream)) {
+		rc = RC_EF;
+	} else {
+#if defined(__WIN__)
+		sprintf(g->Message, MSG(READ_ERROR), To_File, _strerror(NULL));
+#else
+		sprintf(g->Message, MSG(READ_ERROR), To_File, strerror(0));
+#endif
+		xtrc(2, "%s\n", g->Message);
+		rc = RC_FX;
+	} // endif's fread
+
+	xtrc(2, "ReadBuffer: rc=%d\n", rc);
+	IsRead = true;
+	return rc;
+} // end of ReadBuffer
+
+/***********************************************************************/
+/*  WriteBuffer: File write routine for BIN access method.             */
+/***********************************************************************/
+int BINFAM::WriteBuffer(PGLOBAL g) {
+	int   curpos = 0;
+	bool  moved = true;
+
+	/*********************************************************************/
+	/*  Prepare writing the line.                                        */
+	/*********************************************************************/
+	memcpy(To_Buf, Tdbp->GetLine(), Recsize);
+
+	/*********************************************************************/
+	/*  Now start the writing process.                                   */
+	/*********************************************************************/
+	if (fwrite(&Recsize, sizeof(size_t), 1, BStream) != 1) {
+		sprintf(g->Message, "Error %d writing prefix to %s",
+			errno, To_File);
+		return RC_FX;
+	} else if (fwrite(To_Buf, Recsize, 1, BStream) != 1) {
+		sprintf(g->Message, "Error %d writing %zd bytes to %s",
+			errno, Recsize, To_File);
+		return RC_FX;
+	} // endif fwrite
+
+	xtrc(1, "write done\n");
+	return RC_OK;
+} // end of WriteBuffer
+
+/***********************************************************************/
+/*  Table file close routine for DOS access method.                    */
+/***********************************************************************/
+void BINFAM::CloseTableFile(PGLOBAL g, bool abort) {
+	int rc;
+
+	Abort = abort;
+	rc = PlugCloseFile(g, To_Fb);
+	xtrc(1, "BIN Close: closing %s rc=%d\n", To_File, rc);
+	BStream = NULL;           // So we can know whether table is open
+} // end of CloseTableFile
+
+/***********************************************************************/
+/*  Rewind routine for BIN access method.                              */
+/***********************************************************************/
+void BINFAM::Rewind(void) {
+	if (BStream)  // Can be NULL when making index on void table
+		rewind(BStream);
+
+	Rows = 0;
+	OldBlk = CurBlk = -1;
+} // end of Rewind
+
diff --git a/storage/connect/filamtxt.h b/storage/connect/filamtxt.h
index 1fdae8fcd37..8c1fe5e7dbc 100644
--- a/storage/connect/filamtxt.h
+++ b/storage/connect/filamtxt.h
@@ -1,7 +1,7 @@
 /************** FilAMTxt H Declares Source Code File (.H) **************/
-/*  Name: FILAMTXT.H    Version 1.3                                    */
+/*  Name: FILAMTXT.H    Version 1.4                                    */
 /*                                                                     */
-/*  (C) Copyright to the author Olivier BERTRAND          2005-2014    */
+/*  (C) Copyright to the author Olivier BERTRAND          2005-2020    */
 /*                                                                     */
 /*  This file contains the file access method classes declares.        */
 /***********************************************************************/
@@ -15,6 +15,7 @@
 typedef class TXTFAM *PTXF;
 typedef class DOSFAM *PDOSFAM;
 typedef class BLKFAM *PBLKFAM;
+typedef class BINFAM *PBINFAM;
 typedef class DOSDEF *PDOSDEF;
 typedef class TDBDOS *PTDBDOS;
 
@@ -210,4 +211,45 @@ class DllExport BLKFAM : public DOSFAM {
   bool  Closing;              // True when closing on Update
   }; // end of class BLKFAM
 
+/***********************************************************************/
+/*  This is the DOS/UNIX Access Method class declaration for binary    */
+/*  files with variable record format (BJSON)                          */
+/***********************************************************************/
+class DllExport BINFAM : public TXTFAM {
+public:
+	// Constructor
+	BINFAM(PDOSDEF tdp) : TXTFAM(tdp) {BStream = NULL; Recsize = 0;}
+	BINFAM(PBINFAM txfp) : TXTFAM(txfp) {BStream = txfp->BStream;}
+
+	// Implementation
+	virtual AMT   GetAmType(void) {return TYPE_AM_BIN;}
+	virtual int   GetPos(void);
+	virtual int   GetNextPos(void);
+	virtual PTXF  Duplicate(PGLOBAL g) { return (PTXF)new(g) BINFAM(this); }
+
+	// Methods
+//virtual void  Reset(void) {TXTFAM::Reset();}
+	virtual int   GetFileLength(PGLOBAL g);
+	virtual int   Cardinality(PGLOBAL g);
+	virtual int   MaxBlkSize(PGLOBAL g, int s) {return s;}
+	virtual bool  AllocateBuffer(PGLOBAL g);
+	virtual int   GetRowID(void);
+	virtual bool  RecordPos(PGLOBAL g);
+	virtual bool  SetPos(PGLOBAL g, int recpos);
+	virtual int   SkipRecord(PGLOBAL g, bool header) {return 0;}
+	virtual bool  OpenTableFile(PGLOBAL g);
+	virtual int   ReadBuffer(PGLOBAL g);
+	virtual int   WriteBuffer(PGLOBAL g);
+	virtual int   DeleteRecords(PGLOBAL g, int irc) {return RC_FX;}
+	virtual void  CloseTableFile(PGLOBAL g, bool abort);
+	virtual void  Rewind(void);
+
+protected:
+//virtual int   InitDelete(PGLOBAL g, int fpos, int spos);
+
+	// Members
+	FILE *BStream;             // Points to Bin file structure
+	size_t Recsize;						 // Length of last read record
+}; // end of class BINFAM
+
 #endif // __FILAMTXT_H
diff --git a/storage/connect/filamvct.cpp b/storage/connect/filamvct.cpp
index 6d0779b150a..bf4ef8557ad 100644
--- a/storage/connect/filamvct.cpp
+++ b/storage/connect/filamvct.cpp
@@ -1327,7 +1327,7 @@ VCMFAM::VCMFAM(PVCMFAM txfp) : VCTFAM(txfp)
 bool VCMFAM::OpenTableFile(PGLOBAL g)
   {
   char    filename[_MAX_PATH];
-  int    len;
+  size_t  len;
   MODE    mode = Tdbp->GetMode();
   PFBLOCK fp = NULL;
   PDBUSER dbuserp = (PDBUSER)g->Activityp->Aptr;
@@ -1421,9 +1421,9 @@ bool VCMFAM::OpenTableFile(PGLOBAL g)
       } // endif hFile
 
     /*******************************************************************/
-    /*  Get the file size (assuming file is smaller than 4 GB)         */
+    /*  Get the file size.                                             */
     /*******************************************************************/
-    len = mm.lenL;
+    len = (size_t)mm.sz.QuadPart;
     Memory = (char *)mm.memory;
 
     if (!len) {             // Empty or deleted file
@@ -2762,7 +2762,7 @@ bool VMPFAM::OpenTableFile(PGLOBAL g)
 bool VMPFAM::MapColumnFile(PGLOBAL g, MODE mode, int i)
   {
   char    filename[_MAX_PATH];
-  int    len;
+  size_t  len;
   HANDLE  hFile;
   MEMMAP  mm;
   PFBLOCK fp;
@@ -2816,7 +2816,7 @@ bool VMPFAM::MapColumnFile(PGLOBAL g, MODE mode, int i)
     /*****************************************************************/
     /*  Get the file size (assuming file is smaller than 4 GB)       */
     /*****************************************************************/
-    len = mm.lenL;
+    len = (size_t)mm.sz.QuadPart;
     Memcol[i] = (char *)mm.memory;
 
     if (!len) {             // Empty or deleted file
diff --git a/storage/connect/global.h b/storage/connect/global.h
index d17620861fa..294ad0e1d7b 100644
--- a/storage/connect/global.h
+++ b/storage/connect/global.h
@@ -240,10 +240,14 @@ inline void* MakePtr(void* memp, size_t offset) {
 /* This routine makes an offset from a pointer new format.             */
 /***********************************************************************/
 inline size_t MakeOff(void* memp, void* ptr) {
+	if (ptr) {
 #if defined(_DEBUG)
-	assert(ptr > memp);
+		assert(ptr > memp);
 #endif   // _DEBUG
-	return ((!ptr) ? 0 : (size_t)((char*)ptr - (size_t)memp));
+		return (size_t)((char*)ptr - (size_t)memp);
+	} else
+		return 0;
+
 } /* end of MakeOff */
 
 /*-------------------------- End of Global.H --------------------------*/
diff --git a/storage/connect/ha_connect.cc b/storage/connect/ha_connect.cc
index a3dfc50562d..859d50b9a2c 100644
--- a/storage/connect/ha_connect.cc
+++ b/storage/connect/ha_connect.cc
@@ -1574,6 +1574,7 @@ void *ha_connect::GetColumnOption(PGLOBAL g, void *field, PCOLINFO pcf)
 
   // Now get column information
   pcf->Name= (char*)fp->field_name;
+	chset = (char*)fp->charset()->name;
 
   if (fop && fop->special) {
     pcf->Fieldfmt= (char*)fop->special;
@@ -1584,8 +1585,15 @@ void *ha_connect::GetColumnOption(PGLOBAL g, void *field, PCOLINFO pcf)
   pcf->Scale= 0;
   pcf->Opt= (fop) ? (int)fop->opt : 0;
 
-  if ((pcf->Length= fp->field_length) < 0)
-    pcf->Length= 256;            // BLOB?
+	if (fp->field_length >= 0) {
+		pcf->Length = fp->field_length;
+
+		// length is bytes for Connect, not characters
+		if (!strnicmp(chset, "utf8", 4))
+			pcf->Length /= 3;
+
+	} else
+		pcf->Length= 256;            // BLOB?
 
   pcf->Precision= pcf->Length;
 
@@ -1602,8 +1610,6 @@ void *ha_connect::GetColumnOption(PGLOBAL g, void *field, PCOLINFO pcf)
     pcf->Fieldfmt= NULL;
   } // endif fop
 
-  chset= (char *)fp->charset()->name;
-
 	if (!strcmp(chset, "binary"))
 		v = 'B';		// Binary string
 
@@ -4940,11 +4946,11 @@ int ha_connect::external_lock(THD *thd, int lock_type)
             // 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;
-							//my_message(ER_UNKNOWN_ERROR, g->Message, MYF(0));
-							//rc= HA_ERR_INTERNAL_ERROR;
+              //push_warning(thd, Sql_condition::WARN_LEVEL_WARN, 
+              //                  0, g->Message);
+              //rc= 0;
+							my_message(ER_TOO_MANY_KEYS, g->Message, MYF(0));
+							rc= HA_ERR_INDEX_CORRUPT;
 						} // endif MakeIndex
       
         } else if (tdbp->GetDef()->Indexable() == 3) {
diff --git a/storage/connect/json.cpp b/storage/connect/json.cpp
index ea3ea18da0b..ce3ddd865a5 100644
--- a/storage/connect/json.cpp
+++ b/storage/connect/json.cpp
@@ -1,7 +1,7 @@
 /*************** json CPP Declares Source Code File (.H) ***************/
-/*  Name: json.cpp   Version 1.4                                       */
+/*  Name: json.cpp   Version 1.5                                       */
 /*                                                                     */
-/*  (C) Copyright to the author Olivier BERTRAND          2014 - 2017  */
+/*  (C) Copyright to the author Olivier BERTRAND          2014 - 2020  */
 /*                                                                     */
 /*  This file contains the JSON classes functions.                     */
 /***********************************************************************/
@@ -21,7 +21,7 @@
 #include "plgdbsem.h"
 #include "json.h"
 
-#define ARGS       MY_MIN(24,len-i),s+MY_MAX(i-3,0)
+#define ARGS       MY_MIN(24,(int)len-i),s+MY_MAX(i-3,0)
 
 #if defined(__WIN__)
 #define EL  "\r\n"
@@ -38,16 +38,16 @@
 
 class SE_Exception {
 public:
-	SE_Exception(unsigned int n, PEXCEPTION_RECORD p) : nSE(n), eRec(p) {}
-	~SE_Exception() {}
+  SE_Exception(unsigned int n, PEXCEPTION_RECORD p) : nSE(n), eRec(p) {}
+  ~SE_Exception() {}
 
-	unsigned int      nSE;
-	PEXCEPTION_RECORD eRec;
+  unsigned int      nSE;
+  PEXCEPTION_RECORD eRec;
 };  // end of class SE_Exception
 
 void trans_func(unsigned int u, _EXCEPTION_POINTERS* pExp)
 {
-	throw SE_Exception(u, pExp->ExceptionRecord);
+  throw SE_Exception(u, pExp->ExceptionRecord);
 } // end of trans_func
 
 char *GetExceptionDesc(PGLOBAL g, unsigned int e);
@@ -58,46 +58,58 @@ char *GetJsonNull(void);
 /***********************************************************************/
 /* IsNum: check whether this string is all digits.                     */
 /***********************************************************************/
-bool IsNum(PSZ s)
-{
-	for (char *p = s; *p; p++)
-		if (*p == ']')
-			break;
-		else if (!isdigit(*p) || *p == '-')
-			return false;
+bool IsNum(PSZ s) {
+  for (char* p = s; *p; p++)
+    if (*p == ']')
+      break;
+    else if (!isdigit(*p) || *p == '-')
+      return false;
 
-	return true;
-}	// end of IsNum
+  return true;
+} // end of IsNum
 
 /***********************************************************************/
 /* NextChr: return the first found '[' or Sep pointer.                 */
 /***********************************************************************/
-char *NextChr(PSZ s, char sep)
+char* NextChr(PSZ s, char sep)
 {
-	char *p1 = strchr(s, '[');
-	char *p2 = strchr(s, sep);
+  char* p1 = strchr(s, '[');
+  char* p2 = strchr(s, sep);
 
-	if (!p2)
-		return p1;
-	else if (p1)
-		return MY_MIN(p1, p2);
+  if (!p2)
+    return p1;
+  else if (p1)
+    return MY_MIN(p1, p2);
 
-	return p2;
-}	// end of NextChr
+  return p2;
+} // end of NextChr
 
+/***********************************************************************/
+/* Allocate a VAL structure, make sure common field and Nd are zeroed. */
+/***********************************************************************/
+PVL AllocVal(PGLOBAL g, JTYP type)
+{
+  PVL vlp = (PVL)PlugSubAlloc(g, NULL, sizeof(VAL));
+
+  vlp->LLn = 0;
+  vlp->Nd = 0;
+  vlp->Type = type;
+  return vlp;
+} // end of AllocVal
 
 /***********************************************************************/
 /* Parse a json string.                                                */
 /* Note: when pretty is not known, the caller set pretty to 3.         */
 /***********************************************************************/
-PJSON ParseJson(PGLOBAL g, char *s, int len, int *ptyp, bool *comma)
+PJSON ParseJson(PGLOBAL g, char* s, size_t len, int* ptyp, bool* comma)
 {
-	int   i, pretty = (ptyp) ? *ptyp : 3;
-	bool  b = false, pty[3] = {true,true,true};
-  PJSON jsp = NULL, jp = NULL;
+  int   i, pretty = (ptyp) ? *ptyp : 3;
+  bool  b = false, pty[3] = { true,true,true };
+  PJSON jsp = NULL;
+  PJDOC jdp = NULL;
 
-	if (trace(1))
-		htrc("ParseJson: s=%.10s len=%d\n", s, len);
+  if (trace(1))
+    htrc("ParseJson: s=%.10s len=%zd\n", s, len);
 
   if (!s || !len) {
     strcpy(g->Message, "Void JSON object");
@@ -105,116 +117,388 @@ PJSON ParseJson(PGLOBAL g, char *s, int len, int *ptyp, bool *comma)
   } else if (comma)
     *comma = false;
 
-	// Trying to guess the pretty format
-	if (s[0] == '[' && (s[1] == '\n' || (s[1] == '\r' && s[2] == '\n')))
-		pty[0] = false;
-
-	try {
-		jp = new(g) JSON();
-		jp->s = s;
-		jp->len = len;
-		jp->pty = pty;
-
-		for (i = 0; i < jp->len; i++)
-			switch (s[i]) {
-				case '[':
-					if (jsp)
-						jsp = jp->ParseAsArray(g, i, pretty, ptyp);
-					else
-						jsp = jp->ParseArray(g, ++i);
-
-					break;
-				case '{':
-					if (jsp)
-						jsp = jp->ParseAsArray(g, i, pretty, ptyp);
-					else if (!(jsp = jp->ParseObject(g, ++i)))
-						throw 2;
-
-					break;
-				case ' ':
-				case '\t':
-				case '\n':
-				case '\r':
-					break;
-				case ',':
-					if (jsp && (pretty == 1 || pretty == 3)) {
-						if (comma)
-							*comma = true;
-
-						pty[0] = pty[2] = false;
-						break;
-					} // endif pretty
-
-					sprintf(g->Message, "Unexpected ',' (pretty=%d)", pretty);
-					throw 3;
-				case '(':
-					b = true;
-					break;
-				case ')':
-					if (b) {
-						b = false;
-						break;
-					} // endif b
-
-				default:
-					if (jsp)
-						jsp = jp->ParseAsArray(g, i, pretty, ptyp);
-					else if (!(jsp = jp->ParseValue(g, i)))
-						throw 4;
-
-					break;
-			}; // endswitch s[i]
-
-		if (!jsp)
-			sprintf(g->Message, "Invalid Json string '%.*s'", MY_MIN(len, 50), s);
-		else if (ptyp && pretty == 3) {
-			*ptyp = 3;     // Not recognized pretty
-
-			for (i = 0; i < 3; i++)
-				if (pty[i]) {
-					*ptyp = i;
-					break;
-				} // endif pty
-
-		} // endif ptyp
-
-	} catch (int n) {
-		if (trace(1))
-			htrc("Exception %d: %s\n", n, g->Message);
-		jsp = NULL;
-	} catch (const char *msg) {
-		strcpy(g->Message, msg);
-		jsp = NULL;
-	} // end catch
-
-	return jsp;
+  // Trying to guess the pretty format
+  if (s[0] == '[' && (s[1] == '\n' || (s[1] == '\r' && s[2] == '\n')))
+    pty[0] = false;
+
+  try {
+    jdp = new(g) JDOC;
+    jdp->s = s;
+    jdp->len = len;
+    jdp->pty = pty;
+
+    for (i = 0; i < jdp->len; i++)
+      switch (s[i]) {
+      case '[':
+        if (jsp)
+          jsp = jdp->ParseAsArray(g, i, pretty, ptyp);
+        else
+          jsp = jdp->ParseArray(g, ++i);
+
+        break;
+      case '{':
+        if (jsp)
+          jsp = jdp->ParseAsArray(g, i, pretty, ptyp);
+        else if (!(jsp = jdp->ParseObject(g, ++i)))
+          throw 2;
+
+        break;
+      case ' ':
+      case '\t':
+      case '\n':
+      case '\r':
+        break;
+      case ',':
+        if (jsp && (pretty == 1 || pretty == 3)) {
+          if (comma)
+            *comma = true;
+
+          pty[0] = pty[2] = false;
+          break;
+        } // endif pretty
+
+        sprintf(g->Message, "Unexpected ',' (pretty=%d)", pretty);
+        throw 3;
+      case '(':
+        b = true;
+        break;
+      case ')':
+        if (b) {
+          b = false;
+          break;
+        } // endif b
+
+      default:
+        if (jsp)
+          jsp = jdp->ParseAsArray(g, i, pretty, ptyp);
+        else if (!(jsp = jdp->ParseValue(g, i)))
+          throw 4;
+
+        break;
+      }; // endswitch s[i]
+
+    if (!jsp)
+      sprintf(g->Message, "Invalid Json string '%.*s'", MY_MIN((int)len, 50), s);
+    else if (ptyp && pretty == 3) {
+      *ptyp = 3;     // Not recognized pretty
+
+      for (i = 0; i < 3; i++)
+        if (pty[i]) {
+          *ptyp = i;
+          break;
+        } // endif pty
+
+    } // endif ptyp
+
+  } catch (int n) {
+    if (trace(1))
+      htrc("Exception %d: %s\n", n, g->Message);
+    jsp = NULL;
+  } catch (const char* msg) {
+    strcpy(g->Message, msg);
+    jsp = NULL;
+  } // end catch
+
+  return jsp;
 } // end of ParseJson
 
 /***********************************************************************/
+/* Serialize a JSON document tree:                                     */
+/***********************************************************************/
+PSZ Serialize(PGLOBAL g, PJSON jsp, char* fn, int pretty) {
+  PSZ   str = NULL;
+  bool  b = false, err = true;
+  JOUT* jp;
+  FILE* fs = NULL;
+  PJDOC jdp = NULL;
+
+  g->Message[0] = 0;
+
+  try {
+    jdp = new(g) JDOC; // MUST BE ALLOCATED BEFORE jp !!!!!
+
+    if (!jsp) {
+      strcpy(g->Message, "Null json tree");
+      throw 1;
+    } else if (!fn) {
+      // Serialize to a string
+      jp = new(g) JOUTSTR(g);
+      b = pretty == 1;
+    } else {
+      if (!(fs = fopen(fn, "wb"))) {
+        sprintf(g->Message, MSG(OPEN_MODE_ERROR),
+          "w", (int)errno, fn);
+        strcat(strcat(g->Message, ": "), strerror(errno));
+        throw 2;
+      } else if (pretty >= 2) {
+        // Serialize to a pretty file
+        jp = new(g)JOUTPRT(g, fs);
+      } else {
+        // Serialize to a flat file
+        b = true;
+        jp = new(g)JOUTFILE(g, fs, pretty);
+      } // endif's
+
+    } // endif's
+
+    jdp->SetJp(jp);
+
+    switch (jsp->GetType()) {
+    case TYPE_JAR:
+      err = jdp->SerializeArray((PJAR)jsp, b);
+      break;
+    case TYPE_JOB:
+      err = ((b && jp->Prty()) && jp->WriteChr('\t'));
+      err |= jdp->SerializeObject((PJOB)jsp);
+      break;
+    case TYPE_JVAL:
+      err = jdp->SerializeValue((PJVAL)jsp);
+      break;
+    default:
+      strcpy(g->Message, "Invalid json tree");
+    } // endswitch Type
+
+    if (fs) {
+      fputs(EL, fs);
+      fclose(fs);
+      str = (err) ? NULL : strcpy(g->Message, "Ok");
+    } else if (!err) {
+      str = ((JOUTSTR*)jp)->Strp;
+      jp->WriteChr('\0');
+      PlugSubAlloc(g, NULL, ((JOUTSTR*)jp)->N);
+    } else {
+      if (!g->Message[0])
+        strcpy(g->Message, "Error in Serialize");
+
+    } // endif's
+
+  } catch (int n) {
+    if (trace(1))
+      htrc("Exception %d: %s\n", n, g->Message);
+    str = NULL;
+  } catch (const char* msg) {
+    strcpy(g->Message, msg);
+    str = NULL;
+  } // end catch
+
+  return str;
+} // end of Serialize
+
+
+/* -------------------------- Class JOUTSTR -------------------------- */
+
+/***********************************************************************/
+/* JOUTSTR constructor.                                                */
+/***********************************************************************/
+JOUTSTR::JOUTSTR(PGLOBAL g) : JOUT(g) {
+  PPOOLHEADER pph = (PPOOLHEADER)g->Sarea;
+
+  N = 0;
+  Max = pph->FreeBlk;
+  Max = (Max > 32) ? Max - 32 : Max;
+  Strp = (char*)PlugSubAlloc(g, NULL, 0);  // Size not know yet
+} // end of JOUTSTR constructor
+
+/***********************************************************************/
+/* Concatenate a string to the Serialize string.                       */
+/***********************************************************************/
+bool JOUTSTR::WriteStr(const char* s) {
+  if (s) {
+    size_t len = strlen(s);
+
+    if (N + len > Max)
+      return true;
+
+    memcpy(Strp + N, s, len);
+    N += len;
+    return false;
+  } else
+    return true;
+
+} // end of WriteStr
+
+/***********************************************************************/
+/* Concatenate a character to the Serialize string.                    */
+/***********************************************************************/
+bool JOUTSTR::WriteChr(const char c) {
+  if (N + 1 > Max)
+    return true;
+
+  Strp[N++] = c;
+  return false;
+} // end of WriteChr
+
+/***********************************************************************/
+/* Escape and Concatenate a string to the Serialize string.            */
+/***********************************************************************/
+bool JOUTSTR::Escape(const char* s) {
+  WriteChr('"');
+
+  for (unsigned int i = 0; s[i]; i++)
+    switch (s[i]) {
+    case '"':
+    case '\\':
+    case '\t':
+    case '\n':
+    case '\r':
+    case '\b':
+    case '\f': WriteChr('\\');
+      // fall through
+    default:
+      WriteChr(s[i]);
+      break;
+    } // endswitch s[i]
+
+  WriteChr('"');
+  return false;
+} // end of Escape
+
+/* ------------------------- Class JOUTFILE -------------------------- */
+
+/***********************************************************************/
+/* Write a string to the Serialize file.                               */
+/***********************************************************************/
+bool JOUTFILE::WriteStr(const char* s) {
+  // This is temporary
+  fputs(s, Stream);
+  return false;
+} // end of WriteStr
+
+/***********************************************************************/
+/* Write a character to the Serialize file.                            */
+/***********************************************************************/
+bool JOUTFILE::WriteChr(const char c) {
+  // This is temporary
+  fputc(c, Stream);
+  return false;
+} // end of WriteChr
+
+/***********************************************************************/
+/* Escape and Concatenate a string to the Serialize string.            */
+/***********************************************************************/
+bool JOUTFILE::Escape(const char* s) {
+  // This is temporary
+  fputc('"', Stream);
+
+  for (unsigned int i = 0; s[i]; i++)
+    switch (s[i]) {
+    case '"':  fputs("\\\"", Stream); break;
+    case '\\': fputs("\\\\", Stream); break;
+    case '\t': fputs("\\t", Stream); break;
+    case '\n': fputs("\\n", Stream); break;
+    case '\r': fputs("\\r", Stream); break;
+    case '\b': fputs("\\b", Stream); break;
+    case '\f': fputs("\\f", Stream); break;
+    default:
+      fputc(s[i], Stream);
+      break;
+    } // endswitch s[i]
+
+  fputc('"', Stream);
+  return false;
+} // end of Escape
+
+/* ------------------------- Class JOUTPRT --------------------------- */
+
+/***********************************************************************/
+/* Write a string to the Serialize pretty file.                        */
+/***********************************************************************/
+bool JOUTPRT::WriteStr(const char* s) {
+  // This is temporary
+  if (B) {
+    fputs(EL, Stream);
+    M--;
+
+    for (int i = 0; i < M; i++)
+      fputc('\t', Stream);
+
+    B = false;
+  } // endif B
+
+  fputs(s, Stream);
+  return false;
+} // end of WriteStr
+
+/***********************************************************************/
+/* Write a character to the Serialize pretty file.                     */
+/***********************************************************************/
+bool JOUTPRT::WriteChr(const char c) {
+  switch (c) {
+  case ':':
+    fputs(": ", Stream);
+    break;
+  case '{':
+  case '[':
+#if 0
+    if (M)
+      fputs(EL, Stream);
+
+    for (int i = 0; i < M; i++)
+      fputc('\t', Stream);
+#endif // 0
+
+    fputc(c, Stream);
+    fputs(EL, Stream);
+    M++;
+
+    for (int i = 0; i < M; i++)
+      fputc('\t', Stream);
+
+    break;
+  case '}':
+  case ']':
+    M--;
+    fputs(EL, Stream);
+
+    for (int i = 0; i < M; i++)
+      fputc('\t', Stream);
+
+    fputc(c, Stream);
+    B = true;
+    break;
+  case ',':
+    fputc(c, Stream);
+    fputs(EL, Stream);
+
+    for (int i = 0; i < M; i++)
+      fputc('\t', Stream);
+
+    B = false;
+    break;
+  default:
+    fputc(c, Stream);
+  } // endswitch c
+
+  return false;
+} // end of WriteChr
+
+/* --------------------------- Class JDOC ---------------------------- */
+
+/***********************************************************************/
 /* Parse several items as being in an array.                           */
 /***********************************************************************/
-PJAR JSON::ParseAsArray(PGLOBAL g, int& i, int pretty, int *ptyp)
+PJAR JDOC::ParseAsArray(PGLOBAL g, int& i, int pretty, int *ptyp)
 {
-	if (pty[0] && (!pretty || pretty > 2)) {
-		PJAR jsp;
+  if (pty[0] && (!pretty || pretty > 2)) {
+    PJAR jsp;
 
-		if ((jsp = ParseArray(g, (i = 0))) && ptyp && pretty == 3)
-			*ptyp = (pty[0]) ? 0 : 3;
+    if ((jsp = ParseArray(g, (i = 0))) && ptyp && pretty == 3)
+      *ptyp = (pty[0]) ? 0 : 3;
 
-		return jsp;
-	} else
-		strcpy(g->Message, "More than one item in file");
+    return jsp;
+  } else
+    strcpy(g->Message, "More than one item in file");
 
-	return NULL;
+  return NULL;
 } // end of ParseAsArray
 
 /***********************************************************************/
 /* Parse a JSON Array.                                                 */
 /***********************************************************************/
-PJAR JSON::ParseArray(PGLOBAL g, int& i)
+PJAR JDOC::ParseArray(PGLOBAL g, int& i)
 {
-	int  level = 0;
-	bool b = (!i);
+  int  level = 0;
+  bool b = (!i);
   PJAR jarp = new(g) JARRAY;
 
   for (; i < len; i++)
@@ -235,11 +519,11 @@ PJAR JSON::ParseArray(PGLOBAL g, int& i)
 
         jarp->InitArray(g);
         return jarp;
-			case '\n':
-				if (!b)
-					pty[0] = pty[1] = false;
-			case '\r':
-			case ' ':
+      case '\n':
+        if (!b)
+          pty[0] = pty[1] = false;
+      case '\r':
+      case ' ':
       case '\t':
         break;
       default:
@@ -253,11 +537,11 @@ PJAR JSON::ParseArray(PGLOBAL g, int& i)
         break;
     }; // endswitch s[i]
 
-	if (b) {
-		// Case of Pretty == 0
-		jarp->InitArray(g);
-		return jarp;
-	} // endif b
+  if (b) {
+    // Case of Pretty == 0
+    jarp->InitArray(g);
+    return jarp;
+  } // endif b
 
   throw ("Unexpected EOF in array");
 } // end of ParseArray
@@ -265,7 +549,7 @@ PJAR JSON::ParseArray(PGLOBAL g, int& i)
 /***********************************************************************/
 /* Parse a JSON Object.                                                */
 /***********************************************************************/
-PJOB JSON::ParseObject(PGLOBAL g, int& i)
+PJOB JDOC::ParseObject(PGLOBAL g, int& i)
 {
   PSZ   key;
   int   level = 0;
@@ -276,7 +560,7 @@ PJOB JSON::ParseObject(PGLOBAL g, int& i)
     switch (s[i]) {
       case '"':
         if (level < 2) {
-					key = ParseString(g, ++i);
+          key = ParseString(g, ++i);
           jpp = jobp->AddPair(g, key);
           level = 1;
         } else {
@@ -287,7 +571,7 @@ PJOB JSON::ParseObject(PGLOBAL g, int& i)
         break;
       case ':':
         if (level == 1) {
-					jpp->Val = ParseValue(g, ++i);
+          jpp->Val = ParseValue(g, ++i);
           level = 2;
         } else {
           sprintf(g->Message, "Unexpected ':' near %.*s", ARGS);
@@ -310,10 +594,10 @@ PJOB JSON::ParseObject(PGLOBAL g, int& i)
           } // endif level
 
         return jobp;
-			case '\n':
-				pty[0] = pty[1] = false;
-			case '\r':
-			case ' ':
+      case '\n':
+        pty[0] = pty[1] = false;
+      case '\r':
+      case ' ':
       case '\t':
         break;
       default:
@@ -329,38 +613,38 @@ PJOB JSON::ParseObject(PGLOBAL g, int& i)
 /***********************************************************************/
 /* Parse a JSON Value.                                                 */
 /***********************************************************************/
-PJVAL JSON::ParseValue(PGLOBAL g, int& i)
+PJVAL JDOC::ParseValue(PGLOBAL g, int& i)
 {
-  int   n;
   PJVAL jvp = new(g) JVALUE;
 
   for (; i < len; i++)
-		switch (s[i]) {
-			case '\n':
-				pty[0] = pty[1] = false;
-			case '\r':
-			case ' ':
-			case '\t':
-				break;
-			default:
-				goto suite;
-		} // endswitch
+    switch (s[i]) {
+      case '\n':
+        pty[0] = pty[1] = false;
+      case '\r':
+      case ' ':
+      case '\t':
+        break;
+      default:
+        goto suite;
+    } // endswitch
 
  suite:
   switch (s[i]) {
     case '[':
-			jvp->Jsp = ParseArray(g, ++i);
+      jvp->Jsp = ParseArray(g, ++i);
       break;
     case '{':
-			jvp->Jsp = ParseObject(g, ++i);
+      jvp->Jsp = ParseObject(g, ++i);
       break;
     case '"':
-      jvp->Value = AllocateValue(g, ParseString(g, ++i), TYPE_STRING);
+      jvp->Val = AllocVal(g, TYPE_STRG);
+      jvp->Val->Strp = ParseString(g, ++i);
       break;
     case 't':
       if (!strncmp(s + i, "true", 4)) {
-        n = 1;
-        jvp->Value = AllocateValue(g, &n, TYPE_TINY);
+        jvp->Val = AllocVal(g, TYPE_BOOL);
+        jvp->Val->B = true;
         i += 3;
       } else
         goto err;
@@ -368,8 +652,8 @@ PJVAL JSON::ParseValue(PGLOBAL g, int& i)
       break;
     case 'f':
       if (!strncmp(s + i, "false", 5)) {
-        n = 0;
-        jvp->Value = AllocateValue(g, &n, TYPE_TINY);
+        jvp->Val = AllocVal(g, TYPE_BOOL);
+        jvp->Val->B = false;
         i += 4;
       } else
         goto err;
@@ -385,7 +669,7 @@ PJVAL JSON::ParseValue(PGLOBAL g, int& i)
     case '-':
     default:
       if (s[i] == '-' || isdigit(s[i]))
-				jvp->Value = ParseNumeric(g, i);
+        jvp->Val = ParseNumeric(g, i);
       else
         goto err;
 
@@ -401,7 +685,7 @@ err:
 /***********************************************************************/
 /*  Unescape and parse a JSON string.                                  */
 /***********************************************************************/
-char *JSON::ParseString(PGLOBAL g, int& i)
+char *JDOC::ParseString(PGLOBAL g, int& i)
 {
   uchar *p;
   int    n = 0;
@@ -488,15 +772,15 @@ char *JSON::ParseString(PGLOBAL g, int& i)
 /***********************************************************************/
 /* Parse a JSON numeric value.                                         */
 /***********************************************************************/
-PVAL JSON::ParseNumeric(PGLOBAL g, int& i)
+PVL JDOC::ParseNumeric(PGLOBAL g, int& i)
 {
   char  buf[50];
   int   n = 0;
   short nd = 0;
-	bool  has_dot = false;
-	bool  has_e = false;
-	bool  found_digit = false;
-  PVAL  valp = NULL;
+  bool  has_dot = false;
+  bool  has_e = false;
+  bool  found_digit = false;
+  PVL   vlp = NULL;
 
   for (; i < len; i++) {
     switch (s[i]) {
@@ -545,15 +829,24 @@ PVAL JSON::ParseNumeric(PGLOBAL g, int& i)
     if (has_dot || has_e) {
       double dv = strtod(buf, NULL);
 
-      valp = AllocateValue(g, &dv, TYPE_DOUBLE, nd);
+      vlp = AllocVal(g, TYPE_DBL);
+      vlp->F = dv;
+      vlp->Nd = nd;
     } else {
       long long iv = strtoll(buf, NULL, 10);
 
-      valp = AllocateValue(g, &iv, TYPE_BIGINT);
+      if (iv > INT_MAX32 || iv < INT_MIN32) {
+        vlp = AllocVal(g, TYPE_BINT);
+        vlp->LLn = iv;
+      } else {
+        vlp = AllocVal(g, TYPE_INTG);
+        vlp->N = (int)iv;
+      } // endif iv
+
     } // endif has
 
     i--;  // Unstack  following character
-    return valp;
+    return vlp;
   } else
     throw("No digit found");
 
@@ -562,137 +855,59 @@ PVAL JSON::ParseNumeric(PGLOBAL g, int& i)
 } // end of ParseNumeric
 
 /***********************************************************************/
-/* Serialize a JSON tree:                                              */
-/***********************************************************************/
-PSZ Serialize(PGLOBAL g, PJSON jsp, char *fn, int pretty)
-{
-	PSZ   str = NULL;
-	bool  b = false, err = true;
-	JOUT *jp;
-	FILE *fs = NULL;
-
-	g->Message[0] = 0;
-
-	try {
-		if (!jsp) {
-			strcpy(g->Message, "Null json tree");
-			throw 1;
-		} else if (!fn) {
-			// Serialize to a string
-			jp = new(g) JOUTSTR(g);
-			b = pretty == 1;
-		} else {
-			if (!(fs = fopen(fn, "wb"))) {
-				sprintf(g->Message, MSG(OPEN_MODE_ERROR),
-					"w", (int)errno, fn);
-				strcat(strcat(g->Message, ": "), strerror(errno));
-				throw 2;
-			} else if (pretty >= 2) {
-				// Serialize to a pretty file
-				jp = new(g)JOUTPRT(g, fs);
-			} else {
-				// Serialize to a flat file
-				b = true;
-				jp = new(g)JOUTFILE(g, fs, pretty);
-			} // endif's
-
-		}	// endif's
-
-		switch (jsp->GetType()) {
-			case TYPE_JAR:
-				err = SerializeArray(jp, (PJAR)jsp, b);
-				break;
-			case TYPE_JOB:
-				err = ((b && jp->Prty()) && jp->WriteChr('\t'));
-				err |= SerializeObject(jp, (PJOB)jsp);
-				break;
-			case TYPE_JVAL:
-				err = SerializeValue(jp, (PJVAL)jsp);
-				break;
-			default:
-				strcpy(g->Message, "Invalid json tree");
-		} // endswitch Type
-
-		if (fs) {
-			fputs(EL, fs);
-			fclose(fs);
-			str = (err) ? NULL : strcpy(g->Message, "Ok");
-		} else if (!err) {
-			str = ((JOUTSTR*)jp)->Strp;
-			jp->WriteChr('\0');
-			PlugSubAlloc(g, NULL, ((JOUTSTR*)jp)->N);
-		} else {
-			if (!g->Message[0])
-				strcpy(g->Message, "Error in Serialize");
-
-		} // endif's
-
-	} catch (int n) {
-		if (trace(1))
-			htrc("Exception %d: %s\n", n, g->Message);
-		str = NULL;
-	} catch (const char *msg) {
-		strcpy(g->Message, msg);
-		str = NULL;
-	} // end catch
-
-	return str;
-} // end of Serialize
-
-/***********************************************************************/
 /* Serialize a JSON Array.                                             */
 /***********************************************************************/
-bool SerializeArray(JOUT *js, PJAR jarp, bool b)
+bool JDOC::SerializeArray(PJAR jarp, bool b)
 {
   bool first = true;
 
-	if (b) {
-		if (js->Prty()) {
-			if (js->WriteChr('['))
-				return true;
-			else if (js->Prty() == 1 && (js->WriteStr(EL) || js->WriteChr('\t')))
-				return true;
+  if (b) {
+    if (js->Prty()) {
+      if (js->WriteChr('['))
+        return true;
+      else if (js->Prty() == 1 && (js->WriteStr(EL) || js->WriteChr('\t')))
+        return true;
 
-		} // endif Prty
+    } // endif Prty
 
-	} else if (js->WriteChr('['))
-		return true;
+  } else if (js->WriteChr('['))
+    return true;
 
   for (int i = 0; i < jarp->size(); i++) {
     if (first)
       first = false;
-		else if ((!b || js->Prty()) && js->WriteChr(','))
+    else if ((!b || js->Prty()) && js->WriteChr(','))
       return true;
-		else if (b) {
-			if (js->Prty() < 2 && js->WriteStr(EL))
-				return true;
-			else if (js->Prty() == 1 && js->WriteChr('\t'))
-				return true;
+    else if (b) {
+      if (js->Prty() < 2 && js->WriteStr(EL))
+        return true;
+      else if (js->Prty() == 1 && js->WriteChr('\t'))
+        return true;
 
-		} // endif b
+    } // endif b
 
-    if (SerializeValue(js, jarp->GetValue(i)))
+    if (SerializeValue(jarp->GetValue(i)))
       return true;
 
     } // endfor i
 
-	if (b && js->Prty() == 1 && js->WriteStr(EL))
+  if (b && js->Prty() == 1 && js->WriteStr(EL))
     return true;
 
-	return ((!b || js->Prty()) && js->WriteChr(']'));
+  return ((!b || js->Prty()) && js->WriteChr(']'));
 } // end of SerializeArray
 
 /***********************************************************************/
 /* Serialize a JSON Object.                                            */
 /***********************************************************************/
-bool SerializeObject(JOUT *js, PJOB jobp)
+bool JDOC::SerializeObject(PJOB jobp)
 {
   bool first = true;
 
   if (js->WriteChr('{'))
     return true;
 
-  for (PJPR pair = jobp->First; pair; pair = pair->Next) {
+  for (PJPR pair = jobp->GetFirst(); pair; pair = pair->Next) {
     if (first)
       first = false;
     else if (js->WriteChr(','))
@@ -702,7 +917,7 @@ bool SerializeObject(JOUT *js, PJOB jobp)
         js->WriteStr(pair->Key) ||
         js->WriteChr('"') ||
         js->WriteChr(':') ||
-        SerializeValue(js, pair->Val))
+        SerializeValue(pair->Val))
       return true;
 
     } // endfor i
@@ -713,259 +928,70 @@ bool SerializeObject(JOUT *js, PJOB jobp)
 /***********************************************************************/
 /* Serialize a JSON Value.                                             */
 /***********************************************************************/
-bool SerializeValue(JOUT *js, PJVAL jvp)
+bool JDOC::SerializeValue(PJVAL jvp)
 {
+  char buf[64];
   PJAR jap;
   PJOB jop;
-  PVAL valp;
+  PVL  vlp;
 
   if ((jap = jvp->GetArray()))
-    return SerializeArray(js, jap, false);
+    return SerializeArray(jap, false);
   else if ((jop = jvp->GetObject()))
-    return SerializeObject(js, jop);
-  else if (!(valp = jvp->Value) || valp->IsNull())
+    return SerializeObject(jop);
+  else if (!(vlp = jvp->Val))
     return js->WriteStr("null");
-  else switch (valp->GetType()) {
-    case TYPE_TINY:
-      return js->WriteStr(valp->GetTinyValue() ? "true" : "false");
-    case TYPE_STRING:
-      return js->Escape(valp->GetCharValue());
+  else switch (vlp->Type) {
+    case TYPE_BOOL:
+      return js->WriteStr(vlp->B ? "true" : "false");
+    case TYPE_STRG:
+    case TYPE_DTM:
+      return js->Escape(vlp->Strp);
+    case TYPE_INTG:
+      sprintf(buf, "%d", vlp->N);
+      return js->WriteStr(buf);
+    case TYPE_BINT:
+      sprintf(buf, "%lld", vlp->LLn);
+      return js->WriteStr(buf);
+    case TYPE_DBL:
+      sprintf(buf, "%.*lf", vlp->Nd, vlp->F);
+      return js->WriteStr(buf);
+    case TYPE_NULL:
+      return js->WriteStr("null");
     default:
-      if (valp->IsTypeNum()) {
-        char buf[32];
+      return js->WriteStr("???");   // TODO
+  } // endswitch Type
 
-        return js->WriteStr(valp->GetCharString(buf));
-        } // endif valp
-
-    } // endswitch Type
-
-	strcpy(js->g->Message, "Unrecognized value");
-	return true;
+  strcpy(js->g->Message, "Unrecognized value");
+  return true;
 } // end of SerializeValue
 
-/* -------------------------- Class JOUTSTR -------------------------- */
-
-/***********************************************************************/
-/* JOUTSTR constructor.                                                */
-/***********************************************************************/
-JOUTSTR::JOUTSTR(PGLOBAL g) : JOUT(g)
-{
-  PPOOLHEADER pph = (PPOOLHEADER)g->Sarea;
-
-  N = 0;
-  Max = pph->FreeBlk;
-  Max = (Max > 32) ? Max - 32 : Max;
-  Strp = (char*)PlugSubAlloc(g, NULL, 0);  // Size not know yet
-} // end of JOUTSTR constructor
-
-/***********************************************************************/
-/* Concatenate a string to the Serialize string.                       */
-/***********************************************************************/
-bool JOUTSTR::WriteStr(const char *s)
-{
-  if (s) {
-    size_t len = strlen(s);
-
-    if (N + len > Max)
-      return true;
-
-    memcpy(Strp + N, s, len);
-    N += len;
-    return false;
-  } else
-    return true;
-
-} // end of WriteStr
-
-/***********************************************************************/
-/* Concatenate a character to the Serialize string.                    */
-/***********************************************************************/
-bool JOUTSTR::WriteChr(const char c)
-{
-  if (N + 1 > Max)
-    return true;
-
-  Strp[N++] = c;
-  return false;
-} // end of WriteChr
-
-/***********************************************************************/
-/* Escape and Concatenate a string to the Serialize string.            */
-/***********************************************************************/
-bool JOUTSTR::Escape(const char *s)
-{
-  WriteChr('"');
-
-  for (unsigned int i = 0; s[i]; i++)
-    switch (s[i]) {
-      case '"':
-      case '\\':
-      case '\t':
-      case '\n':
-      case '\r':
-      case '\b':
-      case '\f': WriteChr('\\');
-        // fall through
-      default:
-        WriteChr(s[i]);
-        break;
-      } // endswitch s[i]
-
-  WriteChr('"');
-  return false;
-} // end of Escape
-
-/* ------------------------- Class JOUTFILE -------------------------- */
-
-/***********************************************************************/
-/* Write a string to the Serialize file.                               */
-/***********************************************************************/
-bool JOUTFILE::WriteStr(const char *s)
-{
-  // This is temporary
-  fputs(s, Stream);
-  return false;
-} // end of WriteStr
-
-/***********************************************************************/
-/* Write a character to the Serialize file.                            */
-/***********************************************************************/
-bool JOUTFILE::WriteChr(const char c)
-{
-  // This is temporary
-  fputc(c, Stream);
-  return false;
-} // end of WriteChr
-
-/***********************************************************************/
-/* Escape and Concatenate a string to the Serialize string.            */
-/***********************************************************************/
-bool JOUTFILE::Escape(const char *s)
-{
-  // This is temporary
-  fputc('"', Stream);
-
-  for (unsigned int i = 0; s[i]; i++)
-    switch (s[i]) {
-      case '"':  fputs("\\\"", Stream); break;
-      case '\\': fputs("\\\\", Stream); break;
-      case '\t': fputs("\\t",  Stream); break;
-      case '\n': fputs("\\n",  Stream); break;
-      case '\r': fputs("\\r",  Stream); break;
-      case '\b': fputs("\\b",  Stream); break;
-      case '\f': fputs("\\f",  Stream); break;
-      default:
-        fputc(s[i], Stream);
-        break;
-      } // endswitch s[i]
-
-  fputc('"', Stream);
-  return false;
-} // end of Escape
-
-/* ------------------------- Class JOUTPRT --------------------------- */
-
-/***********************************************************************/
-/* Write a string to the Serialize pretty file.                        */
-/***********************************************************************/
-bool JOUTPRT::WriteStr(const char *s)
-{
-  // This is temporary
-  if (B) {
-    fputs(EL, Stream);
-    M--;
-
-    for (int i = 0; i < M; i++)
-      fputc('\t', Stream);
-
-    B = false;
-    } // endif B
-
-  fputs(s, Stream);
-  return false;
-} // end of WriteStr
-
-/***********************************************************************/
-/* Write a character to the Serialize pretty file.                     */
-/***********************************************************************/
-bool JOUTPRT::WriteChr(const char c)
-{
-  switch (c) {
-    case ':':
-      fputs(": ", Stream);
-      break;
-    case '{':
-    case '[':
-#if 0
-      if (M)
-        fputs(EL, Stream);
-
-      for (int i = 0; i < M; i++)
-        fputc('\t', Stream);
-#endif // 0
-
-      fputc(c, Stream);
-      fputs(EL, Stream);
-      M++;
-
-      for (int i = 0; i < M; i++)
-        fputc('\t', Stream);
-
-      break;
-    case '}':
-    case ']':
-      M--;
-      fputs(EL, Stream);
-
-      for (int i = 0; i < M; i++)
-        fputc('\t', Stream);
-
-      fputc(c, Stream);
-      B = true;
-      break;
-    case ',':
-      fputc(c, Stream);
-      fputs(EL, Stream);
-
-      for (int i = 0; i < M; i++)
-        fputc('\t', Stream);
-
-      B = false;
-      break;
-    default:
-      fputc(c, Stream);
-    } // endswitch c
-
-return false;
-} // end of WriteChr
-
 /* -------------------------- Class JOBJECT -------------------------- */
 
 /***********************************************************************/
 /* Return the number of pairs in this object.                          */
 /***********************************************************************/
-int JOBJECT::GetSize(bool b)
-{
-	if (b) {
-		// Return only non null pairs
-		int n = 0;
+int JOBJECT::GetSize(bool b) {
+  int n = 0;
 
-		for (PJPR jpp = First; jpp; jpp = jpp->Next)
-			if (jpp->Val && !jpp->Val->IsNull())
-				n++;
+  for (PJPR jpp = First; jpp; jpp = jpp->Next)
+    // If b return only non null pairs
+    if (!b || jpp->Val && !jpp->Val->IsNull())
+      n++;
 
-		return n;
-	} else
-		return Size;
-
-}	// end of	GetSize
+  return n;
+} // end of GetSize
 
 /***********************************************************************/
 /* Add a new pair to an Object.                                        */
 /***********************************************************************/
 PJPR JOBJECT::AddPair(PGLOBAL g, PCSZ key)
 {
-  PJPR jpp = new(g) JPAIR(key);
+  PJPR jpp = (PJPR)PlugSubAlloc(g, NULL, sizeof(JPAIR));
+
+  jpp->Key = key;
+  jpp->Next = NULL;
+  jpp->Val = NULL;
 
   if (Last)
     Last->Next = jpp;
@@ -973,7 +999,6 @@ PJPR JOBJECT::AddPair(PGLOBAL g, PCSZ key)
     First = jpp;
 
   Last = jpp;
-  Size++;
   return jpp;
 } // end of AddPair
 
@@ -982,13 +1007,13 @@ PJPR JOBJECT::AddPair(PGLOBAL g, PCSZ key)
 /***********************************************************************/
 PJAR JOBJECT::GetKeyList(PGLOBAL g)
 {
-	PJAR jarp = new(g) JARRAY();
+  PJAR jarp = new(g) JARRAY();
 
-	for (PJPR jpp = First; jpp; jpp = jpp->Next)
-		jarp->AddValue(g, new(g) JVALUE(g, jpp->GetKey()));
+  for (PJPR jpp = First; jpp; jpp = jpp->Next)
+    jarp->AddValue(g, new(g) JVALUE(g, jpp->Key));
 
-	jarp->InitArray(g);
-	return jarp;
+  jarp->InitArray(g);
+  return jarp;
 } // end of GetKeyList
 
 /***********************************************************************/
@@ -996,13 +1021,13 @@ PJAR JOBJECT::GetKeyList(PGLOBAL g)
 /***********************************************************************/
 PJAR JOBJECT::GetValList(PGLOBAL g)
 {
-	PJAR jarp = new(g) JARRAY();
+  PJAR jarp = new(g) JARRAY();
 
-	for (PJPR jpp = First; jpp; jpp = jpp->Next)
-		jarp->AddValue(g, jpp->GetVal());
+  for (PJPR jpp = First; jpp; jpp = jpp->Next)
+    jarp->AddValue(g, jpp->Val);
 
-	jarp->InitArray(g);
-	return jarp;
+  jarp->InitArray(g);
+  return jarp;
 } // end of GetValList
 
 /***********************************************************************/
@@ -1024,6 +1049,9 @@ PSZ JOBJECT::GetText(PGLOBAL g, PSZ text)
 {
   int n;
 
+  if (!First)
+    return text;
+
   if (!text) {
     text = (char*)PlugSubAlloc(g, NULL, 0);
     text[0] = 0;
@@ -1031,26 +1059,24 @@ PSZ JOBJECT::GetText(PGLOBAL g, PSZ text)
   } else
     n = 0;
 
-  if (!First && n)
-    return NULL;
-	else if (n == 1 && Size == 1 && !strcmp(First->GetKey(), "$date")) {
-		int i;
+   if (n == 1 && !First->Next && !strcmp(First->Key, "$date")) {
+    int i;
 
-		First->Val->GetText(g, text);
-		i = (text[1] == '-' ? 2 : 1);
+    First->Val->GetText(g, text);
+    i = (text[1] == '-' ? 2 : 1);
 
-		if (IsNum(text + i)) {
-			// Date is in milliseconds
-			int j = (int)strlen(text);
+    if (IsNum(text + i)) {
+      // Date is in milliseconds
+      int j = (int)strlen(text);
 
-			if (j >= 4 + i)
-				text[j - 3] = 0;			// Change it to seconds
-			else
-				strcpy(text, " 0");
+      if (j >= 4 + i)
+        text[j - 3] = 0;      // Change it to seconds
+      else
+        strcpy(text, " 0");
 
-		}	// endif text
+    } // endif text
 
-	} else for (PJPR jp = First; jp; jp = jp->Next)
+  } else for (PJPR jp = First; jp; jp = jp->Next)
     jp->Val->GetText(g, text);
 
   if (n)
@@ -1064,17 +1090,17 @@ PSZ JOBJECT::GetText(PGLOBAL g, PSZ text)
 /***********************************************************************/
 bool JOBJECT::Merge(PGLOBAL g, PJSON jsp)
 {
-	if (jsp->GetType() != TYPE_JOB) {
-		strcpy(g->Message, "Second argument is not an object");
-		return true;
-	}	// endif Type
+  if (jsp->GetType() != TYPE_JOB) {
+    strcpy(g->Message, "Second argument is not an object");
+    return true;
+  } // endif Type
 
-	PJOB jobp = (PJOB)jsp;
+  PJOB jobp = (PJOB)jsp;
 
-	for (PJPR jpp = jobp->First; jpp; jpp = jpp->Next)
-		SetValue(g, jpp->GetVal(), jpp->GetKey());
+  for (PJPR jpp = jobp->First; jpp; jpp = jpp->Next)
+    SetValue(g, jpp->Val, jpp->Key);
 
-	return false;
+  return false;
 } // end of Marge;
 
 /***********************************************************************/
@@ -1082,7 +1108,7 @@ bool JOBJECT::Merge(PGLOBAL g, PJSON jsp)
 /***********************************************************************/
 void JOBJECT::SetValue(PGLOBAL g, PJVAL jvp, PCSZ key)
 {
-	PJPR jp;
+  PJPR jp;
 
   for (jp = First; jp; jp = jp->Next)
     if (!strcmp(jp->Key, key)) {
@@ -1102,15 +1128,14 @@ void JOBJECT::SetValue(PGLOBAL g, PJVAL jvp, PCSZ key)
 /***********************************************************************/
 void JOBJECT::DeleteKey(PCSZ key)
 {
-	PJPR jp, *pjp = &First;
+  PJPR jp, *pjp = &First;
 
-	for (jp = First; jp; jp = jp->Next)
-		if (!strcmp(jp->Key, key)) {
-			*pjp = jp->Next;
-			Size--;
-			break;
-		} else
-			pjp = &jp->Next;
+  for (jp = First; jp; jp = jp->Next)
+    if (!strcmp(jp->Key, key)) {
+      *pjp = jp->Next;
+      break;
+    } else
+      pjp = &jp->Next;
 
 } // end of DeleteKey
 
@@ -1133,19 +1158,19 @@ bool JOBJECT::IsNull(void)
 /***********************************************************************/
 int JARRAY::GetSize(bool b)
 {
-	if (b) {
-		// Return only non null values
-		int n = 0;
+  if (b) {
+    // Return only non null values
+    int n = 0;
 
-		for (PJVAL jvp = First; jvp; jvp = jvp->Next)
-			if (!jvp->IsNull())
-				n++;
+    for (PJVAL jvp = First; jvp; jvp = jvp->Next)
+      if (!jvp->IsNull())
+        n++;
 
-		return n;
-	} else
-		return Size;
+    return n;
+  } else
+    return Size;
 
-}	// end of	GetSize
+} // end of GetSize
 
 /***********************************************************************/
 /* Make the array of values from the values list.                      */
@@ -1166,12 +1191,12 @@ void JARRAY::InitArray(PGLOBAL g)
   } // endif Size
 
   for (i = 0, jvp = First; jvp; jvp = jvp->Next)
-		if (!jvp->Del) {
-			Mvals[i++] = jvp;
-			pjvp = &jvp->Next;
-			Last = jvp;
-		} else
-			*pjvp = jvp->Next;
+    if (!jvp->Del) {
+      Mvals[i++] = jvp;
+      pjvp = &jvp->Next;
+      Last = jvp;
+    } else
+      *pjvp = jvp->Next;
 
 } // end of InitArray
 
@@ -1194,28 +1219,28 @@ PJVAL JARRAY::AddValue(PGLOBAL g, PJVAL jvp, int *x)
   if (!jvp)
     jvp = new(g) JVALUE;
 
-	if (x) {
-		int   i = 0, n = *x;
-		PJVAL jp, *jpp = &First;
+  if (x) {
+    int   i = 0, n = *x;
+    PJVAL jp, *jpp = &First;
 
-		for (jp = First; jp && i < n; i++, jp = *(jpp = &jp->Next));
+    for (jp = First; jp && i < n; i++, jp = *(jpp = &jp->Next));
 
-		(*jpp) = jvp;
+    (*jpp) = jvp;
 
-		if (!(jvp->Next = jp))
-			Last = jvp;
+    if (!(jvp->Next = jp))
+      Last = jvp;
 
-	} else {
-		if (!First)
-			First = jvp;
-		else if (Last == First)
-			First->Next = Last = jvp;
-		else
-			Last->Next = jvp;
+  } else {
+    if (!First)
+      First = jvp;
+    else if (Last == First)
+      First->Next = Last = jvp;
+    else
+      Last->Next = jvp;
 
-		Last = jvp;
-		Last->Next = NULL;
-	} // endif x
+    Last = jvp;
+    Last->Next = NULL;
+  } // endif x
 
   return jvp;
 } // end of AddValue
@@ -1225,18 +1250,18 @@ PJVAL JARRAY::AddValue(PGLOBAL g, PJVAL jvp, int *x)
 /***********************************************************************/
 bool JARRAY::Merge(PGLOBAL g, PJSON jsp)
 {
-	if (jsp->GetType() != TYPE_JAR) {
-		strcpy(g->Message, "Second argument is not an array");
-		return true;
-	}	// endif Type
+  if (jsp->GetType() != TYPE_JAR) {
+    strcpy(g->Message, "Second argument is not an array");
+    return true;
+  } // endif Type
 
-	PJAR arp = (PJAR)jsp;
+  PJAR arp = (PJAR)jsp;
 
-	for (int i = 0; i < jsp->size(); i++)
-		AddValue(g, arp->GetValue(i));
+  for (int i = 0; i < arp->size(); i++)
+    AddValue(g, arp->GetValue(i));
 
-	InitArray(g);
-	return false;
+  InitArray(g);
+  return false;
 } // end of Merge
 
 /***********************************************************************/
@@ -1261,23 +1286,23 @@ bool JARRAY::SetValue(PGLOBAL g, PJVAL jvp, int n)
 /***********************************************************************/
 PSZ JARRAY::GetText(PGLOBAL g, PSZ text)
 {
-	int   n;
-	PJVAL jp;
+  int   n;
+  PJVAL jp;
 
-	if (!text) {
-		text = (char*)PlugSubAlloc(g, NULL, 0);
-		text[0] = 0;
-		n = 1;
-	} else
-		n = 0;
+  if (!text) {
+    text = (char*)PlugSubAlloc(g, NULL, 0);
+    text[0] = 0;
+    n = 1;
+  } else
+    n = 0;
 
-	for (jp = First; jp; jp = jp->Next)
-		jp->GetText(g, text);
+  for (jp = First; jp; jp = jp->Next)
+    jp->GetText(g, text);
 
-	if (n)
-		PlugSubAlloc(g, NULL, strlen(text) + 1);
+  if (n)
+    PlugSubAlloc(g, NULL, strlen(text) + 1);
 
-	return text + n;
+  return text + n;
 } // end of GetText;
 
 /***********************************************************************/
@@ -1285,13 +1310,13 @@ PSZ JARRAY::GetText(PGLOBAL g, PSZ text)
 /***********************************************************************/
 bool JARRAY::DeleteValue(int n)
 {
-	PJVAL jvp = GetValue(n);
+  PJVAL jvp = GetValue(n);
 
-	if (jvp) {
-		jvp->Del = true;
-		return false;
-	} else
-		return true;
+  if (jvp) {
+    jvp->Del = true;
+    return false;
+  } else
+    return true;
 
 } // end of DeleteValue
 
@@ -1314,28 +1339,41 @@ bool JARRAY::IsNull(void)
 /***********************************************************************/
 JVALUE::JVALUE(PJSON jsp) : JSON()
 {
-	if (jsp->GetType() == TYPE_JVAL) {
-		Jsp = jsp->GetJsp();
-		Value = jsp->GetValue();
-	} else {
-		Jsp = jsp; 
-		Value = NULL;
-	}	// endif Type
+  if (jsp->GetType() == TYPE_JVAL) {
+    Jsp = jsp->GetJsp();
+    Val = ((PJVAL)jsp)->GetVal();
+  } else {
+    Jsp = jsp;
+    Val = NULL;
+  } // endif Type
 
-	Next = NULL; 
-	Del = false; 
-	Size = 1;
-}	// end of JVALUE constructor
+  Next = NULL;
+  Del = false;
+  Type = TYPE_JVAL;
+} // end of JVALUE constructor
 
 /***********************************************************************/
-/* Constructor for a Value with a given string or numeric value.       */
+/* Constructor for a Val with a given string or numeric value.         */
 /***********************************************************************/
-JVALUE::JVALUE(PGLOBAL g, PVAL valp) : JSON()
+JVALUE::JVALUE(PGLOBAL g, PVL vlp) : JSON()
 {
   Jsp = NULL;
-  Value = AllocateValue(g, valp);
+  Val = vlp;
+  Next = NULL;
+  Del = false;
+  Type = TYPE_JVAL;
+} // end of JVALUE constructor
+
+/***********************************************************************/
+/* Constructor for a Value with a given string or numeric value.       */
+/***********************************************************************/
+JVALUE::JVALUE(PGLOBAL g, PVAL valp) : JSON() {
+  Jsp = NULL;
+  Val = NULL;
+  SetValue(g, valp);
   Next = NULL;
   Del = false;
+  Type = TYPE_JVAL;
 } // end of JVALUE constructor
 
 /***********************************************************************/
@@ -1343,10 +1381,12 @@ JVALUE::JVALUE(PGLOBAL g, PVAL valp) : JSON()
 /***********************************************************************/
 JVALUE::JVALUE(PGLOBAL g, PCSZ strp) : JSON()
 {
-	Jsp = NULL;
-	Value = AllocateValue(g, (void*)strp, TYPE_STRING);
-	Next = NULL;
-	Del = false;
+  Jsp = NULL;
+  Val = AllocVal(g, TYPE_STRG);
+  Val->Strp = (char*)strp;
+  Next = NULL;
+  Del = false;
+  Type = TYPE_JVAL;
 } // end of JVALUE constructor
 
 /***********************************************************************/
@@ -1356,8 +1396,8 @@ JTYP JVALUE::GetValType(void)
 {
   if (Jsp)
     return Jsp->GetType();
-  else if (Value)
-    return (JTYP)Value->GetType();
+  else if (Val)
+    return Val->Type;
   else
     return TYPE_NULL;
 
@@ -1386,11 +1426,41 @@ PJAR JVALUE::GetArray(void)
 } // end of GetArray
 
 /***********************************************************************/
-/* Return the Value's Integer value.                                   */
+/* Return the Value's as a Value class.                                */
 /***********************************************************************/
-int JVALUE::GetInteger(void)
+PVAL JVALUE::GetValue(PGLOBAL g)
 {
-  return (Value) ? Value->GetIntValue() : 0;
+  PVAL valp = NULL;
+
+  if (Val)
+    if (Val->Type == TYPE_STRG)
+      valp = AllocateValue(g, Val->Strp, Val->Type, Val->Nd);
+    else
+      valp = AllocateValue(g, Val, Val->Type, Val->Nd);
+
+  return valp;
+} // end of GetValue
+
+/***********************************************************************/
+/* Return the Value's Integer value.                                   */
+/***********************************************************************/
+int JVALUE::GetInteger(void) {
+  int n;
+
+  if (!Val)
+    n = 0;
+  else switch (Val->Type) {
+  case TYPE_INTG: n = Val->N;           break;
+  case TYPE_DBL:  n = (int)Val->F;      break;
+  case TYPE_DTM:
+  case TYPE_STRG: n = atoi(Val->Strp);  break;
+  case TYPE_BOOL: n = (Val->B) ? 1 : 0; break;
+  case TYPE_BINT: n = (int)Val->LLn;    break;
+  default:
+    n = 0;
+  } // endswitch Type
+
+  return n;
 } // end of GetInteger
 
 /***********************************************************************/
@@ -1398,7 +1468,22 @@ int JVALUE::GetInteger(void)
 /***********************************************************************/
 long long JVALUE::GetBigint(void)
 {
-	return (Value) ? Value->GetBigintValue() : 0;
+  long long lln;
+
+  if (!Val)
+    lln = 0;
+  else switch (Val->Type) {
+  case TYPE_BINT: lln = Val->LLn;          break;
+  case TYPE_INTG: lln = (long long)Val->N; break;
+  case TYPE_DBL:  lln = (long long)Val->F; break;
+  case TYPE_DTM:
+  case TYPE_STRG: lln = atoll(Val->Strp);  break;
+  case TYPE_BOOL: lln = (Val->B) ? 1 : 0;  break;
+  default:
+    lln = 0;
+  } // endswitch Type
+
+  return lln;
 } // end of GetBigint
 
 /***********************************************************************/
@@ -1406,7 +1491,22 @@ long long JVALUE::GetBigint(void)
 /***********************************************************************/
 double JVALUE::GetFloat(void)
 {
-  return (Value) ? Value->GetFloatValue() : 0.0;
+  double d;
+
+  if (!Val)
+    d = 0.0;
+  else switch (Val->Type) {
+  case TYPE_DBL:  d = Val->F;               break;
+  case TYPE_BINT: d = (double)Val->LLn;     break;
+  case TYPE_INTG: d = (double)Val->N;       break;
+  case TYPE_DTM:
+  case TYPE_STRG: d = atof(Val->Strp);      break;
+  case TYPE_BOOL: d = (Val->B) ? 1.0 : 0.0; break;
+  default:
+    d = 0.0;
+  } // endswitch Type
+
+  return d;
 } // end of GetFloat
 
 /***********************************************************************/
@@ -1414,18 +1514,38 @@ double JVALUE::GetFloat(void)
 /***********************************************************************/
 PSZ JVALUE::GetString(PGLOBAL g)
 {
-	char *p;
-
-	if (Value) {
-		char buf[32];
-
-		if ((p = Value->GetCharString(buf)) == buf)
-			p = PlugDup(g, buf);
+  char  buf[32];
+  char *p = buf;
+
+  if (Val) {
+    switch (Val->Type) {
+    case TYPE_DTM:
+    case TYPE_STRG:
+      p = Val->Strp;
+      break;
+    case TYPE_INTG:
+      sprintf(buf, "%d", Val->N);
+      break;
+    case TYPE_BINT:
+      sprintf(buf, "%lld", Val->LLn);
+      break;
+    case TYPE_DBL:
+      sprintf(buf, "%.*lf", Val->Nd, Val->F);
+      break;
+    case TYPE_BOOL:
+      p = (Val->B) ? "true" : "false";
+      break;
+    case TYPE_NULL:
+      p = "null";
+      break;
+    default:
+      p = NULL;
+    } // endswitch Type
 
-	} else
-		p = NULL;
+  } else
+    p = NULL;
 
-	return p;
+  return p;
 } // end of GetString
 
 /***********************************************************************/
@@ -1436,8 +1556,7 @@ PSZ JVALUE::GetText(PGLOBAL g, PSZ text)
   if (Jsp)
     return Jsp->GetText(g, text);
 
-  char buf[32];
-  PSZ  s = (Value) ? Value->GetCharString(buf) : NULL;
+  PSZ  s = (Val) ? GetString(g) : NULL;
 
   if (s)
     strcat(strcat(text, " "), s);
@@ -1449,32 +1568,74 @@ PSZ JVALUE::GetText(PGLOBAL g, PSZ text)
 
 void JVALUE::SetValue(PJSON jsp)
 {
-	if (jsp && jsp->GetType() == TYPE_JVAL) {
-		Jsp = jsp->GetJsp();
-		Value = jsp->GetValue();
-	} else {
-		Jsp = jsp;
-		Value = NULL;
-	} // endif Type
+  if (jsp && jsp->GetType() == TYPE_JVAL) {
+    Jsp = jsp->GetJsp();
+    Val = ((PJVAL)jsp)->GetVal();
+  } else {
+    Jsp = jsp;
+    Val = NULL;
+  } // endif Type
+
+} // end of SetValue;
+
+void JVALUE::SetValue(PGLOBAL g, PVAL valp)
+{
+  if (!Val)
+    Val = AllocVal(g, TYPE_VAL);
+
+  if (!valp || valp->IsNull()) {
+    Val->Type = TYPE_NULL;
+  } else switch (valp->GetType()) {
+  case TYPE_STRING:
+  case TYPE_DATE:
+    Val->Strp = valp->GetCharValue();
+    Val->Type = TYPE_STRG;
+    break;
+  case TYPE_DOUBLE:
+  case TYPE_DECIM:
+    Val->F = valp->GetFloatValue();
+
+    if (IsTypeNum(valp->GetType()))
+      Val->Nd = valp->GetValPrec();
+
+    Val->Type = TYPE_DBL;
+    break;
+  case TYPE_TINY:
+    Val->B = valp->GetTinyValue() != 0;
+    Val->Type = TYPE_BOOL;
+  case TYPE_INT:
+    Val->N = valp->GetIntValue();
+    Val->Type = TYPE_INTG;
+    break;
+  case TYPE_BIGINT:
+    Val->LLn = valp->GetBigintValue();
+    Val->Type = TYPE_BINT;
+    break;
+  default:
+    sprintf(g->Message, "Unsupported typ %d\n", valp->GetType());
+    throw(777);
+  } // endswitch Type
 
-}	// end of SetValue;
+} // end of SetValue
 
 /***********************************************************************/
 /* Set the Value's value as the given integer.                         */
 /***********************************************************************/
 void JVALUE::SetInteger(PGLOBAL g, int n)
 {
-  Value = AllocateValue(g, &n, TYPE_INT);
-	Jsp = NULL;
+  Val = AllocVal(g, TYPE_INTG);
+  Val->N = n;
+  Jsp = NULL;
 } // end of SetInteger
 
 /***********************************************************************/
 /* Set the Value's Boolean value as a tiny integer.                    */
 /***********************************************************************/
-void JVALUE::SetTiny(PGLOBAL g, char n)
+void JVALUE::SetBool(PGLOBAL g, bool b)
 {
-	Value = AllocateValue(g, &n, TYPE_TINY);
-	Jsp = NULL;
+  Val = AllocVal(g, TYPE_BOOL);
+  Val->B = b;
+  Jsp = NULL;
 } // end of SetTiny
 
 /***********************************************************************/
@@ -1482,8 +1643,9 @@ void JVALUE::SetTiny(PGLOBAL g, char n)
 /***********************************************************************/
 void JVALUE::SetBigint(PGLOBAL g, long long ll)
 {
-	Value = AllocateValue(g, &ll, TYPE_BIGINT);
-	Jsp = NULL;
+  Val = AllocVal(g, TYPE_BINT);
+  Val->LLn = ll;
+  Jsp = NULL;
 } // end of SetBigint
 
 /***********************************************************************/
@@ -1491,17 +1653,21 @@ void JVALUE::SetBigint(PGLOBAL g, long long ll)
 /***********************************************************************/
 void JVALUE::SetFloat(PGLOBAL g, double f)
 {
-  Value = AllocateValue(g, &f, TYPE_DOUBLE, 6);
-	Jsp = NULL;
+  Val = AllocVal(g, TYPE_DBL);
+  Val->F = f;
+  Val->Nd = 6;
+  Jsp = NULL;
 } // end of SetFloat
 
 /***********************************************************************/
 /* Set the Value's value as the given string.                          */
 /***********************************************************************/
-void JVALUE::SetString(PGLOBAL g, PSZ s, short c)
+void JVALUE::SetString(PGLOBAL g, PSZ s, int ci)
 {
-  Value = AllocateValue(g, s, TYPE_STRING, c);
-	Jsp = NULL;
+  Val = AllocVal(g, TYPE_STRG);
+  Val->Strp = s;
+  Val->Nd = ci;
+  Jsp = NULL;
 } // end of SetString
 
 /***********************************************************************/
@@ -1509,6 +1675,228 @@ void JVALUE::SetString(PGLOBAL g, PSZ s, short c)
 /***********************************************************************/
 bool JVALUE::IsNull(void)
 {
-  return (Jsp) ? Jsp->IsNull() : (Value) ? Value->IsNull() : true;
+  return (Jsp) ? Jsp->IsNull() : (Val) ? Val->Type == TYPE_NULL : true;
 } // end of IsNull
 
+
+/* ---------------------------- Class SWAP --------------------------- */
+
+/***********************************************************************/
+/* Replace all pointers by offsets or the opposite.                    */
+/***********************************************************************/
+void SWAP::SwapJson(PJSON jsp, bool move)
+{
+  if (move)
+    MoffJson(jsp);
+  else
+    MptrJson((PJSON)MakeOff(Base, jsp));
+
+  return;
+} // end of SwapJson
+
+/***********************************************************************/
+/* Replace all pointers by offsets.                                    */
+/***********************************************************************/
+size_t SWAP::MoffJson(PJSON jsp) {
+  size_t res;
+
+  if (jsp)
+    switch (jsp->Type) {
+    case TYPE_JAR:
+      res = MoffArray((PJAR)jsp);
+      break;
+    case TYPE_JOB:
+      res = MoffObject((PJOB)jsp);
+      break;
+    case TYPE_JVAL:
+      res = MoffJValue((PJVAL)jsp);
+      break;
+    default:
+      throw "Invalid json tree";
+    } // endswitch Type
+
+  return res;
+} // end of MoffJson
+
+/***********************************************************************/
+/* Replace all array pointers by offsets.                              */
+/***********************************************************************/
+size_t SWAP::MoffArray(PJAR jarp)
+{
+  if (jarp->First) {
+    for (int i = 0; i < jarp->Size; i++)
+      jarp->Mvals[i] = (PJVAL)MakeOff(Base, jarp->Mvals[i]);
+
+    jarp->First = (PJVAL)MoffJValue(jarp->First);
+    jarp->Last = (PJVAL)MakeOff(Base, jarp->Last);
+  } // endif First
+
+  return MakeOff(Base, jarp);
+} // end of MoffArray
+
+/***********************************************************************/
+/* Replace all object pointers by offsets.                             */
+/***********************************************************************/
+size_t SWAP::MoffObject(PJOB jobp) {
+  if (jobp->First) {
+    jobp->First = (PJPR)MoffPair(jobp->First);
+    jobp->Last = (PJPR)MakeOff(Base, jobp->Last);
+  } // endif First
+
+  return MakeOff(Base, jobp);
+} // end of MoffObject
+
+/***********************************************************************/
+/* Replace all pair pointers by offsets.                               */
+/***********************************************************************/
+size_t SWAP::MoffPair(PJPR jpp) {
+  jpp->Key = (PCSZ)MakeOff(Base, (void*)jpp->Key);
+
+  if (jpp->Val)
+    jpp->Val = (PJVAL)MoffJValue(jpp->Val);
+
+  if (jpp->Next)
+    jpp->Next = (PJPR)MoffPair(jpp->Next);
+
+  return MakeOff(Base, jpp);
+} // end of MoffPair
+
+/***********************************************************************/
+/* Replace all jason value pointers by offsets.                        */
+/***********************************************************************/
+size_t SWAP::MoffJValue(PJVAL jvp) {
+  if (!jvp->Del) {
+    if (jvp->Jsp)
+      jvp->Jsp = (PJSON)MoffJson(jvp->Jsp);
+
+    if (jvp->Val)
+      jvp->Val = (PVL)MoffVal(jvp->Val);
+
+  } // endif Del
+
+  if (jvp->Next)
+    jvp->Next = (PJVAL)MoffJValue(jvp->Next);
+
+  return MakeOff(Base, jvp);
+} // end of MoffJValue
+
+/***********************************************************************/
+/* Replace string pointers by offset.                                  */
+/***********************************************************************/
+size_t SWAP::MoffVal(PVL vlp) {
+  if (vlp->Type == TYPE_STRG)
+    vlp->Strp = (PSZ)MakeOff(Base, (vlp->Strp));
+
+  return MakeOff(Base, vlp);
+} // end of MoffVal
+
+/***********************************************************************/
+/* Replace all offsets by pointers.                                    */
+/***********************************************************************/
+PJSON SWAP::MptrJson(PJSON ojp) {      // ojp is an offset
+  PJSON jsp = (PJSON)MakePtr(Base, (size_t)ojp);
+
+  if (ojp)
+    switch (jsp->Type) {
+    case TYPE_JAR:
+      jsp = MptrArray((PJAR)ojp);
+      break;
+    case TYPE_JOB:
+      jsp = MptrObject((PJOB)ojp);
+      break;
+    case TYPE_JVAL:
+      jsp = MptrJValue((PJVAL)ojp);
+      break;
+    default:
+      throw "Invalid json tree";
+    } // endswitch Type
+
+  return jsp;
+} // end of MptrJson
+
+/***********************************************************************/
+/* Replace all array offsets by pointers.                              */
+/***********************************************************************/
+PJAR SWAP::MptrArray(PJAR ojar) {
+  PJAR jarp = (PJAR)MakePtr(Base, (size_t)ojar);
+
+  jarp = (PJAR)new((size_t)jarp) JARRAY(NULL);
+
+  if (jarp->First) {
+    for (int i = 0; i < jarp->Size; i++)
+      jarp->Mvals[i] = (PJVAL)MakePtr(Base, (size_t)jarp->Mvals[i]);
+
+    jarp->First = (PJVAL)MptrJValue(jarp->First);
+    jarp->Last = (PJVAL)MakePtr(Base, (size_t)jarp->Last);
+  } // endif First
+
+  return jarp;
+} // end of MptrArray
+
+/***********************************************************************/
+/* Replace all object offsets by pointers.                             */
+/***********************************************************************/
+PJOB SWAP::MptrObject(PJOB ojob) {
+  PJOB jobp = (PJOB)MakePtr(Base, (size_t)ojob);
+
+  jobp = (PJOB)new((size_t)jobp) JOBJECT(NULL);
+
+  if (jobp->First) {
+    jobp->First = (PJPR)MptrPair(jobp->First);
+    jobp->Last = (PJPR)MakePtr(Base, (size_t)jobp->Last);
+  } // endif First
+
+  return jobp;
+} // end of MptrObject
+
+/***********************************************************************/
+/* Replace all pair offsets by pointers.                               */
+/***********************************************************************/
+PJPR SWAP::MptrPair(PJPR ojp) {
+  PJPR jpp = (PJPR)MakePtr(Base, (size_t)ojp);
+
+  jpp->Key = (PCSZ)MakePtr(Base, (size_t)jpp->Key);
+
+  if (jpp->Val)
+    jpp->Val = (PJVAL)MptrJValue(jpp->Val);
+
+  if (jpp->Next)
+    jpp->Next = (PJPR)MptrPair(jpp->Next);
+
+  return jpp;
+} // end of MptrPair
+
+/***********************************************************************/
+/* Replace all value offsets by pointers.                              */
+/***********************************************************************/
+PJVAL SWAP::MptrJValue(PJVAL ojv) {
+  PJVAL jvp = (PJVAL)MakePtr(Base, (size_t)ojv);
+
+  jvp = (PJVAL)new((size_t)jvp) JVALUE(0);
+
+  if (!jvp->Del) {
+    if (jvp->Jsp)
+      jvp->Jsp = (PJSON)MptrJson(jvp->Jsp);
+
+    if (jvp->Val)
+      jvp->Val = (PVL)MptrVal(jvp->Val);
+
+  } // endif Del
+
+  if (jvp->Next)
+    jvp->Next = (PJVAL)MptrJValue(jvp->Next);
+
+  return jvp;
+} // end of MptrJValue
+
+/***********************************************************************/
+/* Replace string offsets by a pointer.                                */
+/***********************************************************************/
+PVL SWAP::MptrVal(PVL ovl) {
+  PVL vlp = (PVL)MakePtr(Base, (size_t)ovl);
+
+  if (vlp->Type == TYPE_STRG)
+    vlp->Strp = (PSZ)MakePtr(Base, (size_t)vlp->Strp);
+
+  return vlp;
+} // end of MptrValue
diff --git a/storage/connect/json.h b/storage/connect/json.h
index bc94b372133..c457a3fec45 100644
--- a/storage/connect/json.h
+++ b/storage/connect/json.h
@@ -27,27 +27,48 @@ enum JTYP {TYPE_NULL = TYPE_VOID,
            TYPE_JOB, 
            TYPE_JVAL};
 
+class JDOC;
 class JOUT;
 class JSON;
-class JMAP;
 class JVALUE;
 class JOBJECT;
 class JARRAY;
 
-typedef class JPAIR   *PJPR;
+typedef class JDOC    *PJDOC;
 typedef class JSON    *PJSON;
 typedef class JVALUE  *PJVAL;
 typedef class JOBJECT *PJOB;
 typedef class JARRAY  *PJAR;
 
-typedef struct {
-  char *str;
-  int   len;
-  } STRG, *PSG;
-
 // BSON size should be equal on Linux and Windows
 #define BMX 255
-typedef struct BSON* PBSON;
+typedef struct BSON  *PBSON;
+typedef struct JPAIR *PJPR;
+typedef struct VAL   *PVL;
+
+/***********************************************************************/
+/* Structure JPAIR. The pairs of a json Object.                        */
+/***********************************************************************/
+struct JPAIR {
+	PCSZ  Key;      // This pair key name
+	PJVAL Val;      // To the value of the pair
+	PJPR  Next;     // To the next pair
+}; // end of struct JPAIR
+
+/***********************************************************************/
+/* Structure VAL (string, int, float, bool or null)                    */
+/***********************************************************************/
+struct VAL {
+	union {
+		char     *Strp;      // Ptr to a string
+		int       N;         // An integer value
+		long long LLn;			 // A big integer value
+		double    F;				 // A float value
+		bool      B;				 // True or false
+	};
+	int         Nd;				 // Decimal number
+	JTYP        Type;      // The value type
+}; // end of struct VAL
 
 /***********************************************************************/
 /*  Structure used to return binary json to Json UDF functions.        */
@@ -65,176 +86,111 @@ struct BSON {
 }; // end of struct BSON
 
 PBSON JbinAlloc(PGLOBAL g, UDF_ARGS* args, ulong len, PJSON jsp);
-
+PVL   AllocVal(PGLOBAL g, JTYP type);
 char *NextChr(PSZ s, char sep);
 char *GetJsonNull(void);
+const char* GetFmt(int type, bool un);
 
-PJSON ParseJson(PGLOBAL g, char* s, int n, int* prty = NULL, bool* b = NULL);
+PJSON ParseJson(PGLOBAL g, char* s, size_t n, int* prty = NULL, bool* b = NULL);
 PSZ   Serialize(PGLOBAL g, PJSON jsp, char *fn, int pretty);
-bool  SerializeArray(JOUT *js, PJAR jarp, bool b);
-bool  SerializeObject(JOUT *js, PJOB jobp);
-bool  SerializeValue(JOUT *js, PJVAL jvp);
-char *NextChr(PSZ s, char sep);
 DllExport bool IsNum(PSZ s);
 
 /***********************************************************************/
-/* Class JOUT. Used by Serialize.                                      */
-/***********************************************************************/
-class JOUT : public BLOCK {
- public:
-	JOUT(PGLOBAL gp) : BLOCK() {g = gp; Pretty = 3;}
-
-  virtual bool WriteStr(const char *s) = 0;
-  virtual bool WriteChr(const char c) = 0;
-  virtual bool Escape(const char *s) = 0;
-					int  Prty(void) {return Pretty;}
-
-  // Member
-  PGLOBAL g;
-	int     Pretty;
-}; // end of class JOUT
-
-/***********************************************************************/
-/* Class JOUTSTR. Used to Serialize to a string.                       */
-/***********************************************************************/
-class JOUTSTR : public JOUT {
- public:
-  JOUTSTR(PGLOBAL g);
-
-  virtual bool WriteStr(const char *s);
-  virtual bool WriteChr(const char c);
-  virtual bool Escape(const char *s);
-
-  // Member
-  char  *Strp;                         // The serialized string
-  size_t N;                            // Position of next char
-  size_t Max;                          // String max size
-}; // end of class JOUTSTR
-
-/***********************************************************************/
-/* Class JOUTFILE. Used to Serialize to a file.                        */
-/***********************************************************************/
-class JOUTFILE : public JOUT {
- public:
-	JOUTFILE(PGLOBAL g, FILE *str, int pty) : JOUT(g) {Stream = str; Pretty = pty;}
-
-  virtual bool WriteStr(const char *s);
-  virtual bool WriteChr(const char c);
-  virtual bool Escape(const char *s);
-
-  // Member
-  FILE *Stream;
-}; // end of class JOUTFILE
-
-/***********************************************************************/
-/* Class JOUTPRT. Used to Serialize to a pretty file.                  */
-/***********************************************************************/
-class JOUTPRT : public JOUTFILE {
- public:
-  JOUTPRT(PGLOBAL g, FILE *str) : JOUTFILE(g, str, 2) {M = 0; B = false;}
-
-  virtual bool WriteStr(const char *s);
-  virtual bool WriteChr(const char c);
-
-  // Member
-  int  M;
-  bool B;
-}; // end of class JOUTPRT
-
-/***********************************************************************/
-/* Class PAIR. The pairs of a json Object.                             */
+/* Class JDOC. The class for parsing and serializing json documents.   */
 /***********************************************************************/
-class JPAIR : public BLOCK {
-  friend class JOBJECT;
-	friend class JSNX;
-	friend class JSON;
-  friend bool SerializeObject(JOUT *, PJOB);
- public:
-  JPAIR(PCSZ key) : BLOCK() {Key = key; Val = NULL; Next = NULL;}
+class JDOC: public BLOCK {
+	friend PJSON ParseJson(PGLOBAL, char*, size_t, int*, bool*);
+	friend PSZ Serialize(PGLOBAL, PJSON, char*, int);
+public:
+	JDOC(void) : js(NULL), s(NULL), len(0), pty(NULL) {}
 
-  inline PCSZ  GetKey(void) {return Key;}
-  inline PJVAL GetVal(void) {return Val;}
-  inline PJPR  GetNext(void) {return Next;}
+	void  SetJp(JOUT* jp) { js = jp; }
 
  protected:
-  PCSZ  Key;      // This pair key name
-  PJVAL Val;      // To the value of the pair
-  PJPR  Next;     // To the next pair
-}; // end of class JPAIR
+	PJAR  ParseArray(PGLOBAL g, int& i);
+	PJOB  ParseObject(PGLOBAL g, int& i);
+	PJVAL ParseValue(PGLOBAL g, int& i);
+	char *ParseString(PGLOBAL g, int& i);
+	PVL   ParseNumeric(PGLOBAL g, int& i);
+	PJAR  ParseAsArray(PGLOBAL g, int& i, int pretty, int *ptyp);
+	bool  SerializeArray(PJAR jarp, bool b);
+	bool  SerializeObject(PJOB jobp);
+	bool  SerializeValue(PJVAL jvp);
+
+	// Members used when parsing and serializing
+ private:
+	JOUT* js;
+	char *s;
+	int   len;
+	bool *pty;
+}; // end of class JDOC
 
 /***********************************************************************/
 /* Class JSON. The base class for all other json classes.              */
 /***********************************************************************/
 class JSON : public BLOCK {
-	friend PJSON ParseJson(PGLOBAL, char*, int, int*, bool*);
- public:
-	 JSON(void) : s(NULL), len(0), pty(NULL) {Size = 0;}
-
-          int    size(void) {return Size;}
-	virtual int    GetSize(bool b) {return Size;}
-  virtual void   Clear(void) {Size = 0;}
-  virtual JTYP   GetType(void) {return TYPE_JSON;}
-  virtual JTYP   GetValType(void) {X return TYPE_JSON;}
-  virtual void   InitArray(PGLOBAL g) {X}
-//virtual PJVAL  AddValue(PGLOBAL g, PJVAL jvp = NULL, int *x = NULL) {X return NULL;}
-  virtual PJPR   AddPair(PGLOBAL g, PCSZ key) {X return NULL;}
-	virtual PJAR   GetKeyList(PGLOBAL g) {X return NULL;}
-	virtual PJAR   GetValList(PGLOBAL g) {X return NULL;}
-	virtual PJVAL  GetValue(const char *key) {X return NULL;}
-  virtual PJOB   GetObject(void) {return NULL;}
-  virtual PJAR   GetArray(void) {return NULL;}
-	virtual PJVAL  GetValue(int i) {X return NULL;}
-  virtual PVAL   GetValue(void) {X return NULL;}
+public:
+	// Constructor
+	JSON(void) { Type = TYPE_JSON; }
+	JSON(int) {}
+
+	// Implementation
+	inline  JTYP   GetType(void) { return Type; }
+
+	// Methods
+	virtual int    size(void) { return 1; }
+	virtual JTYP   GetValType(void) { X return TYPE_JSON; }
+	virtual void   InitArray(PGLOBAL g) { X }
+	//virtual PJVAL  AddValue(PGLOBAL g, PJVAL jvp = NULL, int *x = NULL) {X return NULL;}
+	virtual PJPR   AddPair(PGLOBAL g, PCSZ key) { X return NULL; }
+	virtual void   Clear(void) { X }
+	virtual PJAR   GetKeyList(PGLOBAL g) { X return NULL; }
+	virtual PJAR   GetValList(PGLOBAL g) { X return NULL; }
+	virtual PJVAL  GetValue(const char* key) { X return NULL; }
+	virtual PJOB   GetObject(void) { return NULL; }
+	virtual PJAR   GetArray(void) { return NULL; }
+	virtual PJVAL  GetValue(int i) { X return NULL; }
+	virtual int    GetSize(bool b) { X return 0; }
+	//virtual PVL    GetVal(void) { X return NULL; }
 	virtual PJSON  GetJsp(void) { X return NULL; }
 	virtual PJSON  GetJson(void) { X return NULL; }
-  virtual PJPR   GetFirst(void) {X return NULL;}
-  virtual int    GetInteger(void) {X return 0;}
-  virtual double GetFloat() {X return 0.0;}
-  virtual PSZ    GetString(PGLOBAL g) {X return NULL;}
-  virtual PSZ    GetText(PGLOBAL g, PSZ text) {X return NULL;}
+	virtual PJPR   GetFirst(void) { X return NULL; }
+	virtual int    GetInteger(void) { X return 0; }
+	virtual double GetFloat() { X return 0.0; }
+	virtual PSZ    GetString(PGLOBAL g) { X return NULL; }
+	virtual PSZ    GetText(PGLOBAL g, PSZ text) { X return NULL; }
 	virtual bool   Merge(PGLOBAL g, PJSON jsp) { X return true; }
 	virtual bool   SetValue(PGLOBAL g, PJVAL jvp, int i) { X return true; }
-  virtual void   SetValue(PGLOBAL g, PJVAL jvp, PCSZ key) {X}
-  virtual void   SetValue(PVAL valp) {X}
-  virtual void   SetValue(PJSON jsp) {X}
-  virtual void   SetString(PGLOBAL g, PSZ s, short c) {X}
-  virtual void   SetInteger(PGLOBAL g, int n) {X}
-  virtual void   SetFloat(PGLOBAL g, double f) {X}
-	virtual void   DeleteKey(PCSZ k) {X}
-	virtual bool   DeleteValue(int i) {X return true;}
-	virtual bool   IsNull(void) {X return true;}
-
- protected:
-	PJAR  ParseArray(PGLOBAL g, int& i);
-	PJOB  ParseObject(PGLOBAL g, int& i);
-	PJVAL ParseValue(PGLOBAL g, int& i);
-	char *ParseString(PGLOBAL g, int& i);
-	PVAL  ParseNumeric(PGLOBAL g, int& i);
-	PJAR  ParseAsArray(PGLOBAL g, int& i, int pretty, int *ptyp);
+	virtual void   SetValue(PGLOBAL g, PJVAL jvp, PCSZ key) { X }
+	virtual void   SetVal(PVL vlp) { X }
+	virtual void   SetValue(PGLOBAL g, PVAL valp) { X }
+	virtual void   SetValue(PJSON jsp) { X }
+	virtual void   SetString(PGLOBAL g, PSZ s, short c) { X }
+	virtual void   SetInteger(PGLOBAL g, int n) { X }
+	virtual void   SetFloat(PGLOBAL g, double f) { X }
+	virtual void   DeleteKey(PCSZ k) { X }
+	virtual bool   DeleteValue(int i) { X return true; }
+	virtual bool   IsNull(void) { X return true; }
 
 	// Members
-	int Size;
-
-	// Only used when parsing
- private:
-	char *s;
-	int   len;
-	bool *pty;
+	JTYP Type;
 }; // end of class JSON
 
 /***********************************************************************/
 /* Class JOBJECT: contains a list of value pairs.                      */
 /***********************************************************************/
 class JOBJECT : public JSON {
-  friend bool SerializeObject(JOUT *, PJOB);
+  friend class JDOC;
 	friend class JSNX;
- public:
-  JOBJECT(void) : JSON() {First = Last = NULL;}
-
-  using JSON::GetValue;
-  using JSON::SetValue;
-	virtual void  Clear(void) {First = Last = NULL; Size = 0;}
-  virtual JTYP  GetType(void) {return TYPE_JOB;}
+	friend class SWAP;
+public:
+	JOBJECT(void) : JSON() { Type = TYPE_JOB; First = Last = NULL; }
+	JOBJECT(int i) : JSON(i) {}
+
+  //using JSON::GetVal;
+  //using JSON::SetVal;
+	virtual void  Clear(void) {First = Last = NULL;}
+//virtual JTYP  GetValType(void) {return TYPE_JOB;}
   virtual PJPR  GetFirst(void) {return First;}
 	virtual int   GetSize(bool b);
 	virtual PJPR  AddPair(PGLOBAL g, PCSZ key);
@@ -257,13 +213,16 @@ class JOBJECT : public JSON {
 /* Class JARRAY.                                                       */
 /***********************************************************************/
 class JARRAY : public JSON {
-  friend PJAR ParseArray(PGLOBAL, int&, STRG&, bool*);
+	friend class SWAP;
  public:
-  JARRAY(void) : JSON() {Alloc = 0; First = Last = NULL; Mvals = NULL;}
+	JARRAY(void) : JSON()
+	 { Type = TYPE_JAR;  Alloc = 0; First = Last = NULL; Mvals = NULL; }
+	JARRAY(int i) : JSON(i) {}
 
-  using JSON::GetValue;
-  using JSON::SetValue;
+  //using JSON::GetVal;
+  //using JSON::SetVal;
   virtual void  Clear(void) {First = Last = NULL; Size = 0;}
+	virtual int   size(void) { return Size; }
 	virtual JTYP  GetType(void) {return TYPE_JAR;}
   virtual PJAR  GetArray(void) {return this;}
 	virtual int   GetSize(bool b);
@@ -278,6 +237,7 @@ class JARRAY : public JSON {
 
  protected:
   // Members
+	int    Size;		 // The number of items in the array
   int    Alloc;    // The Mvals allocated size
   PJVAL  First;    // Used when constructing
   PJVAL  Last;     // Last constructed value
@@ -292,22 +252,26 @@ class JVALUE : public JSON {
 	friend class JSNX;
 	friend class JSONCOL;
   friend class JSON;
-	friend bool SerializeValue(JOUT*, PJVAL);
- public:
-  JVALUE(void) : JSON() {Clear();}
+	friend class JDOC;
+	friend class SWAP;
+public:
+	JVALUE(void) : JSON() { Type = TYPE_JVAL; Clear(); }
 	JVALUE(PJSON jsp);
+	JVALUE(PGLOBAL g, PVL vlp);
 	JVALUE(PGLOBAL g, PVAL valp);
 	JVALUE(PGLOBAL g, PCSZ strp);
+	JVALUE(int i) : JSON(i) {}
 
-  using JSON::GetValue;
-  using JSON::SetValue;
+  //using JSON::GetVal;
+  //using JSON::SetVal;
   virtual void   Clear(void)
-          {Jsp = NULL; Value = NULL; Next = NULL; Del = false; Size = 1;}
+          {Jsp = NULL; Val = NULL; Next = NULL; Del = false;}
   virtual JTYP   GetType(void) {return TYPE_JVAL;}
   virtual JTYP   GetValType(void);
   virtual PJOB   GetObject(void);
   virtual PJAR   GetArray(void);
-  virtual PVAL   GetValue(void) {return Value;}
+  inline  PVL    GetVal(void) {return Val;}
+					PVAL   GetValue(PGLOBAL g);
   virtual PJSON  GetJsp(void) {return Jsp;}
 	virtual PJSON  GetJson(void) { return (Jsp ? Jsp : this); }
 	virtual int    GetInteger(void);
@@ -316,17 +280,118 @@ class JVALUE : public JSON {
   virtual PSZ    GetString(PGLOBAL g);
   virtual PSZ    GetText(PGLOBAL g, PSZ text);
 	virtual void   SetValue(PJSON jsp);
-	virtual void   SetValue(PVAL valp) { Value = valp; Jsp = NULL; }
-	virtual void   SetString(PGLOBAL g, PSZ s, short c = 0);
+	virtual void   SetValue(PGLOBAL g, PVAL valp);
+	inline  void   SetVal(PVL vlp) { Val = vlp; }
+	virtual void   SetString(PGLOBAL g, PSZ s, int ci = 0);
   virtual void   SetInteger(PGLOBAL g, int n);
 	virtual void   SetBigint(PGLOBAL g, longlong ll);
 	virtual void   SetFloat(PGLOBAL g, double f);
-	virtual void   SetTiny(PGLOBAL g, char f);
+	virtual void   SetBool(PGLOBAL g, bool b);
 	virtual bool   IsNull(void);
 
  protected:
   PJSON Jsp;      // To the json value
-  PVAL  Value;    // The numeric value
+  PVL   Val;      // To the string or numeric value
   PJVAL Next;     // Next value in array
   bool  Del;      // True when deleted
 }; // end of class JVALUE
+
+
+/***********************************************************************/
+/* Class JOUT. Used by Serialize.                                      */
+/***********************************************************************/
+class JOUT : public BLOCK {
+public:
+	JOUT(PGLOBAL gp) : BLOCK() { g = gp; Pretty = 3; }
+
+	virtual bool WriteStr(const char* s) = 0;
+	virtual bool WriteChr(const char c) = 0;
+	virtual bool Escape(const char* s) = 0;
+	int  Prty(void) { return Pretty; }
+
+	// Member
+	PGLOBAL g;
+	int     Pretty;
+}; // end of class JOUT
+
+/***********************************************************************/
+/* Class JOUTSTR. Used to Serialize to a string.                       */
+/***********************************************************************/
+class JOUTSTR : public JOUT {
+public:
+	JOUTSTR(PGLOBAL g);
+
+	virtual bool WriteStr(const char* s);
+	virtual bool WriteChr(const char c);
+	virtual bool Escape(const char* s);
+
+	// Member
+	char* Strp;                         // The serialized string
+	size_t N;                            // Position of next char
+	size_t Max;                          // String max size
+}; // end of class JOUTSTR
+
+/***********************************************************************/
+/* Class JOUTFILE. Used to Serialize to a file.                        */
+/***********************************************************************/
+class JOUTFILE : public JOUT {
+public:
+	JOUTFILE(PGLOBAL g, FILE* str, int pty) : JOUT(g) { Stream = str; Pretty = pty; }
+
+	virtual bool WriteStr(const char* s);
+	virtual bool WriteChr(const char c);
+	virtual bool Escape(const char* s);
+
+	// Member
+	FILE* Stream;
+}; // end of class JOUTFILE
+
+/***********************************************************************/
+/* Class JOUTPRT. Used to Serialize to a pretty file.                  */
+/***********************************************************************/
+class JOUTPRT : public JOUTFILE {
+public:
+	JOUTPRT(PGLOBAL g, FILE* str) : JOUTFILE(g, str, 2) { M = 0; B = false; }
+
+	virtual bool WriteStr(const char* s);
+	virtual bool WriteChr(const char c);
+
+	// Member
+	int  M;
+	bool B;
+}; // end of class JOUTPRT
+
+
+/***********************************************************************/
+/* Class SWAP. Used to make or unmake a JSON tree movable.             */
+/* This is done by making all pointers to offsets.                     */
+/***********************************************************************/
+class SWAP : public BLOCK {
+public:
+	// Constructor
+	SWAP(PGLOBAL g, PJSON jsp) 
+	{
+		G = g, Base = (char*)jsp - 8;
+	}
+
+	// Methods
+	void   SwapJson(PJSON jsp, bool move);
+
+protected:
+	size_t MoffJson(PJSON jnp);
+	size_t MoffArray(PJAR jarp);
+	size_t MoffObject(PJOB jobp);
+	size_t MoffJValue(PJVAL jvp);
+	size_t MoffPair(PJPR jpp);
+	size_t MoffVal(PVL vlp);
+	PJSON  MptrJson(PJSON jnp);
+	PJAR   MptrArray(PJAR jarp);
+	PJOB   MptrObject(PJOB jobp);
+	PJVAL  MptrJValue(PJVAL jvp);
+	PJPR   MptrPair(PJPR jpp);
+	PVL    MptrVal(PVL vlp);
+
+	// Member
+	PGLOBAL G, NG;
+	void   *Base;
+}; // end of class SWAP
diff --git a/storage/connect/jsonudf.cpp b/storage/connect/jsonudf.cpp
index 06164f4ed78..6354b92107a 100644
--- a/storage/connect/jsonudf.cpp
+++ b/storage/connect/jsonudf.cpp
@@ -355,11 +355,20 @@ void JSNX::SetJsonValue(PGLOBAL g, PVAL vp, PJVAL val, int n)
 		if (Jb) {
 			vp->SetValue_psz(Serialize(g, val->GetJsp(), NULL, 0));
 		} else switch (val->GetValType()) {
+			case TYPE_DTM:
 			case TYPE_STRG:
+				vp->SetValue_psz(val->GetString(g));
+				break;
 			case TYPE_INTG:
 			case TYPE_BINT:
+				vp->SetValue(val->GetInteger());
+				break;
 			case TYPE_DBL:
-				vp->SetValue_pval(val->GetValue());
+				if (vp->IsTypeNum())
+					vp->SetValue(val->GetFloat());
+				else // Get the proper number of decimals
+					vp->SetValue_psz(val->GetString(g));
+
 				break;
 			case TYPE_BOOL:
 				if (vp->IsTypeNum())
@@ -430,7 +439,7 @@ PJVAL JSNX::GetRowValue(PGLOBAL g, PJSON row, int i, my_bool b)
 
 	for (; i < Nod && row; i++) {
 		if (Nodes[i].Op == OP_NUM) {
-			Value->SetValue(row->GetType() == TYPE_JAR ? row->size() : 1);
+			Value->SetValue(row->GetType() == TYPE_JAR ? ((PJAR)row)->size() : 1);
 			val = new(g) JVALUE(g, Value);
 			return val;
 		} else if (Nodes[i].Op == OP_XX) {
@@ -526,10 +535,10 @@ PVAL JSNX::CalculateArray(PGLOBAL g, PJAR arp, int n)
 
 		if (!jvrp->IsNull() || (op == OP_CNC && GetJsonNull())) {
 			if (jvrp->IsNull()) {
-				jvrp->Value = AllocateValue(g, GetJsonNull(), TYPE_STRING);
+				jvrp->SetString(g, GetJsonNull(), 0);
 				jvp = jvrp;
 			} else if (n < Nod - 1 && jvrp->GetJson()) {
-				jval.SetValue(GetColumnValue(g, jvrp->GetJson(), n + 1));
+				jval.SetValue(g, GetColumnValue(g, jvrp->GetJson(), n + 1));
 				jvp = &jval;
 			} else
 				jvp = jvrp;
@@ -781,13 +790,13 @@ PSZ JSNX::Locate(PGLOBAL g, PJSON jsp, PJVAL jvp, int k)
 
 		switch (jsp->GetType()) {
 			case TYPE_JAR:
-				err = LocateArray((PJAR)jsp);
+				err = LocateArray(g, (PJAR)jsp);
 				break;
 			case TYPE_JOB:
-				err = LocateObject((PJOB)jsp);
+				err = LocateObject(g, (PJOB)jsp);
 				break;
 			case TYPE_JVAL:
-				err = LocateValue((PJVAL)jsp);
+				err = LocateValue(g, (PJVAL)jsp);
 				break;
 			default:
 				err = true;
@@ -818,7 +827,7 @@ PSZ JSNX::Locate(PGLOBAL g, PJSON jsp, PJVAL jvp, int k)
 /*********************************************************************************/
 /*  Locate in a JSON Array.                                                      */
 /*********************************************************************************/
-my_bool JSNX::LocateArray(PJAR jarp)
+my_bool JSNX::LocateArray(PGLOBAL g, PJAR jarp)
 {
 	char   s[16];
 	size_t m = Jp->N;
@@ -830,7 +839,7 @@ my_bool JSNX::LocateArray(PJAR jarp)
 		if (Jp->WriteStr(s))
 			return true;
 
-		if (LocateValue(jarp->GetValue(i)))
+		if (LocateValue(g, jarp->GetValue(i)))
 			return true;
 
 		} // endfor i
@@ -841,7 +850,7 @@ my_bool JSNX::LocateArray(PJAR jarp)
 /*********************************************************************************/
 /*  Locate in a JSON Object.                                                     */
 /*********************************************************************************/
-my_bool JSNX::LocateObject(PJOB jobp)
+my_bool JSNX::LocateObject(PGLOBAL g, PJOB jobp)
 {
 	size_t m;
 
@@ -856,7 +865,7 @@ my_bool JSNX::LocateObject(PJOB jobp)
 		if (Jp->WriteStr(pair->Key))
 			return true;
 
-		if (LocateValue(pair->Val))
+		if (LocateValue(g, pair->Val))
 			return true;
 
 		} // endfor i
@@ -867,14 +876,14 @@ my_bool JSNX::LocateObject(PJOB jobp)
 /*********************************************************************************/
 /*  Locate a JSON Value.                                                         */
 /*********************************************************************************/
-my_bool JSNX::LocateValue(PJVAL jvp)
+my_bool JSNX::LocateValue(PGLOBAL g, PJVAL jvp)
 {
-	if (CompareTree(Jvalp, jvp))
+	if (CompareTree(g, Jvalp, jvp))
 		Found = (--K == 0);
 	else if (jvp->GetArray())
-		return LocateArray(jvp->GetArray());
+		return LocateArray(g, jvp->GetArray());
 	else if (jvp->GetObject())
-		return LocateObject(jvp->GetObject());
+		return LocateObject(g, jvp->GetObject());
 
 	return false;
 } // end of LocateValue
@@ -907,13 +916,13 @@ PSZ JSNX::LocateAll(PGLOBAL g, PJSON jsp, PJVAL jvp, int mx)
 
 		switch (jsp->GetType()) {
 			case TYPE_JAR:
-				err = LocateArrayAll((PJAR)jsp);
+				err = LocateArrayAll(g, (PJAR)jsp);
 				break;
 			case TYPE_JOB:
-				err = LocateObjectAll((PJOB)jsp);
+				err = LocateObjectAll(g, (PJOB)jsp);
 				break;
 			case TYPE_JVAL:
-				err = LocateValueAll((PJVAL)jsp);
+				err = LocateValueAll(g, (PJVAL)jsp);
 				break;
 			default:
 				err = true;
@@ -945,7 +954,7 @@ PSZ JSNX::LocateAll(PGLOBAL g, PJSON jsp, PJVAL jvp, int mx)
 /*********************************************************************************/
 /*  Locate in a JSON Array.                                                      */
 /*********************************************************************************/
-my_bool JSNX::LocateArrayAll(PJAR jarp)
+my_bool JSNX::LocateArrayAll(PGLOBAL g, PJAR jarp)
 {
 	if (I < Imax) {
 		Jpnp[++I].Type = TYPE_JAR;
@@ -953,7 +962,7 @@ my_bool JSNX::LocateArrayAll(PJAR jarp)
 		for (int i = 0; i < jarp->size(); i++) {
 			Jpnp[I].N = i;
 
-			if (LocateValueAll(jarp->GetValue(i)))
+			if (LocateValueAll(g, jarp->GetValue(i)))
 				return true;
 
 		} // endfor i
@@ -967,7 +976,7 @@ my_bool JSNX::LocateArrayAll(PJAR jarp)
 /*********************************************************************************/
 /*  Locate in a JSON Object.                                                     */
 /*********************************************************************************/
-my_bool JSNX::LocateObjectAll(PJOB jobp)
+my_bool JSNX::LocateObjectAll(PGLOBAL g, PJOB jobp)
 {
 	if (I < Imax) {
 		Jpnp[++I].Type = TYPE_JOB;
@@ -975,7 +984,7 @@ my_bool JSNX::LocateObjectAll(PJOB jobp)
 		for (PJPR pair = jobp->First; pair; pair = pair->Next) {
 			Jpnp[I].Key = pair->Key;
 
-			if (LocateValueAll(pair->Val))
+			if (LocateValueAll(g, pair->Val))
 				return true;
 
 		} // endfor i
@@ -989,14 +998,14 @@ my_bool JSNX::LocateObjectAll(PJOB jobp)
 /*********************************************************************************/
 /*  Locate a JSON Value.                                                         */
 /*********************************************************************************/
-my_bool JSNX::LocateValueAll(PJVAL jvp)
+my_bool JSNX::LocateValueAll(PGLOBAL g, PJVAL jvp)
 {
-	if (CompareTree(Jvalp, jvp))
+	if (CompareTree(g, Jvalp, jvp))
 		return AddPath();
 	else if (jvp->GetArray())
-		return LocateArrayAll(jvp->GetArray());
+		return LocateArrayAll(g, jvp->GetArray());
 	else if (jvp->GetObject())
-		return LocateObjectAll(jvp->GetObject());
+		return LocateObjectAll(g, jvp->GetObject());
 
 	return false;
 } // end of LocateValueAll
@@ -1004,7 +1013,7 @@ my_bool JSNX::LocateValueAll(PJVAL jvp)
 /*********************************************************************************/
 /*  Compare two JSON trees.                                                      */
 /*********************************************************************************/
-my_bool JSNX::CompareTree(PJSON jp1, PJSON jp2)
+my_bool JSNX::CompareTree(PGLOBAL g, PJSON jp1, PJSON jp2)
 {
 	if (!jp1 || !jp2 || jp1->GetType() != jp2->GetType()
 		               || jp1->size() != jp2->size())
@@ -1013,26 +1022,22 @@ my_bool JSNX::CompareTree(PJSON jp1, PJSON jp2)
 	my_bool found = true;
 
 	if (jp1->GetType() == TYPE_JVAL) {
-		PVAL v1 = jp1->GetValue(), v2 = jp2->GetValue();
-
-		if (v1 && v2) {
-			if (v1->GetType() == v2->GetType())
-				found = !v1->CompareValue(v2);
-			else
-				found = false;
+		PVL v1 = ((PJVAL)jp1)->GetVal(), v2 = ((PJVAL)jp2)->GetVal();
 
-		} else
-			found = CompareTree(jp1->GetJsp(), jp2->GetJsp());
+		if (v1 && v2)
+			found = CompareValues(v1, v2);
+		else
+			found = CompareTree(g, jp1->GetJsp(), jp2->GetJsp());
 
 	} else if (jp1->GetType() == TYPE_JAR) {
 		for (int i = 0; found && i < jp1->size(); i++)
-			found = (CompareTree(jp1->GetValue(i), jp2->GetValue(i)));
+			found = (CompareTree(g, jp1->GetValue(i), jp2->GetValue(i)));
 
 	} else if (jp1->GetType() == TYPE_JOB) {
 		PJPR p1 = jp1->GetFirst(), p2 = jp2->GetFirst();
 
 		for (; found && p1 && p2; p1 = p1->Next, p2 = p2->Next)
-			found = CompareTree(p1->Val, p2->Val);
+			found = CompareTree(g, p1->Val, p2->Val);
 
 	} else
 		found = false;
@@ -1041,10 +1046,60 @@ my_bool JSNX::CompareTree(PJSON jp1, PJSON jp2)
 } // end of CompareTree
 
 /*********************************************************************************/
-/*  Add the found path to the list.                                              */
+/*  Compare two VAL values and return true if they are equal.                    */
 /*********************************************************************************/
-my_bool JSNX::AddPath(void)
+my_bool JSNX::CompareValues(PVL v1, PVL v2)
 {
+	my_bool b = false;
+
+	switch (v1->Type) {
+	case TYPE_STRG:
+		if (v2->Type == TYPE_STRG) {
+			if (v1->Nd || v2->Nd)		// Case insensitive
+				b = (!stricmp(v1->Strp, v2->Strp));
+			else
+				b = (!strcmp(v1->Strp, v2->Strp));
+
+		} // endif Type
+
+		break;
+	case TYPE_DTM:
+		b = (!strcmp(v1->Strp, v2->Strp));
+		break;
+	case TYPE_INTG:
+		if (v2->Type == TYPE_INTG)
+			b = (v1->N == v2->N);
+		else if (v2->Type == TYPE_BINT)
+			b = (v1->N == v2->LLn);
+
+		break;
+	case TYPE_BINT:
+		if (v2->Type == TYPE_INTG)
+			b = (v1->LLn == v2->N);
+		else if (v2->Type == TYPE_BINT)
+			b = (v1->LLn == v2->LLn);
+
+		break;
+	case TYPE_DBL:
+		if (v2->Type == TYPE_DBL)
+			b = (v1->F == v2->F);
+		
+		break;
+	case TYPE_BOOL:
+		if (v2->Type == TYPE_BOOL)
+		  b = (v1->B == v2->B);
+
+		break;
+	default:        b = true;   // both nulls
+	}	// endswitch Type
+
+	return b;
+} // end of CompareValues
+
+/*********************************************************************************/
+/*  Add the found path to the list.                                              */
+/*********************************************************************************/
+my_bool JSNX::AddPath(void) {
 	char s[16];
 
 	if (Jp->WriteStr("\"$"))
@@ -1196,6 +1251,7 @@ static PJVAL JvalNew(PGLOBAL g, JTYP type, void *vp)
 			case TYPE_VAL:
 				jvp = new(g) JVALUE(g, (PVAL)vp);
 				break;
+			case TYPE_DTM:
 			case TYPE_STRG:
 				jvp = new(g) JVALUE(g, (PCSZ)vp);
 				break;
@@ -1221,7 +1277,7 @@ static my_bool JsonInit(UDF_INIT *initid, UDF_ARGS *args,
                         unsigned long reslen, unsigned long memlen,
 												unsigned long more = 0)
 {
-  PGLOBAL g = PlugInit(NULL, memlen + more + 500);	// +500 to avoid CheckMem
+  PGLOBAL g = PlugInit(NULL, (size_t)memlen + more + 500); // +500 to avoid CheckMem
 
   if (!g) {
     strcpy(message, "Allocation error");
@@ -1690,7 +1746,7 @@ static PCSZ MakeKey(PGLOBAL g, UDF_ARGS *args, int i)
 /*********************************************************************************/
 /*  Parse a json file.                                                 */
 /*********************************************************************************/
-static PJSON ParseJsonFile(PGLOBAL g, char *fn, int *pretty, int& len)
+static PJSON ParseJsonFile(PGLOBAL g, char *fn, int *pretty, size_t& len)
 {
 	char   *memory;
 	HANDLE  hFile;
@@ -1714,7 +1770,7 @@ static PJSON ParseJsonFile(PGLOBAL g, char *fn, int *pretty, int& len)
 	/*******************************************************************************/
 	/*  Get the file size (assuming file is smaller than 4 GB)                     */
 	/*******************************************************************************/
-	len = mm.lenL;
+	len = (size_t)mm.sz.QuadPart;
 	memory = (char *)mm.memory;
 
 	if (!len) {              // Empty or deleted file
@@ -1784,7 +1840,7 @@ static PJVAL MakeValue(PGLOBAL g, UDF_ARGS *args, uint i, PJSON *top = NULL)
 {
 	char *sap = (args->arg_count > i) ? args->args[i] : NULL;
 	int   n, len;
-	short c;
+	int   ci;
 	long long bigint;
   PJSON jsp;
   PJVAL jvp = new(g) JVALUE;
@@ -1827,8 +1883,8 @@ static PJVAL MakeValue(PGLOBAL g, UDF_ARGS *args, uint i, PJSON *top = NULL)
             jvp->SetValue(jsp);
 
 				} else {
-					c = (strnicmp(args->attributes[i], "ci", 2)) ? 0 : 1;
-					jvp->SetString(g, sap, c);
+					ci = (strnicmp(args->attributes[i], "ci", 2)) ? 0 : 1;
+					jvp->SetString(g, sap, ci);
 				}	// endif n
 
       } // endif len
@@ -1839,7 +1895,7 @@ static PJVAL MakeValue(PGLOBAL g, UDF_ARGS *args, uint i, PJSON *top = NULL)
 
 			if ((bigint == 0LL && !strcmp(args->attributes[i], "FALSE")) ||
 					(bigint == 1LL && !strcmp(args->attributes[i], "TRUE")))
-				jvp->SetTiny(g, (char)bigint);
+				jvp->SetBool(g, (char)bigint);
 			else
 				jvp->SetBigint(g, bigint);
 
@@ -4404,7 +4460,8 @@ char *json_file(UDF_INIT *initid, UDF_ARGS *args, char *result,
 	fn = MakePSZ(g, args, 0);
 
 	if (args->arg_count > 1) {
-		int    len, pretty = 3, pty = 3;
+		int    pretty = 3, pty = 3;
+		size_t len;
 		PJSON  jsp;
 		PJVAL  jvp = NULL;
 
@@ -5311,7 +5368,7 @@ char *jbin_get_item(UDF_INIT *initid, UDF_ARGS *args, char *result,
 
 	// Get the json tree
 	if ((jvp = jsx->GetRowValue(g, jsp, 0, false))) {
-		jsp = (jvp->GetJsp()) ? jvp->GetJsp() : JvalNew(g, TYPE_VAL, jvp->GetValue());
+		jsp = (jvp->GetJsp()) ? jvp->GetJsp() : JvalNew(g, TYPE_VAL, jvp->GetValue(g));
 
 		if ((bsp = JbinAlloc(g, args, initid->max_length, jsp)))
 			strcat(bsp->Msg, " item");
@@ -5637,7 +5694,8 @@ char *jbin_file(UDF_INIT *initid, UDF_ARGS *args, char *result,
 	unsigned long *res_length, char *is_null, char *error)
 {
 	char   *fn;
-	int     pretty = 3, len = 0, pty = 3;
+	int     pretty = 3, pty = 3;
+	size_t  len = 0;
 	PJSON   jsp;
 	PJVAL   jvp = NULL;
 	PGLOBAL g = (PGLOBAL)initid->ptr;
@@ -5796,16 +5854,16 @@ char *jfile_convert(UDF_INIT* initid, UDF_ARGS* args, char* result,
 	if (!g->Xchk) {
 		JUP* jup = new(g) JUP(g);
 
-		str = jup->UnprettyJsonFile(g, fn, ofn, lrecl);
+		str = strcpy(result, jup->UnprettyJsonFile(g, fn, ofn, lrecl));
 		g->Xchk = str;
 	} else
 		str = (char*)g->Xchk;
 
 	if (!str) {
 		if (g->Message)
-			str = PlugDup(g, g->Message);
+			str = strcpy(result, g->Message);
 		else
-			str = PlugDup(g, "Unexpected error");
+			str = strcpy(result, "Unexpected error");
 
 	} // endif str
 
@@ -5817,9 +5875,136 @@ void jfile_convert_deinit(UDF_INIT* initid) {
 	JsonFreeMem((PGLOBAL)initid->ptr);
 } // end of jfile_convert_deinit
 
+/*********************************************************************************/
+/*  Convert a prettiest Json file to Pretty=0.                                   */
+/*********************************************************************************/
+my_bool jfile_bjson_init(UDF_INIT* initid, UDF_ARGS* args, char* message) {
+	unsigned long reslen, memlen;
+
+	if (args->arg_count != 2 && args->arg_count != 3) {
+		strcpy(message, "This function must have 2 or 3 arguments");
+		return true;
+	} else if (args->arg_count == 3 && args->arg_type[2] != INT_RESULT) {
+		strcpy(message, "Third Argument must be an integer (LRECL)");
+		return true;
+	} else for (int i = 0; i < 2; i++)
+		if (args->arg_type[i] != STRING_RESULT) {
+			sprintf(message, "Arguments %d must be a string (file name)", i + 1);
+			return true;
+		} // endif args
+
+	CalcLen(args, false, reslen, memlen);
+	memlen = memlen * M;
+	memlen += (args->arg_count == 3) ? (ulong)*(longlong*)args->args[2] : 1024;
+	return JsonInit(initid, args, message, false, reslen, memlen);
+} // end of jfile_bjson_init
+
+char *jfile_bjson(UDF_INIT *initid, UDF_ARGS *args, char *result,
+	unsigned long *res_length, char*, char *error) {
+	char   *fn, *ofn, *buf, *str = NULL;
+	bool    loop;
+	ssize_t len, newloc;
+	size_t  lrecl, *binszp;
+	PJSON		jsp;
+	SWAP   *swp;
+	PGLOBAL g = (PGLOBAL)initid->ptr;
+
+	PlugSubSet(g->Sarea, g->Sarea_Size);
+	fn = MakePSZ(g, args, 0);
+	ofn = MakePSZ(g, args, 1);
+
+	if (args->arg_count == 3)
+		lrecl = (size_t)*(longlong*)args->args[2];
+	else
+		lrecl = 1024;
+
+	if (!g->Xchk) {
+		int 	msgid = MSGID_OPEN_MODE_STRERROR;
+		FILE *fout;
+		FILE *fin;
+
+		if (!(fin = global_fopen(g, msgid, fn, "rt")))
+			str = strcpy(result, g->Message);
+		else if (!(fout = global_fopen(g, msgid, ofn, "wb")))
+			str = strcpy(result, g->Message);
+		else if ((buf = (char*)PlgDBSubAlloc(g, NULL, lrecl)) &&
+						 (binszp = (size_t*)PlgDBSubAlloc(g, NULL, sizeof(size_t)))) {
+			JsonMemSave(g);
+
+			try {
+				do {
+					loop = false;
+					JsonSubSet(g);
+
+					if (!fgets(buf, lrecl, fin)) {
+						if (!feof(fin)) {
+							sprintf(g->Message, "Error %d reading %zd bytes from %s", errno, lrecl, fn);
+							str = strcpy(result, g->Message);
+						}	else
+							str = strcpy(result, ofn);
+
+					} else if ((len = strlen(buf))) {
+						if ((jsp = ParseJson(g, buf, len))) {
+							newloc = (size_t)PlugSubAlloc(g, NULL, 0);
+							*binszp = newloc - (size_t)jsp;
+
+							swp = new(g) SWAP(g, jsp);
+							swp->SwapJson(jsp, true);
+
+							if (fwrite(binszp, sizeof(binszp), 1, fout) != 1) {
+								sprintf(g->Message, "Error %d writing %zd bytes to %s", 
+																		errno, sizeof(binszp), ofn);
+								str = strcpy(result, g->Message);
+							} else if (fwrite(jsp, *binszp, 1, fout) != 1) {
+								sprintf(g->Message, "Error %d writing %zd bytes to %s", 
+																		errno, *binszp, ofn);
+								str = strcpy(result, g->Message);
+							} else
+								loop = true;
+
+						} else {
+							str = strcpy(result, g->Message);
+						}	// endif jsp
+
+					} else
+						loop = true;
+
+				} while (loop);
+
+			} catch (int) {
+				str = strcpy(result, g->Message);
+			} catch (const char* msg) {
+				str = strcpy(result, msg);
+			} // end catch
+
+		} else
+			str = strcpy(result, g->Message);
+
+		if (fin) fclose(fin);
+		if (fout) fclose(fout);
+		g->Xchk = str;
+	} else
+		str = (char*)g->Xchk;
+
+	if (!str) {
+		if (g->Message)
+			str = strcpy(result, g->Message);
+		else
+			str = strcpy(result, "Unexpected error");
+
+	} // endif str
+
+	*res_length = strlen(str);
+	return str;
+} // end of jfile_bjson
+
+void jfile_bjson_deinit(UDF_INIT* initid) {
+	JsonFreeMem((PGLOBAL)initid->ptr);
+} // end of jfile_bjson_deinit
+
 /* --------------------------------- Class JUP --------------------------------- */
 
-#define ARGS       MY_MIN(24,len-i),s+MY_MAX(i-3,0)
+#define ARGS       MY_MIN(24,(int)len-i),s+MY_MAX(i-3,0)
 
 /*********************************************************************************/
 /*  JUP public constructor.                                                      */
@@ -5827,7 +6012,8 @@ void jfile_convert_deinit(UDF_INIT* initid) {
 JUP::JUP(PGLOBAL g) {
 	fs = NULL;
 	s = buff = NULL;
-	i = k = len = recl = 0;
+	len = 0;
+	i = k = recl = 0;
 } // end of JUP constructor
 
 /*********************************************************************************/
@@ -5855,11 +6041,11 @@ char* JUP::UnprettyJsonFile(PGLOBAL g, char *fn, char *outfn, int lrecl) {
 	/*******************************************************************************/
 	/*  Get the file size (assuming file is smaller than 4 GB)                     */
 	/*******************************************************************************/
-	if (!mm.lenL) {              // Empty or deleted file
+	if (!mm.sz.QuadPart) {              // Empty or deleted file
 		CloseFileHandle(hFile);
 		return NULL;
 	} else
-		len = (int)mm.lenL;
+		len = (size_t)mm.sz.QuadPart;
 
 	if (!mm.memory) {
 		CloseFileHandle(hFile);
@@ -5877,7 +6063,7 @@ char* JUP::UnprettyJsonFile(PGLOBAL g, char *fn, char *outfn, int lrecl) {
 		sprintf(g->Message, MSG(OPEN_MODE_ERROR),
 			"w", (int)errno, outfn);
 		strcat(strcat(g->Message, ": "), strerror(errno));
-		CloseMemMap(mm.memory, (size_t)mm.lenL);
+		CloseMemMap(mm.memory, len);
 		return NULL;
 	} // endif fs
 
@@ -5886,7 +6072,7 @@ char* JUP::UnprettyJsonFile(PGLOBAL g, char *fn, char *outfn, int lrecl) {
 	if (!unPretty(g, lrecl))
 		ret = outfn;
 
-	CloseMemMap(mm.memory, (size_t)mm.lenL);
+	CloseMemMap(mm.memory, len);
 	fclose(fs);
 	return ret;
 } // end of UnprettyJsonFile
diff --git a/storage/connect/jsonudf.h b/storage/connect/jsonudf.h
index 897b0fe9919..f5b2bf75654 100644
--- a/storage/connect/jsonudf.h
+++ b/storage/connect/jsonudf.h
@@ -239,6 +239,10 @@ extern "C" {
 	DllExport char* jfile_convert(UDF_EXEC_ARGS);
 	DllExport void jfile_convert_deinit(UDF_INIT*);
 
+	DllExport my_bool jfile_bjson_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport char* jfile_bjson(UDF_EXEC_ARGS);
+	DllExport void jfile_bjson_deinit(UDF_INIT*);
+
 	DllExport my_bool envar_init(UDF_INIT*, UDF_ARGS*, char*);
 	DllExport char *envar(UDF_EXEC_ARGS);
 
@@ -292,13 +296,14 @@ protected:
 	PVAL    MakeJson(PGLOBAL g, PJSON jsp);
 	void    SetJsonValue(PGLOBAL g, PVAL vp, PJVAL val, int n);
 	PJSON   GetRow(PGLOBAL g);
-	my_bool LocateArray(PJAR jarp);
-	my_bool LocateObject(PJOB jobp);
-	my_bool LocateValue(PJVAL jvp);
-	my_bool LocateArrayAll(PJAR jarp);
-	my_bool LocateObjectAll(PJOB jobp);
-	my_bool LocateValueAll(PJVAL jvp);
-	my_bool CompareTree(PJSON jp1, PJSON jp2);
+	my_bool CompareValues(PVL v1, PVL v2);
+	my_bool LocateArray(PGLOBAL g, PJAR jarp);
+	my_bool LocateObject(PGLOBAL g, PJOB jobp);
+	my_bool LocateValue(PGLOBAL g, PJVAL jvp);
+	my_bool LocateArrayAll(PGLOBAL g, PJAR jarp);
+	my_bool LocateObjectAll(PGLOBAL g, PJOB jobp);
+	my_bool LocateValueAll(PGLOBAL g, PJVAL jvp);
+	my_bool CompareTree(PGLOBAL g, PJSON jp1, PJSON jp2);
 	my_bool AddPath(void);
 
 	// Default constructor not to be used
@@ -355,11 +360,11 @@ public:
 	void  CopyNumeric(PGLOBAL g);
 
 	// Members
-	FILE* fs;
-	char* s;
-	char* buff;
-	int len;
-	int recl;
-	int i, k;
+	FILE  *fs;
+	char  *s;
+	char  *buff;
+	size_t len;
+	int    recl;
+	int    i, k;
 }; // end of class JUP
 
diff --git a/storage/connect/maputil.cpp b/storage/connect/maputil.cpp
index 87263b3adf6..86300f17200 100644
--- a/storage/connect/maputil.cpp
+++ b/storage/connect/maputil.cpp
@@ -90,8 +90,8 @@ HANDLE CreateFileMap(PGLOBAL g, LPCSTR filename,
         return INVALID_HANDLE_VALUE;
         } // endif memory
 
-      // lenH is the high-order word of the file size
-      mm->lenL = GetFileSize(hFile, &mm->lenH);
+      // HighPart is the high-order word of the file size
+      mm->sz.LowPart = GetFileSize(hFile, (LPDWORD)&mm->sz.HighPart);
       CloseHandle(hFileMap);                    // Not used anymore
     }  else // MODE_INSERT
       /*****************************************************************/
diff --git a/storage/connect/maputil.h b/storage/connect/maputil.h
index e310488eb5d..fd62fbcfeae 100644
--- a/storage/connect/maputil.h
+++ b/storage/connect/maputil.h
@@ -7,8 +7,7 @@ extern "C" {
 
 typedef struct {
   void *memory;
-  DWORD lenL;
-  DWORD lenH;
+	LARGE_INTEGER sz;
   } MEMMAP;
 
 DllExport HANDLE  CreateFileMap(PGLOBAL, LPCSTR, MEMMAP *, MODE, bool);
diff --git a/storage/connect/mysql-test/connect/r/alter_xml.result b/storage/connect/mysql-test/connect/r/alter_xml.result
index 7cdb1e5d21c..d2f882f1287 100644
--- a/storage/connect/mysql-test/connect/r/alter_xml.result
+++ b/storage/connect/mysql-test/connect/r/alter_xml.result
@@ -54,7 +54,7 @@ line
 </t1>
 # NOTE: The first (ignored) row is due to the remaining HEADER=1 option.
 # Testing field option modification
-ALTER TABLE t1 MODIFY d CHAR(10) NOT NULL FIELD_FORMAT='@', HEADER=0;
+ALTER TABLE t1 MODIFY d CHAR(10) NOT NULL XPATH='@', HEADER=0;
 SELECT * FROM t1;
 c	d
 1	One
@@ -64,7 +64,7 @@ SHOW CREATE TABLE t1;
 Table	Create Table
 t1	CREATE TABLE `t1` (
   `c` int(11) NOT NULL,
-  `d` char(10) NOT NULL `FIELD_FORMAT`='@'
+  `d` char(10) NOT NULL `XPATH`='@'
 ) ENGINE=CONNECT DEFAULT CHARSET=latin1 `QUOTED`=1 `TABLE_TYPE`=XML `TABNAME`=t1 `OPTION_LIST`='xmlsup=domdoc,rownode=row' `HEADER`=0
 SELECT * FROM t2;
 line
diff --git a/storage/connect/mysql-test/connect/r/alter_xml2.result b/storage/connect/mysql-test/connect/r/alter_xml2.result
index 8eb56e3dcc3..a15be966aa8 100644
--- a/storage/connect/mysql-test/connect/r/alter_xml2.result
+++ b/storage/connect/mysql-test/connect/r/alter_xml2.result
@@ -56,7 +56,7 @@ line
 </t1>
 # NOTE: The first (ignored) row is due to the remaining HEADER=1 option.
 # Testing field option modification
-ALTER TABLE t1 MODIFY d CHAR(10) NOT NULL FIELD_FORMAT='@', HEADER=0;
+ALTER TABLE t1 MODIFY d CHAR(10) NOT NULL XPATH='@', HEADER=0;
 SELECT * FROM t1;
 c	d
 1	One
@@ -66,7 +66,7 @@ SHOW CREATE TABLE t1;
 Table	Create Table
 t1	CREATE TABLE `t1` (
   `c` int(11) NOT NULL,
-  `d` char(10) NOT NULL `FIELD_FORMAT`='@'
+  `d` char(10) NOT NULL `XPATH`='@'
 ) ENGINE=CONNECT DEFAULT CHARSET=latin1 `QUOTED`=1 `TABLE_TYPE`=XML `TABNAME`=t1 `OPTION_LIST`='xmlsup=libxml2,rownode=row' `HEADER`=0
 SELECT * FROM t2;
 line
diff --git a/storage/connect/mysql-test/connect/r/jdbc_oracle.result b/storage/connect/mysql-test/connect/r/jdbc_oracle.result
index ec314c5f072..d895a9aed87 100644
--- a/storage/connect/mysql-test/connect/r/jdbc_oracle.result
+++ b/storage/connect/mysql-test/connect/r/jdbc_oracle.result
@@ -3,7 +3,7 @@ command varchar(128) not null,
 number int(5) not null flag=1,
 message varchar(255) flag=2)
 ENGINE=CONNECT TABLE_TYPE=JDBC CONNECTION='jdbc:oracle:thin:@localhost:1521:xe'
-OPTION_LIST='User=system,Password=manager,Execsrc=1';
+OPTION_LIST='User=system,Password=Choupy01,Execsrc=1';
 SELECT * FROM t2 WHERE command = 'drop table employee';
 command	number	message
 drop table employee	0	Execute: java.sql.SQLSyntaxErrorException: ORA-00942: table or view does not exist
@@ -23,14 +23,14 @@ Warnings:
 Warning	1105	Affected rows
 CREATE TABLE t1 ENGINE=CONNECT TABLE_TYPE=JDBC CATFUNC=tables
 CONNECTION='jdbc:oracle:thin:@localhost:1521:xe'
-OPTION_LIST='User=system,Password=manager';
+OPTION_LIST='User=system,Password=Choupy01';
 SELECT * FROM t1 WHERE table_name='employee';
 Table_Cat	Table_Schema	Table_Name	Table_Type	Remark
 NULL	SYSTEM	EMPLOYEE	TABLE	NULL
 DROP TABLE t1;
 CREATE TABLE t1 ENGINE=CONNECT TABLE_TYPE=JDBC TABNAME='EMPLOYEE' CATFUNC=columns
 CONNECTION='jdbc:oracle:thin:@localhost:1521:xe'
-OPTION_LIST='User=system,Password=manager';
+OPTION_LIST='User=system,Password=Choupy01';
 SELECT * FROM t1;
 Table_Cat	Table_Schema	Table_Name	Column_Name	Data_Type	Type_Name	Column_Size	Buffer_Length	Decimal_Digits	Radix	Nullable	Remarks
 NULL	SYSTEM	EMPLOYEE	ID	3	NUMBER	38	0	0	10	0	NULL
@@ -42,7 +42,7 @@ CREATE SERVER 'oracle' FOREIGN DATA WRAPPER 'oracle.jdbc.driver.OracleDriver' OP
 HOST 'jdbc:oracle:thin:@localhost:1521:xe',
 DATABASE 'SYSTEM',
 USER 'system',
-PASSWORD 'manager',
+PASSWORD 'Choupy01',
 PORT 0,
 SOCKET '',
 OWNER 'SYSTEM');
diff --git a/storage/connect/mysql-test/connect/r/json.result b/storage/connect/mysql-test/connect/r/json.result
index 6b6f40d2c47..affaea604a8 100644
--- a/storage/connect/mysql-test/connect/r/json.result
+++ b/storage/connect/mysql-test/connect/r/json.result
@@ -24,15 +24,15 @@ DROP TABLE t1;
 CREATE TABLE t1
 (
 ISBN CHAR(15),
-Language CHAR(2) FIELD_FORMAT='$.LANG',
-Subject CHAR(32) FIELD_FORMAT='$.SUBJECT',
-Authors INT(2) FIELD_FORMAT='$.AUTHOR[#]',
-Title CHAR(32) FIELD_FORMAT='$.TITLE',
-Translation CHAR(32) FIELD_FORMAT='$.TRANSLATION',
-Translator CHAR(80) FIELD_FORMAT='$.TRANSLATOR',
-Publisher CHAR(20) FIELD_FORMAT='$.PUBLISHER.NAME',
-Location CHAR(16) FIELD_FORMAT='$.PUBLISHER.PLACE',
-Year int(4) FIELD_FORMAT='$.DATEPUB'
+Language CHAR(2) JPATH='$.LANG',
+Subject CHAR(32) JPATH='$.SUBJECT',
+Authors INT(2) JPATH='$.AUTHOR[#]',
+Title CHAR(32) JPATH='$.TITLE',
+Translation CHAR(32) JPATH='$.TRANSLATION',
+Translator CHAR(80) JPATH='$.TRANSLATOR',
+Publisher CHAR(20) JPATH='$.PUBLISHER.NAME',
+Location CHAR(16) JPATH='$.PUBLISHER.PLACE',
+Year int(4) JPATH='$.DATEPUB'
 )
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='biblio.json';
 SELECT * FROM t1;
@@ -46,16 +46,16 @@ DROP TABLE t1;
 CREATE TABLE t1
 (
 ISBN CHAR(15),
-Language CHAR(2) FIELD_FORMAT='$.LANG',
-Subject CHAR(32) FIELD_FORMAT='$.SUBJECT',
-AuthorFN CHAR(128) FIELD_FORMAT='$.AUTHOR[" and "].FIRSTNAME',
-AuthorLN CHAR(128) FIELD_FORMAT='$.AUTHOR[" and "].LASTNAME',
-Title CHAR(32) FIELD_FORMAT='$.TITLE',
-Translation CHAR(32) FIELD_FORMAT='$.TRANSLATION',
-Translator CHAR(80) FIELD_FORMAT='$.TRANSLATOR',
-Publisher CHAR(20) FIELD_FORMAT='$.PUBLISHER.NAME',
-Location CHAR(16) FIELD_FORMAT='$.PUBLISHER.PLACE',
-Year int(4) FIELD_FORMAT='$.DATEPUB'
+Language CHAR(2) JPATH='$.LANG',
+Subject CHAR(32) JPATH='$.SUBJECT',
+AuthorFN CHAR(128) JPATH='$.AUTHOR[" and "].FIRSTNAME',
+AuthorLN CHAR(128) JPATH='$.AUTHOR[" and "].LASTNAME',
+Title CHAR(32) JPATH='$.TITLE',
+Translation CHAR(32) JPATH='$.TRANSLATION',
+Translator CHAR(80) JPATH='$.TRANSLATOR',
+Publisher CHAR(20) JPATH='$.PUBLISHER.NAME',
+Location CHAR(16) JPATH='$.PUBLISHER.PLACE',
+Year int(4) JPATH='$.DATEPUB'
 )
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='biblio.json';
 SELECT * FROM t1;
@@ -69,16 +69,16 @@ DROP TABLE t1;
 CREATE TABLE t1
 (
 ISBN CHAR(15),
-Language CHAR(2) FIELD_FORMAT='$.LANG',
-Subject CHAR(32) FIELD_FORMAT='$.SUBJECT',
-AuthorFN CHAR(128) FIELD_FORMAT='$.AUTHOR[*].FIRSTNAME',
-AuthorLN CHAR(128) FIELD_FORMAT='$.AUTHOR[*].LASTNAME',
-Title CHAR(32) FIELD_FORMAT='$.TITLE',
-Translation CHAR(32) FIELD_FORMAT='$.TRANSLATION',
-Translator CHAR(80) FIELD_FORMAT='$.TRANSLATOR',
-Publisher CHAR(20) FIELD_FORMAT='$.PUBLISHER.NAME',
-Location CHAR(16) FIELD_FORMAT='$.PUBLISHER.PLACE',
-Year int(4) FIELD_FORMAT='$.DATEPUB'
+Language CHAR(2) JPATH='$.LANG',
+Subject CHAR(32) JPATH='$.SUBJECT',
+AuthorFN CHAR(128) JPATH='$.AUTHOR[*].FIRSTNAME',
+AuthorLN CHAR(128) JPATH='$.AUTHOR[*].LASTNAME',
+Title CHAR(32) JPATH='$.TITLE',
+Translation CHAR(32) JPATH='$.TRANSLATION',
+Translator CHAR(80) JPATH='$.TRANSLATOR',
+Publisher CHAR(20) JPATH='$.PUBLISHER.NAME',
+Location CHAR(16) JPATH='$.PUBLISHER.PLACE',
+Year int(4) JPATH='$.DATEPUB'
 )
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='biblio.json';
 SELECT * FROM t1;
@@ -176,17 +176,17 @@ DROP TABLE t1;
 CREATE TABLE t1
 (
 ISBN CHAR(15) NOT NULL,
-Language CHAR(2) FIELD_FORMAT='$.LANG',
-Subject CHAR(32) FIELD_FORMAT='$.SUBJECT',
-AuthorFN CHAR(128) FIELD_FORMAT='$.AUTHOR[*].FIRSTNAME',
-AuthorLN CHAR(128) FIELD_FORMAT='$.AUTHOR[*].LASTNAME',
-Title CHAR(32) FIELD_FORMAT='$.TITLE',
-Translation CHAR(32) FIELD_FORMAT='$.TRANSLATED.PREFIX',
-TranslatorFN CHAR(80) FIELD_FORMAT='$.TRANSLATED.TRANSLATOR.FIRSTNAME',
-TranslatorLN CHAR(80) FIELD_FORMAT='$.TRANSLATED.TRANSLATOR.LASTNAME',
-Publisher CHAR(20) FIELD_FORMAT='$.PUBLISHER.NAME',
-Location CHAR(16) FIELD_FORMAT='$.PUBLISHER.PLACE',
-Year int(4) FIELD_FORMAT='$.DATEPUB',
+Language CHAR(2) JPATH='$.LANG',
+Subject CHAR(32) JPATH='$.SUBJECT',
+AuthorFN CHAR(128) JPATH='$.AUTHOR[*].FIRSTNAME',
+AuthorLN CHAR(128) JPATH='$.AUTHOR[*].LASTNAME',
+Title CHAR(32) JPATH='$.TITLE',
+Translation CHAR(32) JPATH='$.TRANSLATED.PREFIX',
+TranslatorFN CHAR(80) JPATH='$.TRANSLATED.TRANSLATOR.FIRSTNAME',
+TranslatorLN CHAR(80) JPATH='$.TRANSLATED.TRANSLATOR.LASTNAME',
+Publisher CHAR(20) JPATH='$.PUBLISHER.NAME',
+Location CHAR(16) JPATH='$.PUBLISHER.PLACE',
+Year int(4) JPATH='$.DATEPUB',
 INDEX IX(ISBN)
 )
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='bib0.json' LRECL=320 OPTION_LIST='Pretty=0';
@@ -209,9 +209,9 @@ DROP TABLE t1;
 #
 CREATE TABLE t1 (
 WHO CHAR(12),
-WEEK INT(2) FIELD_FORMAT='$.WEEK[*].NUMBER',
-WHAT CHAR(32) FIELD_FORMAT='$.WEEK[].EXPENSE["+"].WHAT',
-AMOUNT DOUBLE(8,2) FIELD_FORMAT='$.WEEK[].EXPENSE[+].AMOUNT')
+WEEK INT(2) JPATH='$.WEEK[*].NUMBER',
+WHAT CHAR(32) JPATH='$.WEEK[].EXPENSE["+"].WHAT',
+AMOUNT DOUBLE(8,2) JPATH='$.WEEK[].EXPENSE[+].AMOUNT')
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='expense.json';
 SELECT * FROM t1;
 WHO	WEEK	WHAT	AMOUNT
@@ -230,9 +230,9 @@ DROP TABLE t1;
 #
 CREATE TABLE t1 (
 WHO CHAR(12),
-WEEK INT(2) FIELD_FORMAT='$.WEEK[*].NUMBER',
-WHAT CHAR(32) FIELD_FORMAT='$.WEEK[*].EXPENSE[*].WHAT',
-AMOUNT DOUBLE(8,2) FIELD_FORMAT='$.WEEK[*].EXPENSE[*].AMOUNT')
+WEEK INT(2) JPATH='$.WEEK[*].NUMBER',
+WHAT CHAR(32) JPATH='$.WEEK[*].EXPENSE[*].WHAT',
+AMOUNT DOUBLE(8,2) JPATH='$.WEEK[*].EXPENSE[*].AMOUNT')
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='expense.json';
 SELECT * FROM t1;
 WHO	WEEK	WHAT	AMOUNT
@@ -266,14 +266,14 @@ DROP TABLE t1;
 #
 CREATE TABLE t1 (
 WHO CHAR(12) NOT NULL,
-WEEKS CHAR(12) NOT NULL FIELD_FORMAT='$.WEEK[", "].NUMBER',
-SUMS CHAR(64) NOT NULL FIELD_FORMAT='$.WEEK["+"].EXPENSE[+].AMOUNT',
-SUM DOUBLE(8,2) NOT NULL FIELD_FORMAT='$.WEEK[+].EXPENSE[+].AMOUNT',
-AVGS CHAR(64) NOT NULL FIELD_FORMAT='$.WEEK["+"].EXPENSE[!].AMOUNT',
-SUMAVG DOUBLE(8,2) NOT NULL FIELD_FORMAT='$.WEEK[+].EXPENSE[!].AMOUNT',
-AVGSUM DOUBLE(8,2) NOT NULL FIELD_FORMAT='$.WEEK[!].EXPENSE[+].AMOUNT',
-AVGAVG DOUBLE(8,2) NOT NULL FIELD_FORMAT='$.WEEK[!].EXPENSE[!].AMOUNT',
-AVERAGE DOUBLE(8,2) NOT NULL FIELD_FORMAT='$.WEEK[!].EXPENSE[*].AMOUNT')
+WEEKS CHAR(12) NOT NULL JPATH='$.WEEK[", "].NUMBER',
+SUMS CHAR(64) NOT NULL JPATH='$.WEEK["+"].EXPENSE[+].AMOUNT',
+SUM DOUBLE(8,2) NOT NULL JPATH='$.WEEK[+].EXPENSE[+].AMOUNT',
+AVGS CHAR(64) NOT NULL JPATH='$.WEEK["+"].EXPENSE[!].AMOUNT',
+SUMAVG DOUBLE(8,2) NOT NULL JPATH='$.WEEK[+].EXPENSE[!].AMOUNT',
+AVGSUM DOUBLE(8,2) NOT NULL JPATH='$.WEEK[!].EXPENSE[+].AMOUNT',
+AVGAVG DOUBLE(8,2) NOT NULL JPATH='$.WEEK[!].EXPENSE[!].AMOUNT',
+AVERAGE DOUBLE(8,2) NOT NULL JPATH='$.WEEK[!].EXPENSE[*].AMOUNT')
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='expense.json';
 SELECT * FROM t1;
 WHO	WEEKS	SUMS	SUM	AVGS	SUMAVG	AVGSUM	AVGAVG	AVERAGE
@@ -286,9 +286,9 @@ DROP TABLE t1;
 #
 CREATE TABLE t2 (
 WHO CHAR(12),
-WEEK INT(2) FIELD_FORMAT='$.WEEK[0].NUMBER',
-WHAT CHAR(32) FIELD_FORMAT='$.WEEK[0].EXPENSE[*].WHAT',
-AMOUNT DOUBLE(8,2) FIELD_FORMAT='$.WEEK[0].EXPENSE[*].AMOUNT')
+WEEK INT(2) JPATH='$.WEEK[0].NUMBER',
+WHAT CHAR(32) JPATH='$.WEEK[0].EXPENSE[*].WHAT',
+AMOUNT DOUBLE(8,2) JPATH='$.WEEK[0].EXPENSE[*].AMOUNT')
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='expense.json';
 SELECT * FROM t2;
 WHO	WEEK	WHAT	AMOUNT
@@ -302,9 +302,9 @@ Janet	3	Food	18.00
 Janet	3	Beer	18.00
 CREATE TABLE t3 (
 WHO CHAR(12),
-WEEK INT(2) FIELD_FORMAT='$.WEEK[1].NUMBER',
-WHAT CHAR(32) FIELD_FORMAT='$.WEEK[1].EXPENSE[*].WHAT',
-AMOUNT DOUBLE(8,2) FIELD_FORMAT='$.WEEK[1].EXPENSE[*].AMOUNT')
+WEEK INT(2) JPATH='$.WEEK[1].NUMBER',
+WHAT CHAR(32) JPATH='$.WEEK[1].EXPENSE[*].WHAT',
+AMOUNT DOUBLE(8,2) JPATH='$.WEEK[1].EXPENSE[*].AMOUNT')
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='expense.json';
 SELECT * FROM t3;
 WHO	WEEK	WHAT	AMOUNT
@@ -318,9 +318,9 @@ Beth	4	Beer	15.00
 Janet	4	Car	17.00
 CREATE TABLE t4 (
 WHO CHAR(12),
-WEEK INT(2) FIELD_FORMAT='$.WEEK[2].NUMBER',
-WHAT CHAR(32) FIELD_FORMAT='$.WEEK[2].EXPENSE[*].WHAT',
-AMOUNT DOUBLE(8,2) FIELD_FORMAT='$.WEEK[2].EXPENSE[*].AMOUNT')
+WEEK INT(2) JPATH='$.WEEK[2].NUMBER',
+WHAT CHAR(32) JPATH='$.WEEK[2].EXPENSE[*].WHAT',
+AMOUNT DOUBLE(8,2) JPATH='$.WEEK[2].EXPENSE[*].AMOUNT')
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='expense.json';
 SELECT * FROM t4;
 WHO	WEEK	WHAT	AMOUNT
@@ -374,8 +374,8 @@ DROP TABLE t1, t2, t3, t4;
 CREATE TABLE t2 (
 WHO CHAR(12),
 WEEK INT(2),
-WHAT CHAR(32) FIELD_FORMAT='$.EXPENSE[*].WHAT',
-AMOUNT DOUBLE(8,2) FIELD_FORMAT='$.EXPENSE.[*].AMOUNT')
+WHAT CHAR(32) JPATH='$.EXPENSE[*].WHAT',
+AMOUNT DOUBLE(8,2) JPATH='$.EXPENSE.[*].AMOUNT')
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='mulexp3.json';
 SELECT * FROM t2;
 WHO	WEEK	WHAT	AMOUNT
@@ -390,8 +390,8 @@ Janet	3	Beer	18.00
 CREATE TABLE t3 (
 WHO CHAR(12),
 WEEK INT(2),
-WHAT CHAR(32) FIELD_FORMAT='$.EXPENSE[*].WHAT',
-AMOUNT DOUBLE(8,2) FIELD_FORMAT='$.EXPENSE.[*].AMOUNT')
+WHAT CHAR(32) JPATH='$.EXPENSE[*].WHAT',
+AMOUNT DOUBLE(8,2) JPATH='$.EXPENSE.[*].AMOUNT')
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='mulexp4.json';
 SELECT * FROM t3;
 WHO	WEEK	WHAT	AMOUNT
@@ -406,8 +406,8 @@ Janet	4	Car	17.00
 CREATE TABLE t4 (
 WHO CHAR(12),
 WEEK INT(2),
-WHAT CHAR(32) FIELD_FORMAT='$.EXPENSE[*].WHAT',
-AMOUNT DOUBLE(8,2) FIELD_FORMAT='$.EXPENSE.[*].AMOUNT')
+WHAT CHAR(32) JPATH='$.EXPENSE[*].WHAT',
+AMOUNT DOUBLE(8,2) JPATH='$.EXPENSE.[*].AMOUNT')
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='mulexp5.json';
 SELECT * FROM t4;
 WHO	WEEK	WHAT	AMOUNT
@@ -425,8 +425,8 @@ Janet	5	Food	12.00
 CREATE TABLE t1 (
 WHO CHAR(12),
 WEEK INT(2),
-WHAT CHAR(32) FIELD_FORMAT='$.EXPENSE[*].WHAT',
-AMOUNT DOUBLE(8,2) FIELD_FORMAT='$.EXPENSE.[*].AMOUNT')
+WHAT CHAR(32) JPATH='$.EXPENSE[*].WHAT',
+AMOUNT DOUBLE(8,2) JPATH='$.EXPENSE.[*].AMOUNT')
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='mulexp*.json' MULTIPLE=1;
 SELECT * FROM t1 ORDER BY WHO, WEEK, WHAT, AMOUNT;
 WHO	WEEK	WHAT	AMOUNT
@@ -461,8 +461,8 @@ DROP TABLE t1;
 CREATE TABLE t1 (
 WHO CHAR(12),
 WEEK INT(2),
-WHAT CHAR(32) FIELD_FORMAT='$.EXPENSE[*].WHAT',
-AMOUNT DOUBLE(8,2) FIELD_FORMAT='$.EXPENSE.[*].AMOUNT')
+WHAT CHAR(32) JPATH='$.EXPENSE[*].WHAT',
+AMOUNT DOUBLE(8,2) JPATH='$.EXPENSE.[*].AMOUNT')
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='mulexp%s.json';
 ALTER TABLE t1
 PARTITION BY LIST COLUMNS(WEEK) (
diff --git a/storage/connect/mysql-test/connect/r/json_java_2.result b/storage/connect/mysql-test/connect/r/json_java_2.result
index 47fc4abbd28..2ce89f971b2 100644
--- a/storage/connect/mysql-test/connect/r/json_java_2.result
+++ b/storage/connect/mysql-test/connect/r/json_java_2.result
@@ -2,7 +2,7 @@ set connect_enable_mongo=1;
 #
 # Test the MONGO table type
 #
-CREATE TABLE t1 (Document varchar(1024) field_format='*')
+CREATE TABLE t1 (Document varchar(1024) JPATH='*')
 ENGINE=CONNECT TABLE_TYPE=JSON TABNAME=restaurants CONNECTION='mongodb://localhost:27017' LRECL=4096
 OPTION_LIST='Driver=Java,Version=2' DATA_CHARSET=utf8;
 SELECT * from t1 limit 3;
@@ -15,7 +15,7 @@ DROP TABLE t1;
 # Test catfunc
 #
 CREATE TABLE t1 ENGINE=CONNECT TABLE_TYPE=JSON TABNAME=restaurants CATFUNC=columns
-OPTION_LIST='Level=1,Driver=Java,Version=2' DATA_CHARSET=utf8 CONNECTION='mongodb://localhost:27017' LRECL=4096;
+OPTION_LIST='Depth=1,Driver=Java,Version=2' DATA_CHARSET=utf8 CONNECTION='mongodb://localhost:27017' LRECL=4096;
 SELECT * from t1;
 Column_Name	Data_Type	Type_Name	Column_Size	Buffer_Length	Decimal_Digits	Nullable	Jpath
 _id	1	CHAR	24	24	0	0	_id
@@ -27,7 +27,7 @@ borough	1	CHAR	13	13	0	0
 cuisine	1	CHAR	64	64	0	0	
 grades_date	1	CHAR	1024	1024	0	1	grades.0.date
 grades_grade	1	CHAR	14	14	0	1	grades.0.grade
-grades_score	5	BIGINT	2	2	0	1	grades.0.score
+grades_score	7	INTEGER	2	2	0	1	grades.0.score
 name	1	CHAR	98	98	0	0	
 restaurant_id	1	CHAR	8	8	0	0	
 DROP TABLE t1;
@@ -60,7 +60,7 @@ DROP TABLE t1;
 # Test discovery
 #
 CREATE TABLE t1 ENGINE=CONNECT TABLE_TYPE=JSON TABNAME=restaurants
-OPTION_LIST='Level=1,Driver=Java,Version=2' CONNECTION='mongodb://localhost:27017' LRECL=4096 DATA_CHARSET=utf8;
+OPTION_LIST='Depth=1,Driver=Java,Version=2' CONNECTION='mongodb://localhost:27017' LRECL=4096 DATA_CHARSET=utf8;
 SHOW CREATE TABLE t1;
 Table	Create Table
 t1	CREATE TABLE `t1` (
@@ -73,10 +73,10 @@ t1	CREATE TABLE `t1` (
   `cuisine` char(64) NOT NULL,
   `grades_date` varchar(1024) DEFAULT NULL `JPATH`='grades.0.date',
   `grades_grade` char(14) DEFAULT NULL `JPATH`='grades.0.grade',
-  `grades_score` bigint(2) DEFAULT NULL `JPATH`='grades.0.score',
+  `grades_score` int(2) DEFAULT NULL `JPATH`='grades.0.score',
   `name` char(98) NOT NULL,
   `restaurant_id` char(8) NOT NULL
-) ENGINE=CONNECT DEFAULT CHARSET=latin1 CONNECTION='mongodb://localhost:27017' `TABLE_TYPE`='JSON' `TABNAME`='restaurants' `OPTION_LIST`='Level=1,Driver=Java,Version=2' `DATA_CHARSET`='utf8' `LRECL`=4096
+) ENGINE=CONNECT DEFAULT CHARSET=latin1 CONNECTION='mongodb://localhost:27017' `TABLE_TYPE`='JSON' `TABNAME`='restaurants' `OPTION_LIST`='Depth=1,Driver=Java,Version=2' `DATA_CHARSET`='utf8' `LRECL`=4096
 SELECT * FROM t1 LIMIT 5;
 _id	address_building	address_coord	address_street	address_zipcode	borough	cuisine	grades_date	grades_grade	grades_score	name	restaurant_id
 58ada47de5a51ddfcd5ed51c	1007	-73.856077	Morris Park Ave	10462	Bronx	Bakery	2014-03-03T00:00:00.000Z	A	2	Morris Park Bake Shop	30075445
@@ -111,12 +111,12 @@ _id VARCHAR(24) NOT NULL,
 name VARCHAR(64) NOT NULL,
 cuisine CHAR(200) NOT NULL,
 borough CHAR(16) NOT NULL,
-street VARCHAR(65) FIELD_FORMAT='address.street',
-building CHAR(16) FIELD_FORMAT='address.building',
-zipcode CHAR(5) FIELD_FORMAT='address.zipcode',
-grade CHAR(1) FIELD_FORMAT='grades.0.grade',
-score INT(4) NOT NULL FIELD_FORMAT='grades.0.score',
-`date` DATE FIELD_FORMAT='grades.0.date',
+street VARCHAR(65) JPATH='address.street',
+building CHAR(16) JPATH='address.building',
+zipcode CHAR(5) JPATH='address.zipcode',
+grade CHAR(1) JPATH='grades.0.grade',
+score INT(4) NOT NULL JPATH='grades.0.score',
+`date` DATE JPATH='grades.0.date',
 restaurant_id VARCHAR(255) NOT NULL)
 ENGINE=CONNECT TABLE_TYPE=JSON TABNAME='restaurants' DATA_CHARSET=utf8
 OPTION_LIST='Driver=Java,Version=2' CONNECTION='mongodb://localhost:27017' LRECL=4096;
@@ -259,7 +259,7 @@ t1	CREATE TABLE `t1` (
   `borough` char(13) NOT NULL,
   `grades_date` char(24) DEFAULT NULL `JPATH`='grades.0.date',
   `grades_grade` char(14) DEFAULT NULL `JPATH`='grades.0.grade',
-  `grades_score` bigint(2) DEFAULT NULL `JPATH`='grades.0.score',
+  `grades_score` int(2) DEFAULT NULL `JPATH`='grades.0.score',
   `name` char(98) NOT NULL,
   `restaurant_id` char(8) NOT NULL
 ) ENGINE=CONNECT DEFAULT CHARSET=latin1 CONNECTION='mongodb://localhost:27017' `TABLE_TYPE`='JSON' `TABNAME`='restaurants' `COLIST`='{"cuisine":0}' `FILTER`='{"cuisine":"French","borough":{"$ne":"Manhattan"}}' `OPTION_LIST`='Driver=Java,level=2,version=2' `LRECL`=4096
@@ -305,8 +305,8 @@ false
 CREATE TABLE t1 (
 _id char(5) NOT NULL,
 city char(16) NOT NULL,
-loc_0 double(12,6) NOT NULL `FIELD_FORMAT`='loc.0',
-loc_1 char(12) NOT NULL `FIELD_FORMAT`='loc.1',
+loc_0 double(12,6) NOT NULL `JPATH`='loc.0',
+loc_1 char(12) NOT NULL `JPATH`='loc.1',
 pop int(11) NOT NULL,
 state char(2) NOT NULL)
 ENGINE=CONNECT CONNECTION='mongodb://localhost:27017' TABLE_TYPE=JSON TABNAME='cities'
@@ -344,11 +344,11 @@ true
 CREATE TABLE t1 (
 _id int(4) NOT NULL,
 item CHAR(8) NOT NULL,
-prices_0 INT(6) FIELD_FORMAT='prices.0',
-prices_1 INT(6) FIELD_FORMAT='prices.1',
-prices_2 INT(6) FIELD_FORMAT='prices.2',
-prices_3 INT(6) FIELD_FORMAT='prices.3',
-prices_4 INT(6) FIELD_FORMAT='prices.4')
+prices_0 INT(6) JPATH='prices.0',
+prices_1 INT(6) JPATH='prices.1',
+prices_2 INT(6) JPATH='prices.2',
+prices_3 INT(6) JPATH='prices.3',
+prices_4 INT(6) JPATH='prices.4')
 ENGINE=CONNECT TABLE_TYPE=JSON TABNAME='testcoll' DATA_CHARSET=utf8
 OPTION_LIST='Driver=Java,Version=2' CONNECTION='mongodb://localhost:27017' LRECL=4096;
 INSERT INTO t1 VALUES
diff --git a/storage/connect/mysql-test/connect/r/json_java_3.result b/storage/connect/mysql-test/connect/r/json_java_3.result
index 720c82cd7f9..d914b507f52 100644
--- a/storage/connect/mysql-test/connect/r/json_java_3.result
+++ b/storage/connect/mysql-test/connect/r/json_java_3.result
@@ -2,7 +2,7 @@ set connect_enable_mongo=1;
 #
 # Test the MONGO table type
 #
-CREATE TABLE t1 (Document varchar(1024) field_format='*')
+CREATE TABLE t1 (Document varchar(1024) JPATH='*')
 ENGINE=CONNECT TABLE_TYPE=JSON TABNAME=restaurants CONNECTION='mongodb://localhost:27017' LRECL=4096
 OPTION_LIST='Driver=Java,Version=3' DATA_CHARSET=utf8;
 SELECT * from t1 limit 3;
@@ -15,7 +15,7 @@ DROP TABLE t1;
 # Test catfunc
 #
 CREATE TABLE t1 ENGINE=CONNECT TABLE_TYPE=JSON TABNAME=restaurants CATFUNC=columns
-OPTION_LIST='Level=1,Driver=Java,Version=3' DATA_CHARSET=utf8 CONNECTION='mongodb://localhost:27017' LRECL=4096;
+OPTION_LIST='Depth=1,Driver=Java,Version=3' DATA_CHARSET=utf8 CONNECTION='mongodb://localhost:27017' LRECL=4096;
 SELECT * from t1;
 Column_Name	Data_Type	Type_Name	Column_Size	Buffer_Length	Decimal_Digits	Nullable	Jpath
 _id	1	CHAR	24	24	0	0	_id
@@ -27,7 +27,7 @@ borough	1	CHAR	13	13	0	0
 cuisine	1	CHAR	64	64	0	0	
 grades_date	1	CHAR	1024	1024	0	1	grades.0.date
 grades_grade	1	CHAR	14	14	0	1	grades.0.grade
-grades_score	5	BIGINT	2	2	0	1	grades.0.score
+grades_score	7	INTEGER	2	2	0	1	grades.0.score
 name	1	CHAR	98	98	0	0	
 restaurant_id	1	CHAR	8	8	0	0	
 DROP TABLE t1;
@@ -60,7 +60,7 @@ DROP TABLE t1;
 # Test discovery
 #
 CREATE TABLE t1 ENGINE=CONNECT TABLE_TYPE=JSON TABNAME=restaurants
-OPTION_LIST='Level=1,Driver=Java,Version=3' CONNECTION='mongodb://localhost:27017' LRECL=4096 DATA_CHARSET=utf8;
+OPTION_LIST='Depth=1,Driver=Java,Version=3' CONNECTION='mongodb://localhost:27017' LRECL=4096 DATA_CHARSET=utf8;
 SHOW CREATE TABLE t1;
 Table	Create Table
 t1	CREATE TABLE `t1` (
@@ -73,10 +73,10 @@ t1	CREATE TABLE `t1` (
   `cuisine` char(64) NOT NULL,
   `grades_date` varchar(1024) DEFAULT NULL `JPATH`='grades.0.date',
   `grades_grade` char(14) DEFAULT NULL `JPATH`='grades.0.grade',
-  `grades_score` bigint(2) DEFAULT NULL `JPATH`='grades.0.score',
+  `grades_score` int(2) DEFAULT NULL `JPATH`='grades.0.score',
   `name` char(98) NOT NULL,
   `restaurant_id` char(8) NOT NULL
-) ENGINE=CONNECT DEFAULT CHARSET=latin1 CONNECTION='mongodb://localhost:27017' `TABLE_TYPE`='JSON' `TABNAME`='restaurants' `OPTION_LIST`='Level=1,Driver=Java,Version=3' `DATA_CHARSET`='utf8' `LRECL`=4096
+) ENGINE=CONNECT DEFAULT CHARSET=latin1 CONNECTION='mongodb://localhost:27017' `TABLE_TYPE`='JSON' `TABNAME`='restaurants' `OPTION_LIST`='Depth=1,Driver=Java,Version=3' `DATA_CHARSET`='utf8' `LRECL`=4096
 SELECT * FROM t1 LIMIT 5;
 _id	address_building	address_coord	address_street	address_zipcode	borough	cuisine	grades_date	grades_grade	grades_score	name	restaurant_id
 58ada47de5a51ddfcd5ed51c	1007	-73.856077	Morris Park Ave	10462	Bronx	Bakery	1393804800	A	2	Morris Park Bake Shop	30075445
@@ -111,12 +111,12 @@ _id VARCHAR(24) NOT NULL,
 name VARCHAR(64) NOT NULL,
 cuisine CHAR(200) NOT NULL,
 borough CHAR(16) NOT NULL,
-street VARCHAR(65) FIELD_FORMAT='address.street',
-building CHAR(16) FIELD_FORMAT='address.building',
-zipcode CHAR(5) FIELD_FORMAT='address.zipcode',
-grade CHAR(1) FIELD_FORMAT='grades.0.grade',
-score INT(4) NOT NULL FIELD_FORMAT='grades.0.score',
-`date` DATE FIELD_FORMAT='grades.0.date',
+street VARCHAR(65) JPATH='address.street',
+building CHAR(16) JPATH='address.building',
+zipcode CHAR(5) JPATH='address.zipcode',
+grade CHAR(1) JPATH='grades.0.grade',
+score INT(4) NOT NULL JPATH='grades.0.score',
+`date` DATE JPATH='grades.0.date',
 restaurant_id VARCHAR(255) NOT NULL)
 ENGINE=CONNECT TABLE_TYPE=JSON TABNAME='restaurants' DATA_CHARSET=utf8
 OPTION_LIST='Driver=Java,Version=3' CONNECTION='mongodb://localhost:27017' LRECL=4096;
@@ -259,7 +259,7 @@ t1	CREATE TABLE `t1` (
   `borough` char(13) NOT NULL,
   `grades_date` bigint(13) DEFAULT NULL `JPATH`='grades.0.date',
   `grades_grade` char(14) DEFAULT NULL `JPATH`='grades.0.grade',
-  `grades_score` bigint(2) DEFAULT NULL `JPATH`='grades.0.score',
+  `grades_score` int(2) DEFAULT NULL `JPATH`='grades.0.score',
   `name` char(98) NOT NULL,
   `restaurant_id` char(8) NOT NULL
 ) ENGINE=CONNECT DEFAULT CHARSET=latin1 CONNECTION='mongodb://localhost:27017' `TABLE_TYPE`='JSON' `TABNAME`='restaurants' `COLIST`='{"cuisine":0}' `FILTER`='{"cuisine":"French","borough":{"$ne":"Manhattan"}}' `OPTION_LIST`='Driver=Java,level=2,version=3' `LRECL`=4096
@@ -305,8 +305,8 @@ false
 CREATE TABLE t1 (
 _id char(5) NOT NULL,
 city char(16) NOT NULL,
-loc_0 double(12,6) NOT NULL `FIELD_FORMAT`='loc.0',
-loc_1 char(12) NOT NULL `FIELD_FORMAT`='loc.1',
+loc_0 double(12,6) NOT NULL `JPATH`='loc.0',
+loc_1 char(12) NOT NULL `JPATH`='loc.1',
 pop int(11) NOT NULL,
 state char(2) NOT NULL)
 ENGINE=CONNECT CONNECTION='mongodb://localhost:27017' TABLE_TYPE=JSON TABNAME='cities'
@@ -344,11 +344,11 @@ true
 CREATE TABLE t1 (
 _id int(4) NOT NULL,
 item CHAR(8) NOT NULL,
-prices_0 INT(6) FIELD_FORMAT='prices.0',
-prices_1 INT(6) FIELD_FORMAT='prices.1',
-prices_2 INT(6) FIELD_FORMAT='prices.2',
-prices_3 INT(6) FIELD_FORMAT='prices.3',
-prices_4 INT(6) FIELD_FORMAT='prices.4')
+prices_0 INT(6) JPATH='prices.0',
+prices_1 INT(6) JPATH='prices.1',
+prices_2 INT(6) JPATH='prices.2',
+prices_3 INT(6) JPATH='prices.3',
+prices_4 INT(6) JPATH='prices.4')
 ENGINE=CONNECT TABLE_TYPE=JSON TABNAME='testcoll' DATA_CHARSET=utf8
 OPTION_LIST='Driver=Java,Version=3' CONNECTION='mongodb://localhost:27017' LRECL=4096;
 INSERT INTO t1 VALUES
diff --git a/storage/connect/mysql-test/connect/r/json_mongo_c.result b/storage/connect/mysql-test/connect/r/json_mongo_c.result
index f9bfc01763e..454743e679b 100644
--- a/storage/connect/mysql-test/connect/r/json_mongo_c.result
+++ b/storage/connect/mysql-test/connect/r/json_mongo_c.result
@@ -2,7 +2,7 @@ set connect_enable_mongo=1;
 #
 # Test the MONGO table type
 #
-CREATE TABLE t1 (Document varchar(1024) field_format='*')
+CREATE TABLE t1 (Document varchar(1024) JPATH='*')
 ENGINE=CONNECT TABLE_TYPE=JSON TABNAME=restaurants CONNECTION='mongodb://localhost:27017' LRECL=1024
 OPTION_LIST='Driver=C,Version=0' DATA_CHARSET=utf8;
 SELECT * from t1 limit 3;
@@ -15,7 +15,7 @@ DROP TABLE t1;
 # Test catfunc
 #
 CREATE TABLE t1 ENGINE=CONNECT TABLE_TYPE=JSON TABNAME=restaurants CATFUNC=columns
-OPTION_LIST='Level=1,Driver=C,Version=0' DATA_CHARSET=utf8 CONNECTION='mongodb://localhost:27017' LRECL=1024;
+OPTION_LIST='Depth=1,Driver=C,Version=0' DATA_CHARSET=utf8 CONNECTION='mongodb://localhost:27017' LRECL=1024;
 SELECT * from t1;
 Column_Name	Data_Type	Type_Name	Column_Size	Buffer_Length	Decimal_Digits	Nullable	Jpath
 _id	1	CHAR	24	24	0	0	_id
@@ -27,7 +27,7 @@ borough	1	CHAR	13	13	0	0
 cuisine	1	CHAR	64	64	0	0	
 grades_date	1	CHAR	1024	1024	0	1	grades.0.date
 grades_grade	1	CHAR	14	14	0	1	grades.0.grade
-grades_score	5	BIGINT	2	2	0	1	grades.0.score
+grades_score	7	INTEGER	2	2	0	1	grades.0.score
 name	1	CHAR	98	98	0	0	
 restaurant_id	1	CHAR	8	8	0	0	
 DROP TABLE t1;
@@ -60,7 +60,7 @@ DROP TABLE t1;
 # Test discovery
 #
 CREATE TABLE t1 ENGINE=CONNECT TABLE_TYPE=JSON TABNAME=restaurants
-OPTION_LIST='Level=1,Driver=C,Version=0' CONNECTION='mongodb://localhost:27017' LRECL=1024 DATA_CHARSET=utf8;
+OPTION_LIST='Depth=1,Driver=C,Version=0' CONNECTION='mongodb://localhost:27017' LRECL=1024 DATA_CHARSET=utf8;
 SHOW CREATE TABLE t1;
 Table	Create Table
 t1	CREATE TABLE `t1` (
@@ -73,10 +73,10 @@ t1	CREATE TABLE `t1` (
   `cuisine` char(64) NOT NULL,
   `grades_date` varchar(1024) DEFAULT NULL `JPATH`='grades.0.date',
   `grades_grade` char(14) DEFAULT NULL `JPATH`='grades.0.grade',
-  `grades_score` bigint(2) DEFAULT NULL `JPATH`='grades.0.score',
+  `grades_score` int(2) DEFAULT NULL `JPATH`='grades.0.score',
   `name` char(98) NOT NULL,
   `restaurant_id` char(8) NOT NULL
-) ENGINE=CONNECT DEFAULT CHARSET=latin1 CONNECTION='mongodb://localhost:27017' `TABLE_TYPE`='JSON' `TABNAME`='restaurants' `OPTION_LIST`='Level=1,Driver=C,Version=0' `DATA_CHARSET`='utf8' `LRECL`=1024
+) ENGINE=CONNECT DEFAULT CHARSET=latin1 CONNECTION='mongodb://localhost:27017' `TABLE_TYPE`='JSON' `TABNAME`='restaurants' `OPTION_LIST`='Depth=1,Driver=C,Version=0' `DATA_CHARSET`='utf8' `LRECL`=1024
 SELECT * FROM t1 LIMIT 5;
 _id	address_building	address_coord	address_street	address_zipcode	borough	cuisine	grades_date	grades_grade	grades_score	name	restaurant_id
 58ada47de5a51ddfcd5ed51c	1007	-73.856076999999999089	Morris Park Ave	10462	Bronx	Bakery	1393804800	A	2	Morris Park Bake Shop	30075445
@@ -111,12 +111,12 @@ _id VARCHAR(24) NOT NULL,
 name VARCHAR(64) NOT NULL,
 cuisine CHAR(200) NOT NULL,
 borough CHAR(16) NOT NULL,
-street VARCHAR(65) FIELD_FORMAT='address.street',
-building CHAR(16) FIELD_FORMAT='address.building',
-zipcode CHAR(5) FIELD_FORMAT='address.zipcode',
-grade CHAR(1) FIELD_FORMAT='grades.0.grade',
-score INT(4) NOT NULL FIELD_FORMAT='grades.0.score',
-`date` DATE FIELD_FORMAT='grades.0.date',
+street VARCHAR(65) JPATH='address.street',
+building CHAR(16) JPATH='address.building',
+zipcode CHAR(5) JPATH='address.zipcode',
+grade CHAR(1) JPATH='grades.0.grade',
+score INT(4) NOT NULL JPATH='grades.0.score',
+`date` DATE JPATH='grades.0.date',
 restaurant_id VARCHAR(255) NOT NULL)
 ENGINE=CONNECT TABLE_TYPE=JSON TABNAME='restaurants' DATA_CHARSET=utf8
 OPTION_LIST='Driver=C,Version=0' CONNECTION='mongodb://localhost:27017' LRECL=1024;
@@ -259,7 +259,7 @@ t1	CREATE TABLE `t1` (
   `borough` char(13) NOT NULL,
   `grades_date` bigint(13) DEFAULT NULL `JPATH`='grades.0.date',
   `grades_grade` char(14) DEFAULT NULL `JPATH`='grades.0.grade',
-  `grades_score` bigint(2) DEFAULT NULL `JPATH`='grades.0.score',
+  `grades_score` int(2) DEFAULT NULL `JPATH`='grades.0.score',
   `name` char(98) NOT NULL,
   `restaurant_id` char(8) NOT NULL
 ) ENGINE=CONNECT DEFAULT CHARSET=latin1 CONNECTION='mongodb://localhost:27017' `TABLE_TYPE`='JSON' `TABNAME`='restaurants' `COLIST`='{"projection":{"cuisine":0}}' `FILTER`='{"cuisine":"French","borough":{"$ne":"Manhattan"}}' `OPTION_LIST`='Driver=C,level=2,version=0' `LRECL`=1024
@@ -305,8 +305,8 @@ false
 CREATE TABLE t1 (
 _id char(5) NOT NULL,
 city char(16) NOT NULL,
-loc_0 double(12,6) NOT NULL `FIELD_FORMAT`='loc.0',
-loc_1 char(12) NOT NULL `FIELD_FORMAT`='loc.1',
+loc_0 double(12,6) NOT NULL `JPATH`='loc.0',
+loc_1 char(12) NOT NULL `JPATH`='loc.1',
 pop int(11) NOT NULL,
 state char(2) NOT NULL)
 ENGINE=CONNECT CONNECTION='mongodb://localhost:27017' TABLE_TYPE=JSON TABNAME='cities'
@@ -344,11 +344,11 @@ true
 CREATE TABLE t1 (
 _id int(4) NOT NULL,
 item CHAR(8) NOT NULL,
-prices_0 INT(6) FIELD_FORMAT='prices.0',
-prices_1 INT(6) FIELD_FORMAT='prices.1',
-prices_2 INT(6) FIELD_FORMAT='prices.2',
-prices_3 INT(6) FIELD_FORMAT='prices.3',
-prices_4 INT(6) FIELD_FORMAT='prices.4')
+prices_0 INT(6) JPATH='prices.0',
+prices_1 INT(6) JPATH='prices.1',
+prices_2 INT(6) JPATH='prices.2',
+prices_3 INT(6) JPATH='prices.3',
+prices_4 INT(6) JPATH='prices.4')
 ENGINE=CONNECT TABLE_TYPE=JSON TABNAME='testcoll' DATA_CHARSET=utf8
 OPTION_LIST='Driver=C,Version=0' CONNECTION='mongodb://localhost:27017' LRECL=1024;
 INSERT INTO t1 VALUES
diff --git a/storage/connect/mysql-test/connect/r/mongo_c.result b/storage/connect/mysql-test/connect/r/mongo_c.result
index 132bb34ce64..cabdf713d16 100644
--- a/storage/connect/mysql-test/connect/r/mongo_c.result
+++ b/storage/connect/mysql-test/connect/r/mongo_c.result
@@ -2,7 +2,7 @@ set connect_enable_mongo=1;
 #
 # Test the MONGO table type
 #
-CREATE TABLE t1 (Document varchar(1024) field_format='*')
+CREATE TABLE t1 (Document varchar(1024) JPATH='*')
 ENGINE=CONNECT TABLE_TYPE=MONGO TABNAME=restaurants 
 OPTION_LIST='Driver=C,Version=0' DATA_CHARSET=utf8;
 SELECT * from t1 limit 3;
@@ -15,7 +15,7 @@ DROP TABLE t1;
 # Test catfunc
 #
 CREATE TABLE t1 ENGINE=CONNECT TABLE_TYPE=MONGO TABNAME=restaurants CATFUNC=columns
-OPTION_LIST='Level=1,Driver=C,Version=0' DATA_CHARSET=utf8 ;
+OPTION_LIST='Depth=1,Driver=C,Version=0' DATA_CHARSET=utf8 ;
 SELECT * from t1;
 Column_Name	Data_Type	Type_Name	Column_Size	Buffer_Length	Decimal_Digits	Nullable	Bpath
 _id	1	CHAR	24	24	0	0	
@@ -58,7 +58,7 @@ DROP TABLE t1;
 # Test discovery
 #
 CREATE TABLE t1 ENGINE=CONNECT TABLE_TYPE=MONGO TABNAME=restaurants
-OPTION_LIST='Level=1,Driver=C,Version=0'  DATA_CHARSET=utf8;
+OPTION_LIST='Depth=1,Driver=C,Version=0'  DATA_CHARSET=utf8;
 SHOW CREATE TABLE t1;
 Table	Create Table
 t1	CREATE TABLE `t1` (
@@ -72,7 +72,7 @@ t1	CREATE TABLE `t1` (
   `grades_0` varchar(512) DEFAULT NULL `FIELD_FORMAT`='grades.0',
   `name` char(98) NOT NULL,
   `restaurant_id` char(8) NOT NULL
-) ENGINE=CONNECT DEFAULT CHARSET=latin1 `TABLE_TYPE`='MONGO' `TABNAME`='restaurants' `OPTION_LIST`='Level=1,Driver=C,Version=0' `DATA_CHARSET`='utf8'
+) ENGINE=CONNECT DEFAULT CHARSET=latin1 `TABLE_TYPE`='MONGO' `TABNAME`='restaurants' `OPTION_LIST`='Depth=1,Driver=C,Version=0' `DATA_CHARSET`='utf8'
 SELECT * FROM t1 LIMIT 5;
 _id	address_building	address_coord	address_street	address_zipcode	borough	cuisine	grades_0	name	restaurant_id
 58ada47de5a51ddfcd5ed51c	1007		Morris Park Ave	10462	Bronx	Bakery	{"date":{"$date":1393804800000},"grade":"A","score":2}	Morris Park Bake Shop	30075445
@@ -107,12 +107,12 @@ _id VARCHAR(24) NOT NULL,
 name VARCHAR(64) NOT NULL,
 cuisine CHAR(200) NOT NULL,
 borough CHAR(16) NOT NULL,
-street VARCHAR(65) FIELD_FORMAT='address.street',
-building CHAR(16) FIELD_FORMAT='address.building',
-zipcode CHAR(5) FIELD_FORMAT='address.zipcode',
-grade CHAR(1) FIELD_FORMAT='grades.0.grade',
-score INT(4) NOT NULL FIELD_FORMAT='grades.0.score',
-`date` DATE FIELD_FORMAT='grades.0.date',
+street VARCHAR(65) JPATH='address.street',
+building CHAR(16) JPATH='address.building',
+zipcode CHAR(5) JPATH='address.zipcode',
+grade CHAR(1) JPATH='grades.0.grade',
+score INT(4) NOT NULL JPATH='grades.0.score',
+`date` DATE JPATH='grades.0.date',
 restaurant_id VARCHAR(255) NOT NULL)
 ENGINE=CONNECT TABLE_TYPE=MONGO TABNAME='restaurants' DATA_CHARSET=utf8
 OPTION_LIST='Driver=C,Version=0' ;
@@ -301,8 +301,8 @@ false
 CREATE TABLE t1 (
 _id char(5) NOT NULL,
 city char(16) NOT NULL,
-loc_0 double(12,6) NOT NULL `FIELD_FORMAT`='loc.0',
-loc_1 char(12) NOT NULL `FIELD_FORMAT`='loc.1',
+loc_0 double(12,6) NOT NULL `JPATH`='loc.0',
+loc_1 char(12) NOT NULL `JPATH`='loc.1',
 pop int(11) NOT NULL,
 state char(2) NOT NULL)
 ENGINE=CONNECT CONNECTION='mongodb://localhost:27017' TABLE_TYPE=MONGO TABNAME='cities'
@@ -340,11 +340,11 @@ true
 CREATE TABLE t1 (
 _id int(4) NOT NULL,
 item CHAR(8) NOT NULL,
-prices_0 INT(6) FIELD_FORMAT='prices.0',
-prices_1 INT(6) FIELD_FORMAT='prices.1',
-prices_2 INT(6) FIELD_FORMAT='prices.2',
-prices_3 INT(6) FIELD_FORMAT='prices.3',
-prices_4 INT(6) FIELD_FORMAT='prices.4')
+prices_0 INT(6) JPATH='prices.0',
+prices_1 INT(6) JPATH='prices.1',
+prices_2 INT(6) JPATH='prices.2',
+prices_3 INT(6) JPATH='prices.3',
+prices_4 INT(6) JPATH='prices.4')
 ENGINE=CONNECT TABLE_TYPE=MONGO TABNAME='testcoll' DATA_CHARSET=utf8
 OPTION_LIST='Driver=C,Version=0' ;
 INSERT INTO t1 VALUES
diff --git a/storage/connect/mysql-test/connect/r/mongo_java_2.result b/storage/connect/mysql-test/connect/r/mongo_java_2.result
index bc186d7137e..890b88324bb 100644
--- a/storage/connect/mysql-test/connect/r/mongo_java_2.result
+++ b/storage/connect/mysql-test/connect/r/mongo_java_2.result
@@ -2,7 +2,7 @@ set connect_enable_mongo=1;
 #
 # Test the MONGO table type
 #
-CREATE TABLE t1 (Document varchar(1024) field_format='*')
+CREATE TABLE t1 (Document varchar(1024) JPATH='*')
 ENGINE=CONNECT TABLE_TYPE=MONGO TABNAME=restaurants 
 OPTION_LIST='Driver=Java,Version=2' DATA_CHARSET=utf8;
 SELECT * from t1 limit 3;
@@ -15,7 +15,7 @@ DROP TABLE t1;
 # Test catfunc
 #
 CREATE TABLE t1 ENGINE=CONNECT TABLE_TYPE=MONGO TABNAME=restaurants CATFUNC=columns
-OPTION_LIST='Level=1,Driver=Java,Version=2' DATA_CHARSET=utf8 ;
+OPTION_LIST='Depth=1,Driver=Java,Version=2' DATA_CHARSET=utf8 ;
 SELECT * from t1;
 Column_Name	Data_Type	Type_Name	Column_Size	Buffer_Length	Decimal_Digits	Nullable	Bpath
 _id	1	CHAR	24	24	0	0	
@@ -58,7 +58,7 @@ DROP TABLE t1;
 # Test discovery
 #
 CREATE TABLE t1 ENGINE=CONNECT TABLE_TYPE=MONGO TABNAME=restaurants
-OPTION_LIST='Level=1,Driver=Java,Version=2'  DATA_CHARSET=utf8;
+OPTION_LIST='Depth=1,Driver=Java,Version=2'  DATA_CHARSET=utf8;
 SHOW CREATE TABLE t1;
 Table	Create Table
 t1	CREATE TABLE `t1` (
@@ -72,7 +72,7 @@ t1	CREATE TABLE `t1` (
   `grades_0` char(99) DEFAULT NULL `FIELD_FORMAT`='grades.0',
   `name` char(98) NOT NULL,
   `restaurant_id` char(8) NOT NULL
-) ENGINE=CONNECT DEFAULT CHARSET=latin1 `TABLE_TYPE`='MONGO' `TABNAME`='restaurants' `OPTION_LIST`='Level=1,Driver=Java,Version=2' `DATA_CHARSET`='utf8'
+) ENGINE=CONNECT DEFAULT CHARSET=latin1 `TABLE_TYPE`='MONGO' `TABNAME`='restaurants' `OPTION_LIST`='Depth=1,Driver=Java,Version=2' `DATA_CHARSET`='utf8'
 SELECT * FROM t1 LIMIT 5;
 _id	address_building	address_coord	address_street	address_zipcode	borough	cuisine	grades_0	name	restaurant_id
 58ada47de5a51ddfcd5ed51c	1007	[ -73.856077 , 40.848447]	Morris Park Ave	10462	Bronx	Bakery	{ "date" : { "$date" : "2014-03-03T00:00:00.000Z"} , "grade" : "A" , "score" : 2}	Morris Park Bake Shop	30075445
@@ -107,12 +107,12 @@ _id VARCHAR(24) NOT NULL,
 name VARCHAR(64) NOT NULL,
 cuisine CHAR(200) NOT NULL,
 borough CHAR(16) NOT NULL,
-street VARCHAR(65) FIELD_FORMAT='address.street',
-building CHAR(16) FIELD_FORMAT='address.building',
-zipcode CHAR(5) FIELD_FORMAT='address.zipcode',
-grade CHAR(1) FIELD_FORMAT='grades.0.grade',
-score INT(4) NOT NULL FIELD_FORMAT='grades.0.score',
-`date` DATE FIELD_FORMAT='grades.0.date',
+street VARCHAR(65) JPATH='address.street',
+building CHAR(16) JPATH='address.building',
+zipcode CHAR(5) JPATH='address.zipcode',
+grade CHAR(1) JPATH='grades.0.grade',
+score INT(4) NOT NULL JPATH='grades.0.score',
+`date` DATE JPATH='grades.0.date',
 restaurant_id VARCHAR(255) NOT NULL)
 ENGINE=CONNECT TABLE_TYPE=MONGO TABNAME='restaurants' DATA_CHARSET=utf8
 OPTION_LIST='Driver=Java,Version=2' ;
@@ -301,8 +301,8 @@ false
 CREATE TABLE t1 (
 _id char(5) NOT NULL,
 city char(16) NOT NULL,
-loc_0 double(12,6) NOT NULL `FIELD_FORMAT`='loc.0',
-loc_1 char(12) NOT NULL `FIELD_FORMAT`='loc.1',
+loc_0 double(12,6) NOT NULL `JPATH`='loc.0',
+loc_1 char(12) NOT NULL `JPATH`='loc.1',
 pop int(11) NOT NULL,
 state char(2) NOT NULL)
 ENGINE=CONNECT CONNECTION='mongodb://localhost:27017' TABLE_TYPE=MONGO TABNAME='cities'
@@ -340,11 +340,11 @@ true
 CREATE TABLE t1 (
 _id int(4) NOT NULL,
 item CHAR(8) NOT NULL,
-prices_0 INT(6) FIELD_FORMAT='prices.0',
-prices_1 INT(6) FIELD_FORMAT='prices.1',
-prices_2 INT(6) FIELD_FORMAT='prices.2',
-prices_3 INT(6) FIELD_FORMAT='prices.3',
-prices_4 INT(6) FIELD_FORMAT='prices.4')
+prices_0 INT(6) JPATH='prices.0',
+prices_1 INT(6) JPATH='prices.1',
+prices_2 INT(6) JPATH='prices.2',
+prices_3 INT(6) JPATH='prices.3',
+prices_4 INT(6) JPATH='prices.4')
 ENGINE=CONNECT TABLE_TYPE=MONGO TABNAME='testcoll' DATA_CHARSET=utf8
 OPTION_LIST='Driver=Java,Version=2' ;
 INSERT INTO t1 VALUES
diff --git a/storage/connect/mysql-test/connect/r/mongo_java_3.result b/storage/connect/mysql-test/connect/r/mongo_java_3.result
index 30c696fc9eb..f6f9895a29e 100644
--- a/storage/connect/mysql-test/connect/r/mongo_java_3.result
+++ b/storage/connect/mysql-test/connect/r/mongo_java_3.result
@@ -2,7 +2,7 @@ set connect_enable_mongo=1;
 #
 # Test the MONGO table type
 #
-CREATE TABLE t1 (Document varchar(1024) field_format='*')
+CREATE TABLE t1 (Document varchar(1024) JPATH='*')
 ENGINE=CONNECT TABLE_TYPE=MONGO TABNAME=restaurants 
 OPTION_LIST='Driver=Java,Version=3' DATA_CHARSET=utf8;
 SELECT * from t1 limit 3;
@@ -15,7 +15,7 @@ DROP TABLE t1;
 # Test catfunc
 #
 CREATE TABLE t1 ENGINE=CONNECT TABLE_TYPE=MONGO TABNAME=restaurants CATFUNC=columns
-OPTION_LIST='Level=1,Driver=Java,Version=3' DATA_CHARSET=utf8 ;
+OPTION_LIST='Depth=1,Driver=Java,Version=3' DATA_CHARSET=utf8 ;
 SELECT * from t1;
 Column_Name	Data_Type	Type_Name	Column_Size	Buffer_Length	Decimal_Digits	Nullable	Bpath
 _id	1	CHAR	24	24	0	0	
@@ -58,7 +58,7 @@ DROP TABLE t1;
 # Test discovery
 #
 CREATE TABLE t1 ENGINE=CONNECT TABLE_TYPE=MONGO TABNAME=restaurants
-OPTION_LIST='Level=1,Driver=Java,Version=3'  DATA_CHARSET=utf8;
+OPTION_LIST='Depth=1,Driver=Java,Version=3'  DATA_CHARSET=utf8;
 SHOW CREATE TABLE t1;
 Table	Create Table
 t1	CREATE TABLE `t1` (
@@ -72,7 +72,7 @@ t1	CREATE TABLE `t1` (
   `grades_0` char(84) DEFAULT NULL `FIELD_FORMAT`='grades.0',
   `name` char(98) NOT NULL,
   `restaurant_id` char(8) NOT NULL
-) ENGINE=CONNECT DEFAULT CHARSET=latin1 `TABLE_TYPE`='MONGO' `TABNAME`='restaurants' `OPTION_LIST`='Level=1,Driver=Java,Version=3' `DATA_CHARSET`='utf8'
+) ENGINE=CONNECT DEFAULT CHARSET=latin1 `TABLE_TYPE`='MONGO' `TABNAME`='restaurants' `OPTION_LIST`='Depth=1,Driver=Java,Version=3' `DATA_CHARSET`='utf8'
 SELECT * FROM t1 LIMIT 5;
 _id	address_building	address_coord	address_street	address_zipcode	borough	cuisine	grades_0	name	restaurant_id
 58ada47de5a51ddfcd5ed51c	1007	[-73.856077, 40.848447]	Morris Park Ave	10462	Bronx	Bakery	{ "date" : { "$date" : 1393804800000 }, "grade" : "A", "score" : 2 }	Morris Park Bake Shop	30075445
@@ -107,12 +107,12 @@ _id VARCHAR(24) NOT NULL,
 name VARCHAR(64) NOT NULL,
 cuisine CHAR(200) NOT NULL,
 borough CHAR(16) NOT NULL,
-street VARCHAR(65) FIELD_FORMAT='address.street',
-building CHAR(16) FIELD_FORMAT='address.building',
-zipcode CHAR(5) FIELD_FORMAT='address.zipcode',
-grade CHAR(1) FIELD_FORMAT='grades.0.grade',
-score INT(4) NOT NULL FIELD_FORMAT='grades.0.score',
-`date` DATE FIELD_FORMAT='grades.0.date',
+street VARCHAR(65) JPATH='address.street',
+building CHAR(16) JPATH='address.building',
+zipcode CHAR(5) JPATH='address.zipcode',
+grade CHAR(1) JPATH='grades.0.grade',
+score INT(4) NOT NULL JPATH='grades.0.score',
+`date` DATE JPATH='grades.0.date',
 restaurant_id VARCHAR(255) NOT NULL)
 ENGINE=CONNECT TABLE_TYPE=MONGO TABNAME='restaurants' DATA_CHARSET=utf8
 OPTION_LIST='Driver=Java,Version=3' ;
@@ -301,8 +301,8 @@ false
 CREATE TABLE t1 (
 _id char(5) NOT NULL,
 city char(16) NOT NULL,
-loc_0 double(12,6) NOT NULL `FIELD_FORMAT`='loc.0',
-loc_1 char(12) NOT NULL `FIELD_FORMAT`='loc.1',
+loc_0 double(12,6) NOT NULL `JPATH`='loc.0',
+loc_1 char(12) NOT NULL `JPATH`='loc.1',
 pop int(11) NOT NULL,
 state char(2) NOT NULL)
 ENGINE=CONNECT CONNECTION='mongodb://localhost:27017' TABLE_TYPE=MONGO TABNAME='cities'
@@ -340,11 +340,11 @@ true
 CREATE TABLE t1 (
 _id int(4) NOT NULL,
 item CHAR(8) NOT NULL,
-prices_0 INT(6) FIELD_FORMAT='prices.0',
-prices_1 INT(6) FIELD_FORMAT='prices.1',
-prices_2 INT(6) FIELD_FORMAT='prices.2',
-prices_3 INT(6) FIELD_FORMAT='prices.3',
-prices_4 INT(6) FIELD_FORMAT='prices.4')
+prices_0 INT(6) JPATH='prices.0',
+prices_1 INT(6) JPATH='prices.1',
+prices_2 INT(6) JPATH='prices.2',
+prices_3 INT(6) JPATH='prices.3',
+prices_4 INT(6) JPATH='prices.4')
 ENGINE=CONNECT TABLE_TYPE=MONGO TABNAME='testcoll' DATA_CHARSET=utf8
 OPTION_LIST='Driver=Java,Version=3' ;
 INSERT INTO t1 VALUES
diff --git a/storage/connect/mysql-test/connect/r/odbc_oracle.result b/storage/connect/mysql-test/connect/r/odbc_oracle.result
index 8dc7dc07bb1..acb7d9a74c9 100644
--- a/storage/connect/mysql-test/connect/r/odbc_oracle.result
+++ b/storage/connect/mysql-test/connect/r/odbc_oracle.result
@@ -10,7 +10,7 @@ SET NAMES utf8;
 
 # All tables in all schemas (filtered with WHERE)
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 CATFUNC=Tables;
 SELECT * FROM t1 WHERE Table_Schema='MTR' ORDER BY Table_Schema, Table_Name;
 Table_Cat	Table_Schema	Table_Name	Table_Type	Remark
@@ -20,7 +20,7 @@ NULL	MTR	V1	VIEW	NULL
 DROP TABLE t1;
 # All tables in all schemas (filtered with WHERE)
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 CATFUNC=Tables TABNAME='%.%';
 SELECT * FROM t1 WHERE Table_Schema='MTR' ORDER BY Table_Schema, Table_Name;
 Table_Cat	Table_Schema	Table_Name	Table_Type	Remark
@@ -30,7 +30,7 @@ NULL	MTR	V1	VIEW	NULL
 DROP TABLE t1;
 # All tables "T1" in all schemas (filtered with WHERE)
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 CATFUNC=Tables TABNAME='%.T1';
 SELECT * FROM t1 WHERE Table_Schema='MTR' ORDER BY Table_Schema, Table_Name;
 Table_Cat	Table_Schema	Table_Name	Table_Type	Remark
@@ -38,7 +38,7 @@ NULL	MTR	T1	TABLE	NULL
 DROP TABLE t1;
 # All tables "T1" in all schemas (filtered with WHERE)
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 CATFUNC=Tables TABNAME='T1';
 SELECT * FROM t1 WHERE Table_Schema='MTR' ORDER BY Table_Schema, Table_Name;
 Table_Cat	Table_Schema	Table_Name	Table_Type	Remark
@@ -46,7 +46,7 @@ NULL	MTR	T1	TABLE	NULL
 DROP TABLE t1;
 # Table "T1" in the schema "MTR"
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 CATFUNC=Tables TABNAME='MTR.T1';
 SELECT * FROM t1 ORDER BY Table_Schema, Table_Name;
 Table_Cat	Table_Schema	Table_Name	Table_Type	Remark
@@ -54,7 +54,7 @@ NULL	MTR	T1	TABLE	NULL
 DROP TABLE t1;
 # All tables in the schema "MTR"
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 CATFUNC=Tables TABNAME='MTR.%';
 SELECT * FROM t1 ORDER BY Table_Schema, Table_Name;
 Table_Cat	Table_Schema	Table_Name	Table_Type	Remark
@@ -68,7 +68,7 @@ DROP TABLE t1;
 
 # All columns in all schemas (limited with WHERE)
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 CATFUNC=Columns;
 SELECT * FROM t1 WHERE Table_Schema='MTR' ORDER BY Table_Schema, Table_Name;
 Table_Cat	Table_Schema	Table_Name	Column_Name	Data_Type	Type_Name	Column_Size	Buffer_Length	Decimal_Digits	Radix	Nullable	Remarks
@@ -80,7 +80,7 @@ Table_Cat	Table_Schema	Table_Name	Column_Name	Data_Type	Type_Name	Column_Size	Bu
 DROP TABLE t1;
 # All columns in all schemas (limited with WHERE)
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 CATFUNC=Columns TABNAME='%.%';
 SELECT * FROM t1 WHERE Table_Schema='MTR' ORDER BY Table_Schema, Table_Name;
 Table_Cat	Table_Schema	Table_Name	Column_Name	Data_Type	Type_Name	Column_Size	Buffer_Length	Decimal_Digits	Radix	Nullable	Remarks
@@ -91,7 +91,7 @@ Table_Cat	Table_Schema	Table_Name	Column_Name	Data_Type	Type_Name	Column_Size	Bu
 	MTR	V1	B	6	NUMBER	38	40	NULL	NULL	1	
 DROP TABLE t1;
 # All tables "T1" in all schemas (limited with WHERE)
-CREATE TABLE t1 ENGINE=CONNECT TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr' CATFUNC=Columns TABNAME='%.T1';
+CREATE TABLE t1 ENGINE=CONNECT TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr' CATFUNC=Columns TABNAME='%.T1';
 SELECT * FROM t1 WHERE Table_Schema='MTR' ORDER BY Table_Schema, Table_Name;
 Table_Cat	Table_Schema	Table_Name	Column_Name	Data_Type	Type_Name	Column_Size	Buffer_Length	Decimal_Digits	Radix	Nullable	Remarks
 	MTR	T1	A	3	DECIMAL	38	40	0	10	1	
@@ -99,7 +99,7 @@ Table_Cat	Table_Schema	Table_Name	Column_Name	Data_Type	Type_Name	Column_Size	Bu
 DROP TABLE t1;
 # Table "T1" in the schema "MTR"
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 CATFUNC=Columns TABNAME='MTR.T1';
 SELECT * FROM t1 ORDER BY Table_Schema, Table_Name;
 Table_Cat	Table_Schema	Table_Name	Column_Name	Data_Type	Type_Name	Column_Size	Buffer_Length	Decimal_Digits	Radix	Nullable	Remarks
@@ -108,7 +108,7 @@ Table_Cat	Table_Schema	Table_Name	Column_Name	Data_Type	Type_Name	Column_Size	Bu
 DROP TABLE t1;
 # All tables "T1" in all schemas (filtered with WHERE)
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 CATFUNC=Columns TABNAME='%.T1';
 SELECT * FROM t1 WHERE Table_Schema='MTR' ORDER BY Table_Schema, Table_Name;
 Table_Cat	Table_Schema	Table_Name	Column_Name	Data_Type	Type_Name	Column_Size	Buffer_Length	Decimal_Digits	Radix	Nullable	Remarks
@@ -121,14 +121,14 @@ DROP TABLE t1;
 
 # Table "T1" in the default schema ("MTR")
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 TABNAME='T1';
 SHOW CREATE TABLE t1;
 Table	Create Table
 t1	CREATE TABLE `t1` (
   `A` decimal(40,0) DEFAULT NULL,
   `B` double DEFAULT NULL
-) ENGINE=CONNECT DEFAULT CHARSET=latin1 CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr' `TABLE_TYPE`='ODBC' `TABNAME`='T1'
+) ENGINE=CONNECT DEFAULT CHARSET=latin1 CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr' `TABLE_TYPE`='ODBC' `TABNAME`='T1'
 SELECT * FROM t1 ORDER BY A;
 A	B
 10	1000000000
@@ -157,14 +157,14 @@ DROP VIEW v1;
 DROP TABLE t1;
 # Table "T1" in the schema "MTR"
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 TABNAME='MTR.T1';
 SHOW CREATE TABLE t1;
 Table	Create Table
 t1	CREATE TABLE `t1` (
   `A` decimal(40,0) DEFAULT NULL,
   `B` double DEFAULT NULL
-) ENGINE=CONNECT DEFAULT CHARSET=latin1 CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr' `TABLE_TYPE`='ODBC' `TABNAME`='MTR.T1'
+) ENGINE=CONNECT DEFAULT CHARSET=latin1 CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr' `TABLE_TYPE`='ODBC' `TABNAME`='MTR.T1'
 SELECT * FROM t1;
 A	B
 10	1000000000
@@ -173,14 +173,14 @@ A	B
 DROP TABLE t1;
 # View "V1" in the schema "MTR"
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 TABNAME='MTR.V1';
 SHOW CREATE TABLE t1;
 Table	Create Table
 t1	CREATE TABLE `t1` (
   `A` decimal(40,0) DEFAULT NULL,
   `B` double DEFAULT NULL
-) ENGINE=CONNECT DEFAULT CHARSET=latin1 CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr' `TABLE_TYPE`='ODBC' `TABNAME`='MTR.V1'
+) ENGINE=CONNECT DEFAULT CHARSET=latin1 CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr' `TABLE_TYPE`='ODBC' `TABNAME`='MTR.V1'
 SELECT * FROM t1;
 A	B
 10	1000000000
@@ -209,13 +209,13 @@ DROP VIEW v1;
 DROP TABLE t1;
 # Table "T2" in the schema "MTR"
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 TABNAME='MTR.T2';
 SHOW CREATE TABLE t1;
 Table	Create Table
 t1	CREATE TABLE `t1` (
   `A` varchar(64) DEFAULT NULL
-) ENGINE=CONNECT DEFAULT CHARSET=latin1 CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr' `TABLE_TYPE`='ODBC' `TABNAME`='MTR.T2'
+) ENGINE=CONNECT DEFAULT CHARSET=latin1 CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr' `TABLE_TYPE`='ODBC' `TABNAME`='MTR.T2'
 SELECT * FROM t1;
 A
 test
diff --git a/storage/connect/mysql-test/connect/r/xml.result b/storage/connect/mysql-test/connect/r/xml.result
index 6a0c9db27b3..09dac32a2a4 100644
--- a/storage/connect/mysql-test/connect/r/xml.result
+++ b/storage/connect/mysql-test/connect/r/xml.result
@@ -85,9 +85,9 @@ DROP TABLE t1;
 # Testing mixed tag and attribute values
 #
 CREATE TABLE t1 (
-ISBN CHAR(15) FIELD_FORMAT='@',
-LANG CHAR(2)  FIELD_FORMAT='@',
-SUBJECT CHAR(32) FIELD_FORMAT='@',
+ISBN CHAR(15) XPATH='@',
+LANG CHAR(2)  XPATH='@',
+SUBJECT CHAR(32) XPATH='@',
 AUTHOR CHAR(50),
 TITLE CHAR(32),
 TRANSLATOR CHAR(40),
@@ -118,9 +118,9 @@ DROP TABLE t1;
 # Testing INSERT on mixed tag and attribute values
 #
 CREATE TABLE t1 (
-ISBN CHAR(15) FIELD_FORMAT='@',
-LANG CHAR(2)  FIELD_FORMAT='@',
-SUBJECT CHAR(32) FIELD_FORMAT='@',
+ISBN CHAR(15) XPATH='@',
+LANG CHAR(2)  XPATH='@',
+SUBJECT CHAR(32) XPATH='@',
 AUTHOR CHAR(50),
 TITLE CHAR(32),
 TRANSLATOR CHAR(40),
@@ -205,18 +205,18 @@ DROP TABLE t1;
 # Testing XPath
 #
 CREATE TABLE t1 (
-isbn       CHAR(15) FIELD_FORMAT='@ISBN',
-language   CHAR(2)  FIELD_FORMAT='@LANG',
-subject    CHAR(32) FIELD_FORMAT='@SUBJECT',
-authorfn   CHAR(20) FIELD_FORMAT='AUTHOR/FIRSTNAME',
-authorln   CHAR(20) FIELD_FORMAT='AUTHOR/LASTNAME',
-title      CHAR(32) FIELD_FORMAT='TITLE',
-translated CHAR(32) FIELD_FORMAT='TRANSLATOR/@PREFIX',
-tranfn     CHAR(20) FIELD_FORMAT='TRANSLATOR/FIRSTNAME',
-tranln     CHAR(20) FIELD_FORMAT='TRANSLATOR/LASTNAME',
-publisher  CHAR(20) FIELD_FORMAT='PUBLISHER/NAME',
-location   CHAR(20) FIELD_FORMAT='PUBLISHER/PLACE',
-year       INT(4)   FIELD_FORMAT='DATEPUB'
+isbn       CHAR(15) XPATH='@ISBN',
+language   CHAR(2)  XPATH='@LANG',
+subject    CHAR(32) XPATH='@SUBJECT',
+authorfn   CHAR(20) XPATH='AUTHOR/FIRSTNAME',
+authorln   CHAR(20) XPATH='AUTHOR/LASTNAME',
+title      CHAR(32) XPATH='TITLE',
+translated CHAR(32) XPATH='TRANSLATOR/@PREFIX',
+tranfn     CHAR(20) XPATH='TRANSLATOR/FIRSTNAME',
+tranln     CHAR(20) XPATH='TRANSLATOR/LASTNAME',
+publisher  CHAR(20) XPATH='PUBLISHER/NAME',
+location   CHAR(20) XPATH='PUBLISHER/PLACE',
+year       INT(4)   XPATH='DATEPUB'
 ) ENGINE=CONNECT TABLE_TYPE=XML FILE_NAME='xsample.xml'
   TABNAME='BIBLIO' OPTION_LIST='rownode=BOOK,skipnull=1,xmlsup=domdoc';
 SELECT * FROM t1;
@@ -258,7 +258,7 @@ DROP TABLE t1;
 #
 CREATE TABLE t1
 (
-isbn       CHAR(15) FIELD_FORMAT='@isbn'
+isbn       CHAR(15) XPATH='@isbn'
 ) ENGINE=CONNECT TABLE_TYPE=XML FILE_NAME='xsample.xml'
   TABNAME='BIBLIO' OPTION_LIST='rownode=BOOK,skipnull=1,xmlsup=domdoc';
 SELECT * FROM t1;
@@ -374,7 +374,7 @@ INSERT INTO t1 VALUES (_cp1251 0xC0C1C2C3);
 Warnings:
 Level	Warning
 Code	1105
-Message	Com error: Unable to save character to 'iso-8859-1' encoding.

+Message	Com error: Impossible d'enregistrer le caractère dans le codage iso-8859-1.

 
 INSERT INTO t1 VALUES ('&<>"\'');
 SELECT node, hex(node) FROM t1;
diff --git a/storage/connect/mysql-test/connect/r/xml2.result b/storage/connect/mysql-test/connect/r/xml2.result
index f7bbc17c8a0..891c6e6f8dd 100644
--- a/storage/connect/mysql-test/connect/r/xml2.result
+++ b/storage/connect/mysql-test/connect/r/xml2.result
@@ -87,9 +87,9 @@ DROP TABLE t1;
 # Testing mixed tag and attribute values
 #
 CREATE TABLE t1 (
-ISBN CHAR(15) FIELD_FORMAT='@',
-LANG CHAR(2)  FIELD_FORMAT='@',
-SUBJECT CHAR(32) FIELD_FORMAT='@',
+ISBN CHAR(15) XPATH='@',
+LANG CHAR(2)  XPATH='@',
+SUBJECT CHAR(32) XPATH='@',
 AUTHOR CHAR(50),
 TITLE CHAR(32),
 TRANSLATOR CHAR(40),
@@ -120,9 +120,9 @@ DROP TABLE t1;
 # Testing INSERT on mixed tag and attribute values
 #
 CREATE TABLE t1 (
-ISBN CHAR(15) FIELD_FORMAT='@',
-LANG CHAR(2)  FIELD_FORMAT='@',
-SUBJECT CHAR(32) FIELD_FORMAT='@',
+ISBN CHAR(15) XPATH='@',
+LANG CHAR(2)  XPATH='@',
+SUBJECT CHAR(32) XPATH='@',
 AUTHOR CHAR(50),
 TITLE CHAR(32),
 TRANSLATOR CHAR(40),
@@ -207,18 +207,18 @@ DROP TABLE t1;
 # Testing XPath
 #
 CREATE TABLE t1 (
-isbn       CHAR(15) FIELD_FORMAT='@ISBN',
-language   CHAR(2)  FIELD_FORMAT='@LANG',
-subject    CHAR(32) FIELD_FORMAT='@SUBJECT',
-authorfn   CHAR(20) FIELD_FORMAT='AUTHOR/FIRSTNAME',
-authorln   CHAR(20) FIELD_FORMAT='AUTHOR/LASTNAME',
-title      CHAR(32) FIELD_FORMAT='TITLE',
-translated CHAR(32) FIELD_FORMAT='TRANSLATOR/@PREFIX',
-tranfn     CHAR(20) FIELD_FORMAT='TRANSLATOR/FIRSTNAME',
-tranln     CHAR(20) FIELD_FORMAT='TRANSLATOR/LASTNAME',
-publisher  CHAR(20) FIELD_FORMAT='PUBLISHER/NAME',
-location   CHAR(20) FIELD_FORMAT='PUBLISHER/PLACE',
-year       INT(4)   FIELD_FORMAT='DATEPUB'
+isbn       CHAR(15) XPATH='@ISBN',
+language   CHAR(2)  XPATH='@LANG',
+subject    CHAR(32) XPATH='@SUBJECT',
+authorfn   CHAR(20) XPATH='AUTHOR/FIRSTNAME',
+authorln   CHAR(20) XPATH='AUTHOR/LASTNAME',
+title      CHAR(32) XPATH='TITLE',
+translated CHAR(32) XPATH='TRANSLATOR/@PREFIX',
+tranfn     CHAR(20) XPATH='TRANSLATOR/FIRSTNAME',
+tranln     CHAR(20) XPATH='TRANSLATOR/LASTNAME',
+publisher  CHAR(20) XPATH='PUBLISHER/NAME',
+location   CHAR(20) XPATH='PUBLISHER/PLACE',
+year       INT(4)   XPATH='DATEPUB'
 ) ENGINE=CONNECT TABLE_TYPE=XML FILE_NAME='xsample.xml'
   TABNAME='BIBLIO' OPTION_LIST='rownode=BOOK,skipnull=1,xmlsup=libxml2';
 SELECT * FROM t1;
@@ -260,7 +260,7 @@ DROP TABLE t1;
 #
 CREATE TABLE t1
 (
-isbn       CHAR(15) FIELD_FORMAT='@isbn'
+isbn       CHAR(15) XPATH='@isbn'
 ) ENGINE=CONNECT TABLE_TYPE=XML FILE_NAME='xsample.xml'
   TABNAME='BIBLIO' OPTION_LIST='rownode=BOOK,skipnull=1,xmlsup=libxml2';
 SELECT * FROM t1;
diff --git a/storage/connect/mysql-test/connect/r/xml2_html.result b/storage/connect/mysql-test/connect/r/xml2_html.result
index 143f46529f6..499108b724d 100644
--- a/storage/connect/mysql-test/connect/r/xml2_html.result
+++ b/storage/connect/mysql-test/connect/r/xml2_html.result
@@ -5,9 +5,9 @@ SET NAMES utf8;
 # Testing HTML like XML file
 #
 CREATE TABLE beers (
-`Name` CHAR(16) FIELD_FORMAT='brandName',
-`Origin` CHAR(16) FIELD_FORMAT='origin',
-`Description` CHAR(32) FIELD_FORMAT='details')
+`Name` CHAR(16) XPATH='brandName',
+`Origin` CHAR(16) XPATH='origin',
+`Description` CHAR(32) XPATH='details')
 ENGINE=CONNECT TABLE_TYPE=XML FILE_NAME='beers.xml'
 TABNAME='table' OPTION_LIST='xmlsup=libxml2,rownode=tr,colnode=td';
 SELECT * FROM beers;
diff --git a/storage/connect/mysql-test/connect/r/xml2_mult.result b/storage/connect/mysql-test/connect/r/xml2_mult.result
index 87d1118edd5..ac4cdea4e7f 100644
--- a/storage/connect/mysql-test/connect/r/xml2_mult.result
+++ b/storage/connect/mysql-test/connect/r/xml2_mult.result
@@ -5,9 +5,9 @@ SET NAMES utf8;
 # Testing expanded values
 #
 CREATE TABLE `bookstore` (
-`category` CHAR(16) NOT NULL FIELD_FORMAT='@',
+`category` CHAR(16) NOT NULL XPATH='@',
 `title` VARCHAR(50) NOT NULL,
-`lang` char(2) NOT NULL FIELD_FORMAT='title/@',
+`lang` char(2) NOT NULL XPATH='title/@',
 `author` VARCHAR(24) NOT NULL,
 `year` INT(4) NOT NULL,
 `price` DOUBLE(8,2) NOT NULL)
diff --git a/storage/connect/mysql-test/connect/r/xml2_zip.result b/storage/connect/mysql-test/connect/r/xml2_zip.result
index f176149c53f..7d67a3d5498 100644
--- a/storage/connect/mysql-test/connect/r/xml2_zip.result
+++ b/storage/connect/mysql-test/connect/r/xml2_zip.result
@@ -4,17 +4,17 @@ Warning	1105	No file name. Table will use t1.xml
 # Testing zipped XML tables
 #
 CREATE TABLE t1 (
-ISBN CHAR(13) NOT NULL FIELD_FORMAT='@',
-LANG CHAR(2) NOT NULL FIELD_FORMAT='@',
-SUBJECT CHAR(12) NOT NULL FIELD_FORMAT='@',
-AUTHOR_FIRSTNAME CHAR(15) NOT NULL FIELD_FORMAT='AUTHOR/FIRSTNAME',
-AUTHOR_LASTNAME CHAR(8) NOT NULL FIELD_FORMAT='AUTHOR/LASTNAME',
-TRANSLATOR_PREFIX CHAR(24) DEFAULT NULL FIELD_FORMAT='TRANSLATOR/@PREFIX',
-TRANSLATOR_FIRSTNAME CHAR(6) DEFAULT NULL FIELD_FORMAT='TRANSLATOR/FIRSTNAME',
-TRANSLATOR_LASTNAME CHAR(6) DEFAULT NULL FIELD_FORMAT='TRANSLATOR/LASTNAME',
+ISBN CHAR(13) NOT NULL XPATH='@',
+LANG CHAR(2) NOT NULL XPATH='@',
+SUBJECT CHAR(12) NOT NULL XPATH='@',
+AUTHOR_FIRSTNAME CHAR(15) NOT NULL XPATH='AUTHOR/FIRSTNAME',
+AUTHOR_LASTNAME CHAR(8) NOT NULL XPATH='AUTHOR/LASTNAME',
+TRANSLATOR_PREFIX CHAR(24) DEFAULT NULL XPATH='TRANSLATOR/@PREFIX',
+TRANSLATOR_FIRSTNAME CHAR(6) DEFAULT NULL XPATH='TRANSLATOR/FIRSTNAME',
+TRANSLATOR_LASTNAME CHAR(6) DEFAULT NULL XPATH='TRANSLATOR/LASTNAME',
 TITLE CHAR(30) NOT NULL,
-PUBLISHER_NAME CHAR(15) NOT NULL FIELD_FORMAT='PUBLISHER/NAME',
-PUBLISHER_PLACE CHAR(5) NOT NULL FIELD_FORMAT='PUBLISHER/PLACE',
+PUBLISHER_NAME CHAR(15) NOT NULL XPATH='PUBLISHER/NAME',
+PUBLISHER_PLACE CHAR(5) NOT NULL XPATH='PUBLISHER/PLACE',
 DATEPUB CHAR(4) NOT NULL
 ) ENGINE=CONNECT TABLE_TYPE=XML FILE_NAME='xsample2.zip' ZIPPED=YES
 OPTION_LIST='entry=xsample2.xml,load=xsample2.xml,rownode=BOOK,xmlsup=libxml2,expand=1,mulnode=AUTHOR';
diff --git a/storage/connect/mysql-test/connect/r/xml_html.result b/storage/connect/mysql-test/connect/r/xml_html.result
index 4b984a49901..308c67ffc28 100644
--- a/storage/connect/mysql-test/connect/r/xml_html.result
+++ b/storage/connect/mysql-test/connect/r/xml_html.result
@@ -3,9 +3,9 @@ SET NAMES utf8;
 # Testing HTML like XML file
 #
 CREATE TABLE beers (
-`Name` CHAR(16) FIELD_FORMAT='brandName',
-`Origin` CHAR(16) FIELD_FORMAT='origin',
-`Description` CHAR(32) FIELD_FORMAT='details')
+`Name` CHAR(16) XPATH='brandName',
+`Origin` CHAR(16) XPATH='origin',
+`Description` CHAR(32) XPATH='details')
 ENGINE=CONNECT TABLE_TYPE=XML FILE_NAME='beers.xml'
 TABNAME='table' OPTION_LIST='xmlsup=domdoc,rownode=tr,colnode=td';
 SELECT * FROM beers;
diff --git a/storage/connect/mysql-test/connect/r/xml_mult.result b/storage/connect/mysql-test/connect/r/xml_mult.result
index 9922b40060c..427adf94313 100644
--- a/storage/connect/mysql-test/connect/r/xml_mult.result
+++ b/storage/connect/mysql-test/connect/r/xml_mult.result
@@ -3,9 +3,9 @@ SET NAMES utf8;
 # Testing expanded values
 #
 CREATE TABLE `bookstore` (
-`category` CHAR(16) NOT NULL FIELD_FORMAT='@',
+`category` CHAR(16) NOT NULL XPATH='@',
 `title` VARCHAR(50) NOT NULL,
-`lang` char(2) NOT NULL FIELD_FORMAT='title/@',
+`lang` char(2) NOT NULL XPATH='title/@',
 `author` VARCHAR(24) NOT NULL,
 `year` INT(4) NOT NULL,
 `price` DOUBLE(8,2) NOT NULL)
diff --git a/storage/connect/mysql-test/connect/r/xml_zip.result b/storage/connect/mysql-test/connect/r/xml_zip.result
index f7790e4cfff..ddde0fa8a35 100644
--- a/storage/connect/mysql-test/connect/r/xml_zip.result
+++ b/storage/connect/mysql-test/connect/r/xml_zip.result
@@ -2,17 +2,17 @@
 # Testing zipped XML tables
 #
 CREATE TABLE t1 (
-ISBN CHAR(13) NOT NULL FIELD_FORMAT='@',
-LANG CHAR(2) NOT NULL FIELD_FORMAT='@',
-SUBJECT CHAR(12) NOT NULL FIELD_FORMAT='@',
-AUTHOR_FIRSTNAME CHAR(15) NOT NULL FIELD_FORMAT='AUTHOR/FIRSTNAME',
-AUTHOR_LASTNAME CHAR(8) NOT NULL FIELD_FORMAT='AUTHOR/LASTNAME',
-TRANSLATOR_PREFIX CHAR(24) DEFAULT NULL FIELD_FORMAT='TRANSLATOR/@PREFIX',
-TRANSLATOR_FIRSTNAME CHAR(6) DEFAULT NULL FIELD_FORMAT='TRANSLATOR/FIRSTNAME',
-TRANSLATOR_LASTNAME CHAR(6) DEFAULT NULL FIELD_FORMAT='TRANSLATOR/LASTNAME',
+ISBN CHAR(13) NOT NULL XPATH='@',
+LANG CHAR(2) NOT NULL XPATH='@',
+SUBJECT CHAR(12) NOT NULL XPATH='@',
+AUTHOR_FIRSTNAME CHAR(15) NOT NULL XPATH='AUTHOR/FIRSTNAME',
+AUTHOR_LASTNAME CHAR(8) NOT NULL XPATH='AUTHOR/LASTNAME',
+TRANSLATOR_PREFIX CHAR(24) DEFAULT NULL XPATH='TRANSLATOR/@PREFIX',
+TRANSLATOR_FIRSTNAME CHAR(6) DEFAULT NULL XPATH='TRANSLATOR/FIRSTNAME',
+TRANSLATOR_LASTNAME CHAR(6) DEFAULT NULL XPATH='TRANSLATOR/LASTNAME',
 TITLE CHAR(30) NOT NULL,
-PUBLISHER_NAME CHAR(15) NOT NULL FIELD_FORMAT='PUBLISHER/NAME',
-PUBLISHER_PLACE CHAR(5) NOT NULL FIELD_FORMAT='PUBLISHER/PLACE',
+PUBLISHER_NAME CHAR(15) NOT NULL XPATH='PUBLISHER/NAME',
+PUBLISHER_PLACE CHAR(5) NOT NULL XPATH='PUBLISHER/PLACE',
 DATEPUB CHAR(4) NOT NULL
 ) ENGINE=CONNECT TABLE_TYPE=XML FILE_NAME='xsample2.zip' ZIPPED=YES
 OPTION_LIST='entry=xsample2.xml,load=xsample2.xml,rownode=BOOK,xmlsup=domdoc,expand=1,mulnode=AUTHOR';
diff --git a/storage/connect/mysql-test/connect/t/alter_xml.test b/storage/connect/mysql-test/connect/t/alter_xml.test
index 8b2164d5548..4c2e1670f4c 100644
--- a/storage/connect/mysql-test/connect/t/alter_xml.test
+++ b/storage/connect/mysql-test/connect/t/alter_xml.test
@@ -21,7 +21,7 @@ SELECT * FROM t2;
 --echo # NOTE: The first (ignored) row is due to the remaining HEADER=1 option.
 
 --echo # Testing field option modification
-ALTER TABLE t1 MODIFY d CHAR(10) NOT NULL FIELD_FORMAT='@', HEADER=0;
+ALTER TABLE t1 MODIFY d CHAR(10) NOT NULL XPATH='@', HEADER=0;
 SELECT * FROM t1;
 SHOW CREATE TABLE t1;
 SELECT * FROM t2;
diff --git a/storage/connect/mysql-test/connect/t/alter_xml2.test b/storage/connect/mysql-test/connect/t/alter_xml2.test
index d67c80c4e9f..ec4065baa47 100644
--- a/storage/connect/mysql-test/connect/t/alter_xml2.test
+++ b/storage/connect/mysql-test/connect/t/alter_xml2.test
@@ -21,7 +21,7 @@ SELECT * FROM t2;
 --echo # NOTE: The first (ignored) row is due to the remaining HEADER=1 option.
 
 --echo # Testing field option modification
-ALTER TABLE t1 MODIFY d CHAR(10) NOT NULL FIELD_FORMAT='@', HEADER=0;
+ALTER TABLE t1 MODIFY d CHAR(10) NOT NULL XPATH='@', HEADER=0;
 SELECT * FROM t1;
 SHOW CREATE TABLE t1;
 SELECT * FROM t2;
diff --git a/storage/connect/mysql-test/connect/t/jdbc_oracle.test b/storage/connect/mysql-test/connect/t/jdbc_oracle.test
index 10cb7a7b77d..1316352d4f5 100644
--- a/storage/connect/mysql-test/connect/t/jdbc_oracle.test
+++ b/storage/connect/mysql-test/connect/t/jdbc_oracle.test
@@ -8,20 +8,20 @@ CREATE TABLE t2 (
   number int(5) not null flag=1,
   message varchar(255) flag=2)
 ENGINE=CONNECT TABLE_TYPE=JDBC CONNECTION='jdbc:oracle:thin:@localhost:1521:xe'
-OPTION_LIST='User=system,Password=manager,Execsrc=1';
+OPTION_LIST='User=system,Password=Choupy01,Execsrc=1';
 SELECT * FROM t2 WHERE command = 'drop table employee';
 SELECT * FROM t2 WHERE command = 'create table employee (id int not null, name varchar(32), title char(16), salary number(8,2))';
 SELECT * FROM t2 WHERE command = "insert into employee values(4567,'Johnson', 'Engineer', 12560.50)";
 
 CREATE TABLE t1 ENGINE=CONNECT TABLE_TYPE=JDBC CATFUNC=tables
 CONNECTION='jdbc:oracle:thin:@localhost:1521:xe'
-OPTION_LIST='User=system,Password=manager';
+OPTION_LIST='User=system,Password=Choupy01';
 SELECT * FROM t1 WHERE table_name='employee';
 DROP TABLE t1;
 
 CREATE TABLE t1 ENGINE=CONNECT TABLE_TYPE=JDBC TABNAME='EMPLOYEE' CATFUNC=columns
 CONNECTION='jdbc:oracle:thin:@localhost:1521:xe'
-OPTION_LIST='User=system,Password=manager';
+OPTION_LIST='User=system,Password=Choupy01';
 SELECT * FROM t1;
 DROP TABLE t1;
 
@@ -32,7 +32,7 @@ CREATE SERVER 'oracle' FOREIGN DATA WRAPPER 'oracle.jdbc.driver.OracleDriver' OP
 HOST 'jdbc:oracle:thin:@localhost:1521:xe',
 DATABASE 'SYSTEM',
 USER 'system',
-PASSWORD 'manager',
+PASSWORD 'Choupy01',
 PORT 0,
 SOCKET '',
 OWNER 'SYSTEM');
diff --git a/storage/connect/mysql-test/connect/t/json.test b/storage/connect/mysql-test/connect/t/json.test
index 018489525f7..8b42ef9cfab 100644
--- a/storage/connect/mysql-test/connect/t/json.test
+++ b/storage/connect/mysql-test/connect/t/json.test
@@ -35,15 +35,15 @@ DROP TABLE t1;
 CREATE TABLE t1
 (
   ISBN CHAR(15),
-  Language CHAR(2) FIELD_FORMAT='$.LANG',
-  Subject CHAR(32) FIELD_FORMAT='$.SUBJECT',
-  Authors INT(2) FIELD_FORMAT='$.AUTHOR[#]',
-  Title CHAR(32) FIELD_FORMAT='$.TITLE',
-  Translation CHAR(32) FIELD_FORMAT='$.TRANSLATION',
-  Translator CHAR(80) FIELD_FORMAT='$.TRANSLATOR',
-  Publisher CHAR(20) FIELD_FORMAT='$.PUBLISHER.NAME',
-  Location CHAR(16) FIELD_FORMAT='$.PUBLISHER.PLACE',
-  Year int(4) FIELD_FORMAT='$.DATEPUB'
+  Language CHAR(2) JPATH='$.LANG',
+  Subject CHAR(32) JPATH='$.SUBJECT',
+  Authors INT(2) JPATH='$.AUTHOR[#]',
+  Title CHAR(32) JPATH='$.TITLE',
+  Translation CHAR(32) JPATH='$.TRANSLATION',
+  Translator CHAR(80) JPATH='$.TRANSLATOR',
+  Publisher CHAR(20) JPATH='$.PUBLISHER.NAME',
+  Location CHAR(16) JPATH='$.PUBLISHER.PLACE',
+  Year int(4) JPATH='$.DATEPUB'
 )
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='biblio.json';
 SELECT * FROM t1;
@@ -55,16 +55,16 @@ DROP TABLE t1;
 CREATE TABLE t1
 (
   ISBN CHAR(15),
-  Language CHAR(2) FIELD_FORMAT='$.LANG',
-  Subject CHAR(32) FIELD_FORMAT='$.SUBJECT',
-  AuthorFN CHAR(128) FIELD_FORMAT='$.AUTHOR[" and "].FIRSTNAME',
-  AuthorLN CHAR(128) FIELD_FORMAT='$.AUTHOR[" and "].LASTNAME',
-  Title CHAR(32) FIELD_FORMAT='$.TITLE',
-  Translation CHAR(32) FIELD_FORMAT='$.TRANSLATION',
-  Translator CHAR(80) FIELD_FORMAT='$.TRANSLATOR',
-  Publisher CHAR(20) FIELD_FORMAT='$.PUBLISHER.NAME',
-  Location CHAR(16) FIELD_FORMAT='$.PUBLISHER.PLACE',
-  Year int(4) FIELD_FORMAT='$.DATEPUB'
+  Language CHAR(2) JPATH='$.LANG',
+  Subject CHAR(32) JPATH='$.SUBJECT',
+  AuthorFN CHAR(128) JPATH='$.AUTHOR[" and "].FIRSTNAME',
+  AuthorLN CHAR(128) JPATH='$.AUTHOR[" and "].LASTNAME',
+  Title CHAR(32) JPATH='$.TITLE',
+  Translation CHAR(32) JPATH='$.TRANSLATION',
+  Translator CHAR(80) JPATH='$.TRANSLATOR',
+  Publisher CHAR(20) JPATH='$.PUBLISHER.NAME',
+  Location CHAR(16) JPATH='$.PUBLISHER.PLACE',
+  Year int(4) JPATH='$.DATEPUB'
 )
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='biblio.json';
 SELECT * FROM t1;
@@ -76,16 +76,16 @@ DROP TABLE t1;
 CREATE TABLE t1
 (
   ISBN CHAR(15),
-  Language CHAR(2) FIELD_FORMAT='$.LANG',
-  Subject CHAR(32) FIELD_FORMAT='$.SUBJECT',
-  AuthorFN CHAR(128) FIELD_FORMAT='$.AUTHOR[*].FIRSTNAME',
-  AuthorLN CHAR(128) FIELD_FORMAT='$.AUTHOR[*].LASTNAME',
-  Title CHAR(32) FIELD_FORMAT='$.TITLE',
-  Translation CHAR(32) FIELD_FORMAT='$.TRANSLATION',
-  Translator CHAR(80) FIELD_FORMAT='$.TRANSLATOR',
-  Publisher CHAR(20) FIELD_FORMAT='$.PUBLISHER.NAME',
-  Location CHAR(16) FIELD_FORMAT='$.PUBLISHER.PLACE',
-  Year int(4) FIELD_FORMAT='$.DATEPUB'
+  Language CHAR(2) JPATH='$.LANG',
+  Subject CHAR(32) JPATH='$.SUBJECT',
+  AuthorFN CHAR(128) JPATH='$.AUTHOR[*].FIRSTNAME',
+  AuthorLN CHAR(128) JPATH='$.AUTHOR[*].LASTNAME',
+  Title CHAR(32) JPATH='$.TITLE',
+  Translation CHAR(32) JPATH='$.TRANSLATION',
+  Translator CHAR(80) JPATH='$.TRANSLATOR',
+  Publisher CHAR(20) JPATH='$.PUBLISHER.NAME',
+  Location CHAR(16) JPATH='$.PUBLISHER.PLACE',
+  Year int(4) JPATH='$.DATEPUB'
 )
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='biblio.json';
 SELECT * FROM t1;
@@ -122,17 +122,17 @@ DROP TABLE t1;
 CREATE TABLE t1
 (
   ISBN CHAR(15) NOT NULL,
-  Language CHAR(2) FIELD_FORMAT='$.LANG',
-  Subject CHAR(32) FIELD_FORMAT='$.SUBJECT',
-  AuthorFN CHAR(128) FIELD_FORMAT='$.AUTHOR[*].FIRSTNAME',
-  AuthorLN CHAR(128) FIELD_FORMAT='$.AUTHOR[*].LASTNAME',
-  Title CHAR(32) FIELD_FORMAT='$.TITLE',
-  Translation CHAR(32) FIELD_FORMAT='$.TRANSLATED.PREFIX',
-  TranslatorFN CHAR(80) FIELD_FORMAT='$.TRANSLATED.TRANSLATOR.FIRSTNAME',
-  TranslatorLN CHAR(80) FIELD_FORMAT='$.TRANSLATED.TRANSLATOR.LASTNAME',
-  Publisher CHAR(20) FIELD_FORMAT='$.PUBLISHER.NAME',
-  Location CHAR(16) FIELD_FORMAT='$.PUBLISHER.PLACE',
-  Year int(4) FIELD_FORMAT='$.DATEPUB',
+  Language CHAR(2) JPATH='$.LANG',
+  Subject CHAR(32) JPATH='$.SUBJECT',
+  AuthorFN CHAR(128) JPATH='$.AUTHOR[*].FIRSTNAME',
+  AuthorLN CHAR(128) JPATH='$.AUTHOR[*].LASTNAME',
+  Title CHAR(32) JPATH='$.TITLE',
+  Translation CHAR(32) JPATH='$.TRANSLATED.PREFIX',
+  TranslatorFN CHAR(80) JPATH='$.TRANSLATED.TRANSLATOR.FIRSTNAME',
+  TranslatorLN CHAR(80) JPATH='$.TRANSLATED.TRANSLATOR.LASTNAME',
+  Publisher CHAR(20) JPATH='$.PUBLISHER.NAME',
+  Location CHAR(16) JPATH='$.PUBLISHER.PLACE',
+  Year int(4) JPATH='$.DATEPUB',
   INDEX IX(ISBN)
 )
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='bib0.json' LRECL=320 OPTION_LIST='Pretty=0';
@@ -148,9 +148,9 @@ DROP TABLE t1;
 --echo #
 CREATE TABLE t1 (
 WHO CHAR(12),
-WEEK INT(2) FIELD_FORMAT='$.WEEK[*].NUMBER',
-WHAT CHAR(32) FIELD_FORMAT='$.WEEK[].EXPENSE["+"].WHAT',
-AMOUNT DOUBLE(8,2) FIELD_FORMAT='$.WEEK[].EXPENSE[+].AMOUNT')
+WEEK INT(2) JPATH='$.WEEK[*].NUMBER',
+WHAT CHAR(32) JPATH='$.WEEK[].EXPENSE["+"].WHAT',
+AMOUNT DOUBLE(8,2) JPATH='$.WEEK[].EXPENSE[+].AMOUNT')
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='expense.json';
 SELECT * FROM t1;
 DROP TABLE t1;
@@ -160,9 +160,9 @@ DROP TABLE t1;
 --echo #
 CREATE TABLE t1 (
 WHO CHAR(12),
-WEEK INT(2) FIELD_FORMAT='$.WEEK[*].NUMBER',
-WHAT CHAR(32) FIELD_FORMAT='$.WEEK[*].EXPENSE[*].WHAT',
-AMOUNT DOUBLE(8,2) FIELD_FORMAT='$.WEEK[*].EXPENSE[*].AMOUNT')
+WEEK INT(2) JPATH='$.WEEK[*].NUMBER',
+WHAT CHAR(32) JPATH='$.WEEK[*].EXPENSE[*].WHAT',
+AMOUNT DOUBLE(8,2) JPATH='$.WEEK[*].EXPENSE[*].AMOUNT')
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='expense.json';
 #--error ER_GET_ERRMSG
 SELECT * FROM t1;
@@ -173,14 +173,14 @@ DROP TABLE t1;
 --echo #
 CREATE TABLE t1 (
 WHO CHAR(12) NOT NULL,
-WEEKS CHAR(12) NOT NULL FIELD_FORMAT='$.WEEK[", "].NUMBER',
-SUMS CHAR(64) NOT NULL FIELD_FORMAT='$.WEEK["+"].EXPENSE[+].AMOUNT',
-SUM DOUBLE(8,2) NOT NULL FIELD_FORMAT='$.WEEK[+].EXPENSE[+].AMOUNT',
-AVGS CHAR(64) NOT NULL FIELD_FORMAT='$.WEEK["+"].EXPENSE[!].AMOUNT',
-SUMAVG DOUBLE(8,2) NOT NULL FIELD_FORMAT='$.WEEK[+].EXPENSE[!].AMOUNT',
-AVGSUM DOUBLE(8,2) NOT NULL FIELD_FORMAT='$.WEEK[!].EXPENSE[+].AMOUNT',
-AVGAVG DOUBLE(8,2) NOT NULL FIELD_FORMAT='$.WEEK[!].EXPENSE[!].AMOUNT',
-AVERAGE DOUBLE(8,2) NOT NULL FIELD_FORMAT='$.WEEK[!].EXPENSE[*].AMOUNT')
+WEEKS CHAR(12) NOT NULL JPATH='$.WEEK[", "].NUMBER',
+SUMS CHAR(64) NOT NULL JPATH='$.WEEK["+"].EXPENSE[+].AMOUNT',
+SUM DOUBLE(8,2) NOT NULL JPATH='$.WEEK[+].EXPENSE[+].AMOUNT',
+AVGS CHAR(64) NOT NULL JPATH='$.WEEK["+"].EXPENSE[!].AMOUNT',
+SUMAVG DOUBLE(8,2) NOT NULL JPATH='$.WEEK[+].EXPENSE[!].AMOUNT',
+AVGSUM DOUBLE(8,2) NOT NULL JPATH='$.WEEK[!].EXPENSE[+].AMOUNT',
+AVGAVG DOUBLE(8,2) NOT NULL JPATH='$.WEEK[!].EXPENSE[!].AMOUNT',
+AVERAGE DOUBLE(8,2) NOT NULL JPATH='$.WEEK[!].EXPENSE[*].AMOUNT')
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='expense.json';
 SELECT * FROM t1;
 DROP TABLE t1;
@@ -190,25 +190,25 @@ DROP TABLE t1;
 --echo #
 CREATE TABLE t2 (
 WHO CHAR(12),
-WEEK INT(2) FIELD_FORMAT='$.WEEK[0].NUMBER',
-WHAT CHAR(32) FIELD_FORMAT='$.WEEK[0].EXPENSE[*].WHAT',
-AMOUNT DOUBLE(8,2) FIELD_FORMAT='$.WEEK[0].EXPENSE[*].AMOUNT')
+WEEK INT(2) JPATH='$.WEEK[0].NUMBER',
+WHAT CHAR(32) JPATH='$.WEEK[0].EXPENSE[*].WHAT',
+AMOUNT DOUBLE(8,2) JPATH='$.WEEK[0].EXPENSE[*].AMOUNT')
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='expense.json';
 SELECT * FROM t2;
 
 CREATE TABLE t3 (
 WHO CHAR(12),
-WEEK INT(2) FIELD_FORMAT='$.WEEK[1].NUMBER',
-WHAT CHAR(32) FIELD_FORMAT='$.WEEK[1].EXPENSE[*].WHAT',
-AMOUNT DOUBLE(8,2) FIELD_FORMAT='$.WEEK[1].EXPENSE[*].AMOUNT')
+WEEK INT(2) JPATH='$.WEEK[1].NUMBER',
+WHAT CHAR(32) JPATH='$.WEEK[1].EXPENSE[*].WHAT',
+AMOUNT DOUBLE(8,2) JPATH='$.WEEK[1].EXPENSE[*].AMOUNT')
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='expense.json';
 SELECT * FROM t3;
 
 CREATE TABLE t4 (
 WHO CHAR(12),
-WEEK INT(2) FIELD_FORMAT='$.WEEK[2].NUMBER',
-WHAT CHAR(32) FIELD_FORMAT='$.WEEK[2].EXPENSE[*].WHAT',
-AMOUNT DOUBLE(8,2) FIELD_FORMAT='$.WEEK[2].EXPENSE[*].AMOUNT')
+WEEK INT(2) JPATH='$.WEEK[2].NUMBER',
+WHAT CHAR(32) JPATH='$.WEEK[2].EXPENSE[*].WHAT',
+AMOUNT DOUBLE(8,2) JPATH='$.WEEK[2].EXPENSE[*].AMOUNT')
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='expense.json';
 SELECT * FROM t4;
 
@@ -230,24 +230,24 @@ DROP TABLE t1, t2, t3, t4;
 CREATE TABLE t2 (
 WHO CHAR(12),
 WEEK INT(2),
-WHAT CHAR(32) FIELD_FORMAT='$.EXPENSE[*].WHAT',
-AMOUNT DOUBLE(8,2) FIELD_FORMAT='$.EXPENSE.[*].AMOUNT')
+WHAT CHAR(32) JPATH='$.EXPENSE[*].WHAT',
+AMOUNT DOUBLE(8,2) JPATH='$.EXPENSE.[*].AMOUNT')
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='mulexp3.json';
 SELECT * FROM t2;
 
 CREATE TABLE t3 (
 WHO CHAR(12),
 WEEK INT(2),
-WHAT CHAR(32) FIELD_FORMAT='$.EXPENSE[*].WHAT',
-AMOUNT DOUBLE(8,2) FIELD_FORMAT='$.EXPENSE.[*].AMOUNT')
+WHAT CHAR(32) JPATH='$.EXPENSE[*].WHAT',
+AMOUNT DOUBLE(8,2) JPATH='$.EXPENSE.[*].AMOUNT')
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='mulexp4.json';
 SELECT * FROM t3;
 
 CREATE TABLE t4 (
 WHO CHAR(12),
 WEEK INT(2),
-WHAT CHAR(32) FIELD_FORMAT='$.EXPENSE[*].WHAT',
-AMOUNT DOUBLE(8,2) FIELD_FORMAT='$.EXPENSE.[*].AMOUNT')
+WHAT CHAR(32) JPATH='$.EXPENSE[*].WHAT',
+AMOUNT DOUBLE(8,2) JPATH='$.EXPENSE.[*].AMOUNT')
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='mulexp5.json';
 SELECT * FROM t4;
 
@@ -257,8 +257,8 @@ SELECT * FROM t4;
 CREATE TABLE t1 (
 WHO CHAR(12),
 WEEK INT(2),
-WHAT CHAR(32) FIELD_FORMAT='$.EXPENSE[*].WHAT',
-AMOUNT DOUBLE(8,2) FIELD_FORMAT='$.EXPENSE.[*].AMOUNT')
+WHAT CHAR(32) JPATH='$.EXPENSE[*].WHAT',
+AMOUNT DOUBLE(8,2) JPATH='$.EXPENSE.[*].AMOUNT')
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='mulexp*.json' MULTIPLE=1;
 SELECT * FROM t1 ORDER BY WHO, WEEK, WHAT, AMOUNT;
 DROP TABLE t1;
@@ -269,8 +269,8 @@ DROP TABLE t1;
 CREATE TABLE t1 (
 WHO CHAR(12),
 WEEK INT(2),
-WHAT CHAR(32) FIELD_FORMAT='$.EXPENSE[*].WHAT',
-AMOUNT DOUBLE(8,2) FIELD_FORMAT='$.EXPENSE.[*].AMOUNT')
+WHAT CHAR(32) JPATH='$.EXPENSE[*].WHAT',
+AMOUNT DOUBLE(8,2) JPATH='$.EXPENSE.[*].AMOUNT')
 ENGINE=CONNECT TABLE_TYPE=JSON FILE_NAME='mulexp%s.json';
 ALTER TABLE t1
 PARTITION BY LIST COLUMNS(WEEK) (
diff --git a/storage/connect/mysql-test/connect/t/mongo_test.inc b/storage/connect/mysql-test/connect/t/mongo_test.inc
index 357fa55240b..1c8bf07184f 100644
--- a/storage/connect/mysql-test/connect/t/mongo_test.inc
+++ b/storage/connect/mysql-test/connect/t/mongo_test.inc
@@ -3,7 +3,7 @@ set connect_enable_mongo=1;
 --echo #
 --echo # Test the MONGO table type
 --echo #
-eval CREATE TABLE t1 (Document varchar(1024) field_format='*')
+eval CREATE TABLE t1 (Document varchar(1024) JPATH='*')
 ENGINE=CONNECT TABLE_TYPE=$TYPE TABNAME=restaurants $CONN
 OPTION_LIST='Driver=$DRV,Version=$VERS' DATA_CHARSET=utf8;
 SELECT * from t1 limit 3;
@@ -13,7 +13,7 @@ DROP TABLE t1;
 --echo # Test catfunc
 --echo #
 eval CREATE TABLE t1 ENGINE=CONNECT TABLE_TYPE=$TYPE TABNAME=restaurants CATFUNC=columns
-OPTION_LIST='Level=1,Driver=$DRV,Version=$VERS' DATA_CHARSET=utf8 $CONN;
+OPTION_LIST='Depth=1,Driver=$DRV,Version=$VERS' DATA_CHARSET=utf8 $CONN;
 SELECT * from t1;
 DROP TABLE t1;
 
@@ -36,7 +36,7 @@ DROP TABLE t1;
 --echo # Test discovery
 --echo #
 eval CREATE TABLE t1 ENGINE=CONNECT TABLE_TYPE=$TYPE TABNAME=restaurants
-OPTION_LIST='Level=1,Driver=$DRV,Version=$VERS' $CONN DATA_CHARSET=utf8;
+OPTION_LIST='Depth=1,Driver=$DRV,Version=$VERS' $CONN DATA_CHARSET=utf8;
 SHOW CREATE TABLE t1;
 SELECT * FROM t1 LIMIT 5;
 DROP TABLE t1;
@@ -58,12 +58,12 @@ _id VARCHAR(24) NOT NULL,
 name VARCHAR(64) NOT NULL,
 cuisine CHAR(200) NOT NULL,
 borough CHAR(16) NOT NULL,
-street VARCHAR(65) FIELD_FORMAT='address.street',
-building CHAR(16) FIELD_FORMAT='address.building',
-zipcode CHAR(5) FIELD_FORMAT='address.zipcode',
-grade CHAR(1) FIELD_FORMAT='grades.0.grade',
-score INT(4) NOT NULL FIELD_FORMAT='grades.0.score',
-`date` DATE FIELD_FORMAT='grades.0.date',
+street VARCHAR(65) JPATH='address.street',
+building CHAR(16) JPATH='address.building',
+zipcode CHAR(5) JPATH='address.zipcode',
+grade CHAR(1) JPATH='grades.0.grade',
+score INT(4) NOT NULL JPATH='grades.0.score',
+`date` DATE JPATH='grades.0.date',
 restaurant_id VARCHAR(255) NOT NULL)
 ENGINE=CONNECT TABLE_TYPE=$TYPE TABNAME='restaurants' DATA_CHARSET=utf8
 OPTION_LIST='Driver=$DRV,Version=$VERS' $CONN;
@@ -156,8 +156,8 @@ DROP TABLE t1;
 eval CREATE TABLE t1 (
   _id char(5) NOT NULL,
   city char(16) NOT NULL,
-  loc_0 double(12,6) NOT NULL `FIELD_FORMAT`='loc.0',
-  loc_1 char(12) NOT NULL `FIELD_FORMAT`='loc.1',
+  loc_0 double(12,6) NOT NULL `JPATH`='loc.0',
+  loc_1 char(12) NOT NULL `JPATH`='loc.1',
   pop int(11) NOT NULL,
   state char(2) NOT NULL)
 ENGINE=CONNECT CONNECTION='mongodb://localhost:27017' TABLE_TYPE=$TYPE TABNAME='cities'
@@ -181,11 +181,11 @@ DROP TABLE t1;
 eval CREATE TABLE t1 (
   _id int(4) NOT NULL,
   item CHAR(8) NOT NULL,
-  prices_0 INT(6) FIELD_FORMAT='prices.0',
-  prices_1 INT(6) FIELD_FORMAT='prices.1',
-  prices_2 INT(6) FIELD_FORMAT='prices.2',
-  prices_3 INT(6) FIELD_FORMAT='prices.3',
-  prices_4 INT(6) FIELD_FORMAT='prices.4')
+  prices_0 INT(6) JPATH='prices.0',
+  prices_1 INT(6) JPATH='prices.1',
+  prices_2 INT(6) JPATH='prices.2',
+  prices_3 INT(6) JPATH='prices.3',
+  prices_4 INT(6) JPATH='prices.4')
 ENGINE=CONNECT TABLE_TYPE=$TYPE TABNAME='testcoll' DATA_CHARSET=utf8
 OPTION_LIST='Driver=$DRV,Version=$VERS' $CONN;
 INSERT INTO t1 VALUES
diff --git a/storage/connect/mysql-test/connect/t/odbc_oracle.test b/storage/connect/mysql-test/connect/t/odbc_oracle.test
index 9de742a2647..18d29f69f1a 100644
--- a/storage/connect/mysql-test/connect/t/odbc_oracle.test
+++ b/storage/connect/mysql-test/connect/t/odbc_oracle.test
@@ -78,42 +78,42 @@ SET NAMES utf8;
 
 --echo # All tables in all schemas (filtered with WHERE)
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 CATFUNC=Tables;
 SELECT * FROM t1 WHERE Table_Schema='MTR' ORDER BY Table_Schema, Table_Name;
 DROP TABLE t1;
 
 --echo # All tables in all schemas (filtered with WHERE)
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 CATFUNC=Tables TABNAME='%.%';
 SELECT * FROM t1 WHERE Table_Schema='MTR' ORDER BY Table_Schema, Table_Name;
 DROP TABLE t1;
 
 --echo # All tables "T1" in all schemas (filtered with WHERE)
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 CATFUNC=Tables TABNAME='%.T1';
 SELECT * FROM t1 WHERE Table_Schema='MTR' ORDER BY Table_Schema, Table_Name;
 DROP TABLE t1;
 
 --echo # All tables "T1" in all schemas (filtered with WHERE)
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 CATFUNC=Tables TABNAME='T1';
 SELECT * FROM t1 WHERE Table_Schema='MTR' ORDER BY Table_Schema, Table_Name;
 DROP TABLE t1;
 
 --echo # Table "T1" in the schema "MTR"
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 CATFUNC=Tables TABNAME='MTR.T1';
 SELECT * FROM t1 ORDER BY Table_Schema, Table_Name;
 DROP TABLE t1;
 
 --echo # All tables in the schema "MTR"
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 CATFUNC=Tables TABNAME='MTR.%';
 SELECT * FROM t1 ORDER BY Table_Schema, Table_Name;
 DROP TABLE t1;
@@ -127,7 +127,7 @@ DROP TABLE t1;
 
 --echo # All columns in all schemas (limited with WHERE)
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 CATFUNC=Columns;
 # Disable warnings to avoid "Result limited to 20000 lines"
 --disable_warnings
@@ -137,7 +137,7 @@ DROP TABLE t1;
 
 --echo # All columns in all schemas (limited with WHERE)
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 CATFUNC=Columns TABNAME='%.%';
 # Disable warnings to avoid "Result limited to 20000 lines"
 --disable_warnings
@@ -146,20 +146,20 @@ SELECT * FROM t1 WHERE Table_Schema='MTR' ORDER BY Table_Schema, Table_Name;
 DROP TABLE t1;
 
 --echo # All tables "T1" in all schemas (limited with WHERE)
-CREATE TABLE t1 ENGINE=CONNECT TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr' CATFUNC=Columns TABNAME='%.T1';
+CREATE TABLE t1 ENGINE=CONNECT TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr' CATFUNC=Columns TABNAME='%.T1';
 SELECT * FROM t1 WHERE Table_Schema='MTR' ORDER BY Table_Schema, Table_Name;
 DROP TABLE t1;
 
 --echo # Table "T1" in the schema "MTR"
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 CATFUNC=Columns TABNAME='MTR.T1';
 SELECT * FROM t1 ORDER BY Table_Schema, Table_Name;
 DROP TABLE t1;
 
 --echo # All tables "T1" in all schemas (filtered with WHERE)
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 CATFUNC=Columns TABNAME='%.T1';
 SELECT * FROM t1 WHERE Table_Schema='MTR' ORDER BY Table_Schema, Table_Name;
 DROP TABLE t1;
@@ -172,7 +172,7 @@ DROP TABLE t1;
 
 --echo # Table "T1" in the default schema ("MTR")
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 TABNAME='T1';
 SHOW CREATE TABLE t1;
 SELECT * FROM t1 ORDER BY A;
@@ -189,7 +189,7 @@ DROP TABLE t1;
 
 --echo # Table "T1" in the schema "MTR"
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 TABNAME='MTR.T1';
 SHOW CREATE TABLE t1;
 SELECT * FROM t1;
@@ -197,7 +197,7 @@ DROP TABLE t1;
 
 --echo # View "V1" in the schema "MTR"
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 TABNAME='MTR.V1';
 SHOW CREATE TABLE t1;
 SELECT * FROM t1;
@@ -214,7 +214,7 @@ DROP TABLE t1;
 
 --echo # Table "T2" in the schema "MTR"
 CREATE TABLE t1 ENGINE=CONNECT
-TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=mtr'
+TABLE_TYPE=ODBC CONNECTION='DSN=ConnectEngineOracle;UID=mtr;PWD=newmtr'
 TABNAME='MTR.T2';
 SHOW CREATE TABLE t1;
 SELECT * FROM t1;
diff --git a/storage/connect/mysql-test/connect/t/xml.test b/storage/connect/mysql-test/connect/t/xml.test
index 0fdf8e90b6e..669fa3f64dc 100644
--- a/storage/connect/mysql-test/connect/t/xml.test
+++ b/storage/connect/mysql-test/connect/t/xml.test
@@ -77,9 +77,9 @@ DROP TABLE t1;
 --echo # Testing mixed tag and attribute values
 --echo #
 CREATE TABLE t1 (
-  ISBN CHAR(15) FIELD_FORMAT='@',
-  LANG CHAR(2)  FIELD_FORMAT='@',
-  SUBJECT CHAR(32) FIELD_FORMAT='@',
+  ISBN CHAR(15) XPATH='@',
+  LANG CHAR(2)  XPATH='@',
+  SUBJECT CHAR(32) XPATH='@',
   AUTHOR CHAR(50),
   TITLE CHAR(32),
   TRANSLATOR CHAR(40),
@@ -98,9 +98,9 @@ DROP TABLE t1;
 --copy_file $MTR_SUITE_DIR/std_data/xsample.xml $MYSQLD_DATADIR/test/xsample2.xml
 --chmod 0644 $MYSQLD_DATADIR/test/xsample2.xml
 CREATE TABLE t1 (
-  ISBN CHAR(15) FIELD_FORMAT='@',
-  LANG CHAR(2)  FIELD_FORMAT='@',
-  SUBJECT CHAR(32) FIELD_FORMAT='@',
+  ISBN CHAR(15) XPATH='@',
+  LANG CHAR(2)  XPATH='@',
+  SUBJECT CHAR(32) XPATH='@',
   AUTHOR CHAR(50),
   TITLE CHAR(32),
   TRANSLATOR CHAR(40),
@@ -123,18 +123,18 @@ DROP TABLE t1;
 --echo # Testing XPath
 --echo #
 CREATE TABLE t1 (
-  isbn       CHAR(15) FIELD_FORMAT='@ISBN',
-  language   CHAR(2)  FIELD_FORMAT='@LANG',
-  subject    CHAR(32) FIELD_FORMAT='@SUBJECT',
-  authorfn   CHAR(20) FIELD_FORMAT='AUTHOR/FIRSTNAME',
-  authorln   CHAR(20) FIELD_FORMAT='AUTHOR/LASTNAME',
-  title      CHAR(32) FIELD_FORMAT='TITLE',
-  translated CHAR(32) FIELD_FORMAT='TRANSLATOR/@PREFIX',
-  tranfn     CHAR(20) FIELD_FORMAT='TRANSLATOR/FIRSTNAME',
-  tranln     CHAR(20) FIELD_FORMAT='TRANSLATOR/LASTNAME',
-  publisher  CHAR(20) FIELD_FORMAT='PUBLISHER/NAME',
-  location   CHAR(20) FIELD_FORMAT='PUBLISHER/PLACE',
-  year       INT(4)   FIELD_FORMAT='DATEPUB'
+  isbn       CHAR(15) XPATH='@ISBN',
+  language   CHAR(2)  XPATH='@LANG',
+  subject    CHAR(32) XPATH='@SUBJECT',
+  authorfn   CHAR(20) XPATH='AUTHOR/FIRSTNAME',
+  authorln   CHAR(20) XPATH='AUTHOR/LASTNAME',
+  title      CHAR(32) XPATH='TITLE',
+  translated CHAR(32) XPATH='TRANSLATOR/@PREFIX',
+  tranfn     CHAR(20) XPATH='TRANSLATOR/FIRSTNAME',
+  tranln     CHAR(20) XPATH='TRANSLATOR/LASTNAME',
+  publisher  CHAR(20) XPATH='PUBLISHER/NAME',
+  location   CHAR(20) XPATH='PUBLISHER/PLACE',
+  year       INT(4)   XPATH='DATEPUB'
 ) ENGINE=CONNECT TABLE_TYPE=XML FILE_NAME='xsample.xml'
   TABNAME='BIBLIO' OPTION_LIST='rownode=BOOK,skipnull=1,xmlsup=domdoc';
 SELECT * FROM t1;
@@ -150,8 +150,8 @@ DROP TABLE t1;
 #--echo # Relative paths are not supported
 #--echo #
 #CREATE TABLE t1 (
-#  authorfn   CHAR(20) FIELD_FORMAT='//FIRSTNAME',
-#  authorln   CHAR(20) FIELD_FORMAT='//LASTNAME'
+#  authorfn   CHAR(20) XPATH='//FIRSTNAME',
+#  authorln   CHAR(20) XPATH='//LASTNAME'
 #) ENGINE=CONNECT TABLE_TYPE=XML FILE_NAME='xsample.xml'
 #  TABNAME='BIBLIO' OPTION_LIST='rownode=BOOK,skipnull=1';
 #SELECT * FROM t1;
@@ -165,8 +165,8 @@ DROP TABLE t1;
 #--echo # Absolute path is not supported
 #--echo #
 #CREATE TABLE t1 (
-#  authorfn   CHAR(20) FIELD_FORMAT='/BIBLIO/BOOK/AUTHOR/FIRSTNAME',
-#  authorln   CHAR(20) FIELD_FORMAT='/BIBLIO/BOOK/AUTHOR/LASTNAME'
+#  authorfn   CHAR(20) XPATH='/BIBLIO/BOOK/AUTHOR/FIRSTNAME',
+#  authorln   CHAR(20) XPATH='/BIBLIO/BOOK/AUTHOR/LASTNAME'
 #) ENGINE=CONNECT TABLE_TYPE=XML FILE_NAME='xsample.xml'
 #  TABNAME='BIBLIO' OPTION_LIST='rownode=BOOK,skipnull=1';
 #SELECT * FROM t1;
@@ -178,7 +178,7 @@ DROP TABLE t1;
 --echo #
 CREATE TABLE t1
 (
-  isbn       CHAR(15) FIELD_FORMAT='@isbn'
+  isbn       CHAR(15) XPATH='@isbn'
 ) ENGINE=CONNECT TABLE_TYPE=XML FILE_NAME='xsample.xml'
   TABNAME='BIBLIO' OPTION_LIST='rownode=BOOK,skipnull=1,xmlsup=domdoc';
 SELECT * FROM t1;
diff --git a/storage/connect/mysql-test/connect/t/xml2.test b/storage/connect/mysql-test/connect/t/xml2.test
index 7bbc3dbd87c..9c5f685d399 100644
--- a/storage/connect/mysql-test/connect/t/xml2.test
+++ b/storage/connect/mysql-test/connect/t/xml2.test
@@ -77,9 +77,9 @@ DROP TABLE t1;
 --echo # Testing mixed tag and attribute values
 --echo #
 CREATE TABLE t1 (
-  ISBN CHAR(15) FIELD_FORMAT='@',
-  LANG CHAR(2)  FIELD_FORMAT='@',
-  SUBJECT CHAR(32) FIELD_FORMAT='@',
+  ISBN CHAR(15) XPATH='@',
+  LANG CHAR(2)  XPATH='@',
+  SUBJECT CHAR(32) XPATH='@',
   AUTHOR CHAR(50),
   TITLE CHAR(32),
   TRANSLATOR CHAR(40),
@@ -98,9 +98,9 @@ DROP TABLE t1;
 --copy_file $MTR_SUITE_DIR/std_data/xsample.xml $MYSQLD_DATADIR/test/xsample2.xml
 --chmod 0644 $MYSQLD_DATADIR/test/xsample2.xml
 CREATE TABLE t1 (
-  ISBN CHAR(15) FIELD_FORMAT='@',
-  LANG CHAR(2)  FIELD_FORMAT='@',
-  SUBJECT CHAR(32) FIELD_FORMAT='@',
+  ISBN CHAR(15) XPATH='@',
+  LANG CHAR(2)  XPATH='@',
+  SUBJECT CHAR(32) XPATH='@',
   AUTHOR CHAR(50),
   TITLE CHAR(32),
   TRANSLATOR CHAR(40),
@@ -123,18 +123,18 @@ DROP TABLE t1;
 --echo # Testing XPath
 --echo #
 CREATE TABLE t1 (
-  isbn       CHAR(15) FIELD_FORMAT='@ISBN',
-  language   CHAR(2)  FIELD_FORMAT='@LANG',
-  subject    CHAR(32) FIELD_FORMAT='@SUBJECT',
-  authorfn   CHAR(20) FIELD_FORMAT='AUTHOR/FIRSTNAME',
-  authorln   CHAR(20) FIELD_FORMAT='AUTHOR/LASTNAME',
-  title      CHAR(32) FIELD_FORMAT='TITLE',
-  translated CHAR(32) FIELD_FORMAT='TRANSLATOR/@PREFIX',
-  tranfn     CHAR(20) FIELD_FORMAT='TRANSLATOR/FIRSTNAME',
-  tranln     CHAR(20) FIELD_FORMAT='TRANSLATOR/LASTNAME',
-  publisher  CHAR(20) FIELD_FORMAT='PUBLISHER/NAME',
-  location   CHAR(20) FIELD_FORMAT='PUBLISHER/PLACE',
-  year       INT(4)   FIELD_FORMAT='DATEPUB'
+  isbn       CHAR(15) XPATH='@ISBN',
+  language   CHAR(2)  XPATH='@LANG',
+  subject    CHAR(32) XPATH='@SUBJECT',
+  authorfn   CHAR(20) XPATH='AUTHOR/FIRSTNAME',
+  authorln   CHAR(20) XPATH='AUTHOR/LASTNAME',
+  title      CHAR(32) XPATH='TITLE',
+  translated CHAR(32) XPATH='TRANSLATOR/@PREFIX',
+  tranfn     CHAR(20) XPATH='TRANSLATOR/FIRSTNAME',
+  tranln     CHAR(20) XPATH='TRANSLATOR/LASTNAME',
+  publisher  CHAR(20) XPATH='PUBLISHER/NAME',
+  location   CHAR(20) XPATH='PUBLISHER/PLACE',
+  year       INT(4)   XPATH='DATEPUB'
 ) ENGINE=CONNECT TABLE_TYPE=XML FILE_NAME='xsample.xml'
   TABNAME='BIBLIO' OPTION_LIST='rownode=BOOK,skipnull=1,xmlsup=libxml2';
 SELECT * FROM t1;
@@ -150,8 +150,8 @@ DROP TABLE t1;
 #--echo # Relative paths are not supported
 #--echo #
 #CREATE TABLE t1 (
-#  authorfn   CHAR(20) FIELD_FORMAT='//FIRSTNAME',
-#  authorln   CHAR(20) FIELD_FORMAT='//LASTNAME'
+#  authorfn   CHAR(20) XPATH='//FIRSTNAME',
+#  authorln   CHAR(20) XPATH='//LASTNAME'
 #) ENGINE=CONNECT TABLE_TYPE=XML FILE_NAME='xsample.xml'
 #  TABNAME='BIBLIO' OPTION_LIST='rownode=BOOK,skipnull=1';
 #SELECT * FROM t1;
@@ -165,8 +165,8 @@ DROP TABLE t1;
 #--echo # Absolute path is not supported
 #--echo #
 #CREATE TABLE t1 (
-#  authorfn   CHAR(20) FIELD_FORMAT='/BIBLIO/BOOK/AUTHOR/FIRSTNAME',
-#  authorln   CHAR(20) FIELD_FORMAT='/BIBLIO/BOOK/AUTHOR/LASTNAME'
+#  authorfn   CHAR(20) XPATH='/BIBLIO/BOOK/AUTHOR/FIRSTNAME',
+#  authorln   CHAR(20) XPATH='/BIBLIO/BOOK/AUTHOR/LASTNAME'
 #) ENGINE=CONNECT TABLE_TYPE=XML FILE_NAME='xsample.xml'
 #  TABNAME='BIBLIO' OPTION_LIST='rownode=BOOK,skipnull=1';
 #SELECT * FROM t1;
@@ -178,7 +178,7 @@ DROP TABLE t1;
 --echo #
 CREATE TABLE t1
 (
-  isbn       CHAR(15) FIELD_FORMAT='@isbn'
+  isbn       CHAR(15) XPATH='@isbn'
 ) ENGINE=CONNECT TABLE_TYPE=XML FILE_NAME='xsample.xml'
   TABNAME='BIBLIO' OPTION_LIST='rownode=BOOK,skipnull=1,xmlsup=libxml2';
 SELECT * FROM t1;
diff --git a/storage/connect/mysql-test/connect/t/xml2_html.test b/storage/connect/mysql-test/connect/t/xml2_html.test
index 1c84b46ec38..2f4fc50e5e6 100644
--- a/storage/connect/mysql-test/connect/t/xml2_html.test
+++ b/storage/connect/mysql-test/connect/t/xml2_html.test
@@ -11,9 +11,9 @@ SET NAMES utf8;
 --echo # Testing HTML like XML file
 --echo #
 CREATE TABLE beers (
-`Name` CHAR(16) FIELD_FORMAT='brandName',
-`Origin` CHAR(16) FIELD_FORMAT='origin',
-`Description` CHAR(32) FIELD_FORMAT='details')
+`Name` CHAR(16) XPATH='brandName',
+`Origin` CHAR(16) XPATH='origin',
+`Description` CHAR(32) XPATH='details')
 ENGINE=CONNECT TABLE_TYPE=XML FILE_NAME='beers.xml'
 TABNAME='table' OPTION_LIST='xmlsup=libxml2,rownode=tr,colnode=td';
 SELECT * FROM beers;
diff --git a/storage/connect/mysql-test/connect/t/xml2_mult.test b/storage/connect/mysql-test/connect/t/xml2_mult.test
index cd83827fe34..e9914c71aad 100644
--- a/storage/connect/mysql-test/connect/t/xml2_mult.test
+++ b/storage/connect/mysql-test/connect/t/xml2_mult.test
@@ -15,9 +15,9 @@ SET NAMES utf8;
 --echo # Testing expanded values
 --echo #
 CREATE TABLE `bookstore` (
-  `category` CHAR(16) NOT NULL FIELD_FORMAT='@',
+  `category` CHAR(16) NOT NULL XPATH='@',
   `title` VARCHAR(50) NOT NULL,
-  `lang` char(2) NOT NULL FIELD_FORMAT='title/@',
+  `lang` char(2) NOT NULL XPATH='title/@',
   `author` VARCHAR(24) NOT NULL,
   `year` INT(4) NOT NULL,
   `price` DOUBLE(8,2) NOT NULL)
diff --git a/storage/connect/mysql-test/connect/t/xml2_zip.test b/storage/connect/mysql-test/connect/t/xml2_zip.test
index d8c7894f861..46697dc97f7 100644
--- a/storage/connect/mysql-test/connect/t/xml2_zip.test
+++ b/storage/connect/mysql-test/connect/t/xml2_zip.test
@@ -11,17 +11,17 @@ let $MYSQLD_DATADIR= `select @@datadir`;
 --echo # Testing zipped XML tables
 --echo #
 CREATE TABLE t1 (
-ISBN CHAR(13) NOT NULL FIELD_FORMAT='@',
-LANG CHAR(2) NOT NULL FIELD_FORMAT='@',
-SUBJECT CHAR(12) NOT NULL FIELD_FORMAT='@',
-AUTHOR_FIRSTNAME CHAR(15) NOT NULL FIELD_FORMAT='AUTHOR/FIRSTNAME',
-AUTHOR_LASTNAME CHAR(8) NOT NULL FIELD_FORMAT='AUTHOR/LASTNAME',
-TRANSLATOR_PREFIX CHAR(24) DEFAULT NULL FIELD_FORMAT='TRANSLATOR/@PREFIX',
-TRANSLATOR_FIRSTNAME CHAR(6) DEFAULT NULL FIELD_FORMAT='TRANSLATOR/FIRSTNAME',
-TRANSLATOR_LASTNAME CHAR(6) DEFAULT NULL FIELD_FORMAT='TRANSLATOR/LASTNAME',
+ISBN CHAR(13) NOT NULL XPATH='@',
+LANG CHAR(2) NOT NULL XPATH='@',
+SUBJECT CHAR(12) NOT NULL XPATH='@',
+AUTHOR_FIRSTNAME CHAR(15) NOT NULL XPATH='AUTHOR/FIRSTNAME',
+AUTHOR_LASTNAME CHAR(8) NOT NULL XPATH='AUTHOR/LASTNAME',
+TRANSLATOR_PREFIX CHAR(24) DEFAULT NULL XPATH='TRANSLATOR/@PREFIX',
+TRANSLATOR_FIRSTNAME CHAR(6) DEFAULT NULL XPATH='TRANSLATOR/FIRSTNAME',
+TRANSLATOR_LASTNAME CHAR(6) DEFAULT NULL XPATH='TRANSLATOR/LASTNAME',
 TITLE CHAR(30) NOT NULL,
-PUBLISHER_NAME CHAR(15) NOT NULL FIELD_FORMAT='PUBLISHER/NAME',
-PUBLISHER_PLACE CHAR(5) NOT NULL FIELD_FORMAT='PUBLISHER/PLACE',
+PUBLISHER_NAME CHAR(15) NOT NULL XPATH='PUBLISHER/NAME',
+PUBLISHER_PLACE CHAR(5) NOT NULL XPATH='PUBLISHER/PLACE',
 DATEPUB CHAR(4) NOT NULL
 ) ENGINE=CONNECT TABLE_TYPE=XML FILE_NAME='xsample2.zip' ZIPPED=YES
 OPTION_LIST='entry=xsample2.xml,load=xsample2.xml,rownode=BOOK,xmlsup=libxml2,expand=1,mulnode=AUTHOR';
diff --git a/storage/connect/mysql-test/connect/t/xml_html.test b/storage/connect/mysql-test/connect/t/xml_html.test
index 34d29953f68..1430f68d2b2 100644
--- a/storage/connect/mysql-test/connect/t/xml_html.test
+++ b/storage/connect/mysql-test/connect/t/xml_html.test
@@ -11,9 +11,9 @@ SET NAMES utf8;
 --echo # Testing HTML like XML file
 --echo #
 CREATE TABLE beers (
-`Name` CHAR(16) FIELD_FORMAT='brandName',
-`Origin` CHAR(16) FIELD_FORMAT='origin',
-`Description` CHAR(32) FIELD_FORMAT='details')
+`Name` CHAR(16) XPATH='brandName',
+`Origin` CHAR(16) XPATH='origin',
+`Description` CHAR(32) XPATH='details')
 ENGINE=CONNECT TABLE_TYPE=XML FILE_NAME='beers.xml'
 TABNAME='table' OPTION_LIST='xmlsup=domdoc,rownode=tr,colnode=td';
 SELECT * FROM beers;
diff --git a/storage/connect/mysql-test/connect/t/xml_mult.test b/storage/connect/mysql-test/connect/t/xml_mult.test
index cf703e90da4..221d6734546 100644
--- a/storage/connect/mysql-test/connect/t/xml_mult.test
+++ b/storage/connect/mysql-test/connect/t/xml_mult.test
@@ -15,9 +15,9 @@ SET NAMES utf8;
 --echo # Testing expanded values
 --echo #
 CREATE TABLE `bookstore` (
-  `category` CHAR(16) NOT NULL FIELD_FORMAT='@',
+  `category` CHAR(16) NOT NULL XPATH='@',
   `title` VARCHAR(50) NOT NULL,
-  `lang` char(2) NOT NULL FIELD_FORMAT='title/@',
+  `lang` char(2) NOT NULL XPATH='title/@',
   `author` VARCHAR(24) NOT NULL,
   `year` INT(4) NOT NULL,
   `price` DOUBLE(8,2) NOT NULL)
diff --git a/storage/connect/mysql-test/connect/t/xml_zip.test b/storage/connect/mysql-test/connect/t/xml_zip.test
index ad31ca46d4c..774021485f9 100644
--- a/storage/connect/mysql-test/connect/t/xml_zip.test
+++ b/storage/connect/mysql-test/connect/t/xml_zip.test
@@ -11,17 +11,17 @@ let $MYSQLD_DATADIR= `select @@datadir`;
 --echo # Testing zipped XML tables
 --echo #
 CREATE TABLE t1 (
-ISBN CHAR(13) NOT NULL FIELD_FORMAT='@',
-LANG CHAR(2) NOT NULL FIELD_FORMAT='@',
-SUBJECT CHAR(12) NOT NULL FIELD_FORMAT='@',
-AUTHOR_FIRSTNAME CHAR(15) NOT NULL FIELD_FORMAT='AUTHOR/FIRSTNAME',
-AUTHOR_LASTNAME CHAR(8) NOT NULL FIELD_FORMAT='AUTHOR/LASTNAME',
-TRANSLATOR_PREFIX CHAR(24) DEFAULT NULL FIELD_FORMAT='TRANSLATOR/@PREFIX',
-TRANSLATOR_FIRSTNAME CHAR(6) DEFAULT NULL FIELD_FORMAT='TRANSLATOR/FIRSTNAME',
-TRANSLATOR_LASTNAME CHAR(6) DEFAULT NULL FIELD_FORMAT='TRANSLATOR/LASTNAME',
+ISBN CHAR(13) NOT NULL XPATH='@',
+LANG CHAR(2) NOT NULL XPATH='@',
+SUBJECT CHAR(12) NOT NULL XPATH='@',
+AUTHOR_FIRSTNAME CHAR(15) NOT NULL XPATH='AUTHOR/FIRSTNAME',
+AUTHOR_LASTNAME CHAR(8) NOT NULL XPATH='AUTHOR/LASTNAME',
+TRANSLATOR_PREFIX CHAR(24) DEFAULT NULL XPATH='TRANSLATOR/@PREFIX',
+TRANSLATOR_FIRSTNAME CHAR(6) DEFAULT NULL XPATH='TRANSLATOR/FIRSTNAME',
+TRANSLATOR_LASTNAME CHAR(6) DEFAULT NULL XPATH='TRANSLATOR/LASTNAME',
 TITLE CHAR(30) NOT NULL,
-PUBLISHER_NAME CHAR(15) NOT NULL FIELD_FORMAT='PUBLISHER/NAME',
-PUBLISHER_PLACE CHAR(5) NOT NULL FIELD_FORMAT='PUBLISHER/PLACE',
+PUBLISHER_NAME CHAR(15) NOT NULL XPATH='PUBLISHER/NAME',
+PUBLISHER_PLACE CHAR(5) NOT NULL XPATH='PUBLISHER/PLACE',
 DATEPUB CHAR(4) NOT NULL
 ) ENGINE=CONNECT TABLE_TYPE=XML FILE_NAME='xsample2.zip' ZIPPED=YES
 OPTION_LIST='entry=xsample2.xml,load=xsample2.xml,rownode=BOOK,xmlsup=domdoc,expand=1,mulnode=AUTHOR';
diff --git a/storage/connect/tabdos.cpp b/storage/connect/tabdos.cpp
index b3147bb7357..a2b5204cd0a 100644
--- a/storage/connect/tabdos.cpp
+++ b/storage/connect/tabdos.cpp
@@ -1998,7 +1998,7 @@ int TDBDOS::Cardinality(PGLOBAL g)
       if (Mode == MODE_ANY && ExactInfo()) {
         // Using index impossible or failed, do it the hard way
         Mode = MODE_READ;
-        To_Line = (char*)PlugSubAlloc(g, NULL, Lrecl + 1);
+        To_Line = (char*)PlugSubAlloc(g, NULL, (size_t)Lrecl + 1);
     
         if (Txfp->OpenTableFile(g))
           return (Cardinal = Txfp->Cardinality(g));
@@ -2232,7 +2232,7 @@ int TDBDOS::ReadDB(PGLOBAL g)
         return RC_EF;
       case -2:           // No match for join
         return RC_NF;
-      case -3:           // Same record as last non null one
+      case -3:           // Same record as non null last one
         num_there++;
         return RC_OK;
       default:
diff --git a/storage/connect/tabjson.cpp b/storage/connect/tabjson.cpp
index cdf9e40f97c..a79f2a37f32 100644
--- a/storage/connect/tabjson.cpp
+++ b/storage/connect/tabjson.cpp
@@ -1,6 +1,6 @@
 /************* tabjson C++ Program Source Code File (.CPP) *************/
-/* PROGRAM NAME: tabjson     Version 1.7                               */
-/*  (C) Copyright to the author Olivier BERTRAND          2014 - 2019  */
+/* PROGRAM NAME: tabjson     Version 1.8                               */
+/*  (C) Copyright to the author Olivier BERTRAND          2014 - 2020  */
 /*  This program are the JSON class DB execution routines.             */
 /***********************************************************************/
 
@@ -286,15 +286,17 @@ int JSONDISC::GetColumns(PGLOBAL g, PCSZ db, PCSZ dsn, PTOS topt)
 #endif
       } // endif Driver
 
-    } else
+    } else if (tdp->Pretty >= 0)
       tjnp = new(g) TDBJSN(tdp, new(g) DOSFAM(tdp));
+		else
+			tjnp = new(g) TDBJSN(tdp, new(g) BINFAM(tdp));
 
     tjnp->SetMode(MODE_READ);
 
     // Allocate the parse work memory
     PGLOBAL G = (PGLOBAL)PlugSubAlloc(g, NULL, sizeof(GLOBAL));
     memset(G, 0, sizeof(GLOBAL));
-    G->Sarea_Size = (size_t)tdp->Lrecl * 10;
+    G->Sarea_Size = (size_t)tdp->Lrecl * (tdp->Pretty >= 0 ? 10 : 2);
     G->Sarea = PlugSubAlloc(g, NULL, G->Sarea_Size);
     PlugSubSet(G->Sarea, G->Sarea_Size);
     G->jump_level = 0;
@@ -309,7 +311,7 @@ int JSONDISC::GetColumns(PGLOBAL g, PCSZ db, PCSZ dsn, PTOS topt)
     case RC_FX:
       goto err;
     default:
-      jsp = tjnp->GetRow();
+      jsp = tjnp->FindRow(g);
     } // endswitch ReadDB
 
   } // endif pretty
@@ -335,11 +337,11 @@ int JSONDISC::GetColumns(PGLOBAL g, PCSZ db, PCSZ dsn, PTOS topt)
   /*  Analyse the JSON tree and define columns.                        */
   /*********************************************************************/
   for (i = 1; ; i++) {
-    for (jpp = row->GetFirst(); jpp; jpp = jpp->GetNext()) {
-      strncpy(colname, jpp->GetKey(), 64);
+    for (jpp = row->GetFirst(); jpp; jpp = jpp->Next) {
+      strncpy(colname, jpp->Key, 64);
       fmt[bf] = 0;
 
-      if (Find(g, jpp->GetVal(), colname, MY_MIN(lvl, 0)))
+      if (Find(g, jpp->Val, colname, MY_MIN(lvl, 0)))
         goto err;
 
     } // endfor jpp
@@ -359,7 +361,7 @@ int JSONDISC::GetColumns(PGLOBAL g, PCSZ db, PCSZ dsn, PTOS topt)
       case RC_FX:
         goto err;
       default:
-        jsp = tjnp->GetRow();
+        jsp = tjnp->FindRow(g);
       } // endswitch ReadDB
 
     } else
@@ -390,14 +392,35 @@ bool JSONDISC::Find(PGLOBAL g, PJVAL jvp, PCSZ key, int j)
   PJOB   job;
   PJAR   jar;
 
-  if ((valp = jvp ? jvp->GetValue() : NULL)) {
+  if ((vlp = jvp ? jvp->GetVal() : NULL)) {
 		if (JsonAllPath() && !fmt[bf])
 			strcat(fmt, colname);
 
-		jcol.Type = valp->GetType();
-    jcol.Len = valp->GetValLen();
-    jcol.Scale = valp->GetValPrec();
-    jcol.Cbn = valp->IsNull();
+		jcol.Type = vlp->Type;
+
+		switch (vlp->Type) {
+		case TYPE_STRG:
+		case TYPE_DTM:
+			jcol.Len = (int)strlen(vlp->Strp);
+			break;
+		case TYPE_INTG:
+		case TYPE_BINT:
+			jcol.Len = (int)strlen(jvp->GetString(g));
+			break;
+		case TYPE_DBL:
+			jcol.Len = (int)strlen(jvp->GetString(g));
+			jcol.Scale = vlp->Nd;
+			break;
+		case TYPE_BOOL:
+			jcol.Len = 1;
+			break;
+		default:
+			jcol.Len = 0;
+			break;
+		} // endswitch Type
+
+    jcol.Scale = vlp->Nd;
+    jcol.Cbn = vlp->Type == TYPE_NULL;
   } else if (!jvp || jvp->IsNull()) {
     jcol.Type = TYPE_UNKNOWN;
     jcol.Len = jcol.Scale = 0;
@@ -413,8 +436,8 @@ bool JSONDISC::Find(PGLOBAL g, PJVAL jvp, PCSZ key, int j)
       case TYPE_JOB:
         job = (PJOB)jsp;
 
-        for (PJPR jrp = job->GetFirst(); jrp; jrp = jrp->GetNext()) {
-          PCSZ k = jrp->GetKey();
+        for (PJPR jrp = job->GetFirst(); jrp; jrp = jrp->Next) {
+          PCSZ k = jrp->Key;
 
           if (*k != '$') {
 						n = sizeof(fmt) - strlen(fmt) -1;
@@ -423,7 +446,7 @@ bool JSONDISC::Find(PGLOBAL g, PJVAL jvp, PCSZ key, int j)
 						strncat(strncat(colname, "_", n), k, n - 1);
           } // endif Key
 
-          if (Find(g, jrp->GetVal(), k, j + 1))
+          if (Find(g, jrp->Val, k, j + 1))
             return true;
 
           *p = *pc = 0;
@@ -625,9 +648,9 @@ PTDB JSONDEF::GetTable(PGLOBAL g, MODE m)
   PTXF    txfp = NULL;
 
   // JSN not used for pretty=1 for insert or delete
-  if (!Pretty || (Pretty == 1 && (m == MODE_READ || m == MODE_UPDATE))) {
+  if (Pretty <= 0 || (Pretty == 1 && (m == MODE_READ || m == MODE_UPDATE))) {
     USETEMP tmp = UseTemp();
-    bool    map = Mapped && m != MODE_INSERT &&
+    bool    map = Mapped && Pretty >= 0 && m != MODE_INSERT &&
                 !(tmp != TMP_NO && m == MODE_UPDATE) &&
                 !(tmp == TMP_FORCE &&
                 (m == MODE_UPDATE || m == MODE_DELETE));
@@ -684,17 +707,19 @@ PTDB JSONDEF::GetTable(PGLOBAL g, MODE m)
 #endif  // !GZ_SUPPORT
     } else if (map)
       txfp = new(g) MAPFAM(this);
-    else
+		else if (Pretty < 0)	 // BJsonfile
+			txfp = new(g) BINFAM(this);
+		else
       txfp = new(g) DOSFAM(this);
 
-    // Txfp must be set for TDBDOS
+    // Txfp must be set for TDBJSN
     tdbp = new(g) TDBJSN(this, txfp);
 
     if (Lrecl) {
       // Allocate the parse work memory
       PGLOBAL G = (PGLOBAL)PlugSubAlloc(g, NULL, sizeof(GLOBAL));
       memset(G, 0, sizeof(GLOBAL));
-      G->Sarea_Size = Lrecl * 10;
+      G->Sarea_Size = (size_t)Lrecl * 10;
       G->Sarea = PlugSubAlloc(g, NULL, G->Sarea_Size);
       PlugSubSet(G->Sarea, G->Sarea_Size);
       G->jump_level = 0;
@@ -736,10 +761,10 @@ PTDB JSONDEF::GetTable(PGLOBAL g, MODE m)
 /* --------------------------- Class TDBJSN -------------------------- */
 
 /***********************************************************************/
-/*  Implementation of the TDBJSN class.                                */
+/*  Implementation of the TDBJSN class (Pretty < 2)                    */
 /***********************************************************************/
 TDBJSN::TDBJSN(PJDEF tdp, PTXF txfp) : TDBDOS(tdp, txfp)
-  {
+{
 	G = NULL;
   Top = NULL;
   Row = NULL;
@@ -772,35 +797,35 @@ TDBJSN::TDBJSN(PJDEF tdp, PTXF txfp) : TDBDOS(tdp, txfp)
   SameRow = 0;
   Xval = -1;
   Comma = false;
-  } // end of TDBJSN standard constructor
+} // end of TDBJSN standard constructor
 
-TDBJSN::TDBJSN(TDBJSN *tdbp) : TDBDOS(NULL, tdbp)
-  {
-  G = NULL;
-  Top = tdbp->Top;
-  Row = tdbp->Row;
-  Val = tdbp->Val;
-  Colp = tdbp->Colp;
-  Jmode = tdbp->Jmode;
-  Objname = tdbp->Objname;
-  Xcol = tdbp->Xcol;
-  Fpos = tdbp->Fpos;
-  N = tdbp->N;
-  M = tdbp->M;
-  Limit = tdbp->Limit;
-  NextSame = tdbp->NextSame;
-  SameRow = tdbp->SameRow;
-  Xval = tdbp->Xval;
-  B = tdbp->B;
-  Sep = tdbp->Sep;
-  Pretty = tdbp->Pretty;
-  Strict = tdbp->Strict;
-  Comma = tdbp->Comma;
-  } // end of TDBJSN copy constructor
+TDBJSN::TDBJSN(TDBJSN* tdbp) : TDBDOS(NULL, tdbp)
+{
+	G = NULL;
+	Top = tdbp->Top;
+	Row = tdbp->Row;
+	Val = tdbp->Val;
+	Colp = tdbp->Colp;
+	Jmode = tdbp->Jmode;
+	Objname = tdbp->Objname;
+	Xcol = tdbp->Xcol;
+	Fpos = tdbp->Fpos;
+	N = tdbp->N;
+	M = tdbp->M;
+	Limit = tdbp->Limit;
+	NextSame = tdbp->NextSame;
+	SameRow = tdbp->SameRow;
+	Xval = tdbp->Xval;
+	B = tdbp->B;
+	Sep = tdbp->Sep;
+	Pretty = tdbp->Pretty;
+	Strict = tdbp->Strict;
+	Comma = tdbp->Comma;
+}  // end of TDBJSN copy constructor
 
 // Used for update
 PTDB TDBJSN::Clone(PTABS t)
-  {
+{
   G = NULL;
   PTDB    tp;
   PJCOL   cp1, cp2;
@@ -814,23 +839,23 @@ PTDB TDBJSN::Clone(PTABS t)
     } // endfor cp1
 
   return tp;
-  } // end of Clone
+} // end of Clone
 
 /***********************************************************************/
 /*  Allocate JSN column description block.                             */
 /***********************************************************************/
 PCOL TDBJSN::MakeCol(PGLOBAL g, PCOLDEF cdp, PCOL cprec, int n)
-  {
+{
   PJCOL colp = new(g) JSONCOL(g, cdp, this, cprec, n);
 
   return (colp->ParseJpath(g)) ? NULL : colp;
-  } // end of MakeCol
+} // end of MakeCol
 
 /***********************************************************************/
 /*  InsertSpecialColumn: Put a special column ahead of the column list.*/
 /***********************************************************************/
 PCOL TDBJSN::InsertSpecialColumn(PCOL colp)
-  {
+{
   if (!colp->IsSpecial())
     return NULL;
 
@@ -840,31 +865,47 @@ PCOL TDBJSN::InsertSpecialColumn(PCOL colp)
   colp->SetNext(Columns);
   Columns = colp;
   return colp;
-  } // end of InsertSpecialColumn
+} // end of InsertSpecialColumn
 
+#if 0
 /***********************************************************************/
 /*  JSON Cardinality: returns table size in number of rows.            */
 /***********************************************************************/
 int TDBJSN::Cardinality(PGLOBAL g)
-  {
+{
   if (!g)
     return 0;
-  else if (Cardinal < 0)
-    Cardinal = TDBDOS::Cardinality(g);
+	else if (Cardinal < 0) {
+		Cardinal = TDBDOS::Cardinality(g);
+
+	}	// endif Cardinal
 
   return Cardinal;
-  } // end of Cardinality
+} // end of Cardinality
 
 /***********************************************************************/
 /*  JSON GetMaxSize: returns file size estimate in number of lines.    */
 /***********************************************************************/
 int TDBJSN::GetMaxSize(PGLOBAL g)
-  {
-  if (MaxSize < 0)
-    MaxSize = TDBDOS::GetMaxSize(g) * ((Xcol) ? Limit : 1);
+{
+	if (MaxSize < 0)
+		MaxSize = TDBDOS::GetMaxSize(g) * ((Xcol) ? Limit : 1);
 
   return MaxSize;
-  } // end of GetMaxSize
+} // end of GetMaxSize
+#endif // 0
+
+/***********************************************************************/
+/*  JSON EstimatedLength. Returns an estimated minimum line length.    */
+/***********************************************************************/
+int TDBJSN::EstimatedLength(void)
+{
+	if (AvgLen <= 0)
+		return (Lrecl ? Lrecl : 1024) / 8;		// TODO: make it better
+	else
+		return AvgLen;
+
+} // end of Estimated Length
 
 /***********************************************************************/
 /*  Find the row in the tree structure.                                */
@@ -904,7 +945,7 @@ PJSON TDBJSN::FindRow(PGLOBAL g)
 /*  OpenDB: Data Base open routine for JSN access method.              */
 /***********************************************************************/
 bool TDBJSN::OpenDB(PGLOBAL g)
-  {
+{
   if (Use == USE_OPEN) {
     /*******************************************************************/
     /*  Table already open replace it at its beginning.                */
@@ -928,7 +969,45 @@ bool TDBJSN::OpenDB(PGLOBAL g)
 
   } // endif Use
 
-  if (TDBDOS::OpenDB(g))
+	if (Pretty < 0) {
+		/*******************************************************************/
+		/*  Binary BJSON table.                                            */
+		/*******************************************************************/
+		xtrc(1, "JSN OpenDB: tdbp=%p tdb=R%d use=%d mode=%d\n",
+						this, Tdb_No, Use, Mode);
+
+		if (Use == USE_OPEN) {
+			/*******************************************************************/
+			/*  Table already open, just replace it at its beginning.          */
+			/*******************************************************************/
+			if (!To_Kindex) {
+				Txfp->Rewind();       // see comment in Work.log
+			} else // Table is to be accessed through a sorted index table
+				To_Kindex->Reset();
+
+			return false;
+		} // endif use
+
+		/*********************************************************************/
+		/*  Open according to logical input/output mode required.            */
+		/*  Use conventionnal input/output functions.                        */
+		/*********************************************************************/
+		if (Txfp->OpenTableFile(g))
+			return true;
+
+		Use = USE_OPEN;       // Do it now in case we are recursively called
+
+		/*********************************************************************/
+		/*  Lrecl is Ok.                      															 */
+		/*********************************************************************/
+		size_t linelen = Lrecl;
+
+		//To_Line = (char*)PlugSubAlloc(g, NULL, linelen);
+		//memset(To_Line, 0, linelen);
+		To_Line = Txfp->GetBuf();
+		xtrc(1, "OpenJSN: R%hd mode=%d To_Line=%p\n", Tdb_No, Mode, To_Line);
+		return false;
+	} else if (TDBDOS::OpenDB(g))
     return true;
 
   if (Xcol)
@@ -943,7 +1022,7 @@ bool TDBJSN::OpenDB(PGLOBAL g)
 /*  Kindex construction if the file is accessed using an index.        */
 /***********************************************************************/
 bool TDBJSN::SkipHeader(PGLOBAL g)
-  {
+{
   int  len = GetFileLength(g);
   bool rc = false;
 
@@ -952,62 +1031,71 @@ bool TDBJSN::SkipHeader(PGLOBAL g)
     return true;
 #endif   // _DEBUG
 
-#if defined(__WIN__)
-#define  Ending  2
-#else   // !__WIN__
-#define  Ending  1
-#endif  // !__WIN__
-
   if (Pretty == 1) {
     if (Mode == MODE_INSERT || Mode == MODE_DELETE) {
       // Mode Insert and delete are no more handled here
-      assert(false);
-    } else if (len) // !Insert && !Delete
+      DBUG_ASSERT(false);
+    } else if (len > 0) // !Insert && !Delete
       rc = (Txfp->SkipRecord(g, false) == RC_FX || Txfp->RecordPos(g));
 
-    } // endif Pretty
+  } // endif Pretty
 
   return rc;
-  } // end of SkipHeader
+} // end of SkipHeader
 
 /***********************************************************************/
 /*  ReadDB: Data Base read routine for JSN access method.              */
 /***********************************************************************/
-int TDBJSN::ReadDB(PGLOBAL g)
-  {
-  int   rc;
-
-  N++;
+int TDBJSN::ReadDB(PGLOBAL g) {
+	int   rc;
+
+	N++;
+
+	if (NextSame) {
+		SameRow = NextSame;
+		NextSame = 0;
+		M++;
+		return RC_OK;
+	} else if ((rc = TDBDOS::ReadDB(g)) == RC_OK) {
+		if (!IsRead() && ((rc = ReadBuffer(g)) != RC_OK))
+			return rc;	// Deferred reading failed
+
+		if (Pretty >= 0) {
+			// Recover the memory used for parsing
+			PlugSubSet(G->Sarea, G->Sarea_Size);
+
+			if ((Row = ParseJson(G, To_Line, strlen(To_Line), &Pretty, &Comma))) {
+				Row = FindRow(g);
+				SameRow = 0;
+				Fpos++;
+				M = 1;
+				rc = RC_OK;
+			} else if (Pretty != 1 || strcmp(To_Line, "]")) {
+				strcpy(g->Message, G->Message);
+				rc = RC_FX;
+			} else
+				rc = RC_EF;
 
-  if (NextSame) {
-    SameRow = NextSame;
-    NextSame = 0;
-    M++;
-    return RC_OK;
-  } else if ((rc = TDBDOS::ReadDB(g)) == RC_OK) {
-    if (!IsRead() && ((rc = ReadBuffer(g)) != RC_OK))
-      // Deferred reading failed
-      return rc;
+		} else {
+			// Here we get a movable Json binary tree
+			PJSON jsp;
+			SWAP* swp;
 
-    // Recover the memory used for parsing
-    PlugSubSet(G->Sarea, G->Sarea_Size);
+			jsp = (PJSON)To_Line;
+			swp = new(g) SWAP(G, jsp);
+			swp->SwapJson(jsp, false);		// Restore pointers from offsets
+			Row = jsp;
+			Row = FindRow(g);
+			SameRow = 0;
+			Fpos++;
+			M = 1;
+			rc = RC_OK;
+		}	// endif Pretty
 
-    if ((Row = ParseJson(G, To_Line, strlen(To_Line), &Pretty, &Comma))) {
-      Row = FindRow(g);
-      SameRow = 0;
-      Fpos++;
-      M = 1;
-      rc = RC_OK;
-    } else if (Pretty != 1 || strcmp(To_Line, "]")) {
-      strcpy(g->Message, G->Message);
-      rc = RC_FX;
-    } else
-      rc = RC_EF;
+	} // endif ReadDB
 
-  } // endif ReadDB
-
-  return rc;
-  } // end of ReadDB
+	return rc;
+} // end of ReadDB
 
 /***********************************************************************/
 /*  Make the top tree from the object path.                            */
@@ -1081,8 +1169,8 @@ int TDBJSN::MakeTopTree(PGLOBAL g, PJSON jsp)
 /***********************************************************************/
 /*  PrepareWriting: Prepare the line for WriteDB.                      */
 /***********************************************************************/
-  bool TDBJSN::PrepareWriting(PGLOBAL g)
-  {
+bool TDBJSN::PrepareWriting(PGLOBAL g)
+{
   PSZ s;
 
   if (MakeTopTree(g, Row))
@@ -1103,7 +1191,7 @@ int TDBJSN::MakeTopTree(PGLOBAL g, PJSON jsp)
   } else
     return true;
 
-  } // end of PrepareWriting
+} // end of PrepareWriting
 
 /***********************************************************************/
 /*  WriteDB: Data Base write routine for JSON access method.           */
@@ -1125,7 +1213,7 @@ int TDBJSN::WriteDB(PGLOBAL g)
 JSONCOL::JSONCOL(PGLOBAL g, PCOLDEF cdp, PTDB tdbp, PCOL cprec, int i)
        : DOSCOL(g, cdp, tdbp, cprec, i, "DOS")
 {
-  Tjp = (TDBJSN *)(tdbp->GetOrig() ? tdbp->GetOrig() : tdbp);
+  Tjp = (TDBJSN *)(tdbp->GetOrig() ? tdbp->GetOrig() : tdbp);         
   G = Tjp->G;
   Jpath = cdp->GetFmt();
   MulVal = NULL;
@@ -1159,7 +1247,7 @@ JSONCOL::JSONCOL(JSONCOL *col1, PTDB tdbp) : DOSCOL(col1, tdbp)
 /*  SetBuffer: prepare a column block for write operation.             */
 /***********************************************************************/
 bool JSONCOL::SetBuffer(PGLOBAL g, PVAL value, bool ok, bool check)
-  {
+{
   if (DOSCOL::SetBuffer(g, value, ok, check))
     return true;
 
@@ -1170,13 +1258,13 @@ bool JSONCOL::SetBuffer(PGLOBAL g, PVAL value, bool ok, bool check)
   Tjp = (TDBJSN*)To_Tdb;
   G = Tjp->G;
   return false;
-  } // end of SetBuffer
+} // end of SetBuffer
 
 /***********************************************************************/
 /*  Check whether this object is expanded.                             */
 /***********************************************************************/
 bool JSONCOL::CheckExpand(PGLOBAL g, int i, PSZ nm, bool b)
-  {
+{
   if ((Tjp->Xcol && nm && !strcmp(nm, Tjp->Xcol) &&
       (Tjp->Xval < 0 || Tjp->Xval == i)) || Xpd) {
     Xpd = true;              // Expandable object
@@ -1187,7 +1275,7 @@ bool JSONCOL::CheckExpand(PGLOBAL g, int i, PSZ nm, bool b)
   } // endif Xcol
 
   return false;
-  } // end of CheckExpand
+} // end of CheckExpand
 
 /***********************************************************************/
 /*  Analyse array processing options.                                  */
@@ -1502,13 +1590,13 @@ PVAL JSONCOL::MakeJson(PGLOBAL g, PJSON jsp)
     Value->SetValue_psz(Serialize(g, jsp, NULL, 0));
 
   return Value;
-  } // end of MakeJson
+} // end of MakeJson
 
 /***********************************************************************/
 /*  SetValue: Set a value from a JVALUE contains.                      */
 /***********************************************************************/
 void JSONCOL::SetJsonValue(PGLOBAL g, PVAL vp, PJVAL val, int n)
-  {
+{
   if (val) {
     vp->SetNull(false);
 
@@ -1518,7 +1606,31 @@ void JSONCOL::SetJsonValue(PGLOBAL g, PVAL vp, PJVAL val, int n)
       case TYPE_BINT:
       case TYPE_DBL:
       case TYPE_DTM:
-        vp->SetValue_pval(val->GetValue());
+				switch (vp->GetType()) {
+				case TYPE_STRING:
+				case TYPE_DATE:
+					vp->SetValue_psz(val->GetString(g));
+					break;
+				case TYPE_INT:
+				case TYPE_SHORT:
+				case TYPE_TINY:
+					vp->SetValue(val->GetInteger());
+					break;
+				case TYPE_BIGINT:
+					vp->SetValue(val->GetBigint());
+					break;
+				case TYPE_DOUBLE:
+					vp->SetValue(val->GetFloat());
+
+					if (val->GetValType() == TYPE_DBL)
+						vp->SetPrec(val->Val->Nd);
+
+					break;
+				default:
+					sprintf(g->Message, "Unsupported column type %d\n", vp->GetType());
+					throw 888;
+				} // endswitch Type
+
         break;
       case TYPE_BOOL:
         if (vp->IsTypeNum())
@@ -1546,13 +1658,13 @@ void JSONCOL::SetJsonValue(PGLOBAL g, PVAL vp, PJVAL val, int n)
     vp->SetNull(true);
   } // endif val
 
-  } // end of SetJsonValue
+} // end of SetJsonValue
 
 /***********************************************************************/
 /*  ReadColumn:                                                        */
 /***********************************************************************/
 void JSONCOL::ReadColumn(PGLOBAL g)
-  {
+{
   if (!Tjp->SameRow || Xnod >= Tjp->SameRow)
     Value->SetValue_pval(GetColumnValue(g, Tjp->Row, 0));
 
@@ -1563,20 +1675,20 @@ void JSONCOL::ReadColumn(PGLOBAL g)
   if (!Nullable)
     Value->SetNull(false);
 
-  } // end of ReadColumn
+} // end of ReadColumn
 
 /***********************************************************************/
 /*  GetColumnValue:                                                    */
 /***********************************************************************/
 PVAL JSONCOL::GetColumnValue(PGLOBAL g, PJSON row, int i)
-  {
+{
   int   n = Nod - 1;
   PJAR  arp;
   PJVAL val = NULL;
 
   for (; i < Nod && row; i++) {
     if (Nodes[i].Op == OP_NUM) {
-      Value->SetValue(row->GetType() == TYPE_JAR ? row->size() : 1);
+      Value->SetValue(row->GetType() == TYPE_JAR ? ((PJAR)row)->size() : 1);
       return(Value);
     } else if (Nodes[i].Op == OP_XX) {
       return MakeJson(G, row);
@@ -1626,13 +1738,13 @@ PVAL JSONCOL::GetColumnValue(PGLOBAL g, PJSON row, int i)
 
   SetJsonValue(g, Value, val, n);
   return Value;
-  } // end of GetColumnValue
+} // end of GetColumnValue
 
 /***********************************************************************/
 /*  ExpandArray:                                                       */
 /***********************************************************************/
 PVAL JSONCOL::ExpandArray(PGLOBAL g, PJAR arp, int n)
-  {
+{
   int    ars = MY_MIN(Tjp->Limit, arp->size());
   PJVAL  jvp;
   JVALUE jval;
@@ -1650,7 +1762,7 @@ PVAL JSONCOL::ExpandArray(PGLOBAL g, PJAR arp, int n)
   } // endif jvp
 
   if (n < Nod - 1 && jvp->GetJson()) {
-    jval.SetValue(GetColumnValue(g, jvp->GetJson(), n + 1));
+    jval.SetValue(g, GetColumnValue(g, jvp->GetJson(), n + 1));
     jvp = &jval;
     } // endif n
 
@@ -1666,13 +1778,13 @@ PVAL JSONCOL::ExpandArray(PGLOBAL g, PJAR arp, int n)
 
   SetJsonValue(g, Value, jvp, n);
   return Value;
-  } // end of ExpandArray
+} // end of ExpandArray
 
 /***********************************************************************/
 /*  CalculateArray:                                                    */
 /***********************************************************************/
 PVAL JSONCOL::CalculateArray(PGLOBAL g, PJAR arp, int n)
-  {
+{
   int    i, ars, nv = 0, nextsame = Tjp->NextSame;
   bool   err;
   OPVAL  op = Nodes[n].Op;
@@ -1695,11 +1807,12 @@ PVAL JSONCOL::CalculateArray(PGLOBAL g, PJAR arp, int n)
 
     if (!jvrp->IsNull() || (op == OP_CNC && GetJsonNull())) do {
       if (jvrp->IsNull()) {
-        jvrp->Value = AllocateValue(g, GetJsonNull(), TYPE_STRING);
-        jvp = jvrp;
+				jvrp->Val = AllocVal(g, TYPE_STRG);
+				jvrp->Val->Strp = PlugDup(g, GetJsonNull());
+				jvp = jvrp;
       } else if (n < Nod - 1 && jvrp->GetJson()) {
         Tjp->NextSame = nextsame;
-        jval.SetValue(GetColumnValue(g, jvrp->GetJson(), n + 1));
+        jval.SetValue(g, GetColumnValue(g, jvrp->GetJson(), n + 1));
         jvp = &jval;
       } else
         jvp = jvrp;
@@ -1767,13 +1880,13 @@ PVAL JSONCOL::CalculateArray(PGLOBAL g, PJAR arp, int n)
 
   Tjp->NextSame = nextsame;
   return vp;
-  } // end of CalculateArray
+} // end of CalculateArray
 
 /***********************************************************************/
 /*  GetRow: Get the object containing this column.                     */
 /***********************************************************************/
 PJSON JSONCOL::GetRow(PGLOBAL g)
-  {
+{
   PJVAL val = NULL;
   PJAR  arp;
   PJSON nwr, row = Tjp->Row;
@@ -1845,13 +1958,13 @@ PJSON JSONCOL::GetRow(PGLOBAL g)
     } // endfor i
 
   return row;
-  } // end of GetRow
+} // end of GetRow
 
 /***********************************************************************/
 /*  WriteColumn:                                                       */
 /***********************************************************************/
 void JSONCOL::WriteColumn(PGLOBAL g)
-  {
+{
   if (Xpd && Tjp->Pretty < 2) {
     strcpy(g->Message, "Cannot write expanded column when Pretty is not 2");
     throw 666;
@@ -1887,7 +2000,7 @@ void JSONCOL::WriteColumn(PGLOBAL g)
       if (Nodes[Nod-1].Op == OP_XX) {
         s = Value->GetCharValue();
 
-        if (!(jsp = ParseJson(G, s, (int)strlen(s)))) {
+        if (!(jsp = ParseJson(G, s, strlen(s)))) {
           strcpy(g->Message, s);
           throw 666;
         } // endif jsp
@@ -1928,14 +2041,14 @@ void JSONCOL::WriteColumn(PGLOBAL g)
           objp->SetValue(G, new(G) JVALUE(G, Value), Nodes[Nod-1].Key);
 
       } else if (jvp)
-        jvp->SetValue(Value);
+        jvp->SetValue(g, Value);
 
       break;
     default:                  // ??????????
       sprintf(g->Message, "Invalid column type %d", Buf_Type);
     } // endswitch Type
 
-  } // end of WriteColumn
+} // end of WriteColumn
 
 /* -------------------------- Class TDBJSON -------------------------- */
 
@@ -1943,23 +2056,23 @@ void JSONCOL::WriteColumn(PGLOBAL g)
 /*  Implementation of the TDBJSON class.                               */
 /***********************************************************************/
 TDBJSON::TDBJSON(PJDEF tdp, PTXF txfp) : TDBJSN(tdp, txfp)
-  {
+{
   Doc = NULL;
   Multiple = tdp->Multiple;
   Done = Changed = false;
-  } // end of TDBJSON standard constructor
+} // end of TDBJSON standard constructor
 
 TDBJSON::TDBJSON(PJTDB tdbp) : TDBJSN(tdbp)
-  {
+{
   Doc = tdbp->Doc;
   Multiple = tdbp->Multiple;
   Done = tdbp->Done;
   Changed = tdbp->Changed;
-  } // end of TDBJSON copy constructor
+} // end of TDBJSON copy constructor
 
 // Used for update
 PTDB TDBJSON::Clone(PTABS t)
-  {
+{
   PTDB    tp;
   PJCOL   cp1, cp2;
   PGLOBAL g = t->G;
@@ -1972,13 +2085,13 @@ PTDB TDBJSON::Clone(PTABS t)
     } // endfor cp1
 
   return tp;
-  } // end of Clone
+} // end of Clone
 
 /***********************************************************************/
 /*  Make the document tree from the object path.                       */
 /***********************************************************************/
 int TDBJSON::MakeNewDoc(PGLOBAL g)
-  {
+{
   // Create a void table that will be populated
   Doc = new(g) JARRAY;
 
@@ -1987,15 +2100,16 @@ int TDBJSON::MakeNewDoc(PGLOBAL g)
 
   Done = true;
   return RC_OK;
-  } // end of MakeNewDoc
+} // end of MakeNewDoc
 
 /***********************************************************************/
 /*  Make the document tree from a file.                                */
 /***********************************************************************/
 int TDBJSON::MakeDocument(PGLOBAL g)
-  {
+{
   char   *p, *p1, *p2, *memory, *objpath, *key = NULL;
-  int     len, i = 0;
+  int     i = 0;
+	size_t  len;
 	my_bool a;
   MODE    mode = Mode;
   PJSON   jsp;
@@ -2139,13 +2253,13 @@ int TDBJSON::MakeDocument(PGLOBAL g)
 
   Done = true;
   return RC_OK;
-  } // end of MakeDocument
+} // end of MakeDocument
 
 /***********************************************************************/
 /*  JSON Cardinality: returns table size in number of rows.            */
 /***********************************************************************/
 int TDBJSON::Cardinality(PGLOBAL g)
-  {
+{
   if (!g)
     return (Xcol || Multiple) ? 0 : 1;
 	else if (Cardinal < 0) {
@@ -2159,48 +2273,48 @@ int TDBJSON::Cardinality(PGLOBAL g)
 	} // endif Cardinal
 
   return Cardinal;
-  } // end of Cardinality
+} // end of Cardinality
 
 /***********************************************************************/
 /*  JSON GetMaxSize: returns table size estimate in number of rows.    */
 /***********************************************************************/
 int TDBJSON::GetMaxSize(PGLOBAL g)
-  {
+{
   if (MaxSize < 0)
     MaxSize = Cardinality(g) * ((Xcol) ? Limit : 1);
 
   return MaxSize;
-  } // end of GetMaxSize
+} // end of GetMaxSize
 
 /***********************************************************************/
 /*  ResetSize: call by TDBMUL when calculating size estimate.          */
 /***********************************************************************/
 void TDBJSON::ResetSize(void)
-  {
+{
   MaxSize = Cardinal = -1;
   Fpos = -1;
   N = 0;
   Done = false;
-  } // end of ResetSize
+} // end of ResetSize
 
 /***********************************************************************/
 /*  TDBJSON is not indexable.                                          */
 /***********************************************************************/
 int TDBJSON::MakeIndex(PGLOBAL g, PIXDEF pxdf, bool)
-  {
+{
   if (pxdf) {
     strcpy(g->Message, "JSON not indexable when pretty = 2");
     return RC_FX;
   } else
     return RC_OK;
 
-  } // end of MakeIndex
+} // end of MakeIndex
 
 /***********************************************************************/
 /*  Return the position in the table.                                  */
 /***********************************************************************/
 int TDBJSON::GetRecpos(void)
-  {
+{
 #if 0
   union {
     uint Rpos;
@@ -2212,13 +2326,13 @@ int TDBJSON::GetRecpos(void)
   return Rpos;
 #endif // 0
   return Fpos;
-  } // end of GetRecpos
+} // end of GetRecpos
 
 /***********************************************************************/
 /*  Set the position in the table.                                  */
 /***********************************************************************/
 bool TDBJSON::SetRecpos(PGLOBAL, int recpos)
-  {
+{
 #if 0
   union {
     uint Rpos;
@@ -2239,13 +2353,13 @@ bool TDBJSON::SetRecpos(PGLOBAL, int recpos)
 
   Fpos = recpos - 1;
   return false;
-  } // end of SetRecpos
+} // end of SetRecpos
 
 /***********************************************************************/
 /*  JSON Access Method opening routine.                                */
 /***********************************************************************/
 bool TDBJSON::OpenDB(PGLOBAL g)
-  {
+{
   if (Use == USE_OPEN) {
     /*******************************************************************/
     /*  Table already open replace it at its beginning.                */
@@ -2277,13 +2391,13 @@ bool TDBJSON::OpenDB(PGLOBAL g)
 
   Use = USE_OPEN;
   return false;
-  } // end of OpenDB
+} // end of OpenDB
 
 /***********************************************************************/
 /*  ReadDB: Data Base read routine for JSON access method.             */
 /***********************************************************************/
 int TDBJSON::ReadDB(PGLOBAL)
-  {
+{
   int rc;
 
   N++;
@@ -2301,18 +2415,18 @@ int TDBJSON::ReadDB(PGLOBAL)
 
     SameRow = 0;
     M = 1;
-    rc = RC_OK;
+    rc = RC_OK;																													  
   } else
     rc = RC_EF;
 
   return rc;
-  } // end of ReadDB
+} // end of ReadDB
 
 /***********************************************************************/
 /*  WriteDB: Data Base write routine for JSON access method.           */
 /***********************************************************************/
 int TDBJSON::WriteDB(PGLOBAL g)
-  {
+{
   if (Jmode == MODE_OBJECT) {
     PJVAL vp = new(g) JVALUE(Row);
 
@@ -2342,13 +2456,13 @@ int TDBJSON::WriteDB(PGLOBAL g)
 
   Changed = true;
   return RC_OK;
-  } // end of WriteDB
+} // end of WriteDB
 
 /***********************************************************************/
 /*  Data Base delete line routine for JSON access method.              */
 /***********************************************************************/
 int TDBJSON::DeleteDB(PGLOBAL g, int irc)
-  {
+{
   if (irc == RC_OK) {
     // Deleted current row
     if (Doc->DeleteValue(Fpos)) {
@@ -2365,13 +2479,13 @@ int TDBJSON::DeleteDB(PGLOBAL g, int irc)
       } // endfor i
 
   return RC_OK;
-  } // end of DeleteDB
+} // end of DeleteDB
 
 /***********************************************************************/
 /*  Data Base close routine for JSON access methods.                   */
 /***********************************************************************/
 void TDBJSON::CloseDB(PGLOBAL g)
-  {
+{
   if (!Changed)
     return;
 
@@ -2387,7 +2501,7 @@ void TDBJSON::CloseDB(PGLOBAL g)
   if (!Serialize(g, Top, filename, Pretty))
     puts(g->Message);
 
-  } // end of CloseDB
+} // end of CloseDB
 
 /* ---------------------------TDBJCL class --------------------------- */
 
@@ -2395,18 +2509,18 @@ void TDBJSON::CloseDB(PGLOBAL g)
 /*  TDBJCL class constructor.                                          */
 /***********************************************************************/
 TDBJCL::TDBJCL(PJDEF tdp) : TDBCAT(tdp)
-  {
+{
   Topt = tdp->GetTopt();
   Db = tdp->Schema;
   Dsn = tdp->Uri;
-  } // end of TDBJCL constructor
+} // end of TDBJCL constructor
 
 /***********************************************************************/
 /*  GetResult: Get the list the JSON file columns.                     */
 /***********************************************************************/
 PQRYRES TDBJCL::GetResult(PGLOBAL g)
-  {
+{
   return JSONColumns(g, Db, Dsn, Topt, false);
-  } // end of GetResult
+} // end of GetResult
 
 /* --------------------------- End of json --------------------------- */
diff --git a/storage/connect/tabjson.h b/storage/connect/tabjson.h
index 88aa5e2ee8b..b9313e4d809 100644
--- a/storage/connect/tabjson.h
+++ b/storage/connect/tabjson.h
@@ -58,7 +58,7 @@ public:
 	// Members
 	JCOL    jcol;
 	PJCL    jcp, fjcp, pjcp;
-	PVAL    valp;
+	PVL     vlp;
 	PJDEF   tdp;
 	TDBJSN *tjnp;
 	PJTDB   tjsp;
@@ -126,6 +126,7 @@ public:
 class DllExport TDBJSN : public TDBDOS {
   friend class JSONCOL;
 	friend class JSONDEF;
+	friend class JSONDISC;
 #if defined(CMGO_SUPPORT)
 	friend class CMGFAM;
 #endif   // CMGO_SUPPORT
@@ -154,14 +155,17 @@ public:
 	              {return Txfp->GetAmType() == TYPE_AM_MGO || !Xcol;}
 
   // Database routines
-  virtual int   Cardinality(PGLOBAL g);
-  virtual int   GetMaxSize(PGLOBAL g);
+  //virtual int   Cardinality(PGLOBAL g);
+  //virtual int   GetMaxSize(PGLOBAL g);
   virtual bool  OpenDB(PGLOBAL g);
   virtual int   ReadDB(PGLOBAL g);
 	virtual bool  PrepareWriting(PGLOBAL g);
 	virtual int   WriteDB(PGLOBAL g);
 
- protected:
+	// Specific routine
+	virtual int   EstimatedLength(void);
+
+protected:
           PJSON FindRow(PGLOBAL g);
           int   MakeTopTree(PGLOBAL g, PJSON jsp);
 
diff --git a/storage/connect/value.cpp b/storage/connect/value.cpp
index de04f7678f9..bca6d26d1e9 100644
--- a/storage/connect/value.cpp
+++ b/storage/connect/value.cpp
@@ -380,8 +380,8 @@ PVAL AllocateValue(PGLOBAL g, int type, int len, int prec,
     case TYPE_STRING:
       valp = new(g) TYPVAL<PSZ>(g, (PSZ)NULL, len, prec);
       break;
-    case TYPE_DATE:
-      valp = new(g) DTVAL(g, len, prec, fmt);
+		case TYPE_DATE:
+			valp = new(g) DTVAL(g, len, prec, fmt);
       break;
     case TYPE_INT:
       if (uns)
diff --git a/storage/connect/value.h b/storage/connect/value.h
index ee7a1c8032f..3b907c2bf41 100644
--- a/storage/connect/value.h
+++ b/storage/connect/value.h
@@ -65,7 +65,8 @@ DllExport BYTE OpBmp(PGLOBAL g, OPVAL opc);
 /***********************************************************************/
 class DllExport VALUE : public BLOCK {
   friend class CONSTANT; // The only object allowed to use SetConstFormat
- public:
+	friend class SWAP;     // The only class allowed to access protected
+public:
   // Constructors
 
   // Implementation
@@ -260,7 +261,8 @@ class DllExport TYPVAL : public VALUE {
 /***********************************************************************/
 template <>
 class DllExport TYPVAL<PSZ>: public VALUE {
- public:
+	friend class SWAP;     // The only class allowed to offsets Strg
+public:
   // Constructors
   TYPVAL(PSZ s, short c = 0);
   TYPVAL(PGLOBAL g, PSZ s, int n, int c);
@@ -346,7 +348,8 @@ class DllExport DECVAL: public TYPVAL<PSZ> {
 /*  Specific BINARY class.                                             */
 /***********************************************************************/
 class DllExport BINVAL: public VALUE {
- public:
+	friend class SWAP;     // The only class allowed to offsets pointers
+public:
   // Constructors
 //BINVAL(void *p);
   BINVAL(PGLOBAL g, void *p, int cl, int n);
diff --git a/storage/connect/xindex.cpp b/storage/connect/xindex.cpp
index 95f038d494c..4d0f198705a 100644
--- a/storage/connect/xindex.cpp
+++ b/storage/connect/xindex.cpp
@@ -2471,7 +2471,7 @@ void XFILE::Close(void)
     } // endif Xfile
 
 #if defined(XMAP)
-  if (Mmp && CloseMemMap(Mmp->memory, Mmp->lenL))
+  if (Mmp && CloseMemMap(Mmp->memory, (size_t)Mmp->sz.QuadPart))
     printf("Error closing mapped index\n");
 #endif   // XMAP
   } // end of Close
@@ -2487,7 +2487,7 @@ void *XFILE::FileView(PGLOBAL g, char *fn)
   Mmp = (MMP)PlugSubAlloc(g, NULL, sizeof(MEMMAP));
   h = CreateFileMap(g, fn, Mmp, MODE_READ, false);
 
-  if (h == INVALID_HANDLE_VALUE || (!Mmp->lenH && !Mmp->lenL)) {
+  if (h == INVALID_HANDLE_VALUE || (!Mmp->sz.QuadPart)) {
     if (!(*g->Message))
       strcpy(g->Message, MSG(FILE_MAP_ERR));