Merge branch 'ob-10.1' into 10.1

storage/connect/CMakeLists.txt

@@ -245,13 +245,10 @@ int main() {
 ENDIF(CONNECT_WITH_ODBC)
 
 #
-# JDBC
+# JDBC without MongoDB Java Driver
 #
-IF(APPLE)
-  OPTION(CONNECT_WITH_JDBC "Compile CONNECT storage engine without JDBC support" OFF)
-ELSE()
-  OPTION(CONNECT_WITH_JDBC "Compile CONNECT storage engine with JDBC support" ON)
-ENDIF()
+# OPTION(CONNECT_WITH_MONGO "Compile CONNECT storage engine with MONGO support" ON)
+OPTION(CONNECT_WITH_JDBC "Compile CONNECT storage engine with JDBC support" ON)
 
 IF(CONNECT_WITH_JDBC)
   FIND_PACKAGE(Java 1.6)
@@ -262,7 +259,8 @@ IF(CONNECT_WITH_JDBC)
     INCLUDE_DIRECTORIES(${JAVA_INCLUDE_PATH2})
     # SET(JDBC_LIBRARY ${JAVA_JVM_LIBRARY}) will be dynamically linked
     SET(CONNECT_SOURCES ${CONNECT_SOURCES}
-    jdbconn.cpp tabjdbc.cpp jdbconn.h tabjdbc.h jdbccat.h
+    javaconn.cpp jdbconn.cpp tabjdbc.cpp
+    jdbccat.h javaconn.h jdbconn.h tabjdbc.h
     JdbcInterface.java ApacheInterface.java MariadbInterface.java
     MysqlInterface.java OracleInterface.java PostgresqlInterface.java
     JavaWrappers.jar)
@@ -274,6 +272,13 @@ IF(CONNECT_WITH_JDBC)
     INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/JavaWrappers.jar
       DESTINATION ${INSTALL_PLUGINDIR} COMPONENT connect-engine)
     add_definitions(-DJDBC_SUPPORT)
+    IF(CONNECT_WITH_MONGO)
+      SET(CONNECT_SOURCES ${CONNECT_SOURCES}
+      jmgfam.cpp jmgoconn.cpp mongo.cpp tabjmg.cpp
+      jmgfam.h jmgoconn.h mongo.h tabjmg.h
+      Mongo2Interface.java Mongo3Interface.java)
+      add_definitions(-DMONGO_SUPPORT)
+    ENDIF()
   ELSE()
     SET(JDBC_LIBRARY "")
   ENDIF()
@@ -292,27 +297,31 @@ IF(CONNECT_WITH_ZIP)
 ENDIF(CONNECT_WITH_ZIP)
 
 #
-# MONGO (CMAKE NOT YET WORKING)
+# MONGO C Driver (CMAKE NOT YET WORKING)
 #
 
-#OPTION(CONNECT_WITH_MONGO "Compile CONNECT storage engine with MONGO support" ON)
-
 #IF(CONNECT_WITH_MONGO)
 #  IF(WIN32)
 #    # Adding some typical places to search in
 #    SET(PC_MONGO_INCLUDE_DIRS
 #        C:/mongo-c-driver/include
-#				D:/mongo-c-driver/include)
+#        D:/mongo-c-driver/include)
 #    SET(PC_MONGO_LIBRARY_DIRS
 #        C:/mongo-c-driver/lib
-#				D:/mongo-c-driver/lib)
+#        D:/mongo-c-driver/lib)
 #  ENDIF(WIN32)
-#  FIND_PACKAGE(libmongoc)
+#  FIND_PACKAGE(libmongoc 1.7)
 #  IF (MONGO_FOUND)
 #    INCLUDE_DIRECTORIES(${MONGO_INCLUDE_DIR})
 #    SET(MONGO_LIBRARY   ${MONGO_LIBRARIES})
-#    SET(CONNECT_SOURCES ${CONNECT_SOURCES} mongofam.cpp mongofam.h)
-#    add_definitions(-DMONGO_SUPPORT)
+#    SET(CONNECT_SOURCES ${CONNECT_SOURCES}
+#    cmgoconn.cpp cmgfam.cpp tabcmg.cpp
+#    cmgoconn.h cmgfam.h tabcmg.h)
+#    add_definitions(-DCMGO_SUPPORT)
+#    IF (NOT JAVA_FOUND AND JNI_FOUND)
+#      SET(CONNECT_SOURCES ${CONNECT_SOURCES} mongo.cpp mongo.h)
+#      add_definitions(-DMONGO_SUPPORT)
+#    ENDIF (NOT JAVA_FOUND AND JNI_FOUND)
 #  ENDIF(MONGO_FOUND)
 #ENDIF(CONNECT_WITH_MONGO)
 
@@ -339,3 +348,4 @@ MYSQL_ADD_PLUGIN(connect ${CONNECT_SOURCES}
   LINK_LIBRARIES ${ZLIB_LIBRARY} ${XML_LIBRARY} ${ICONV_LIBRARY}
                  ${ODBC_LIBRARY} ${JDBC_LIBRARY} ${IPHLPAPI_LIBRARY})
 
+

storage/connect/Mongo2Interface.java

+package wrappers;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Set;
+
+import com.mongodb.AggregationOptions;
+import com.mongodb.BasicDBList;
+import com.mongodb.BasicDBObject;
+import com.mongodb.Cursor;
+import com.mongodb.DB;
+import com.mongodb.DBCollection;
+import com.mongodb.DBObject;
+import com.mongodb.MongoClient;
+import com.mongodb.MongoClientURI;
+import com.mongodb.MongoException;
+import com.mongodb.WriteConcernException;
+import com.mongodb.WriteResult;
+import com.mongodb.util.JSON;
+
+public class Mongo2Interface {
+	boolean DEBUG = false;
+	String Errmsg = "No error";
+	Set<String> Colnames = null;
+	Cursor cursor = null;
+	MongoClient client = null;
+	DB db = null;
+	DBCollection coll = null;
+	BasicDBObject doc = null;
+	BasicDBObject dbq = null;
+	BasicDBObject dbf = null;
+	List<DBObject> pip = null;
+	AggregationOptions aop = null;
+
+	// === Constructors/finalize =========================================
+	public Mongo2Interface() {
+		this(false);
+	} // end of default constructor
+
+	public Mongo2Interface(boolean b) {
+		DEBUG = b;
+	} // end of constructor
+
+	protected void SetErrmsg(String str) {
+		if (DEBUG)
+			System.out.println(str);
+
+		Errmsg = str;
+	} // end of SetErrmsg
+
+	protected void SetErrmsg(Exception e) {
+		if (DEBUG)
+			System.out.println(e.getMessage());
+
+		Errmsg = e.toString();
+	} // end of SetErrmsg
+
+	public String GetErrmsg() {
+		String err = Errmsg;
+
+		Errmsg = "No error";
+		return err;
+	} // end of GetErrmsg
+
+	public int MongoConnect(String[] parms) {
+		int rc = 0;
+
+		if (DEBUG)
+			System.out.println("Mongo2: URI=" + parms[0] + " DB=" + parms[1]);
+
+		try {
+			MongoClientURI uri = new MongoClientURI(parms[0]);
+
+			client = new MongoClient(uri);
+
+			if (DEBUG)
+				System.out.println("Connection " + client.toString() + " established");
+
+			// Now connect to your databases
+			db = client.getDB(parms[1]);
+
+			if (parms[2] != null && !parms[2].isEmpty()) {
+				if (DEBUG)
+					System.out.println("user=" + parms[2] + " pwd=" + parms[3]);
+
+				@SuppressWarnings("deprecation")
+				boolean auth = db.authenticate(parms[2], parms[3].toCharArray());
+
+				if (DEBUG)
+					System.out.println("Authentication: " + auth);
+
+			} // endif user
+
+		} catch (MongoException me) {
+			SetErrmsg(me);
+			rc = -1;
+		} catch (Exception e) {
+			SetErrmsg(e);
+			rc = -3;
+		} // end try/catch
+
+		return rc;
+	} // end of MongoConnect
+
+	public int MongoDisconnect() {
+		int rc = 0;
+
+		try {
+			if (cursor != null) {
+				if (DEBUG)
+					System.out.println("Closing cursor");
+
+				cursor.close();
+				cursor = null;
+			} // endif client
+
+			if (client != null) {
+				if (DEBUG)
+					System.out.println("Closing connection");
+
+				client.close();
+				client = null;
+			} // endif client
+
+		} catch (MongoException se) {
+			SetErrmsg(se);
+			rc += 8;
+		} // end try/catch
+
+		return rc;
+	} // end of MongoDisconnect
+
+	public boolean GetCollection(String name) {
+		if (DEBUG)
+			System.out.println("GetCollection: name=" + name);
+
+		try {
+			coll = db.getCollection(name);
+		} catch (Exception e) {
+			SetErrmsg(e);
+			return true;
+		} // end try/catch
+
+		return false;
+	} // end of GetCollection
+
+	public long GetCollSize() {
+		return (coll != null) ? coll.count() : 0;
+	} // end of GetCollSize
+
+	public boolean FindColl(String query, String fields) {
+		if (DEBUG)
+			System.out.println("FindColl: query=" + query + " fields=" + fields);
+
+		try {
+			if (query != null || fields != null) {
+				dbq = (BasicDBObject) JSON.parse((query != null) ? query : "{}");
+
+				if (fields != null) {
+					dbf = (BasicDBObject) JSON.parse(fields);
+					cursor = coll.find(dbq, dbf);
+				} else
+					cursor = coll.find(dbq);
+
+			} else
+				cursor = coll.find();
+
+		} catch (Exception e) {
+			SetErrmsg(e);
+			return true;
+		} // end try/catch
+
+		return false;
+	} // end of FindColl
+
+	@SuppressWarnings("unchecked")
+	public boolean AggregateColl(String pipeline) {
+		if (DEBUG)
+			System.out.println("AggregateColl: pipeline=" + pipeline);
+
+		try {
+			DBObject pipe = (DBObject) JSON.parse(pipeline);
+
+			pip = (List<DBObject>) pipe.get("pipeline");
+			aop = AggregationOptions.builder().batchSize(0).allowDiskUse(true)
+					.outputMode(AggregationOptions.OutputMode.CURSOR).build();
+			cursor = coll.aggregate(pip, aop);
+		} catch (MongoException me) {
+			SetErrmsg(me);
+			return true;
+		} // end try/catch
+
+		return false;
+	} // end of AggregateColl
+
+	public boolean Rewind() {
+		if (cursor != null)
+			cursor.close();
+
+		if (pip == null) {
+			if (dbf != null)
+				cursor = coll.find(dbq, dbf);
+			else if (dbq != null)
+				cursor = coll.find(dbq);
+			else
+				cursor = coll.find();
+
+		} else
+			cursor = coll.aggregate(pip, aop);
+
+		return (cursor == null);
+	} // end of Rewind
+
+	public int ReadNext() {
+		try {
+			if (cursor.hasNext()) {
+				doc = (BasicDBObject) cursor.next();
+
+				if (DEBUG)
+					System.out.println("Class doc = " + doc.getClass());
+
+				Colnames = doc.keySet();
+				return 1;
+			} else
+				return 0;
+
+		} catch (MongoException me) {
+			SetErrmsg(me);
+			return -1;
+		} // end try/catch
+
+	} // end of ReadNext
+
+	public boolean Fetch(int row) {
+		if (cursor.hasNext()) {
+			doc = (BasicDBObject) cursor.next();
+			Colnames = doc.keySet();
+			return true;
+		} else
+			return false;
+
+	} // end of Fetch
+
+	public String GetDoc() {
+		return (doc != null) ? doc.toString() : null;
+	} // end of GetDoc
+
+	public Set<String> GetColumns() {
+		if (doc != null)
+			return doc.keySet();
+		else
+			return null;
+
+	} // end of GetColumns
+
+	public String ColumnDesc(int n, int[] val) {
+		// if (rsmd == null) {
+		// System.out.println("No result metadata");
+		// return null;
+		// } else try {
+		// val[0] = rsmd.getColumnType(n);
+		// val[1] = rsmd.getPrecision(n);
+		// val[2] = rsmd.getScale(n);
+		// val[3] = rsmd.isNullable(n);
+		// return rsmd.getColumnLabel(n);
+		// } catch (SQLException se) {
+		// SetErrmsg(se);
+		// } //end try/catch
+
+		return null;
+	} // end of ColumnDesc
+
+	protected Object GetFieldObject(String path) {
+		Object o = null;
+		BasicDBObject dob = null;
+		BasicDBList lst = null;
+		String[] names = null;
+
+		if (path == null || path.equals("*"))
+			return doc;
+		else if (doc instanceof BasicDBObject)
+			dob = doc;
+		// else if (o instanceof BasicDBList)
+		// lst = (BasicDBList) doc;
+		else
+			return doc;
+
+		try {
+			names = path.split("\\.");
+
+			for (String name : names) {
+				if (lst != null) {
+					o = lst.get(Integer.parseInt(name));
+				} else
+					o = dob.get(name);
+
+				if (o == null)
+					break;
+
+				if (DEBUG)
+					System.out.println("Class o = " + o.getClass());
+
+				if (o instanceof BasicDBObject) {
+					dob = (BasicDBObject) o;
+					lst = null;
+				} else if (o instanceof BasicDBList) {
+					lst = (BasicDBList) o;
+				} else
+					break;
+
+			} // endfor name
+
+		} catch (IndexOutOfBoundsException x) {
+			o = null;
+		} catch (MongoException se) {
+			SetErrmsg(se);
+			o = null;
+		} // end try/catch
+
+		return o;
+	} // end of GetFieldObject
+
+	public String GetField(String path) {
+		Object o = GetFieldObject(path);
+
+		if (o != null) {
+			if (o instanceof Date) {
+				Integer TS = (int) (((Date) o).getTime() / 1000);
+				return TS.toString();
+			} // endif Date
+
+			return o.toString();
+		} else
+			return null;
+
+	} // end of GetField
+
+	public Object MakeDocument() {
+		return new BasicDBObject();
+	} // end of MakeDocument
+
+	public boolean DocAdd(Object bdc, String key, Object val) {
+		try {
+			((BasicDBObject) bdc).append(key, val);
+		} catch (MongoException me) {
+			SetErrmsg(me);
+			return true;
+		} // end try/catch
+
+		return false;
+	} // end of DocAdd
+
+	public Object MakeArray() {
+		return new BasicDBList();
+	} // end of MakeArray
+
+	public boolean ArrayAdd(Object bar, int n, Object val) {
+		try {
+			((BasicDBList) bar).put(n, val);
+		} catch (MongoException me) {
+			SetErrmsg(me);
+			return true;
+		} catch (Exception ex) {
+			SetErrmsg(ex);
+			return true;
+		} // end try/catch
+
+		return false;
+	} // end of ArrayAdd
+
+	public boolean CollInsert(Object dob) {
+		try {
+			coll.insert((BasicDBObject) dob);
+		} catch (MongoException me) {
+			SetErrmsg(me);
+			return true;
+		} catch (Exception ex) {
+			SetErrmsg(ex);
+			return true;
+		} // end try/catch
+
+		return false;
+	} // end of CollInsert
+
+	public long CollUpdate(Object upd) {
+		long n = -1;
+
+		if (DEBUG)
+			System.out.println("upd: " + upd.toString());
+
+		try {
+			DBObject qry = new BasicDBObject("_id", doc.get("_id"));
+
+			WriteResult res = coll.update(qry, (DBObject) upd);
+
+			if (DEBUG)
+				System.out.println("CollUpdate: " + res.toString());
+
+			n = res.getN();
+		} catch (MongoException me) {
+			SetErrmsg(me);
+		} catch (Exception ex) {
+			SetErrmsg(ex);
+		} // end try/catch
+
+		return n;
+	} // end of CollUpdate
+
+	public long CollDelete(boolean all) {
+		long n = -1;
+
+		try {
+			WriteResult res;
+			BasicDBObject qry = new BasicDBObject();
+
+			if (!all)
+				qry.append("_id", doc.get("_id"));
+
+			res = coll.remove(qry);
+
+			if (DEBUG)
+				System.out.println("CollDelete: " + res.toString());
+
+			n = res.getN();
+		} catch (WriteConcernException wx) {
+			SetErrmsg(wx);
+		} catch (MongoException me) {
+			SetErrmsg(me);
+		} catch (UnsupportedOperationException ux) {
+			SetErrmsg(ux);
+			n = 0;
+		} // end try/catch
+
+		return n;
+	} // end of CollDelete
+
+} // end of class MongoInterface

storage/connect/array.cpp

@@ -519,7 +519,7 @@ bool ARRAY::FilTest(PGLOBAL g, PVAL valp, OPVAL opc, int opm)
 
   } else if (opc != OP_EXIST) {
 		sprintf(g->Message, MSG(MISSING_ARG), opc);
-		throw	TYPE_ARRAY;
+		throw	(int)TYPE_ARRAY;
   } else    // OP_EXIST
     return Nval > 0;
 
@@ -681,14 +681,14 @@ void ARRAY::SetPrecision(PGLOBAL g, int p)
   {
   if (Vblp == NULL) {
     strcpy(g->Message, MSG(PREC_VBLP_NULL));
-		throw TYPE_ARRAY;
+		throw (int)TYPE_ARRAY;
     } // endif Vblp
 
   bool was = Vblp->IsCi();
 
   if (was && !p) {
     strcpy(g->Message, MSG(BAD_SET_CASE));
-		throw TYPE_ARRAY;
+		throw (int)TYPE_ARRAY;
 	} // endif Vblp
 
   if (was || !p)
@@ -699,7 +699,7 @@ void ARRAY::SetPrecision(PGLOBAL g, int p)
   if (!was && Type == TYPE_STRING)
     // Must be resorted to eliminate duplicate strings
     if (Sort(g))
-			throw TYPE_ARRAY;
+			throw (int)TYPE_ARRAY;
 
   } // end of SetPrecision
 

storage/connect/cmgfam.cpp

+/************** CMGFAM C++ Program Source Code File (.CPP) *************/
+/* PROGRAM NAME: cmgfam.cpp                                            */
+/* -------------                                                       */
+/*  Version 1.4                                                        */
+/*                                                                     */
+/* COPYRIGHT:                                                          */
+/* ----------                                                          */
+/*  (C) Copyright to the author Olivier BERTRAND          20017        */
+/*                                                                     */
+/* WHAT THIS PROGRAM DOES:                                             */
+/* -----------------------                                             */
+/*  This program are the MongoDB access method classes.                */
+/*                                                                     */
+/***********************************************************************/
+
+/***********************************************************************/
+/*  Include relevant sections of the System header files.              */
+/***********************************************************************/
+#include "my_global.h"
+
+/***********************************************************************/
+/*  Include application header files:                                  */
+/*  global.h    is header containing all global declarations.          */
+/*  plgdbsem.h  is header containing the DB application declarations.  */
+/*  filamtxt.h  is header containing the file AM classes declarations. */
+/***********************************************************************/
+#include "global.h"
+#include "plgdbsem.h"
+#include "reldef.h"
+#include "filamtxt.h"
+#include "tabdos.h"
+#include "tabjson.h"
+#include "cmgfam.h"
+
+#if defined(UNIX) || defined(UNIV_LINUX)
+#include "osutil.h"
+#endif
+
+/* --------------------------- Class CMGFAM -------------------------- */
+
+/***********************************************************************/
+/*  Constructors.                                                      */
+/***********************************************************************/
+CMGFAM::CMGFAM(PJDEF tdp) : DOSFAM((PDOSDEF)NULL)
+{
+	Cmgp = NULL;
+	Pcg.Tdbp = NULL;
+
+	if (tdp) {
+		Pcg.Uristr = tdp->Uri;
+		Pcg.Db_name = tdp->Schema;
+		Pcg.Coll_name = tdp->Collname;
+		Pcg.Options = tdp->Options;
+		Pcg.Filter = tdp->Filter;
+		Pcg.Pipe = tdp->Pipe && tdp->Options != NULL;
+	} else {
+		Pcg.Uristr = NULL;
+		Pcg.Db_name = NULL;
+		Pcg.Coll_name = NULL;
+		Pcg.Options = NULL;
+		Pcg.Filter = NULL;
+		Pcg.Pipe = false;
+	} // endif tdp
+
+	To_Fbt = NULL;
+	Mode = MODE_ANY;
+	Done = false;
+	Lrecl = tdp->Lrecl + tdp->Ending;
+} // end of CMGFAM standard constructor
+ 
+ CMGFAM::CMGFAM(PCMGFAM tdfp) : DOSFAM(tdfp)
+{
+	Pcg = tdfp->Pcg;
+	To_Fbt = tdfp->To_Fbt;
+	Mode = tdfp->Mode;
+	Done = tdfp->Done;
+ } // end of CMGFAM copy constructor
+
+/***********************************************************************/
+/*  Reset: reset position values at the beginning of file.             */
+/***********************************************************************/
+void CMGFAM::Reset(void)
+{
+	TXTFAM::Reset();
+	Fpos = Tpos = Spos = 0;
+} // end of Reset
+
+/***********************************************************************/
+/*  MGO GetFileLength: returns file size in number of bytes.           */
+/***********************************************************************/
+int CMGFAM::GetFileLength(PGLOBAL g)
+{
+	return 0;
+} // end of GetFileLength
+
+/***********************************************************************/
+/*  Cardinality: returns the number of documents in the collection.    */
+/*  This function can be called with a null argument to test the       */
+/*  availability of Cardinality implementation (1 yes, 0 no).          */
+/***********************************************************************/
+int CMGFAM::Cardinality(PGLOBAL g)
+{
+	if (!g)
+		return 1;
+
+	return (!Init(g)) ? Cmgp->CollSize(g) : 0;
+} // end of Cardinality
+
+/***********************************************************************/
+/*  Note: This function is not really implemented yet.                 */
+/***********************************************************************/
+int CMGFAM::MaxBlkSize(PGLOBAL, int s)
+{
+	return s;
+} // end of MaxBlkSize
+
+/***********************************************************************/
+/*  Init: initialize MongoDB processing.                               */
+/***********************************************************************/
+bool CMGFAM::Init(PGLOBAL g)
+{
+	if (Done)
+		return false;
+
+	/*********************************************************************/
+	/*  Open an C connection for this table.                             */
+	/*********************************************************************/
+	if (!Cmgp) {
+		Pcg.Tdbp = Tdbp;
+		Cmgp = new(g) CMgoConn(g, &Pcg);
+	} else if (Cmgp->IsConnected())
+		Cmgp->Close();
+
+	if (Cmgp->Connect(g))
+		return true;
+
+	Done = true;
+	return false;
+} // end of Init
+
+/***********************************************************************/
+/*  OpenTableFile: Open a MongoDB table.                               */
+/***********************************************************************/
+bool CMGFAM::OpenTableFile(PGLOBAL g)
+{
+	Mode = Tdbp->GetMode();
+
+	if (Pcg.Pipe && Mode != MODE_READ) {
+		strcpy(g->Message, "Pipeline tables are read only");
+		return true;
+	}	// endif Pipe
+
+	if (Init(g))
+		return true;
+
+	if (Mode == MODE_DELETE && !Tdbp->GetNext())
+		// Delete all documents
+		return Cmgp->DocDelete(g);
+	else if (Mode == MODE_INSERT)
+		Cmgp->MakeColumnGroups(g);
+
+	return false;
+} // end of OpenTableFile
+
+/***********************************************************************/
+/*  GetRowID: return the RowID of last read record.                    */
+/***********************************************************************/
+int CMGFAM::GetRowID(void)
+{
+	return Rows;
+} // end of GetRowID
+
+/***********************************************************************/
+/*  GetPos: return the position of last read record.                   */
+/***********************************************************************/
+int CMGFAM::GetPos(void)
+{
+	return Fpos;
+} // end of GetPos
+
+/***********************************************************************/
+/*  GetNextPos: return the position of next record.                    */
+/***********************************************************************/
+int CMGFAM::GetNextPos(void)
+{
+	return Fpos;						// TODO
+} // end of GetNextPos
+
+/***********************************************************************/
+/*  SetPos: Replace the table at the specified position.               */
+/***********************************************************************/
+bool CMGFAM::SetPos(PGLOBAL g, int pos)
+{
+	Fpos = pos;
+	Placed = true;
+	return false;
+} // end of SetPos
+
+/***********************************************************************/
+/*  Record file position in case of UPDATE or DELETE.                  */
+/***********************************************************************/
+bool CMGFAM::RecordPos(PGLOBAL g)
+{
+	strcpy(g->Message, "CMGFAM::RecordPos NIY");
+	return true;
+} // end of RecordPos
+
+/***********************************************************************/
+/*  Initialize Fpos and the current position for indexed DELETE.       */
+/***********************************************************************/
+int CMGFAM::InitDelete(PGLOBAL g, int fpos, int spos)
+{
+	strcpy(g->Message, "CMGFAM::InitDelete NIY");
+	return RC_FX;
+} // end of InitDelete
+
+/***********************************************************************/
+/*  Skip one record in file.                                           */
+/***********************************************************************/
+int CMGFAM::SkipRecord(PGLOBAL g, bool header)
+{
+	return RC_OK;                  // Dummy
+} // end of SkipRecord
+
+/***********************************************************************/
+/*  ReadBuffer: Get next document from a collection.                   */
+/***********************************************************************/
+int CMGFAM::ReadBuffer(PGLOBAL g)
+{
+	int rc = Cmgp->ReadNext(g);
+
+	if (rc != RC_OK)
+		return rc;
+
+	strncpy(Tdbp->GetLine(), Cmgp->GetDocument(g), Lrecl);
+	return RC_OK;
+} // end of ReadBuffer
+
+/***********************************************************************/
+/*  WriteBuffer: File write routine for MGO access method.             */
+/***********************************************************************/
+int CMGFAM::WriteBuffer(PGLOBAL g)
+{
+	return Cmgp->Write(g);
+} // end of WriteBuffer
+
+/***********************************************************************/
+/*  Data Base delete line routine for MGO and BLK access methods.      */
+/***********************************************************************/
+int CMGFAM::DeleteRecords(PGLOBAL g, int irc)
+{
+	return (irc == RC_OK) ? WriteBuffer(g) : RC_OK;
+} // end of DeleteRecords
+
+/***********************************************************************/
+/*  Table file close routine for MGO access method.                    */
+/***********************************************************************/
+void CMGFAM::CloseTableFile(PGLOBAL g, bool)
+{
+	Cmgp->Close();
+	Done = false;
+} // end of CloseTableFile
+
+/***********************************************************************/
+/*  Rewind routine for MGO access method.                              */
+/***********************************************************************/
+void CMGFAM::Rewind(void)
+{
+	Cmgp->Rewind();
+} // end of Rewind
+

storage/connect/cmgfam.h

+/*************** CMGFam H Declares Source Code File (.H) ***************/
+/*  Name: cmgfam.h    Version 1.5                                      */
+/*                                                                     */
+/*  (C) Copyright to the author Olivier BERTRAND          2017         */
+/*                                                                     */
+/*  This file contains the MongoDB access method classes declares.     */
+/***********************************************************************/
+#include "cmgoconn.h"
+
+typedef class TXTFAM *PTXF;
+typedef class CMGFAM *PCMGFAM;
+typedef class MGODEF *PMGODEF;
+typedef class TDBCMG *PTDBCMG;
+
+/***********************************************************************/
+/*  This is the MongoDB Access Method class declaration.               */
+/***********************************************************************/
+class DllExport CMGFAM : public DOSFAM {
+	friend void mongo_init(bool);
+public:
+	// Constructor
+	CMGFAM(PJDEF tdp);
+	CMGFAM(PCMGFAM txfp);
+
+	// Implementation
+	virtual AMT   GetAmType(void) { return TYPE_AM_MGO; }
+	virtual bool  GetUseTemp(void) { return false; }
+	virtual int   GetPos(void);
+	virtual int   GetNextPos(void);
+	void  SetTdbp(PTDBDOS tdbp) { Tdbp = tdbp; }
+	virtual PTXF  Duplicate(PGLOBAL g) { return (PTXF)new(g) CMGFAM(this); }
+	void  SetLrecl(int lrecl) { Lrecl = lrecl; }
+
+	// Methods
+	virtual void  Reset(void);
+	virtual int   GetFileLength(PGLOBAL g);
+	virtual int   Cardinality(PGLOBAL g);
+	virtual int   MaxBlkSize(PGLOBAL g, int s);
+	virtual bool  AllocateBuffer(PGLOBAL g) { return false; }
+	virtual int   GetRowID(void);
+	virtual bool  RecordPos(PGLOBAL g);
+	virtual bool  SetPos(PGLOBAL g, int recpos);
+	virtual int   SkipRecord(PGLOBAL g, bool header);
+	virtual bool  OpenTableFile(PGLOBAL g);
+	virtual int   ReadBuffer(PGLOBAL g);
+	virtual int   WriteBuffer(PGLOBAL g);
+	virtual int   DeleteRecords(PGLOBAL g, int irc);
+	virtual void  CloseTableFile(PGLOBAL g, bool abort);
+	virtual void  Rewind(void);
+
+protected:
+	virtual bool  OpenTempFile(PGLOBAL g) { return false; }
+	virtual bool  MoveIntermediateLines(PGLOBAL g, bool *b) { return false; }
+	virtual int   RenameTempFile(PGLOBAL g) { return RC_OK; }
+	virtual int   InitDelete(PGLOBAL g, int fpos, int spos);
+	bool  Init(PGLOBAL g);
+
+	// Members
+	CMgoConn *Cmgp;       // Points to a C Mongo connection class
+	CMGOPARM	Pcg;				// Parms passed to Cmgp
+	PFBLOCK   To_Fbt;     // Pointer to temp file block
+	MODE      Mode;
+	bool      Done;			  // Init done
+}; // end of class CMGFAM
+

storage/connect/cmgoconn.h

+/***********************************************************************/
+/*  CMgoConn.h : header file for the MongoDB connection classes.       */
+/***********************************************************************/
+
+/***********************************************************************/
+/*  Include MongoDB library header files.                       	  	 */
+/***********************************************************************/
+#include <bson.h>
+#include <bcon.h>
+#include <mongoc.h>
+
+// C connection to a MongoDB data source
+class TDBCMG;
+class MGOCOL;
+
+/***********************************************************************/
+/*  Include MongoDB library header files.                       	  	 */
+/***********************************************************************/
+typedef class INCOL  *PINCOL;
+typedef class MGODEF *PMGODEF;
+typedef class TDBCMG *PTDBCMG;
+typedef class MGOCOL *PMGOCOL;
+
+typedef struct mongo_parms {
+	PTDB Tdbp;
+	PCSZ Uristr;               // Driver URI
+	PCSZ Db_name;
+	PCSZ Coll_name;
+	PCSZ Options;
+	PCSZ Filter;
+	bool Pipe;
+//PCSZ User;                 // User connect info
+//PCSZ Pwd;                  // Password connect info
+//int  Fsize;								 // Fetch size
+//bool Scrollable;					 // Scrollable cursor
+} CMGOPARM, *PCPARM;
+
+typedef struct KEYCOL {
+	KEYCOL *Next;
+	PINCOL  Incolp;
+	PCOL    Colp;
+	char   *Key;
+} *PKC;
+
+/***********************************************************************/
+/*  Used when inserting values in a MongoDB collection.                */
+/***********************************************************************/
+class INCOL : public BLOCK {
+public:
+	// Constructor
+	INCOL(bool ar) { Child = bson_new(); Klist = NULL; Array = ar; }
+
+	// Methods
+	void AddCol(PGLOBAL g, PCOL colp, char *jp);
+	void Init(void);
+	void Destroy(void);
+
+	//Members
+	bson_t *Child;
+	PKC     Klist;
+	bool    Array;
+}; // end of INCOL;
+
+/***********************************************************************/
+/*  CMgoConn class.                                                    */
+/***********************************************************************/
+class CMgoConn : public BLOCK {
+	friend class TDBCMG;
+	friend class CMGDISC;
+public:
+	// Constructor
+	CMgoConn(PGLOBAL g, PCPARM pcg);
+
+	//static void *mgo_alloc(size_t n);
+	//static void *mgo_calloc(size_t n, size_t sz);
+	//static void *mgo_realloc(void *m, size_t n);
+	//static void  mgo_free(void *) {}
+
+	// Implementation
+	bool IsConnected(void) { return m_Connected; }
+	bool Connect(PGLOBAL g);
+	int  CollSize(PGLOBAL g);
+	bool MakeCursor(PGLOBAL g);
+	int  ReadNext(PGLOBAL g);
+	PSZ  GetDocument(PGLOBAL g);
+	void ShowDocument(bson_iter_t *iter, const bson_t *doc, const char *k);
+	void MakeColumnGroups(PGLOBAL g);
+	bool DocWrite(PGLOBAL g, PINCOL icp);
+	int  Write(PGLOBAL g);
+	bool DocDelete(PGLOBAL g);
+	void Rewind(void);
+	void Close(void);
+	PSZ  Mini(PGLOBAL g, PCOL colp, const bson_t *bson, bool b);
+	void GetColumnValue(PGLOBAL g, PCOL colp);
+	bool AddValue(PGLOBAL g, PCOL colp, bson_t *doc, char *key, bool upd);
+
+protected:
+	// Members
+	PCPARM								Pcg;
+	mongoc_uri_t         *Uri;
+	mongoc_client_pool_t *Pool;				// Thread safe client pool
+	mongoc_client_t      *Client;		  // The MongoDB client
+	mongoc_database_t    *Database;	  // The MongoDB database
+	mongoc_collection_t  *Collection; // The MongoDB collection
+	mongoc_cursor_t      *Cursor;
+	const bson_t         *Document;
+	bson_t               *Query;			// MongoDB cursor filter
+	bson_t               *Opts;			  // MongoDB cursor options
+	bson_error_t          Error;
+	bson_iter_t           Iter;				// Used to retrieve column value
+	bson_iter_t           Desc;				// Descendant iter
+	PINCOL                Fpc;				// To insert INCOL classes
+	PFBLOCK               fp;
+	bool                  m_Connected;
+}; // end of class CMgoConn

storage/connect/colblk.cpp

@@ -197,7 +197,7 @@ int COLBLK::GetLengthEx(void)
 void COLBLK::ReadColumn(PGLOBAL g)
 {
   sprintf(g->Message, MSG(UNDEFINED_AM), "ReadColumn");
-	throw TYPE_COLBLK;
+	throw (int)TYPE_COLBLK;
 } // end of ReadColumn
 
 /***********************************************************************/
@@ -208,7 +208,7 @@ void COLBLK::ReadColumn(PGLOBAL g)
 void COLBLK::WriteColumn(PGLOBAL g)
 {
   sprintf(g->Message, MSG(UNDEFINED_AM), "WriteColumn");
-	throw TYPE_COLBLK;
+	throw (int)TYPE_COLBLK;
 } // end of WriteColumn
 
 /***********************************************************************/
@@ -262,7 +262,7 @@ SPCBLK::SPCBLK(PCOLUMN cp)
 void SPCBLK::WriteColumn(PGLOBAL g)
 {
   sprintf(g->Message, MSG(SPCOL_READONLY), Name);
-	throw TYPE_COLBLK;
+	throw (int)TYPE_COLBLK;
 } // end of WriteColumn
 
 /***********************************************************************/

storage/connect/colblk.h

@@ -38,7 +38,8 @@ class DllExport COLBLK : public XOBJECT {
   virtual PTDB    GetTo_Tdb(void) {return To_Tdb;}
   virtual int     GetClustered(void) {return 0;}
   virtual int     IsClustered(void) {return FALSE;}
-          PCOL    GetNext(void) {return Next;}
+	virtual PSZ     GetJpath(PGLOBAL g, bool proj) {return NULL;}
+					PCOL    GetNext(void) {return Next;}
           PSZ     GetName(void) {return Name;}
           int     GetIndex(void) {return Index;}
           ushort  GetColUse(void) {return ColUse;}

storage/connect/connect.cc

-/* Copyright (C) Olivier Bertrand 2004 - 2017
+/* Copyright (C) MariaDB Corporation Ab
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -66,8 +66,10 @@ PGLOBAL CntExit(PGLOBAL g)
   if (g) {
     CntEndDB(g);
 
-    if (g->Activityp)
-      delete g->Activityp;
+		if (g->Activityp) {
+			delete g->Activityp;
+			g->Activityp = NULL;
+		}	// endif Activityp
 
     PlugExit(g);
     g= NULL;
@@ -80,7 +82,7 @@ PGLOBAL CntExit(PGLOBAL g)
 /*  CntEndDB: DB termination semantic routine.                         */
 /***********************************************************************/
 void CntEndDB(PGLOBAL g)
-  {
+{
   PDBUSER dbuserp= PlgGetUser(g);
 
   if (dbuserp) {
@@ -88,9 +90,14 @@ void CntEndDB(PGLOBAL g)
       delete dbuserp->Catalog;
 
     free(dbuserp);
-    } // endif dbuserp
 
-  } // end of CntEndDB
+		if (trace)
+			htrc("CntEndDB: Freeing Dup\n");
+
+		g->Activityp->Aptr = NULL;
+	} // endif dbuserp
+
+} // end of CntEndDB
 
 /***********************************************************************/
 /*  CntCheckDB: Initialize a DB application session.                   */
@@ -185,10 +192,10 @@ bool CntInfo(PGLOBAL g, PTDB tp, PXF info)
 /***********************************************************************/
 PTDB CntGetTDB(PGLOBAL g, LPCSTR name, MODE mode, PHC h)
 {
-	PTDB    tdbp;
+	PTDB    tdbp = NULL;
 	PTABLE  tabp;
 	PDBUSER dup = PlgGetUser(g);
-	volatile PCATLG  cat = (dup) ? dup->Catalog : NULL;     // Safe over longjmp
+	volatile PCATLG  cat = (dup) ? dup->Catalog : NULL;  // Safe over throw
 
 	if (trace)
 		printf("CntGetTDB: name=%s mode=%d cat=%p\n", name, mode, cat);

storage/connect/connect.h

-/* Copyright (C) Olivier Bertrand 2004 - 2011
+/* Copyright (C) MariaDB Corporation Ab
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -15,6 +15,7 @@
 
 /**************** Cnt H Declares Source Code File (.H) *****************/
 /*  Name: CONNECT.H    Version 2.4                                     */
+/*  Author Olivier BERTRAND  bertrandop@gmail.com                      */
 /*  This file contains the some based classes declares.                */
 /***********************************************************************/
 #include "filamtxt.h"

storage/connect/engmsg.h

+/* Copyright (C) MariaDB Corporation Ab */
 #define MSG_ACCESS_VIOLATN  "Access violation"
 #define MSG_ADD_BAD_TYPE    "Array add value type mismatch (%s -> %s)"
 #define MSG_ALLOC_ERROR     "Error allocating %s"

storage/connect/filamzip.cpp

@@ -290,6 +290,9 @@ void ZIPUTIL::close()
 		zipfile = NULL;
 	}	// endif zipfile
 
+	if (fp)
+		fp->Count = 0;
+
 }	// end of close
 
 /***********************************************************************/
@@ -493,6 +496,9 @@ void UNZIPUTL::close()
 		zipfile = NULL;
 	}	// endif zipfile
 
+	if (fp)
+		fp->Count = 0;
+
 }	// end of close
 
 /***********************************************************************/

storage/connect/filter.cpp

@@ -33,18 +33,11 @@
 #include "tabcol.h"
 #include "xtable.h"
 #include "array.h"
-//#include "subquery.h"
 #include "filter.h"
-//#include "token.h"
-//#include "select.h"
 #include "xindex.h"
-#if defined(MONGO_SUPPORT)
-#include "filamtxt.h"
-#include "tabdos.h"
-#include "tabjson.h"
+#if defined(MONGO_SUPPORT) || defined(JDBC_SUPPORT)
 #include "tabext.h"
-#include "tabmgo.h"
-#endif   // MONGO_SUPPORT
+#endif   // MONGO_SUPPORT  || JDBC_SUPPORT
 
 /***********************************************************************/
 /*  Utility routines.                                                  */
@@ -94,7 +87,7 @@ BYTE OpBmp(PGLOBAL g, OPVAL opc)
     case OP_EXIST: bt = 0x00; break;
     default:
       sprintf(g->Message, MSG(BAD_FILTER_OP), opc);
-			throw TYPE_ARRAY;
+			throw (int)TYPE_ARRAY;
 	} // endswitch opc
 
   return bt;
@@ -1412,11 +1405,11 @@ PFIL FILTER::Copy(PTABS t)
   } // end of Copy
 #endif // 0
 
+#if defined(MONGO_SUPPORT)
 /***********************************************************************/
 /*  Make selector json representation for Mongo tables.                */
 /***********************************************************************/
-#if defined(MONGO_SUPPORT)
-bool FILTER::MakeSelector(PGLOBAL g, PSTRG s, bool m)
+bool FILTER::MakeSelector(PGLOBAL g, PSTRG s)
 {
 	s->Append('{');
 
@@ -1428,29 +1421,21 @@ bool FILTER::MakeSelector(PGLOBAL g, PSTRG s, bool m)
 		s->Append(Opc == OP_AND ? "and" : "or");
 		s->Append("\":[");
 
-		if (((PFIL)Arg(0))->MakeSelector(g, s, m))
+		if (((PFIL)Arg(0))->MakeSelector(g, s))
 			return true;
 
 		s->Append(',');
 
-		if (((PFIL)Arg(1))->MakeSelector(g, s, m))
+		if (((PFIL)Arg(1))->MakeSelector(g, s))
 			return true;
 
 		s->Append(']');
 	} else {
-		char *pth, buf[501];
-
 		if (GetArgType(0) != TYPE_COLBLK)
 			return true;
 
 		s->Append('"');
-
-		if (m)
-		  pth = ((PMGOCOL)Arg(0))->Jpath;
-		else if (!(pth = ((PJCOL)Arg(0))->GetJpath(g, false)))
-			return true;
-
-		s->Append(pth);
+		s->Append(((PCOL)Arg(0))->GetJpath(g, false));
 		s->Append("\":{\"$");
 
 		switch (Opc) {
@@ -1472,26 +1457,26 @@ bool FILTER::MakeSelector(PGLOBAL g, PSTRG s, bool m)
 			case OP_LE:
 				s->Append("lte");
 				break;
-				//case OP_NULL:
-				//	s->Append("ne");
-				//	break;
-				//case OP_LIKE:
-				//	s->Append("ne");
-				//	break;
-				//case OP_EXIST:
-				//	s->Append("ne");
-				//	break;
+			case OP_NULL:
+			case OP_LIKE:
+			case OP_EXIST:
 			default:
 				return true;
 		} // endswitch Opc
 
 		s->Append("\":");
 
-		if (GetArgType(1) == TYPE_COLBLK)
-			return true;
+		if (GetArgType(1) == TYPE_COLBLK) {
+			s->Append("\"$");
+			s->Append(((PEXTCOL)Arg(1))->GetJpath(g, false));
+			s->Append('"');
+		} else {
+			char buf[501];
+
+			Arg(1)->Prints(g, buf, 500);
+			s->Append(buf);
+		} // endif Type
 
-		Arg(1)->Prints(g, buf, 500);
-		s->Append(buf);
 		s->Append('}');
 	} // endif Opc
 
@@ -1804,7 +1789,7 @@ PFIL PrepareFilter(PGLOBAL g, PFIL fp, bool having)
         break;  // Remove eventual ending separator(s)
 
 //  if (fp->Convert(g, having))
-//			throw TYPE_ARRAY;
+//		(int)throw TYPE_ARRAY;
 
     filp = fp;
     fp = fp->Next;
@@ -1837,7 +1822,7 @@ DllExport bool ApplyFilter(PGLOBAL g, PFIL filp)
 //  return TRUE;
 
   if (filp->Eval(g))
-		throw TYPE_FILTER;
+		throw (int)TYPE_FILTER;
 
   if (trace > 1)
     htrc("PlugFilter filp=%p result=%d\n",

storage/connect/filter.h

 /*************** Filter H Declares Source Code File (.H) ***************/
-/*  Name: FILTER.H    Version 1.2                                      */
+/*  Name: FILTER.H    Version 1.3                                      */
 /*                                                                     */
-/*  (C) Copyright to the author Olivier BERTRAND          2010-2015    */
+/*  (C) Copyright to the author Olivier BERTRAND          2010-2017    */
 /*                                                                     */
 /*  This file contains the FILTER and derived classes declares.        */
 /***********************************************************************/
@@ -62,7 +62,7 @@ class DllExport FILTER : public XOBJECT { /* Filter description block  */
 //virtual bool   CheckLocal(PTDB);
 //virtual int    CheckSpcCol(PTDB tdbp, int n);
 #if defined(MONGO_SUPPORT)
-	        bool   MakeSelector(PGLOBAL g, PSTRG s, bool m);
+					bool   MakeSelector(PGLOBAL g, PSTRG s);
 #endif   // MONGO_SUPPORT
 	virtual void   Printf(PGLOBAL g, FILE *f, uint n);
   virtual void   Prints(PGLOBAL g, char *ps, uint z);

storage/connect/global.h

 /***********************************************************************/
 /*  GLOBAL.H: Declaration file used by all CONNECT implementations.    */
-/*  (C) Copyright Olivier Bertrand                       1993-2017     */
+/*  (C) Copyright MariaDB Corporation Ab                 							 */
+/*  Author Olivier Bertrand                              1993-2017     */
 /***********************************************************************/
 
 /***********************************************************************/
@@ -57,31 +58,10 @@
 /*  Miscellaneous Constants                                            */
 /***********************************************************************/
 #define  NO_IVAL   -95684275        /* Used by GetIntegerOption        */
-#define  VMLANG          370        /* Size of olf VM lang blocks      */
 #define  MAX_JUMP         24        /* Maximum jump level number       */
 #define  MAX_STR        4160        /* Maximum message length          */
-#define  STR_SIZE        501        /* Length of char strings.         */
-#define  STD_INPUT         0        /* Standard language input         */
-#define  STD_OUTPUT        1        /* Standard language output        */
-#define  ERROR_OUTPUT      2        /* Error    message  output        */
-#define  DEBUG_OUTPUT      3        /* Debug    info     output        */
-#define  PROMPT_OUTPUT     4        /* Prompt   message  output        */
-#define  COPY_OUTPUT       5        /* Copy of  language input         */
-#define  STD_MSG           6        /* System message file             */
-#define  DEBUG_MSG         7        /* Debug  message file             */
-#define  DUMMY             0        /* Dummy  file index in Ldm block  */
-#define  STDIN             1        /* stdin  file index in Ldm block  */
-#define  STDOUT            2        /* stdout file index in Ldm block  */
-#define  STDERR            3        /* stderr file index in Ldm block  */
-#define  STDEBUG           4        /* debug  file index in Ldm block  */
-#define  STDPRN            5        /* stdprn file index in Ldm block  */
-#define  STDFREE           6        /* Free   file index in Ldm block  */
 
-#define  TYPE_SEM         -2        /* Returned semantic function      */
-#define  TYPE_DFONC       -2        /* Indirect sem ref in FPARM       */
 #define  TYPE_VOID        -1
-#define  TYPE_SBPAR       -1        /* Phrase reference in FPARM       */
-#define  TYPE_SEMX         0        /* Initial semantic function type? */
 #define  TYPE_ERROR        0
 #define  TYPE_STRING       1
 #define  TYPE_DOUBLE       2
@@ -95,22 +75,6 @@
 #define  TYPE_BIN         10
 #define  TYPE_PCHAR       11
 
-#if defined(OS32)
-  #define  SYS_STAMP   "OS32"
-#elif defined(UNIX) || defined(LINUX) || defined(UNIV_LINUX)
-  #define  SYS_STAMP   "UNIX"
-#elif defined(OS16)
-  #define  SYS_STAMP   "OS16"
-#elif defined(DOSR)
-  #define  SYS_STAMP   "DOSR"
-#elif defined(WIN)
-  #define  SYS_STAMP   "WIN1"
-#elif defined(__WIN__)
-  #define  SYS_STAMP   "WIN2"
-#else
-  #define  SYS_STAMP   "XXXX"
-#endif
-
 #if defined(__cplusplus)
 extern "C" {
 #endif
@@ -118,11 +82,6 @@ extern "C" {
 /***********************************************************************/
 /*  Static variables                                                   */
 /***********************************************************************/
-#if defined(STORAGE)
-         char      sys_stamp[5] = SYS_STAMP;
-#else
-  extern char      sys_stamp[];
-#endif
 
 /***********************************************************************/
 /*                       File-Selection Indicators                     */

storage/connect/ha_connect.h

-/* Copyright (C) Olivier Bertrand 2004 - 2015
+/* Copyright (C) MariaDB Corporation Ab
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -14,6 +14,7 @@
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA */
 
 /** @file ha_connect.h
+	Author Olivier Bertrand
 
     @brief
   The ha_connect engine is a prototype storage engine to access external data.
@@ -165,8 +166,8 @@ class ha_connect: public handler
   ~ha_connect();
 
   // CONNECT Implementation
-  static   bool connect_init(void);
-  static   bool connect_end(void);
+//static   bool connect_init(void);
+//static   bool connect_end(void);
   TABTYPE  GetRealType(PTOS pos= NULL);
   char    *GetRealString(PCSZ s);
 	PCSZ     GetStringOption(PCSZ opname, PCSZ sdef= NULL);

storage/connect/javaconn.h

+/***********************************************************************/
+/*  JavaConn.h : header file for the Java connection classes.          */
+/***********************************************************************/
+
+/***********************************************************************/
+/*  Included C-definition files required by the interface.             */
+/***********************************************************************/
+#include "block.h"
+#include "jdbccat.h"
+
+/***********************************************************************/
+/*  Java native interface.                                             */
+/***********************************************************************/
+#include <jni.h>
+
+/***********************************************************************/
+/*  Constants and defines.                                             */
+/***********************************************************************/
+//  Miscellaneous sizing info
+#define MAX_NUM_OF_MSG   10     // Max number of error messages
+//efine MAX_CURRENCY     30     // Max size of Currency($) string
+#define MAX_TNAME_LEN    32     // Max size of table names
+//efine MAX_FNAME_LEN    256    // Max size of field names
+//efine MAX_STRING_INFO  256    // Max size of string from SQLGetInfo
+//efine MAX_DNAME_LEN    256    // Max size of Recordset names
+//efine MAX_CONNECT_LEN  512    // Max size of Connect string
+//efine MAX_CURSOR_NAME  18     // Max size of a cursor name
+//efine DEFAULT_FIELD_TYPE 0    // TYPE_NULL
+
+#if !defined(__WIN__)
+typedef unsigned char *PUCHAR;
+#endif   // !__WIN__
+
+enum JCATINFO {
+	JCAT_TAB = 1,      // JDBC Tables
+	JCAT_COL = 2,      // JDBC Columns
+	JCAT_KEY = 3,      // JDBC PrimaryKeys
+};
+
+/***********************************************************************/
+/*  This structure is used to control the catalog functions.           */
+/***********************************************************************/
+typedef struct tagJCATPARM {
+	JCATINFO Id;                 // Id to indicate function 
+	PQRYRES  Qrp;                // Result set pointer
+	PCSZ     DB;                 // Database (Schema)
+	PCSZ     Tab;                // Table name or pattern
+	PCSZ     Pat;                // Table type or column pattern
+} JCATPARM;
+
+typedef jint(JNICALL *CRTJVM) (JavaVM **, void **, void *);
+typedef jint(JNICALL *GETJVM) (JavaVM **, jsize, jsize *);
+#if defined(_DEBUG)
+typedef jint(JNICALL *GETDEF) (void *);
+#endif   // _DEBUG
+
+class JAVAConn;
+
+/***********************************************************************/
+/*  JAVAConn class.                                                    */
+/***********************************************************************/
+class JAVAConn : public BLOCK {
+	friend class TDBJMG;
+	friend class JMGDISC;
+private:
+	JAVAConn();                      // Standard (unused) constructor
+
+public:
+	// Constructor
+	JAVAConn(PGLOBAL g, PCSZ wrapper);
+
+	// Set static variables
+	static void SetJVM(void) {
+		LibJvm = NULL;
+		CreateJavaVM = NULL;
+		GetCreatedJavaVMs = NULL;
+#if defined(_DEBUG)
+		GetDefaultJavaVMInitArgs = NULL;
+#endif   // _DEBUG
+	}	// end of SetJVM
+
+	static void ResetJVM(void);
+	static bool GetJVM(PGLOBAL g);
+
+	// Implementation
+public:
+	//virtual ~JAVAConn();
+	bool IsOpen(void) { return m_Opened; }
+	bool IsConnected(void) { return m_Connected; }
+
+	// Java operations
+protected:
+	bool gmID(PGLOBAL g, jmethodID& mid, const char *name, const char *sig);
+	bool Check(jint rc = 0);
+
+public:
+	virtual void AddJars(PSTRG jpop, char sep) = 0;
+	virtual bool Connect(PJPARM sop) = 0;
+	virtual bool Open(PGLOBAL g);
+	virtual bool MakeCursor(PGLOBAL g, PTDB tdbp, PCSZ options, 
+		                                            PCSZ filter, bool pipe) = 0;
+	virtual void Close(void);
+
+protected:
+	// Members
+#if defined(__WIN__)
+	static HANDLE LibJvm;              // Handle to the jvm DLL
+#else   // !__WIN__
+	static void  *LibJvm;              // Handle for the jvm shared library
+#endif  // !__WIN__
+	static CRTJVM CreateJavaVM;
+	static GETJVM GetCreatedJavaVMs;
+#if defined(_DEBUG)
+	static GETDEF GetDefaultJavaVMInitArgs;
+#endif   // _DEBUG
+	PGLOBAL   m_G;
+	JavaVM   *jvm;                      // Pointer to the JVM (Java Virtual Machine)
+	JNIEnv   *env;                      // Pointer to native interface
+	jclass    jdi;											// Pointer to the java wrapper class
+	jobject   job;											// The java wrapper class object
+	jmethodID errid;										// The GetErrmsg method ID
+	PFBLOCK   fp;
+	bool      m_Opened;
+	bool      m_Connected;
+	PCSZ      DiscFunc;
+	PCSZ      Msg;
+	PCSZ      m_Wrap;
+	int       m_Rows;
+}; // end of JAVAConn class definition

storage/connect/jdbccat.h

+#ifndef __JDBCCAT_H
+#define __JDBCCAT_H
+
 // Timeout and net wait defaults
 #define DEFAULT_LOGIN_TIMEOUT -1                  // means do not set
 #define DEFAULT_QUERY_TIMEOUT -1                  // means do not set
@@ -8,9 +11,9 @@ typedef struct jdbc_parms {
 	PCSZ  Url;                  // Driver URL
 	PCSZ  User;                 // User connect info
 	PCSZ  Pwd;                  // Password connect info
-//char *Properties;						// Connection property list
 //int   Cto;                  // Connect timeout
 //int   Qto;                  // Query timeout
+	int   Version;							// Driver version
 	int   Fsize;								// Fetch size
 	bool  Scrollable;						// Scrollable cursor
 } JDBCPARM, *PJPARM;
@@ -28,3 +31,5 @@ PQRYRES JDBCSrcCols(PGLOBAL g, PCSZ src, PJPARM sop);
 PQRYRES JDBCTables(PGLOBAL g, PCSZ db, PCSZ tabpat,
 	PCSZ tabtyp, int maxres, bool info, PJPARM sop);
 PQRYRES JDBCDrivers(PGLOBAL g, int maxres, bool info);
+
+#endif // __JDBCCAT_H

storage/connect/jdbconn.h

 /***********************************************************************/
 /*  JDBConn.h : header file for the JDBC connection classes.           */
 /***********************************************************************/
-//nclude <windows.h>                           /* Windows include file */
-//nclude <windowsx.h>                          /* Message crackers     */
-
-/***********************************************************************/
-/*  Included C-definition files required by the interface.             */
-/***********************************************************************/
-#include "block.h"
-
-/***********************************************************************/
-/*  JDBC interface.                                                    */
-/***********************************************************************/
-#include <jni.h>
-
-/***********************************************************************/
-/*  Constants and defines.                                             */
-/***********************************************************************/
-//  Miscellaneous sizing info
-#define MAX_NUM_OF_MSG   10     // Max number of error messages
-//efine MAX_CURRENCY     30     // Max size of Currency($) string
-#define MAX_TNAME_LEN    32     // Max size of table names
-//efine MAX_FNAME_LEN    256    // Max size of field names
-//efine MAX_STRING_INFO  256    // Max size of string from SQLGetInfo
-//efine MAX_DNAME_LEN    256    // Max size of Recordset names
-//efine MAX_CONNECT_LEN  512    // Max size of Connect string
-//efine MAX_CURSOR_NAME  18     // Max size of a cursor name
-#define DEFAULT_FIELD_TYPE 0    // TYPE_NULL
-
-#if !defined(__WIN__)
-typedef unsigned char *PUCHAR;
-#endif   // !__WIN__
-
-enum JCATINFO {
-	CAT_TAB   =     1,      // JDBC Tables
-	CAT_COL   =     2,      // JDBC Columns
-	CAT_KEY   =     3,      // JDBC PrimaryKeys
-//CAT_STAT  =     4,      // SQLStatistics
-//CAT_SPC   =     5       // SQLSpecialColumns
-};
-
-/***********************************************************************/
-/*  This structure is used to control the catalog functions.           */
-/***********************************************************************/
-typedef struct tagJCATPARM {
-	JCATINFO Id;                 // Id to indicate function 
-	PQRYRES  Qrp;                // Result set pointer
-	PCSZ     DB;                 // Database (Schema)
-	PCSZ     Tab;                // Table name or pattern
-	PCSZ     Pat;                // Table type or column pattern
-} JCATPARM;
-
-typedef jint(JNICALL *CRTJVM) (JavaVM **, void **, void *);
-typedef jint(JNICALL *GETJVM) (JavaVM **, jsize, jsize *);
-#if defined(_DEBUG)
-typedef jint(JNICALL *GETDEF) (void *);
-#endif   // _DEBUG
+#include "javaconn.h"
 
 // JDBC connection to a data source
 class TDBJDBC;
@@ -66,7 +12,7 @@ class TDBXJDC;
 /***********************************************************************/
 /*  JDBConn class.                                                     */
 /***********************************************************************/
-class JDBConn : public BLOCK {
+class JDBConn : public JAVAConn {
 	friend class TDBJDBC;
 	friend class TDBXJDC;
 //friend PQRYRES GetColumnInfo(PGLOBAL, char*&, char *, int, PVBLK&);
@@ -74,118 +20,80 @@ class JDBConn : public BLOCK {
 	JDBConn();                      // Standard (unused) constructor
 
 public:
-	JDBConn(PGLOBAL g, TDBJDBC *tdbp);
+	// Constructor
+	JDBConn(PGLOBAL g, PCSZ wrapper);
 
-	int  Open(PJPARM sop);
-	int  Rewind(PCSZ sql);
-	void Close(void);
-	PQRYRES AllocateResult(PGLOBAL g);
+	virtual void AddJars(PSTRG jpop, char sep);
+	PQRYRES AllocateResult(PGLOBAL g, PTDB tdbp);
 
 	// Attributes
 public:
-	char *GetQuoteChar(void) { return m_IDQuoteChar; }
-	// Database successfully opened?
-	bool  IsOpen(void) { return m_Opened; }
-//PSZ   GetStringInfo(ushort infotype);
-	int   GetMaxValue(int infotype);
-//PSZ   GetConnect(void) { return m_Connect; }
+	char   *GetQuoteChar(void) { return m_IDQuoteChar; }
+	virtual int  GetMaxValue(int infotype);
 
 public:
 	// Operations
-	//void SetLoginTimeout(DWORD sec) {m_LoginTimeout = sec;}
-	//void SetQueryTimeout(DWORD sec) {m_QueryTimeout = sec;}
-	//void SetUserName(PSZ user) {m_User = user;}
-	//void SetUserPwd(PSZ pwd) {m_Pwd = pwd;}
-	int     GetResultSize(PCSZ sql, JDBCCOL *colp);
-	int     ExecuteQuery(PCSZ sql);
-	int     ExecuteUpdate(PCSZ sql);
-	int     Fetch(int pos = 0);
+	virtual bool Connect(PJPARM sop);
+	virtual bool MakeCursor(PGLOBAL g, PTDB tdbp, PCSZ options,
+		PCSZ filter, bool pipe) {return true;}
+	virtual int  GetResultSize(PCSZ sql, PCOL colp);
+	virtual int  ExecuteCommand(PCSZ sql);
+	virtual int  ExecuteQuery(PCSZ sql);
+	virtual int  ExecuteUpdate(PCSZ sql);
+	virtual int  Fetch(int pos = 0);
+	virtual void SetColumnValue(int rank, PSZ name, PVAL val);
+
+	// Jdbc operations
 	bool    PrepareSQL(PCSZ sql);
-	int     ExecuteSQL(void);
+	int     ExecuteSQL(void);					 // Prepared statement
 	bool    SetParam(JDBCCOL *colp);
-	int     ExecSQLcommand(PCSZ sql);
-	void    SetColumnValue(int rank, PSZ name, PVAL val);
 	int     GetCatInfo(JCATPARM *cap);
-	//bool  GetDataSources(PQRYRES qrp);
 	bool    GetDrivers(PQRYRES qrp);
 	PQRYRES GetMetaData(PGLOBAL g, PCSZ src);
-
-public:
-	// Set static variables
-	static void SetJVM(void) {
-		LibJvm = NULL; 
-	  CreateJavaVM = NULL; 
-	  GetCreatedJavaVMs = NULL;
-#if defined(_DEBUG)
-		GetDefaultJavaVMInitArgs = NULL;
-#endif   // _DEBUG
-	}	// end of SetJVM
-
-	static void ResetJVM(void);
-	static bool GetJVM(PGLOBAL g);
+	int     Rewind(PCSZ sql);
 
 	// Implementation
 public:
 	//virtual ~JDBConn();
 
-	// JDBC operations
-protected:
-	bool gmID(PGLOBAL g, jmethodID& mid, const char *name, const char *sig);
-	bool Check(jint rc = 0);
-//void ThrowDJX(int rc, PSZ msg/*, HSTMT hstmt = SQL_NULL_HSTMT*/);
-//void ThrowDJX(PSZ msg);
-//void Free(void);
-
 protected:
 	// Members
-#if defined(__WIN__)
-	static HANDLE LibJvm;              // Handle to the jvm DLL
-#else   // !__WIN__
-	static void  *LibJvm;              // Handle for the jvm shared library
-#endif  // !__WIN__
-	static CRTJVM CreateJavaVM;
-	static GETJVM GetCreatedJavaVMs;
-#if defined(_DEBUG)
-	static GETDEF GetDefaultJavaVMInitArgs;
-#endif   // _DEBUG
-	PGLOBAL   m_G;
-	TDBJDBC  *m_Tdb;
-	JavaVM   *jvm;                      // Pointer to the JVM (Java Virtual Machine)
-	JNIEnv   *env;                      // Pointer to native interface
-	jclass    jdi;											// Pointer to the java wrapper class
-	jobject   job;											// The java wrapper class object
-	jmethodID xqid;											// The ExecuteQuery method ID
-	jmethodID xuid;											// The ExecuteUpdate method ID
-	jmethodID xid;											// The Execute method ID
-	jmethodID grs;											// The GetResult method ID
-	jmethodID readid;										// The ReadNext method ID
-	jmethodID fetchid;									// The Fetch method ID
-	jmethodID typid;										// The ColumnType method ID
-	jmethodID prepid;										// The CreatePrepStmt method ID
-	jmethodID xpid;										  // The ExecutePrep method ID
-	jmethodID pcid;										  // The ClosePrepStmt method ID
-	jmethodID errid;										// The GetErrmsg method ID
-	jmethodID objfldid;									// The ObjectField method ID
-	jmethodID chrfldid;									// The StringField method ID
-	jmethodID intfldid;									// The IntField method ID
-	jmethodID dblfldid;									// The DoubleField method ID
-	jmethodID fltfldid;									// The FloatField method ID
-	jmethodID datfldid;									// The DateField method ID
-	jmethodID timfldid;									// The TimeField method ID
-	jmethodID tspfldid;									// The TimestampField method ID
-	jmethodID bigfldid;									// The BigintField method ID
-	PCSZ      Msg;
-	char     *m_Wrap;
+#if 0
+	JavaVM   *jvm;              // Pointer to the JVM (Java Virtual Machine)
+	JNIEnv   *env;              // Pointer to native interface
+	jclass    jdi;							// Pointer to the java wrapper class
+	jobject   job;							// The java wrapper class object
+	jmethodID errid;						// The GetErrmsg method ID
+#endif // 0
+	jmethodID xqid;							// The ExecuteQuery method ID
+	jmethodID xuid;							// The ExecuteUpdate method ID
+	jmethodID xid;							// The Execute method ID
+	jmethodID grs;							// The GetResult method ID
+	jmethodID readid;						// The ReadNext method ID
+	jmethodID fetchid;					// The Fetch method ID
+	jmethodID typid;						// The ColumnType method ID
+	jmethodID prepid;						// The CreatePrepStmt method ID
+	jmethodID xpid;							// The ExecutePrep method ID
+	jmethodID pcid;							// The ClosePrepStmt method ID
+	jmethodID objfldid;					// The ObjectField method ID
+	jmethodID chrfldid;					// The StringField method ID
+	jmethodID intfldid;					// The IntField method ID
+	jmethodID dblfldid;					// The DoubleField method ID
+	jmethodID fltfldid;					// The FloatField method ID
+	jmethodID datfldid;					// The DateField method ID
+	jmethodID timfldid;					// The TimeField method ID
+	jmethodID tspfldid;					// The TimestampField method ID
+	jmethodID bigfldid;					// The BigintField method ID
+//	PCSZ      Msg;
+//	PCSZ      m_Wrap;
 	char      m_IDQuoteChar[2];
 	PCSZ      m_Pwd;
   int       m_Ncol;
 	int       m_Aff;
-	int       m_Rows;
 	int       m_Fetch;
 	int       m_RowsetSize;
 	jboolean  m_Updatable;
 	jboolean  m_Transact;
 	jboolean  m_Scrollable;
-	bool      m_Opened;
 	bool      m_Full;
 }; // end of JDBConn class definition

storage/connect/jmgfam.h

+/************** MongoFam H Declares Source Code File (.H) **************/
+/*  Name: jmgfam.h    Version 1.0                                      */
+/*                                                                     */
+/*  (C) Copyright to the author Olivier BERTRAND          2017         */
+/*                                                                     */
+/*  This file contains the JAVA MongoDB access method classes declares */
+/***********************************************************************/
+#pragma once
+
+/***********************************************************************/
+/*  Include MongoDB library header files.                       	  	 */
+/***********************************************************************/
+#include "block.h"
+//#include "mongo.h"
+#include "jmgoconn.h"
+
+typedef class JMGFAM *PJMGFAM;
+typedef class MGODEF *PMGODEF;
+
+/***********************************************************************/
+/*  This is the Java MongoDB Access Method class declaration.          */
+/***********************************************************************/
+class DllExport JMGFAM : public DOSFAM {
+	friend void mongo_init(bool);
+public:
+	// Constructor
+	JMGFAM(PJDEF tdp);
+	JMGFAM(PJMGFAM txfp);
+
+	// Implementation
+	virtual AMT   GetAmType(void) { return TYPE_AM_MGO; }
+	virtual bool  GetUseTemp(void) { return false; }
+	virtual int   GetPos(void);
+	virtual int   GetNextPos(void);
+	virtual PTXF  Duplicate(PGLOBAL g) { return (PTXF)new(g) JMGFAM(this); }
+	void  SetLrecl(int lrecl) { Lrecl = lrecl; }
+
+	// Methods
+	virtual void  Reset(void);
+	virtual int   GetFileLength(PGLOBAL g);
+	virtual int   Cardinality(PGLOBAL g);
+	virtual int   MaxBlkSize(PGLOBAL g, int s);
+	virtual bool  AllocateBuffer(PGLOBAL g) { return false; }
+	virtual int   GetRowID(void);
+	virtual bool  RecordPos(PGLOBAL g);
+	virtual bool  SetPos(PGLOBAL g, int recpos);
+	virtual int   SkipRecord(PGLOBAL g, bool header);
+	virtual bool  OpenTableFile(PGLOBAL g);
+	virtual int   ReadBuffer(PGLOBAL g);
+	virtual int   WriteBuffer(PGLOBAL g);
+	virtual int   DeleteRecords(PGLOBAL g, int irc);
+	virtual void  CloseTableFile(PGLOBAL g, bool abort);
+	virtual void  Rewind(void);
+
+protected:
+	virtual bool  OpenTempFile(PGLOBAL g) { return false; }
+	virtual bool  MoveIntermediateLines(PGLOBAL g, bool *b) { return false; }
+	virtual int   RenameTempFile(PGLOBAL g) { return RC_OK; }
+	virtual int   InitDelete(PGLOBAL g, int fpos, int spos);
+	bool  Init(PGLOBAL g);
+//bool  MakeCursor(PGLOBAL g);
+
+	// Members
+	JMgoConn  *Jcp;              // Points to a Mongo connection class
+	JDBCPARM   Ops;              // Additional parameters
+	PFBLOCK    To_Fbt;           // Pointer to temp file block
+	MODE       Mode;
+	PCSZ       Uristr;
+	PCSZ       Db_name;
+	PCSZ       Coll_name;
+	PCSZ       Options;
+	PCSZ       Filter;
+	PSZ        Wrapname;
+	bool       Done;			       // Init done
+	bool       Pipe;
+	int        Version;
+	int        Curpos;           // Cursor position of last fetch
+}; // end of class JMGFAM
+

storage/connect/jmgoconn.h

+/***********************************************************************/
+/*  JMgoConn.h : header file for the MongoDB connection classes.       */
+/***********************************************************************/
+
+/***********************************************************************/
+/*  Java interface.                                                    */
+/***********************************************************************/
+#include "javaconn.h"
+
+// Java connection to a MongoDB data source
+class TDBJMG;
+class JMGCOL;
+
+/***********************************************************************/
+/*  Include MongoDB library header files.                       	  	 */
+/***********************************************************************/
+typedef class JNCOL  *PJNCOL;
+typedef class MGODEF *PMGODEF;
+typedef class TDBJMG *PTDBJMG;
+typedef class JMGCOL *PJMGCOL;
+
+typedef struct JKCOL {
+	JKCOL *Next;
+	PJNCOL Jncolp;
+	PCOL   Colp;
+	char  *Key;
+	int    N;
+} *PJKC;
+
+/***********************************************************************/
+/*  Used when inserting values in a MongoDB collection.                */
+/***********************************************************************/
+class JNCOL : public BLOCK {
+public:
+	// Constructor
+	JNCOL(bool ar) { Klist = NULL; Array = ar; }
+
+	// Methods
+	void AddCol(PGLOBAL g, PCOL colp, PSZ jp);
+
+	//Members
+	PJKC   Klist;
+	bool   Array;
+}; // end of JNCOL;
+
+/***********************************************************************/
+/*  JMgoConn class.                                                   */
+/***********************************************************************/
+class JMgoConn : public JAVAConn {
+	friend class TDBJMG;
+	friend class JMGDISC;
+	//friend class TDBXJDC;
+	//friend PQRYRES GetColumnInfo(PGLOBAL, char*&, char *, int, PVBLK&);
+private:
+	JMgoConn();                      // Standard (unused) constructor
+
+public:
+	// Constructor
+	JMgoConn(PGLOBAL g, PCSZ collname, PCSZ wrapper);
+
+	// Implementation
+public:
+	virtual void AddJars(PSTRG jpop, char sep);
+	virtual bool Connect(PJPARM sop);
+	virtual bool MakeCursor(PGLOBAL g, PTDB tdbp, PCSZ options, PCSZ filter, bool pipe);
+//	PQRYRES AllocateResult(PGLOBAL g, TDBEXT *tdbp, int n);
+
+	// Attributes
+public:
+//	virtual int   GetMaxValue(int infotype);
+
+public:
+	// Operations
+	virtual int  Fetch(int pos = 0);
+	virtual PSZ  GetColumnValue(PSZ name);
+
+	int     CollSize(PGLOBAL g);
+	bool    FindCollection(PCSZ query, PCSZ proj);
+	bool    AggregateCollection(PCSZ pipeline);
+	void    MakeColumnGroups(PGLOBAL g, PTDB tdbp);
+	bool    GetMethodId(PGLOBAL g, MODE mode);
+	jobject MakeObject(PGLOBAL g, PCOL colp, bool& error);
+	jobject MakeDoc(PGLOBAL g, PJNCOL jcp);
+	int     DocWrite(PGLOBAL g);
+	int     DocUpdate(PGLOBAL g, PTDB tdbp);
+	int     DocDelete(PGLOBAL g, bool all);
+	bool    Rewind(void);
+	PSZ     GetDocument(void);
+
+protected:
+	// Members
+	PCSZ      CollName;									// The collation name
+	jmethodID gcollid;								// The GetCollection method ID
+	jmethodID countid;								  // The GetCollSize method ID
+	jmethodID fcollid;									// The FindColl method ID
+	jmethodID acollid;									// The AggregateColl method ID
+	jmethodID readid;										// The ReadNext method ID
+	jmethodID fetchid;									// The Fetch method ID
+	jmethodID rewindid;									// The Rewind method ID
+	jmethodID getdocid;									// The GetDoc method ID
+	jmethodID objfldid;									// The ObjectField method ID
+	jmethodID mkdocid;									// The MakeDocument method ID
+	jmethodID docaddid;									// The DocAdd method ID
+	jmethodID mkarid;										// The MakeArray method ID
+	jmethodID araddid;									// The ArrayAdd method ID
+	jmethodID insertid;									// The CollInsert method ID
+	jmethodID updateid;									// The CollUpdate method ID
+	jmethodID deleteid;									// The CollDelete method ID
+	PJNCOL    Fpc;				              // To JNCOL classes
+	int       m_Fetch;
+	int       m_Ncol;
+	int       m_Version;								// Java driver version (2 or 3)
+}; // end of JMgoConn class definition

storage/connect/json.h

@@ -13,7 +13,8 @@
 #define X
 #endif
 
-enum JTYP {TYPE_STRG = TYPE_STRING, 
+enum JTYP {TYPE_NULL = TYPE_VOID,
+					 TYPE_STRG = TYPE_STRING, 
            TYPE_DBL  = TYPE_DOUBLE,
            TYPE_BOOL = TYPE_TINY,
            TYPE_BINT = TYPE_BIGINT,
@@ -52,6 +53,8 @@ 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);
+bool  IsNum(PSZ s);
+char *NextChr(PSZ s, char sep);
 
 /***********************************************************************/
 /* Class JOUT. Used by Serialize.                                      */
@@ -146,6 +149,7 @@ class JSON : public BLOCK {
   JSON(void) {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;}
@@ -163,7 +167,7 @@ class JSON : public BLOCK {
   virtual PJPR   GetFirst(void) {X return NULL;}
   virtual int    GetInteger(void) {X return 0;}
   virtual double GetFloat() {X return 0.0;}
-  virtual PSZ    GetString() {X return NULL;}
+  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; }
@@ -193,10 +197,11 @@ class JOBJECT : public JSON {
 
   using JSON::GetValue;
   using JSON::SetValue;
-  virtual void  Clear(void) {First = Last = NULL; Size = 0;}
+	virtual void  Clear(void) {First = Last = NULL; Size = 0;}
   virtual JTYP  GetType(void) {return TYPE_JOB;}
   virtual PJPR  GetFirst(void) {return First;}
-  virtual PJPR  AddPair(PGLOBAL g, PCSZ key);
+	virtual int   GetSize(bool b);
+	virtual PJPR  AddPair(PGLOBAL g, PCSZ key);
   virtual PJOB  GetObject(void) {return this;}
   virtual PJVAL GetValue(const char* key);
 	virtual PJAR  GetKeyList(PGLOBAL g);
@@ -222,11 +227,13 @@ class JARRAY : public JSON {
   using JSON::GetValue;
   using JSON::SetValue;
   virtual void  Clear(void) {First = Last = NULL; Size = 0;}
-  virtual JTYP  GetType(void) {return TYPE_JAR;}
+	virtual JTYP  GetType(void) {return TYPE_JAR;}
   virtual PJAR  GetArray(void) {return this;}
-          PJVAL AddValue(PGLOBAL g, PJVAL jvp = NULL, int *x = NULL);
+	virtual int   GetSize(bool b);
+					PJVAL AddValue(PGLOBAL g, PJVAL jvp = NULL, int *x = NULL);
   virtual void  InitArray(PGLOBAL g);
   virtual PJVAL GetValue(int i);
+	virtual PSZ   GetText(PGLOBAL g, PSZ text);
 	virtual bool  Merge(PGLOBAL g, PJSON jsp);
 	virtual bool  SetValue(PGLOBAL g, PJVAL jvp, int i);
   virtual bool  DeleteValue(int n);
@@ -246,20 +253,20 @@ class JARRAY : public JSON {
 class JVALUE : public JSON {
   friend class JARRAY;
 	friend class JSNX;
+	friend class JSONCOL;
 	friend PJVAL ParseValue(PGLOBAL, int&, STRG&, bool*);
   friend bool  SerializeValue(JOUT *, PJVAL);
  public:
-  JVALUE(void) : JSON() 
-                {Jsp = NULL; Value = NULL; Next = NULL; Del = false;}
+  JVALUE(void) : JSON() {Clear();}
   JVALUE(PJSON jsp) : JSON()
-                {Jsp = jsp; Value = NULL; Next = NULL; Del = false;}
-  JVALUE(PGLOBAL g, PVAL valp);
+		{Jsp = jsp; Value = NULL; Next = NULL; Del = false; Size = 1;}
+	JVALUE(PGLOBAL g, PVAL valp);
 	JVALUE(PGLOBAL g, PCSZ strp);
 
   using JSON::GetValue;
   using JSON::SetValue;
   virtual void   Clear(void)
-          {Jsp = NULL; Value = NULL; Next = NULL; Del = false; Size = 0;}
+          {Jsp = NULL; Value = NULL; Next = NULL; Del = false; Size = 1;}
   virtual JTYP   GetType(void) {return TYPE_JVAL;}
   virtual JTYP   GetValType(void);
   virtual PJOB   GetObject(void);
@@ -270,7 +277,7 @@ class JVALUE : public JSON {
 	virtual int    GetInteger(void);
 	virtual long long GetBigint(void);
 	virtual double GetFloat(void);
-  virtual PSZ    GetString(void);
+  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; }

storage/connect/jsonudf.h

@@ -53,6 +53,18 @@ extern "C" {
 	DllExport char *json_array_delete(UDF_EXEC_ARGS);
 	DllExport void json_array_delete_deinit(UDF_INIT*);
 
+	DllExport my_bool jsonsum_int_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport long long jsonsum_int(UDF_INIT*, UDF_ARGS*, char*, char*);
+	DllExport void jsonsum_int_deinit(UDF_INIT*);
+
+	DllExport my_bool jsonsum_real_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport double jsonsum_real(UDF_INIT*, UDF_ARGS*, char*, char*);
+	DllExport void jsonsum_real_deinit(UDF_INIT*);
+
+	DllExport my_bool jsonavg_real_init(UDF_INIT*, UDF_ARGS*, char*);
+	DllExport double jsonavg_real(UDF_INIT*, UDF_ARGS*, char*, char*);
+	DllExport void jsonavg_real_deinit(UDF_INIT*);
+
 	DllExport my_bool json_make_object_init(UDF_INIT*, UDF_ARGS*, char*);
 	DllExport char *json_make_object(UDF_EXEC_ARGS);
 	DllExport void json_make_object_deinit(UDF_INIT*);