Incorporate storage changes.

arangod/RocksDBEngine/RocksDBCollection.cpp

@@ -68,6 +68,14 @@
 
 using namespace arangodb;
 
+namespace {
+LocalDocumentId generateDocumentId(LogicalCollection const& collection,
+                                   TRI_voc_rid_t revisionId) {
+  bool useRev = collection.usesRevisionsAsDocumentIds();
+  return useRev ? LocalDocumentId::create(revisionId) : LocalDocumentId::create();
+}
+}  // namespace
+
 RocksDBCollection::RocksDBCollection(LogicalCollection& collection,
                                      arangodb::velocypack::Slice const& info)
     : RocksDBMetaCollection(collection, info),
@@ -852,7 +860,7 @@ Result RocksDBCollection::insert(arangodb::transaction::Methods* trx,
     }
   }
 
-  LocalDocumentId const documentId = LocalDocumentId::create(revisionId);
+  LocalDocumentId const documentId = ::generateDocumentId(_logicalCollection, revisionId);
 
   RocksDBSavePoint guard(trx, TRI_VOC_DOCUMENT_OPERATION_INSERT);
 
@@ -950,7 +958,7 @@ Result RocksDBCollection::update(arangodb::transaction::Methods* trx,
   if (res.fail()) {
     return res;
   }
-  LocalDocumentId const newDocumentId = LocalDocumentId::create(revisionId);
+  LocalDocumentId const newDocumentId = ::generateDocumentId(_logicalCollection, revisionId);
 
   if (_isDBServer) {
     // Need to check that no sharding keys have changed:
@@ -1050,7 +1058,7 @@ Result RocksDBCollection::replace(transaction::Methods* trx,
   if (res.fail()) {
     return res;
   }
-  LocalDocumentId const newDocumentId = LocalDocumentId::create(revisionId);
+  LocalDocumentId const newDocumentId = ::generateDocumentId(_logicalCollection, revisionId);
 
   if (_isDBServer) {
     // Need to check that no sharding keys have changed:

arangod/VocBase/LogicalCollection.cpp

@@ -142,7 +142,7 @@ LogicalCollection::LogicalCollection(TRI_vocbase_t& vocbase, VPackSlice const& i
           info, "version", static_cast<uint32_t>(currentVersion())))),
       _v8CacheVersion(0),
       _type(Helper::getNumericValue<TRI_col_type_e, int>(info, StaticStrings::DataSourceType,
-                                                          TRI_COL_TYPE_UNKNOWN)),
+                                                         TRI_COL_TYPE_UNKNOWN)),
       _status(Helper::getNumericValue<TRI_vocbase_col_status_e, int>(
           info, "status", TRI_VOC_COL_STATUS_CORRUPTED)),
       _isAStub(isAStub),
@@ -150,6 +150,8 @@ LogicalCollection::LogicalCollection(TRI_vocbase_t& vocbase, VPackSlice const& i
       _isSmart(Helper::getBooleanValue(info, StaticStrings::IsSmart, false)),
       _isSmartChild(Helper::getBooleanValue(info, StaticStrings::IsSmartChild, false)),
 #endif
+      _usesRevisionsAsDocumentIds(
+          Helper::getBooleanValue(info, StaticStrings::UsesRevisionsAsDocumentIds, false)),
       _waitForSync(Helper::getBooleanValue(info, StaticStrings::WaitForSyncString, false)),
       _allowUserKeys(Helper::getBooleanValue(info, "allowUserKeys", true)),
 #ifdef USE_ENTERPRISE
@@ -376,8 +378,7 @@ uint64_t LogicalCollection::numberDocuments(transaction::Methods* trx,
 }
 
 bool LogicalCollection::hasClusterWideUniqueRevs() const {
-  return isSmartChild() &&
-         vocbase().server().getFeature<EngineSelectorFeature>().isRocksDB();
+  return usesRevisionsAsDocumentIds() && isSmartChild();
 }
 
 uint32_t LogicalCollection::v8CacheVersion() const { return _v8CacheVersion; }
@@ -434,6 +435,10 @@ TRI_voc_rid_t LogicalCollection::revision(transaction::Methods* trx) const {
   return _physical->revision(trx);
 }
 
+bool LogicalCollection::usesRevisionsAsDocumentIds() const {
+  return _usesRevisionsAsDocumentIds;
+}
+
 std::unique_ptr<FollowerInfo> const& LogicalCollection::followers() const {
   return _followers;
 }
@@ -678,7 +683,9 @@ arangodb::Result LogicalCollection::appendVelocyPack(arangodb::velocypack::Build
   // Cluster Specific
   result.add(StaticStrings::IsSmart, VPackValue(isSmart()));
   result.add(StaticStrings::IsSmartChild, VPackValue(isSmartChild()));
-
+  result.add(StaticStrings::UsesRevisionsAsDocumentIds,
+             VPackValue(usesRevisionsAsDocumentIds()));
+             
   if (hasSmartJoinAttribute()) {
     result.add(StaticStrings::SmartJoinAttribute, VPackValue(_smartJoinAttribute));
   }

arangod/VocBase/LogicalCollection.h

@@ -145,6 +145,7 @@ class LogicalCollection : public LogicalDataSource {
   bool isSmart() const { return false; }
   bool isSmartChild() const { return false; }
 #endif
+  bool usesRevisionsAsDocumentIds() const;
   /// @brief is this a cluster-wide Plan (ClusterInfo) collection
   bool isAStub() const { return _isAStub; }
   /// @brief is this a cluster-wide Plan (ClusterInfo) collection
@@ -375,7 +376,9 @@ class LogicalCollection : public LogicalDataSource {
   // @brief Flag if this collection is a child of a smart collection (Enterprise only)
   bool const _isSmartChild;
 #endif
-  
+
+  bool const _usesRevisionsAsDocumentIds;
+
   // SECTION: Properties
   bool _waitForSync;
 

arangod/VocBase/Methods/Collections.cpp

@@ -46,6 +46,7 @@
 #include "Scheduler/SchedulerFeature.h"
 #include "Sharding/ShardingFeature.h"
 #include "Sharding/ShardingInfo.h"
+#include "StorageEngine/EngineSelectorFeature.h"
 #include "StorageEngine/PhysicalCollection.h"
 #include "Transaction/Helpers.h"
 #include "Transaction/V8Context.h"
@@ -254,6 +255,9 @@ Result Collections::create(TRI_vocbase_t& vocbase,
   TRI_ASSERT(!vocbase.isDangling());
   bool haveShardingFeature = ServerState::instance()->isCoordinator() &&
                              vocbase.server().hasFeature<ShardingFeature>();
+  bool addUseRevs = ServerState::instance()->isSingleServerOrCoordinator();
+  bool useRevs =
+      vocbase.server().getFeature<arangodb::EngineSelectorFeature>().isRocksDB();
   VPackBuilder builder;
   VPackBuilder helper;
   builder.openArray();
@@ -287,6 +291,11 @@ Result Collections::create(TRI_vocbase_t& vocbase,
     helper.add(arangodb::StaticStrings::DataSourceName,
                arangodb::velocypack::Value(info.name));
 
+    if (addUseRevs) {
+      helper.add(arangodb::StaticStrings::UsesRevisionsAsDocumentIds,
+                 arangodb::velocypack::Value(useRevs));
+    }
+
     if (ServerState::instance()->isCoordinator()) {
       auto replicationFactorSlice = info.properties.get(StaticStrings::ReplicationFactor);
       if (replicationFactorSlice.isNone()) {

js/client/modules/@arangodb/arango-collection.js

@@ -358,7 +358,8 @@ ArangoCollection.prototype.properties = function (properties) {
     'minReplicationFactor': true,
     'distributeShardsLike': false,
     'shardingStrategy': false,
-    'cacheEnabled': true
+    'cacheEnabled': true,
+    'usesRevisionsAsDocumentIds': false
   };
   var a;
 

lib/Basics/StaticStrings.cpp

@@ -242,6 +242,8 @@ std::string const StaticStrings::ShardingStrategy("shardingStrategy");
 std::string const StaticStrings::SmartJoinAttribute("smartJoinAttribute");
 std::string const StaticStrings::Sharding("sharding");
 std::string const StaticStrings::Satellite("satellite");
+std::string const StaticStrings::UsesRevisionsAsDocumentIds(
+    "usesRevisionsAsDocumentIds");
 
 // graph attribute names
 std::string const StaticStrings::GraphCollection("_graphs");

lib/Basics/StaticStrings.h

@@ -224,7 +224,8 @@ class StaticStrings {
   static std::string const SmartJoinAttribute;
   static std::string const Sharding;
   static std::string const Satellite;
-
+  static std::string const UsesRevisionsAsDocumentIds;
+  
   // graph attribute names
   static std::string const GraphCollection;
   static std::string const GraphIsSmart;

tests/IResearch/IResearchAnalyzerFeature-test.cpp

@@ -376,7 +376,7 @@ static const VPackSlice   systemDatabaseArgs = systemDatabaseBuilder.slice();
 class IResearchAnalyzerFeatureTest
     : public ::testing::Test,
       public arangodb::tests::LogSuppressor<arangodb::Logger::AUTHENTICATION, arangodb::LogLevel::ERR>,
-      public arangodb::tests::LogSuppressor<arangodb::Logger::CLUSTER, arangodb::LogLevel::WARN> {
+      public arangodb::tests::LogSuppressor<arangodb::Logger::CLUSTER, arangodb::LogLevel::FATAL> {
  protected:
   struct ClusterCommControl : arangodb::ClusterComm {
     static void reset() { arangodb::ClusterComm::_theInstanceInit.store(0); }
@@ -2397,6 +2397,7 @@ TEST_F(IResearchAnalyzerFeatureTest, test_tokens) {
   auto& sharding = newServer.addFeature<arangodb::ShardingFeature>();
   auto& systemdb = newServer.addFeature<arangodb::SystemDatabaseFeature>();
   newServer.addFeature<arangodb::V8DealerFeature>();  // required for DatabaseFeature::createDatabase>(std::make_unique<arangodb::V8DealerFeature(server)); // required for DatabaseFeature::createDatabase>(...)
+  newServer.addFeature<arangodb::EngineSelectorFeature>();
 
   auto cleanup = arangodb::scopeGuard([&dbfeature]() { dbfeature.unprepare(); });
 
@@ -3273,6 +3274,7 @@ TEST_F(IResearchAnalyzerFeatureTest, test_visit) {
   newServer.addFeature<arangodb::QueryRegistryFeature>();  // required for constructing TRI_vocbase_t
   auto& sysDatabase = newServer.addFeature<arangodb::SystemDatabaseFeature>();  // required for IResearchAnalyzerFeature::start()
   newServer.addFeature<arangodb::V8DealerFeature>();  // required for DatabaseFeature::createDatabase>(std::make_unique<arangodb::V8DealerFeature(server)); // required for DatabaseFeature::createDatabase>(...)
+  newServer.addFeature<arangodb::EngineSelectorFeature>();
 
   // create system vocbase (before feature start)
   {
@@ -3539,6 +3541,7 @@ TEST_F(IResearchAnalyzerFeatureTest, custom_analyzers_toVelocyPack) {
   newServer.addFeature<arangodb::QueryRegistryFeature>();  // required for constructing TRI_vocbase_t
   auto& sysDatabase = newServer.addFeature<arangodb::SystemDatabaseFeature>();  // required for IResearchAnalyzerFeature::start()
   newServer.addFeature<arangodb::V8DealerFeature>();  // required for DatabaseFeature::createDatabase>(std::make_unique<arangodb::V8DealerFeature(server)); // required for DatabaseFeature::createDatabase>(...)
+  newServer.addFeature<arangodb::EngineSelectorFeature>();
   auto cleanup = arangodb::scopeGuard([&dbFeature]() { dbFeature.unprepare(); });
 
   // create system vocbase (before feature start)
@@ -3640,6 +3643,7 @@ TEST_F(IResearchAnalyzerFeatureTest, custom_analyzers_vpack_create) {
   newServer.addFeature<arangodb::QueryRegistryFeature>();  // required for constructing TRI_vocbase_t
   auto& sysDatabase = newServer.addFeature<arangodb::SystemDatabaseFeature>();  // required for IResearchAnalyzerFeature::start()
   newServer.addFeature<arangodb::V8DealerFeature>();  // required for DatabaseFeature::createDatabase>(std::make_unique<arangodb::V8DealerFeature(server)); // required for DatabaseFeature::createDatabase>(...)
+  newServer.addFeature<arangodb::EngineSelectorFeature>();
   auto cleanup = arangodb::scopeGuard([&dbFeature]() { dbFeature.unprepare(); });
 
   // create system vocbase (before feature start)

tests/js/common/shell/shell-collection.js

@@ -533,6 +533,31 @@ function CollectionSuite () {
       db._drop(cn);
     },
 
+////////////////////////////////////////////////////////////////////////////////
+/// @brief check that properties include usesRevisionsAsDocumentIds
+////////////////////////////////////////////////////////////////////////////////
+
+    testUsesRevisionsAsDocumentIds: function () {
+      var cn = "example";
+
+      db._drop(cn);
+      var c1 = db._create(cn);
+
+      assertTypeOf("string", c1._id);
+      assertEqual(cn, c1.name());
+      assertTypeOf("number", c1.status());
+      assertEqual(ArangoCollection.TYPE_DOCUMENT, c1.type());
+      assertTypeOf("number", c1.type());
+
+      var p = c1.properties();
+
+      var isRocksDB = db._engine().name === "rocksdb";
+      assertEqual(true, p.hasOwnProperty("usesRevisionsAsDocumentIds"));
+      assertEqual(isRocksDB, p.usesRevisionsAsDocumentIds);
+
+      db._drop(cn);
+    },
+
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief drop new-born
 ////////////////////////////////////////////////////////////////////////////////