jt2594838 commented on a change in pull request #1556: URL: https://github.com/apache/incubator-iotdb/pull/1556#discussion_r459914623
########## File path: client-py/src/SessionUT.py ########## @@ -0,0 +1,482 @@ +# 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 unittest +import sys +import struct + +from Session import Session +from Tablet import Tablet +from IoTDBConstants import * +from SessionDataSet import SessionDataSet + +from thrift.protocol import TBinaryProtocol, TCompactProtocol +from thrift.transport import TSocket, TTransport + + +class MyTestCase(unittest.TestCase): + + def setUp(self) -> None: + self.session = Session("127.0.0.1", 6667, "root", "root") + self.session.open(False) + + def tearDown(self) -> None: + # clean up storage groups and time series. + self.session.delete_storage_group("root.sg1") + self.session.close() + + def test_insert_by_str(self): + self.session.set_storage_group("root.sg1") + + self.createTimeSeries(self.session) + self.insertByStr(self.session) + + # sql test + self.insert_via_sql(self.session) + self.query3() + + def test_insert_by_blank_str_infer_type(self): + device_id = "root.sg1.d1" + measurements = ["s1 "] + values = ["1.0"] + self.session.insert_str_record(device_id, 1, measurements, values) + + expected = ["root.sg1.d1.s1 "] + + self.assertFalse(self.session.check_time_series_exists("root.sg1.d1.s1 ")) + data_set = self.session.execute_query_statement("show timeseries") + i = 0 + while data_set.has_next(): + self.assertEquals(expected[i], str(data_set.next().get_fields()[0])) + i += 1 + + def test_insert_by_str_infer_type(self): + device_id = "root.sg1.d1" + measurements = ["s1", "s2", "s3", "s4"] + values = ["1", "1.2", "true", "dad"] + self.session.insert_str_record(device_id, 1, measurements, values) + + expected = [TSDataType.FLOAT.name, TSDataType.FLOAT.name, TSDataType.BOOLEAN.name, TSDataType.TEXT.name] + data_set = self.session.execute_query_statement("show timeseries root") + i = 0 + while data_set.has_next(): + self.assertEquals(expected[i], str(data_set.next().get_fields()[3])) + i += 1 + + def test_insert_by_obj_not_infer_type(self): + device_id = "root.sg1.d1" + measurements = ["s1", "s2", "s3", "s4"] + data_types = [TSDataType.INT64, TSDataType.DOUBLE, TSDataType.TEXT, TSDataType.TEXT] + values = [1, 1.2, "true", "dad"] + self.session.insert_record(device_id, 1, measurements, data_types, values) + + expected = [TSDataType.INT64.name, TSDataType.DOUBLE.name, TSDataType.TEXT.name, TSDataType.TEXT.name] + + data_set = self.session.execute_query_statement("show timeseries root") + i = 0 + while data_set.has_next(): + self.assertEquals(expected[i], str(data_set.next().get_fields()[3])) + i += 1 + + def test_insert_by_obj(self): + self.session.set_storage_group("root.sg1") + self.createTimeSeries(self.session) + self.insertInObj(self.session) + + # SQL tests + self.insert_via_sql(self.session) + self.query3() + + def test_align_by_device(self): + self.session.set_storage_group("root.sg1") + self.createTimeSeries(self.session) + self.insertTabletTest2(self.session, "root.sg1.d1") + + self.queryForAlignByDevice() + self.queryForAlignByDevice2() + + def test_time(self): + """ it will output too much trivia, so ignore it. """ + pass + + def test_batch_insert_seq_and_unseq(self): + self.session.set_storage_group("root.sg1") + self.session.execute_non_query_statement("FLUSH") + self.session.execute_non_query_statement("FLUSH root.sg1") + self.session.execute_non_query_statement("MERGE") + self.session.execute_non_query_statement("FULL MERGE") Review comment: How about doing some insertion before executing the commands? ########## File path: client-py/src/SessionUT.py ########## @@ -0,0 +1,482 @@ +# 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 unittest +import sys +import struct + +from Session import Session +from Tablet import Tablet +from IoTDBConstants import * +from SessionDataSet import SessionDataSet + +from thrift.protocol import TBinaryProtocol, TCompactProtocol +from thrift.transport import TSocket, TTransport + + +class MyTestCase(unittest.TestCase): + + def setUp(self) -> None: + self.session = Session("127.0.0.1", 6667, "root", "root") + self.session.open(False) + + def tearDown(self) -> None: + # clean up storage groups and time series. + self.session.delete_storage_group("root.sg1") + self.session.close() + + def test_insert_by_str(self): + self.session.set_storage_group("root.sg1") + + self.createTimeSeries(self.session) + self.insertByStr(self.session) + + # sql test + self.insert_via_sql(self.session) + self.query3() + + def test_insert_by_blank_str_infer_type(self): + device_id = "root.sg1.d1" + measurements = ["s1 "] + values = ["1.0"] + self.session.insert_str_record(device_id, 1, measurements, values) + + expected = ["root.sg1.d1.s1 "] + + self.assertFalse(self.session.check_time_series_exists("root.sg1.d1.s1 ")) + data_set = self.session.execute_query_statement("show timeseries") + i = 0 + while data_set.has_next(): + self.assertEquals(expected[i], str(data_set.next().get_fields()[0])) + i += 1 + + def test_insert_by_str_infer_type(self): + device_id = "root.sg1.d1" + measurements = ["s1", "s2", "s3", "s4"] + values = ["1", "1.2", "true", "dad"] + self.session.insert_str_record(device_id, 1, measurements, values) + + expected = [TSDataType.FLOAT.name, TSDataType.FLOAT.name, TSDataType.BOOLEAN.name, TSDataType.TEXT.name] + data_set = self.session.execute_query_statement("show timeseries root") + i = 0 + while data_set.has_next(): + self.assertEquals(expected[i], str(data_set.next().get_fields()[3])) + i += 1 + + def test_insert_by_obj_not_infer_type(self): + device_id = "root.sg1.d1" + measurements = ["s1", "s2", "s3", "s4"] + data_types = [TSDataType.INT64, TSDataType.DOUBLE, TSDataType.TEXT, TSDataType.TEXT] + values = [1, 1.2, "true", "dad"] + self.session.insert_record(device_id, 1, measurements, data_types, values) + + expected = [TSDataType.INT64.name, TSDataType.DOUBLE.name, TSDataType.TEXT.name, TSDataType.TEXT.name] + + data_set = self.session.execute_query_statement("show timeseries root") + i = 0 + while data_set.has_next(): + self.assertEquals(expected[i], str(data_set.next().get_fields()[3])) + i += 1 + + def test_insert_by_obj(self): + self.session.set_storage_group("root.sg1") + self.createTimeSeries(self.session) + self.insertInObj(self.session) + + # SQL tests + self.insert_via_sql(self.session) + self.query3() + + def test_align_by_device(self): + self.session.set_storage_group("root.sg1") + self.createTimeSeries(self.session) + self.insertTabletTest2(self.session, "root.sg1.d1") + + self.queryForAlignByDevice() + self.queryForAlignByDevice2() + + def test_time(self): + """ it will output too much trivia, so ignore it. """ + pass + + def test_batch_insert_seq_and_unseq(self): + self.session.set_storage_group("root.sg1") + self.session.execute_non_query_statement("FLUSH") + self.session.execute_non_query_statement("FLUSH root.sg1") + self.session.execute_non_query_statement("MERGE") + self.session.execute_non_query_statement("FULL MERGE") + + self.insertTabletTest3(self.session, "root.sg1.d1") + # not yet done! JDBC connection required. + self.queryForBatchSeqAndUnseq() + + def test_batch_insert(self): + self.session.set_storage_group("root.sg1") + self.createTimeSeries(self.session) + self.insertTabletTest2(self.session, "root.sg1.d1") + # not yet done! JDBC connection required. + self.queryForBatch() + + def test_create_multi_time_series(self): + paths = ["root.sg1.d1.s1", "root.sg1.d1.s2"] + types = [TSDataType.DOUBLE, TSDataType.DOUBLE] + encodings = [TSEncoding.RLE, TSEncoding.RLE] + compressor = [Compressor.SNAPPY, Compressor.SNAPPY] + self.session.create_multi_time_series(paths, types, encodings, compressor) + + self.assertTrue(self.session.check_time_series_exists("root.sg1.d1.s1")) + self.assertTrue(self.session.check_time_series_exists("root.sg1.d1.s2")) + + def test_test_method(self): + self.session.set_storage_group("root.sg1") + self.createTimeSeries(self.session) + device_id = "root.sg1.d1" + + # test insert tablet + measurements = ["s1", "s2", "s3"] + timestamps = [1] + values = [[1, 2, 3]] + types = [TSDataType.INT64, TSDataType.INT64, TSDataType.INT64] + tablet = Tablet(device_id, measurements, types, values, timestamps) + self.session.test_insert_tablet(tablet) + + # test insert record + measurements = ["s1", "s2", "s3"] + data_types = [TSDataType.INT64, TSDataType.INT64, TSDataType.INT64] + values = [1, 2, 3] + for time in range(100): + self.session.test_insert_record(device_id, time, measurements, data_types, values) + + # test insert records + measurements = ["s1", "s2", "s3"] + device_ids = [device_id for _ in range(100)] + data_types = [[TSDataType.INT64, TSDataType.INT64, TSDataType.INT64] for _ in range(100)] + values = [[1, 2, 3] for _ in range(100)] + timestamps = [i for i in range(100)] + self.session.test_insert_records(device_ids, timestamps, measurements, data_types, values) + + def test_Chinese_character(self): + storage_group = "root.存储组1" + devices = ["设备1.指标1", "设备1.s2", "d2.s1", "d2.指标2"] + self.session.set_storage_group(storage_group) + self.createTimeSeriesInChinese(self.session, storage_group, devices) + self.insertInChinese(self.session, storage_group, devices) + self.session.delete_storage_group(storage_group) + + def test(self): + self.session.set_storage_group("root.sg1") + self.createTimeSeries(self.session) + self.insert(self.session) + # SQL tests + self.insert_via_sql(self.session) + self.query3() + # self.insertTabletTest1(self.session, "root.sg1.d1") + self.deleteData(self.session) + self.query() + self.deleteTimeseries(self.session) + self.query2() + self.insertRecords(self.session) + self.query4() + + # special characters + self.session.create_time_series("root.sg1.d1.1_2", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + self.session.create_time_series("root.sg1.d1.\"1.2.3\"", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + self.session.create_time_series("root.sg1.d1.\'1.2.4\'", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + + self.session.set_storage_group("root.1") + self.session.create_time_series("root.1.2.3", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + + # Add another storage group to test the deletion of storage group + self.session.set_storage_group("root.sg2") + self.session.create_time_series("root.sg2.d1.s1", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + self.deleteStorageGroupTest(self.session) + + # set storage group without creating time series + self.session.set_storage_group("root.sg3") + self.insertTabletTest1(self.session, "root.sg3.d1") + + # create timeseries without setting storage groups + self.session.create_time_series("root.sg4.d1.s1", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + self.session.create_time_series("root.sg4.d1.s2", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + self.session.create_time_series("root.sg4.d1.s3", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + self.insertTabletTest1(self.session, "root.sg4.d1") + + # directly insertion, without any setting of storage groups and time series. + self.insertTabletTest1(self.session, "root.sg5.d1") + + # clear + self.session.delete_storage_groups(["root.sg3", "root.sg4", "root.sg5", "root.1"]) + + def test_by_str(self): + self.session.set_storage_group("root.sg1") + self.createTimeSeries(self.session) + self.insertByStr(self.session) + # SQL tests + self.insert_via_sql(self.session) + self.query3() + # self.insertTabletTest1(self.session, "root.sg1.d1") + self.deleteData(self.session) + self.query() + self.deleteTimeseries(self.session) + self.query2() + self.insertRecordsByStr(self.session) + self.query4() + + # special characters + self.session.create_time_series("root.sg1.d1.1_2", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + self.session.create_time_series("root.sg1.d1.\"1.2.3\"", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + self.session.create_time_series("root.sg1.d1.\'1.2.4\'", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + + self.session.set_storage_group("root.1") + self.session.create_time_series("root.1.2.3", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + + # Add another storage group to test the deletion of storage group + self.session.set_storage_group("root.sg2") + self.session.create_time_series("root.sg2.d1.s1", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + self.deleteStorageGroupTest(self.session) + + # set storage group without creating time series + self.session.set_storage_group("root.sg3") + self.insertTabletTest1(self.session, "root.sg3.d1") + + # create timeseries without setting storage groups + self.session.create_time_series("root.sg4.d1.s1", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + self.session.create_time_series("root.sg4.d1.s2", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + self.session.create_time_series("root.sg4.d1.s3", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + self.insertTabletTest1(self.session, "root.sg4.d1") + + # directly insertion, without any setting of storage groups and time series. + self.insertTabletTest1(self.session, "root.sg5.d1") + + # clear + self.session.delete_storage_groups(["root.sg3", "root.sg4", "root.sg5", "root.1"]) + + def test_session_interfaces_with_disabled_WAL(self): + pass + + def query(self): + """ JDBC connection required. """ + pass + + def query2(self): + """ JDBC connection required. """ + pass + + def query3(self): + session_data_set = self.session.execute_query_statement("select * from root.sg1.d1") + session_data_set.set_fetch_size(1024) + count = 0 + while session_data_set.has_next(): + index = 1 + count += 1 + for f in session_data_set.next().get_fields(): + self.assertEqual(str(index), f.get_string_value()) + index += 1 + + self.assertEqual(101, count) + session_data_set.close_operation_handle() Review comment: It would be better to put the close operation into a finally block, otherwise, one failed test may influence others. ########## File path: client-py/src/SessionUT.py ########## @@ -0,0 +1,482 @@ +# 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 unittest +import sys +import struct + +from Session import Session +from Tablet import Tablet +from IoTDBConstants import * +from SessionDataSet import SessionDataSet + +from thrift.protocol import TBinaryProtocol, TCompactProtocol +from thrift.transport import TSocket, TTransport + + +class MyTestCase(unittest.TestCase): + + def setUp(self) -> None: + self.session = Session("127.0.0.1", 6667, "root", "root") + self.session.open(False) + + def tearDown(self) -> None: + # clean up storage groups and time series. + self.session.delete_storage_group("root.sg1") + self.session.close() + + def test_insert_by_str(self): + self.session.set_storage_group("root.sg1") + + self.createTimeSeries(self.session) + self.insertByStr(self.session) + + # sql test + self.insert_via_sql(self.session) + self.query3() + + def test_insert_by_blank_str_infer_type(self): + device_id = "root.sg1.d1" + measurements = ["s1 "] + values = ["1.0"] + self.session.insert_str_record(device_id, 1, measurements, values) + + expected = ["root.sg1.d1.s1 "] + + self.assertFalse(self.session.check_time_series_exists("root.sg1.d1.s1 ")) + data_set = self.session.execute_query_statement("show timeseries") + i = 0 + while data_set.has_next(): + self.assertEquals(expected[i], str(data_set.next().get_fields()[0])) + i += 1 Review comment: How about adding an assertion of `i` after `while`. ########## File path: client-py/src/SessionUT.py ########## @@ -0,0 +1,482 @@ +# 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 unittest +import sys +import struct + +from Session import Session +from Tablet import Tablet +from IoTDBConstants import * +from SessionDataSet import SessionDataSet + +from thrift.protocol import TBinaryProtocol, TCompactProtocol +from thrift.transport import TSocket, TTransport + + +class MyTestCase(unittest.TestCase): Review comment: I wonder how to run the tests? ########## File path: client-py/src/SessionUT.py ########## @@ -0,0 +1,482 @@ +# 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 unittest +import sys +import struct + +from Session import Session +from Tablet import Tablet +from IoTDBConstants import * +from SessionDataSet import SessionDataSet + +from thrift.protocol import TBinaryProtocol, TCompactProtocol +from thrift.transport import TSocket, TTransport + + +class MyTestCase(unittest.TestCase): + + def setUp(self) -> None: + self.session = Session("127.0.0.1", 6667, "root", "root") + self.session.open(False) + + def tearDown(self) -> None: + # clean up storage groups and time series. + self.session.delete_storage_group("root.sg1") + self.session.close() + + def test_insert_by_str(self): + self.session.set_storage_group("root.sg1") + + self.createTimeSeries(self.session) + self.insertByStr(self.session) + + # sql test + self.insert_via_sql(self.session) + self.query3() + + def test_insert_by_blank_str_infer_type(self): + device_id = "root.sg1.d1" + measurements = ["s1 "] + values = ["1.0"] + self.session.insert_str_record(device_id, 1, measurements, values) + + expected = ["root.sg1.d1.s1 "] + + self.assertFalse(self.session.check_time_series_exists("root.sg1.d1.s1 ")) + data_set = self.session.execute_query_statement("show timeseries") + i = 0 + while data_set.has_next(): + self.assertEquals(expected[i], str(data_set.next().get_fields()[0])) + i += 1 + + def test_insert_by_str_infer_type(self): + device_id = "root.sg1.d1" + measurements = ["s1", "s2", "s3", "s4"] + values = ["1", "1.2", "true", "dad"] + self.session.insert_str_record(device_id, 1, measurements, values) + + expected = [TSDataType.FLOAT.name, TSDataType.FLOAT.name, TSDataType.BOOLEAN.name, TSDataType.TEXT.name] + data_set = self.session.execute_query_statement("show timeseries root") + i = 0 + while data_set.has_next(): + self.assertEquals(expected[i], str(data_set.next().get_fields()[3])) + i += 1 + + def test_insert_by_obj_not_infer_type(self): + device_id = "root.sg1.d1" + measurements = ["s1", "s2", "s3", "s4"] + data_types = [TSDataType.INT64, TSDataType.DOUBLE, TSDataType.TEXT, TSDataType.TEXT] + values = [1, 1.2, "true", "dad"] + self.session.insert_record(device_id, 1, measurements, data_types, values) + + expected = [TSDataType.INT64.name, TSDataType.DOUBLE.name, TSDataType.TEXT.name, TSDataType.TEXT.name] + + data_set = self.session.execute_query_statement("show timeseries root") + i = 0 + while data_set.has_next(): + self.assertEquals(expected[i], str(data_set.next().get_fields()[3])) + i += 1 + + def test_insert_by_obj(self): + self.session.set_storage_group("root.sg1") + self.createTimeSeries(self.session) + self.insertInObj(self.session) + + # SQL tests + self.insert_via_sql(self.session) + self.query3() + + def test_align_by_device(self): + self.session.set_storage_group("root.sg1") + self.createTimeSeries(self.session) + self.insertTabletTest2(self.session, "root.sg1.d1") + + self.queryForAlignByDevice() + self.queryForAlignByDevice2() + + def test_time(self): + """ it will output too much trivia, so ignore it. """ + pass + + def test_batch_insert_seq_and_unseq(self): + self.session.set_storage_group("root.sg1") + self.session.execute_non_query_statement("FLUSH") + self.session.execute_non_query_statement("FLUSH root.sg1") + self.session.execute_non_query_statement("MERGE") + self.session.execute_non_query_statement("FULL MERGE") + + self.insertTabletTest3(self.session, "root.sg1.d1") + # not yet done! JDBC connection required. + self.queryForBatchSeqAndUnseq() + + def test_batch_insert(self): + self.session.set_storage_group("root.sg1") + self.createTimeSeries(self.session) + self.insertTabletTest2(self.session, "root.sg1.d1") + # not yet done! JDBC connection required. + self.queryForBatch() + + def test_create_multi_time_series(self): + paths = ["root.sg1.d1.s1", "root.sg1.d1.s2"] + types = [TSDataType.DOUBLE, TSDataType.DOUBLE] + encodings = [TSEncoding.RLE, TSEncoding.RLE] + compressor = [Compressor.SNAPPY, Compressor.SNAPPY] + self.session.create_multi_time_series(paths, types, encodings, compressor) + + self.assertTrue(self.session.check_time_series_exists("root.sg1.d1.s1")) + self.assertTrue(self.session.check_time_series_exists("root.sg1.d1.s2")) + + def test_test_method(self): + self.session.set_storage_group("root.sg1") + self.createTimeSeries(self.session) + device_id = "root.sg1.d1" + + # test insert tablet + measurements = ["s1", "s2", "s3"] + timestamps = [1] + values = [[1, 2, 3]] + types = [TSDataType.INT64, TSDataType.INT64, TSDataType.INT64] + tablet = Tablet(device_id, measurements, types, values, timestamps) + self.session.test_insert_tablet(tablet) + + # test insert record + measurements = ["s1", "s2", "s3"] + data_types = [TSDataType.INT64, TSDataType.INT64, TSDataType.INT64] + values = [1, 2, 3] + for time in range(100): + self.session.test_insert_record(device_id, time, measurements, data_types, values) + + # test insert records + measurements = ["s1", "s2", "s3"] + device_ids = [device_id for _ in range(100)] + data_types = [[TSDataType.INT64, TSDataType.INT64, TSDataType.INT64] for _ in range(100)] + values = [[1, 2, 3] for _ in range(100)] + timestamps = [i for i in range(100)] + self.session.test_insert_records(device_ids, timestamps, measurements, data_types, values) + + def test_Chinese_character(self): + storage_group = "root.存储组1" + devices = ["设备1.指标1", "设备1.s2", "d2.s1", "d2.指标2"] + self.session.set_storage_group(storage_group) + self.createTimeSeriesInChinese(self.session, storage_group, devices) + self.insertInChinese(self.session, storage_group, devices) + self.session.delete_storage_group(storage_group) + + def test(self): + self.session.set_storage_group("root.sg1") + self.createTimeSeries(self.session) + self.insert(self.session) + # SQL tests + self.insert_via_sql(self.session) + self.query3() + # self.insertTabletTest1(self.session, "root.sg1.d1") Review comment: Why is this commented? ########## File path: client-py/src/SessionUT.py ########## @@ -0,0 +1,482 @@ +# 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 unittest +import sys +import struct + +from Session import Session +from Tablet import Tablet +from IoTDBConstants import * +from SessionDataSet import SessionDataSet + +from thrift.protocol import TBinaryProtocol, TCompactProtocol +from thrift.transport import TSocket, TTransport + + +class MyTestCase(unittest.TestCase): + + def setUp(self) -> None: + self.session = Session("127.0.0.1", 6667, "root", "root") + self.session.open(False) + + def tearDown(self) -> None: + # clean up storage groups and time series. + self.session.delete_storage_group("root.sg1") + self.session.close() + + def test_insert_by_str(self): + self.session.set_storage_group("root.sg1") + + self.createTimeSeries(self.session) + self.insertByStr(self.session) + + # sql test + self.insert_via_sql(self.session) + self.query3() + + def test_insert_by_blank_str_infer_type(self): + device_id = "root.sg1.d1" + measurements = ["s1 "] + values = ["1.0"] + self.session.insert_str_record(device_id, 1, measurements, values) + + expected = ["root.sg1.d1.s1 "] + + self.assertFalse(self.session.check_time_series_exists("root.sg1.d1.s1 ")) + data_set = self.session.execute_query_statement("show timeseries") + i = 0 + while data_set.has_next(): + self.assertEquals(expected[i], str(data_set.next().get_fields()[0])) + i += 1 + + def test_insert_by_str_infer_type(self): + device_id = "root.sg1.d1" + measurements = ["s1", "s2", "s3", "s4"] + values = ["1", "1.2", "true", "dad"] + self.session.insert_str_record(device_id, 1, measurements, values) + + expected = [TSDataType.FLOAT.name, TSDataType.FLOAT.name, TSDataType.BOOLEAN.name, TSDataType.TEXT.name] + data_set = self.session.execute_query_statement("show timeseries root") + i = 0 + while data_set.has_next(): + self.assertEquals(expected[i], str(data_set.next().get_fields()[3])) + i += 1 + + def test_insert_by_obj_not_infer_type(self): + device_id = "root.sg1.d1" + measurements = ["s1", "s2", "s3", "s4"] + data_types = [TSDataType.INT64, TSDataType.DOUBLE, TSDataType.TEXT, TSDataType.TEXT] + values = [1, 1.2, "true", "dad"] + self.session.insert_record(device_id, 1, measurements, data_types, values) + + expected = [TSDataType.INT64.name, TSDataType.DOUBLE.name, TSDataType.TEXT.name, TSDataType.TEXT.name] + + data_set = self.session.execute_query_statement("show timeseries root") + i = 0 + while data_set.has_next(): + self.assertEquals(expected[i], str(data_set.next().get_fields()[3])) + i += 1 + + def test_insert_by_obj(self): + self.session.set_storage_group("root.sg1") + self.createTimeSeries(self.session) + self.insertInObj(self.session) + + # SQL tests + self.insert_via_sql(self.session) + self.query3() + + def test_align_by_device(self): + self.session.set_storage_group("root.sg1") + self.createTimeSeries(self.session) + self.insertTabletTest2(self.session, "root.sg1.d1") + + self.queryForAlignByDevice() + self.queryForAlignByDevice2() + + def test_time(self): + """ it will output too much trivia, so ignore it. """ + pass + + def test_batch_insert_seq_and_unseq(self): + self.session.set_storage_group("root.sg1") + self.session.execute_non_query_statement("FLUSH") + self.session.execute_non_query_statement("FLUSH root.sg1") + self.session.execute_non_query_statement("MERGE") + self.session.execute_non_query_statement("FULL MERGE") + + self.insertTabletTest3(self.session, "root.sg1.d1") + # not yet done! JDBC connection required. + self.queryForBatchSeqAndUnseq() + + def test_batch_insert(self): + self.session.set_storage_group("root.sg1") + self.createTimeSeries(self.session) + self.insertTabletTest2(self.session, "root.sg1.d1") + # not yet done! JDBC connection required. + self.queryForBatch() + + def test_create_multi_time_series(self): + paths = ["root.sg1.d1.s1", "root.sg1.d1.s2"] + types = [TSDataType.DOUBLE, TSDataType.DOUBLE] + encodings = [TSEncoding.RLE, TSEncoding.RLE] + compressor = [Compressor.SNAPPY, Compressor.SNAPPY] + self.session.create_multi_time_series(paths, types, encodings, compressor) + + self.assertTrue(self.session.check_time_series_exists("root.sg1.d1.s1")) + self.assertTrue(self.session.check_time_series_exists("root.sg1.d1.s2")) + + def test_test_method(self): + self.session.set_storage_group("root.sg1") + self.createTimeSeries(self.session) + device_id = "root.sg1.d1" + + # test insert tablet + measurements = ["s1", "s2", "s3"] + timestamps = [1] + values = [[1, 2, 3]] + types = [TSDataType.INT64, TSDataType.INT64, TSDataType.INT64] + tablet = Tablet(device_id, measurements, types, values, timestamps) + self.session.test_insert_tablet(tablet) + + # test insert record + measurements = ["s1", "s2", "s3"] + data_types = [TSDataType.INT64, TSDataType.INT64, TSDataType.INT64] + values = [1, 2, 3] + for time in range(100): + self.session.test_insert_record(device_id, time, measurements, data_types, values) + + # test insert records + measurements = ["s1", "s2", "s3"] + device_ids = [device_id for _ in range(100)] + data_types = [[TSDataType.INT64, TSDataType.INT64, TSDataType.INT64] for _ in range(100)] + values = [[1, 2, 3] for _ in range(100)] + timestamps = [i for i in range(100)] + self.session.test_insert_records(device_ids, timestamps, measurements, data_types, values) + + def test_Chinese_character(self): + storage_group = "root.存储组1" + devices = ["设备1.指标1", "设备1.s2", "d2.s1", "d2.指标2"] + self.session.set_storage_group(storage_group) + self.createTimeSeriesInChinese(self.session, storage_group, devices) + self.insertInChinese(self.session, storage_group, devices) + self.session.delete_storage_group(storage_group) + + def test(self): + self.session.set_storage_group("root.sg1") + self.createTimeSeries(self.session) + self.insert(self.session) + # SQL tests + self.insert_via_sql(self.session) + self.query3() + # self.insertTabletTest1(self.session, "root.sg1.d1") + self.deleteData(self.session) + self.query() + self.deleteTimeseries(self.session) + self.query2() + self.insertRecords(self.session) + self.query4() + + # special characters + self.session.create_time_series("root.sg1.d1.1_2", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + self.session.create_time_series("root.sg1.d1.\"1.2.3\"", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + self.session.create_time_series("root.sg1.d1.\'1.2.4\'", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + + self.session.set_storage_group("root.1") + self.session.create_time_series("root.1.2.3", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + + # Add another storage group to test the deletion of storage group + self.session.set_storage_group("root.sg2") + self.session.create_time_series("root.sg2.d1.s1", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + self.deleteStorageGroupTest(self.session) + + # set storage group without creating time series + self.session.set_storage_group("root.sg3") + self.insertTabletTest1(self.session, "root.sg3.d1") + + # create timeseries without setting storage groups + self.session.create_time_series("root.sg4.d1.s1", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + self.session.create_time_series("root.sg4.d1.s2", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + self.session.create_time_series("root.sg4.d1.s3", TSDataType.INT64, TSEncoding.RLE, Compressor.SNAPPY) + self.insertTabletTest1(self.session, "root.sg4.d1") + + # directly insertion, without any setting of storage groups and time series. + self.insertTabletTest1(self.session, "root.sg5.d1") + + # clear + self.session.delete_storage_groups(["root.sg3", "root.sg4", "root.sg5", "root.1"]) + + def test_by_str(self): Review comment: I found some duplicates among the two methods, are they necessary? ---------------------------------------------------------------- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. For queries about this service, please contact Infrastructure at: us...@infra.apache.org
