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 test_connection(): with IoTDBContainer("iotdb:dev") as db: db: IoTDBContainer conn = connect(db.get_container_host_ip(), db.get_exposed_port(6667)) if conn.is_close: print("can't create connect") exit(1) conn.close() if not conn.is_close: test_fail() print_message("failed to close the connection!")
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_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_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_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_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 test_cursor(): with IoTDBContainer("iotdb:dev") as db: db: IoTDBContainer conn = connect(db.get_container_host_ip(), db.get_exposed_port(6667)) cursor: Cursor = conn.cursor() # execute test cursor.execute("create storage group root.cursor") cursor.execute("create storage group root.cursor_s1") cursor.execute("delete storage group root.cursor_s1") if cursor.rowcount < 0: test_fail() print_message("execute test failed!") # execute with args test cursor.execute( "create timeseries root.cursor.temperature with datatype=FLOAT,encoding=RLE" ) cursor.execute( "insert into root.cursor(timestamp,temperature) values(1,%(temperature)s)", {"temperature": 0.3}, ) cursor.execute( "insert into root.cursor(timestamp,temperature) values(2,%(temperature)s)", {"temperature": 0.4}, ) cursor.execute("select * from root.cursor") count = 2 actual_count = 0 for row in cursor.fetchall(): actual_count += 1 if count != actual_count: test_fail() print_message("execute with args test failed!") # executemany with args test args = [ { "timestamp": 3, "temperature": 3 }, { "timestamp": 4, "temperature": 4 }, { "timestamp": 5, "temperature": 5 }, { "timestamp": 6, "temperature": 6 }, { "timestamp": 7, "temperature": 7 }, ] cursor.executemany( "insert into root.cursor(timestamp,temperature) values(%(timestamp)s,%(temperature)s)", args, ) cursor.execute("select * from root.cursor") count = 7 actual_count = 0 for row in cursor.fetchall(): actual_count += 1 if count != actual_count: test_fail() print_message("executemany with args test failed!") # fetchmany test cursor.execute("select * from root.cursor") count = 2 actual_count = 0 for row in cursor.fetchmany(count): actual_count += 1 if count != actual_count: test_fail() print_message("fetchmany test failed!") # fetchone test cursor.execute("select * from root.cursor") row = cursor.fetchone() if row[0] != 1: test_fail() print_message("fetchone test failed") cursor.execute("delete storage group root.cursor") cursor.close() conn.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()
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()