revert group::write change + more tests for checking compression

Author: nicola-cab

src/realm/group.cpp

@@ -1012,10 +1012,6 @@ ref_type Group::DefaultTableWriter::write_names(_impl::OutputStream& out)
 }
 ref_type Group::DefaultTableWriter::write_tables(_impl::OutputStream& out)
 {
-    // bool deep = true;              // Deep
-    // bool only_if_modified = false; // Always
-    // bool compress = false;         // true;
-    // return m_group->m_tables.write(out, deep, only_if_modified, compress); // Throws
     return m_group->typed_write_tables(out);
 }
 
@@ -1151,12 +1147,7 @@ void Group::write(std::ostream& out, int file_format_version, TableWriter& table
         // DB to compact the database by writing only the live data
         // into a separate file.
         ref_type names_ref = table_writer.write_names(out_2);   // Throws
-
-        // compress the tables
-        out_2.only_modified = false;
-        out_2.compress = true;
-        ref_type tables_ref = table_writer.typed_write_tables(out_2); // Throws
-        out_2.compress = false;                                       // disable compression for other tables/arrays
+        ref_type tables_ref = table_writer.write_tables(out_2);
 
         SlabAlloc new_alloc;
         new_alloc.attach_empty(); // Throws

src/realm/group.hpp

@@ -1133,10 +1133,7 @@ class Group::TableWriter {
     {
         m_group->typed_print(prefix);
     }
-    ref_type typed_write_tables(_impl::OutputStream& out)
-    {
-        return m_group->typed_write_tables(out);
-    }
+
     virtual ~TableWriter() noexcept {}
 
     void set_group(const Group* g)

test/test_group.cpp

@@ -2363,4 +2363,103 @@ TEST(Group_ArrayCompression_Correctness)
 #endif
 }
 
+TEST(Group_ArrayCompression_Correctness_Negative)
+{
+    GROUP_TEST_PATH(path);
+
+    // Create group with one list<int> which maps to array_integer
+    Group to_disk;
+    TableRef table = to_disk.add_table("test");
+    auto col_key = table->add_column_list(type_Int, "lint");
+    auto obj = table->create_object();
+    auto array = obj.get_list<int64_t>(col_key);
+
+    array.add(-1);
+    array.add(-1);
+    array.add(-1);
+    array.add(-1);
+    array.add(std::numeric_limits<int64_t>::max());
+    array.add(std::numeric_limits<int64_t>::max());
+
+    CHECK_EQUAL(array.size(), 6);
+    CHECK_EQUAL(array.get_any(0).get_int(), -1);
+    CHECK_EQUAL(array.get_any(1).get_int(), -1);
+    CHECK_EQUAL(array.get_any(2).get_int(), -1);
+    CHECK_EQUAL(array.get_any(3).get_int(), -1);
+    CHECK_EQUAL(array.get_any(4).get_int(), std::numeric_limits<int64_t>::max());
+    CHECK_EQUAL(array.get_any(5).get_int(), std::numeric_limits<int64_t>::max());
+
+    // Serialize to disk (compression should happen when the proper leaf array is serialized to disk)
+    to_disk.write(path, crypt_key());
+
+#ifdef REALM_DEBUG
+    to_disk.verify();
+#endif
+
+    // Load the tables
+    Group from_disk(path, crypt_key());
+    TableRef read_table = from_disk.get_table("test");
+    auto col_key1 = read_table->get_column_key("lint");
+    auto obj1 = read_table->get_object(0);
+    auto l1 = obj1.get_list<int64_t>(col_key1);
+    CHECK(l1.size() == array.size());
+    CHECK(*read_table == *table);
+    for (size_t i = 0; i < l1.size(); ++i) {
+        CHECK_EQUAL(l1.get_any(i), array.get_any(i));
+    }
+
+#ifdef REALM_DEBUG
+    from_disk.verify();
+#endif
+}
+
+TEST(Group_ArrayCompression_Correctness_Random_Input)
+{
+    GROUP_TEST_PATH(path);
+
+    // Create group with one list<int> which maps to array_integer
+    Group to_disk;
+    TableRef table = to_disk.add_table("test");
+    auto col_key = table->add_column_list(type_Int, "lint");
+    auto obj = table->create_object();
+    auto array = obj.get_list<int64_t>(col_key);
+
+    std::random_device dev;
+    std::mt19937 rng(dev());
+    constexpr auto min = std::numeric_limits<int64_t>::min();
+    constexpr auto max = std::numeric_limits<int64_t>::max();
+    std::uniform_int_distribution<std::mt19937::result_type> dist6(static_cast<unsigned int>(min),
+                                                                   static_cast<unsigned int>(max));
+    for (size_t i = 0; i < 1000; ++i) {
+        const auto v = dist6(rng);
+        array.add(v);
+        const auto stored_v = array.get_any(i).get_int();
+        CHECK_EQUAL(stored_v, v);
+    }
+
+    // Serialize to disk (compression should happen when the proper leaf array is serialized to disk)
+    to_disk.write(path, crypt_key());
+
+#ifdef REALM_DEBUG
+    to_disk.verify();
+#endif
+
+    // Load the tables
+    Group from_disk(path, crypt_key());
+    TableRef read_table = from_disk.get_table("test");
+    auto col_key1 = read_table->get_column_key("lint");
+    auto obj1 = read_table->get_object(0);
+    auto l1 = obj1.get_list<int64_t>(col_key1);
+    CHECK(l1.size() == array.size());
+    CHECK(*read_table == *table);
+    for (size_t i = 0; i < l1.size(); ++i) {
+        CHECK_EQUAL(l1.get_any(i), array.get_any(i));
+    }
+
+#ifdef REALM_DEBUG
+    from_disk.verify();
+#endif
+}
+
+
 #endif // TEST_GROUP