Commit new source and all recent changes.

8 files changed, 314 insertions, 251 deletions

diff --git a/storage/connect/json.cpp b/storage/connect/json.cpp
index 5e04f65f748..eba9d0d8575 100644
--- a/storage/connect/json.cpp
+++ b/storage/connect/json.cpp
@@ -84,6 +84,7 @@ char* NextChr(PSZ s, char sep)
   return p2;
 } // end of NextChr
 
+#if 0
 /***********************************************************************/
 /* Allocate a VAL structure, make sure common field and Nd are zeroed. */
 /***********************************************************************/
@@ -96,6 +97,7 @@ PVL AllocVal(PGLOBAL g, JTYP type)
   vlp->Type = type;
   return vlp;
 } // end of AllocVal
+#endif // 0
 
 /***********************************************************************/
 /* Parse a json string.                                                */
@@ -633,18 +635,22 @@ PJVAL JDOC::ParseValue(PGLOBAL g, int& i)
   switch (s[i]) {
     case '[':
       jvp->Jsp = ParseArray(g, ++i);
+      jvp->DataType = TYPE_JSON;
       break;
     case '{':
       jvp->Jsp = ParseObject(g, ++i);
+      jvp->DataType = TYPE_JSON;
       break;
     case '"':
-      jvp->Val = AllocVal(g, TYPE_STRG);
-      jvp->Val->Strp = ParseString(g, ++i);
+//    jvp->Val = AllocVal(g, TYPE_STRG);
+      jvp->Strp = ParseString(g, ++i);
+      jvp->DataType = TYPE_STRG;
       break;
     case 't':
       if (!strncmp(s + i, "true", 4)) {
-        jvp->Val = AllocVal(g, TYPE_BOOL);
-        jvp->Val->B = true;
+//      jvp->Val = AllocVal(g, TYPE_BOOL);
+        jvp->B = true;
+        jvp->DataType = TYPE_BOOL;
         i += 3;
       } else
         goto err;
@@ -652,24 +658,26 @@ PJVAL JDOC::ParseValue(PGLOBAL g, int& i)
       break;
     case 'f':
       if (!strncmp(s + i, "false", 5)) {
-        jvp->Val = AllocVal(g, TYPE_BOOL);
-        jvp->Val->B = false;
+//      jvp->Val = AllocVal(g, TYPE_BOOL);
+        jvp->B = false;
+        jvp->DataType = TYPE_BOOL;
         i += 4;
       } else
         goto err;
 
       break;
     case 'n':
-      if (!strncmp(s + i, "null", 4))
+      if (!strncmp(s + i, "null", 4)) {
+        jvp->DataType = TYPE_NULL;
         i += 3;
-      else
+      } else
         goto err;
 
       break;
     case '-':
     default:
       if (s[i] == '-' || isdigit(s[i]))
-        jvp->Val = ParseNumeric(g, i);
+        ParseNumeric(g, i, jvp);
       else
         goto err;
 
@@ -772,7 +780,7 @@ char *JDOC::ParseString(PGLOBAL g, int& i)
 /***********************************************************************/
 /* Parse a JSON numeric value.                                         */
 /***********************************************************************/
-PVL JDOC::ParseNumeric(PGLOBAL g, int& i)
+void JDOC::ParseNumeric(PGLOBAL g, int& i, PJVAL vlp)
 {
   char  buf[50];
   int   n = 0;
@@ -780,7 +788,7 @@ PVL JDOC::ParseNumeric(PGLOBAL g, int& i)
   bool  has_dot = false;
   bool  has_e = false;
   bool  found_digit = false;
-  PVL   vlp = NULL;
+//PVL   vlp = NULL;
 
   for (; i < len; i++) {
     switch (s[i]) {
@@ -829,24 +837,27 @@ PVL JDOC::ParseNumeric(PGLOBAL g, int& i)
     if (has_dot || has_e) {
       double dv = strtod(buf, NULL);
 
-      vlp = AllocVal(g, TYPE_DBL);
+//    vlp = AllocVal(g, TYPE_DBL);
       vlp->F = dv;
       vlp->Nd = nd;
+      vlp->DataType = TYPE_DBL;
     } else {
       long long iv = strtoll(buf, NULL, 10);
 
       if (iv > INT_MAX32 || iv < INT_MIN32) {
-        vlp = AllocVal(g, TYPE_BINT);
+//      vlp = AllocVal(g, TYPE_BINT);
         vlp->LLn = iv;
+        vlp->DataType = TYPE_BINT;
       } else {
-        vlp = AllocVal(g, TYPE_INTG);
+//      vlp = AllocVal(g, TYPE_INTG);
         vlp->N = (int)iv;
+        vlp->DataType = TYPE_INTG;
       } // endif iv
 
     } // endif has
 
     i--;  // Unstack  following character
-    return vlp;
+    return;
   } else
     throw("No digit found");
 
@@ -933,28 +944,28 @@ bool JDOC::SerializeValue(PJVAL jvp)
   char buf[64];
   PJAR jap;
   PJOB jop;
-  PVL  vlp;
+  //PVL  vlp;
 
   if ((jap = jvp->GetArray()))
     return SerializeArray(jap, false);
   else if ((jop = jvp->GetObject()))
     return SerializeObject(jop);
-  else if (!(vlp = jvp->Val))
-    return js->WriteStr("null");
-  else switch (vlp->Type) {
+//else if (!(vlp = jvp->Val))
+//  return js->WriteStr("null");
+  else switch (jvp->DataType) {
     case TYPE_BOOL:
-      return js->WriteStr(vlp->B ? "true" : "false");
+      return js->WriteStr(jvp->B ? "true" : "false");
     case TYPE_STRG:
     case TYPE_DTM:
-      return js->Escape(vlp->Strp);
+      return js->Escape(jvp->Strp);
     case TYPE_INTG:
-      sprintf(buf, "%d", vlp->N);
+      sprintf(buf, "%d", jvp->N);
       return js->WriteStr(buf);
     case TYPE_BINT:
-      sprintf(buf, "%lld", vlp->LLn);
+      sprintf(buf, "%lld", jvp->LLn);
       return js->WriteStr(buf);
     case TYPE_DBL:
-      sprintf(buf, "%.*lf", vlp->Nd, vlp->F);
+      sprintf(buf, "%.*lf", jvp->Nd, jvp->F);
       return js->WriteStr(buf);
     case TYPE_NULL:
       return js->WriteStr("null");
@@ -1382,11 +1393,24 @@ bool JARRAY::IsNull(void)
 JVALUE::JVALUE(PJSON jsp) : JSON()
 {
   if (jsp->GetType() == TYPE_JVAL) {
-    Jsp = jsp->GetJsp();
-    Val = ((PJVAL)jsp)->GetVal();
+    PJVAL jvp = (PJVAL)jsp;
+
+//  Val = ((PJVAL)jsp)->GetVal();
+    if (jvp->DataType == TYPE_JSON) {
+      Jsp = jvp->GetJsp();
+      DataType = TYPE_JSON;
+      Nd = 0;
+    } else {
+      LLn = jvp->LLn;   // Must be LLn on 32 bit machines
+      Nd = jvp->Nd;
+      DataType = jvp->DataType;
+    } // endelse Jsp
+ 
   } else {
     Jsp = jsp;
-    Val = NULL;
+//  Val = NULL;
+    DataType = TYPE_JSON;
+    Nd = 0;
   } // endif Type
 
   Next = NULL;
@@ -1394,6 +1418,7 @@ JVALUE::JVALUE(PJSON jsp) : JSON()
   Type = TYPE_JVAL;
 } // end of JVALUE constructor
 
+#if 0
 /***********************************************************************/
 /* Constructor for a JVALUE with a given string or numeric value.      */
 /***********************************************************************/
@@ -1405,13 +1430,14 @@ JVALUE::JVALUE(PGLOBAL g, PVL vlp) : JSON()
   Del = false;
   Type = TYPE_JVAL;
 } // end of JVALUE constructor
+#endif // 0
 
 /***********************************************************************/
 /* Constructor for a JVALUE with a given string or numeric value.      */
 /***********************************************************************/
 JVALUE::JVALUE(PGLOBAL g, PVAL valp) : JSON() {
   Jsp = NULL;
-  Val = NULL;
+//Val = NULL;
   SetValue(g, valp);
   Next = NULL;
   Del = false;
@@ -1424,24 +1450,39 @@ JVALUE::JVALUE(PGLOBAL g, PVAL valp) : JSON() {
 JVALUE::JVALUE(PGLOBAL g, PCSZ strp) : JSON()
 {
   Jsp = NULL;
-  Val = AllocVal(g, TYPE_STRG);
-  Val->Strp = (char*)strp;
+//Val = AllocVal(g, TYPE_STRG);
+  Strp = (char*)strp;
+  DataType = TYPE_STRG;
+  Nd = 0;
   Next = NULL;
   Del = false;
   Type = TYPE_JVAL;
 } // end of JVALUE constructor
 
 /***********************************************************************/
+/* Set or reset all Jvalue members.                                    */
+/***********************************************************************/
+void JVALUE::Clear(void)
+{
+  Jsp = NULL; 
+  Next = NULL; 
+  Type = TYPE_JVAL; 
+  Del = false; 
+  Nd = 0; 
+  DataType = TYPE_NULL;
+} // end of Clear
+
+/***********************************************************************/
 /* Returns the type of the Value's value.                              */
 /***********************************************************************/
 JTYP JVALUE::GetValType(void)
 {
-  if (Jsp)
+  if (DataType == TYPE_JSON)
     return Jsp->GetType();
-  else if (Val)
-    return Val->Type;
+//else if (Val)
+//  return Val->Type;
   else
-    return TYPE_NULL;
+    return DataType;
 
 } // end of GetValType
 
@@ -1450,7 +1491,7 @@ JTYP JVALUE::GetValType(void)
 /***********************************************************************/
 PJOB JVALUE::GetObject(void)
 {
-  if (Jsp && Jsp->GetType() == TYPE_JOB)
+  if (DataType == TYPE_JSON && Jsp->GetType() == TYPE_JOB)
     return (PJOB)Jsp;
 
   return NULL;
@@ -1461,7 +1502,7 @@ PJOB JVALUE::GetObject(void)
 /***********************************************************************/
 PJAR JVALUE::GetArray(void)
 {
-  if (Jsp && Jsp->GetType() == TYPE_JAR)
+  if (DataType == TYPE_JSON && Jsp->GetType() == TYPE_JAR)
     return (PJAR)Jsp;
 
   return NULL;
@@ -1474,11 +1515,11 @@ PVAL JVALUE::GetValue(PGLOBAL g)
 {
   PVAL valp = NULL;
 
-  if (Val)
-    if (Val->Type == TYPE_STRG)
-      valp = AllocateValue(g, Val->Strp, Val->Type, Val->Nd);
+  if (DataType != TYPE_JSON)
+    if (DataType == TYPE_STRG)
+      valp = AllocateValue(g, Strp, DataType, Nd);
     else
-      valp = AllocateValue(g, Val, Val->Type, Val->Nd);
+      valp = AllocateValue(g, &LLn, DataType, Nd);
 
   return valp;
 } // end of GetValue
@@ -1489,15 +1530,13 @@ PVAL JVALUE::GetValue(PGLOBAL g)
 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;
+  switch (DataType) {
+  case TYPE_INTG: n = N;           break;
+  case TYPE_DBL:  n = (int)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;
+  case TYPE_STRG: n = atoi(Strp);  break;
+  case TYPE_BOOL: n = (B) ? 1 : 0; break;
+  case TYPE_BINT: n = (int)LLn;    break;
   default:
     n = 0;
   } // endswitch Type
@@ -1512,15 +1551,13 @@ long long JVALUE::GetBigint(void)
 {
   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;
+  switch (DataType) {
+  case TYPE_BINT: lln = LLn;          break;
+  case TYPE_INTG: lln = (long long)N; break;
+  case TYPE_DBL:  lln = (long long)F; break;
   case TYPE_DTM:
-  case TYPE_STRG: lln = atoll(Val->Strp);  break;
-  case TYPE_BOOL: lln = (Val->B) ? 1 : 0;  break;
+  case TYPE_STRG: lln = atoll(Strp);  break;
+  case TYPE_BOOL: lln = (B) ? 1 : 0;  break;
   default:
     lln = 0;
   } // endswitch Type
@@ -1535,15 +1572,13 @@ double JVALUE::GetFloat(void)
 {
   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;
+  switch (DataType) {
+  case TYPE_DBL:  d = F;               break;
+  case TYPE_BINT: d = (double)LLn;     break;
+  case TYPE_INTG: d = (double)N;       break;
   case TYPE_DTM:
-  case TYPE_STRG: d = atof(Val->Strp);      break;
-  case TYPE_BOOL: d = (Val->B) ? 1.0 : 0.0; break;
+  case TYPE_STRG: d = atof(Strp);      break;
+  case TYPE_BOOL: d = (B) ? 1.0 : 0.0; break;
   default:
     d = 0.0;
   } // endswitch Type
@@ -1559,33 +1594,30 @@ PSZ JVALUE::GetString(PGLOBAL g, char *buff)
   char  buf[32];
   char *p = (buff) ? buff : buf;
 
-  if (Val) {
-    switch (Val->Type) {
-    case TYPE_DTM:
-    case TYPE_STRG:
-      p = Val->Strp;
-      break;
-    case TYPE_INTG:
-      sprintf(p, "%d", Val->N);
-      break;
-    case TYPE_BINT:
-      sprintf(p, "%lld", Val->LLn);
-      break;
-    case TYPE_DBL:
-      sprintf(p, "%.*lf", Val->Nd, Val->F);
-      break;
-    case TYPE_BOOL:
-      p = (char*)((Val->B) ? "true" : "false");
-      break;
-    case TYPE_NULL:
-      p = (char*)"null";
-      break;
-    default:
-      p = NULL;
-    } // endswitch Type
-
-  } else
+  switch (DataType) {
+  case TYPE_DTM:
+  case TYPE_STRG:
+    p = Strp;
+    break;
+  case TYPE_INTG:
+    sprintf(p, "%d", N);
+    break;
+  case TYPE_BINT:
+    sprintf(p, "%lld", LLn);
+    break;
+  case TYPE_DBL:
+    sprintf(p, "%.*lf", Nd, F);
+    break;
+  case TYPE_BOOL:
+    p = (char*)((B) ? "true" : "false");
+    break;
+  case TYPE_NULL:
+    p = (char*)"null";
+    break;
+  default:
     p = NULL;
+  } // endswitch Type
+
 
   return (p == buf) ? (char*)PlugDup(g, buf) : p;
 } // end of GetString
@@ -1595,11 +1627,11 @@ PSZ JVALUE::GetString(PGLOBAL g, char *buff)
 /***********************************************************************/
 PSZ JVALUE::GetText(PGLOBAL g, PSTRG text)
 {
-  if (Jsp)
+  if (DataType == TYPE_JSON)
     return Jsp->GetText(g, text);
 
 	char buff[32];
-  PSZ  s = (Val) ? GetString(g, buff) : NULL;
+  PSZ  s = (DataType == TYPE_NULL) ? NULL : GetString(g, buff);
 
 	if (s)
 		text->Append(s);
@@ -1611,58 +1643,60 @@ PSZ JVALUE::GetText(PGLOBAL g, PSTRG text)
 
 void JVALUE::SetValue(PJSON jsp)
 {
-  if (jsp && jsp->GetType() == TYPE_JVAL) {
+  if (DataType == TYPE_JSON && jsp->GetType() == TYPE_JVAL) {
     Jsp = jsp->GetJsp();
-    Val = ((PJVAL)jsp)->GetVal();
+    Nd = ((PJVAL)jsp)->Nd;
+    DataType = ((PJVAL)jsp)->DataType;
+    //  Val = ((PJVAL)jsp)->GetVal();
   } else {
     Jsp = jsp;
-    Val = NULL;
+    DataType = TYPE_JSON;
   } // endif Type
 
 } // end of SetValue;
 
 void JVALUE::SetValue(PGLOBAL g, PVAL valp)
 {
-  if (!Val)
-    Val = AllocVal(g, TYPE_VAL);
+//if (!Val)
+//  Val = AllocVal(g, TYPE_VAL);
 
   if (!valp || valp->IsNull()) {
-    Val->Type = TYPE_NULL;
+    DataType = TYPE_NULL;
   } else switch (valp->GetType()) {
-  case TYPE_STRING:
+  case TYPE_DATE:
 		if (((DTVAL*)valp)->IsFormatted())
-			Val->Strp = valp->GetCharValue();
+			Strp = valp->GetCharValue();
 		else {
 			char buf[32];
 
-			Val->Strp = PlugDup(g, valp->GetCharString(buf));
+			Strp = PlugDup(g, valp->GetCharString(buf));
 		}	// endif Formatted
 
-		Val->Type = TYPE_DTM;
+		DataType = TYPE_DTM;
 		break;
-	case TYPE_DATE:
-    Val->Strp = valp->GetCharValue();
-    Val->Type = TYPE_STRG;
+	case TYPE_STRING:
+    Strp = valp->GetCharValue();
+    DataType = TYPE_STRG;
     break;
   case TYPE_DOUBLE:
   case TYPE_DECIM:
-    Val->F = valp->GetFloatValue();
+    F = valp->GetFloatValue();
 
     if (IsTypeNum(valp->GetType()))
-      Val->Nd = valp->GetValPrec();
+      Nd = valp->GetValPrec();
 
-    Val->Type = TYPE_DBL;
+    DataType = TYPE_DBL;
     break;
   case TYPE_TINY:
-    Val->B = valp->GetTinyValue() != 0;
-    Val->Type = TYPE_BOOL;
+    B = valp->GetTinyValue() != 0;
+    DataType = TYPE_BOOL;
   case TYPE_INT:
-    Val->N = valp->GetIntValue();
-    Val->Type = TYPE_INTG;
+    N = valp->GetIntValue();
+    DataType = TYPE_INTG;
     break;
   case TYPE_BIGINT:
-    Val->LLn = valp->GetBigintValue();
-    Val->Type = TYPE_BINT;
+    LLn = valp->GetBigintValue();
+    DataType = TYPE_BINT;
     break;
   default:
     sprintf(g->Message, "Unsupported typ %d\n", valp->GetType());
@@ -1676,9 +1710,8 @@ void JVALUE::SetValue(PGLOBAL g, PVAL valp)
 /***********************************************************************/
 void JVALUE::SetInteger(PGLOBAL g, int n)
 {
-  Val = AllocVal(g, TYPE_INTG);
-  Val->N = n;
-  Jsp = NULL;
+  N = n;
+  DataType = TYPE_INTG;
 } // end of SetInteger
 
 /***********************************************************************/
@@ -1686,9 +1719,8 @@ void JVALUE::SetInteger(PGLOBAL g, int n)
 /***********************************************************************/
 void JVALUE::SetBool(PGLOBAL g, bool b)
 {
-  Val = AllocVal(g, TYPE_BOOL);
-  Val->B = b;
-  Jsp = NULL;
+  B = b;
+  DataType = TYPE_BOOL;
 } // end of SetTiny
 
 /***********************************************************************/
@@ -1696,9 +1728,8 @@ void JVALUE::SetBool(PGLOBAL g, bool b)
 /***********************************************************************/
 void JVALUE::SetBigint(PGLOBAL g, long long ll)
 {
-  Val = AllocVal(g, TYPE_BINT);
-  Val->LLn = ll;
-  Jsp = NULL;
+  LLn = ll;
+  DataType = TYPE_BINT;
 } // end of SetBigint
 
 /***********************************************************************/
@@ -1706,10 +1737,9 @@ void JVALUE::SetBigint(PGLOBAL g, long long ll)
 /***********************************************************************/
 void JVALUE::SetFloat(PGLOBAL g, double f)
 {
-  Val = AllocVal(g, TYPE_DBL);
-  Val->F = f;
-  Val->Nd = 6;
-  Jsp = NULL;
+  F = f;
+  Nd = 6;
+  DataType = TYPE_DBL;
 } // end of SetFloat
 
 /***********************************************************************/
@@ -1717,10 +1747,9 @@ void JVALUE::SetFloat(PGLOBAL g, double f)
 /***********************************************************************/
 void JVALUE::SetString(PGLOBAL g, PSZ s, int ci)
 {
-  Val = AllocVal(g, TYPE_STRG);
-  Val->Strp = s;
-  Val->Nd = ci;
-  Jsp = NULL;
+  Strp = s;
+  Nd = ci;
+  DataType = TYPE_STRG;
 } // end of SetString
 
 /***********************************************************************/
@@ -1728,7 +1757,7 @@ void JVALUE::SetString(PGLOBAL g, PSZ s, int ci)
 /***********************************************************************/
 bool JVALUE::IsNull(void)
 {
-  return (Jsp) ? Jsp->IsNull() : (Val) ? Val->Type == TYPE_NULL : true;
+  return (DataType == TYPE_JSON) ? Jsp->IsNull() : DataType == TYPE_NULL;
 } // end of IsNull
 
 
@@ -1751,7 +1780,7 @@ void SWAP::SwapJson(PJSON jsp, bool move)
 /* Replace all pointers by offsets.                                    */
 /***********************************************************************/
 size_t SWAP::MoffJson(PJSON jsp) {
-  size_t res;
+  size_t res = NULL;
 
   if (jsp)
     switch (jsp->Type) {
@@ -1780,6 +1809,7 @@ size_t SWAP::MoffArray(PJAR jarp)
     for (int i = 0; i < jarp->Size; i++)
       jarp->Mvals[i] = (PJVAL)MakeOff(Base, jarp->Mvals[i]);
 
+    jarp->Mvals = (PJVAL*)MakeOff(Base, jarp->Mvals);
     jarp->First = (PJVAL)MoffJValue(jarp->First);
     jarp->Last = (PJVAL)MakeOff(Base, jarp->Last);
   } // endif First
@@ -1819,11 +1849,13 @@ size_t SWAP::MoffPair(PJPR jpp) {
 /***********************************************************************/
 size_t SWAP::MoffJValue(PJVAL jvp) {
   if (!jvp->Del) {
-    if (jvp->Jsp)
+    if (jvp->DataType == TYPE_JSON)
       jvp->Jsp = (PJSON)MoffJson(jvp->Jsp);
+    else if (jvp->DataType == TYPE_STRG)
+      jvp->Strp = (PSZ)MakeOff(Base, (jvp->Strp));
 
-    if (jvp->Val)
-      jvp->Val = (PVL)MoffVal(jvp->Val);
+//  if (jvp->Val)
+//    jvp->Val = (PVL)MoffVal(jvp->Val);
 
   } // endif Del
 
@@ -1833,6 +1865,7 @@ size_t SWAP::MoffJValue(PJVAL jvp) {
   return MakeOff(Base, jvp);
 } // end of MoffJValue
 
+#if 0
 /***********************************************************************/
 /* Replace string pointers by offset.                                  */
 /***********************************************************************/
@@ -1842,6 +1875,7 @@ size_t SWAP::MoffVal(PVL vlp) {
 
   return MakeOff(Base, vlp);
 } // end of MoffVal
+#endif // 0
 
 /***********************************************************************/
 /* Replace all offsets by pointers.                                    */
@@ -1876,6 +1910,8 @@ PJAR SWAP::MptrArray(PJAR ojar) {
   jarp = (PJAR)new((long long)jarp) JARRAY(0);
 
   if (jarp->First) {
+    jarp->Mvals = (PJVAL*)MakePtr(Base, (size_t)jarp->Mvals);
+
     for (int i = 0; i < jarp->Size; i++)
       jarp->Mvals[i] = (PJVAL)MakePtr(Base, (size_t)jarp->Mvals[i]);
 
@@ -1928,11 +1964,13 @@ PJVAL SWAP::MptrJValue(PJVAL ojv) {
   jvp = (PJVAL)new((long long)jvp) JVALUE(0);
 
   if (!jvp->Del) {
-    if (jvp->Jsp)
+    if (jvp->DataType == TYPE_JSON)
       jvp->Jsp = (PJSON)MptrJson(jvp->Jsp);
+    else if (jvp->DataType == TYPE_STRG)
+      jvp->Strp = (PSZ)MakePtr(Base, (size_t)jvp->Strp);
 
-    if (jvp->Val)
-      jvp->Val = (PVL)MptrVal(jvp->Val);
+//  if (jvp->Val)
+//    jvp->Val = (PVL)MptrVal(jvp->Val);
 
   } // endif Del
 
@@ -1942,6 +1980,7 @@ PJVAL SWAP::MptrJValue(PJVAL ojv) {
   return jvp;
 } // end of MptrJValue
 
+#if 0
 /***********************************************************************/
 /* Replace string offsets by a pointer.                                */
 /***********************************************************************/
@@ -1953,3 +1992,4 @@ PVL SWAP::MptrVal(PVL ovl) {
 
   return vlp;
 } // end of MptrValue
+#endif // 0
diff --git a/storage/connect/json.h b/storage/connect/json.h
index 31175777985..999b2cd8a1c 100644
--- a/storage/connect/json.h
+++ b/storage/connect/json.h
@@ -45,7 +45,7 @@ typedef class JARRAY  *PJAR;
 #define BMX 255
 typedef struct BSON  *PBSON;
 typedef struct JPAIR *PJPR;
-typedef struct VAL   *PVL;
+//typedef struct VAL   *PVL;
 
 /***********************************************************************/
 /* Structure JPAIR. The pairs of a json Object.                        */
@@ -56,6 +56,7 @@ struct JPAIR {
 	PJPR  Next;     // To the next pair
 }; // end of struct JPAIR
 
+#if 0
 /***********************************************************************/
 /* Structure VAL (string, int, float, bool or null)                    */
 /***********************************************************************/
@@ -70,6 +71,7 @@ struct VAL {
 	int         Nd;				 // Decimal number
 	JTYP        Type;      // The value type
 }; // end of struct VAL
+#endif // 0
 
 /***********************************************************************/
 /*  Structure used to return binary json to Json UDF functions.        */
@@ -87,7 +89,7 @@ struct BSON {
 }; // end of struct BSON
 
 PBSON JbinAlloc(PGLOBAL g, UDF_ARGS* args, ulong len, PJSON jsp);
-PVL   AllocVal(PGLOBAL g, JTYP type);
+//PVL   AllocVal(PGLOBAL g, JTYP type);
 char *NextChr(PSZ s, char sep);
 char *GetJsonNull(void);
 const char* GetFmt(int type, bool un);
@@ -112,7 +114,7 @@ public:
 	PJOB  ParseObject(PGLOBAL g, int& i);
 	PJVAL ParseValue(PGLOBAL g, int& i);
 	char *ParseString(PGLOBAL g, int& i);
-	PVL   ParseNumeric(PGLOBAL g, int& i);
+	void  ParseNumeric(PGLOBAL g, int& i, PJVAL jvp);
 	PJAR  ParseAsArray(PGLOBAL g, int& i, int pretty, int *ptyp);
 	bool  SerializeArray(PJAR jarp, bool b);
 	bool  SerializeObject(PJOB jobp);
@@ -231,6 +233,7 @@ class JARRAY : public JSON {
 class JVALUE : public JSON {
   friend class JARRAY;
 	friend class JSNX;
+	friend class JSONDISC;
 	friend class JSONCOL;
   friend class JSON;
 	friend class JDOC;
@@ -238,7 +241,7 @@ class JVALUE : public JSON {
 public:
 	JVALUE(void) : JSON() { Type = TYPE_JVAL; Clear(); }
 	JVALUE(PJSON jsp);
-	JVALUE(PGLOBAL g, PVL vlp);
+//JVALUE(PGLOBAL g, PVL vlp);
 	JVALUE(PGLOBAL g, PVAL valp);
 	JVALUE(PGLOBAL g, PCSZ strp);
 	JVALUE(int i) : JSON(i) {}
@@ -247,20 +250,19 @@ public:
   //using JSON::SetVal;
 
 	// Methods
-  virtual void   Clear(void)
-          {Jsp = NULL; Val = NULL; Next = NULL; Del = false;}
+	virtual void   Clear(void);
 //virtual JTYP   GetType(void) {return TYPE_JVAL;}
   virtual JTYP   GetValType(void);
   virtual PJOB   GetObject(void);
   virtual PJAR   GetArray(void);
-  virtual PJSON  GetJsp(void) {return Jsp;}
+  virtual PJSON  GetJsp(void) {return (DataType == TYPE_JSON ? Jsp : NULL);}
   virtual PSZ    GetText(PGLOBAL g, PSTRG text);
 	virtual bool   IsNull(void);
 
 	// Specific
-	inline PVL  GetVal(void) { return Val; }
-	inline void SetVal(PVL vlp) { Val = vlp; }
-	inline PJSON  GetJson(void) { return (Jsp ? Jsp : this); }
+	//inline PVL  GetVal(void) { return Val; }
+	//inline void SetVal(PVL vlp) { Val = vlp; }
+	inline PJSON  GetJson(void) { return (DataType == TYPE_JSON ? Jsp : this); }
 	PSZ    GetString(PGLOBAL g, char* buff = NULL);
 	int    GetInteger(void);
 	long long GetBigint(void);
@@ -275,10 +277,19 @@ public:
 	void   SetBool(PGLOBAL g, bool b);
 
  protected:
-  PJSON Jsp;      // To the json value
-  PVL   Val;      // To the string or numeric value
-  PJVAL Next;     // Next value in array
-  bool  Del;      // True when deleted
+	 union {
+		 PJSON  Jsp;       // To the json value
+		 char  *Strp;      // Ptr to a string
+		 int    N;         // An integer value
+		 long long LLn;		 // A big integer value
+		 double F;				 // A (double) float value
+		 bool   B;				 // True or false
+	 };
+//PVL   Val;      // To the string or numeric value
+	PJVAL Next;     // Next value in array
+	JTYP  DataType; // The data value type
+	int   Nd;				// Decimal number
+	bool  Del;      // True when deleted
 }; // end of class JVALUE
 
 
@@ -368,15 +379,15 @@ protected:
 	size_t MoffObject(PJOB jobp);
 	size_t MoffJValue(PJVAL jvp);
 	size_t MoffPair(PJPR jpp);
-	size_t MoffVal(PVL vlp);
+//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);
+//PVL    MptrVal(PVL vlp);
 
 	// Member
-	PGLOBAL G, NG;
+	PGLOBAL G;
 	void   *Base;
 }; // end of class SWAP
diff --git a/storage/connect/jsonudf.cpp b/storage/connect/jsonudf.cpp
index 3908e2a37a8..9ec70512823 100644
--- a/storage/connect/jsonudf.cpp
+++ b/storage/connect/jsonudf.cpp
@@ -1018,12 +1018,12 @@ my_bool JSNX::CompareTree(PGLOBAL g, PJSON jp1, PJSON jp2)
 	my_bool found = true;
 
 	if (jp1->GetType() == TYPE_JVAL) {
-		PVL v1 = ((PJVAL)jp1)->GetVal(), v2 = ((PJVAL)jp2)->GetVal();
+//	PVL v1 = ((PJVAL)jp1)->GetVal(), v2 = ((PJVAL)jp2)->GetVal();
 
-		if (v1 && v2)
-			found = CompareValues(v1, v2);
-		else
+		if (((PJVAL)jp1)->DataType == TYPE_JSON && ((PJVAL)jp2)->DataType == TYPE_JSON)
 			found = CompareTree(g, jp1->GetJsp(), jp2->GetJsp());
+		else
+			found = CompareValues(((PJVAL)jp1), ((PJVAL)jp2));
 
 	} else if (jp1->GetType() == TYPE_JAR) {
 		for (int i = 0; found && i < jp1->size(); i++)
@@ -1044,13 +1044,13 @@ my_bool JSNX::CompareTree(PGLOBAL g, PJSON jp1, PJSON jp2)
 /*********************************************************************************/
 /*  Compare two VAL values and return true if they are equal.                    */
 /*********************************************************************************/
-my_bool JSNX::CompareValues(PVL v1, PVL v2)
+my_bool JSNX::CompareValues(PJVAL v1, PJVAL v2)
 {
 	my_bool b = false;
 
-	switch (v1->Type) {
+	switch (v1->DataType) {
 	case TYPE_STRG:
-		if (v2->Type == TYPE_STRG) {
+		if (v2->DataType == TYPE_STRG) {
 			if (v1->Nd || v2->Nd)		// Case insensitive
 				b = (!stricmp(v1->Strp, v2->Strp));
 			else
@@ -1060,33 +1060,41 @@ my_bool JSNX::CompareValues(PVL v1, PVL v2)
 
 		break;
 	case TYPE_DTM:
-		b = (!strcmp(v1->Strp, v2->Strp));
+		if (v2->DataType == TYPE_DTM)
+			b = (!strcmp(v1->Strp, v2->Strp));
+
 		break;
 	case TYPE_INTG:
-		if (v2->Type == TYPE_INTG)
+		if (v2->DataType == TYPE_INTG)
 			b = (v1->N == v2->N);
-		else if (v2->Type == TYPE_BINT)
+		else if (v2->DataType == TYPE_BINT)
 			b = (v1->N == v2->LLn);
 
 		break;
 	case TYPE_BINT:
-		if (v2->Type == TYPE_INTG)
+		if (v2->DataType == TYPE_INTG)
 			b = (v1->LLn == v2->N);
-		else if (v2->Type == TYPE_BINT)
+		else if (v2->DataType == TYPE_BINT)
 			b = (v1->LLn == v2->LLn);
 
 		break;
 	case TYPE_DBL:
-		if (v2->Type == TYPE_DBL)
+		if (v2->DataType == TYPE_DBL)
 			b = (v1->F == v2->F);
 		
 		break;
 	case TYPE_BOOL:
-		if (v2->Type == TYPE_BOOL)
+		if (v2->DataType == TYPE_BOOL)
 		  b = (v1->B == v2->B);
 
 		break;
-	default:        b = true;   // both nulls
+	case TYPE_NULL:
+		if (v2->DataType == TYPE_NULL)
+			b = true;
+
+		break;
+	default:
+		break;
 	}	// endswitch Type
 
 	return b;
@@ -1263,7 +1271,7 @@ static PJVAL JvalNew(PGLOBAL g, JTYP type, void *vp)
 	}	// end try/catch
 
 	return jvp;
-} /* end of JsonNew */
+} /* end of JvalNew */
 
 /*********************************************************************************/
 /*  Allocate and initialise the memory area.                                     */
diff --git a/storage/connect/jsonudf.h b/storage/connect/jsonudf.h
index 9b3d478b018..69d6c644d9c 100644
--- a/storage/connect/jsonudf.h
+++ b/storage/connect/jsonudf.h
@@ -296,7 +296,7 @@ protected:
 	PVAL    MakeJson(PGLOBAL g, PJSON jsp);
 	void    SetJsonValue(PGLOBAL g, PVAL vp, PJVAL val);
 	PJSON   GetRow(PGLOBAL g);
-	my_bool CompareValues(PVL v1, PVL v2);
+	my_bool CompareValues(PJVAL v1, PJVAL v2);
 	my_bool LocateArray(PGLOBAL g, PJAR jarp);
 	my_bool LocateObject(PGLOBAL g, PJOB jobp);
 	my_bool LocateValue(PGLOBAL g, PJVAL jvp);
diff --git a/storage/connect/mysql-test/connect/r/xml.result b/storage/connect/mysql-test/connect/r/xml.result
index 09dac32a2a4..92e1abb615d 100644
--- a/storage/connect/mysql-test/connect/r/xml.result
+++ b/storage/connect/mysql-test/connect/r/xml.result
@@ -158,47 +158,47 @@ TRANSLATOR	NULL
 PUBLISHER	Eyrolles Paris
 DATEPUB	1998
 SELECT LOAD_FILE('MYSQLD_DATADIR/test/xsample2.xml') AS xml;
-xml	<?xml version="1.0" encoding="UTF-8"?>

-<BIBLIO SUBJECT="XML">

-	<BOOK ISBN="9782212090819" LANG="fr" SUBJECT="applications">

-		<AUTHOR>

-			<FIRSTNAME>Jean-Christophe</FIRSTNAME>

-			<LASTNAME>Bernadac</LASTNAME>

-		</AUTHOR>

-		<AUTHOR>

-			<FIRSTNAME>François</FIRSTNAME>

-			<LASTNAME>Knab</LASTNAME>

-		</AUTHOR>

-		<TITLE>Construire une application XML</TITLE>

-		<PUBLISHER>

-			<NAME>Eyrolles</NAME>

-			<PLACE>Paris</PLACE>

-		</PUBLISHER>

-		<DATEPUB>1999</DATEPUB>

-	</BOOK>

-	<BOOK ISBN="9782840825685" LANG="fr" SUBJECT="applications">

-		<AUTHOR>

-			<FIRSTNAME>William J.</FIRSTNAME>

-			<LASTNAME>Pardi</LASTNAME>

-		</AUTHOR>

-		<TRANSLATOR PREFIX="adapté de l'anglais par">

-			<FIRSTNAME>James</FIRSTNAME>

-			<LASTNAME>Guerin</LASTNAME>

-		</TRANSLATOR>

-		<TITLE>XML en Action</TITLE>

-		<PUBLISHER>

-			<NAME>Microsoft Press</NAME>

-			<PLACE>Paris</PLACE>

-		</PUBLISHER>

-		<DATEPUB>1999</DATEPUB>

-	</BOOK>

-	<BOOK ISBN="9782212090529" LANG="fr" SUBJECT="général">

-		<AUTHOR>Alain Michard</AUTHOR>

-		<TITLE>XML, Langage et Applications</TITLE>

-		<PUBLISHER>Eyrolles Paris</PUBLISHER>

-		<DATEPUB>1998</DATEPUB>

-	</BOOK>

-</BIBLIO>

+xml	<?xml version="1.0" encoding="UTF-8"?>
+<BIBLIO SUBJECT="XML">
+	<BOOK ISBN="9782212090819" LANG="fr" SUBJECT="applications">
+		<AUTHOR>
+			<FIRSTNAME>Jean-Christophe</FIRSTNAME>
+			<LASTNAME>Bernadac</LASTNAME>
+		</AUTHOR>
+		<AUTHOR>
+			<FIRSTNAME>François</FIRSTNAME>
+			<LASTNAME>Knab</LASTNAME>
+		</AUTHOR>
+		<TITLE>Construire une application XML</TITLE>
+		<PUBLISHER>
+			<NAME>Eyrolles</NAME>
+			<PLACE>Paris</PLACE>
+		</PUBLISHER>
+		<DATEPUB>1999</DATEPUB>
+	</BOOK>
+	<BOOK ISBN="9782840825685" LANG="fr" SUBJECT="applications">
+		<AUTHOR>
+			<FIRSTNAME>William J.</FIRSTNAME>
+			<LASTNAME>Pardi</LASTNAME>
+		</AUTHOR>
+		<TRANSLATOR PREFIX="adapté de l'anglais par">
+			<FIRSTNAME>James</FIRSTNAME>
+			<LASTNAME>Guerin</LASTNAME>
+		</TRANSLATOR>
+		<TITLE>XML en Action</TITLE>
+		<PUBLISHER>
+			<NAME>Microsoft Press</NAME>
+			<PLACE>Paris</PLACE>
+		</PUBLISHER>
+		<DATEPUB>1999</DATEPUB>
+	</BOOK>
+	<BOOK ISBN="9782212090529" LANG="fr" SUBJECT="général">
+		<AUTHOR>Alain Michard</AUTHOR>
+		<TITLE>XML, Langage et Applications</TITLE>
+		<PUBLISHER>Eyrolles Paris</PUBLISHER>
+		<DATEPUB>1998</DATEPUB>
+	</BOOK>
+</BIBLIO>
 
 DROP TABLE t1;
 #
@@ -374,7 +374,7 @@ INSERT INTO t1 VALUES (_cp1251 0xC0C1C2C3);
 Warnings:
 Level	Warning
 Code	1105
-Message	Com error: Impossible d'enregistrer le caractère dans le codage iso-8859-1.

+Message	Com error: Unable to save character to 'iso-8859-1' encoding.
 
 INSERT INTO t1 VALUES ('&<>"\'');
 SELECT node, hex(node) FROM t1;
@@ -383,11 +383,11 @@ hex(node)	263C3E2227
 DROP TABLE t1;
 SET @a=LOAD_FILE('MYSQLD_DATADIR/test/t1.xml');
 SELECT CAST(@a AS CHAR CHARACTER SET latin1);
-CAST(@a AS CHAR CHARACTER SET latin1)	<?xml version="1.0" encoding="iso-8859-1"?>

-<!-- Created by the MariaDB CONNECT Storage Engine-->

-<t1>

-	<line>

-		<node>&amp;&lt;&gt;"'</node>

-	</line>

-</t1>

+CAST(@a AS CHAR CHARACTER SET latin1)	<?xml version="1.0" encoding="iso-8859-1"?>
+<!-- Created by the MariaDB CONNECT Storage Engine-->
+<t1>
+	<line>
+		<node>&amp;&lt;&gt;"'</node>
+	</line>
+</t1>
 
diff --git a/storage/connect/tabjson.cpp b/storage/connect/tabjson.cpp
index 9ebece5d4e7..b0866ba1b18 100644
--- a/storage/connect/tabjson.cpp
+++ b/storage/connect/tabjson.cpp
@@ -152,6 +152,7 @@ JSONDISC::JSONDISC(PGLOBAL g, uint *lg)
 {
   length = lg;
   jcp = fjcp = pjcp = NULL;
+  tdp = NULL;
   tjnp = NULL;
   jpp = NULL;
   tjsp = NULL;
@@ -392,16 +393,16 @@ bool JSONDISC::Find(PGLOBAL g, PJVAL jvp, PCSZ key, int j)
   PJOB   job;
   PJAR   jar;
 
-  if ((vlp = jvp ? jvp->GetVal() : NULL)) {
+  if (jvp && jvp->DataType != TYPE_JSON) {
 		if (JsonAllPath() && !fmt[bf])
 			strcat(fmt, colname);
 
-		jcol.Type = vlp->Type;
+		jcol.Type = jvp->DataType;
 
-		switch (vlp->Type) {
+		switch (jvp->DataType) {
 		case TYPE_STRG:
 		case TYPE_DTM:
-			jcol.Len = (int)strlen(vlp->Strp);
+			jcol.Len = (int)strlen(jvp->Strp);
 			break;
 		case TYPE_INTG:
 		case TYPE_BINT:
@@ -409,7 +410,7 @@ bool JSONDISC::Find(PGLOBAL g, PJVAL jvp, PCSZ key, int j)
 			break;
 		case TYPE_DBL:
 			jcol.Len = (int)strlen(jvp->GetString(g));
-			jcol.Scale = vlp->Nd;
+			jcol.Scale = jvp->Nd;
 			break;
 		case TYPE_BOOL:
 			jcol.Len = 1;
@@ -419,8 +420,8 @@ bool JSONDISC::Find(PGLOBAL g, PJVAL jvp, PCSZ key, int j)
 			break;
 		} // endswitch Type
 
-    jcol.Scale = vlp->Nd;
-    jcol.Cbn = vlp->Type == TYPE_NULL;
+    jcol.Scale = jvp->Nd;
+    jcol.Cbn = jvp->DataType == TYPE_NULL;
   } else if (!jvp || jvp->IsNull()) {
     jcol.Type = TYPE_UNKNOWN;
     jcol.Len = jcol.Scale = 0;
@@ -528,7 +529,7 @@ void JSONDISC::AddColumn(PGLOBAL g)
     if (jcp->Type != jcol.Type) {
       if (jcp->Type == TYPE_UNKNOWN)
         jcp->Type = jcol.Type;
-      else if (jcol.Type != TYPE_UNKNOWN)
+      else if (jcol.Type != TYPE_UNKNOWN && jcol.Type != TYPE_VOID)
         jcp->Type = TYPE_STRING;
 
     } // endif Type
@@ -1595,12 +1596,12 @@ PVAL JSONCOL::MakeJson(PGLOBAL g, PJSON jsp)
 /***********************************************************************/
 /*  SetValue: Set a value from a JVALUE contains.                      */
 /***********************************************************************/
-void JSONCOL::SetJsonValue(PGLOBAL g, PVAL vp, PJVAL val)
+void JSONCOL::SetJsonValue(PGLOBAL g, PVAL vp, PJVAL jvp)
 {
-  if (val) {
+  if (jvp) {
     vp->SetNull(false);
 
-    switch (val->GetValType()) {
+    switch (jvp->GetValType()) {
       case TYPE_STRG:
       case TYPE_INTG:
       case TYPE_BINT:
@@ -1609,21 +1610,21 @@ void JSONCOL::SetJsonValue(PGLOBAL g, PVAL vp, PJVAL val)
 				switch (vp->GetType()) {
 				case TYPE_STRING:
 				case TYPE_DATE:
-					vp->SetValue_psz(val->GetString(g));
+					vp->SetValue_psz(jvp->GetString(g));
 					break;
 				case TYPE_INT:
 				case TYPE_SHORT:
 				case TYPE_TINY:
-					vp->SetValue(val->GetInteger());
+					vp->SetValue(jvp->GetInteger());
 					break;
 				case TYPE_BIGINT:
-					vp->SetValue(val->GetBigint());
+					vp->SetValue(jvp->GetBigint());
 					break;
 				case TYPE_DOUBLE:
-					vp->SetValue(val->GetFloat());
+					vp->SetValue(jvp->GetFloat());
 
-					if (val->GetValType() == TYPE_DBL)
-						vp->SetPrec(val->Val->Nd);
+					if (jvp->GetValType() == TYPE_DBL)
+						vp->SetPrec(jvp->Nd);
 
 					break;
 				default:
@@ -1634,18 +1635,18 @@ void JSONCOL::SetJsonValue(PGLOBAL g, PVAL vp, PJVAL val)
         break;
       case TYPE_BOOL:
         if (vp->IsTypeNum())
-          vp->SetValue(val->GetInteger() ? 1 : 0);
+          vp->SetValue(jvp->GetInteger() ? 1 : 0);
         else
-          vp->SetValue_psz((PSZ)(val->GetInteger() ? "true" : "false"));
+          vp->SetValue_psz((PSZ)(jvp->GetInteger() ? "true" : "false"));
 
         break;
       case TYPE_JAR:
 //      SetJsonValue(g, vp, val->GetArray()->GetValue(0));
-				vp->SetValue_psz(val->GetArray()->GetText(g, NULL));
+				vp->SetValue_psz(jvp->GetArray()->GetText(g, NULL));
 				break;
       case TYPE_JOB:
 //      if (!vp->IsTypeNum() || !Strict) {
-          vp->SetValue_psz(val->GetObject()->GetText(g, NULL));
+          vp->SetValue_psz(jvp->GetObject()->GetText(g, NULL));
           break;
 //        } // endif Type
 
@@ -1808,9 +1809,9 @@ PVAL JSONCOL::CalculateArray(PGLOBAL g, PJAR arp, int n)
 
     if (!jvrp->IsNull() || (op == OP_CNC && GetJsonNull())) do {
       if (jvrp->IsNull()) {
-				jvrp->Val = AllocVal(g, TYPE_STRG);
-				jvrp->Val->Strp = PlugDup(g, GetJsonNull());
-				jvp = jvrp;
+				jvrp->Strp = PlugDup(g, GetJsonNull());
+        jvrp->DataType = TYPE_STRG;
+        jvp = jvrp;
       } else if (n < Nod - 1 && jvrp->GetJson()) {
         Tjp->NextSame = nextsame;
         jval.SetValue(g, GetColumnValue(g, jvrp->GetJson(), n + 1));
diff --git a/storage/connect/tabjson.h b/storage/connect/tabjson.h
index f5d7b3153b2..de5115a4e09 100644
--- a/storage/connect/tabjson.h
+++ b/storage/connect/tabjson.h
@@ -58,7 +58,7 @@ public:
 	// Members
 	JCOL    jcol;
 	PJCL    jcp, fjcp, pjcp;
-	PVL     vlp;
+//PVL     vlp;
 	PJDEF   tdp;
 	TDBJSN *tjnp;
 	PJTDB   tjsp;
diff --git a/storage/connect/tabrest.cpp b/storage/connect/tabrest.cpp
index ee3a289c2e3..ec8cd70cac3 100644
--- a/storage/connect/tabrest.cpp
+++ b/storage/connect/tabrest.cpp
@@ -1,8 +1,11 @@
 /************** tabrest C++ Program Source Code File (.CPP) ************/
-/* PROGRAM NAME: tabrest   Version 1.7                                 */
-/*  (C) Copyright to the author Olivier BERTRAND          2018 - 2019  */
+/* PROGRAM NAME: tabrest   Version 1.8                                 */
+/*  (C) Copyright to the author Olivier BERTRAND          2018 - 2020  */
 /*  This program is the REST Web API support for MariaDB.              */
 /*  When compiled without MARIADB defined, it is the EOM module code.  */
+/*  The way Connect handles NOSQL data returned by REST queries is     */
+/*  just by retrieving it as a file and then leave the existing data   */
+/*  type tables (JSON, XML or CSV) process it as usual.                */
 /***********************************************************************/
 
 /***********************************************************************/
@@ -78,7 +81,7 @@ PTABDEF __stdcall GetREST(PGLOBAL g, void *memp)
 #endif   // !MARIADB
 
 /***********************************************************************/
-/*  Xcurl: retrieve the REST answer by executing curl.                 */
+/*  Xcurl: retrieve the REST answer by executing cURL.                 */
 /***********************************************************************/
 int Xcurl(PGLOBAL g, PCSZ Http, PCSZ Uri, PCSZ filename)
 {
@@ -112,7 +115,7 @@ int Xcurl(PGLOBAL g, PCSZ Http, PCSZ Uri, PCSZ filename)
 } // end od Xcurl
 
 /***********************************************************************/
-/*  GetREST: get the external TABDEF from OEM module.                  */
+/*  GetREST: load the Rest lib and get the Rest function.              */
 /***********************************************************************/
 XGETREST GetRestFunction(PGLOBAL g)
 {