def test_simple_query():
with IoTDBContainer() as db:
db: IoTDBContainer
session = Session(db.get_container_host_ip(), db.get_exposed_port(6667))
session.open(False)
create_ts(session)
# insert data
data_nums = 100
data = {}
timestamps = np.arange(data_nums)
data[ts_path_lst[0]] = np.float32(np.random.rand(data_nums))
data[ts_path_lst[1]] = np.random.rand(data_nums)
data[ts_path_lst[2]] = np.random.randint(10, 100, data_nums, dtype="int32")
data[ts_path_lst[3]] = np.random.randint(10, 100, data_nums, dtype="int64")
data[ts_path_lst[4]] = np.random.choice([True, False], size=data_nums)
data[ts_path_lst[5]] = np.random.choice(["text1", "text2"], size=data_nums)
df_input = pd.DataFrame(data)
tablet = Tablet(
device_id, measurements, data_type_lst, df_input.values, timestamps
)
session.insert_tablet(tablet)
df_input.insert(0, "Time", timestamps)
session_data_set = session.execute_query_statement("SELECT * FROM root.*")
df_output = session_data_set.todf()
df_output = df_output[df_input.columns.tolist()]
session.close()
assert_frame_equal(df_input, df_output)
def create_open_session():
"""
creating session connection.
:return:
"""
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 __init__(
self,
host,
port,
username=Session.DEFAULT_USER,
password=Session.DEFAULT_PASSWORD,
fetch_size=Session.DEFAULT_FETCH_SIZE,
zone_id=Session.DEFAULT_ZONE_ID,
enable_rpc_compression=False,
sqlalchemy_mode=False,
):
self.__session = Session(host, port, username, password, fetch_size,
zone_id)
self.__sqlalchemy_mode = sqlalchemy_mode
self.__is_close = True
try:
self.__session.open(enable_rpc_compression)
self.__is_close = False
except Exception as e:
raise ConnectionError(e)
def test_simple_query():
with IoTDBContainer("apache/iotdb:0.11.2") as db:
db: IoTDBContainer
session = Session(db.get_container_host_ip(), db.get_exposed_port(6667))
session.open(False)
# Write data
session.insert_str_record("root.device", 123, "pressure", "15.0")
# Read
session_data_set = session.execute_query_statement("SELECT * FROM root.*")
df = session_data_set.todf()
session.close()
assert list(df.columns) == ["Time", "root.device.pressure"]
assert_array_equal(df.values, [[123.0, 15.0]])
def test_nullable_tablet_insertion():
with IoTDBContainer("iotdb:dev") as db:
db: IoTDBContainer
session = Session(db.get_container_host_ip(),
db.get_exposed_port(6667))
session.open(False)
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,
]
values_ = [
[None, None, 11, 1.1, 10011.1, "test01"],
[True, None, 11111, 1.25, 101.0, "test02"],
[False, 100, 1, None, 688.25, "test03"],
[True, None, 0, 0, 6.25, None],
]
timestamps_ = [16, 17, 18, 19]
tablet_ = Tablet("root.sg_test_01.d_01", measurements_, data_types_,
values_, timestamps_)
session.insert_tablet(tablet_)
columns = []
for measurement in measurements_:
columns.append("root.sg_test_01.d_01." + measurement)
df_input = pd.DataFrame(values_, None, columns)
df_input.insert(0, "Time", timestamps_)
session_data_set = session.execute_query_statement(
"select s_01, s_02, s_03, s_04, s_05, s_06 from root.sg_test_01.d_01"
)
df_output = session_data_set.todf()
df_output = df_output[df_input.columns.tolist()]
session.close()
assert_frame_equal(df_input, df_output, False)
def test_non_time_query():
with IoTDBContainer("iotdb:dev") as db:
db: IoTDBContainer
session = Session(db.get_container_host_ip(),
db.get_exposed_port(6667))
session.open(False)
# Write data
session.insert_str_record("root.device0", 123, "pressure", "15.0")
# Read
session_data_set = session.execute_query_statement("SHOW TIMESERIES")
df = session_data_set.todf()
session.close()
assert list(df.columns) == [
"timeseries",
"alias",
"storage group",
"dataType",
"encoding",
"compression",
"tags",
"attributes",
]
assert_array_equal(
df.values,
[[
"root.device0.pressure",
None,
"root.device0",
"FLOAT",
"GORILLA",
"SNAPPY",
None,
None,
]],
)
def test_non_time_query():
with IoTDBContainer("apache/iotdb:0.11.2") as db:
db: IoTDBContainer
session = Session(db.get_container_host_ip(),
db.get_exposed_port(6667))
session.open(False)
# Write data
session.insert_str_record("root.device", 123, "pressure", "15.0")
# Read
session_data_set = session.execute_query_statement("SHOW TIMESERIES")
df = session_data_set.todf()
session.close()
assert list(df.columns) == [
'timeseries', 'alias', 'storage group', 'dataType', 'encoding',
'compression', 'tags', 'attributes'
]
assert_array_equal(df.values, [[
'root.device.pressure', None, 'root.device', 'FLOAT', 'GORILLA',
'SNAPPY', None, None
]])
def test_session():
with IoTDBContainer("iotdb:dev") as db:
db: IoTDBContainer
session = Session(db.get_container_host_ip(),
db.get_exposed_port(6667))
session.open(False)
if not session.is_open():
print("can't open session")
exit(1)
# 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")
if session.delete_storage_group("root.sg_test_02") < 0:
test_fail()
print_message("delete storage group failed")
if session.delete_storage_groups(
["root.sg_test_03", "root.sg_test_04"]) < 0:
test_fail()
print_message("delete storage groups failed")
# 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,
)
session.create_time_series(
"root.sg_test_01.d_02.s_01",
TSDataType.BOOLEAN,
TSEncoding.PLAIN,
Compressor.SNAPPY,
None,
{"tag1": "v1"},
{"description": "v1"},
"temperature",
)
# 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_)
ts_path_lst_ = [
"root.sg_test_01.d_02.s_04",
"root.sg_test_01.d_02.s_05",
"root.sg_test_01.d_02.s_06",
"root.sg_test_01.d_02.s_07",
"root.sg_test_01.d_02.s_08",
"root.sg_test_01.d_02.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_))
]
tags_lst_ = [{"tag2": "v2"} for _ in range(len(data_type_lst_))]
attributes_lst_ = [{
"description": "v2"
} for _ in range(len(data_type_lst_))]
session.create_multi_time_series(
ts_path_lst_,
data_type_lst_,
encoding_lst_,
compressor_lst_,
None,
tags_lst_,
attributes_lst_,
None,
)
# delete time series
if (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",
]) < 0):
test_fail()
print_message("delete time series failed")
# checking time series
# s_07 expecting False
if session.check_time_series_exists("root.sg_test_01.d_01.s_07"):
test_fail()
print_message("root.sg_test_01.d_01.s_07 shouldn't exist")
# s_03 expecting True
if not session.check_time_series_exists("root.sg_test_01.d_01.s_03"):
test_fail()
print_message("root.sg_test_01.d_01.s_03 should exist")
# d_02.s_01 expecting True
if not session.check_time_series_exists("root.sg_test_01.d_02.s_01"):
test_fail()
print_message("root.sg_test_01.d_02.s_01 should exist")
# d_02.s_06 expecting True
if not session.check_time_series_exists("root.sg_test_01.d_02.s_06"):
test_fail()
print_message("root.sg_test_01.d_02.s_06 should exist")
# 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,
]
if (session.insert_record("root.sg_test_01.d_01", 1, measurements_,
data_types_, values_) < 0):
test_fail()
print_message("insert record failed")
# insert multiple records into database
measurements_list_ = [
["s_01", "s_02", "s_03", "s_04", "s_05", "s_06"],
["s_01", "s_02", "s_03", "s_04", "s_05", "s_06"],
]
values_list_ = [
[False, 22, 33, 4.4, 55.1, "test_records01"],
[True, 77, 88, 1.25, 8.125, "test_records02"],
]
data_type_list_ = [data_types_, data_types_]
device_ids_ = ["root.sg_test_01.d_01", "root.sg_test_01.d_01"]
if (session.insert_records(device_ids_, [2, 3], measurements_list_,
data_type_list_, values_list_) < 0):
test_fail()
print_message("insert records failed")
# insert one tablet into the database.
values_ = [
[False, 10, 11, 1.1, 10011.1, "test01"],
[True, 100, 11111, 1.25, 101.0, "test02"],
[False, 100, 1, 188.1, 688.25, "test03"],
[True, 0, 0, 0, 6.25, "test04"],
] # Non-ASCII text will cause error since bytes can only hold 0-128 nums.
timestamps_ = [4, 5, 6, 7]
tablet_ = Tablet("root.sg_test_01.d_01", measurements_, data_types_,
values_, timestamps_)
if session.insert_tablet(tablet_) < 0:
test_fail()
print_message("insert tablet failed")
# insert one numpy tablet into the database.
np_values_ = [
np.array([False, True, False, True], np.dtype(">?")),
np.array([10, 100, 100, 0], np.dtype(">i4")),
np.array([11, 11111, 1, 0], np.dtype(">i8")),
np.array([1.1, 1.25, 188.1, 0], np.dtype(">f4")),
np.array([10011.1, 101.0, 688.25, 6.25], np.dtype(">f8")),
np.array(["test01", "test02", "test03", "test04"]),
]
np_timestamps_ = np.array([1, 2, 3, 4], np.dtype(">i8"))
np_tablet_ = NumpyTablet(
"root.sg_test_01.d_02",
measurements_,
data_types_,
np_values_,
np_timestamps_,
)
if session.insert_tablet(np_tablet_) < 0:
test_fail()
print_message("insert numpy tablet failed")
# insert multiple tablets into database
tablet_01 = Tablet("root.sg_test_01.d_01", measurements_, data_types_,
values_, [8, 9, 10, 11])
tablet_02 = Tablet(
"root.sg_test_01.d_01",
measurements_,
data_types_,
values_,
[12, 13, 14, 15],
)
if session.insert_tablets([tablet_01, tablet_02]) < 0:
test_fail()
print_message("insert tablets failed")
# insert one tablet with empty cells into the database.
values_ = [
[None, 10, 11, 1.1, 10011.1, "test01"],
[True, None, 11111, 1.25, 101.0, "test02"],
[False, 100, 1, None, 688.25, "test03"],
[True, 0, 0, 0, None, None],
] # Non-ASCII text will cause error since bytes can only hold 0-128 nums.
timestamps_ = [20, 21, 22, 23]
tablet_ = Tablet("root.sg_test_01.d_01", measurements_, data_types_,
values_, timestamps_)
if session.insert_tablet(tablet_) < 0:
test_fail()
print_message("insert tablet with empty cells failed")
# insert records of one device
time_list = [1, 2, 3]
measurements_list = [
["s_01", "s_02", "s_03"],
["s_01", "s_02", "s_03"],
["s_01", "s_02", "s_03"],
]
data_types_list = [
[TSDataType.BOOLEAN, TSDataType.INT32, TSDataType.INT64],
[TSDataType.BOOLEAN, TSDataType.INT32, TSDataType.INT64],
[TSDataType.BOOLEAN, TSDataType.INT32, TSDataType.INT64],
]
values_list = [[False, 22, 33], [True, 1, 23], [False, 15, 26]]
if (session.insert_records_of_one_device(
"root.sg_test_01.d_01",
time_list,
measurements_list,
data_types_list,
values_list,
) < 0):
test_fail()
print_message("insert records of one device failed")
# execute non-query sql statement
if (session.execute_non_query_statement(
"insert into root.sg_test_01.d_01(timestamp, s_02) values(16, 188)"
) < 0):
test_fail()
print_message(
"execute 'insert into root.sg_test_01.d_01(timestamp, s_02) values(16, 188)' failed"
)
# execute sql query statement
session_data_set = session.execute_query_statement(
"select * from root.sg_test_01.d_01")
session_data_set.set_fetch_size(1024)
expect_count = 20
actual_count = 0
while session_data_set.has_next():
print(session_data_set.next())
actual_count += 1
session_data_set.close_operation_handle()
if actual_count != expect_count:
test_fail()
print_message("query count mismatch: expect count: " +
str(expect_count) + " actual count: " +
str(actual_count))
# close session connection.
session.close()
def _connect(self):
session = Session(self.get_container_host_ip(),
self.get_exposed_port(6667), "root", "root")
session.open(False)
session.close()
# 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 aligned time series.
measurements_lst_ = [
"s_01",
"s_02",
"s_03",
class Connection(object):
def __init__(
self,
host,
port,
username=Session.DEFAULT_USER,
password=Session.DEFAULT_PASSWORD,
fetch_size=Session.DEFAULT_FETCH_SIZE,
zone_id=Session.DEFAULT_ZONE_ID,
enable_rpc_compression=False,
sqlalchemy_mode=False,
):
self.__session = Session(host, port, username, password, fetch_size,
zone_id)
self.__sqlalchemy_mode = sqlalchemy_mode
self.__is_close = True
try:
self.__session.open(enable_rpc_compression)
self.__is_close = False
except Exception as e:
raise ConnectionError(e)
def close(self):
"""
Close the connection now
"""
if self.__is_close:
return
self.__session.close()
self.__is_close = True
def cursor(self):
"""
Return a new Cursor Object using the connection.
"""
if not self.__is_close:
return Cursor(self, self.__session, self.__sqlalchemy_mode)
else:
raise ProgrammingError("Connection closed")
def commit(self):
"""
Not supported method.
"""
pass
def rollback(self):
"""
Not supported method.
"""
pass
@property
def is_close(self):
"""
This read-only attribute specified whether the object is closed
"""
return self.__is_close
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.close()
# 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.Tablet import Tablet
from iotdb.utils.IoTDBConstants import *
# 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)
def test_add_measurements_template():
with IoTDBContainer("iotdb:dev") as db:
db: IoTDBContainer
session = Session(db.get_container_host_ip(),
db.get_exposed_port(6667))
session.open(False)
template_name = "add_template_python"
template = Template(name=template_name, share_time=False)
i_node_v = InternalNode(name="GPS", share_time=False)
i_node_gps_x = MeasurementNode("x", TSDataType.FLOAT, TSEncoding.RLE,
Compressor.SNAPPY)
i_node_v.add_child(i_node_gps_x)
template.add_template(i_node_v)
session.create_schema_template(template)
# # append schema template
data_types = [TSDataType.FLOAT, TSDataType.FLOAT, TSDataType.DOUBLE]
encoding_list = [TSEncoding.RLE, TSEncoding.RLE, TSEncoding.GORILLA]
compressor_list = [
Compressor.SNAPPY, Compressor.SNAPPY, Compressor.LZ4
]
measurements_aligned_path = ["aligned.s1", "aligned.s2", "aligned.s3"]
session.add_measurements_in_template(
template_name,
measurements_aligned_path,
data_types,
encoding_list,
compressor_list,
is_aligned=True,
)
# session.drop_schema_template("add_template_python")
measurements_aligned_path = [
"unaligned.s1", "unaligned.s2", "unaligned.s3"
]
session.add_measurements_in_template(
template_name,
measurements_aligned_path,
data_types,
encoding_list,
compressor_list,
is_aligned=False,
)
measurements_aligned_path = ["s1", "s2", "s3"]
session.add_measurements_in_template(
template_name,
measurements_aligned_path,
data_types,
encoding_list,
compressor_list,
is_aligned=False,
)
assert session.count_measurements_in_template(template_name) == 10
assert session.is_measurement_in_template(template_name,
"GPS") is False
assert session.is_path_exist_in_template(template_name,
"GPS.x") is True
assert session.is_path_exist_in_template(template_name, "x") is False
session.drop_schema_template(template_name)
session.close()
def test_one_device():
with IoTDBContainer("iotdb:dev") as db:
db: IoTDBContainer
session = Session(db.get_container_host_ip(),
db.get_exposed_port(6667))
session.open(False)
if not session.is_open():
print("can't open session")
exit(1)
# insert string records of one device
time_list = [1, 2, 3]
measurements_list = [
["s_01", "s_02", "s_03"],
["s_01", "s_02", "s_03"],
["s_01", "s_02", "s_03"],
]
values_list = [
["False", "22", "33"],
["True", "1", "23"],
["False", "15", "26"],
]
if (session.insert_string_records_of_one_device(
"root.str_test_01.d_01",
time_list,
measurements_list,
values_list,
) < 0):
test_fail()
print_message("insert string records of one device failed")
# insert aligned string record into the database.
time_list = [1, 2, 3]
measurements_list = [
["s_01", "s_02", "s_03"],
["s_01", "s_02", "s_03"],
["s_01", "s_02", "s_03"],
]
values_list = [
["False", "22", "33"],
["True", "1", "23"],
["False", "15", "26"],
]
if (session.insert_aligned_string_records_of_one_device(
"root.str_test_01.d_02",
time_list,
measurements_list,
values_list,
) < 0):
test_fail()
print_message("insert aligned record of one device failed")
# execute raw data query sql statement
session_data_set = session.execute_raw_data_query(
["root.str_test_01.d_02.s_01", "root.str_test_01.d_02.s_02"], 1, 4)
session_data_set.set_fetch_size(1024)
expect_count = 3
actual_count = 0
while session_data_set.has_next():
print(session_data_set.next())
actual_count += 1
session_data_set.close_operation_handle()
if actual_count != expect_count:
test_fail()
print_message("query count mismatch: expect count: " +
str(expect_count) + " actual count: " +
str(actual_count))
assert actual_count == expect_count
# execute last data query sql statement
session_data_set = session.execute_last_data_query(
["root.str_test_01.d_02.s_01", "root.str_test_01.d_02.s_02"], 0)
session_data_set.set_fetch_size(1024)
expect_time = 3
actual_time = session_data_set.next().get_timestamp()
session_data_set.close_operation_handle()
if actual_time != expect_time:
test_fail()
print_message("query count mismatch: expect count: " +
str(expect_time) + " actual count: " +
str(actual_time))
assert actual_time == expect_time
# close session connection.
session.close()
#
# Uncomment the following line to use apache-iotdb module installed by pip3
import numpy as np
from iotdb.Session import Session
from iotdb.utils.IoTDBConstants import TSDataType, TSEncoding, Compressor
from iotdb.utils.Tablet import Tablet
from iotdb.utils.NumpyTablet import NumpyTablet
# 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(
def test_with_null_query():
with IoTDBContainer("iotdb:dev") as db:
db: IoTDBContainer
session = Session(db.get_container_host_ip(),
db.get_exposed_port(6667))
session.open(False)
create_ts(session)
# insert data
data_nums = 100
data = {}
timestamps = np.arange(data_nums)
data[ts_path_lst[0]] = np.float32(np.random.rand(data_nums))
data[ts_path_lst[1]] = np.random.rand(data_nums)
data[ts_path_lst[2]] = np.random.randint(10,
100,
data_nums,
dtype="int32")
data[ts_path_lst[3]] = np.random.randint(10,
100,
data_nums,
dtype="int64")
data[ts_path_lst[4]] = np.random.choice([True, False],
size=data_nums).astype("bool")
data[ts_path_lst[5]] = np.random.choice(["text1", "text2"],
size=data_nums).astype(object)
data_empty = {}
for ts_path in ts_path_lst:
if data[ts_path].dtype == np.int32 or data[
ts_path].dtype == np.int64:
tmp_array = np.full(data_nums, np.nan, np.float32)
if data[ts_path].dtype == np.int32:
tmp_array = pd.Series(tmp_array).astype("Int32")
else:
tmp_array = pd.Series(tmp_array).astype("Int64")
elif data[ts_path].dtype == np.float32 or data[
ts_path].dtype == np.double:
tmp_array = np.full(data_nums, np.nan, data[ts_path].dtype)
elif data[ts_path].dtype == bool:
tmp_array = np.full(data_nums, np.nan, np.float32)
tmp_array = pd.Series(tmp_array).astype("boolean")
else:
tmp_array = np.full(data_nums, None, dtype=data[ts_path].dtype)
data_empty[ts_path] = tmp_array
df_input = pd.DataFrame(data_empty)
for row_index in range(data_nums):
is_row_inserted = False
for column_index in range(len(measurements)):
if random.choice([True, False]):
session.insert_record(
device_id,
row_index,
[measurements[column_index]],
[data_type_lst[column_index]],
[data[ts_path_lst[column_index]].tolist()[row_index]],
)
df_input.at[row_index, ts_path_lst[column_index]] = data[
ts_path_lst[column_index]][row_index]
is_row_inserted = True
if not is_row_inserted:
column_index = 0
session.insert_record(
device_id,
row_index,
[measurements[column_index]],
[data_type_lst[column_index]],
[data[ts_path_lst[column_index]].tolist()[row_index]],
)
df_input.at[row_index, ts_path_lst[column_index]] = data[
ts_path_lst[column_index]][row_index]
df_input.insert(0, "Time", timestamps)
session_data_set = session.execute_query_statement(
"SELECT ** FROM root")
df_output = session_data_set.todf()
df_output = df_output[df_input.columns.tolist()]
session.close()
assert_frame_equal(df_input, df_output)
def test_set_template():
with IoTDBContainer("iotdb:dev") as db:
db: IoTDBContainer
session = Session(db.get_container_host_ip(),
db.get_exposed_port(6667))
session.open(False)
template_name = "set_template_python"
template = Template(name=template_name, share_time=False)
session.create_schema_template(template)
session.set_schema_template(template_name, "root.python.GPS")
assert session.show_paths_template_set_on(template_name) == [
"root.python.GPS"
]
assert session.show_paths_template_using_on(template_name) == []
session.unset_schema_template(template_name, "root.python.GPS")
session.drop_schema_template(template_name)
session.close()
def test_template_create():
with IoTDBContainer("iotdb:dev") as db:
db: IoTDBContainer
session = Session(db.get_container_host_ip(),
db.get_exposed_port(6667))
session.open(False)
measurement_template_name = "template_python"
template = Template(name=measurement_template_name, share_time=False)
m_node_1 = MeasurementNode(
name="s1",
data_type=TSDataType.INT64,
encoding=TSEncoding.RLE,
compression_type=Compressor.SNAPPY,
)
m_node_2 = MeasurementNode(
name="s2",
data_type=TSDataType.INT64,
encoding=TSEncoding.RLE,
compression_type=Compressor.SNAPPY,
)
m_node_3 = MeasurementNode(
name="s3",
data_type=TSDataType.INT64,
encoding=TSEncoding.RLE,
compression_type=Compressor.SNAPPY,
)
template.add_template(m_node_1)
template.add_template(m_node_2)
template.add_template(m_node_3)
session.create_schema_template(template)
assert session.show_measurements_in_template(
measurement_template_name) == [
"s3",
"s1",
"s2",
]
assert session.count_measurements_in_template(
measurement_template_name) == 3
assert (session.is_measurement_in_template(measurement_template_name,
"s1") is True)
assert (session.is_path_exist_in_template(measurement_template_name,
"s1") is True)
assert (session.is_path_exist_in_template(measurement_template_name,
"s4") is False)
session.delete_node_in_template(measurement_template_name, "s1")
assert session.show_measurements_in_template(
measurement_template_name) == [
"s3",
"s2",
]
assert session.count_measurements_in_template(
measurement_template_name) == 2
assert (session.is_path_exist_in_template(measurement_template_name,
"s1") is False)
tree_template_name = "treeTemplate_python"
template = Template(name=tree_template_name, share_time=True)
i_node_gps = InternalNode(name="GPS", share_time=False)
i_node_v = InternalNode(name="vehicle", share_time=True)
m_node_x = MeasurementNode("x", TSDataType.FLOAT, TSEncoding.RLE,
Compressor.SNAPPY)
i_node_gps.add_child(m_node_x)
i_node_v.add_child(m_node_x)
template.add_template(i_node_gps)
template.add_template(i_node_v)
template.add_template(m_node_x)
session.create_schema_template(template)
assert session.show_measurements_in_template(tree_template_name) == [
"x",
"GPS.x",
"vehicle.x",
]
assert session.count_measurements_in_template(tree_template_name) == 3
assert session.show_all_templates() == [
measurement_template_name,
tree_template_name,
]
assert session.is_measurement_in_template(tree_template_name,
"GPS") is False
assert session.is_measurement_in_template(tree_template_name,
"GPS.x") is True
session.drop_schema_template(measurement_template_name)
session.drop_schema_template(tree_template_name)
session.close()
global final_flag
print("*********")
print(message)
print("*********")
final_flag = False
failed_count += 1
# 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)
if not session.is_open():
print("can't open session")
exit(1)
# 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")
if session.delete_storage_group("root.sg_test_02") < 0:
