- Add the new BSON temporary type for testing

  modified:   storage/connect/CMakeLists.txt
  modified:   storage/connect/bson.cpp
  modified:   storage/connect/bson.h
  modified:   storage/connect/bsonudf.cpp
  modified:   storage/connect/bsonudf.h
  modified:   storage/connect/global.h
  modified:   storage/connect/json.cpp
  modified:   storage/connect/jsonudf.cpp
  modified:   storage/connect/mysql-test/connect/disabled.def
  modified:   storage/connect/mysql-test/connect/t/mongo_test.inc
  modified:   storage/connect/plugutil.cpp
  modified:   storage/connect/tabbson.cpp
  modified:   storage/connect/tabjson.cpp

storage/connect/CMakeLists.txt

@@ -80,6 +80,19 @@ ELSE(NOT UNIX)
   ENDIF()
 ENDIF(UNIX)
 
+#
+# BSON: this the new version of JSON that is temporarily included here for testing
+# When fully tested, it will replace the old support (and be renamed to JSON)
+#
+
+OPTION(CONNECT_WITH_BSON "Compile CONNECT storage engine with BSON support" ON)
+
+IF(CONNECT_WITH_BSON)
+  SET(CONNECT_SOURCES ${CONNECT_SOURCES} 
+  bson.cpp tabbson.cpp bsonudf.cpp bson.h tabbson.h bsonudf.h)
+  add_definitions(-DBSON_SUPPORT)
+ENDIF(CONNECT_WITH_BSON)
+
 
 #
 # VCT: the VEC format might be not supported in future versions

storage/connect/bson.cpp

@@ -544,9 +544,9 @@ void BDOC::ParseNumeric(int& i, PBVAL vlp)
     buf[n] = 0;
 
     if (has_dot || has_e) {
-      double dv = strtod(buf, NULL);
+      double dv = atof(buf);
 
-      if (nd > 5 || dv > FLT_MAX || dv < FLT_MIN) {
+      if (nd >= 6 || dv > FLT_MAX || dv < FLT_MIN) {
         double* dvp = (double*)PlugSubAlloc(G, NULL, sizeof(double));
 
         *dvp = dv;
@@ -557,7 +557,7 @@ void BDOC::ParseNumeric(int& i, PBVAL vlp)
         vlp->Type = TYPE_FLOAT;
       } // endif nd
 
-      vlp->Nd = nd;
+      vlp->Nd = MY_MIN(nd, 16);
     } else {
       longlong iv = strtoll(buf, NULL, 10);
 
@@ -765,6 +765,8 @@ bool BDOC::SerializeValue(PBVAL jvp)
     return jp->WriteStr(buf);
   case TYPE_NULL:
     return jp->WriteStr("null");
+  case TYPE_JVAL:
+    return SerializeValue(MVP(jvp->To_Val));
   default:
     return jp->WriteStr("???");   // TODO
   } // endswitch Type
@@ -793,7 +795,12 @@ void* BJSON::BsonSubAlloc(size_t size)
       "Not enough memory for request of %zd (used=%zd free=%zd)",
       size, pph->To_Free, pph->FreeBlk);
     xtrc(1, "BsonSubAlloc: %s\n", G->Message);
+
+    if (Throw)
       throw(1234);
+    else
+      return NULL;
+
   } /* endif size OS32 code */
 
   // Do the suballocation the simplest way
@@ -1066,7 +1073,7 @@ PBVAL BJSON::MergeObject(PBVAL bop1, PBVAL bop2)
 /***********************************************************************/
 /* Delete a value corresponding to the given key.                      */
 /***********************************************************************/
-void BJSON::DeleteKey(PBVAL bop, PCSZ key)
+bool BJSON::DeleteKey(PBVAL bop, PCSZ key)
 {
   CheckType(bop, TYPE_JOB);
   PBPR brp, pbrp = NULL;
@@ -1079,10 +1086,11 @@ void BJSON::DeleteKey(PBVAL bop, PCSZ key)
         bop->To_Val = brp->Vlp.Next;
 
       bop->Nd--;
-      break;
+      return true;;
     } else
       pbrp = brp;
 
+  return false;
 } // end of DeleteKey
 
 /***********************************************************************/
@@ -1247,7 +1255,7 @@ PSZ BJSON::GetArrayText(PGLOBAL g, PBVAL bap, PSTRG text)
 /***********************************************************************/
 /* Delete a Value from the Arrays Value list.                          */
 /***********************************************************************/
-void BJSON::DeleteValue(PBVAL bap, int n)
+bool BJSON::DeleteValue(PBVAL bap, int n)
 {
   CheckType(bap, TYPE_JAR);
   int   i = 0;
@@ -1261,10 +1269,11 @@ void BJSON::DeleteValue(PBVAL bap, int n)
         bap->To_Val = bvp->Next;
 
       bap->Nd--;
-        break;
+      return true;;
     } else
       pvp = bvp;
 
+  return false;
 } // end of DeleteValue
 
 /***********************************************************************/
@@ -1510,7 +1519,7 @@ double BJSON::GetDouble(PBVAL vp)
   } // endswitch Type
 
   return d;
-} // end of GetFloat
+} // end of GetDouble
 
 /***********************************************************************/
 /* Return the Value's String value.                                    */
@@ -1620,23 +1629,26 @@ PBVAL BJSON::SetValue(PBVAL vlp, PVAL valp)
       break;
     case TYPE_DOUBLE:
     case TYPE_DECIM:
-    vlp->Nd = (IsTypeNum(valp->GetType())) ? valp->GetValPrec() : 0;
+    { double d = valp->GetFloatValue();
+      int    nd = (IsTypeNum(valp->GetType())) ? valp->GetValPrec() : 0;
 
-    if (vlp->Nd <= 6) {
+      if (nd <= 6 && d >= FLT_MIN && d <= FLT_MAX) {
         vlp->F = (float)valp->GetFloatValue();
         vlp->Type = TYPE_FLOAT;
       } else {
-      double *dp = (double*)BsonSubAlloc(sizeof(double));
+        double* dp = (double*)BsonSubAlloc(sizeof(double));
 
-      *dp = valp->GetFloatValue();
+        *dp = d;
         vlp->To_Val = MOF(dp);
         vlp->Type = TYPE_DBL;
       } // endif Nd
 
-    break;
+      vlp->Nd = MY_MIN(nd, 16);
+    } break;
     case TYPE_TINY:
       vlp->B = valp->GetTinyValue() != 0;
       vlp->Type = TYPE_BOOL;
+      break;
     case TYPE_INT:
       vlp->N = valp->GetIntValue();
       vlp->Type = TYPE_INTG;
@@ -1702,16 +1714,44 @@ void BJSON::SetBigint(PBVAL vlp, longlong ll)
 /***********************************************************************/
 /* Set the Value's value as the given DOUBLE.                          */
 /***********************************************************************/
-void BJSON::SetFloat(PBVAL vlp, double f) {
-  vlp->F = (float)f;
-  vlp->Nd = 6;
-  vlp->Type = TYPE_FLOAT;
+void BJSON::SetFloat(PBVAL vlp, double d, int nd)
+{
+  double* dp = (double*)BsonSubAlloc(sizeof(double));
+
+  *dp = d;
+  vlp->To_Val = MOF(dp);
+  vlp->Nd = MY_MIN(nd, 16);
+  vlp->Type = TYPE_DBL;
 } // end of SetFloat
 
 /***********************************************************************/
+/* Set the Value's value as the given DOUBLE representation.                          */
+/***********************************************************************/
+void BJSON::SetFloat(PBVAL vlp, PSZ s)
+{
+  char  *p = strchr(s, '.');
+  int    nd = 0;
+  double d = atof(s);
+
+  if (p) {
+    for (++p; isdigit(*p); nd++, p++);
+    for (--p; *p == '0'; nd--, p--);
+  } // endif p
+
+  if (nd < 6 && d >= FLT_MIN && d <= FLT_MAX) {
+    vlp->F = (float)d;
+    vlp->Nd = nd;
+    vlp->Type = TYPE_FLOAT;
+  } else
+    SetFloat(vlp, d, nd);
+
+} // end of SetFloat
+
+ /***********************************************************************/
 /* Set the Value's value as the given string.                          */
 /***********************************************************************/
-void BJSON::SetString(PBVAL vlp, PSZ s, int ci) {
+void BJSON::SetString(PBVAL vlp, PSZ s, int ci)
+{
   vlp->To_Val = MOF(s);
   vlp->Nd = ci;
   vlp->Type = TYPE_STRG;
@@ -1720,7 +1760,8 @@ void BJSON::SetString(PBVAL vlp, PSZ s, int ci) {
 /***********************************************************************/
 /* True when its JSON or normal value is null.                         */
 /***********************************************************************/
-bool BJSON::IsValueNull(PBVAL vlp) {
+bool BJSON::IsValueNull(PBVAL vlp)
+{
   bool b;
 
   switch (vlp->Type) {

storage/connect/bson.h

@@ -62,7 +62,8 @@ DllExport bool IsNum(PSZ s);
 class BJSON : public BLOCK {
 public:
 	// Constructor
-	BJSON(PGLOBAL g, PBVAL vp = NULL) { G = g, Base = G->Sarea; Bvp = vp; }
+	BJSON(PGLOBAL g, PBVAL vp = NULL)
+	  { G = g, Base = G->Sarea; Bvp = vp; Throw = true; }
 
 	// Utility functions
 	inline OFFSET   MOF(void  *p) {return MakeOff(Base, p);}
@@ -73,6 +74,7 @@ class BJSON : public BLOCK {
 	inline longlong LLN(OFFSET o) {return *(longlong*)MakePtr(Base, o);}
 	inline double   DBL(OFFSET o) {return *(double*)MakePtr(Base, o);}
 
+	void  Reset(void) {Base = G->Sarea;}
 	void* GetBase(void) { return Base; }
 	void  SubSet(bool b = false);
 	void  MemSave(void) {G->Saved_Size = ((PPOOLHEADER)G->Sarea)->To_Free;}
@@ -102,7 +104,7 @@ class BJSON : public BLOCK {
 	PBVAL GetArrayValue(PBVAL bap, int i);
   PSZ   GetArrayText(PGLOBAL g, PBVAL bap, PSTRG text);
 	void  MergeArray(PBVAL bap1,PBVAL bap2);
-	void  DeleteValue(PBVAL bap, int n);
+	bool  DeleteValue(PBVAL bap, int n);
 	void  AddArrayValue(PBVAL bap, OFFSET nvp = NULL, int* x = NULL);
 	inline void AddArrayValue(PBVAL bap, PBVAL nvp = NULL, int* x = NULL)
 				{AddArrayValue(bap, MOF(nvp), x);}
@@ -126,7 +128,7 @@ class BJSON : public BLOCK {
 	void  SetKeyValue(PBVAL bop, OFFSET bvp, PSZ key);
 	inline void SetKeyValue(PBVAL bop, PBVAL vlp, PSZ key)
 				{SetKeyValue(bop, MOF(vlp), key);}
-	void  DeleteKey(PBVAL bop, PCSZ k);
+	bool  DeleteKey(PBVAL bop, PCSZ k);
 	bool  IsObjectNull(PBVAL bop);
 
 	// Value functions
@@ -147,17 +149,20 @@ class BJSON : public BLOCK {
 	void  SetString(PBVAL vlp, PSZ s, int ci = 0);
 	void  SetInteger(PBVAL vlp, int n);
 	void  SetBigint(PBVAL vlp, longlong ll);
-	void  SetFloat(PBVAL vlp, double f);
+	void  SetFloat(PBVAL vlp, double f, int nd = 16);
+	void  SetFloat(PBVAL vlp, PSZ s);
 	void  SetBool(PBVAL vlp, bool b);
 	void  Clear(PBVAL vlp) { vlp->N = 0; vlp->Nd = 0; vlp->Next = 0; }
 	bool  IsValueNull(PBVAL vlp);
-	bool  IsJson(PBVAL vlp) 
-				{return vlp ? vlp->Type == TYPE_JAR || vlp->Type == TYPE_JOB : false;}
+	bool  IsJson(PBVAL vlp)	{return vlp ? vlp->Type == TYPE_JAR ||
+		                                    vlp->Type == TYPE_JOB ||
+		                                    vlp->Type == TYPE_JVAL : false;}
 
 	// Members
 	PGLOBAL G;
 	PBVAL   Bvp;
 	void   *Base;
+	bool    Throw;
 
 protected:
 	// Default constructor not to be used

storage/connect/bsonudf.h

 /******************** tabjson H Declares Source Code File (.H) *******************/
 /*  Name: bsonudf.h   Version 1.0                                                */
 /*                                                                               */
-/*  (C) Copyright to the author Olivier BERTRAND          2020                   */
+/*  (C) Copyright to the author Olivier BERTRAND          2020 - 2021            */
 /*                                                                               */
 /*  This file contains the BSON UDF function and class declares.                 */
 /*********************************************************************************/
@@ -96,6 +96,7 @@ class BJNX : public BDOC {
 	int     GetPrecision(void) { return Prec; }
 	PVAL    GetValue(void) { return Value; }
 	void    SetRow(PBVAL vp) { Row = vp; }
+	void    SetChanged(my_bool b) { Changed = b; }
 
 	// Methods
 	my_bool SetJpath(PGLOBAL g, char* path, my_bool jb = false);
@@ -106,14 +107,16 @@ class BJNX : public BDOC {
 	my_bool CheckPath(PGLOBAL g);
 	my_bool CheckPath(PGLOBAL g, UDF_ARGS* args, PBVAL jsp, PBVAL& jvp, int n);
 	my_bool WriteValue(PGLOBAL g, PBVAL jvalp);
+	my_bool DeleteItem(PGLOBAL g, PBVAL vlp);
 	char   *Locate(PGLOBAL g, PBVAL jsp, PBVAL jvp, int k = 1);
 	char   *LocateAll(PGLOBAL g, PBVAL jsp, PBVAL jvp, int mx = 10);
 	PSZ     MakeKey(UDF_ARGS* args, int i);
-	PBVAL   MakeBinValue(PGLOBAL g, UDF_ARGS* args, uint i);
-	PBVAL   MakeValue(PGLOBAL g, UDF_ARGS* args, uint i, PBVAL* top = NULL);
+	PBVAL   MakeValue(UDF_ARGS* args, uint i, bool b = false, PBVAL* top = NULL);
 	PBVAL   MakeTypedValue(PGLOBAL g, UDF_ARGS* args, uint i,
 		                     JTYP type, PBVAL* top = NULL);
 	PBVAL   ParseJsonFile(PGLOBAL g, char* fn, int& pty, size_t& len);
+	char   *MakeResult(UDF_ARGS* args, PBVAL top, uint n = 2);
+	PBSON   MakeBinResult(PGLOBAL g, UDF_ARGS* args, PBVAL top, ulong len, int n = 2);
 
 protected:
 	my_bool SetArrayOptions(PGLOBAL g, char* p, int i, PSZ nm);
@@ -159,6 +162,7 @@ class BJNX : public BDOC {
 	my_bool  Found;								// Item found by locate
 	my_bool  Wr;			  					// Write mode
 	my_bool  Jb;			  					// Must return json item
+	my_bool  Changed;			  			// True when contains was modified
 }; // end of class BJNX
 
 extern "C" {
@@ -268,6 +272,10 @@ extern "C" {
 	DllExport char *bson_object_grp(UDF_EXEC_ARGS);
 	DllExport void bson_object_grp_deinit(UDF_INIT*);
 
+	DllExport my_bool bson_delete_item_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport char *bson_delete_item(UDF_EXEC_ARGS);
+	DllExport void bson_delete_item_deinit(UDF_INIT*);
+
 	DllExport my_bool bson_set_item_init(UDF_INIT*, UDF_ARGS*, char*);
 	DllExport char *bson_set_item(UDF_EXEC_ARGS);
 	DllExport void bson_set_item_deinit(UDF_INIT*);
@@ -295,4 +303,92 @@ extern "C" {
 	DllExport my_bool bfile_bjson_init(UDF_INIT*, UDF_ARGS*, char*);
 	DllExport char* bfile_bjson(UDF_EXEC_ARGS);
 	DllExport void bfile_bjson_deinit(UDF_INIT*);
+
+	DllExport my_bool bson_serialize_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport char *bson_serialize(UDF_EXEC_ARGS);
+	DllExport void bson_serialize_deinit(UDF_INIT*);
+
+	DllExport my_bool bbin_make_array_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport char* bbin_make_array(UDF_EXEC_ARGS);
+	DllExport void bbin_make_array_deinit(UDF_INIT*);
+
+	DllExport my_bool bbin_array_add_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport char* bbin_array_add(UDF_EXEC_ARGS);
+	DllExport void bbin_array_add_deinit(UDF_INIT*);
+
+	DllExport my_bool bbin_array_add_values_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport char* bbin_array_add_values(UDF_EXEC_ARGS);
+	DllExport void bbin_array_add_values_deinit(UDF_INIT*);
+
+	DllExport my_bool bbin_array_delete_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport char* bbin_array_delete(UDF_EXEC_ARGS);
+	DllExport void bbin_array_delete_deinit(UDF_INIT*);
+
+	DllExport my_bool bbin_array_grp_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport void bbin_array_grp_clear(UDF_INIT *, char *, char *);
+	DllExport void bbin_array_grp_add(UDF_INIT *, UDF_ARGS *, char *, char *);
+	DllExport char *bbin_array_grp(UDF_EXEC_ARGS);
+	DllExport void bbin_array_grp_deinit(UDF_INIT*);
+
+	DllExport my_bool bbin_object_grp_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport void bbin_object_grp_clear(UDF_INIT *, char *, char *);
+	DllExport void bbin_object_grp_add(UDF_INIT *, UDF_ARGS *, char *, char *);
+	DllExport char *bbin_object_grp(UDF_EXEC_ARGS);
+	DllExport void bbin_object_grp_deinit(UDF_INIT*);
+
+	DllExport my_bool bbin_make_object_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport char* bbin_make_object(UDF_EXEC_ARGS);
+	DllExport void bbin_make_object_deinit(UDF_INIT*);
+
+	DllExport my_bool bbin_object_nonull_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport char* bbin_object_nonull(UDF_EXEC_ARGS);
+	DllExport void bbin_object_nonull_deinit(UDF_INIT*);
+
+	DllExport my_bool bbin_object_key_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport char* bbin_object_key(UDF_EXEC_ARGS);
+	DllExport void bbin_object_key_deinit(UDF_INIT*);
+
+	DllExport my_bool bbin_object_add_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport char *bbin_object_add(UDF_EXEC_ARGS);
+	DllExport void bbin_object_add_deinit(UDF_INIT*);
+
+	DllExport my_bool bbin_object_delete_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport char *bbin_object_delete(UDF_EXEC_ARGS);
+	DllExport void bbin_object_delete_deinit(UDF_INIT*);
+
+	DllExport my_bool bbin_object_list_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport char *bbin_object_list(UDF_EXEC_ARGS);
+	DllExport void bbin_object_list_deinit(UDF_INIT*);
+
+	DllExport my_bool bbin_object_values_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport char* bbin_object_values(UDF_EXEC_ARGS);
+	DllExport void bbin_object_values_deinit(UDF_INIT*);
+
+	DllExport my_bool bbin_get_item_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport char *bbin_get_item(UDF_EXEC_ARGS);
+	DllExport void bbin_get_item_deinit(UDF_INIT*);
+
+	DllExport my_bool bbin_set_item_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport char *bbin_set_item(UDF_EXEC_ARGS);
+	DllExport void bbin_set_item_deinit(UDF_INIT*);
+
+	DllExport my_bool bbin_insert_item_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport char *bbin_insert_item(UDF_EXEC_ARGS);
+	DllExport void bbin_insert_item_deinit(UDF_INIT*);
+
+	DllExport my_bool bbin_update_item_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport char *bbin_update_item(UDF_EXEC_ARGS);
+	DllExport void bbin_update_item_deinit(UDF_INIT*);
+
+	DllExport my_bool bbin_delete_item_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport char *bbin_delete_item(UDF_EXEC_ARGS);
+	DllExport void bbin_delete_item_deinit(UDF_INIT*);
+
+	DllExport my_bool bbin_locate_all_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport char* bbin_locate_all(UDF_EXEC_ARGS);
+	DllExport void bbin_locate_all_deinit(UDF_INIT*);
+
+	DllExport my_bool bbin_file_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport char *bbin_file(UDF_EXEC_ARGS);
+	DllExport void bbin_file_deinit(UDF_INIT*);
 } // extern "C"

storage/connect/global.h

@@ -185,7 +185,7 @@ typedef struct _global {            /* Global structure                */
   size_t    Sarea_Size;             /* Work area size                  */
 	PACTIVITY Activityp;
   char      Message[MAX_STR];				/* Message (result, error, trace)  */
-	ulong     More;										/* Used by jsonudf                 */
+	size_t    More;										/* Used by jsonudf                 */
 	size_t    Saved_Size;             /* Saved work area to_free         */
 	bool      Createas;               /* To pass multi to ext tables     */
   void     *Xchk;                   /* indexes in create/alter         */

storage/connect/json.cpp

@@ -333,7 +333,9 @@ bool JOUTSTR::WriteChr(const char c) {
 /***********************************************************************/
 /* Escape and Concatenate a string to the Serialize string.            */
 /***********************************************************************/
-bool JOUTSTR::Escape(const char* s) {
+bool JOUTSTR::Escape(const char* s)
+{
+  if (s) {
     WriteChr('"');
 
     for (unsigned int i = 0; s[i]; i++)
@@ -352,6 +354,9 @@ bool JOUTSTR::Escape(const char* s) {
       } // endswitch s[i]
 
     WriteChr('"');
+  } else
+    WriteStr("null");
+
   return false;
 } // end of Escape
 
@@ -360,7 +365,8 @@ bool JOUTSTR::Escape(const char* s) {
 /***********************************************************************/
 /* Write a string to the Serialize file.                               */
 /***********************************************************************/
-bool JOUTFILE::WriteStr(const char* s) {
+bool JOUTFILE::WriteStr(const char* s)
+{
   // This is temporary
   fputs(s, Stream);
   return false;
@@ -369,7 +375,8 @@ bool JOUTFILE::WriteStr(const char* s) {
 /***********************************************************************/
 /* Write a character to the Serialize file.                            */
 /***********************************************************************/
-bool JOUTFILE::WriteChr(const char c) {
+bool JOUTFILE::WriteChr(const char c)
+{
   // This is temporary
   fputc(c, Stream);
   return false;
@@ -378,8 +385,10 @@ bool JOUTFILE::WriteChr(const char c) {
 /***********************************************************************/
 /* Escape and Concatenate a string to the Serialize string.            */
 /***********************************************************************/
-bool JOUTFILE::Escape(const char* s) {
+bool JOUTFILE::Escape(const char* s)
+{
   // This is temporary
+  if (s) {
     fputc('"', Stream);
 
     for (unsigned int i = 0; s[i]; i++)
@@ -397,6 +406,9 @@ bool JOUTFILE::Escape(const char* s) {
       } // endswitch s[i]
 
     fputc('"', Stream);
+  } else
+    fputs("null", Stream);
+
   return false;
 } // end of Escape
 
@@ -405,7 +417,8 @@ bool JOUTFILE::Escape(const char* s) {
 /***********************************************************************/
 /* Write a string to the Serialize pretty file.                        */
 /***********************************************************************/
-bool JOUTPRT::WriteStr(const char* s) {
+bool JOUTPRT::WriteStr(const char* s)
+{
   // This is temporary
   if (B) {
     fputs(EL, Stream);
@@ -424,7 +437,8 @@ bool JOUTPRT::WriteStr(const char* s) {
 /***********************************************************************/
 /* Write a character to the Serialize pretty file.                     */
 /***********************************************************************/
-bool JOUTPRT::WriteChr(const char c) {
+bool JOUTPRT::WriteChr(const char c)
+{
   switch (c) {
   case ':':
     fputs(": ", Stream);

storage/connect/jsonudf.cpp

@@ -1155,7 +1155,7 @@ PBSON JbinAlloc(PGLOBAL g, UDF_ARGS *args, ulong len, PJSON jsp)
 /*********************************************************************************/
 /*  Set the BSON chain as changed.                                               */
 /*********************************************************************************/
-static void SetChanged(PBSON bsp)
+void SetChanged(PBSON bsp)
 {
 	if (bsp->Bsp)
 		SetChanged(bsp->Bsp);

storage/connect/mysql-test/connect/disabled.def

@@ -16,9 +16,12 @@ jdbc_postgresql : Variable settings depend on machine configuration
 json_mongo_c    : Need MongoDB running and its C Driver installed
 json_java_2     : Need MongoDB running and its Java Driver installed
 json_java_3     : Need MongoDB running and its Java Driver installed
+bson_mongo_c    : Need MongoDB running and its C Driver installed
+bson_java_2     : Need MongoDB running and its Java Driver installed
+bson_java_3     : Need MongoDB running and its Java Driver installed
 mongo_c         : Need MongoDB running and its C Driver installed
 mongo_java_2    : Need MongoDB running and its Java Driver installed
 mongo_java_3    : Need MongoDB running and its Java Driver installed
 tbl_thread      : Bug MDEV-9844,10179,14214 03/01/2018 OB Option THREAD removed
-bson            : Development
+#bson            : Development
 #vcol            : Different error code on different versions

storage/connect/mysql-test/connect/t/bson_java_2.test

+-- source jdbconn.inc
+-- source mongo.inc
+
+--disable_query_log
+eval SET GLOBAL connect_class_path='$MTR_SUITE_DIR/std_data/Mongo2.jar';
+set connect_json_all_path=0;
+--enable_query_log
+let $DRV= Java;
+let $VERS= 2;
+let $TYPE= BSON;
+let $CONN= CONNECTION='mongodb://localhost:27017' LRECL=4096;
+
+-- source mongo_test.inc
+-- source jdbconn_cleanup.inc

storage/connect/mysql-test/connect/t/bson_java_3.test

+-- source jdbconn.inc
+-- source mongo.inc
+
+--disable_query_log
+eval SET GLOBAL connect_class_path='$MTR_SUITE_DIR/std_data/Mongo3.jar';
+set connect_json_all_path=0;
+--enable_query_log
+let $DRV= Java;
+let $VERS= 3;
+let $TYPE= BSON;
+let $CONN= CONNECTION='mongodb://localhost:27017' LRECL=4096;
+
+-- source mongo_test.inc
+-- source jdbconn_cleanup.inc

storage/connect/mysql-test/connect/t/bson_mongo_c.test

+-- source mongo.inc
+
+let $DRV= C;
+let $VERS= 0;
+let $PROJ= {"projection":;
+let $ENDP= };
+let $TYPE= BSON;
+let $CONN= CONNECTION='mongodb://localhost:27017' LRECL=1024;
+
+-- source mongo_test.inc

storage/connect/mysql-test/connect/t/mongo_test.inc

@@ -126,6 +126,10 @@ IF ($TYPE == JSON)
 {
 SELECT name, borough, address_street, grades_score AS score FROM t1 WHERE grades_grade = 'B';
 }
+IF ($TYPE == BSON)
+{
+SELECT name, borough, address_street, grades_score AS score FROM t1 WHERE grades_grade = 'B';
+}
 DROP TABLE t1;
 
 --echo #

storage/connect/plugutil.cpp

@@ -474,8 +474,10 @@ bool AllocSarea(PGLOBAL g, size_t size)
 	if (!g->Sarea) {
 		sprintf(g->Message, MSG(MALLOC_ERROR), "malloc");
 		g->Sarea_Size = 0;
-	}	else
+	}	else {
     g->Sarea_Size = size;
+    PlugSubSet(g->Sarea, size);
+  } // endif Sarea
 
 #if defined(DEVELOPMENT)
 	if (true) {
@@ -484,7 +486,6 @@ bool AllocSarea(PGLOBAL g, size_t size)
 #endif
     if (g->Sarea) {
       htrc("Work area of %zd allocated at %p\n", size, g->Sarea);
-      PlugSubSet(g->Sarea, size);
     } else
       htrc("SareaAlloc: %s\n", g->Message);
 
@@ -624,7 +625,7 @@ size_t MakeOff(void* memp, void* ptr)
 #if defined(_DEBUG) || defined(DEVELOPMENT)
     if (ptr <= memp) {
       fprintf(stderr, "ptr %p <= memp %p", ptr, memp);
-      throw 999;
+      DoThrow(999);
     } // endif ptr
 #endif   // _DEBUG  ||         DEVELOPMENT
     return (size_t)((char*)ptr - (size_t)memp);
@@ -633,4 +634,4 @@ size_t MakeOff(void* memp, void* ptr)
 
 } /* end of MakeOff */
 
-  /*--------------------- End of PLUGUTIL program -----------------------*/
+/*---------------------- End of PLUGUTIL program ------------------------*/

storage/connect/tabbson.cpp

@@ -246,7 +246,8 @@ int BSONDISC::GetColumns(PGLOBAL g, PCSZ db, PCSZ dsn, PTOS topt)
       return 0;
 
     bp = tjsp->Bp;
-    bdp = tjsp->GetDoc() ? bp->GetBson(tjsp->GetDoc()) : NULL;
+//  bdp = tjsp->GetDoc() ? bp->GetBson(tjsp->GetDoc()) : NULL;
+    bdp = tjsp->GetDoc();
     jsp = bdp ? bp->GetArrayValue(bdp, 0) : NULL;
   } else {
     if (!((tdp->Lrecl = GetIntegerTableOption(g, topt, "Lrecl", 0)))) {
@@ -312,7 +313,7 @@ int BSONDISC::GetColumns(PGLOBAL g, PCSZ db, PCSZ dsn, PTOS topt)
     case RC_FX:
       goto err;
     default:
-      jsp = bp->FindRow(g);
+      jsp = tjnp->Row;
     } // endswitch ReadDB
 
   } // endif pretty
@@ -362,7 +363,7 @@ int BSONDISC::GetColumns(PGLOBAL g, PCSZ db, PCSZ dsn, PTOS topt)
       case RC_FX:
         goto err;
       default:
-        jsp = bp->FindRow(g);
+        jsp = tjnp->Row;
       } // endswitch ReadDB
 
     } else
@@ -406,8 +407,12 @@ bool BSONDISC::Find(PGLOBAL g, PBVAL jvp, PCSZ key, int j)
         break;
       case TYPE_INTG:
       case TYPE_BINT:
+        jcol.Len = (int)strlen(bp->GetString(jvp, buf));
+        break;
       case TYPE_DBL:
+      case TYPE_FLOAT:
         jcol.Len = (int)strlen(bp->GetString(jvp, buf));
+        jcol.Scale = jvp->Nd;
         break;
       case TYPE_BOOL:
         jcol.Len = 1;
@@ -513,7 +518,8 @@ bool BSONDISC::Find(PGLOBAL g, PBVAL jvp, PCSZ key, int j)
   return false;
 } // end of Find
 
-void BSONDISC::AddColumn(PGLOBAL g) {
+void BSONDISC::AddColumn(PGLOBAL g)
+{
   bool b = fmt[bf] != 0;     // True if formatted
 
   // Check whether this column was already found

storage/connect/tabjson.cpp

@@ -310,7 +310,8 @@ int JSONDISC::GetColumns(PGLOBAL g, PCSZ db, PCSZ dsn, PTOS topt)
     case RC_FX:
       goto err;
     default:
-      jsp = tjnp->FindRow(g);
+//    jsp = tjnp->FindRow(g);    // FindRow was done in ReadDB
+      jsp = tjnp->Row;
     } // endswitch ReadDB
 
   } // endif pretty
@@ -360,7 +361,8 @@ int JSONDISC::GetColumns(PGLOBAL g, PCSZ db, PCSZ dsn, PTOS topt)
       case RC_FX:
         goto err;
       default:
-        jsp = tjnp->FindRow(g);
+//      jsp = tjnp->FindRow(g);
+        jsp = tjnp->Row;
       } // endswitch ReadDB
 
     } else