client-cpp/src/test/cpp/sessionIT.cpp - iotdb - Git at Google


            
            /**

            
             * 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.

            
             */


            #include "catch.hpp"

            
            #include "Session.h"


            using namespace std;


            extern Session *session;


            static vector<string> testTimeseries = {"root.test.d1.s1", "root.test.d1.s2", "root.test.d1.s3"};


            void prepareTimeseries() {

            
                for (const string &timeseries: testTimeseries) {

            
                    if (session->checkTimeseriesExists(timeseries)) {

            
                        session->deleteTimeseries(timeseries);

            
                    }

            
                    session->createTimeseries(timeseries, TSDataType::INT64, TSEncoding::RLE, CompressionType::SNAPPY);

            
                }

            
            }


            TEST_CASE("Create timeseries success", "[createTimeseries]") {

            
                if (!session->checkTimeseriesExists("root.test.d1.s1")) {

            
                    session->createTimeseries("root.test.d1.s1", TSDataType::INT64, TSEncoding::RLE, CompressionType::SNAPPY);

            
                }

            
                REQUIRE(session->checkTimeseriesExists("root.test.d1.s1") == true);

            
                session->deleteTimeseries("root.test.d1.s1");

            
            }


            TEST_CASE("Delete timeseries success", "[deleteTimeseries]") {

            
                if (!session->checkTimeseriesExists("root.test.d1.s1")) {

            
                    session->createTimeseries("root.test.d1.s1", TSDataType::INT64, TSEncoding::RLE, CompressionType::SNAPPY);

            
                }

            
                REQUIRE(session->checkTimeseriesExists("root.test.d1.s1") == true);

            
                session->deleteTimeseries("root.test.d1.s1");

            
                REQUIRE(session->checkTimeseriesExists("root.test.d1.s1") == false);

            
            }


            TEST_CASE("Test insertRecord by string", "[testInsertRecord]") {

            
                prepareTimeseries();

            
                string deviceId = "root.test.d1";

            
                vector<string> measurements = {"s1", "s2", "s3"};


                for (long time = 0; time < 100; time++) {

            
                    vector<string> values = {"1", "2", "3"};

            
                    session->insertRecord(deviceId, time, measurements, values);

            
                }


                session->executeNonQueryStatement("insert into root.test.d1(timestamp,s1, s2, s3) values(100, 1,2,3)");


                unique_ptr<SessionDataSet> sessionDataSet = session->executeQueryStatement("select * from root.test.d1");

            
                sessionDataSet->setBatchSize(1024);

            
                int count = 0;

            
                while (sessionDataSet->hasNext()) {

            
                    long index = 1;

            
                    count++;

            
                    for (const Field &f: sessionDataSet->next()->fields) {

            
                        REQUIRE(f.longV == index);

            
                        index++;

            
                    }

            
                }

            
                REQUIRE(count == 101);

            
            }


            TEST_CASE("Test insertRecords ", "[testInsertRecords]") {

            
                prepareTimeseries();

            
                string deviceId = "root.test.d1";

            
                vector<string> measurements = {"s1", "s2", "s3"};

            
                vector<string> deviceIds;

            
                vector<vector<string>> measurementsList;

            
                vector<vector<string>> valuesList;

            
                vector<int64_t> timestamps;


                for (int64_t time = 0; time < 500; time++) {

            
                    vector<string> values = {"1", "2", "3"};


                    deviceIds.push_back(deviceId);

            
                    measurementsList.push_back(measurements);

            
                    valuesList.push_back(values);

            
                    timestamps.push_back(time);

            
                    if (time != 0 && time % 100 == 0) {

            
                        session->insertRecords(deviceIds, timestamps, measurementsList, valuesList);

            
                        deviceIds.clear();

            
                        measurementsList.clear();

            
                        valuesList.clear();

            
                        timestamps.clear();

            
                    }

            
                }


                session->insertRecords(deviceIds, timestamps, measurementsList, valuesList);


                unique_ptr<SessionDataSet> sessionDataSet = session->executeQueryStatement("select * from root.test.d1");

            
                sessionDataSet->setBatchSize(1024);

            
                int count = 0;

            
                while (sessionDataSet->hasNext()) {

            
                    long index = 1;

            
                    count++;

            
                    for (const Field &f: sessionDataSet->next()->fields) {

            
                        REQUIRE(f.longV == index);

            
                        index++;

            
                    }

            
                }

            
                REQUIRE(count == 500);

            
            }


            TEST_CASE("Test insertRecord with types ", "[testTypedInsertRecord]") {

            
                vector<string> timeseries = {"root.test.d1.s1", "root.test.d1.s2", "root.test.d1.s3"};

            
                vector<TSDataType::TSDataType> types = {TSDataType::INT32, TSDataType::DOUBLE, TSDataType::INT64};


                for (int i = 0; i < timeseries.size(); i++) {

            
                    if (session->checkTimeseriesExists(timeseries[i])) {

            
                        session->deleteTimeseries(timeseries[i]);

            
                    }

            
                    session->createTimeseries(timeseries[i], types[i], TSEncoding::RLE, CompressionType::SNAPPY);

            
                }

            
                string deviceId = "root.test.d1";

            
                vector<string> measurements = {"s1", "s2", "s3"};

            
                vector<int32_t> value1(100, 1);

            
                vector<double> value2(100, 2.2);

            
                vector<int64_t> value3(100, 3);


                for (long time = 0; time < 100; time++) {

            
                    vector<char *> values = {(char *) (&value1[time]), (char *) (&value2[time]), (char *) (&value3[time])};

            
                    session->insertRecord(deviceId, time, measurements, types, values);

            
                }


                unique_ptr<SessionDataSet> sessionDataSet = session->executeQueryStatement("select s1,s2,s3 from root.test.d1");

            
                sessionDataSet->setBatchSize(1024);

            
                long count = 0;

            
                while (sessionDataSet->hasNext()) {

            
                    sessionDataSet->next();

            
                    count++;

            
                }

            
                REQUIRE(count == 100);

            
            }


            TEST_CASE("Test insertRecords with types ", "[testTypedInsertRecords]") {

            
                vector<string> timeseries = {"root.test.d1.s1", "root.test.d1.s2", "root.test.d1.s3"};

            
                vector<TSDataType::TSDataType> types = {TSDataType::INT32, TSDataType::DOUBLE, TSDataType::INT64};


                for (int i = 0; i < timeseries.size(); i++) {

            
                    if (session->checkTimeseriesExists(timeseries[i])) {

            
                        session->deleteTimeseries(timeseries[i]);

            
                    }

            
                    session->createTimeseries(timeseries[i], types[i], TSEncoding::RLE, CompressionType::SNAPPY);

            
                }

            
                string deviceId = "root.test.d1";

            
                vector<string> measurements = {"s1", "s2", "s3"};

            
                vector<string> deviceIds;

            
                vector<vector<string>> measurementsList;

            
                vector<vector<TSDataType::TSDataType>> typesList;

            
                vector<vector<char *>> valuesList;

            
                vector<int64_t> timestamps;

            
                vector<int32_t> value1(100, 1);

            
                vector<double> value2(100, 2.2);

            
                vector<int64_t> value3(100, 3);


                for (int64_t time = 0; time < 100; time++) {

            
                    vector<char *> values = {(char *) (&value1[time]), (char *) (&value2[time]), (char *) (&value3[time])};

            
                    deviceIds.push_back(deviceId);

            
                    measurementsList.push_back(measurements);

            
                    typesList.push_back(types);

            
                    valuesList.push_back(values);

            
                    timestamps.push_back(time);

            
                }


                session->insertRecords(deviceIds, timestamps, measurementsList, typesList, valuesList);


                unique_ptr<SessionDataSet> sessionDataSet = session->executeQueryStatement("select * from root.test.d1");

            
                sessionDataSet->setBatchSize(1024);

            
                int count = 0;

            
                while (sessionDataSet->hasNext()) {

            
                    sessionDataSet->next();

            
                    count++;

            
                }

            
                REQUIRE(count == 100);

            
            }


            TEST_CASE("Test insertRecordsOfOneDevice", "[testInsertRecordsOfOneDevice]") {

            
                vector<string> timeseries = {"root.test.d1.s1", "root.test.d1.s2", "root.test.d1.s3"};

            
                vector<TSDataType::TSDataType> types = {TSDataType::INT32, TSDataType::DOUBLE, TSDataType::INT64};


                for (int i = 0; i < timeseries.size(); i++) {

            
                    if (session->checkTimeseriesExists(timeseries[i])) {

            
                        session->deleteTimeseries(timeseries[i]);

            
                    }

            
                    session->createTimeseries(timeseries[i], types[i], TSEncoding::RLE, CompressionType::SNAPPY);

            
                }

            
                string deviceId = "root.test.d1";

            
                vector<string> measurements = {"s1", "s2", "s3"};

            
                vector<vector<string>> measurementsList;

            
                vector<vector<TSDataType::TSDataType>> typesList;

            
                vector<vector<char *>> valuesList;

            
                vector<int64_t> timestamps;

            
                vector<int32_t> value1(100, 1);

            
                vector<double> value2(100, 2.2);

            
                vector<int64_t> value3(100, 3);


                for (int64_t time = 0; time < 100; time++) {

            
                    vector<char *> values = {(char *) (&value1[time]), (char *) (&value2[time]), (char *) (&value3[time])};

            
                    measurementsList.push_back(measurements);

            
                    typesList.push_back(types);

            
                    valuesList.push_back(values);

            
                    timestamps.push_back(time);

            
                }


                session->insertRecordsOfOneDevice(deviceId, timestamps, measurementsList, typesList, valuesList);


                unique_ptr<SessionDataSet> sessionDataSet = session->executeQueryStatement("select * from root.test.d1");

            
                sessionDataSet->setBatchSize(1024);

            
                int count = 0;

            
                while (sessionDataSet->hasNext()) {

            
                    sessionDataSet->next();

            
                    count++;

            
                }

            
                REQUIRE(count == 100);

            
            }


            TEST_CASE("Test insertTablet ", "[testInsertTablet]") {

            
                prepareTimeseries();

            
                string deviceId = "root.test.d1";

            
                vector<pair<string, TSDataType::TSDataType>> schemaList;

            
                schemaList.emplace_back("s1", TSDataType::INT64);

            
                schemaList.emplace_back("s2", TSDataType::INT64);

            
                schemaList.emplace_back("s3", TSDataType::INT64);


                Tablet tablet(deviceId, schemaList, 100);

            
                for (int64_t time = 0; time < 100; time++) {

            
                    int row = tablet.rowSize++;

            
                    tablet.timestamps[row] = time;

            
                    for (int i = 0; i < 3; i++) {

            
                        int64_t randVal = rand();

            
                        tablet.addValue(i, row, &randVal);

            
                    }

            
                    if (tablet.rowSize == tablet.maxRowNumber) {

            
                        session->insertTablet(tablet);

            
                        tablet.reset();

            
                    }

            
                }


                if (tablet.rowSize != 0) {

            
                    session->insertTablet(tablet);

            
                    tablet.reset();

            
                }

            
                unique_ptr<SessionDataSet> sessionDataSet = session->executeQueryStatement("select * from root.test.d1");

            
                sessionDataSet->setBatchSize(1024);

            
                int count = 0;

            
                while (sessionDataSet->hasNext()) {

            
                    long index = 0;

            
                    count++;

            
                    for (const Field& f: sessionDataSet->next()->fields) {

            
                        REQUIRE(f.longV == index);

            
                        index++;

            
                    }

            
                }

            
                REQUIRE(count == 100);

            
            }


            TEST_CASE("Test Last query ", "[testLastQuery]") {

            
                prepareTimeseries();

            
                string deviceId = "root.test.d1";

            
                vector<string> measurements = {"s1", "s2", "s3"};


                for (long time = 0; time < 100; time++) {

            
                    vector<string> values = {"1", "2", "3"};

            
                    session->insertRecord(deviceId, time, measurements, values);

            
                }


                vector<string> measurementValues = {"1", "2", "3"};

            
                unique_ptr<SessionDataSet> sessionDataSet = session->executeQueryStatement(

            
                        "select last s1,s2,s3 from root.test.d1");

            
                sessionDataSet->setBatchSize(1024);

            
                long index = 0;

            
                while (sessionDataSet->hasNext()) {

            
                    vector<Field> fields = sessionDataSet->next()->fields;

            
                    REQUIRE(fields[0].stringV == deviceId + "." + measurements[index]);

            
                    REQUIRE(fields[1].stringV == measurementValues[index]);

            
                    index++;

            
                }

            
            }


            TEST_CASE("Test Huge query ", "[testHugeQuery]") {

            
                prepareTimeseries();

            
                string deviceId = "root.test.d1";

            
                vector<string> measurements = {"s1", "s2", "s3"};

            
                vector<TSDataType::TSDataType> types = {TSDataType::INT32, TSDataType::INT32, TSDataType::INT32};

            
                int value1 = 1, value2 = 2, value3 = 3;

            
                vector<char*> values = {(char*)&value1, (char*)&value2, (char*)&value3};


                for (long time = 0; time < 1000000; time++) {

            
                    session->insertRecord(deviceId, time, measurements, types, values);

            
                }


                unique_ptr<SessionDataSet> sessionDataSet = session->executeQueryStatement("select * from root.test.d1");

            
                sessionDataSet->setBatchSize(1024);

            
                RowRecord* rowRecord;

            
                int count = 0;

            
                while (sessionDataSet->hasNext()) {

            
                    rowRecord = sessionDataSet->next();

            
                    REQUIRE(rowRecord->timestamp == count);

            
                    REQUIRE(rowRecord->fields[0].intV == 1);

            
                    REQUIRE(rowRecord->fields[1].intV == 2);

            
                    REQUIRE(rowRecord->fields[2].intV == 3);

            
                    count++;

            
                }


                REQUIRE(count == 1000000);

            
            }
	/**
	* 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.
	*/

	#include "catch.hpp"
	#include "Session.h"

	using namespace std;

	extern Session *session;

	static vector<string> testTimeseries = {"root.test.d1.s1", "root.test.d1.s2", "root.test.d1.s3"};

	void prepareTimeseries() {
	for (const string &timeseries: testTimeseries) {
	if (session->checkTimeseriesExists(timeseries)) {
	session->deleteTimeseries(timeseries);
	}
	session->createTimeseries(timeseries, TSDataType::INT64, TSEncoding::RLE, CompressionType::SNAPPY);
	}
	}

	TEST_CASE("Create timeseries success", "[createTimeseries]") {
	if (!session->checkTimeseriesExists("root.test.d1.s1")) {
	session->createTimeseries("root.test.d1.s1", TSDataType::INT64, TSEncoding::RLE, CompressionType::SNAPPY);
	}
	REQUIRE(session->checkTimeseriesExists("root.test.d1.s1") == true);
	session->deleteTimeseries("root.test.d1.s1");
	}

	TEST_CASE("Delete timeseries success", "[deleteTimeseries]") {
	if (!session->checkTimeseriesExists("root.test.d1.s1")) {
	session->createTimeseries("root.test.d1.s1", TSDataType::INT64, TSEncoding::RLE, CompressionType::SNAPPY);
	}
	REQUIRE(session->checkTimeseriesExists("root.test.d1.s1") == true);
	session->deleteTimeseries("root.test.d1.s1");
	REQUIRE(session->checkTimeseriesExists("root.test.d1.s1") == false);
	}

	TEST_CASE("Test insertRecord by string", "[testInsertRecord]") {
	prepareTimeseries();
	string deviceId = "root.test.d1";
	vector<string> measurements = {"s1", "s2", "s3"};

	for (long time = 0; time < 100; time++) {
	vector<string> values = {"1", "2", "3"};
	session->insertRecord(deviceId, time, measurements, values);
	}

	session->executeNonQueryStatement("insert into root.test.d1(timestamp,s1, s2, s3) values(100, 1,2,3)");

	unique_ptr<SessionDataSet> sessionDataSet = session->executeQueryStatement("select * from root.test.d1");
	sessionDataSet->setBatchSize(1024);
	int count = 0;
	while (sessionDataSet->hasNext()) {
	long index = 1;
	count++;
	for (const Field &f: sessionDataSet->next()->fields) {
	REQUIRE(f.longV == index);
	index++;
	}
	}
	REQUIRE(count == 101);
	}

	TEST_CASE("Test insertRecords ", "[testInsertRecords]") {
	prepareTimeseries();
	string deviceId = "root.test.d1";
	vector<string> measurements = {"s1", "s2", "s3"};
	vector<string> deviceIds;
	vector<vector<string>> measurementsList;
	vector<vector<string>> valuesList;
	vector<int64_t> timestamps;

	for (int64_t time = 0; time < 500; time++) {
	vector<string> values = {"1", "2", "3"};

	deviceIds.push_back(deviceId);
	measurementsList.push_back(measurements);
	valuesList.push_back(values);
	timestamps.push_back(time);
	if (time != 0 && time % 100 == 0) {
	session->insertRecords(deviceIds, timestamps, measurementsList, valuesList);
	deviceIds.clear();
	measurementsList.clear();
	valuesList.clear();
	timestamps.clear();
	}
	}

	session->insertRecords(deviceIds, timestamps, measurementsList, valuesList);

	unique_ptr<SessionDataSet> sessionDataSet = session->executeQueryStatement("select * from root.test.d1");
	sessionDataSet->setBatchSize(1024);
	int count = 0;
	while (sessionDataSet->hasNext()) {
	long index = 1;
	count++;
	for (const Field &f: sessionDataSet->next()->fields) {
	REQUIRE(f.longV == index);
	index++;
	}
	}
	REQUIRE(count == 500);
	}

	TEST_CASE("Test insertRecord with types ", "[testTypedInsertRecord]") {
	vector<string> timeseries = {"root.test.d1.s1", "root.test.d1.s2", "root.test.d1.s3"};
	vector<TSDataType::TSDataType> types = {TSDataType::INT32, TSDataType::DOUBLE, TSDataType::INT64};

	for (int i = 0; i < timeseries.size(); i++) {
	if (session->checkTimeseriesExists(timeseries[i])) {
	session->deleteTimeseries(timeseries[i]);
	}
	session->createTimeseries(timeseries[i], types[i], TSEncoding::RLE, CompressionType::SNAPPY);
	}
	string deviceId = "root.test.d1";
	vector<string> measurements = {"s1", "s2", "s3"};
	vector<int32_t> value1(100, 1);
	vector<double> value2(100, 2.2);
	vector<int64_t> value3(100, 3);

	for (long time = 0; time < 100; time++) {
	vector<char > values = {(char ) (&value1[time]), (char ) (&value2[time]), (char ) (&value3[time])};
	session->insertRecord(deviceId, time, measurements, types, values);
	}

	unique_ptr<SessionDataSet> sessionDataSet = session->executeQueryStatement("select s1,s2,s3 from root.test.d1");
	sessionDataSet->setBatchSize(1024);
	long count = 0;
	while (sessionDataSet->hasNext()) {
	sessionDataSet->next();
	count++;
	}
	REQUIRE(count == 100);
	}

	TEST_CASE("Test insertRecords with types ", "[testTypedInsertRecords]") {
	vector<string> timeseries = {"root.test.d1.s1", "root.test.d1.s2", "root.test.d1.s3"};
	vector<TSDataType::TSDataType> types = {TSDataType::INT32, TSDataType::DOUBLE, TSDataType::INT64};

	for (int i = 0; i < timeseries.size(); i++) {
	if (session->checkTimeseriesExists(timeseries[i])) {
	session->deleteTimeseries(timeseries[i]);
	}
	session->createTimeseries(timeseries[i], types[i], TSEncoding::RLE, CompressionType::SNAPPY);
	}
	string deviceId = "root.test.d1";
	vector<string> measurements = {"s1", "s2", "s3"};
	vector<string> deviceIds;
	vector<vector<string>> measurementsList;
	vector<vector<TSDataType::TSDataType>> typesList;
	vector<vector<char *>> valuesList;
	vector<int64_t> timestamps;
	vector<int32_t> value1(100, 1);
	vector<double> value2(100, 2.2);
	vector<int64_t> value3(100, 3);

	for (int64_t time = 0; time < 100; time++) {
	vector<char > values = {(char ) (&value1[time]), (char ) (&value2[time]), (char ) (&value3[time])};
	deviceIds.push_back(deviceId);
	measurementsList.push_back(measurements);
	typesList.push_back(types);
	valuesList.push_back(values);
	timestamps.push_back(time);
	}

	session->insertRecords(deviceIds, timestamps, measurementsList, typesList, valuesList);

	unique_ptr<SessionDataSet> sessionDataSet = session->executeQueryStatement("select * from root.test.d1");
	sessionDataSet->setBatchSize(1024);
	int count = 0;
	while (sessionDataSet->hasNext()) {
	sessionDataSet->next();
	count++;
	}
	REQUIRE(count == 100);
	}

	TEST_CASE("Test insertRecordsOfOneDevice", "[testInsertRecordsOfOneDevice]") {
	vector<string> timeseries = {"root.test.d1.s1", "root.test.d1.s2", "root.test.d1.s3"};
	vector<TSDataType::TSDataType> types = {TSDataType::INT32, TSDataType::DOUBLE, TSDataType::INT64};

	for (int i = 0; i < timeseries.size(); i++) {
	if (session->checkTimeseriesExists(timeseries[i])) {
	session->deleteTimeseries(timeseries[i]);
	}
	session->createTimeseries(timeseries[i], types[i], TSEncoding::RLE, CompressionType::SNAPPY);
	}
	string deviceId = "root.test.d1";
	vector<string> measurements = {"s1", "s2", "s3"};
	vector<vector<string>> measurementsList;
	vector<vector<TSDataType::TSDataType>> typesList;
	vector<vector<char *>> valuesList;
	vector<int64_t> timestamps;
	vector<int32_t> value1(100, 1);
	vector<double> value2(100, 2.2);
	vector<int64_t> value3(100, 3);

	for (int64_t time = 0; time < 100; time++) {
	vector<char > values = {(char ) (&value1[time]), (char ) (&value2[time]), (char ) (&value3[time])};
	measurementsList.push_back(measurements);
	typesList.push_back(types);
	valuesList.push_back(values);
	timestamps.push_back(time);
	}

	session->insertRecordsOfOneDevice(deviceId, timestamps, measurementsList, typesList, valuesList);

	unique_ptr<SessionDataSet> sessionDataSet = session->executeQueryStatement("select * from root.test.d1");
	sessionDataSet->setBatchSize(1024);
	int count = 0;
	while (sessionDataSet->hasNext()) {
	sessionDataSet->next();
	count++;
	}
	REQUIRE(count == 100);
	}

	TEST_CASE("Test insertTablet ", "[testInsertTablet]") {
	prepareTimeseries();
	string deviceId = "root.test.d1";
	vector<pair<string, TSDataType::TSDataType>> schemaList;
	schemaList.emplace_back("s1", TSDataType::INT64);
	schemaList.emplace_back("s2", TSDataType::INT64);
	schemaList.emplace_back("s3", TSDataType::INT64);

	Tablet tablet(deviceId, schemaList, 100);
	for (int64_t time = 0; time < 100; time++) {
	int row = tablet.rowSize++;
	tablet.timestamps[row] = time;
	for (int i = 0; i < 3; i++) {
	int64_t randVal = rand();
	tablet.addValue(i, row, &randVal);
	}
	if (tablet.rowSize == tablet.maxRowNumber) {
	session->insertTablet(tablet);
	tablet.reset();
	}
	}

	if (tablet.rowSize != 0) {
	session->insertTablet(tablet);
	tablet.reset();
	}
	unique_ptr<SessionDataSet> sessionDataSet = session->executeQueryStatement("select * from root.test.d1");
	sessionDataSet->setBatchSize(1024);
	int count = 0;
	while (sessionDataSet->hasNext()) {
	long index = 0;
	count++;
	for (const Field& f: sessionDataSet->next()->fields) {
	REQUIRE(f.longV == index);
	index++;
	}
	}
	REQUIRE(count == 100);
	}

	TEST_CASE("Test Last query ", "[testLastQuery]") {
	prepareTimeseries();
	string deviceId = "root.test.d1";
	vector<string> measurements = {"s1", "s2", "s3"};

	for (long time = 0; time < 100; time++) {
	vector<string> values = {"1", "2", "3"};
	session->insertRecord(deviceId, time, measurements, values);
	}

	vector<string> measurementValues = {"1", "2", "3"};
	unique_ptr<SessionDataSet> sessionDataSet = session->executeQueryStatement(
	"select last s1,s2,s3 from root.test.d1");
	sessionDataSet->setBatchSize(1024);
	long index = 0;
	while (sessionDataSet->hasNext()) {
	vector<Field> fields = sessionDataSet->next()->fields;
	REQUIRE(fields[0].stringV == deviceId + "." + measurements[index]);
	REQUIRE(fields[1].stringV == measurementValues[index]);
	index++;
	}
	}

	TEST_CASE("Test Huge query ", "[testHugeQuery]") {
	prepareTimeseries();
	string deviceId = "root.test.d1";
	vector<string> measurements = {"s1", "s2", "s3"};
	vector<TSDataType::TSDataType> types = {TSDataType::INT32, TSDataType::INT32, TSDataType::INT32};
	int value1 = 1, value2 = 2, value3 = 3;
	vector<char> values = {(char)&value1, (char)&value2, (char)&value3};

	for (long time = 0; time < 1000000; time++) {
	session->insertRecord(deviceId, time, measurements, types, values);
	}

	unique_ptr<SessionDataSet> sessionDataSet = session->executeQueryStatement("select * from root.test.d1");
	sessionDataSet->setBatchSize(1024);
	RowRecord* rowRecord;
	int count = 0;
	while (sessionDataSet->hasNext()) {
	rowRecord = sessionDataSet->next();
	REQUIRE(rowRecord->timestamp == count);
	REQUIRE(rowRecord->fields[0].intV == 1);
	REQUIRE(rowRecord->fields[1].intV == 2);
	REQUIRE(rowRecord->fields[2].intV == 3);
	count++;
	}

	REQUIRE(count == 1000000);
	}