datasketches 0.3.1 → 0.3.2

data/vendor/datasketches-cpp/theta/include/compact_theta_sketch_parser.hpp

@@ -20,7 +20,7 @@
 #ifndef COMPACT_THETA_SKETCH_PARSER_HPP_
 #define COMPACT_THETA_SKETCH_PARSER_HPP_
 
-#include <stdint.h>
+#include <cstdint>
 
 namespace datasketches {
 
@@ -33,7 +33,8 @@ public:
     uint16_t seed_hash;
     uint32_t num_entries;
     uint64_t theta;
-    const uint64_t* entries;
+    const void* entries_start_ptr;
+    uint8_t entry_bits;
   };
 
   static compact_theta_sketch_data parse(const void* ptr, size_t size, uint64_t seed, bool dump_on_error = false);
@@ -45,18 +46,23 @@ private:
   static const size_t COMPACT_SKETCH_TYPE_BYTE = 2;
   static const size_t COMPACT_SKETCH_FLAGS_BYTE = 5;
   static const size_t COMPACT_SKETCH_SEED_HASH_U16 = 3;
-  static const size_t COMPACT_SKETCH_NUM_ENTRIES_U32 = 2;
-  static const size_t COMPACT_SKETCH_SINGLE_ENTRY_U64 = 1;
-  static const size_t COMPACT_SKETCH_ENTRIES_EXACT_U64 = 2;
-  static const size_t COMPACT_SKETCH_THETA_U64 = 2;
-  static const size_t COMPACT_SKETCH_ENTRIES_ESTIMATION_U64 = 3;
+  static const size_t COMPACT_SKETCH_SINGLE_ENTRY_U64 = 1; // ver 3
+  static const size_t COMPACT_SKETCH_NUM_ENTRIES_U32 = 2; // ver 1-3
+  static const size_t COMPACT_SKETCH_ENTRIES_EXACT_U64 = 2; // ver 1-3
+  static const size_t COMPACT_SKETCH_ENTRIES_ESTIMATION_U64 = 3; // ver 1-3
+  static const size_t COMPACT_SKETCH_THETA_U64 = 2; // ver 1-3
+  static const size_t COMPACT_SKETCH_V4_ENTRY_BITS_BYTE = 3;
+  static const size_t COMPACT_SKETCH_V4_NUM_ENTRIES_BYTES_BYTE = 4;
+  static const size_t COMPACT_SKETCH_V4_THETA_U64 = 1;
+  static const size_t COMPACT_SKETCH_V4_PACKED_DATA_EXACT_BYTE = 8;
+  static const size_t COMPACT_SKETCH_V4_PACKED_DATA_ESTIMATION_BYTE = 16;
 
   static const uint8_t COMPACT_SKETCH_IS_EMPTY_FLAG = 2;
   static const uint8_t COMPACT_SKETCH_IS_ORDERED_FLAG = 4;
 
-  static const uint8_t COMPACT_SKETCH_SERIAL_VERSION = 3;
   static const uint8_t COMPACT_SKETCH_TYPE = 3;
 
+  static void check_memory_size(const void* ptr, size_t actual_bytes, size_t expected_bytes, bool dump_on_error);
   static std::string hex_dump(const uint8_t* ptr, size_t size);
 };
 

data/vendor/datasketches-cpp/theta/include/compact_theta_sketch_parser_impl.hpp

@@ -26,106 +26,120 @@
 
 namespace datasketches {
 
+template<typename T>
+T whole_bytes_to_hold_bits(T bits) {
+  static_assert(std::is_integral<T>::value, "integral type expected");
+  return (bits >> 3) + ((bits & 7) > 0);
+}
+
 template<bool dummy>
 auto compact_theta_sketch_parser<dummy>::parse(const void* ptr, size_t size, uint64_t seed, bool dump_on_error) -> compact_theta_sketch_data {
-  if (size < 8) throw std::out_of_range("at least 8 bytes expected, actual " + std::to_string(size)
-      + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), size)) : ""));
-
+  check_memory_size(ptr, size, 8, dump_on_error);
+  checker<true>::check_sketch_type(reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_TYPE_BYTE], COMPACT_SKETCH_TYPE);
   uint8_t serial_version = reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_SERIAL_VERSION_BYTE];
-
   switch(serial_version) {
-  case COMPACT_SKETCH_SERIAL_VERSION: {
-      checker<true>::check_sketch_type(reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_TYPE_BYTE], COMPACT_SKETCH_TYPE);
+  case 4: {
+    // version 4 sketches are ordered and always have entries (single item in exact mode is v3)
+    const uint16_t seed_hash = reinterpret_cast<const uint16_t*>(ptr)[COMPACT_SKETCH_SEED_HASH_U16];
+    checker<true>::check_seed_hash(seed_hash, compute_seed_hash(seed));
+    const bool has_theta = reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_PRE_LONGS_BYTE] > 1;
+    uint64_t theta = theta_constants::MAX_THETA;
+    if (has_theta) {
+      check_memory_size(ptr, size, 16, dump_on_error);
+      theta = reinterpret_cast<const uint64_t*>(ptr)[COMPACT_SKETCH_V4_THETA_U64];
+    }
+    const uint8_t num_entries_bytes = reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_V4_NUM_ENTRIES_BYTES_BYTE];
+    size_t data_offset_bytes = has_theta ? COMPACT_SKETCH_V4_PACKED_DATA_ESTIMATION_BYTE : COMPACT_SKETCH_V4_PACKED_DATA_EXACT_BYTE;
+    check_memory_size(ptr, size, data_offset_bytes + num_entries_bytes, dump_on_error);
+    uint32_t num_entries = 0;
+    const uint8_t* num_entries_ptr = reinterpret_cast<const uint8_t*>(ptr) + data_offset_bytes;
+    for (unsigned i = 0; i < num_entries_bytes; ++i) {
+      num_entries |= (*num_entries_ptr++) << (i << 3);
+    }
+    data_offset_bytes += num_entries_bytes;
+    const uint8_t entry_bits = reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_V4_ENTRY_BITS_BYTE];
+    const size_t expected_bits = entry_bits * num_entries;
+    const size_t expected_size_bytes = data_offset_bytes + whole_bytes_to_hold_bits(expected_bits);
+    check_memory_size(ptr, size, expected_size_bytes, dump_on_error);
+    return {false, true, seed_hash, num_entries, theta,
+      reinterpret_cast<const uint8_t*>(ptr) + data_offset_bytes, entry_bits};
+  }
+  case 3: {
       uint64_t theta = theta_constants::MAX_THETA;
       const uint16_t seed_hash = reinterpret_cast<const uint16_t*>(ptr)[COMPACT_SKETCH_SEED_HASH_U16];
       if (reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_FLAGS_BYTE] & (1 << COMPACT_SKETCH_IS_EMPTY_FLAG)) {
-        return {true, true, seed_hash, 0, theta, nullptr};
+        return {true, true, seed_hash, 0, theta, nullptr, 64};
       }
       checker<true>::check_seed_hash(seed_hash, compute_seed_hash(seed));
       const bool has_theta = reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_PRE_LONGS_BYTE] > 2;
       if (has_theta) {
-        if (size < 16) throw std::out_of_range("at least 16 bytes expected, actual " + std::to_string(size));
+        check_memory_size(ptr, size, (COMPACT_SKETCH_THETA_U64 + 1) * sizeof(uint64_t), dump_on_error);
         theta = reinterpret_cast<const uint64_t*>(ptr)[COMPACT_SKETCH_THETA_U64];
       }
       if (reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_PRE_LONGS_BYTE] == 1) {
-        if (size < 16) throw std::out_of_range("at least 16 bytes expected, actual " + std::to_string(size));
-        return {false, true, seed_hash, 1, theta, reinterpret_cast<const uint64_t*>(ptr) + COMPACT_SKETCH_SINGLE_ENTRY_U64};
+        check_memory_size(ptr, size, 16, dump_on_error);
+        return {false, true, seed_hash, 1, theta, reinterpret_cast<const uint64_t*>(ptr) + COMPACT_SKETCH_SINGLE_ENTRY_U64, 64};
       }
       const uint32_t num_entries = reinterpret_cast<const uint32_t*>(ptr)[COMPACT_SKETCH_NUM_ENTRIES_U32];
       const size_t entries_start_u64 = has_theta ? COMPACT_SKETCH_ENTRIES_ESTIMATION_U64 : COMPACT_SKETCH_ENTRIES_EXACT_U64;
       const uint64_t* entries = reinterpret_cast<const uint64_t*>(ptr) + entries_start_u64;
       const size_t expected_size_bytes = (entries_start_u64 + num_entries) * sizeof(uint64_t);
-      if (size < expected_size_bytes) {
-        throw std::out_of_range(std::to_string(expected_size_bytes) + " bytes expected, actual " + std::to_string(size)
-            + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), size)) : ""));
-      }
+      check_memory_size(ptr, size, expected_size_bytes, dump_on_error);
       const bool is_ordered = reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_FLAGS_BYTE] & (1 << COMPACT_SKETCH_IS_ORDERED_FLAG);
-      return {false, is_ordered, seed_hash, num_entries, theta, entries};
+      return {false, is_ordered, seed_hash, num_entries, theta, entries, 64};
   }
   case 1:  {
       uint16_t seed_hash = compute_seed_hash(seed);
-      checker<true>::check_sketch_type(reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_TYPE_BYTE], COMPACT_SKETCH_TYPE);
       const uint32_t num_entries = reinterpret_cast<const uint32_t*>(ptr)[COMPACT_SKETCH_NUM_ENTRIES_U32];
       uint64_t theta = reinterpret_cast<const uint64_t*>(ptr)[COMPACT_SKETCH_THETA_U64];
       bool is_empty = (num_entries == 0) && (theta == theta_constants::MAX_THETA);
-      if (is_empty) {
-          return {true, true, seed_hash, 0, theta, nullptr};
-      }
+      if (is_empty) return {true, true, seed_hash, 0, theta, nullptr, 64};
       const uint64_t* entries = reinterpret_cast<const uint64_t*>(ptr) + COMPACT_SKETCH_ENTRIES_ESTIMATION_U64;
       const size_t expected_size_bytes = (COMPACT_SKETCH_ENTRIES_ESTIMATION_U64 + num_entries) * sizeof(uint64_t);
-      if (size < expected_size_bytes) {
-        throw std::out_of_range(std::to_string(expected_size_bytes) + " bytes expected, actual " + std::to_string(size)
-            + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), size)) : ""));
-      }
-      return {false, true, seed_hash, num_entries, theta, entries};
+      check_memory_size(ptr, size, expected_size_bytes, dump_on_error);
+      return {false, true, seed_hash, num_entries, theta, entries, 64};
   }
   case 2:  {
-      uint8_t preamble_size =  reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_PRE_LONGS_BYTE];
-      checker<true>::check_sketch_type(reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_TYPE_BYTE], COMPACT_SKETCH_TYPE);
+      uint8_t preamble_size = reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_PRE_LONGS_BYTE];
       const uint16_t seed_hash = reinterpret_cast<const uint16_t*>(ptr)[COMPACT_SKETCH_SEED_HASH_U16];
       checker<true>::check_seed_hash(seed_hash, compute_seed_hash(seed));
       if (preamble_size == 1) {
-          return {true, true, seed_hash, 0, theta_constants::MAX_THETA, nullptr};
+          return {true, true, seed_hash, 0, theta_constants::MAX_THETA, nullptr, 64};
       } else if (preamble_size == 2) {
           const uint32_t num_entries = reinterpret_cast<const uint32_t*>(ptr)[COMPACT_SKETCH_NUM_ENTRIES_U32];
           if (num_entries == 0) {
-              return {true, true, seed_hash, 0, theta_constants::MAX_THETA, nullptr};
+              return {true, true, seed_hash, 0, theta_constants::MAX_THETA, nullptr, 64};
           } else {
               const size_t expected_size_bytes = (preamble_size + num_entries) << 3;
-              if (size < expected_size_bytes) {
-                  throw std::out_of_range(std::to_string(expected_size_bytes) + " bytes expected, actual " + std::to_string(size)
-                      + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), size)) : ""));
-              }
+              check_memory_size(ptr, size, expected_size_bytes, dump_on_error);
               const uint64_t* entries = reinterpret_cast<const uint64_t*>(ptr) + COMPACT_SKETCH_ENTRIES_EXACT_U64;
-              return {false, true, seed_hash, num_entries, theta_constants::MAX_THETA, entries};
+              return {false, true, seed_hash, num_entries, theta_constants::MAX_THETA, entries, 64};
           }
       } else if (preamble_size == 3) {
           const uint32_t num_entries = reinterpret_cast<const uint32_t*>(ptr)[COMPACT_SKETCH_NUM_ENTRIES_U32];
           uint64_t theta = reinterpret_cast<const uint64_t*>(ptr)[COMPACT_SKETCH_THETA_U64];
           bool is_empty = (num_entries == 0) && (theta == theta_constants::MAX_THETA);
-          if (is_empty) {
-              return {true, true, seed_hash, 0, theta, nullptr};
-          }
+          if (is_empty) return {true, true, seed_hash, 0, theta, nullptr, 64};
           const uint64_t* entries = reinterpret_cast<const uint64_t*>(ptr) + COMPACT_SKETCH_ENTRIES_ESTIMATION_U64;
           const size_t expected_size_bytes = (COMPACT_SKETCH_ENTRIES_ESTIMATION_U64 + num_entries) * sizeof(uint64_t);
-          if (size < expected_size_bytes) {
-            throw std::out_of_range(std::to_string(expected_size_bytes) + " bytes expected, actual " + std::to_string(size)
-                + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), size)) : ""));
-          }
-          return {false, true, seed_hash, num_entries, theta, entries};
+          check_memory_size(ptr, size, expected_size_bytes, dump_on_error);
+          return {false, true, seed_hash, num_entries, theta, entries, 64};
       } else {
           throw std::invalid_argument(std::to_string(preamble_size) + " longs of premable, but expected 1, 2, or 3");
       }
   }
   default:
-      // this should always fail since the valid cases are handled above
-      checker<true>::check_serial_version(reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_SERIAL_VERSION_BYTE], COMPACT_SKETCH_SERIAL_VERSION);
-      // this throw is never reached, because check_serial_version will throw an informative exception.
-      // This is only here to avoid a compiler warning about a path without a return value.
-      throw std::invalid_argument("unexpected sketch serialization version");
+    throw std::invalid_argument("unsupported serial version " + std::to_string(serial_version));
   }
 }
 
+template<bool dummy>
+void compact_theta_sketch_parser<dummy>::check_memory_size(const void* ptr, size_t actual_bytes, size_t expected_bytes, bool dump_on_error) {
+  if (actual_bytes < expected_bytes) throw std::out_of_range("at least " + std::to_string(expected_bytes)
+      + " bytes expected, actual " + std::to_string(actual_bytes)
+      + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), actual_bytes)) : ""));
+}
+
 template<bool dummy>
 std::string compact_theta_sketch_parser<dummy>::hex_dump(const uint8_t* ptr, size_t size) {
   std::stringstream s;

data/vendor/datasketches-cpp/theta/include/theta_helpers.hpp

@@ -20,8 +20,10 @@
 #ifndef THETA_HELPERS_HPP_
 #define THETA_HELPERS_HPP_
 
-#include <string>
 #include <stdexcept>
+#include <string>
+
+#include "theta_constants.hpp"
 
 namespace datasketches {
 
@@ -55,7 +57,7 @@ public:
   // consistent way of initializing theta from p
   // avoids multiplication if p == 1 since it might not yield MAX_THETA exactly
   static uint64_t starting_theta_from_p(float p) {
-    if (p < 1) return static_cast<uint64_t>(theta_constants::MAX_THETA * p);
+    if (p < 1) return static_cast<float>(theta_constants::MAX_THETA) * p;
     return theta_constants::MAX_THETA;
   }
 

data/vendor/datasketches-cpp/theta/include/theta_sketch.hpp

@@ -21,6 +21,7 @@
 #define THETA_SKETCH_HPP_
 
 #include "theta_update_sketch_base.hpp"
+#include "compact_theta_sketch_parser.hpp"
 
 namespace datasketches {
 
@@ -317,7 +318,8 @@ public:
   using AllocBytes = typename std::allocator_traits<Allocator>::template rebind_alloc<uint8_t>;
   using vector_bytes = std::vector<uint8_t, AllocBytes>;
 
-  static const uint8_t SERIAL_VERSION = 3;
+  static const uint8_t UNCOMPRESSED_SERIAL_VERSION = 3;
+  static const uint8_t COMPRESSED_SERIAL_VERSION = 4;
   static const uint8_t SKETCH_TYPE = 3;
 
   // Instances of this type can be obtained:
@@ -355,6 +357,25 @@ public:
    */
   vector_bytes serialize(unsigned header_size_bytes = 0) const;
 
+  /**
+   * This method serializes the sketch into a given stream in a compressed binary form.
+   * Compression is applied to ordered sketches except empty and single item.
+   * For unordered, empty and single item sketches this method is equivalent to serialize()
+   * @param os output stream
+   */
+  void serialize_compressed(std::ostream& os) const;
+
+  /**
+   * This method serializes the sketch as a vector of bytes.
+   * An optional header can be reserved in front of the sketch.
+   * It is an uninitialized space of a given size.
+   * This header is used in Datasketches PostgreSQL extension.
+   * Compression is applied to ordered sketches except empty and single item.
+   * For unordered, empty and single item sketches this method is equivalent to serialize()
+   * @param header_size_bytes space to reserve in front of the sketch
+   */
+  vector_bytes serialize_compressed(unsigned header_size_bytes = 0) const;
+
   virtual iterator begin();
   virtual iterator end();
   virtual const_iterator begin() const;
@@ -391,6 +412,16 @@ private:
   uint64_t theta_;
   std::vector<uint64_t, Allocator> entries_;
 
+  bool is_suitable_for_compression() const;
+  uint8_t compute_min_leading_zeros() const;
+  void serialize_version_4(std::ostream& os) const;
+  vector_bytes serialize_version_4(unsigned header_size_bytes = 0) const;
+
+  static compact_theta_sketch_alloc deserialize_v1(uint8_t preamble_longs, std::istream& is, uint64_t seed, const Allocator& allocator);
+  static compact_theta_sketch_alloc deserialize_v2(uint8_t preamble_longs, std::istream& is, uint64_t seed, const Allocator& allocator);
+  static compact_theta_sketch_alloc deserialize_v3(uint8_t preamble_longs, std::istream& is, uint64_t seed, const Allocator& allocator);
+  static compact_theta_sketch_alloc deserialize_v4(uint8_t preamble_longs, std::istream& is, uint64_t seed, const Allocator& allocator);
+
   virtual void print_specifics(std::ostringstream& os) const;
 };
 
@@ -407,7 +438,7 @@ public:
 template<typename Allocator = std::allocator<uint64_t>>
 class wrapped_compact_theta_sketch_alloc : public base_theta_sketch_alloc<Allocator> {
 public:
-  using const_iterator = const uint64_t*;
+  class const_iterator;
 
   Allocator get_allocator() const;
   bool is_empty() const;
@@ -433,15 +464,32 @@ protected:
   virtual void print_items(std::ostringstream& os) const;
 
 private:
-  bool is_empty_;
-  bool is_ordered_;
-  uint16_t seed_hash_;
-  uint32_t num_entries_;
-  uint64_t theta_;
-  const uint64_t* entries_;
+  using data_type = compact_theta_sketch_parser<true>::compact_theta_sketch_data;
+  data_type data_;
 
-  wrapped_compact_theta_sketch_alloc(bool is_empty, bool is_ordered, uint16_t seed_hash, uint32_t num_entries,
-      uint64_t theta, const uint64_t* entries);
+  wrapped_compact_theta_sketch_alloc(const data_type& data);
+};
+
+template<typename Allocator>
+class wrapped_compact_theta_sketch_alloc<Allocator>::const_iterator: public std::iterator<std::input_iterator_tag, uint64_t> {
+public:
+  const_iterator(const void* ptr, uint8_t entry_bits, uint32_t num_entries, uint32_t index);
+  const_iterator& operator++();
+  const_iterator operator++(int);
+  bool operator==(const const_iterator& other) const;
+  bool operator!=(const const_iterator& other) const;
+  const uint64_t& operator*() const;
+  const uint64_t* operator->() const;
+private:
+  const void* ptr_;
+  uint8_t entry_bits_;
+  uint32_t num_entries_;
+  uint32_t index_;
+  uint64_t previous_;
+  bool is_block_mode_;
+  uint8_t buf_i_;
+  uint8_t offset_;
+  uint64_t buffer_[8];
 };
 
 // aliases with default allocator for convenience