Draft: Feature/mongo db

MongoDB implementation of the long-term memory as part of the bachelor thesis of Robin Müller (utwee_mueller).

Tasks:

• implement a Mixin for the MongoDB version of the LTM
  • set-up and connection to database
  • writing into the database
  • reading from the database
  • adjusting keys
• test MongoDBMixin for different memory servers
  • VisionMemory
  • ObjectMemory
  • RobotStateMemory
  • GraspMemory
  • ...
• Implement an autonomous key selection algorithm

source/RobotAPI/libraries/armem/server/ltm/detail/mixins/util/mongodb.cpp

@@ -39,13 +39,48 @@ namespace armarx::armem::server::ltm::util::mongodb
             return ret;
         }
 
+        //Only for MongoCXX Version < 3.5.0 required.
+        std::vector <std::string>
+        list_database_names(mongocxx::client &client) {
+            std::vector <std::string> database_names;
+
+            auto dbs = client.list_databases();
+
+            for (auto &&view: dbs) {
+                std::string name = std::string(view["name"].get_utf8().value);
+                database_names.push_back(name);
+            }
+            return database_names;
+        }
+
+        //Only for MongoCXX Version < 3.4.0 required.
+        std::vector <std::string>
+        list_collection_names(mongocxx::database &db) {
+            std::vector <std::string> collection_names;
+
+            auto dbs = db.list_collections();;
+
+            for (auto &&view: dbs) {
+                std::string name = std::string(view["name"].get_utf8().value);
+                collection_names.push_back(name);
+            }
+            return collection_names;
+        }
+
         bool
         insert(mongocxx::collection& coll, const nlohmann::json& value)
         {
             std::string v = value.dump();
             auto q = bsoncxx::from_json(v);
+            
+            // Überprüfe die Größe des BSON-Dokuments
+            size_t document_size = q.view().length();
+            if (document_size > 16 * 1024 * 1024) { // 16 MB Grenze
+            ARMARX_INFO << deactivateSpam() << "Document size exceeds the 16MB limit: " << document_size << " bytes." ;
+            return false;
+            }
+            
             auto res = coll.insert_one(q.view());
-
             return (bool)res;
         }
 
@@ -79,16 +114,22 @@ namespace armarx::armem::server::ltm::util::mongodb
         }
     } // namespace detail
 
-    std::optional<mongocxx::database>
-    databaseExists(mongocxx::client& client, const std::string& databaseName)
-    {
-        //auto names = client.list_databases();
-        //if (auto it = std::find(names.begin(), names.end(), databaseName); it != names.end())
-        //{
-        //    return client[databaseName];
-        //}
-        return std::nullopt;
+    std::optional<mongocxx::database> 
+    databaseExists(mongocxx::client& client, const std::string& databaseName) {
+    // MongoCXX Version > 3.5.0 required
+    //auto names = client.list_database_names();
+
+    auto names = detail::list_database_names(client);
+
+    if (auto it = std::find(names.begin(), names.end(), databaseName); it != names.end()) {
+        //Workaround to create an empty Database client[databaseName] does not create a database if nothing is added
+        //db = client[databaseName];
+        //db.create_collection("empty");
+        ARMARX_INFO << deactivateSpam() << "Create Database " << databaseName;
+        return client[databaseName];
     }
+    return std::nullopt;
+}
 
     mongocxx::database
     ensureDatabaseExists(mongocxx::client& client,
@@ -104,6 +145,9 @@ namespace armarx::armem::server::ltm::util::mongodb
                                              databaseName);
             }
         }
+        //Workaround to create an empty Database client[databaseName] does not create a database if nothing is added
+        //db = client[databaseName];
+        //db.create_collection("empty");
         return client[databaseName];
     }
 
@@ -131,6 +175,7 @@ namespace armarx::armem::server::ltm::util::mongodb
                                              collectionName);
             }
         }
+        //Workaround to create an empty Collection db[collectionName] does not create a Collection if no document is added
         return db[collectionName];
     }
 
@@ -171,6 +216,37 @@ namespace armarx::armem::server::ltm::util::mongodb
         return ss.str();
     }
 
+    /*unused
+    std::vector<std::string>
+    getDirectSuccessors(const std::vector<std::string>& collection_names, const std::string& prefix) {
+        std::vector<std::string> direct_successors;
+        for (const auto& coll_name : collection_names) {
+            auto segments = split(coll_name, ".");
+            if (segments.size() > collectionNameDepth) {
+                std::string current_prefix;
+                for (size_t i = 0; i < collectionNameDepth; ++i) {
+                    if (i > 0) {
+                        current_prefix += ".";
+                    }
+                    current_prefix += segments[i];
+                }
+                if (current_prefix == prefix) {
+                    direct_successors.push_back(segments[collectionNameDepth]);
+                }
+            }
+        }
+        // Removing duplicates
+        std::set<std::string> unique_successors(direct_successors.begin(), direct_successors.end());
+        direct_successors.assign(unique_successors.begin(), unique_successors.end());
+        return direct_successors;
+    }
+
+    std::vector<std::string>
+    getSubCollections(mongocxx::database& db, const armem::MemoryID& id) {
+        return getDirectSuccessors(detail::list_collection_names(db), toCollectionName(id));
+    }
+    */
+
     std::optional<nlohmann::json>
     documentExists(mongocxx::collection& collection, const nlohmann::json& json)
     {