MonCaché - implementation of the MongoDB API based on InterSystems Caché

IDEA

The idea of the project is to try to implement the basic functions of the MongoDB API to search, save, update and delete documents so that you can use InterSystems Caché without changing the client code instead of MongoDB.

MOTIVATION

Perhaps if you take the MongoDB interface and use InterSystems Caché as a data warehouse, you can get some performance gain.

Well, why not ?! ¯ \ _ (ツ) _ / ¯

LIMITATIONS

Within the framework of the research project, several simplifications were made:
- only primitive data types are used :
- null, boolean, number, string, array, object, ObjectId;
- client code works with MongoDB through the MongoDB driver;
- client code uses MongoDB Node.js driver;
- client code uses only the basic MongoDB API functions:
- find , findOne - search for documents;
- save , insert - save documents;
- update - update documents;
- remove - delete documents;
- count - counting documents.
')

REALIZATION

As a result, the task was divided into the following subtasks:
- play the MongoDB Node.js driver interface using the selected basic functions;
- implement this interface using as a data warehouse - InterSystems Caché:
- develop a database presentation scheme in Caché;
- develop a scheme for the presentation of collections in Caché;
- develop a scheme for the submission of documents in Caché;
- develop a scheme for interaction with Caché using Node.js;
- implement the developed schemes and test a little . :)

IMPLEMENTATION DETAILS

There were no special difficulties with the first subtask, so I will go straight to the subtask of the implementation of the interface.

MongoDB defines the database as a physical container for collections . And the collection as a set of documents . And finally, the document as a data set. The document is similar to a JSON document, but with a large number of valid types - BSON .

In InterSystems Caché, all data is stored in globals . Simply, you can think of globala as hierarchical data structures.

In this project, all data will be stored in one global - ^ MonCache .

Thus, it is required to develop a diagram of the presentation of the database, collections and documents using hierarchical data structures.

Database representation scheme in Caché

In MongoDB, there can be several databases on one instance, which means you need to develop a presentation scheme that allows you to store several databases that would be isolated from each other. It is also important to note that MongoDB supports non-collection databases (hereinafter referred to as “empty” databases).

I chose the simplest and most obvious way to solve the problem. Databases are represented by the first level node in the global ^ MonCache. In addition, the value of "" is assigned to such a node in order to implement support for "empty" databases. The thing is that if you do not do this and simply add child nodes, then as soon as all child nodes are deleted, the parent node will also be removed (features of globals).

Total, each database is represented in Caché as follows:

^MonCache(<db>) = ""

For example, the database representation "my_database" would be:

 ^MonCache("my_database") = ""

Caché Collections Presentation Scheme

MongoDB defines a collection as a database item. All collections in one database have a unique name, which means the name can be used to uniquely identify the collection. This fact allowed me to find an easy way to present collections in the global, namely to use second-level nodes. Now we need to solve two small problems. The first is that, like databases, collections can also be empty. The second is that the collection is a collection of documents. And all documents must be isolated from each other. Honestly, I never thought of anything better than storing a counter, something like an auto-increment value, as the value of a collection node. All documents have their own unique number. When a new document is inserted into the collection, a node is created with the name equal to the current counter value, and then the counter value is increased by 1.

In total, each collection is represented in Caché as follows:

 ^MonCache(<db>) = "" ^MonCache(<db>, <collection>) = 0

For example, the representation of the collection “my_collection” in the database “my_database” would be:

 ^MonCache("my_database") = "" ^MonCache("my_database", "my_collection") = 0

Caché Document Submission Scheme

The document in this project is a JSON document extended by an additional type - ObjectId. It was necessary to develop a scheme for the presentation of documents on hierarchical data structures. Here I had a few surprises. Firstly, there is no way to use native null in Caché, since Caché does not support null. The second interesting point is that boolean values are implemented with constants 0 and 1. That is, roughly speaking, true - 1, false - 0. The most expected problem point was what you need to think of how to store an ObjectId. In general, all these problems have been successfully solved in the most, as it seemed to me, simple form. Next, I will look at each data type and its presentation.

Presentation schemes

For a more concise record, I will use a special notation - @ .
Instead of ^ MonCache (<db>, <collection>, <document id>, ...) I'll just write
@ (...) .

Let there be a field f of the type “null”.

 f: null