Remove ability to synchronize objects without primary key

With the legacy server this was based on GlobalKey, but if we at some
point will allow objects without primary key to be synced to MongoDB
server, we will probably have to invent a new strategy.

As we remove support for GlobalKey we will have to change the way we
allocate ObjKeys for tombstones. Beforehand we used a hash of the
primary key to construct a GlobalKey and from that an ObjKey. Now we just
use the current ObjKey to construct a corresponding unresolved key. But
it has the effect that there is not an easy way to come from primary key
to potential unresolved key, so we will have to search for a potential
tombstone.

Author: jedelbo

src/realm/cluster_tree.cpp

@@ -994,7 +994,6 @@ void ClusterTree::erase(ObjKey k, CascadeState& state)
             }
         }
     }
-    m_owner->free_local_id_after_hash_collision(k);
     m_owner->erase_from_search_indexes(k);
 
     size_t root_size = m_root->erase(k, state);

src/realm/obj.cpp

@@ -114,11 +114,6 @@ Obj::Obj(TableRef table, MemRef mem, ObjKey key, size_t row_ndx)
     m_storage_version = get_alloc().get_storage_version();
 }
 
-GlobalKey Obj::get_object_id() const
-{
-    return m_table->get_object_id(m_key);
-}
-
 ObjLink Obj::get_link() const
 {
     return ObjLink(m_table->get_key(), m_key);

src/realm/obj.hpp

@@ -34,7 +34,6 @@ class ClusterTree;
 class TableView;
 class CascadeState;
 class ObjList;
-struct GlobalKey;
 
 template <class>
 class Lst;
@@ -114,7 +113,6 @@ class Obj : public CollectionParent {
     {
         return m_key;
     }
-    GlobalKey get_object_id() const;
     ObjLink get_link() const;
 
     /// Check if the object is still alive

src/realm/replication.cpp

@@ -139,13 +139,13 @@ void Replication::erase_column(const Table* t, ColKey col_key)
     m_encoder.erase_column(col_key); // Throws
 }
 
-void Replication::create_object(const Table* t, GlobalKey id)
+void Replication::create_object(const Table* t, ObjKey key)
 {
     if (auto logger = get_logger()) {
         logger->log(util::Logger::Level::debug, "Create object '%1'", t->get_class_name());
     }
     select_table(t);                              // Throws
-    m_encoder.create_object(id.get_local_key(0)); // Throws
+    m_encoder.create_object(key);                 // Throws
 }
 
 void Replication::create_object_with_primary_key(const Table* t, ObjKey key, Mixed pk)

src/realm/replication.hpp

@@ -74,7 +74,7 @@ class Replication {
     virtual void dictionary_erase(const CollectionBase& dict, size_t dict_ndx, Mixed key);
     virtual void dictionary_clear(const CollectionBase& dict);
 
-    virtual void create_object(const Table*, GlobalKey);
+    virtual void create_object(const Table*, ObjKey);
     virtual void create_object_with_primary_key(const Table*, ObjKey, Mixed);
     virtual void remove_object(const Table*, ObjKey);
 

src/realm/sync/instruction_applier.cpp

@@ -226,11 +226,8 @@ void InstructionApplier::operator()(const Instruction::CreateObject& instr)
                 }
                 m_last_object = table->create_object_with_primary_key(id);
             },
-            [&](GlobalKey key) {
-                if (pk_col) {
-                    bad_transaction_log("CreateObject(GlobalKey) on table with a primary key");
-                }
-                m_last_object = table->create_object(key);
+            [&](GlobalKey) {
+                bad_transaction_log("CreateObject(GlobalKey) not supported");
             },
         },
         instr.object);
@@ -1682,14 +1679,9 @@ ObjKey InstructionApplier::get_object_key(Table& table, const Instruction::Prima
                 ObjKey key = table.get_objkey_from_primary_key(pk);
                 return key;
             },
-            [&](GlobalKey id) {
-                if (pk_col) {
-                    bad_transaction_log(
-                        "%1 instruction without primary key, but table '%2' has a primary key column of type %3",
-                        name, table_name, pk_type);
-                }
-                ObjKey key = table.get_objkey_from_global_key(id);
-                return key;
+            [&](GlobalKey) {
+                bad_transaction_log("%1 instruction without primary key not supported", name);
+                return ObjKey();
             },
             [&](ObjectId pk) {
                 if (!pk_col) {

src/realm/sync/instruction_replication.cpp

@@ -242,26 +242,6 @@ void SyncReplication::add_class_with_primary_key(TableKey tk, StringData name, D
     }
 }
 
-void SyncReplication::create_object(const Table* table, GlobalKey oid)
-{
-    if (table->is_embedded()) {
-        unsupported_instruction(); // FIXME: TODO
-    }
-
-    Replication::create_object(table, oid);
-    if (select_table(*table)) {
-        if (table->get_primary_key_column()) {
-            // Trying to create object without a primary key in a table that
-            // has a primary key column.
-            unsupported_instruction();
-        }
-        Instruction::CreateObject instr;
-        instr.table = m_last_class_name;
-        instr.object = oid;
-        emit(instr);
-    }
-}
-
 Instruction::PrimaryKey SyncReplication::as_primary_key(Mixed value)
 {
     if (value.is_null()) {
@@ -749,13 +729,7 @@ Instruction::PrimaryKey SyncReplication::primary_key_for_object(const Table& tab
 {
     bool should_emit = select_table(table);
     REALM_ASSERT(should_emit);
-
-    if (table.get_primary_key_column()) {
-        return as_primary_key(table.get_primary_key(key));
-    }
-
-    GlobalKey global_key = table.get_object_id(key);
-    return global_key;
+    return as_primary_key(table.get_primary_key(key));
 }
 
 void SyncReplication::populate_path_instr(Instruction::PathInstruction& instr, const Table& table, ObjKey key,

src/realm/sync/instruction_replication.hpp

@@ -48,7 +48,6 @@ class SyncReplication : public Replication {
     void add_class(TableKey tk, StringData table_name, Table::Type table_type = Table::Type::TopLevel) final;
     void add_class_with_primary_key(TableKey tk, StringData table_name, DataType pk_type, StringData pk_field,
                                     bool nullable, Table::Type table_type) final;
-    void create_object(const Table*, GlobalKey) final;
     void create_object_with_primary_key(const Table*, ObjKey, Mixed) final;
 
     void erase_class(TableKey table_key, StringData table_name, size_t num_tables) final;