apache-iotdb 1.2.0__tar.gz → 1.2.1__tar.gz

{apache-iotdb-1.2.0 → apache-iotdb-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: apache-iotdb
-Version: 1.2.0
+Version: 1.2.1
 Summary: Apache IoTDB client API
 Home-page: https://github.com/apache/iotdb
 Author:  Apache Software Foundation

{apache-iotdb-1.2.0 → apache-iotdb-1.2.1}/apache_iotdb.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: apache-iotdb
-Version: 1.2.0
+Version: 1.2.1
 Summary: Apache IoTDB client API
 Home-page: https://github.com/apache/iotdb
 Author:  Apache Software Foundation

{apache-iotdb-1.2.0 → apache-iotdb-1.2.1}/apache_iotdb.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ apache_iotdb.egg-info/requires.txt
 apache_iotdb.egg-info/top_level.txt
 iotdb/IoTDBContainer.py
 iotdb/Session.py
+iotdb/SessionPool.py
 iotdb/__init__.py
 iotdb/dbapi/Connection.py
 iotdb/dbapi/Cursor.py
@@ -63,6 +64,7 @@ tests/test_delete_data.py
 tests/test_numpy_tablet.py
 tests/test_one_device.py
 tests/test_session.py
+tests/test_session_pool.py
 tests/test_tablet.py
 tests/test_template.py
 tests/test_todf.py

{apache-iotdb-1.2.0 → apache-iotdb-1.2.1}/iotdb/IoTDBContainer.py

@@ -16,13 +16,17 @@
 # under the License.
 #
 
+import time
 from os import environ
 
 from testcontainers.core.container import DockerContainer
+from testcontainers.core.utils import setup_logger
 from testcontainers.core.waiting_utils import wait_container_is_ready
 
 from iotdb.Session import Session
 
+logger = setup_logger(__name__)
+
 
 class IoTDBContainer(DockerContainer):
     IOTDB_USER = environ.get("IOTDB_USER", "root")
@@ -48,4 +52,11 @@ class IoTDBContainer(DockerContainer):
         self._configure()
         super().start()
         self._connect()
+        # sleep 2s to make sure the confignode cached the datanode info
+        time.sleep(2)
+        return self
+
+    def stop(self, force=True, delete_volume=True):
+        logger.info(self.get_wrapped_container().logs().decode("utf-8"))
+        super().stop(force, delete_volume)
         return self

{apache-iotdb-1.2.0 → apache-iotdb-1.2.1}/iotdb/Session.py

@@ -15,6 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 #
+
 import logging
 import random
 import struct

apache-iotdb-1.2.1/iotdb/SessionPool.py

@@ -0,0 +1,140 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+import logging
+import multiprocessing
+import time
+from queue import Queue
+from threading import Lock
+
+from iotdb.Session import Session
+
+DEFAULT_MULTIPIE = 5
+DEFAULT_FETCH_SIZE = 5000
+DEFAULT_MAX_RETRY = 3
+DEFAULT_TIME_ZONE = "UTC+8"
+logger = logging.getLogger("IoTDB")
+
+
+class PoolConfig(object):
+    def __init__(self, host: str = None, port: str = None, user_name: str = None, password: str = None,
+                 node_urls: list = None,
+                 fetch_size: int = DEFAULT_FETCH_SIZE, time_zone: str = DEFAULT_TIME_ZONE,
+                 max_retry: int = DEFAULT_MAX_RETRY, enable_compression: bool = False):
+        self.host = host
+        self.port = port
+        if node_urls is None:
+            if host is None or port is None:
+                raise ValueError("(host,port) and node_urls cannot be None at the same time.")
+            node_urls = []
+        self.node_urls = node_urls
+        self.user_name = user_name
+        self.password = password
+        self.fetch_size = fetch_size
+        self.time_zone = time_zone
+        self.max_retry = max_retry
+        self.enable_compression = enable_compression
+
+
+class SessionPool(object):
+
+    def __init__(self, pool_config: PoolConfig, max_pool_size: int, wait_timeout_in_ms: int):
+        self.__pool_config = pool_config
+        self.__max_pool_size = max_pool_size
+        self.__wait_timeout_in_ms = wait_timeout_in_ms / 1000
+        self.__pool_size = 0
+        self.__queue = Queue(max_pool_size)
+        self.__lock = Lock()
+        self.__closed = False
+
+    def __construct_session(self) -> Session:
+        if len(self.__pool_config.node_urls) > 0:
+            session = Session.init_from_node_urls(self.__pool_config.node_urls, self.__pool_config.user_name,
+                                                  self.__pool_config.password, self.__pool_config.fetch_size,
+                                                  self.__pool_config.time_zone)
+
+        else:
+            session = Session(self.__pool_config.host, self.__pool_config.port, self.__pool_config.user_name,
+                              self.__pool_config.password, self.__pool_config.fetch_size, self.__pool_config.time_zone)
+
+        session.open(self.__pool_config.enable_compression)
+        return session
+
+    def __poll_session(self):
+        q = None
+        if not self.__queue.empty():
+            q = self.__queue.get(block=False)
+        return q
+
+    def get_session(self) -> Session:
+
+        if self.__closed:
+            raise ConnectionError("SessionPool has already been closed.")
+
+        should_create = False
+        start = time.time()
+
+        session = self.__poll_session()
+        while session is None:
+            with self.__lock:
+                if self.__pool_size < self.__max_pool_size:
+                    self.__pool_size += 1
+                    should_create = True
+                    break
+                else:
+                    if time.time() - start > self.__wait_timeout_in_ms:
+                        raise TimeoutError("Wait to get session timeout in SessionPool, current pool size: {0}"
+                                           .format(self.__max_pool_size))
+                    time.sleep(1)
+            session = self.__poll_session()
+
+        if should_create:
+            try:
+                session = self.__construct_session()
+            except Exception as e:
+                with self.__lock:
+                    self.__pool_size -= 1
+                raise e
+
+        return session
+
+    def put_back(self, session: Session):
+
+        if self.__closed:
+            raise ConnectionError("SessionPool has already been closed, please close the session manually.")
+
+        if session.is_open():
+            self.__queue.put(session)
+        else:
+            with self.__lock:
+                self.__pool_size -= 1
+
+    def close(self):
+
+        with self.__lock:
+            while not self.__queue.empty():
+                session = self.__queue.get(block=False)
+                session.close()
+                self.__pool_size -= 1
+        self.__closed = True
+        logger.info("SessionPool has been closed successfully.")
+
+
+def create_session_pool(pool_config: PoolConfig, max_pool_size: int, wait_timeout_in_ms: int) -> SessionPool:
+    if max_pool_size <= 0:
+        max_pool_size = multiprocessing.cpu_count() * DEFAULT_MULTIPIE
+    return SessionPool(pool_config, max_pool_size, wait_timeout_in_ms)

{apache-iotdb-1.2.0 → apache-iotdb-1.2.1}/iotdb/thrift/rpc/IClientRPCService.py

@@ -59,6 +59,14 @@ class Iface(object):
         """
         pass
 
+    def executeFastLastDataQueryForOneDeviceV2(self, req):
+        """
+        Parameters:
+         - req
+
+        """
+        pass
+
     def executeAggregationQueryV2(self, req):
         """
         Parameters:
@@ -664,6 +672,38 @@ class Client(Iface):
             return result.success
         raise TApplicationException(TApplicationException.MISSING_RESULT, "executeLastDataQueryV2 failed: unknown result")
 
+    def executeFastLastDataQueryForOneDeviceV2(self, req):
+        """
+        Parameters:
+         - req
+
+        """
+        self.send_executeFastLastDataQueryForOneDeviceV2(req)
+        return self.recv_executeFastLastDataQueryForOneDeviceV2()
+
+    def send_executeFastLastDataQueryForOneDeviceV2(self, req):
+        self._oprot.writeMessageBegin('executeFastLastDataQueryForOneDeviceV2', TMessageType.CALL, self._seqid)
+        args = executeFastLastDataQueryForOneDeviceV2_args()
+        args.req = req
+        args.write(self._oprot)
+        self._oprot.writeMessageEnd()
+        self._oprot.trans.flush()
+
+    def recv_executeFastLastDataQueryForOneDeviceV2(self):
+        iprot = self._iprot
+        (fname, mtype, rseqid) = iprot.readMessageBegin()
+        if mtype == TMessageType.EXCEPTION:
+            x = TApplicationException()
+            x.read(iprot)
+            iprot.readMessageEnd()
+            raise x
+        result = executeFastLastDataQueryForOneDeviceV2_result()
+        result.read(iprot)
+        iprot.readMessageEnd()
+        if result.success is not None:
+            return result.success
+        raise TApplicationException(TApplicationException.MISSING_RESULT, "executeFastLastDataQueryForOneDeviceV2 failed: unknown result")
+
     def executeAggregationQueryV2(self, req):
         """
         Parameters:
@@ -2456,6 +2496,7 @@ class Processor(Iface, TProcessor):
         self._processMap["executeStatementV2"] = Processor.process_executeStatementV2
         self._processMap["executeRawDataQueryV2"] = Processor.process_executeRawDataQueryV2
         self._processMap["executeLastDataQueryV2"] = Processor.process_executeLastDataQueryV2
+        self._processMap["executeFastLastDataQueryForOneDeviceV2"] = Processor.process_executeFastLastDataQueryForOneDeviceV2
         self._processMap["executeAggregationQueryV2"] = Processor.process_executeAggregationQueryV2
         self._processMap["executeGroupByQueryIntervalQuery"] = Processor.process_executeGroupByQueryIntervalQuery
         self._processMap["fetchResultsV2"] = Processor.process_fetchResultsV2
@@ -2649,6 +2690,29 @@ class Processor(Iface, TProcessor):
         oprot.writeMessageEnd()
         oprot.trans.flush()
 
+    def process_executeFastLastDataQueryForOneDeviceV2(self, seqid, iprot, oprot):
+        args = executeFastLastDataQueryForOneDeviceV2_args()
+        args.read(iprot)
+        iprot.readMessageEnd()
+        result = executeFastLastDataQueryForOneDeviceV2_result()
+        try:
+            result.success = self._handler.executeFastLastDataQueryForOneDeviceV2(args.req)
+            msg_type = TMessageType.REPLY
+        except TTransport.TTransportException:
+            raise
+        except TApplicationException as ex:
+            logging.exception('TApplication exception in handler')
+            msg_type = TMessageType.EXCEPTION
+            result = ex
+        except Exception:
+            logging.exception('Unexpected exception in handler')
+            msg_type = TMessageType.EXCEPTION
+            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
+        oprot.writeMessageBegin("executeFastLastDataQueryForOneDeviceV2", msg_type, seqid)
+        result.write(oprot)
+        oprot.writeMessageEnd()
+        oprot.trans.flush()
+
     def process_executeAggregationQueryV2(self, seqid, iprot, oprot):
         args = executeAggregationQueryV2_args()
         args.read(iprot)
@@ -4565,6 +4629,131 @@ executeLastDataQueryV2_result.thrift_spec = (
 )
 
 
+class executeFastLastDataQueryForOneDeviceV2_args(object):
+    """
+    Attributes:
+     - req
+
+    """
+
+
+    def __init__(self, req=None,):
+        self.req = req
+
+    def read(self, iprot):
+        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
+            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
+            return
+        iprot.readStructBegin()
+        while True:
+            (fname, ftype, fid) = iprot.readFieldBegin()
+            if ftype == TType.STOP:
+                break
+            if fid == 1:
+                if ftype == TType.STRUCT:
+                    self.req = TSFastLastDataQueryForOneDeviceReq()
+                    self.req.read(iprot)
+                else:
+                    iprot.skip(ftype)
+            else:
+                iprot.skip(ftype)
+            iprot.readFieldEnd()
+        iprot.readStructEnd()
+
+    def write(self, oprot):
+        if oprot._fast_encode is not None and self.thrift_spec is not None:
+            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
+            return
+        oprot.writeStructBegin('executeFastLastDataQueryForOneDeviceV2_args')
+        if self.req is not None:
+            oprot.writeFieldBegin('req', TType.STRUCT, 1)
+            self.req.write(oprot)
+            oprot.writeFieldEnd()
+        oprot.writeFieldStop()
+        oprot.writeStructEnd()
+
+    def validate(self):
+        return
+
+    def __repr__(self):
+        L = ['%s=%r' % (key, value)
+             for key, value in self.__dict__.items()]
+        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+    def __eq__(self, other):
+        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+    def __ne__(self, other):
+        return not (self == other)
+all_structs.append(executeFastLastDataQueryForOneDeviceV2_args)
+executeFastLastDataQueryForOneDeviceV2_args.thrift_spec = (
+    None,  # 0
+    (1, TType.STRUCT, 'req', [TSFastLastDataQueryForOneDeviceReq, None], None, ),  # 1
+)
+
+
+class executeFastLastDataQueryForOneDeviceV2_result(object):
+    """
+    Attributes:
+     - success
+
+    """
+
+
+    def __init__(self, success=None,):
+        self.success = success
+
+    def read(self, iprot):
+        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
+            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
+            return
+        iprot.readStructBegin()
+        while True:
+            (fname, ftype, fid) = iprot.readFieldBegin()
+            if ftype == TType.STOP:
+                break
+            if fid == 0:
+                if ftype == TType.STRUCT:
+                    self.success = TSExecuteStatementResp()
+                    self.success.read(iprot)
+                else:
+                    iprot.skip(ftype)
+            else:
+                iprot.skip(ftype)
+            iprot.readFieldEnd()
+        iprot.readStructEnd()
+
+    def write(self, oprot):
+        if oprot._fast_encode is not None and self.thrift_spec is not None:
+            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
+            return
+        oprot.writeStructBegin('executeFastLastDataQueryForOneDeviceV2_result')
+        if self.success is not None:
+            oprot.writeFieldBegin('success', TType.STRUCT, 0)
+            self.success.write(oprot)
+            oprot.writeFieldEnd()
+        oprot.writeFieldStop()
+        oprot.writeStructEnd()
+
+    def validate(self):
+        return
+
+    def __repr__(self):
+        L = ['%s=%r' % (key, value)
+             for key, value in self.__dict__.items()]
+        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+    def __eq__(self, other):
+        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+    def __ne__(self, other):
+        return not (self == other)
+all_structs.append(executeFastLastDataQueryForOneDeviceV2_result)
+executeFastLastDataQueryForOneDeviceV2_result.thrift_spec = (
+    (0, TType.STRUCT, 'success', [TSExecuteStatementResp, None], None, ),  # 0
+)
+
+
 class executeAggregationQueryV2_args(object):
     """
     Attributes:
@@ -7085,10 +7274,10 @@ class deleteTimeseries_args(object):
             elif fid == 2:
                 if ftype == TType.LIST:
                     self.path = []
-                    (_etype627, _size624) = iprot.readListBegin()
-                    for _i628 in range(_size624):
-                        _elem629 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
-                        self.path.append(_elem629)
+                    (_etype634, _size631) = iprot.readListBegin()
+                    for _i635 in range(_size631):
+                        _elem636 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
+                        self.path.append(_elem636)
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
@@ -7109,8 +7298,8 @@ class deleteTimeseries_args(object):
         if self.path is not None:
             oprot.writeFieldBegin('path', TType.LIST, 2)
             oprot.writeListBegin(TType.STRING, len(self.path))
-            for iter630 in self.path:
-                oprot.writeString(iter630.encode('utf-8') if sys.version_info[0] == 2 else iter630)
+            for iter637 in self.path:
+                oprot.writeString(iter637.encode('utf-8') if sys.version_info[0] == 2 else iter637)
             oprot.writeListEnd()
             oprot.writeFieldEnd()
         oprot.writeFieldStop()
@@ -7229,10 +7418,10 @@ class deleteStorageGroups_args(object):
             elif fid == 2:
                 if ftype == TType.LIST:
                     self.storageGroup = []
-                    (_etype634, _size631) = iprot.readListBegin()
-                    for _i635 in range(_size631):
-                        _elem636 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
-                        self.storageGroup.append(_elem636)
+                    (_etype641, _size638) = iprot.readListBegin()
+                    for _i642 in range(_size638):
+                        _elem643 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
+                        self.storageGroup.append(_elem643)
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
@@ -7253,8 +7442,8 @@ class deleteStorageGroups_args(object):
         if self.storageGroup is not None:
             oprot.writeFieldBegin('storageGroup', TType.LIST, 2)
             oprot.writeListBegin(TType.STRING, len(self.storageGroup))
-            for iter637 in self.storageGroup:
-                oprot.writeString(iter637.encode('utf-8') if sys.version_info[0] == 2 else iter637)
+            for iter644 in self.storageGroup:
+                oprot.writeString(iter644.encode('utf-8') if sys.version_info[0] == 2 else iter644)
             oprot.writeListEnd()
             oprot.writeFieldEnd()
         oprot.writeFieldStop()