This is an automated email from the ASF dual-hosted git repository.
kangrong pushed a commit to branch py_cli_performance
in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit 7e6ec75d673178454930327da0b4023640e5e781
Author: kr11 <3095717866.com>
AuthorDate: Thu Jul 8 08:42:09 2021 +0800
temp
---
client-py/TabletOptimizeAssert.py | 85 ++++++++++++++
client-py/TabletOriginalAssert.py | 85 ++++++++++++++
client-py/iotdb/Session.py | 10 +-
client-py/iotdb/utils/IoTDBConstants.py | 3 +
client-py/iotdb/utils/Tablet.py | 110 ++++++++++--------
client-py/tablet_performance_comparison.py | 127 +++++++++++++++++++++
client-py/zzz_SessionInsertRecord.py | 123 ++++++++++++++++++++
client-py/zzz_TestIOTDb.py | 104 +++++++++++++++++
client-py/zzz_debugInsertRecord.py | 28 +++++
client-py/zzz_main.py | 22 ++++
.../main/java/org/apache/iotdb/TestSession.java | 100 ++++++++++++++++
11 files changed, 747 insertions(+), 50 deletions(-)
diff --git a/client-py/TabletOptimizeAssert.py
b/client-py/TabletOptimizeAssert.py
new file mode 100644
index 0000000..98bb02f
--- /dev/null
+++ b/client-py/TabletOptimizeAssert.py
@@ -0,0 +1,85 @@
+# 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.
+#
+
+# Uncomment the following line to use apache-iotdb module installed by pip3
+
+from iotdb.Session import Session
+from iotdb.utils.IoTDBConstants import TSDataType, TSEncoding, Compressor,
UseNew
+from iotdb.utils.Tablet import Tablet
+import random
+import numpy as np
+from numba import jit
+
+# creating session connection.
+ip = "127.0.0.1"
+port_ = "6667"
+username_ = "root"
+password_ = "root"
+session = Session(ip, port_, username_, password_, fetch_size=1024,
zone_id="UTC+8")
+session.open(False)
+import time
+
+# parameters for test
+row_size = 10000
+column_size = 2000
+
+
+measurements_ = ["s_01", "s_02", "s_03", "s_04", "s_05", "s_06"]
+data_types_ = [
+ TSDataType.BOOLEAN,
+ TSDataType.INT32,
+ TSDataType.INT64,
+ TSDataType.FLOAT,
+ TSDataType.DOUBLE,
+ TSDataType.TEXT,
+]
+one_value = [False, 10, 11, 1.1, 10011.1, "test_record"]
+
+insert_cost = 0
+st = time.perf_counter()
+for i in range(0, column_size):
+ device_id = "root.sg%d.%d" % (i % 8, i)
+ timestamps_ = []
+ values_ = []
+ for t in range(0, row_size):
+ timestamps_.append(t)
+ # values_.append([-2 + 6 * random.random(), True])
+ values_.append(one_value)
+
+ tablet_ = Tablet(device_id, measurements_, data_types_, values_,
timestamps_)
+ cost_st = time.perf_counter()
+ session.insert_tablet(tablet_)
+ insert_cost += time.perf_counter() - cost_st
+
+end = time.perf_counter()
+print("use time: %.3f" % (end - st))
+print("insert time: %.3f" % insert_cost)
+print("All executions done!!")
+# assert
+for i in range(0, column_size):
+ device_id = "root.sg%d.%d" % (i % 8, i)
+
+ session_data_set = session.execute_query_statement("select * from " +
device_id)
+ session_data_set.set_fetch_size(row_size)
+ while session_data_set.has_next():
+ print(session_data_set.next())
+ session_data_set.close_operation_handle()
+
+session.close()
+
+print("Assert successfully")
diff --git a/client-py/TabletOriginalAssert.py
b/client-py/TabletOriginalAssert.py
new file mode 100644
index 0000000..98bb02f
--- /dev/null
+++ b/client-py/TabletOriginalAssert.py
@@ -0,0 +1,85 @@
+# 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.
+#
+
+# Uncomment the following line to use apache-iotdb module installed by pip3
+
+from iotdb.Session import Session
+from iotdb.utils.IoTDBConstants import TSDataType, TSEncoding, Compressor,
UseNew
+from iotdb.utils.Tablet import Tablet
+import random
+import numpy as np
+from numba import jit
+
+# creating session connection.
+ip = "127.0.0.1"
+port_ = "6667"
+username_ = "root"
+password_ = "root"
+session = Session(ip, port_, username_, password_, fetch_size=1024,
zone_id="UTC+8")
+session.open(False)
+import time
+
+# parameters for test
+row_size = 10000
+column_size = 2000
+
+
+measurements_ = ["s_01", "s_02", "s_03", "s_04", "s_05", "s_06"]
+data_types_ = [
+ TSDataType.BOOLEAN,
+ TSDataType.INT32,
+ TSDataType.INT64,
+ TSDataType.FLOAT,
+ TSDataType.DOUBLE,
+ TSDataType.TEXT,
+]
+one_value = [False, 10, 11, 1.1, 10011.1, "test_record"]
+
+insert_cost = 0
+st = time.perf_counter()
+for i in range(0, column_size):
+ device_id = "root.sg%d.%d" % (i % 8, i)
+ timestamps_ = []
+ values_ = []
+ for t in range(0, row_size):
+ timestamps_.append(t)
+ # values_.append([-2 + 6 * random.random(), True])
+ values_.append(one_value)
+
+ tablet_ = Tablet(device_id, measurements_, data_types_, values_,
timestamps_)
+ cost_st = time.perf_counter()
+ session.insert_tablet(tablet_)
+ insert_cost += time.perf_counter() - cost_st
+
+end = time.perf_counter()
+print("use time: %.3f" % (end - st))
+print("insert time: %.3f" % insert_cost)
+print("All executions done!!")
+# assert
+for i in range(0, column_size):
+ device_id = "root.sg%d.%d" % (i % 8, i)
+
+ session_data_set = session.execute_query_statement("select * from " +
device_id)
+ session_data_set.set_fetch_size(row_size)
+ while session_data_set.has_next():
+ print(session_data_set.next())
+ session_data_set.close_operation_handle()
+
+session.close()
+
+print("Assert successfully")
diff --git a/client-py/iotdb/Session.py b/client-py/iotdb/Session.py
index 5db100a..c3c685c 100644
--- a/client-py/iotdb/Session.py
+++ b/client-py/iotdb/Session.py
@@ -84,6 +84,7 @@ class Session(object):
self.__session_id = None
self.__statement_id = None
self.__zone_id = zone_id
+ self.values_in_bytes = None
def open(self, enable_rpc_compression):
if not self.__is_close:
@@ -403,13 +404,18 @@ class Session(object):
def gen_insert_record_req(
self, device_id, timestamp, measurements, data_types, values
):
+ # if self.values_in_bytes != None:
+ # return TSInsertRecordReq(
+ # self.__session_id, device_id, measurements,
self.values_in_bytes, timestamp
+ # )
if (len(values) != len(data_types)) or (len(values) !=
len(measurements)):
raise RuntimeError(
"length of data types does not equal to length of values!"
)
- values_in_bytes = Session.value_to_bytes(data_types, values)
+ self.values_in_bytes = Session.value_to_bytes(data_types, values)
+
return TSInsertRecordReq(
- self.__session_id, device_id, measurements, values_in_bytes,
timestamp
+ self.__session_id, device_id, measurements, self.values_in_bytes,
timestamp
)
def gen_insert_str_record_req(
diff --git a/client-py/iotdb/utils/IoTDBConstants.py
b/client-py/iotdb/utils/IoTDBConstants.py
index ff92773..1aeda87 100644
--- a/client-py/iotdb/utils/IoTDBConstants.py
+++ b/client-py/iotdb/utils/IoTDBConstants.py
@@ -51,3 +51,6 @@ class Compressor(Enum):
PAA = 5
PLA = 6
LZ4 = 7
+
+# UseNew=True
+# UseNew=False
\ No newline at end of file
diff --git a/client-py/iotdb/utils/Tablet.py b/client-py/iotdb/utils/Tablet.py
index 667adcb..ea6e456 100644
--- a/client-py/iotdb/utils/Tablet.py
+++ b/client-py/iotdb/utils/Tablet.py
@@ -19,10 +19,11 @@
import struct
from iotdb.utils.IoTDBConstants import TSDataType
+# from iotdb.utils.IoTDBConstants import UseNew
class Tablet(object):
- def __init__(self, device_id, measurements, data_types, values,
timestamps):
+ def __init__(self, device_id, measurements, data_types, values,
timestamps, use_new=False):
"""
creating a tablet for insertion
for example, considering device: root.sg1.d1
@@ -57,6 +58,7 @@ class Tablet(object):
self.__data_types = data_types
self.__row_number = len(timestamps)
self.__column_number = len(measurements)
+ self.__use_new = use_new
@staticmethod
def check_sorted(timestamps):
@@ -78,54 +80,66 @@ class Tablet(object):
return self.__device_id
def get_binary_timestamps(self):
- format_str_list = [">"]
- values_tobe_packed = []
- for timestamp in self.__timestamps:
- format_str_list.append("q")
- values_tobe_packed.append(timestamp)
+ if not self.__use_new:
+ format_str_list = [">"]
+ values_tobe_packed = []
+ for timestamp in self.__timestamps:
+ format_str_list.append("q")
+ values_tobe_packed.append(timestamp)
- format_str = "".join(format_str_list)
- return struct.pack(format_str, *values_tobe_packed)
+ format_str = "".join(format_str_list)
+ return struct.pack(format_str, *values_tobe_packed)
+ else:
+ return self.__timestamps.tobytes()
def get_binary_values(self):
- format_str_list = [">"]
- values_tobe_packed = []
- for i in range(self.__column_number):
- if self.__data_types[i] == TSDataType.BOOLEAN:
- format_str_list.append(str(self.__row_number))
- format_str_list.append("?")
- for j in range(self.__row_number):
- values_tobe_packed.append(self.__values[j][i])
- elif self.__data_types[i] == TSDataType.INT32:
- format_str_list.append(str(self.__row_number))
- format_str_list.append("i")
- for j in range(self.__row_number):
- values_tobe_packed.append(self.__values[j][i])
- elif self.__data_types[i] == TSDataType.INT64:
- format_str_list.append(str(self.__row_number))
- format_str_list.append("q")
- for j in range(self.__row_number):
- values_tobe_packed.append(self.__values[j][i])
- elif self.__data_types[i] == TSDataType.FLOAT:
- format_str_list.append(str(self.__row_number))
- format_str_list.append("f")
- for j in range(self.__row_number):
- values_tobe_packed.append(self.__values[j][i])
- elif self.__data_types[i] == TSDataType.DOUBLE:
- format_str_list.append(str(self.__row_number))
- format_str_list.append("d")
- for j in range(self.__row_number):
- values_tobe_packed.append(self.__values[j][i])
- elif self.__data_types[i] == TSDataType.TEXT:
- for j in range(self.__row_number):
- value_bytes = bytes(self.__values[j][i], "utf-8")
+ if not self.__use_new:
+ format_str_list = [">"]
+ values_tobe_packed = []
+ for i in range(self.__column_number):
+ if self.__data_types[i] == TSDataType.BOOLEAN:
+ format_str_list.append(str(self.__row_number))
+ format_str_list.append("?")
+ for j in range(self.__row_number):
+ values_tobe_packed.append(self.__values[j][i])
+ elif self.__data_types[i] == TSDataType.INT32:
+ format_str_list.append(str(self.__row_number))
format_str_list.append("i")
- format_str_list.append(str(len(value_bytes)))
- format_str_list.append("s")
- values_tobe_packed.append(len(value_bytes))
- values_tobe_packed.append(value_bytes)
- else:
- raise RuntimeError("Unsupported data type:" +
str(self.__data_types[i]))
-
- format_str = "".join(format_str_list)
- return struct.pack(format_str, *values_tobe_packed)
+ for j in range(self.__row_number):
+ values_tobe_packed.append(self.__values[j][i])
+ elif self.__data_types[i] == TSDataType.INT64:
+ format_str_list.append(str(self.__row_number))
+ format_str_list.append("q")
+ for j in range(self.__row_number):
+ values_tobe_packed.append(self.__values[j][i])
+ elif self.__data_types[i] == TSDataType.FLOAT:
+ format_str_list.append(str(self.__row_number))
+ format_str_list.append("f")
+ for j in range(self.__row_number):
+ values_tobe_packed.append(self.__values[j][i])
+ elif self.__data_types[i] == TSDataType.DOUBLE:
+ format_str_list.append(str(self.__row_number))
+ format_str_list.append("d")
+ for j in range(self.__row_number):
+ values_tobe_packed.append(self.__values[j][i])
+ elif self.__data_types[i] == TSDataType.TEXT:
+ for j in range(self.__row_number):
+ value_bytes = bytes(self.__values[j][i], "utf-8")
+ format_str_list.append("i")
+ format_str_list.append(str(len(value_bytes)))
+ format_str_list.append("s")
+ values_tobe_packed.append(len(value_bytes))
+ values_tobe_packed.append(value_bytes)
+ else:
+ raise RuntimeError("Unsupported data type:" +
str(self.__data_types[i]))
+
+ format_str = "".join(format_str_list)
+ return struct.pack(format_str, *values_tobe_packed)
+ else:
+ ret = []
+ for i in range(self.__column_number):
+ # if self.__data_types[i] == TSDataType.FLOAT:
+ ret.append(self.__values.tobytes())
+ # else:
+ # raise RuntimeError("Unsupported data type:" +
str(self.__data_types[i]))
+ return ret
diff --git a/client-py/tablet_performance_comparison.py
b/client-py/tablet_performance_comparison.py
new file mode 100644
index 0000000..afac6d2
--- /dev/null
+++ b/client-py/tablet_performance_comparison.py
@@ -0,0 +1,127 @@
+# 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.
+#
+
+# Uncomment the following line to use apache-iotdb module installed by pip3
+
+from iotdb.Session import Session
+from iotdb.utils.IoTDBConstants import TSDataType
+from iotdb.utils.Tablet import Tablet
+import random
+import numpy as np
+import time
+
+
+def create_open_session():
+ # creating session connection.
+ ip = "127.0.0.1"
+ port_ = "6667"
+ username_ = "root"
+ password_ = "root"
+ session = Session(ip, port_, username_, password_, fetch_size=1024,
zone_id="UTC+8")
+ session.open(False)
+ return session
+
+
+def check_count(expect, _session, _sql):
+ session_data_set = _session.execute_query_statement(_sql)
+ session_data_set.set_fetch_size(1)
+ get_count_line = False
+ while session_data_set.has_next():
+ if get_count_line:
+ assert False, "select count return more than one line"
+ line = session_data_set.next()
+ assert expect == line.get_fields()[0].get_long_value(), "count result
error"
+ get_count_line = True
+ if not get_count_line:
+ assert False, "select count has no result"
+ session_data_set.close_operation_handle()
+
+
+def performance_test(data_types=tuple([TSDataType.FLOAT]), use_new=True,
valid_result=False, row=10000, col=2000,
+ seed=0):
+ session = create_open_session()
+ st = time.perf_counter()
+ random.seed(a=seed, version=2)
+ insert_cost = 0
+
+ VALUES_OF_TYPES = {TSDataType.BOOLEAN: True,
+ TSDataType.DOUBLE: 1.234567,
+ TSDataType.FLOAT: 1.2,
+ TSDataType.INT32: 100,
+ TSDataType.INT64: 123456789098,
+ TSDataType.TEXT: "test_record"}
+ FORMAT_CHAR_OF_TYPES = {TSDataType.BOOLEAN: "?",
+ TSDataType.DOUBLE: "d",
+ TSDataType.FLOAT: "f",
+ TSDataType.INT32: "i",
+ TSDataType.INT64: "q",
+ TSDataType.TEXT: str}
+
+ type_len = len(data_types)
+ measurements_ = ["s" + str(i) for i in range(type_len)]
+
+ for i in range(0, col):
+ device_id = "root.sg%d.%d" % (i % 8, i)
+
+ if not use_new:
+ timestamps_ = []
+ values_ = []
+ for t in range(0, row):
+ timestamps_.append(t)
+ value_ = []
+ for data_type in data_types:
+ value_.append(VALUES_OF_TYPES[data_type])
+ values_.append(value_)
+ else:
+ timestamps_ = np.zeros(row, dtype='>q')
+ values_ = [np.zeros(row, dtype=FORMAT_CHAR_OF_TYPES[data_type])
for data_type in data_types]
+ for t in range(0, row):
+ timestamps_[t] = t
+ for j, data_type in enumerate(data_types):
+ values_[j][t] = VALUES_OF_TYPES[data_type]
+
+ tablet_ = Tablet(device_id, measurements_, data_types, values_,
timestamps_, use_new=use_new)
+ cost_st = time.perf_counter()
+ session.insert_tablet(tablet_)
+ insert_cost += time.perf_counter() - cost_st
+ if valid_result:
+ # query total line
+ print("execute query for validation")
+ check_count(row, session, "select count(*) from %s" % device_id)
+ # query the first
+ check_query_result(, session, "select count(*) from %s" %
device_id)
+ # query the last
+ print("query validation have passed")
+
+ session.close()
+ end = time.perf_counter()
+
+ print("All executions done!!")
+ print("use time: %.3f" % (end - st))
+ print("insert time: %.3f" % insert_cost)
+
+
+valid_result = True
+performance_test(data_types=tuple([TSDataType.FLOAT]), use_new=False,
valid_result=valid_result, row=3, col=1)
+# performance_test(data_types=tuple([TSDataType.FLOAT]), use_new=True,
valid_result=valid_result)
+
+# performance_test(data_types=tuple([TSDataType.BOOLEAN, TSDataType.FLOAT,
TSDataType.DOUBLE, TSDataType.INT32, TSDataType.INT64]), use_new=False,
valid_result=valid_result)
+# performance_test(data_types=tuple([TSDataType.BOOLEAN, TSDataType.FLOAT,
TSDataType.DOUBLE, TSDataType.INT32, TSDataType.INT64]), use_new=True,
valid_result=valid_result)
+#
+# performance_test(data_types=tuple([TSDataType.BOOLEAN, TSDataType.FLOAT,
TSDataType.DOUBLE, TSDataType.INT32, TSDataType.INT64, TSDataType.TEXT]),
use_new=False, valid_result=valid_result)
+# performance_test(data_types=tuple([TSDataType.BOOLEAN, TSDataType.FLOAT,
TSDataType.DOUBLE, TSDataType.INT32, TSDataType.INT64, TSDataType.TEXT]),
use_new=True, valid_result=valid_result)
diff --git a/client-py/zzz_SessionInsertRecord.py
b/client-py/zzz_SessionInsertRecord.py
new file mode 100644
index 0000000..5458c60
--- /dev/null
+++ b/client-py/zzz_SessionInsertRecord.py
@@ -0,0 +1,123 @@
+# 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.
+#
+
+# Uncomment the following line to use apache-iotdb module installed by pip3
+
+from iotdb.Session import Session
+from iotdb.utils.IoTDBConstants import TSDataType, TSEncoding, Compressor
+from iotdb.utils.Tablet import Tablet
+
+# creating session connection.
+ip = "127.0.0.1"
+port_ = "6667"
+username_ = "root"
+password_ = "root"
+session = Session(ip, port_, username_, password_, fetch_size=1024,
zone_id="UTC+8")
+session.open(False)
+
+# set and delete storage groups
+session.set_storage_group("root.sg_test_01")
+session.set_storage_group("root.sg_test_02")
+session.set_storage_group("root.sg_test_03")
+session.set_storage_group("root.sg_test_04")
+session.delete_storage_group("root.sg_test_02")
+session.delete_storage_groups(["root.sg_test_03", "root.sg_test_04"])
+
+# setting time series.
+session.create_time_series(
+ "root.sg_test_01.d_01.s_01", TSDataType.BOOLEAN, TSEncoding.PLAIN,
Compressor.SNAPPY
+)
+session.create_time_series(
+ "root.sg_test_01.d_01.s_02", TSDataType.INT32, TSEncoding.PLAIN,
Compressor.SNAPPY
+)
+session.create_time_series(
+ "root.sg_test_01.d_01.s_03", TSDataType.INT64, TSEncoding.PLAIN,
Compressor.SNAPPY
+)
+
+# setting multiple time series once.
+ts_path_lst_ = [
+ "root.sg_test_01.d_01.s_04",
+ "root.sg_test_01.d_01.s_05",
+ "root.sg_test_01.d_01.s_06",
+ "root.sg_test_01.d_01.s_07",
+ "root.sg_test_01.d_01.s_08",
+ "root.sg_test_01.d_01.s_09",
+]
+data_type_lst_ = [
+ TSDataType.FLOAT,
+ TSDataType.DOUBLE,
+ TSDataType.TEXT,
+ TSDataType.FLOAT,
+ TSDataType.DOUBLE,
+ TSDataType.TEXT,
+]
+encoding_lst_ = [TSEncoding.PLAIN for _ in range(len(data_type_lst_))]
+compressor_lst_ = [Compressor.SNAPPY for _ in range(len(data_type_lst_))]
+session.create_multi_time_series(
+ ts_path_lst_, data_type_lst_, encoding_lst_, compressor_lst_
+)
+
+# delete time series
+session.delete_time_series(
+ [
+ "root.sg_test_01.d_01.s_07",
+ "root.sg_test_01.d_01.s_08",
+ "root.sg_test_01.d_01.s_09",
+ ]
+)
+
+# checking time series
+print(
+ "s_07 expecting False, checking result: ",
+ session.check_time_series_exists("root.sg_test_01.d_01.s_07"),
+)
+print(
+ "s_03 expecting True, checking result: ",
+ session.check_time_series_exists("root.sg_test_01.d_01.s_03"),
+)
+
+# insert one record into the database.
+measurements_ = ["s_01", "s_02", "s_03", "s_04", "s_05", "s_06"]
+values_ = [False, 10, 11, 1.1, 10011.1, "test_record"]
+data_types_ = [
+ TSDataType.BOOLEAN,
+ TSDataType.INT32,
+ TSDataType.INT64,
+ TSDataType.FLOAT,
+ TSDataType.DOUBLE,
+ TSDataType.TEXT,
+]
+
+import time
+
+st = time.perf_counter()
+last_time = st
+total_count = 1_000_000
+
+for i in range(total_count):
+ if i % 10000 == 0:
+ now = time.perf_counter()
+ print("write %d, use time: %.3f" % (i, now - last_time))
+ last_time = now
+ session.insert_record("root.sg_test_01.d_01", i, measurements_,
data_types_, values_)
+end = time.perf_counter()
+# close session connection.
+session.close()
+
+print("All executions done!!")
+print("write %d, total time: %.3f" % (total_count, end - st))
diff --git a/client-py/zzz_TestIOTDb.py b/client-py/zzz_TestIOTDb.py
new file mode 100644
index 0000000..d1d1e19
--- /dev/null
+++ b/client-py/zzz_TestIOTDb.py
@@ -0,0 +1,104 @@
+# import argparse
+# import datetime
+# import random
+#
+# import numpy
+# import pandas as pd
+# import time
+#
+# from iotdb.Session import Session
+#
+# from iotdb.utils.IoTDBConstants import TSDataType
+# from iotdb.utils.Tablet import Tablet
+#
+# # from mertic.utils.iotdb_helper import resultset_to_pandas
+# # from mertic.common import setting
+# from datetime import datetime
+# import time
+#
+# def insertRecordData():
+# # session = setting.get_IoTDB_session()
+# ip = "127.0.0.1"
+# port_ = "6667"
+# username_ = "root"
+# password_ = "root"
+# session = Session(ip, port_, username_, password_, fetch_size=1024,
zone_id="UTC+8")
+# session.open(False)
+# listtablet = []
+# for i in range(2000, 4000):
+# sgnum = int(i) % 8
+# k = 0
+# time = 1621250000 + i
+# json_body = [
+# ]
+# tsd=[]
+# for t in range(10080):
+# k = k + 1
+# time = 1621250000 + k * 60
+# subtsd = []
+#
+# subtsd.append(int(time*1000))
+# subtsd.append(random.uniform(-2, 4))
+# subtsd.append(True)
+# tsd.append(subtsd)
+#
+# # print(tsd[:,0])
+# # break
+# tsd=numpy.array(tsd)
+# device_id = "root.sg" + str(sgnum) + "." + str(i)
+# measurements = [setting.LABEL_TSD_VALUE, setting.LABEL_TSD_ISTRUE]
+# data_types = [TSDataType.FLOAT, TSDataType.BOOLEAN]
+# values = numpy.array(tsd)[:, 1:]
+# times = [int(x) for x in tsd[:, 0]]
+# tablet=Tablet(device_id,measurements,data_types,values,times)
+#
+# listtablet.append(tablet)
+#
+# session.insert_tablets(listtablet)
+# listtablet=[]
+#
+# # session.insert_records(["root.sg"+str(sgnum)+"."+str(i)]*len(tsd),
+# # [int(x) for x in tsd[:,0]],
+# # [[setting.LABEL_TSD_VALUE,
setting.LABEL_TSD_ISTRUE]]*len(tsd),
+# # [[TSDataType.FLOAT,
TSDataType.BOOLEAN]]*len(tsd),
+# # numpy.array(tsd)[:,1:])
+#
+# session.close()
+#
+#
+#
+# def testiotdb():
+# session = setting.get_IoTDB_session()
+# session.open(False)
+# metric_meta_data = session.execute_query_statement(
+# "select metricID, LastUpdateTime, grain, LastTimeofLocal from
root.meta")
+# metric_meta_data = resultset_to_pandas(metric_meta_data)
+# del metric_meta_data['Time']
+# metric_meta_data.columns = [setting.LABEL_METRIC_ID,
setting.LABEL_METRIC_LASTUPDATETIME, setting.LABEL_TSD_GRAIN,
+# setting.LABEL_METRIC_LASTTIMEOFLOCAL]
+# session.close()
+# def queryData():
+#
+# for i in range(2000,4000):
+# session = setting.get_IoTDB_session()
+# session.open(False)
+# sgnum = int(i) % 8
+#
+# metric_meta_data = session.execute_query_statement(
+# "select time,value,is_true from root.sg"+str(sgnum)+"."+str(i))
+# # metric_meta_data = resultset_to_pandas(metric_meta_data)
+# # print(metric_meta_data)
+# print(i)
+# session.close()
+#
+# if __name__ == '__main__':
+# #args = parse_args()
+# #main(host=args.host, port=args.port)
+# #insertData()
+# #queryData(0,2000,1619193180000,1619193180000)
+# a = datetime.now() # 获得当前时间
+# insertRecordData()
+# b = datetime.now() # 获取当前时间
+# durn = (b - a).seconds # 两个时间差，并以秒显示出来
+# print(durn)
+# print("--------")
\ No newline at end of file
diff --git a/client-py/zzz_debugInsertRecord.py
b/client-py/zzz_debugInsertRecord.py
new file mode 100644
index 0000000..6d8d0e7
--- /dev/null
+++ b/client-py/zzz_debugInsertRecord.py
@@ -0,0 +1,28 @@
+from iotdb.Session import Session
+from iotdb.utils.IoTDBConstants import TSDataType, TSEncoding, Compressor
+
+# creating session connection.
+ip = "127.0.0.1"
+port_ = "6667"
+username_ = "root"
+password_ = "root"
+session = Session(ip, port_, username_, password_, fetch_size=1024,
zone_id="UTC+8")
+session.open(False)
+
+
+# setting time series.
+session.create_time_series("root.dj.d_01.temperature", TSDataType.FLOAT,
TSEncoding.PLAIN, Compressor.SNAPPY)
+session.create_time_series("root.dj.d_01.status", TSDataType.BOOLEAN,
TSEncoding.PLAIN, Compressor.SNAPPY)
+
+# insert one record into the database.
+measurements_ = ["temperature", "status"]
+values_ = [19.01, True]
+data_types_ = [
+ TSDataType.FLOAT,
+ TSDataType.BOOLEAN,
+]
+device_id = "root.dj.d_01"
+session.insert_record(device_id, 2, measurements_, data_types_, values_)
+
+session.execute_non_query_statement("insert into
root.sg_test_01.wf02.wf01(timestamp, temperature, status) values(now(), 20.00,
True)")
+session.close()
diff --git a/client-py/zzz_main.py b/client-py/zzz_main.py
new file mode 100644
index 0000000..981a983
--- /dev/null
+++ b/client-py/zzz_main.py
@@ -0,0 +1,22 @@
+import struct
+import numpy as np
+
+format_str = '>2f'
+ret = struct.pack(format_str, *[1., 1.])
+print(ret)
+print(type(ret))
+
+ret = np.array([1., 1.], dtype='>f').tobytes()
+print(ret)
+print(type(ret))
+
+
+format_str = '>2q'
+ret = struct.pack(format_str, *[123321, 123123])
+print(ret)
+print(type(ret))
+
+ret = np.array([123321, 123123], dtype='>q').tobytes()
+print(ret)
+print(type(ret))
+
diff --git a/example/session/src/main/java/org/apache/iotdb/TestSession.java
b/example/session/src/main/java/org/apache/iotdb/TestSession.java
new file mode 100644
index 0000000..2351dc5
--- /dev/null
+++ b/example/session/src/main/java/org/apache/iotdb/TestSession.java
@@ -0,0 +1,100 @@
+package org.apache.iotdb;
+
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.List;
+import java.util.Random;
+
+import org.apache.iotdb.session.Session;
+import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
+import org.apache.iotdb.tsfile.write.record.Tablet;
+import org.apache.iotdb.tsfile.write.schema.IMeasurementSchema;
+import org.apache.iotdb.tsfile.write.schema.MeasurementSchema;
+
+public class TestSession {
+
+ public static void main(String[] args) throws Exception {
+ Session session = new Session("127.0.0.1", 6667, "root", "root");
+ session.open();
+// session.setStorageGroup("root.sestest");
+// session.createTimeseries("root.sestest.wf01.wt01.s0",
TSDataType.INT32, TSEncoding.RLE, CompressionType.SNAPPY);
+// session.createTimeseries("root.sestest.wf01.wt01.s1",
TSDataType.INT32, TSEncoding.RLE, CompressionType.SNAPPY);
+// session.createTimeseries("root.sestest.wf01.wt01.s2",
TSDataType.INT32, TSEncoding.RLE, CompressionType.SNAPPY);
+
+ Date d = new Date();
+ Random r = new Random(0);
+ long insertCost = 0;
+ for (int i = 2000; i < 4000; i++) {
+// Calendar c = Calendar.getInstance();
+// c.setTime(d);
+ String deviceId = "root.sg" + i % 8 + "." + i;
+// List<List<String>> measurementsList = new ArrayList<List<String>>();
+// List<List<TSDataType>> typesList = new ArrayList<List<TSDataType>>();
+// List<List<Object>> valuesList = new ArrayList<List<Object>>();
+// List<Long> times = new ArrayList<Long>();
+// List<String> deviceIds = new ArrayList<String>();
+
+ MeasurementSchema mes = new MeasurementSchema("s1", TSDataType.FLOAT);
+ MeasurementSchema mes1 = new MeasurementSchema("is_true",
TSDataType.BOOLEAN);
+
+ List<IMeasurementSchema> schemas = new ArrayList<>();
+ schemas.add(mes);
+// schemas.add(mes1);
+ int rowSize = 10080;
+// int rowSize = 5080;
+ Tablet ta = new Tablet(deviceId, schemas, rowSize);
+ ta.rowSize = rowSize;
+ for (int t = 0; t < ta.rowSize; t++) {
+// Random r=new Random();
+// List<String> measurement = new
ArrayList<>();
+// List<Object> values = new
ArrayList<>(3);
+// List<TSDataType> types = new ArrayList<>(3);
+// times.add(c.getTimeInMillis());
+// values.add(-2+6*r.nextFloat());
+// types.add(TSDataType.FLOAT);
+// values.add(true);
+// types.add(TSDataType.BOOLEAN);
+// measurement.add("s1");
+// measurement.add("is_true");
+// typesList.add(types);
+// valuesList.add(values);
+// deviceIds.add(deviceId);
+// measurementsList.add(measurement);
+// c.add(Calendar.MINUTE,+i);
+
+// List<String> measurement = new
ArrayList<>();
+// List<Object> values = new
ArrayList<>(3);
+// List<TSDataType> types = new ArrayList<>(3);
+//
+// values.add(-2+6*r.nextFloat());
+// types.add(TSDataType.FLOAT);
+// values.add(true);
+// types.add(TSDataType.BOOLEAN);
+// measurement.add("s1");
+// measurement.add("is_true");
+// typesList.add(types);
+// valuesList.add(values);
+// deviceIds.add(deviceId);
+// measurementsList.add(measurement);
+// ta.addTimestamp(t, c.getTimeInMillis());
+ ta.addTimestamp(t, t);
+// ta.addValue("is_true", t, true);
+// ta.addValue("s1", t, -2 + 6 * r.nextFloat());
+ ta.addValue("s1", t, -2 + 6 * 0.5f);
+// c.add(Calendar.MINUTE, +1);
+ }
+ long st = System.nanoTime();
+ session.insertTablet(ta, true);
+ insertCost += (System.nanoTime() - st);
+ //session.insertRecords(deviceIds, times, measurementsList, typesList,
valuesList);
+ }
+ session.close();
+ Date d1 = new Date();
+ System.out.println(d1.getTime() - d.getTime());
+ System.out.println(insertCost / 1000_000);
+
+
+ }
+
+}
