influxdb3-python 0.11.0__tar.gz → 0.12.0__tar.gz

influxdb3_python-0.12.0/Examples/basic_ssl_example.py

@@ -0,0 +1,104 @@
+import os
+import time
+
+import pyarrow
+
+from config import Config
+from influxdb_client_3 import InfluxDBClient3
+
+bad_cert = """-----BEGIN CERTIFICATE-----
+MIIFDTCCAvWgAwIBAgIUYzpfisy9xLrhiZd+D9vOdzC3+iswDQYJKoZIhvcNAQEL
+BQAwFjEUMBIGA1UEAwwLdGVzdGhvc3QuaW8wHhcNMjUwMjI4MTM1NTMyWhcNMzUw
+MjI2MTM1NTMyWjAWMRQwEgYDVQQDDAt0ZXN0aG9zdC5pbzCCAiIwDQYJKoZIhvcN
+AQEBBQADggIPADCCAgoCggIBAN1lwqXYP8UMvjb56SpUEj2OpoEDRfLeWrEiHkOl
+xoymvJGaXZNEpDXo2TTdysCoYWEjz9IY6GlqSo2Yssf5BZkQwMOw7MdyRwCigzrh
+OAKbyCfsvEgfNFrXEdSDpaxW++5SToeErudYXc+sBfnI1NB4W3GBGqqIvx8fqaB3
+1EU9ql2sKKxI0oYIQD/If9rQEyLFKeWdD8iT6YST1Vugkvd34NPmaqV5+pjdSb4z
+a8olavwUoslqFUeILqIq+WZZbOlgCcJYKcBAmELRnsxGaABRtMwMZx+0D+oKo4Kl
+QQtOcER+RHkBHyYFghZIBnzudfbP9NadknOz3AilJbJolXfXJqeQhRD8Ob49kkhe
+OwjAppHnaZGWjYZMLIfnwwXBwkS7bSwF16Wot83cpL46Xvg6xcl12An4JaoF798Q
+cXyYrWCgvbqjVR7694gxqLGzk138AKTDSbER1h1rfqCqkk7soE0oWCs7jiCk2XvD
+49qVfHtd50KYJ4/yP1XL0PmLL0Hw1kvOxLVkFENc1zkoYXJRt2Ec6j9dajmGlsFn
+0bLLap6UIlIGQFuvcLf4bvsIi9FICy2jBjaIdM4UAWbReG+52+180HEleAwi5bAN
+HY61WVXc4X+N0E2y8HWc1QaRioU7R4XZ5HXKs7OTWkKFZUU2JDFHAKdiiAU78qLU
+7GApAgMBAAGjUzBRMB0GA1UdDgQWBBT2vPFo0mzh9ls4xJUiAgSK+B5LpTAfBgNV
+HSMEGDAWgBT2vPFo0mzh9ls4xJUiAgSK+B5LpTAPBgNVHRMBAf8EBTADAQH/MA0G
+CSqGSIb3DQEBCwUAA4ICAQC4TJNPx476qhiMi8anISv9lo9cnLju+qNhcz7wupBH
+3Go6bVQ7TCbSt2QpAyY64mdnRqHsXeGvZXCnabOpeKRDeAPBtRjc6yNKuXybqFtn
+W3PZEs/OYc659TUA+MoBzSXYStN9yiiYXyVFqVn+Rw6kM9tKh0GgAU7f5P+8IGuR
+gXJbCjkbdJO7JUiVGEEmkjUHyqFxMHaZ8V6uazs52qIFyt7OYQTeV9HdoW8D9vAt
+GfzYwzRDzbsZeIJqqDzLe7NOyxEyqZHCbtNpGcOyaLOl7ZBS52WsqaUZtL+9PjqD
+2TWj4WUFkOWQpTvWKHqM6//Buv4GjnTBShQKm+h+rxcGkdRMF6/sKwxPbr39P3RJ
+TMfJA3u5UuowT44VaA2jkQzqIbxH9+3EA+0qPbqPJchOSr0pHSncqvR9FYcr7ayN
+b6UDFnjeliyEqqksUO0arbvaO9FfB0kH8lU1NOKaQNO++Xj69GZMC6s721cNdad0
+qqcdtyXWeOBBchguYDrSUIgLnUTHEwwzOmcNQ36hO5eX282BJy3ZLT3JU6MJopjz
+vkbDDAxSrpZMcaoAWSrxgJAETeYiO4YbfORIzPkwdUkEIr6XY02Pi7MdkDGQ5hiB
+TavA8+oXRa4b9BR3bCWcg8S/t4uOTTLkeTcQbONPh5A5IRySLCU+CwqB+/+VlO8X
+Aw==
+-----END CERTIFICATE-----"""
+
+
+def write_cert(cert, file_name):
+    f = open(file_name, "w")
+    f.write(cert)
+    f.close()
+
+
+def remove_cert(file_name):
+    os.remove(file_name)
+
+
+def print_results(results: list):
+    print("%-6s%-6s%-6s%-24s" % ("id", "speed", "ticks", "time"))
+    for result in results:
+        print("%-6s%-6.2f%-6i%-24s" % (result['id'], result['speed'], result['ticks'], result['time']))
+
+
+def main() -> None:
+    print("Main")
+    temp_cert_file = "temp_cert.pem"
+    conf = Config()
+
+    write_and_query_with_explicit_sys_cert(conf)
+
+    write_cert(bad_cert, temp_cert_file)
+    query_with_verify_ssl_off(conf, temp_cert_file)
+    remove_cert(temp_cert_file)
+
+
+def write_and_query_with_explicit_sys_cert(conf):
+    print("\nwrite and query with typical linux system cert\n")
+    with InfluxDBClient3(token=conf.token,
+                         host=conf.host,
+                         org=conf.org,
+                         database=conf.database,
+                         ssl_ca_cert="/etc/ssl/certs/ca-certificates.crt",
+                         verify_ssl=True) as _client:
+        now = time.time_ns()
+        lp = f"escooter,id=zx80 speed=3.14,ticks=42i {now - (10 * 1_000_000_000)}"
+        _client.write(lp)
+
+        query = "SELECT * FROM \"escooter\" ORDER BY time DESC"
+        reader: pyarrow.Table = _client.query(query, mode="")
+        print_results(reader.to_pylist())
+
+
+def query_with_verify_ssl_off(conf, cert):
+    print("\nquerying with verify_ssl off\n")
+
+    # Note that the passed root cert above is bad
+    # Switch verify_ssl to True to throw SSL_ERROR_SSL
+    with InfluxDBClient3(token=conf.token,
+                         host=conf.host,
+                         org=conf.org,
+                         database=conf.database,
+                         ssl_ca_cert=cert,
+                         verify_ssl=False) as _client:
+
+        query = "SELECT * FROM \"escooter\"  ORDER BY time DESC"
+        reader: pyarrow.Table = _client.query(query, mode="")
+        print_results(reader.to_pylist())
+
+
+if __name__ == "__main__":
+    main()

influxdb3_python-0.12.0/Examples/query_async.py

@@ -0,0 +1,87 @@
+import asyncio
+import random
+import time
+
+import pandas
+
+from influxdb_client_3 import InfluxDBClient3
+
+from config import Config
+
+
+async def fibio(iterations, grit=0.5):
+    """
+    example coroutine to run parallel with query_async
+    :param iterations:
+    :param grit:
+    :return:
+    """
+    n0 = 1
+    n1 = 1
+    vals = [n0, n1]
+    for _ in range(iterations):
+        val = n0 + n1
+        n0 = n1
+        n1 = val
+        print(val)
+        vals.append(val)
+        await asyncio.sleep(grit)
+    return vals
+
+
+def write_data(client: InfluxDBClient3, measurement):
+    """
+    Synchronous write - only for preparing data
+    :param client:
+    :param measurement:
+    :return:
+    """
+    ids = ['s3b1', 'dq41', 'sgw22']
+    lp_template = f"{measurement},id=%s speed=%f,alt=%f,bearing=%f %d"
+    data_size = 10
+    data = []
+    interval = 10 * 1_000_000_000
+    ts = time.time_ns() - (interval * data_size)
+    for _ in range(data_size):
+        data.append(lp_template % (ids[random.randint(0, len(ids) - 1)],
+                                   random.random() * 300,
+                                   random.random() * 2000,
+                                   random.random() * 360, ts))
+        ts += interval
+
+    client.write(data)
+
+
+async def query_data(client: InfluxDBClient3, measurement):
+    """
+    Query asynchronously - should not block other coroutines
+    :param client:
+    :param measurement:
+    :return:
+    """
+    query = f"SELECT * FROM \"{measurement}\" WHERE time >= now() - interval '5 minutes' ORDER BY time DESC"
+    print(f"query start:    {pandas.Timestamp(time.time_ns())}")
+    table = await client.query_async(query)
+    print(f"query returned: {pandas.Timestamp(time.time_ns())}")
+    return table.to_pandas()
+
+
+async def main():
+    config = Config()
+    client = InfluxDBClient3(
+        host=config.host,
+        token=config.token,
+        database=config.database,
+        org=config.org
+    )
+    measurement = 'example_uav'
+    write_data(client, measurement)
+
+    # run both coroutines simultaneously
+    result = await asyncio.gather(fibio(10, 0.2), query_data(client, measurement))
+    print(f"fibio sequence = {result[0]}")
+    print(f"data set =\n{result[1]}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{influxdb3_python-0.11.0/influxdb3_python.egg-info → influxdb3_python-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: influxdb3-python
-Version: 0.11.0
+Version: 0.12.0
 Summary: Community Python client for InfluxDB 3.0
 Home-page: https://github.com/InfluxCommunity/influxdb3-python
 Author: InfluxData
@@ -39,6 +39,7 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: requires-python

{influxdb3_python-0.11.0 → influxdb3_python-0.12.0/influxdb3_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: influxdb3-python
-Version: 0.11.0
+Version: 0.12.0
 Summary: Community Python client for InfluxDB 3.0
 Home-page: https://github.com/InfluxCommunity/influxdb3-python
 Author: InfluxData
@@ -39,6 +39,7 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: requires-python

{influxdb3_python-0.11.0 → influxdb3_python-0.12.0}/influxdb3_python.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 README.md
 setup.py
 Examples/__init__.py
+Examples/basic_ssl_example.py
 Examples/batching_example.py
 Examples/cloud_dedicated_query.py
 Examples/cloud_dedicated_write.py
@@ -9,6 +10,7 @@ Examples/config.py
 Examples/flight_options_example.py
 Examples/handle_http_error.py
 Examples/pandas_write.py
+Examples/query_async.py
 Examples/query_type.py
 influxdb3_python.egg-info/PKG-INFO
 influxdb3_python.egg-info/SOURCES.txt

{influxdb3_python-0.11.0 → influxdb3_python-0.12.0}/influxdb_client_3/__init__.py

@@ -2,7 +2,7 @@ import urllib.parse
 import pyarrow as pa
 import importlib.util
 
-from influxdb_client_3.query.query_api import QueryApi as _QueryApi
+from influxdb_client_3.query.query_api import QueryApi as _QueryApi, QueryApiOptionsBuilder
 from influxdb_client_3.read_file import UploadFile
 from influxdb_client_3.write_client import InfluxDBClient as _InfluxDBClient, WriteOptions, Point
 from influxdb_client_3.write_client.client.exceptions import InfluxDBError
@@ -165,9 +165,18 @@ class InfluxDBClient3:
             connection_string = f"grpc+tls://{hostname}:{port}"
         else:
             connection_string = f"grpc+tcp://{hostname}:{port}"
+
+        q_opts_builder = QueryApiOptionsBuilder()
+        kw_keys = kwargs.keys()
+        if kw_keys.__contains__('ssl_ca_cert'):
+            q_opts_builder.root_certs(kwargs.get('ssl_ca_cert', None))
+        if kw_keys.__contains__('verify_ssl'):
+            q_opts_builder.tls_verify(kwargs.get('verify_ssl', True))
+        if kw_keys.__contains__('proxy'):
+            q_opts_builder.proxy(kwargs.get('proxy', None))
         self._query_api = _QueryApi(connection_string=connection_string, token=token,
                                     flight_client_options=flight_client_options,
-                                    proxy=kwargs.get("proxy", None))
+                                    proxy=kwargs.get("proxy", None), options=q_opts_builder.build())
 
     def write(self, record=None, database=None, **kwargs):
         """
@@ -269,6 +278,39 @@ class InfluxDBClient3:
         except InfluxDBError as e:
             raise e
 
+    async def query_async(self, query: str, language: str = "sql", mode: str = "all", database: str = None, **kwargs):
+        """Query data from InfluxDB asynchronously.
+
+        If you want to use query parameters, you can pass them as kwargs:
+
+        >>> await client.query_async("select * from cpu where host=$host", query_parameters={"host": "server01"})
+
+        :param query: The query to execute on the database.
+        :param language: The query language to use. It should be one of "influxql" or "sql". Defaults to "sql".
+        :param mode: The mode to use for the query. It should be one of "all", "pandas", "polars", "chunk",
+                     "reader" or "schema". Defaults to "all".
+        :param database: The database to query from. If not provided, uses the database provided during initialization.
+        :param kwargs: Additional arguments to pass to the ``FlightCallOptions headers``. For example, it can be used to
+                       set up per request headers.
+        :keyword query_parameters: The query parameters to use in the query.
+                                   It should be a ``dictionary`` of key-value pairs.
+        :return: The query result in the specified mode.
+        """
+        if mode == "polars" and polars is False:
+            raise ImportError("Polars is not installed. Please install it with `pip install polars`.")
+
+        if database is None:
+            database = self._database
+
+        try:
+            return await self._query_api.query_async(query=query,
+                                                     language=language,
+                                                     mode=mode,
+                                                     database=database,
+                                                     **kwargs)
+        except InfluxDBError as e:
+            raise e
+
     def close(self):
         """Close the client and clean up resources."""
         self._write_api.close()

influxdb3_python-0.12.0/influxdb_client_3/query/query_api.py

@@ -0,0 +1,252 @@
+"""Query data in InfluxDB 3."""
+import asyncio
+# coding: utf-8
+import json
+
+from pyarrow.flight import FlightClient, Ticket, FlightCallOptions, FlightStreamReader
+
+from influxdb_client_3.version import USER_AGENT
+
+
+class QueryApiOptions(object):
+    """
+    Structure for encapsulating options for the QueryApi
+
+    Attributes
+    ----------
+    tls_root_certs (bytes):  contents of an SSL root certificate or chain read as bytes
+    tls_verify (bool): whether to verify SSL certificates or not
+    proxy (str): URL to a proxy server
+    flight_client_options (dict): base set of flight client options passed to internal pyarrow.flight.FlightClient
+    """
+    tls_root_certs: bytes = None
+    tls_verify: bool = None
+    proxy: str = None
+    flight_client_options: dict = None
+
+    def __init__(self, root_certs_path, verify, proxy, flight_client_options):
+        """
+        Initialize a set of QueryApiOptions
+
+        :param root_certs_path: path to a certificate .pem file.
+        :param verify: whether to verify SSL certificates or not.
+        :param proxy: URL of a proxy server, if required.
+        :param flight_client_options: set of flight_client_options
+               to be passed to internal pyarrow.flight.FlightClient.
+        """
+        if root_certs_path:
+            self.tls_root_certs = self._read_certs(root_certs_path)
+        self.tls_verify = verify
+        self.proxy = proxy
+        self.flight_client_options = flight_client_options
+
+    def _read_certs(self, path):
+        with open(path, "rb") as certs_file:
+            return certs_file.read()
+
+
+class QueryApiOptionsBuilder(object):
+    """
+    Helper class to make adding QueryApiOptions more dynamic.
+
+    Example:
+
+    .. code-block:: python
+
+        options = QueryApiOptionsBuilder()\
+            .proxy("http://internal.tunnel.proxy:8080") \
+            .root_certs("/home/fred/.etc/ssl/alt_certs.pem") \
+            .tls_verify(True) \
+            .build()
+
+        client = QueryApi(connection, token, None, None, options)
+    """
+    _root_certs_path = None
+    _tls_verify = True
+    _proxy = None
+    _flight_client_options = None
+
+    def root_certs(self, path):
+        self._root_certs_path = path
+        return self
+
+    def tls_verify(self, verify):
+        self._tls_verify = verify
+        return self
+
+    def proxy(self, proxy):
+        self._proxy = proxy
+        return self
+
+    def flight_client_options(self, flight_client_options):
+        self._flight_client_options = flight_client_options
+        return self
+
+    def build(self):
+        """Build a QueryApiOptions object with previously set values"""
+        return QueryApiOptions(
+            root_certs_path=self._root_certs_path,
+            verify=self._tls_verify,
+            proxy=self._proxy,
+            flight_client_options=self._flight_client_options
+        )
+
+
+class QueryApi(object):
+    """
+    Implementation for '/api/v2/query' endpoint.
+
+    Example:
+
+        .. code-block:: python
+
+            from influxdb_client import InfluxDBClient
+
+
+            # Initialize instance of QueryApi
+            with InfluxDBClient(url="http://localhost:8086", token="my-token", org="my-org") as client:
+                query_api = client.query_api()
+    """
+
+    def __init__(self,
+                 connection_string,
+                 token,
+                 flight_client_options,
+                 proxy=None, options=None) -> None:
+        """
+        Initialize defaults.
+
+        :param connection_string: Flight/gRPC connection string
+        :param token: access token
+        :param flight_client_options: Flight client options
+        """
+        self._token = token
+        self._flight_client_options = flight_client_options or {}
+        default_user_agent = ("grpc.secondary_user_agent", USER_AGENT)
+        if "generic_options" in self._flight_client_options:
+            if "grpc.secondary_user_agent" not in dict(self._flight_client_options["generic_options"]).keys():
+                self._flight_client_options["generic_options"].append(default_user_agent)
+        else:
+            self._flight_client_options["generic_options"] = [default_user_agent]
+        self._proxy = proxy
+        from influxdb_client_3 import _merge_options as merge_options
+        if options:
+            if options.flight_client_options:
+                self._flight_client_options = merge_options(self._flight_client_options,
+                                                            None,
+                                                            options.flight_client_options)
+                if ('generic_options' in options.flight_client_options and
+                        'grpc.secondary_user_agent' in dict(options.flight_client_options["generic_options"]).keys()):
+                    self._flight_client_options['generic_options'].remove(default_user_agent)
+            if options.tls_root_certs:
+                self._flight_client_options["tls_root_certs"] = options.tls_root_certs
+            if options.proxy:
+                self._proxy = options.proxy
+            if options.tls_verify is not None:
+                self._flight_client_options["disable_server_verification"] = not options.tls_verify
+        if self._proxy:
+            self._flight_client_options["generic_options"].append(("grpc.http_proxy", self._proxy))
+        self._flight_client = FlightClient(connection_string, **self._flight_client_options)
+
+    def query(self, query: str, language: str, mode: str, database: str, **kwargs):
+        """Query data from InfluxDB.
+
+        :param query: The query to execute on the database.
+        :param language: The query language.
+        :param mode: The mode to use for the query.
+                     It should be one of "all", "pandas", "polars", "chunk", "reader" or "schema".
+        :param database: The database to query from.
+        :param kwargs: Additional arguments to pass to the ``FlightCallOptions headers``.
+                       For example, it can be used to set up per request headers.
+        :keyword query_parameters: The query parameters to use in the query.
+                                   It should be a ``dictionary`` of key-value pairs.
+        :return: The query result in the specified mode.
+        """
+        try:
+            ticket, _options = self._prepare_query(query, language, database, **kwargs)
+
+            flight_reader = self._do_get(ticket, _options)
+
+            return self._translate_stream_reader(flight_reader, mode)
+        except Exception as e:
+            raise e
+
+    async def query_async(self, query: str, language: str, mode: str, database: str, **kwargs):
+        """Query data from InfluxDB asynchronously.
+
+        Wraps internal FlightClient.doGet call in its own executor, so that the event_loop will not be blocked.
+
+        :param query: The query to execute on the database.
+        :param language: The query language.
+        :param mode: The mode to use for the query.
+             It should be one of "all", "pandas", "polars", "chunk", "reader" or "schema".
+        :param database: The database to query from.
+        :param kwargs: Additional arguments to pass to the ``FlightCallOptions headers``.
+               For example, it can be used to set up per request headers.
+        :keyword query_parameters: The query parameters to use in the query.
+                           It should be a ``dictionary`` of key-value pairs.
+        :return: The query result in the specified mode.
+        """
+        try:
+            ticket, options = self._prepare_query(query, language, database, **kwargs)
+            loop = asyncio.get_running_loop()
+            _flight_reader = await loop.run_in_executor(None,
+                                                        self._flight_client.do_get, ticket, options)
+            return await loop.run_in_executor(None, self._translate_stream_reader,
+                                              _flight_reader,
+                                              mode)
+        except Exception as e:
+            raise e
+
+    def _translate_stream_reader(self, reader: FlightStreamReader, mode: str):
+        from influxdb_client_3 import polars as has_polars
+        try:
+            mode_funcs = {
+                "all": reader.read_all,
+                "pandas": reader.read_pandas,
+                "chunk": lambda: reader,
+                "reader": reader.to_reader,
+                "schema": lambda: reader.schema
+            }
+            if has_polars:
+                import polars as pl
+                mode_funcs["polars"] = lambda: pl.from_arrow(reader.read_all())
+            mode_func = mode_funcs.get(mode, reader.read_all)
+
+            return mode_func() if callable(mode_func) else mode_func
+        except Exception as e:
+            raise e
+
+    def _prepare_query(self, query: str, language: str, database: str, **kwargs):
+        from influxdb_client_3 import _merge_options as merge_options
+        # Create an authorization header
+        optargs = {
+            "headers": [(b"authorization", f"Bearer {self._token}".encode('utf-8'))],
+            "timeout": 300
+        }
+        opts = merge_options(optargs, exclude_keys=['query_parameters'], custom=kwargs)
+        _options = FlightCallOptions(**opts)
+
+        #
+        # Ticket data
+        #
+        ticket_data = {
+            "database": database,
+            "sql_query": query,
+            "query_type": language
+        }
+        # add query parameters
+        query_parameters = kwargs.get("query_parameters", None)
+        if query_parameters:
+            ticket_data["params"] = query_parameters
+
+        ticket = Ticket(json.dumps(ticket_data).encode('utf-8'))
+
+        return ticket, _options
+
+    def _do_get(self, ticket: Ticket, options: FlightCallOptions = None) -> FlightStreamReader:
+        return self._flight_client.do_get(ticket, options)
+
+    def close(self):
+        """Close the Flight client."""
+        self._flight_client.close()

{influxdb3_python-0.11.0 → influxdb3_python-0.12.0}/influxdb_client_3/version.py

@@ -1,4 +1,4 @@
 """Version of the Client that is used in User-Agent header."""
 
-VERSION = '0.11.0'
+VERSION = '0.12.0'
 USER_AGENT = f'influxdb3-python/{VERSION}'

{influxdb3_python-0.11.0 → influxdb3_python-0.12.0}/tests/test_influxdb_client_3.py

@@ -2,6 +2,8 @@ import unittest
 from unittest.mock import patch
 
 from influxdb_client_3 import InfluxDBClient3
+from tests.util import asyncio_run
+from tests.util.mocks import ConstantFlightServer, ConstantData
 
 
 class TestInfluxDBClient3(unittest.TestCase):
@@ -48,6 +50,30 @@ class TestInfluxDBClient3(unittest.TestCase):
         )
         self.assertEqual(client._client.auth_header_value, "my_scheme my_token")
 
+    @asyncio_run
+    async def test_query_async(self):
+        with ConstantFlightServer() as server:
+            client = InfluxDBClient3(
+                host=f"http://localhost:{server.port}",
+                org="my_org",
+                database="my_db",
+                token="my_token",
+            )
+
+            query = "SELECT * FROM my_data"
+
+            table = await client.query_async(query=query, language="sql")
+
+            result_list = table.to_pylist()
+
+            cd = ConstantData()
+            for item in cd.to_list():
+                assert item in result_list
+
+            assert {'data': 'database', 'reference': 'my_db', 'value': -1.0} in result_list
+            assert {'data': 'sql_query', 'reference': query, 'value': -1.0} in result_list
+            assert {'data': 'query_type', 'reference': 'sql', 'value': -1.0} in result_list
+
 
 if __name__ == '__main__':
     unittest.main()