quasardb 3.14.2.dev7__cp39-cp39-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl

quasardb/range-v3/cmake_install.cmake

@@ -0,0 +1,93 @@
+# Install script for directory: /home/teamcity/buildAgent/work/938b0bdf6727d1ad/thirdparty/range-v3
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/usr/local")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  if(BUILD_TYPE)
+    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  else()
+    set(CMAKE_INSTALL_CONFIG_NAME "Release")
+  endif()
+  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+  if(COMPONENT)
+    message(STATUS "Install component: \"${COMPONENT}\"")
+    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  else()
+    set(CMAKE_INSTALL_COMPONENT)
+  endif()
+endif()
+
+# Install shared libraries without execute permission?
+if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
+  set(CMAKE_INSTALL_SO_NO_EXE "0")
+endif()
+
+# Is this installation the result of a crosscompile?
+if(NOT DEFINED CMAKE_CROSSCOMPILING)
+  set(CMAKE_CROSSCOMPILING "FALSE")
+endif()
+
+# Set path to fallback-tool for dependency-resolution.
+if(NOT DEFINED CMAKE_OBJDUMP)
+  set(CMAKE_OBJDUMP "/opt/rh/gcc-toolset-14/root/usr/bin/objdump")
+endif()
+
+if(CMAKE_INSTALL_COMPONENT STREQUAL "Unspecified" OR NOT CMAKE_INSTALL_COMPONENT)
+  include("/home/teamcity/buildAgent/work/938b0bdf6727d1ad/build/lib.linux-x86_64-cpython-39/quasardb/range-v3/CMakeFiles/range-v3-concepts.dir/install-cxx-module-bmi-Release.cmake" OPTIONAL)
+endif()
+
+if(CMAKE_INSTALL_COMPONENT STREQUAL "Unspecified" OR NOT CMAKE_INSTALL_COMPONENT)
+  include("/home/teamcity/buildAgent/work/938b0bdf6727d1ad/build/lib.linux-x86_64-cpython-39/quasardb/range-v3/CMakeFiles/range-v3-meta.dir/install-cxx-module-bmi-Release.cmake" OPTIONAL)
+endif()
+
+if(CMAKE_INSTALL_COMPONENT STREQUAL "Unspecified" OR NOT CMAKE_INSTALL_COMPONENT)
+  include("/home/teamcity/buildAgent/work/938b0bdf6727d1ad/build/lib.linux-x86_64-cpython-39/quasardb/range-v3/CMakeFiles/range-v3.dir/install-cxx-module-bmi-Release.cmake" OPTIONAL)
+endif()
+
+if(CMAKE_INSTALL_COMPONENT STREQUAL "Unspecified" OR NOT CMAKE_INSTALL_COMPONENT)
+  if(EXISTS "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/lib64/cmake/range-v3/range-v3-targets.cmake")
+    file(DIFFERENT _cmake_export_file_changed FILES
+         "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/lib64/cmake/range-v3/range-v3-targets.cmake"
+         "/home/teamcity/buildAgent/work/938b0bdf6727d1ad/build/lib.linux-x86_64-cpython-39/quasardb/range-v3/CMakeFiles/Export/48a02d54b5e9e60c30c5f249b431a911/range-v3-targets.cmake")
+    if(_cmake_export_file_changed)
+      file(GLOB _cmake_old_config_files "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/lib64/cmake/range-v3/range-v3-targets-*.cmake")
+      if(_cmake_old_config_files)
+        string(REPLACE ";" ", " _cmake_old_config_files_text "${_cmake_old_config_files}")
+        message(STATUS "Old export file \"$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/lib64/cmake/range-v3/range-v3-targets.cmake\" will be replaced.  Removing files [${_cmake_old_config_files_text}].")
+        unset(_cmake_old_config_files_text)
+        file(REMOVE ${_cmake_old_config_files})
+      endif()
+      unset(_cmake_old_config_files)
+    endif()
+    unset(_cmake_export_file_changed)
+  endif()
+  file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/lib64/cmake/range-v3" TYPE FILE FILES "/home/teamcity/buildAgent/work/938b0bdf6727d1ad/build/lib.linux-x86_64-cpython-39/quasardb/range-v3/CMakeFiles/Export/48a02d54b5e9e60c30c5f249b431a911/range-v3-targets.cmake")
+endif()
+
+if(CMAKE_INSTALL_COMPONENT STREQUAL "Unspecified" OR NOT CMAKE_INSTALL_COMPONENT)
+  file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/lib64/cmake/range-v3" TYPE FILE FILES
+    "/home/teamcity/buildAgent/work/938b0bdf6727d1ad/build/lib.linux-x86_64-cpython-39/quasardb/range-v3/range-v3-config-version.cmake"
+    "/home/teamcity/buildAgent/work/938b0bdf6727d1ad/thirdparty/range-v3/cmake/range-v3-config.cmake"
+    )
+endif()
+
+if(CMAKE_INSTALL_COMPONENT STREQUAL "Unspecified" OR NOT CMAKE_INSTALL_COMPONENT)
+  file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/include" TYPE DIRECTORY FILES "/home/teamcity/buildAgent/work/938b0bdf6727d1ad/thirdparty/range-v3/include/" FILES_MATCHING REGEX "/[^/]*$")
+endif()
+
+string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
+       "${CMAKE_INSTALL_MANIFEST_FILES}")
+if(CMAKE_INSTALL_LOCAL_ONLY)
+  file(WRITE "/home/teamcity/buildAgent/work/938b0bdf6727d1ad/build/lib.linux-x86_64-cpython-39/quasardb/range-v3/install_local_manifest.txt"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
+endif()

quasardb/range-v3/include/range/v3/version.hpp

@@ -0,0 +1,24 @@
+/// \file
+// Range v3 library
+//
+//  Copyright Eric Niebler 2017-present
+//
+//  Use, modification and distribution is subject to the
+//  Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// Project home: https://github.com/ericniebler/range-v3
+//
+
+#ifndef RANGES_V3_VERSION_HPP
+#define RANGES_V3_VERSION_HPP
+
+#define RANGE_V3_MAJOR 0
+#define RANGE_V3_MINOR 11
+#define RANGE_V3_PATCHLEVEL 0
+
+#define RANGE_V3_VERSION \
+    (RANGE_V3_MAJOR * 10000 + RANGE_V3_MINOR * 100 + RANGE_V3_PATCHLEVEL)
+
+#endif

quasardb/range-v3/range-v3-config-version.cmake

@@ -0,0 +1,83 @@
+# This is a basic version file for the Config-mode of find_package().
+# It is used by write_basic_package_version_file() as input file for configure_file()
+# to create a version-file which can be installed along a config.cmake file.
+#
+# The created file sets PACKAGE_VERSION_EXACT if the current version string and
+# the requested version string are exactly the same and it sets
+# PACKAGE_VERSION_COMPATIBLE if the current version is equal to the requested version.
+# The tweak version component is ignored.
+# The variable CVF_VERSION must be set before calling configure_file().
+
+
+if (PACKAGE_FIND_VERSION_RANGE)
+  message(AUTHOR_WARNING
+    "`find_package()` specify a version range but the version strategy "
+    "(ExactVersion) of the module `${PACKAGE_FIND_NAME}` is incompatible "
+    "with this request. Only the lower endpoint of the range will be used.")
+endif()
+
+set(PACKAGE_VERSION "0.11.0")
+
+if("0.11.0" MATCHES "^([0-9]+)\\.([0-9]+)\\.([0-9]+)") # strip the tweak version
+  set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}")
+  set(CVF_VERSION_MINOR "${CMAKE_MATCH_2}")
+  set(CVF_VERSION_PATCH "${CMAKE_MATCH_3}")
+
+  if(NOT CVF_VERSION_MAJOR VERSION_EQUAL 0)
+    string(REGEX REPLACE "^0+" "" CVF_VERSION_MAJOR "${CVF_VERSION_MAJOR}")
+  endif()
+  if(NOT CVF_VERSION_MINOR VERSION_EQUAL 0)
+    string(REGEX REPLACE "^0+" "" CVF_VERSION_MINOR "${CVF_VERSION_MINOR}")
+  endif()
+  if(NOT CVF_VERSION_PATCH VERSION_EQUAL 0)
+    string(REGEX REPLACE "^0+" "" CVF_VERSION_PATCH "${CVF_VERSION_PATCH}")
+  endif()
+
+  set(CVF_VERSION_NO_TWEAK "${CVF_VERSION_MAJOR}.${CVF_VERSION_MINOR}.${CVF_VERSION_PATCH}")
+else()
+  set(CVF_VERSION_NO_TWEAK "0.11.0")
+endif()
+
+if(PACKAGE_FIND_VERSION MATCHES "^([0-9]+)\\.([0-9]+)\\.([0-9]+)") # strip the tweak version
+  set(REQUESTED_VERSION_MAJOR "${CMAKE_MATCH_1}")
+  set(REQUESTED_VERSION_MINOR "${CMAKE_MATCH_2}")
+  set(REQUESTED_VERSION_PATCH "${CMAKE_MATCH_3}")
+
+  if(NOT REQUESTED_VERSION_MAJOR VERSION_EQUAL 0)
+    string(REGEX REPLACE "^0+" "" REQUESTED_VERSION_MAJOR "${REQUESTED_VERSION_MAJOR}")
+  endif()
+  if(NOT REQUESTED_VERSION_MINOR VERSION_EQUAL 0)
+    string(REGEX REPLACE "^0+" "" REQUESTED_VERSION_MINOR "${REQUESTED_VERSION_MINOR}")
+  endif()
+  if(NOT REQUESTED_VERSION_PATCH VERSION_EQUAL 0)
+    string(REGEX REPLACE "^0+" "" REQUESTED_VERSION_PATCH "${REQUESTED_VERSION_PATCH}")
+  endif()
+
+  set(REQUESTED_VERSION_NO_TWEAK
+      "${REQUESTED_VERSION_MAJOR}.${REQUESTED_VERSION_MINOR}.${REQUESTED_VERSION_PATCH}")
+else()
+  set(REQUESTED_VERSION_NO_TWEAK "${PACKAGE_FIND_VERSION}")
+endif()
+
+if(REQUESTED_VERSION_NO_TWEAK STREQUAL CVF_VERSION_NO_TWEAK)
+  set(PACKAGE_VERSION_COMPATIBLE TRUE)
+else()
+  set(PACKAGE_VERSION_COMPATIBLE FALSE)
+endif()
+
+if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
+  set(PACKAGE_VERSION_EXACT TRUE)
+endif()
+
+
+# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it:
+if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "" STREQUAL "")
+  return()
+endif()
+
+# check that the installed version has the same 32/64bit-ness as the one which is currently searching:
+if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "")
+  math(EXPR installedBits " * 8")
+  set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)")
+  set(PACKAGE_VERSION_UNSUITABLE TRUE)
+endif()

quasardb/range-v3/range-v3-config.cmake

@@ -0,0 +1,80 @@
+# Generated by CMake
+
+if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8)
+   message(FATAL_ERROR "CMake >= 3.0.0 required")
+endif()
+if(CMAKE_VERSION VERSION_LESS "3.0.0")
+   message(FATAL_ERROR "CMake >= 3.0.0 required")
+endif()
+cmake_policy(PUSH)
+cmake_policy(VERSION 3.0.0...3.31)
+#----------------------------------------------------------------
+# Generated CMake target import file.
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Protect against multiple inclusion, which would fail when already imported targets are added once more.
+set(_cmake_targets_defined "")
+set(_cmake_targets_not_defined "")
+set(_cmake_expected_targets "")
+foreach(_cmake_expected_target IN ITEMS range-v3-concepts range-v3-meta range-v3)
+  list(APPEND _cmake_expected_targets "${_cmake_expected_target}")
+  if(TARGET "${_cmake_expected_target}")
+    list(APPEND _cmake_targets_defined "${_cmake_expected_target}")
+  else()
+    list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}")
+  endif()
+endforeach()
+unset(_cmake_expected_target)
+if(_cmake_targets_defined STREQUAL _cmake_expected_targets)
+  unset(_cmake_targets_defined)
+  unset(_cmake_targets_not_defined)
+  unset(_cmake_expected_targets)
+  unset(CMAKE_IMPORT_FILE_VERSION)
+  cmake_policy(POP)
+  return()
+endif()
+if(NOT _cmake_targets_defined STREQUAL "")
+  string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}")
+  string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}")
+  message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n")
+endif()
+unset(_cmake_targets_defined)
+unset(_cmake_targets_not_defined)
+unset(_cmake_expected_targets)
+
+
+# Create imported target range-v3-concepts
+add_library(range-v3-concepts INTERFACE IMPORTED)
+
+set_target_properties(range-v3-concepts PROPERTIES
+  INTERFACE_COMPILE_OPTIONS "\$<\$<COMPILE_LANG_AND_ID:CXX,MSVC>:/permissive->;\$<\$<COMPILE_LANG_AND_ID:CUDA,MSVC>:-Xcompiler=/permissive->"
+  INTERFACE_INCLUDE_DIRECTORIES "/home/teamcity/buildAgent/work/938b0bdf6727d1ad/thirdparty/range-v3/include/"
+  INTERFACE_LINK_LIBRARIES "range-v3-meta"
+)
+
+# Create imported target range-v3-meta
+add_library(range-v3-meta INTERFACE IMPORTED)
+
+set_target_properties(range-v3-meta PROPERTIES
+  INTERFACE_COMPILE_OPTIONS "\$<\$<COMPILE_LANG_AND_ID:CXX,MSVC>:/permissive->;\$<\$<COMPILE_LANG_AND_ID:CUDA,MSVC>:-Xcompiler=/permissive->"
+  INTERFACE_INCLUDE_DIRECTORIES "/home/teamcity/buildAgent/work/938b0bdf6727d1ad/thirdparty/range-v3/include/"
+)
+
+# Create imported target range-v3
+add_library(range-v3 INTERFACE IMPORTED)
+
+set_target_properties(range-v3 PROPERTIES
+  INTERFACE_COMPILE_OPTIONS "\$<\$<COMPILE_LANG_AND_ID:CXX,MSVC>:/permissive->;\$<\$<COMPILE_LANG_AND_ID:CUDA,MSVC>:-Xcompiler=/permissive->"
+  INTERFACE_INCLUDE_DIRECTORIES "/home/teamcity/buildAgent/work/938b0bdf6727d1ad/thirdparty/range-v3/include/"
+  INTERFACE_LINK_LIBRARIES "range-v3-concepts;range-v3-meta"
+)
+
+# This file does not depend on other imported targets which have
+# been exported from the same project but in a separate export set.
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
+cmake_policy(POP)

quasardb/stats.py

@@ -0,0 +1,358 @@
+import re
+
+import quasardb
+import logging
+from collections import defaultdict
+from datetime import datetime
+from enum import Enum
+
+logger = logging.getLogger("quasardb.stats")
+
+MAX_KEYS = 4 * 1024 * 1024  # 4 million max keys
+stats_prefix = "$qdb.statistics."
+
+# Compile these regexes once for speed
+user_pattern = re.compile(r"\$qdb.statistics.(.*).uid_([0-9]+)$")
+total_pattern = re.compile(r"\$qdb.statistics.(.*)$")
+user_clean_pattern = re.compile(r"\.uid_\d+")
+
+
+def is_user_stat(s):
+    return user_pattern.match(s) is not None
+
+
+def is_cumulative_stat(s):
+    # NOTE(leon): It's quite difficult to express in Python that you don't want any
+    # regex to _end_ with uid_[0-9]+, because Python's regex engine doesn't support
+    # variable width look-behind.
+    #
+    # An alternative would be to use the PyPi regex library (for POSIX regexes), but
+    # want to stay light on dependencies#
+    #
+    # As such, we define a 'cumulative' stat as anything that's not a user stat.
+    # Simple but effective.
+    return user_pattern.match(s) is None
+
+
+def by_node(conn):
+    """
+    Returns statistic grouped by node URI.
+
+    Parameters:
+    conn: quasardb.Cluster
+      Active connection to the QuasarDB cluster
+    """
+    return {x: of_node(conn.node(x)) for x in conn.endpoints()}
+
+
+def of_node(dconn):
+    """
+    Returns statistic for a single node.
+
+    Parameters:
+    dconn: quasardb.Node
+      Direct node connection to the node we wish to connect to
+
+    """
+
+    start = datetime.now()
+
+    ks = _get_all_keys(dconn)
+    idx = _index_keys(dconn, ks)
+    raw = {k: _get_stat_value(dconn, k) for k in ks}
+
+    ret = {"by_uid": _by_uid(raw, idx), "cumulative": _cumulative(raw, idx)}
+
+    check_duration = datetime.now() - start
+
+    ret["cumulative"]["check.online"] = {
+        "value": 1,
+        "type": Type.ACCUMULATOR,
+        "unit": Unit.NONE,
+    }
+    ret["cumulative"]["check.duration_ms"] = {
+        "value": int(check_duration.total_seconds() * 1000),
+        "type": Type.ACCUMULATOR,
+        "unit": Unit.MILLISECONDS,
+    }
+
+    return ret
+
+
+async_pipeline_bytes_pattern = re.compile(
+    r"async_pipelines.pipe_[0-9]+.merge_map.bytes"
+)
+async_pipeline_count_pattern = re.compile(
+    r"async_pipelines.pipe_[0-9]+.merge_map.count"
+)
+
+
+def stat_type(stat_id):
+    """
+    Returns the statistic type by a stat id. Returns one of:
+
+     - 'gauge'
+     - 'counter'
+     - None in case of unrecognized statistics
+
+    This is useful for determining which value should be reported in a dashboard.
+    """
+    import warnings
+
+    warnings.warn(
+        "The 'stat_type' method is deprecated and will be removed in a future release."
+        "The stat type and unit are now part of the return value of invocations to the 'of_node' and 'by_node' methods.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
+    return None
+
+
+def _get_all_keys(dconn, n=1024):
+    """
+    Returns all keys from a single node.
+
+    Parameters:
+    dconn: quasardb.Node
+      Direct node connection to the node we wish to connect to.
+
+    n: int
+      Number of keys to retrieve.
+    """
+    xs = None
+    increase_rate = 8
+    # keep getting keys while number of results exceeds the given "n"
+    while xs is None or len(xs) >= n:
+        if xs is not None:
+            n = n * increase_rate
+        if n >= MAX_KEYS:
+            raise Exception(f"ERROR: Cannot fetch more than {MAX_KEYS} keys.")
+        xs = dconn.prefix_get(stats_prefix, n)
+
+    return xs
+
+
+class Type(Enum):
+    ACCUMULATOR = 1
+    GAUGE = 2
+    LABEL = 3
+
+
+class Unit(Enum):
+    NONE = 0
+    COUNT = 1
+
+    # Size units
+    BYTES = 32
+
+    # Time/duration units
+    EPOCH = 64
+    NANOSECONDS = 65
+    MICROSECONDS = 66
+    MILLISECONDS = 67
+    SECONDS = 68
+
+
+_type_string_to_enum = {
+    "accumulator": Type.ACCUMULATOR,
+    "gauge": Type.GAUGE,
+    "label": Type.LABEL,
+}
+
+_unit_string_to_enum = {
+    "none": Unit.NONE,
+    "count": Unit.COUNT,
+    "bytes": Unit.BYTES,
+    "epoch": Unit.EPOCH,
+    "nanoseconds": Unit.NANOSECONDS,
+    "microseconds": Unit.MICROSECONDS,
+    "milliseconds": Unit.MILLISECONDS,
+    "seconds": Unit.SECONDS,
+}
+
+
+def _lookup_enum(dconn, k, m):
+    """
+    Utility function to avoid code duplication: automatically looks up a key's value
+    from QuasarDB and looks it up in provided dict.
+    """
+
+    x = dconn.blob(k).get()
+    x = _clean_blob(x)
+
+    if x not in m:
+        raise Exception(f"Unrecognized unit/type {x} from key {k}")
+
+    return m[x]
+
+
+def _lookup_type(dconn, k):
+    """
+    Looks up and parses/validates the metric type.
+    """
+    assert k.endswith(".type")
+
+    return _lookup_enum(dconn, k, _type_string_to_enum)
+
+
+def _lookup_unit(dconn, k):
+    """
+    Looks up and parses/validates the metric type.
+    """
+    assert k.endswith(".unit")
+
+    return _lookup_enum(dconn, k, _unit_string_to_enum)
+
+
+def _index_keys(dconn, ks):
+    """
+    Takes all statistics keys that are retrieved, and "indexes" them in such a way
+    that we end up with a dict of all statistic keys, their type and their unit.
+    """
+
+    ###
+    # The keys generally look like this, for example:
+    #
+    # $qdb.statistics.requests.out_bytes
+    # $qdb.statistics.requests.out_bytes.type
+    # $qdb.statistics.requests.out_bytes.uid_1
+    # $qdb.statistics.requests.out_bytes.uid_1.type
+    # $qdb.statistics.requests.out_bytes.uid_1.unit
+    # $qdb.statistics.requests.out_bytes.unit
+    #
+    # For this purpose, we simply get rid of the "uid" part, as the per-uid metrics are guaranteed
+    # to be of the exact same type as all the others. So after trimming those, the keys will look
+    # like this:
+    #
+    # $qdb.statistics.requests.out_bytes
+    # $qdb.statistics.requests.out_bytes.type
+    # $qdb.statistics.requests.out_bytes
+    # $qdb.statistics.requests.out_bytes.type
+    # $qdb.statistics.requests.out_bytes.unit
+    # $qdb.statistics.requests.out_bytes.unit
+    #
+    # And after deduplication like this:
+    #
+    # $qdb.statistics.requests.out_bytes
+    # $qdb.statistics.requests.out_bytes.type
+    # $qdb.statistics.requests.out_bytes.unit
+    #
+    # In which case we'll store `requests.out_bytes` as the statistic type, and look up the type
+    # and unit for those metrics and add a placeholder value.
+
+    ret = defaultdict(lambda: {"value": None, "type": None, "unit": None})
+
+    for k in ks:
+        # Remove any 'uid_[0-9]+' part from the string
+        k_ = user_clean_pattern.sub("", k)
+
+        matches = total_pattern.match(k_)
+
+        parts = matches.groups()[0].rsplit(".", 1)
+        metric_id = parts[0]
+
+        if len(parts) > 1 and parts[1] == "type":
+            if ret[metric_id]["type"] == None:
+                # We haven't seen this particular statistic yet
+                ret[metric_id]["type"] = _lookup_type(dconn, k)
+        elif len(parts) > 1 and parts[1] == "unit":
+            if ret[metric_id]["unit"] == None:
+                # We haven't seen this particular statistic yet
+                ret[metric_id]["unit"] = _lookup_unit(dconn, k)
+        else:
+            # It's a value, we look those up later
+            pass
+
+    return ret
+
+
+def _clean_blob(x):
+    """
+    Utility function that decodes a blob as an UTF-8 string, as the direct node C API
+    does not yet support 'string' types and as such all statistics are stored as blobs.
+    """
+    x_ = x.decode("utf-8", "replace")
+
+    # remove trailing zero-terminator
+    return "".join(c for c in x_ if ord(c) != 0)
+
+
+def _get_stat_value(dconn, k):
+    # Ugly, but works: try to retrieve as integer, if not an int, retrieve as
+    # blob
+    #
+    # XXX(leon): we could use the index we built to get a much stronger hint
+    #            on what the type is.
+    try:
+        return dconn.integer(k).get()
+
+    # Older versions of qdb api returned 'alias not found'
+    except quasardb.quasardb.AliasNotFoundError:
+        return _clean_blob(dconn.blob(k).get())
+
+    # Since ~ 3.14.2, it returns 'Incompatible Type'
+    except quasardb.quasardb.IncompatibleTypeError:
+        return _clean_blob(dconn.blob(k).get())
+
+
+def _by_uid(stats, idx):
+    xs = {}
+    for k, v in stats.items():
+        matches = user_pattern.match(k)
+        if is_user_stat(k) and matches:
+            (metric, uid_str) = matches.groups()
+
+            if metric.split(".")[-1] in ["type", "unit"]:
+                # We already indexed the type and unit in our idx, this is not interesting
+                continue
+
+            if metric.startswith("serialized"):
+                # Internal stuff we don't care about nor cannot do anything with
+                continue
+
+            if not metric in idx:
+                raise Exception(f"Metric not in internal index: {metric}")
+
+            # Parse user id
+            uid = int(uid_str)
+
+            # Prepare our metric dict
+            x = idx[metric].copy()
+            x["value"] = v
+
+            if uid not in xs:
+                xs[uid] = {}
+
+            xs[uid][metric] = x
+
+    return xs
+
+
+def _cumulative(stats, idx):
+    xs = {}
+
+    for k, v in stats.items():
+        matches = total_pattern.match(k)
+        if is_cumulative_stat(k) and matches:
+            metric = matches.groups()[0]
+
+            if metric.split(".")[-1] in ["type", "unit"]:
+                # We already indexed the type and unit in our idx, this is not interesting
+                continue
+
+            if metric.startswith("serialized"):
+                # Internal stuff we don't care about nor cannot do anything with
+                continue
+
+            if not metric in idx:
+                raise Exception(f"Metric not in internal index: {metric}")
+
+            x = idx[metric].copy()
+            x["value"] = v
+            xs[metric] = x
+
+    return xs
+
+
+# async_pipelines.buffer.total_bytes

quasardb/table_cache.py

@@ -0,0 +1,56 @@
+import logging
+
+logger = logging.getLogger("quasardb.table_cache")
+
+_cache = {}
+
+
+def clear():
+    logger.info("Clearing table cache")
+    _cache = {}
+
+
+def exists(table_name: str) -> bool:
+    """
+    Returns true if table already exists in table cache.
+    """
+    return table_name in _cache
+
+
+def store(table, table_name=None, force_retrieve_metadata=True):
+    """
+    Stores a table into the cache. Ensures metadata is retrieved. This is useful if you want
+    to retrieve all table metadata at the beginning of a process, to avoid doing expensive
+    lookups in undesired code paths.
+
+    Returns a reference to the table being stored.
+    """
+    if table_name is None:
+        table_name = table.get_name()
+
+    if exists(table_name):
+        logger.warn("Table already in cache, overwriting: %s", table_name)
+
+    logger.debug("Caching table %s", table_name)
+    _cache[table_name] = table
+
+    table.retrieve_metadata()
+
+    return table
+
+
+def lookup(table_name: str, conn, force_retrieve_metadata=True):
+    """
+    Retrieves table from _cache if already exists. If it does not exist,
+    looks up the table from `conn` and puts it in the cache.
+
+    If `force_retrieve_metadata` equals True, we will ensure that the table's
+    metadata is
+    """
+    if exists(table_name):
+        return _cache[table_name]
+
+    logger.debug("table %s not yet found, looking up", table_name)
+    table = conn.table(table_name)
+
+    return store(table, table_name, force_retrieve_metadata=force_retrieve_metadata)