Fix blob accumulator query can't skip read blobStatistics caused by isModified don't change to true in the metadata of chunk and pageReader (#17127)
* Resolve Blob type
* Fix
* Fixed an issue in IT where aggregation queries skipped over Blob and DATE types, leading to incomplete coverage in aggregation queries. Having the same DataType does not ensure that their statistics are identical, so it has been changed to check whether the statistics are the same. Additionally, Blob type has been added to the types that cannot use statistics for acceleration.
* Rename a variable.
* Rename the function.
diff --git a/integration-test/src/test/java/org/apache/iotdb/db/it/schema/IoTDBAlterTimeSeriesTypeIT.java b/integration-test/src/test/java/org/apache/iotdb/db/it/schema/IoTDBAlterTimeSeriesTypeIT.java
index d199dde..3effc3a 100644
--- a/integration-test/src/test/java/org/apache/iotdb/db/it/schema/IoTDBAlterTimeSeriesTypeIT.java
+++ b/integration-test/src/test/java/org/apache/iotdb/db/it/schema/IoTDBAlterTimeSeriesTypeIT.java
@@ -93,10 +93,8 @@
private static final Logger log = LoggerFactory.getLogger(IoTDBAlterTimeSeriesTypeIT.class);
private static long timeout = -1;
private static final String database = "root.alter";
- public static final List<TSDataType> DATA_TYPE_LIST =
- Arrays.asList(TSDataType.STRING, TSDataType.TEXT, TSDataType.BOOLEAN);
- public static final List<TSDataType> UNSUPPORT_ACCUMULATOR_QUERY_DATA_TYPE_LIST =
- Collections.singletonList(TSDataType.BLOB);
+ public static final List<TSDataType> UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST =
+ Arrays.asList(TSDataType.BLOB, TSDataType.TEXT, TSDataType.BOOLEAN);
@BeforeClass
public static void setUp() throws Exception {
@@ -129,6 +127,8 @@
testAlignDeviceSequenceDataQuery(from, to);
testAlignDeviceUnSequenceDataQuery(from, to);
testAlignDeviceUnSequenceOverlappedDataQuery(from, to);
+
+ doWriteAndAlterWriteForAccumulatorQuery(from, to);
}
}
}
@@ -295,7 +295,8 @@
}
assertFalse(dataSet.hasNext());
- if (DATA_TYPE_LIST.contains(from) || DATA_TYPE_LIST.contains(to)) {
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(from)
+ || UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(to)) {
dataSet =
session.executeQueryStatement(
"select first_value(s1),last_value(s1) from "
@@ -352,6 +353,83 @@
}
}
+ private void doWriteAndAlterWriteForAccumulatorQuery(TSDataType from, TSDataType to)
+ throws IoTDBConnectionException, StatementExecutionException {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ session.executeNonQueryStatement(
+ "SET CONFIGURATION \"enable_unseq_space_compaction\"='false'");
+ session.executeNonQueryStatement("SET CONFIGURATION \"enable_seq_space_compaction\"='false'");
+ if (from == TSDataType.DATE && !to.isCompatible(from)) {
+ throw new NotSupportedException("Not supported DATE type.");
+ }
+
+ // create a table with type of "from"
+ session.executeNonQueryStatement(
+ "CREATE TIMESERIES " + database + ".write_and_alter_column_type_write.s1 " + from);
+
+ // write a sequence tsfile point of "from"
+ Tablet tablet =
+ new Tablet(
+ database + ".write_and_alter_column_type_write",
+ Collections.singletonList("s1"),
+ Collections.singletonList(from),
+ Collections.singletonList(ColumnCategory.FIELD));
+ for (int i = 1; i <= 512; i++) {
+ tablet.addTimestamp(0, i);
+ tablet.addValue("s1", 0, genValue(from, i));
+ session.insertTablet(tablet);
+ tablet.reset();
+ }
+ session.executeNonQueryStatement("FLUSH");
+
+ // alter the type to "to"
+ boolean isCompatible = MetadataUtils.canAlter(from, to);
+ if (isCompatible) {
+ session.executeNonQueryStatement(
+ "ALTER TIMESERIES "
+ + database
+ + ".write_and_alter_column_type_write.s1 SET DATA TYPE "
+ + to);
+ } else {
+ try {
+ session.executeNonQueryStatement(
+ "ALTER TIMESERIES "
+ + database
+ + ".write_and_alter_column_type_write.s1 SET DATA TYPE "
+ + to);
+ } catch (StatementExecutionException e) {
+ assertEquals(
+ "701: New type " + to + " is not compatible with the existing one " + from,
+ e.getMessage());
+ }
+ }
+
+ // write a sequence tsfile point of "to"
+ tablet =
+ new Tablet(
+ database + ".write_and_alter_column_type_write",
+ Collections.singletonList("s1"),
+ Collections.singletonList(to),
+ Collections.singletonList(ColumnCategory.FIELD));
+ for (int i = 513; i <= 1024; i++) {
+ tablet.addTimestamp(0, i);
+ tablet.addValue("s1", 0, genValue(to, i));
+ session.insertTablet(tablet);
+ tablet.reset();
+ }
+ session.executeNonQueryStatement("FLUSH");
+
+ standardAccumulatorQueryByTimeOnlyInvolveOldDataTypeTest(session, from, to);
+ standardAccumulatorQueryByTimeOnlyInvolveNewDataTypeTest(session, from, to);
+ standardAccumulatorQueryByTimeInvolveAllDataTypeTest(session, from, to);
+ } finally {
+ try (ISession session = EnvFactory.getEnv().getSessionConnection()) {
+ session.executeNonQueryStatement(
+ "DELETE TIMESERIES " + database + ".write_and_alter_column_type_write.s1");
+ }
+ }
+ }
+
@Test
public void testAlterWithoutWrite() throws IoTDBConnectionException, StatementExecutionException {
Set<TSDataType> typesToTest = new HashSet<>();
@@ -1129,31 +1207,22 @@
tablet.reset();
}
- if (DATA_TYPE_LIST.contains(from) || DATA_TYPE_LIST.contains(to)) {
- SessionDataSet dataSet =
- session.executeQueryStatement(
- "select first_value(s1),last_value(s1) from "
- + database
- + ".construct_and_alter_column_type");
- RowRecord rec = dataSet.next();
- while (rec != null) {
- System.out.println(rec.getFields().toString());
- rec = dataSet.next();
- }
- dataSet.close();
+ String columns;
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(from)
+ || UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(to)) {
+ columns = "first_value(s1),last_value(s1)";
} else {
- SessionDataSet dataSet =
- session.executeQueryStatement(
- "select min_value(s1),max_value(s1),first_value(s1),last_value(s1) from "
- + database
- + ".construct_and_alter_column_type");
- RowRecord rec = dataSet.next();
- while (rec != null) {
- System.out.println(rec.getFields().toString());
- rec = dataSet.next();
- }
- dataSet.close();
+ columns = "min_value(s1),max_value(s1),first_value(s1),last_value(s1)";
}
+ SessionDataSet dataSet =
+ session.executeQueryStatement(
+ "select " + columns + " from " + database + ".construct_and_alter_column_type");
+ RowRecord rec = dataSet.next();
+ while (rec != null) {
+ System.out.println(rec.getFields().toString());
+ rec = dataSet.next();
+ }
+ dataSet.close();
try {
standardSelectTest(session, from, to);
@@ -1275,31 +1344,22 @@
tablet.reset();
}
- if (DATA_TYPE_LIST.contains(from) || DATA_TYPE_LIST.contains(to)) {
- SessionDataSet dataSet =
- session.executeQueryStatement(
- "select first_value(s1),last_value(s1) from "
- + database
- + ".construct_and_alter_column_type");
- RowRecord rec = dataSet.next();
- while (rec != null) {
- System.out.println(rec.getFields().toString());
- rec = dataSet.next();
- }
- dataSet.close();
+ String columns;
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(from)
+ || UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(to)) {
+ columns = "first_value(s1),last_value(s1)";
} else {
- SessionDataSet dataSet =
- session.executeQueryStatement(
- "select min_value(s1),max_value(s1),first_value(s1),last_value(s1) from "
- + database
- + ".construct_and_alter_column_type");
- RowRecord rec = dataSet.next();
- while (rec != null) {
- System.out.println(rec.getFields().toString());
- rec = dataSet.next();
- }
- dataSet.close();
+ columns = "min_value(s1),max_value(s1),first_value(s1),last_value(s1)";
}
+ SessionDataSet dataSet =
+ session.executeQueryStatement(
+ "select " + columns + " from " + database + ".construct_and_alter_column_type");
+ RowRecord rec = dataSet.next();
+ while (rec != null) {
+ System.out.println(rec.getFields().toString());
+ rec = dataSet.next();
+ }
+ dataSet.close();
try {
standardSelectTest(session, from, to);
@@ -1414,31 +1474,22 @@
}
// session.executeNonQueryStatement("FLUSH");
- if (DATA_TYPE_LIST.contains(from) || DATA_TYPE_LIST.contains(to)) {
- SessionDataSet dataSet =
- session.executeQueryStatement(
- "select first_value(s1),last_value(s1) from "
- + database
- + ".construct_and_alter_column_type");
- RowRecord rec = dataSet.next();
- while (rec != null) {
- System.out.println(rec.getFields().toString());
- rec = dataSet.next();
- }
- dataSet.close();
+ String columns;
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(from)
+ || UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(to)) {
+ columns = "first_value(s1),last_value(s1)";
} else {
- SessionDataSet dataSet =
- session.executeQueryStatement(
- "select min_value(s1),max_value(s1),first_value(s1),last_value(s1) from "
- + database
- + ".construct_and_alter_column_type");
- RowRecord rec = dataSet.next();
- while (rec != null) {
- System.out.println(rec.getFields().toString());
- rec = dataSet.next();
- }
- dataSet.close();
+ columns = "min_value(s1),max_value(s1),first_value(s1),last_value(s1)";
}
+ SessionDataSet dataSet =
+ session.executeQueryStatement(
+ "select " + columns + " from " + database + ".construct_and_alter_column_type");
+ RowRecord rec = dataSet.next();
+ while (rec != null) {
+ System.out.println(rec.getFields().toString());
+ rec = dataSet.next();
+ }
+ dataSet.close();
try {
standardSelectTest(session, from, to);
@@ -1556,31 +1607,22 @@
}
// session.executeNonQueryStatement("FLUSH");
- if (DATA_TYPE_LIST.contains(from) || DATA_TYPE_LIST.contains(to)) {
- SessionDataSet dataSet =
- session.executeQueryStatement(
- "select first_value(s1),last_value(s1) from "
- + database
- + ".construct_and_alter_column_type");
- RowRecord rec = dataSet.next();
- while (rec != null) {
- System.out.println(rec.getFields().toString());
- rec = dataSet.next();
- }
- dataSet.close();
+ String columns;
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(from)
+ || UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(to)) {
+ columns = "first_value(s1),last_value(s1)";
} else {
- SessionDataSet dataSet =
- session.executeQueryStatement(
- "select min_value(s1),max_value(s1),first_value(s1),last_value(s1) from "
- + database
- + ".construct_and_alter_column_type");
- RowRecord rec = dataSet.next();
- while (rec != null) {
- System.out.println(rec.getFields().toString());
- rec = dataSet.next();
- }
- dataSet.close();
+ columns = "min_value(s1),max_value(s1),first_value(s1),last_value(s1)";
}
+ SessionDataSet dataSet =
+ session.executeQueryStatement(
+ "select " + columns + " from " + database + ".construct_and_alter_column_type");
+ RowRecord rec = dataSet.next();
+ while (rec != null) {
+ System.out.println(rec.getFields().toString());
+ rec = dataSet.next();
+ }
+ dataSet.close();
try {
standardSelectTest(session, from, to);
@@ -1695,31 +1737,22 @@
}
// session.executeNonQueryStatement("FLUSH");
- if (DATA_TYPE_LIST.contains(from) || DATA_TYPE_LIST.contains(to)) {
- SessionDataSet dataSet =
- session.executeQueryStatement(
- "select first_value(s1),last_value(s1) from "
- + database
- + ".construct_and_alter_column_type");
- RowRecord rec = dataSet.next();
- while (rec != null) {
- System.out.println(rec.getFields().toString());
- rec = dataSet.next();
- }
- dataSet.close();
+ String columns;
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(from)
+ || UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(to)) {
+ columns = "first_value(s1),last_value(s1)";
} else {
- SessionDataSet dataSet =
- session.executeQueryStatement(
- "select min_value(s1),max_value(s1),first_value(s1),last_value(s1) from "
- + database
- + ".construct_and_alter_column_type");
- RowRecord rec = dataSet.next();
- while (rec != null) {
- System.out.println(rec.getFields().toString());
- rec = dataSet.next();
- }
- dataSet.close();
+ columns = "min_value(s1),max_value(s1),first_value(s1),last_value(s1)";
}
+ SessionDataSet dataSet =
+ session.executeQueryStatement(
+ "select " + columns + " from " + database + ".construct_and_alter_column_type");
+ RowRecord rec = dataSet.next();
+ while (rec != null) {
+ System.out.println(rec.getFields().toString());
+ rec = dataSet.next();
+ }
+ dataSet.close();
try {
standardSelectTest(session, from, to);
@@ -1838,31 +1871,22 @@
}
// session.executeNonQueryStatement("FLUSH");
- if (DATA_TYPE_LIST.contains(from) || DATA_TYPE_LIST.contains(to)) {
- SessionDataSet dataSet =
- session.executeQueryStatement(
- "select first_value(s1),last_value(s1) from "
- + database
- + ".construct_and_alter_column_type");
- RowRecord rec = dataSet.next();
- while (rec != null) {
- System.out.println(rec.getFields().toString());
- rec = dataSet.next();
- }
- dataSet.close();
+ String columns;
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(from)
+ || UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(to)) {
+ columns = "first_value(s1),last_value(s1)";
} else {
- SessionDataSet dataSet =
- session.executeQueryStatement(
- "select min_value(s1),max_value(s1),first_value(s1),last_value(s1) from "
- + database
- + ".construct_and_alter_column_type");
- RowRecord rec = dataSet.next();
- while (rec != null) {
- System.out.println(rec.getFields().toString());
- rec = dataSet.next();
- }
- dataSet.close();
+ columns = "min_value(s1),max_value(s1),first_value(s1),last_value(s1)";
}
+ SessionDataSet dataSet =
+ session.executeQueryStatement(
+ "select " + columns + " from " + database + ".construct_and_alter_column_type");
+ RowRecord rec = dataSet.next();
+ while (rec != null) {
+ System.out.println(rec.getFields().toString());
+ rec = dataSet.next();
+ }
+ dataSet.close();
try {
standardSelectTest(session, from, to);
@@ -1984,7 +2008,8 @@
"select s1 from "
+ database
+ ".construct_and_alter_column_type where cast(s1 as TEXT) >= '1' and cast(s2 as TEXT) > '2' order by time");
- // "select s1 from construct_and_alter_column_type where cast(s1 as
+ // "select s1 from " + database + ".construct_and_alter_column_type where
+ // cast(s1 as
// TEXT) >= '1' and s2 > '2' order by time");
} else {
dataSet1 =
@@ -2350,77 +2375,163 @@
private static void standardAccumulatorQueryTest(ISession session, TSDataType newType)
throws StatementExecutionException, IoTDBConnectionException {
- if (newType == TSDataType.DATE) {
- throw new NotSupportedException("Not supported DATE type.");
+ RowRecord rec = null;
+ RowRecord unsupportMinMaxRec = null;
+ SessionDataSet dataSet = null;
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ dataSet =
+ session.executeQueryStatement(
+ "select first_value(s1),last_value(s1) from "
+ + database
+ + ".construct_and_alter_column_type");
+ unsupportMinMaxRec = dataSet.next();
+ } else {
+ dataSet =
+ session.executeQueryStatement(
+ "select min_value(s1),max_value(s1),first_value(s1),last_value(s1) from "
+ + database
+ + ".construct_and_alter_column_type");
+ rec = dataSet.next();
}
- SessionDataSet dataSet;
- RowRecord rec;
- if (!UNSUPPORT_ACCUMULATOR_QUERY_DATA_TYPE_LIST.contains(newType)) {
- int[] expectedValue;
- int max = 4;
- if (DATA_TYPE_LIST.contains(newType)) {
- dataSet =
- session.executeQueryStatement(
- "select first_value(s1),last_value(s1) from "
- + database
- + ".construct_and_alter_column_type");
- rec = dataSet.next();
- expectedValue = new int[] {1, 1024};
- if (newType == TSDataType.STRING
- || newType == TSDataType.TEXT
- || newType == TSDataType.BLOB) {
- // expectedValue[1] = 999;
- } else if (newType == TSDataType.BOOLEAN) {
- expectedValue = new int[] {19700102, 19721021};
- }
- max = 2;
- } else {
- dataSet =
- session.executeQueryStatement(
- "select min_value(s1),max_value(s1),first_value(s1),last_value(s1) from "
- + database
- + ".construct_and_alter_column_type");
- rec = dataSet.next();
- expectedValue = new int[] {1, 1024, 1, 1024};
- if (newType == TSDataType.STRING
- || newType == TSDataType.TEXT
- || newType == TSDataType.BLOB) {
- expectedValue[1] = 999;
- } else if (newType == TSDataType.BOOLEAN) {
- expectedValue = new int[] {19700102, 19721021, 19700102, 19721021};
- }
- }
-
- if (newType != TSDataType.BOOLEAN) {
- for (int i = 0; i < max; i++) {
- if (newType == TSDataType.BLOB) {
- assertEquals(genValue(newType, expectedValue[i]), rec.getFields().get(i).getBinaryV());
- } else if (newType == TSDataType.DATE) {
- assertEquals(genValue(newType, expectedValue[i]), rec.getFields().get(i).getDateV());
- } else {
- log.info(
- "i is {}, expected value: {}, actual value: {}",
- i,
- genValue(newType, expectedValue[i]).toString(),
- rec.getFields().get(i).toString());
+ Object[] expectedValue;
+ switch (newType) {
+ case BOOLEAN:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new Boolean[] {false, true};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(i, expectedValue[i], unsupportMinMaxRec.getFields().get(i).toString());
assertEquals(
- genValue(newType, expectedValue[i]).toString(), rec.getFields().get(i).toString());
+ expectedValue[i], unsupportMinMaxRec.getFields().get(i).getObjectValue(newType));
+ }
+ } else {
+ expectedValue = new Boolean[] {false, true, false, true};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(expectedValue[i], rec.getFields().get(i).getObjectValue(newType));
}
}
-
- assertFalse(dataSet.hasNext());
-
- if (newType.isNumeric()) {
- dataSet =
- session.executeQueryStatement(
- "select avg(s1),sum(s1) from " + database + ".construct_and_alter_column_type");
- rec = dataSet.next();
- assertEquals(512.5, rec.getFields().get(0).getDoubleV(), 0.001);
- assertEquals(524800.0, rec.getFields().get(1).getDoubleV(), 0.001);
- assertFalse(dataSet.hasNext());
+ break;
+ case DATE:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new String[] {"1970-01-02", "1971-05-28"};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(i, expectedValue[i], unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(
+ String.valueOf(expectedValue[i]), unsupportMinMaxRec.getFields().get(i).toString());
+ }
+ } else {
+ expectedValue = new String[] {"1970-01-02", "1971-05-28", "1970-01-02", "1971-05-28"};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(String.valueOf(expectedValue[i]), rec.getFields().get(i).toString());
+ }
}
- }
+ break;
+ case DOUBLE:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new Integer[] {1, 1024};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(
+ i,
+ genValue(newType, (int) expectedValue[i]),
+ unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ unsupportMinMaxRec.getFields().get(i).getObjectValue(newType));
+ }
+ } else {
+ expectedValue = new Integer[] {1, 1024, 1, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i, genValue(newType, (int) expectedValue[i]), rec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ }
+ break;
+ case BLOB:
+ case STRING:
+ case TEXT:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new Integer[] {1, 1024};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(
+ i,
+ genValue(newType, (int) expectedValue[i]),
+ unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ unsupportMinMaxRec.getFields().get(i).getObjectValue(newType));
+ }
+ } else {
+ expectedValue = new Integer[] {1, 999, 1, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i, genValue(newType, (int) expectedValue[i]), rec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ }
+ break;
+ case FLOAT:
+ case INT64:
+ case TIMESTAMP:
+ case INT32:
+ switch (newType) {
+ case STRING:
+ case TEXT:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new Integer[] {1, 1024};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(
+ i,
+ genValue(newType, (int) expectedValue[i]),
+ unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ unsupportMinMaxRec.getFields().get(i).getObjectValue(newType));
+ }
+ } else {
+ expectedValue = new Integer[] {1, 1024, 1, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i,
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ }
+ break;
+ default:
+ expectedValue = new Integer[] {1, 1024, 1, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i, genValue(newType, (int) expectedValue[i]), rec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ }
+ break;
+ default:
+ break;
+ }
+
+ // test avg and sum
+ if (newType.isNumeric()) {
+ dataSet =
+ session.executeQueryStatement(
+ "select avg(s1),sum(s1) from " + database + ".construct_and_alter_column_type");
+ rec = dataSet.next();
+ assertEquals(512.5, rec.getFields().get(0).getDoubleV(), 0.001);
+ assertEquals(524800.0, rec.getFields().get(1).getDoubleV(), 0.001);
+ assertFalse(dataSet.hasNext());
}
// can use statistics information
@@ -2445,152 +2556,805 @@
private static void standardAccumulatorQueryTest(
ISession session, TSDataType from, TSDataType newType)
throws StatementExecutionException, IoTDBConnectionException {
- if (from == TSDataType.DATE) {
- throw new NotSupportedException("Not supported DATE type.");
+ if (!newType.isCompatible(from)) {
+ log.info(newType + " is Incompatible with " + from + ".");
}
- if (from == TSDataType.BLOB || newType == TSDataType.BLOB) {
- throw new NotSupportedException("Not supported BLOB type.");
- }
- // if (from == TSDataType.BOOLEAN
- // && (newType == TSDataType.STRING || newType == TSDataType.TEXT)) {
- if (from == TSDataType.BOOLEAN && DATA_TYPE_LIST.contains(newType)) {
- SessionDataSet dataSet =
+ RowRecord rec = null;
+ RowRecord unsupportMinMaxRec = null;
+ SessionDataSet dataSet = null;
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ dataSet =
session.executeQueryStatement(
"select first_value(s1),last_value(s1) from "
+ database
+ ".construct_and_alter_column_type");
- RowRecord rec = dataSet.next();
- boolean[] expectedValue = {false, true};
- for (int i = 0; i < 2; i++) {
- if (newType == TSDataType.STRING || newType == TSDataType.TEXT) {
- assertEquals(String.valueOf(expectedValue[i]), rec.getFields().get(i).toString());
- }
- }
+ unsupportMinMaxRec = dataSet.next();
+ Assert.assertNotNull(unsupportMinMaxRec);
} else {
- SessionDataSet dataSet;
- int[] expectedValue;
- int max = 4;
- if (DATA_TYPE_LIST.contains(newType)) {
- dataSet =
- session.executeQueryStatement(
- "select first_value(s1),last_value(s1) from "
- + database
- + ".construct_and_alter_column_type");
- expectedValue = new int[] {1, 1024};
- max = 2;
- } else {
- dataSet =
- session.executeQueryStatement(
- "select min_value(s1),max_value(s1),first_value(s1),last_value(s1) from "
- + database
- + ".construct_and_alter_column_type");
- expectedValue = new int[] {1, 1024, 1, 1024};
- if (newType == TSDataType.BOOLEAN) {
- expectedValue = new int[] {19700102, 19721021, 19700102, 19721021};
- }
- }
- RowRecord rec = dataSet.next();
- if (newType != TSDataType.BOOLEAN) {
- for (int i = 0; i < max; i++) {
- if (newType == TSDataType.BLOB) {
- assertEquals(genValue(newType, expectedValue[i]), rec.getFields().get(i).getBinaryV());
- } else if (newType == TSDataType.DATE) {
- assertEquals(genValue(newType, expectedValue[i]), rec.getFields().get(i).getDateV());
- } else if (newType == TSDataType.STRING || newType == TSDataType.TEXT) {
- if (from == TSDataType.DATE) {
- log.info(
- "i is {}, expected value: {}, actual value: {}",
- i,
- new Binary(genValue(from, expectedValue[i]).toString(), StandardCharsets.UTF_8),
- rec.getFields().get(i).getBinaryV());
- assertEquals(
- new Binary(genValue(from, expectedValue[i]).toString(), StandardCharsets.UTF_8),
- rec.getFields().get(i).getBinaryV());
- } else {
- log.info(
- "i is {}, expected value: {}, actual value: {}",
- i,
- newType.castFromSingleValue(from, genValue(from, expectedValue[i])),
- rec.getFields().get(i).getBinaryV());
- assertEquals(
- newType.castFromSingleValue(from, genValue(from, expectedValue[i])),
- rec.getFields().get(i).getBinaryV());
- }
- } else {
- log.info(
- "i is {}, expected value: {}, actual value: {}",
- i,
- genValue(newType, expectedValue[i]).toString(),
- rec.getFields().get(i).toString());
+ dataSet =
+ session.executeQueryStatement(
+ "select min_value(s1),max_value(s1),first_value(s1),last_value(s1) from "
+ + database
+ + ".construct_and_alter_column_type");
+ rec = dataSet.next();
+ Assert.assertNotNull(rec);
+ }
+
+ Object[] expectedValue;
+ switch (from) {
+ case BOOLEAN:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new Boolean[] {false, true};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(i, expectedValue[i], unsupportMinMaxRec.getFields().get(i).toString());
assertEquals(
- genValue(newType, expectedValue[i]).toString(), rec.getFields().get(i).toString());
+ newType.castFromSingleValue(from, expectedValue[i]),
+ unsupportMinMaxRec.getFields().get(i).getObjectValue(newType));
+ }
+ } else {
+ expectedValue = new Boolean[] {false, true, false, true};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(
+ newType.castFromSingleValue(from, expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
}
}
-
- assertFalse(dataSet.hasNext());
-
- if (newType.isNumeric()) {
- dataSet =
- session.executeQueryStatement(
- "select avg(s1),sum(s1) from " + database + ".construct_and_alter_column_type");
- rec = dataSet.next();
- assertEquals(512.5, rec.getFields().get(0).getDoubleV(), 0.001);
- assertEquals(524800.0, rec.getFields().get(1).getDoubleV(), 0.001);
- assertFalse(dataSet.hasNext());
+ break;
+ case DATE:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new String[] {"1970-01-02", "1971-05-28"};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(i, expectedValue[i], unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(
+ String.valueOf(expectedValue[i]), unsupportMinMaxRec.getFields().get(i).toString());
+ }
+ } else {
+ expectedValue = new String[] {"1970-01-02", "1971-05-28", "1970-01-02", "1971-05-28"};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(String.valueOf(expectedValue[i]), rec.getFields().get(i).toString());
+ }
}
- }
+ break;
+ case DOUBLE:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new Integer[] {1, 1024};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(
+ i,
+ newType.castFromSingleValue(from, genValue(from, (int) expectedValue[i])),
+ unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(
+ newType.castFromSingleValue(from, genValue(from, (int) expectedValue[i])),
+ unsupportMinMaxRec.getFields().get(i).getObjectValue(newType));
+ }
+ } else {
+ expectedValue = new Integer[] {1, 999, 1, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i,
+ newType.castFromSingleValue(from, genValue(from, (int) expectedValue[i])),
+ rec.getFields().get(i).toString());
+ assertEquals(
+ newType.castFromSingleValue(from, genValue(from, (int) expectedValue[i])),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ }
+ break;
+ case BLOB:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new String[] {"1", "1024"};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(i, expectedValue[i], unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(expectedValue[i], unsupportMinMaxRec.getFields().get(i).toString());
+ }
+ } else {
+ expectedValue = new String[] {"1", "999", "1", "1024"};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(expectedValue[i], rec.getFields().get(i).toString());
+ }
+ }
+ break;
+ case STRING:
+ case TEXT:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new Integer[] {1, 1024};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(i, expectedValue[i], unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(
+ new Binary(expectedValue[i].toString(), StandardCharsets.UTF_8),
+ unsupportMinMaxRec.getFields().get(i).getObjectValue(newType));
+ }
+ } else {
+ expectedValue = new Integer[] {1, 999, 1, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(
+ new Binary(expectedValue[i].toString(), StandardCharsets.UTF_8),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ }
+ break;
+ case FLOAT:
+ switch (newType) {
+ case STRING:
+ case TEXT:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new String[] {"1.0", "1024.0"};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(
+ i, expectedValue[i], unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(expectedValue[i], unsupportMinMaxRec.getFields().get(i).toString());
+ }
+ } else {
+ expectedValue = new String[] {"1.0", "999.0", "1.0", "1024.0"};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(expectedValue[i], rec.getFields().get(i).toString());
+ }
+ }
+ break;
+ default:
+ expectedValue = new Integer[] {1, 1024, 1, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i, genValue(newType, (int) expectedValue[i]), rec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ }
+ break;
+ case INT64:
+ case TIMESTAMP:
+ case INT32:
+ switch (newType) {
+ case STRING:
+ case TEXT:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new Integer[] {1, 1024};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(
+ i,
+ genValue(newType, (int) expectedValue[i]),
+ unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ unsupportMinMaxRec.getFields().get(i).getObjectValue(newType));
+ }
+ } else {
+ expectedValue = new Integer[] {1, 999, 1, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i,
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ }
+ break;
+ default:
+ expectedValue = new Integer[] {1, 1024, 1, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i, genValue(newType, (int) expectedValue[i]), rec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ }
+ break;
+ default:
+ break;
+ }
- // can use statistics information
+ // test avg and sum
+ if (newType.isNumeric()) {
dataSet =
session.executeQueryStatement(
- "select count(*) from "
- + database
- + ".construct_and_alter_column_type where time > 0");
+ "select avg(s1),sum(s1) from " + database + ".construct_and_alter_column_type");
rec = dataSet.next();
- assertEquals(1024, rec.getFields().get(0).getLongV());
- assertFalse(dataSet.hasNext());
-
- // can't use statistics information
- dataSet =
- session.executeQueryStatement(
- "select count(*) from "
- + database
- + ".construct_and_alter_column_type where time > 10000");
- rec = dataSet.next();
- assertEquals(0, rec.getFields().get(0).getLongV());
+ assertEquals(512.5, rec.getFields().get(0).getDoubleV(), 0.001);
+ assertEquals(524800.0, rec.getFields().get(1).getDoubleV(), 0.001);
assertFalse(dataSet.hasNext());
}
+
+ // can get statistics information
+ dataSet =
+ session.executeQueryStatement(
+ "select count(*) from " + database + ".construct_and_alter_column_type where time > 0");
+ rec = dataSet.next();
+ assertEquals(1024, rec.getFields().get(0).getLongV());
+ assertFalse(dataSet.hasNext());
+
+ // can't use statistics information
+ dataSet =
+ session.executeQueryStatement(
+ "select count(*) from "
+ + database
+ + ".construct_and_alter_column_type where time > 10000");
+ rec = dataSet.next();
+ assertEquals(0, rec.getFields().get(0).getLongV());
+ assertFalse(dataSet.hasNext());
+ }
+
+ private static void standardAccumulatorQueryByTimeOnlyInvolveOldDataTypeTest(
+ ISession session, TSDataType from, TSDataType newType)
+ throws StatementExecutionException, IoTDBConnectionException {
+ if (!newType.isCompatible(from)) {
+ log.info(newType + " is Incompatible with " + from + ".");
+ }
+
+ RowRecord rec = null;
+ RowRecord unsupportMinMaxRec = null;
+ SessionDataSet dataSet = null;
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ dataSet =
+ session.executeQueryStatement(
+ "select first_value(s1),last_value(s1) from "
+ + database
+ + ".write_and_alter_column_type_write where time <= 512");
+ unsupportMinMaxRec = dataSet.next();
+ Assert.assertNotNull(unsupportMinMaxRec);
+ } else {
+ dataSet =
+ session.executeQueryStatement(
+ "select min_value(s1),max_value(s1),first_value(s1),last_value(s1) from "
+ + database
+ + ".write_and_alter_column_type_write where time <= 512");
+ rec = dataSet.next();
+ Assert.assertNotNull(rec);
+ }
+
+ Object[] expectedValue;
+ switch (from) {
+ case BOOLEAN:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new Boolean[] {false, true};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(i, expectedValue[i], unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(
+ newType.castFromSingleValue(from, expectedValue[i]),
+ unsupportMinMaxRec.getFields().get(i).getObjectValue(newType));
+ }
+ } else {
+ expectedValue = new Boolean[] {false, true, false, true};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(
+ newType.castFromSingleValue(from, expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ }
+ break;
+ case DATE:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new String[] {"1970-01-02", "1971-05-28"};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(i, expectedValue[i], unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(
+ String.valueOf(expectedValue[i]), unsupportMinMaxRec.getFields().get(i).toString());
+ }
+ } else {
+ expectedValue = new String[] {"1970-01-02", "1971-05-28", "1970-01-02", "1971-05-28"};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(String.valueOf(expectedValue[i]), rec.getFields().get(i).toString());
+ }
+ }
+ break;
+ case DOUBLE:
+ case BLOB:
+ case STRING:
+ case TEXT:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new Integer[] {1, 512};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(
+ i,
+ newType.castFromSingleValue(from, genValue(from, (int) expectedValue[i])),
+ unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(
+ newType.castFromSingleValue(from, genValue(from, (int) expectedValue[i])),
+ unsupportMinMaxRec.getFields().get(i).getObjectValue(newType));
+ }
+ } else {
+ expectedValue = new Integer[] {1, 99, 1, 512};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i,
+ newType.castFromSingleValue(from, genValue(from, (int) expectedValue[i])),
+ rec.getFields().get(i).toString());
+ assertEquals(
+ newType.castFromSingleValue(from, genValue(from, (int) expectedValue[i])),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ }
+ break;
+ case FLOAT:
+ case INT64:
+ case TIMESTAMP:
+ case INT32:
+ switch (newType) {
+ case STRING:
+ case TEXT:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new Integer[] {1, 512};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(
+ i,
+ newType.castFromSingleValue(from, genValue(from, (int) expectedValue[i])),
+ unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(
+ newType.castFromSingleValue(from, genValue(from, (int) expectedValue[i])),
+ unsupportMinMaxRec.getFields().get(i).getObjectValue(newType));
+ }
+ } else {
+ expectedValue = new Integer[] {1, 99, 1, 512};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i,
+ newType.castFromSingleValue(from, genValue(from, (int) expectedValue[i])),
+ rec.getFields().get(i).toString());
+ assertEquals(
+ newType.castFromSingleValue(from, genValue(from, (int) expectedValue[i])),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ }
+ break;
+ default:
+ expectedValue = new Integer[] {1, 512, 1, 512};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i,
+ newType.castFromSingleValue(from, genValue(from, (int) expectedValue[i])),
+ rec.getFields().get(i).toString());
+ assertEquals(
+ newType.castFromSingleValue(from, genValue(from, (int) expectedValue[i])),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ }
+ break;
+ default:
+ break;
+ }
+
+ // test avg and sum
+ if (newType.isNumeric()) {
+ dataSet =
+ session.executeQueryStatement(
+ "select avg(s1),sum(s1) from "
+ + database
+ + ".write_and_alter_column_type_write where time <= 512");
+ rec = dataSet.next();
+ assertEquals(256.5, rec.getFields().get(0).getDoubleV(), 0.001);
+ assertEquals(131328.0, rec.getFields().get(1).getDoubleV(), 0.001);
+ assertFalse(dataSet.hasNext());
+ }
+
+ // can get statistics information
+ dataSet =
+ session.executeQueryStatement(
+ "select count(*) from "
+ + database
+ + ".write_and_alter_column_type_write where time <= 512");
+ rec = dataSet.next();
+ assertEquals(512, rec.getFields().get(0).getLongV());
+ assertFalse(dataSet.hasNext());
+ }
+
+ private static void standardAccumulatorQueryByTimeOnlyInvolveNewDataTypeTest(
+ ISession session, TSDataType from, TSDataType newType)
+ throws StatementExecutionException, IoTDBConnectionException {
+ if (!newType.isCompatible(from)) {
+ log.info(newType + " is Incompatible with " + from + ".");
+ }
+
+ RowRecord rec = null;
+ RowRecord unsupportMinMaxRec = null;
+ SessionDataSet dataSet = null;
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ dataSet =
+ session.executeQueryStatement(
+ "select first_value(s1),last_value(s1) from "
+ + database
+ + ".write_and_alter_column_type_write where time > 512");
+ unsupportMinMaxRec = dataSet.next();
+ Assert.assertNotNull(unsupportMinMaxRec);
+ } else {
+ dataSet =
+ session.executeQueryStatement(
+ "select min_value(s1),max_value(s1),first_value(s1),last_value(s1) from "
+ + database
+ + ".write_and_alter_column_type_write where time > 512");
+ rec = dataSet.next();
+ Assert.assertNotNull(rec);
+ }
+
+ Object[] expectedValue;
+ switch (from) {
+ case BOOLEAN:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new Integer[] {513, 1024};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(i, expectedValue[i], unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(
+ newType.castFromSingleValue(from, expectedValue[i]),
+ unsupportMinMaxRec.getFields().get(i).getObjectValue(newType));
+ }
+ } else {
+ expectedValue = new Integer[] {1000, 999, 513, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(
+ newType.castFromSingleValue(from, expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ }
+ break;
+ case DATE:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new Integer[] {513, 1024};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(i, expectedValue[i], unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(
+ String.valueOf(expectedValue[i]), unsupportMinMaxRec.getFields().get(i).toString());
+ }
+ } else {
+ expectedValue = new Integer[] {1000, 999, 513, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(String.valueOf(expectedValue[i]), rec.getFields().get(i).toString());
+ }
+ }
+ break;
+ case DOUBLE:
+ case BLOB:
+ case STRING:
+ case TEXT:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new Integer[] {513, 1024};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(
+ i,
+ genValue(newType, (int) expectedValue[i]),
+ unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ unsupportMinMaxRec.getFields().get(i).getObjectValue(newType));
+ }
+ } else {
+ expectedValue = new Integer[] {1000, 999, 513, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i, genValue(newType, (int) expectedValue[i]), rec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ }
+ break;
+ case FLOAT:
+ case INT64:
+ case TIMESTAMP:
+ case INT32:
+ switch (newType) {
+ case STRING:
+ case TEXT:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new Integer[] {513, 1024};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(
+ i,
+ genValue(newType, (int) expectedValue[i]),
+ unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ unsupportMinMaxRec.getFields().get(i).getObjectValue(newType));
+ }
+ } else {
+ expectedValue = new Integer[] {1000, 999, 513, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i,
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ }
+ break;
+ default:
+ expectedValue = new Integer[] {513, 1024, 513, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i, genValue(newType, (int) expectedValue[i]), rec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ }
+ break;
+ default:
+ break;
+ }
+
+ // test avg and sum
+ if (newType.isNumeric()) {
+ dataSet =
+ session.executeQueryStatement(
+ "select avg(s1),sum(s1) from "
+ + database
+ + ".write_and_alter_column_type_write where time > 512");
+ rec = dataSet.next();
+ assertEquals(768.5, rec.getFields().get(0).getDoubleV(), 0.001);
+ assertEquals(393472.0, rec.getFields().get(1).getDoubleV(), 0.001);
+ assertFalse(dataSet.hasNext());
+ }
+
+ // can get statistics information
+ dataSet =
+ session.executeQueryStatement(
+ "select count(*) from "
+ + database
+ + ".write_and_alter_column_type_write where time > 512");
+ rec = dataSet.next();
+ assertEquals(512, rec.getFields().get(0).getLongV());
+ assertFalse(dataSet.hasNext());
+ }
+
+ private static void standardAccumulatorQueryByTimeInvolveAllDataTypeTest(
+ ISession session, TSDataType from, TSDataType newType)
+ throws StatementExecutionException, IoTDBConnectionException {
+ if (!newType.isCompatible(from)) {
+ log.info(newType + " is Incompatible with " + from + ".");
+ }
+
+ RowRecord rec = null;
+ RowRecord unsupportMinMaxRec = null;
+ SessionDataSet dataSet = null;
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ dataSet =
+ session.executeQueryStatement(
+ "select first_value(s1),last_value(s1) from "
+ + database
+ + ".write_and_alter_column_type_write");
+ unsupportMinMaxRec = dataSet.next();
+ Assert.assertNotNull(unsupportMinMaxRec);
+ } else {
+ dataSet =
+ session.executeQueryStatement(
+ "select min_value(s1),max_value(s1),first_value(s1),last_value(s1) from "
+ + database
+ + ".write_and_alter_column_type_write");
+ rec = dataSet.next();
+ Assert.assertNotNull(rec);
+ }
+
+ Object[] expectedValue;
+ switch (from) {
+ case BOOLEAN:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new String[] {"false", "1024"};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(i, expectedValue[i], unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(
+ newType.castFromSingleValue(from, expectedValue[i]),
+ unsupportMinMaxRec.getFields().get(i).getObjectValue(newType));
+ }
+ } else {
+ expectedValue = new String[] {"1000", "true", "false", "1024"};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(
+ newType.castFromSingleValue(from, expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ }
+ break;
+ case DATE:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new String[] {"1970-01-02", "1024"};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(i, expectedValue[i], unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(
+ String.valueOf(expectedValue[i]), unsupportMinMaxRec.getFields().get(i).toString());
+ }
+ } else {
+ expectedValue = new String[] {"1000", "999", "1970-01-02", "1024"};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(String.valueOf(expectedValue[i]), rec.getFields().get(i).toString());
+ }
+ }
+ break;
+ case DOUBLE:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new String[] {"1.0", "1024"};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(i, expectedValue[i], unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(expectedValue[i], unsupportMinMaxRec.getFields().get(i).toString());
+ }
+ } else {
+ expectedValue = new String[] {"1.0", "999", "1.0", "1024"};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(expectedValue[i], rec.getFields().get(i).toString());
+ }
+ }
+ break;
+ case BLOB:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new String[] {"1", "1024"};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(i, expectedValue[i], unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(expectedValue[i], unsupportMinMaxRec.getFields().get(i).toString());
+ }
+ } else {
+ expectedValue = new String[] {"1", "999", "1", "1024"};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(expectedValue[i], rec.getFields().get(i).toString());
+ }
+ }
+ break;
+ case STRING:
+ case TEXT:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new Integer[] {1, 1024};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(i, expectedValue[i], unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(
+ new Binary(expectedValue[i].toString(), StandardCharsets.UTF_8),
+ unsupportMinMaxRec.getFields().get(i).getObjectValue(newType));
+ }
+ } else {
+ expectedValue = new Integer[] {1, 999, 1, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(
+ new Binary(expectedValue[i].toString(), StandardCharsets.UTF_8),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ }
+ break;
+ case FLOAT:
+ switch (newType) {
+ case STRING:
+ case TEXT:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new String[] {"1.0", "1024"};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(
+ i, expectedValue[i], unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(expectedValue[i], unsupportMinMaxRec.getFields().get(i).toString());
+ }
+ } else {
+ expectedValue = new String[] {"1.0", "999", "1.0", "1024"};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(expectedValue[i], rec.getFields().get(i).toString());
+ }
+ }
+ break;
+ default:
+ expectedValue = new Integer[] {1, 1024, 1, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i, genValue(newType, (int) expectedValue[i]), rec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ }
+ break;
+ case INT64:
+ case TIMESTAMP:
+ case INT32:
+ switch (newType) {
+ case STRING:
+ case TEXT:
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ expectedValue = new Integer[] {1, 1024};
+ for (int i = 0; i < 2; i++) {
+ assertExpectLog(
+ i,
+ genValue(newType, (int) expectedValue[i]),
+ unsupportMinMaxRec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ unsupportMinMaxRec.getFields().get(i).getObjectValue(newType));
+ }
+ } else {
+ expectedValue = new Integer[] {1, 999, 1, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i,
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ }
+ break;
+ default:
+ expectedValue = new Integer[] {1, 1024, 1, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i, genValue(newType, (int) expectedValue[i]), rec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ }
+ break;
+ default:
+ break;
+ }
+
+ // test avg and sum
+ if (newType.isNumeric()) {
+ dataSet =
+ session.executeQueryStatement(
+ "select avg(s1),sum(s1) from " + database + ".write_and_alter_column_type_write");
+ rec = dataSet.next();
+ assertEquals(512.5, rec.getFields().get(0).getDoubleV(), 0.001);
+ assertEquals(524800.0, rec.getFields().get(1).getDoubleV(), 0.001);
+ assertFalse(dataSet.hasNext());
+ }
+
+ // can get statistics information
+ dataSet =
+ session.executeQueryStatement(
+ "select count(*) from " + database + ".write_and_alter_column_type_write");
+ rec = dataSet.next();
+ assertEquals(1024, rec.getFields().get(0).getLongV());
+ assertFalse(dataSet.hasNext());
}
private static void accumulatorQueryTestForDateType(ISession session, TSDataType newType)
throws StatementExecutionException, IoTDBConnectionException {
- if (newType != TSDataType.STRING && newType != TSDataType.TEXT) {
- return;
- }
-
log.info("Test the result that after transfered newType:");
- SessionDataSet dataSet =
- session.executeQueryStatement(
- "select first_value(s1),last_value(s1) from "
- + database
- + ".construct_and_alter_column_type");
- RowRecord rec = dataSet.next();
- int[] expectedValue = {19700102, 19721021};
- if (newType != TSDataType.BOOLEAN) {
+ SessionDataSet dataSet = null;
+ RowRecord rec = null;
+ if (UNSUPPORT_MIN_AND_MAX_QUERY_DATA_TYPE_LIST.contains(newType)) {
+ dataSet =
+ session.executeQueryStatement(
+ "select first_value(s1),last_value(s1) from "
+ + database
+ + ".construct_and_alter_column_type");
+ rec = dataSet.next();
+ Object[] expectedValue = new String[] {"1970-01-02", "1972-10-21"};
for (int i = 0; i < 2; i++) {
- if (newType == TSDataType.STRING || newType == TSDataType.TEXT) {
- log.info(
- "i is {}, expected value: {}, actual value: {}",
- i,
- TSDataType.getDateStringValue(expectedValue[i]),
- // rec.getFields().get(i).getBinaryV().toString());
- rec.getFields().get(i).getStringValue());
- assertEquals(
- TSDataType.getDateStringValue(expectedValue[i]),
- rec.getFields().get(i).getBinaryV().toString());
- }
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(String.valueOf(expectedValue[i]), rec.getFields().get(i).toString());
+ }
+ } else {
+ dataSet =
+ session.executeQueryStatement(
+ "select min_value(s1),max_value(s1),first_value(s1),last_value(s1) from "
+ + database
+ + ".construct_and_alter_column_type");
+ rec = dataSet.next();
+ Object[] expectedValue =
+ new String[] {"1970-01-02", "1972-10-21", "1970-01-02", "1972-10-21"};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(String.valueOf(expectedValue[i]), rec.getFields().get(i).toString());
}
}
@@ -2613,6 +3377,17 @@
assertFalse(dataSet.hasNext());
}
+ private static void assertExpectLog(int i, Object expectedValue, Object actualValue) {
+ StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
+ String callerMethodName = stackTraceElements[2].getMethodName();
+ log.info(
+ "[{}] i is {}, expected value: {}, actual value: {}",
+ callerMethodName,
+ i,
+ expectedValue,
+ actualValue);
+ }
+
private static void writeWithTablets(
long timestamp,
Object dataValue,
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/schema/IoTDBAlterColumnTypeIT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/schema/IoTDBAlterColumnTypeIT.java
index 53f15a1..0903a0a 100644
--- a/integration-test/src/test/java/org/apache/iotdb/relational/it/schema/IoTDBAlterColumnTypeIT.java
+++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/schema/IoTDBAlterColumnTypeIT.java
@@ -96,8 +96,6 @@
private static final Logger log = LoggerFactory.getLogger(IoTDBAlterColumnTypeIT.class);
private static long timeout = -1;
- public static final List<TSDataType> DATA_TYPE_LIST =
- Arrays.asList(TSDataType.BLOB, TSDataType.STRING, TSDataType.TEXT);
@BeforeClass
public static void setUp() throws Exception {
@@ -131,6 +129,8 @@
testAlignDeviceSequenceDataQuery(from, to);
testAlignDeviceUnSequenceDataQuery(from, to);
testAlignDeviceUnSequenceOverlappedDataQuery(from, to);
+
+ doWriteAndAlterWriteForAccumulatorQuery(from, to);
}
}
}
@@ -320,6 +320,75 @@
}
}
+ private void doWriteAndAlterWriteForAccumulatorQuery(TSDataType from, TSDataType to)
+ throws IoTDBConnectionException, StatementExecutionException {
+ try (ITableSession session = EnvFactory.getEnv().getTableSessionConnectionWithDB("test")) {
+ session.executeNonQueryStatement("SET CONFIGURATION enable_unseq_space_compaction='false'");
+ session.executeNonQueryStatement("SET CONFIGURATION enable_seq_space_compaction='false'");
+ if (from == TSDataType.DATE && !to.isCompatible(from)) {
+ throw new NotSupportedException("Not supported DATE type.");
+ }
+
+ // create a table with type of "from"
+ session.executeNonQueryStatement(
+ "CREATE TABLE write_and_alter_column_type_write (s1 " + from + ")");
+
+ // write a sequence tsfile point of "from"
+ Tablet tablet =
+ new Tablet(
+ "write_and_alter_column_type_write",
+ Collections.singletonList("s1"),
+ Collections.singletonList(from),
+ Collections.singletonList(ColumnCategory.FIELD));
+ for (int i = 1; i <= 512; i++) {
+ tablet.addTimestamp(0, i);
+ tablet.addValue("s1", 0, genValue(from, i));
+ session.insert(tablet);
+ tablet.reset();
+ }
+ session.executeNonQueryStatement("FLUSH");
+
+ // alter the type to "to"
+ boolean isCompatible = MetadataUtils.canAlter(from, to);
+ if (isCompatible) {
+ session.executeNonQueryStatement(
+ "ALTER TABLE write_and_alter_column_type_write ALTER COLUMN s1 SET DATA TYPE " + to);
+ } else {
+ try {
+ session.executeNonQueryStatement(
+ "ALTER TABLE write_and_alter_column_type_write ALTER COLUMN s1 SET DATA TYPE " + to);
+ } catch (StatementExecutionException e) {
+ assertEquals(
+ "701: New type " + to + " is not compatible with the existing one " + from,
+ e.getMessage());
+ }
+ }
+
+ // write a sequence tsfile point of "to"
+ tablet =
+ new Tablet(
+ "write_and_alter_column_type_write",
+ Collections.singletonList("s1"),
+ Collections.singletonList(to),
+ Collections.singletonList(ColumnCategory.FIELD));
+ for (int i = 513; i <= 1024; i++) {
+ tablet.addTimestamp(0, i);
+ tablet.addValue("s1", 0, genValue(to, i));
+ session.insert(tablet);
+ tablet.reset();
+ }
+ session.executeNonQueryStatement("FLUSH");
+
+ standardAccumulatorQueryByTimeOnlyInvolveOldDataTypeTest(session, from, to);
+ standardAccumulatorQueryByTimeOnlyInvolveNewDataTypeTest(session, from, to);
+ standardAccumulatorQueryByTimeInvolveAllDataTypeTest(session, from, to);
+ } finally {
+ try (ITableSession session = EnvFactory.getEnv().getTableSessionConnectionWithDB("test")) {
+ session.executeNonQueryStatement("DROP TABLE write_and_alter_column_type_write");
+ }
+ }
+ }
+
@Test
public void testAlterWithoutWrite() throws IoTDBConnectionException, StatementExecutionException {
Set<TSDataType> typesToTest = new HashSet<>();
@@ -1317,26 +1386,15 @@
tablet.reset();
}
- if (DATA_TYPE_LIST.contains(from) || DATA_TYPE_LIST.contains(to)) {
- SessionDataSet dataSet =
- session.executeQueryStatement(
- "select first(s1),last(s1) from construct_and_alter_column_type");
- RowRecord rec = dataSet.next();
- while (rec != null) {
- rec = dataSet.next();
- }
- dataSet.close();
- } else {
- SessionDataSet dataSet =
- session.executeQueryStatement(
- "select min(s1),max(s1),first(s1),last(s1) from construct_and_alter_column_type");
- RowRecord rec = dataSet.next();
- while (rec != null) {
- System.out.println(rec.getFields().toString());
- rec = dataSet.next();
- }
- dataSet.close();
+ SessionDataSet dataSet =
+ session.executeQueryStatement(
+ "select min(s1),max(s1),first(s1),last(s1) from construct_and_alter_column_type");
+ RowRecord rec = dataSet.next();
+ while (rec != null) {
+ System.out.println(rec.getFields().toString());
+ rec = dataSet.next();
}
+ dataSet.close();
try {
standardSelectTest(session, from, to);
@@ -1432,27 +1490,15 @@
}
// session.executeNonQueryStatement("FLUSH");
- if (DATA_TYPE_LIST.contains(from) || DATA_TYPE_LIST.contains(to)) {
- SessionDataSet dataSet =
- session.executeQueryStatement(
- "select first(s1),last(s1) from construct_and_alter_column_type");
- RowRecord rec = dataSet.next();
- while (rec != null) {
- System.out.println(rec.getFields().toString());
- rec = dataSet.next();
- }
- dataSet.close();
- } else {
- SessionDataSet dataSet =
- session.executeQueryStatement(
- "select min(s1),max(s1),first(s1),last(s1) from construct_and_alter_column_type");
- RowRecord rec = dataSet.next();
- while (rec != null) {
- System.out.println(rec.getFields().toString());
- rec = dataSet.next();
- }
- dataSet.close();
+ SessionDataSet dataSet =
+ session.executeQueryStatement(
+ "select min(s1),max(s1),first(s1),last(s1) from construct_and_alter_column_type");
+ RowRecord rec = dataSet.next();
+ while (rec != null) {
+ System.out.println(rec.getFields().toString());
+ rec = dataSet.next();
}
+ dataSet.close();
try {
standardSelectTest(session, from, to);
@@ -1550,27 +1596,15 @@
}
// session.executeNonQueryStatement("FLUSH");
- if (DATA_TYPE_LIST.contains(from) || DATA_TYPE_LIST.contains(to)) {
- SessionDataSet dataSet =
- session.executeQueryStatement(
- "select first(s1),last(s1) from construct_and_alter_column_type");
- RowRecord rec = dataSet.next();
- while (rec != null) {
- System.out.println(rec.getFields().toString());
- rec = dataSet.next();
- }
- dataSet.close();
- } else {
- SessionDataSet dataSet =
- session.executeQueryStatement(
- "select min(s1),max(s1),first(s1),last(s1) from construct_and_alter_column_type");
- RowRecord rec = dataSet.next();
- while (rec != null) {
- System.out.println(rec.getFields().toString());
- rec = dataSet.next();
- }
- dataSet.close();
+ SessionDataSet dataSet =
+ session.executeQueryStatement(
+ "select min(s1),max(s1),first(s1),last(s1) from construct_and_alter_column_type");
+ RowRecord rec = dataSet.next();
+ while (rec != null) {
+ System.out.println(rec.getFields().toString());
+ rec = dataSet.next();
}
+ dataSet.close();
try {
standardSelectTest(session, from, to);
@@ -1964,71 +1998,82 @@
private static void standardAccumulatorQueryTest(ITableSession session, TSDataType newType)
throws StatementExecutionException, IoTDBConnectionException {
- if (newType == TSDataType.DATE) {
- throw new NotSupportedException("Not supported DATE type.");
- }
-
- SessionDataSet dataSet;
- RowRecord rec;
- int[] expectedValue;
- int max = 4;
- if (DATA_TYPE_LIST.contains(newType)) {
- dataSet =
- session.executeQueryStatement(
- "select first(s1),last(s1) from construct_and_alter_column_type");
- rec = dataSet.next();
- expectedValue = new int[] {1, 1024};
- if (newType == TSDataType.STRING
- || newType == TSDataType.TEXT
- || newType == TSDataType.BLOB) {
- // expectedValue[1] = 999;
- } else if (newType == TSDataType.BOOLEAN) {
- expectedValue = new int[] {19700102, 19721021};
- }
- max = 2;
- } else {
- dataSet =
- session.executeQueryStatement(
- "select min(s1),max(s1),first(s1),last(s1) from construct_and_alter_column_type");
- rec = dataSet.next();
- expectedValue = new int[] {1, 1024, 1, 1024};
- if (newType == TSDataType.STRING
- || newType == TSDataType.TEXT
- || newType == TSDataType.BLOB) {
- expectedValue[1] = 999;
- } else if (newType == TSDataType.BOOLEAN) {
- expectedValue = new int[] {19700102, 19721021, 19700102, 19721021};
- }
- }
-
- if (newType != TSDataType.BOOLEAN) {
- for (int i = 0; i < max; i++) {
- if (newType == TSDataType.BLOB) {
- assertEquals(genValue(newType, expectedValue[i]), rec.getFields().get(i).getBinaryV());
- } else if (newType == TSDataType.DATE) {
- assertEquals(genValue(newType, expectedValue[i]), rec.getFields().get(i).getDateV());
- } else {
- log.info(
- "i is {}, expected value: {}, actual value: {}",
- i,
- genValue(newType, expectedValue[i]).toString(),
- rec.getFields().get(i).toString());
- assertEquals(
- genValue(newType, expectedValue[i]).toString(), rec.getFields().get(i).toString());
+ SessionDataSet dataSet =
+ session.executeQueryStatement(
+ "select min(s1),max(s1),first(s1),last(s1) from construct_and_alter_column_type");
+ RowRecord rec = dataSet.next();
+ Object[] expectedValue;
+ switch (newType) {
+ case BOOLEAN:
+ expectedValue = new Boolean[] {false, true, false, true};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(expectedValue[i], rec.getFields().get(i).getObjectValue(newType));
}
- }
+ break;
+ case DATE:
+ expectedValue = new String[] {"1970-01-02", "1971-05-28", "1970-01-02", "1971-05-28"};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(String.valueOf(expectedValue[i]), rec.getFields().get(i).toString());
+ }
+ break;
+ case DOUBLE:
+ expectedValue = new Integer[] {1, 1024, 1, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i, genValue(newType, (int) expectedValue[i]), rec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ case BLOB:
+ case STRING:
+ case TEXT:
+ expectedValue = new Integer[] {1, 999, 1, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i, genValue(newType, (int) expectedValue[i]), rec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ case FLOAT:
+ case INT64:
+ case TIMESTAMP:
+ case INT32:
+ switch (newType) {
+ case STRING:
+ case TEXT:
+ expectedValue = new Integer[] {1, 1024, 1, 1024};
+ break;
+ default:
+ expectedValue = new Integer[] {1, 1024, 1, 1024};
+ break;
+ }
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i, genValue(newType, (int) expectedValue[i]), rec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ default:
+ break;
+ }
+ // test avg and sum
+ if (newType.isNumeric()) {
+ dataSet =
+ session.executeQueryStatement(
+ "select avg(s1),sum(s1) from construct_and_alter_column_type");
+ rec = dataSet.next();
+ assertEquals(512.5, rec.getFields().get(0).getDoubleV(), 0.001);
+ assertEquals(524800.0, rec.getFields().get(1).getDoubleV(), 0.001);
assertFalse(dataSet.hasNext());
-
- if (newType.isNumeric()) {
- dataSet =
- session.executeQueryStatement(
- "select avg(s1),sum(s1) from construct_and_alter_column_type");
- rec = dataSet.next();
- assertEquals(512.5, rec.getFields().get(0).getDoubleV(), 0.001);
- assertEquals(524800.0, rec.getFields().get(1).getDoubleV(), 0.001);
- assertFalse(dataSet.hasNext());
- }
}
// can use statistics information
@@ -2051,143 +2096,444 @@
private static void standardAccumulatorQueryTest(
ITableSession session, TSDataType from, TSDataType newType)
throws StatementExecutionException, IoTDBConnectionException {
- if (from == TSDataType.DATE) {
- throw new NotSupportedException("Not supported DATE type.");
+ if (!newType.isCompatible(from)) {
+ log.info(newType + " is Incompatible with " + from + ".");
}
- if (from == TSDataType.BLOB || newType == TSDataType.BLOB) {
- throw new NotSupportedException("Not supported BLOB type.");
- }
- if (from == TSDataType.BOOLEAN && DATA_TYPE_LIST.contains(newType)) {
- SessionDataSet dataSet =
- session.executeQueryStatement(
- "select first(s1),last(s1) from construct_and_alter_column_type");
- RowRecord rec = dataSet.next();
- boolean[] expectedValue = {false, true};
- for (int i = 0; i < 2; i++) {
- if (newType == TSDataType.STRING || newType == TSDataType.TEXT) {
+
+ SessionDataSet dataSet =
+ session.executeQueryStatement(
+ "select min(s1),max(s1),first(s1),last(s1) from construct_and_alter_column_type");
+ RowRecord rec = dataSet.next();
+ Object[] expectedValue;
+ switch (from) {
+ case BOOLEAN:
+ expectedValue = new Boolean[] {false, true, false, true};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(
+ newType.castFromSingleValue(from, expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ case DATE:
+ expectedValue = new String[] {"1970-01-02", "1971-05-28", "1970-01-02", "1971-05-28"};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
assertEquals(String.valueOf(expectedValue[i]), rec.getFields().get(i).toString());
}
- }
- } else {
- SessionDataSet dataSet;
- int[] expectedValue;
- int max = 4;
- if (DATA_TYPE_LIST.contains(newType)) {
- dataSet =
- session.executeQueryStatement(
- "select first(s1),last(s1) from construct_and_alter_column_type");
- expectedValue = new int[] {1, 1024};
- max = 2;
- } else {
- dataSet =
- session.executeQueryStatement(
- "select min(s1),max(s1),first(s1),last(s1) from construct_and_alter_column_type");
- expectedValue = new int[] {1, 1024, 1, 1024};
- if (newType == TSDataType.STRING
- || newType == TSDataType.TEXT
- || newType == TSDataType.BLOB) {
- expectedValue[1] = 999;
- } else if (newType == TSDataType.BOOLEAN) {
- expectedValue = new int[] {19700102, 19721021, 19700102, 19721021};
+ break;
+ case DOUBLE:
+ expectedValue = new Integer[] {1, 999, 1, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i,
+ newType.castFromSingleValue(from, genValue(from, (int) expectedValue[i])),
+ rec.getFields().get(i).toString());
+ assertEquals(
+ newType.castFromSingleValue(from, genValue(from, (int) expectedValue[i])),
+ rec.getFields().get(i).getObjectValue(newType));
}
- }
-
- RowRecord rec = dataSet.next();
- if (newType != TSDataType.BOOLEAN) {
- for (int i = 0; i < max; i++) {
- if (newType == TSDataType.BLOB) {
- assertEquals(genValue(newType, expectedValue[i]), rec.getFields().get(i).getBinaryV());
- } else if (newType == TSDataType.DATE) {
- assertEquals(genValue(newType, expectedValue[i]), rec.getFields().get(i).getDateV());
- } else if (newType == TSDataType.STRING || newType == TSDataType.TEXT) {
- if (from == TSDataType.DATE) {
- log.info(
- "i is {}, expected value: {}, actual value: {}",
- i,
- new Binary(genValue(from, expectedValue[i]).toString(), StandardCharsets.UTF_8),
- rec.getFields().get(i).getBinaryV());
- assertEquals(
- new Binary(genValue(from, expectedValue[i]).toString(), StandardCharsets.UTF_8),
- rec.getFields().get(i).getBinaryV());
- } else {
- log.info(
- "i is {}, expected value: {}, actual value: {}",
- i,
- newType.castFromSingleValue(from, genValue(from, expectedValue[i])),
- rec.getFields().get(i).getBinaryV());
- assertEquals(
- newType.castFromSingleValue(from, genValue(from, expectedValue[i])),
- rec.getFields().get(i).getBinaryV());
+ break;
+ case BLOB:
+ expectedValue = new String[] {"1", "999", "1", "1024"};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(expectedValue[i], rec.getFields().get(i).toString());
+ }
+ break;
+ case STRING:
+ case TEXT:
+ expectedValue = new Integer[] {1, 999, 1, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(
+ new Binary(expectedValue[i].toString(), StandardCharsets.UTF_8),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ case FLOAT:
+ switch (newType) {
+ case STRING:
+ case TEXT:
+ expectedValue = new String[] {"1.0", "999.0", "1.0", "1024.0"};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(expectedValue[i], rec.getFields().get(i).toString());
}
- } else {
- log.info(
- "i is {}, expected value: {}, actual value: {}",
- i,
- genValue(newType, expectedValue[i]).toString(),
- rec.getFields().get(i).toString());
- assertEquals(
- genValue(newType, expectedValue[i]).toString(), rec.getFields().get(i).toString());
- }
+ break;
+ default:
+ expectedValue = new Integer[] {1, 1024, 1, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i, genValue(newType, (int) expectedValue[i]), rec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
}
-
- assertFalse(dataSet.hasNext());
-
- if (newType.isNumeric()) {
- dataSet =
- session.executeQueryStatement(
- "select avg(s1),sum(s1) from construct_and_alter_column_type");
- rec = dataSet.next();
- assertEquals(512.5, rec.getFields().get(0).getDoubleV(), 0.001);
- assertEquals(524800.0, rec.getFields().get(1).getDoubleV(), 0.001);
- assertFalse(dataSet.hasNext());
+ break;
+ case INT64:
+ case TIMESTAMP:
+ case INT32:
+ switch (newType) {
+ case STRING:
+ case TEXT:
+ expectedValue = new Integer[] {1, 999, 1, 1024};
+ break;
+ default:
+ expectedValue = new Integer[] {1, 1024, 1, 1024};
+ break;
}
- }
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i, genValue(newType, (int) expectedValue[i]), rec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ default:
+ break;
+ }
- // can use statistics information
+ // test avg and sum
+ if (newType.isNumeric()) {
dataSet =
session.executeQueryStatement(
- "select count(*) from construct_and_alter_column_type where time > 0");
+ "select avg(s1),sum(s1) from construct_and_alter_column_type");
rec = dataSet.next();
- assertEquals(1024, rec.getFields().get(0).getLongV());
- assertFalse(dataSet.hasNext());
-
- // can't use statistics information
- dataSet =
- session.executeQueryStatement(
- "select count(*) from construct_and_alter_column_type where time > 10000");
- rec = dataSet.next();
- assertEquals(0, rec.getFields().get(0).getLongV());
+ assertEquals(512.5, rec.getFields().get(0).getDoubleV(), 0.001);
+ assertEquals(524800.0, rec.getFields().get(1).getDoubleV(), 0.001);
assertFalse(dataSet.hasNext());
}
+
+ // can get statistics information
+ dataSet =
+ session.executeQueryStatement(
+ "select count(*) from construct_and_alter_column_type where time > 0");
+ rec = dataSet.next();
+ assertEquals(1024, rec.getFields().get(0).getLongV());
+ assertFalse(dataSet.hasNext());
+
+ // can't use statistics information
+ dataSet =
+ session.executeQueryStatement(
+ "select count(*) from construct_and_alter_column_type where time > 10000");
+ rec = dataSet.next();
+ assertEquals(0, rec.getFields().get(0).getLongV());
+ assertFalse(dataSet.hasNext());
+ }
+
+ private static void standardAccumulatorQueryByTimeOnlyInvolveOldDataTypeTest(
+ ITableSession session, TSDataType from, TSDataType newType)
+ throws StatementExecutionException, IoTDBConnectionException {
+ if (!newType.isCompatible(from)) {
+ log.info(newType + " is Incompatible with " + from + ".");
+ }
+
+ SessionDataSet dataSet =
+ session.executeQueryStatement(
+ "select min(s1),max(s1),first(s1),last(s1) from write_and_alter_column_type_write where time <= 512");
+ RowRecord rec = dataSet.next();
+ Object[] expectedValue;
+ switch (from) {
+ case BOOLEAN:
+ expectedValue = new Boolean[] {false, true, false, true};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(
+ newType.castFromSingleValue(from, expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ case DATE:
+ expectedValue = new String[] {"1970-01-02", "1971-05-28", "1970-01-02", "1971-05-28"};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(String.valueOf(expectedValue[i]), rec.getFields().get(i).toString());
+ }
+ break;
+ case DOUBLE:
+ case BLOB:
+ case STRING:
+ case TEXT:
+ expectedValue = new Integer[] {1, 99, 1, 512};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i,
+ newType.castFromSingleValue(from, genValue(from, (int) expectedValue[i])),
+ rec.getFields().get(i).toString());
+ assertEquals(
+ newType.castFromSingleValue(from, genValue(from, (int) expectedValue[i])),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ case FLOAT:
+ case INT64:
+ case TIMESTAMP:
+ case INT32:
+ switch (newType) {
+ case STRING:
+ case TEXT:
+ expectedValue = new Integer[] {1, 99, 1, 512};
+ break;
+ default:
+ expectedValue = new Integer[] {1, 512, 1, 512};
+ break;
+ }
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i,
+ newType.castFromSingleValue(from, genValue(from, (int) expectedValue[i])),
+ rec.getFields().get(i).toString());
+ assertEquals(
+ newType.castFromSingleValue(from, genValue(from, (int) expectedValue[i])),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ default:
+ break;
+ }
+
+ // test avg and sum
+ if (newType.isNumeric()) {
+ dataSet =
+ session.executeQueryStatement(
+ "select avg(s1),sum(s1) from write_and_alter_column_type_write where time <= 512");
+ rec = dataSet.next();
+ assertEquals(256.5, rec.getFields().get(0).getDoubleV(), 0.001);
+ assertEquals(131328.0, rec.getFields().get(1).getDoubleV(), 0.001);
+ assertFalse(dataSet.hasNext());
+ }
+
+ // can get statistics information
+ dataSet =
+ session.executeQueryStatement(
+ "select count(*) from write_and_alter_column_type_write where time <= 512");
+ rec = dataSet.next();
+ assertEquals(512, rec.getFields().get(0).getLongV());
+ assertFalse(dataSet.hasNext());
+ }
+
+ private static void standardAccumulatorQueryByTimeOnlyInvolveNewDataTypeTest(
+ ITableSession session, TSDataType from, TSDataType newType)
+ throws StatementExecutionException, IoTDBConnectionException {
+ if (!newType.isCompatible(from)) {
+ log.info(newType + " is Incompatible with " + from + ".");
+ }
+
+ SessionDataSet dataSet =
+ session.executeQueryStatement(
+ "select min(s1),max(s1),first(s1),last(s1) from write_and_alter_column_type_write where time > 512");
+ RowRecord rec = dataSet.next();
+ Object[] expectedValue;
+ switch (from) {
+ case BOOLEAN:
+ expectedValue = new Integer[] {1000, 999, 513, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(
+ newType.castFromSingleValue(from, expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ case DATE:
+ expectedValue = new Integer[] {1000, 999, 513, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(String.valueOf(expectedValue[i]), rec.getFields().get(i).toString());
+ }
+ break;
+ case DOUBLE:
+ case BLOB:
+ case STRING:
+ case TEXT:
+ expectedValue = new Integer[] {1000, 999, 513, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i, genValue(newType, (int) expectedValue[i]), rec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ case FLOAT:
+ case INT64:
+ case TIMESTAMP:
+ case INT32:
+ switch (newType) {
+ case STRING:
+ case TEXT:
+ expectedValue = new Integer[] {1000, 999, 513, 1024};
+ break;
+ default:
+ expectedValue = new Integer[] {513, 1024, 513, 1024};
+ break;
+ }
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i, genValue(newType, (int) expectedValue[i]), rec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ default:
+ break;
+ }
+
+ // test avg and sum
+ if (newType.isNumeric()) {
+ dataSet =
+ session.executeQueryStatement(
+ "select avg(s1),sum(s1) from write_and_alter_column_type_write where time > 512");
+ rec = dataSet.next();
+ assertEquals(768.5, rec.getFields().get(0).getDoubleV(), 0.001);
+ assertEquals(393472.0, rec.getFields().get(1).getDoubleV(), 0.001);
+ assertFalse(dataSet.hasNext());
+ }
+
+ // can get statistics information
+ dataSet =
+ session.executeQueryStatement(
+ "select count(*) from write_and_alter_column_type_write where time > 512");
+ rec = dataSet.next();
+ assertEquals(512, rec.getFields().get(0).getLongV());
+ assertFalse(dataSet.hasNext());
+ }
+
+ private static void standardAccumulatorQueryByTimeInvolveAllDataTypeTest(
+ ITableSession session, TSDataType from, TSDataType newType)
+ throws StatementExecutionException, IoTDBConnectionException {
+ if (!newType.isCompatible(from)) {
+ log.info(newType + " is Incompatible with " + from + ".");
+ }
+
+ SessionDataSet dataSet =
+ session.executeQueryStatement(
+ "select min(s1),max(s1),first(s1),last(s1) from write_and_alter_column_type_write");
+ RowRecord rec = dataSet.next();
+ Object[] expectedValue;
+ switch (from) {
+ case BOOLEAN:
+ expectedValue = new String[] {"1000", "true", "false", "1024"};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(
+ newType.castFromSingleValue(from, expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ case DATE:
+ expectedValue = new String[] {"1000", "999", "1970-01-02", "1024"};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(String.valueOf(expectedValue[i]), rec.getFields().get(i).toString());
+ }
+ break;
+ case DOUBLE:
+ expectedValue = new String[] {"1.0", "999", "1.0", "1024"};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(expectedValue[i], rec.getFields().get(i).toString());
+ }
+ break;
+ case BLOB:
+ expectedValue = new String[] {"1", "999", "1", "1024"};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(expectedValue[i], rec.getFields().get(i).toString());
+ }
+ break;
+ case STRING:
+ case TEXT:
+ expectedValue = new Integer[] {1, 999, 1, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(
+ new Binary(expectedValue[i].toString(), StandardCharsets.UTF_8),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ case FLOAT:
+ switch (newType) {
+ case STRING:
+ case TEXT:
+ expectedValue = new String[] {"1.0", "999", "1.0", "1024"};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(expectedValue[i], rec.getFields().get(i).toString());
+ }
+ break;
+ default:
+ expectedValue = new Integer[] {1, 1024, 1, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i, genValue(newType, (int) expectedValue[i]), rec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ }
+ break;
+ case INT64:
+ case TIMESTAMP:
+ case INT32:
+ switch (newType) {
+ case STRING:
+ case TEXT:
+ expectedValue = new Integer[] {1, 999, 1, 1024};
+ break;
+ default:
+ expectedValue = new Integer[] {1, 1024, 1, 1024};
+ break;
+ }
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
+ i, genValue(newType, (int) expectedValue[i]), rec.getFields().get(i).toString());
+ assertEquals(
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
+ }
+ break;
+ default:
+ break;
+ }
+
+ // test avg and sum
+ if (newType.isNumeric()) {
+ dataSet =
+ session.executeQueryStatement(
+ "select avg(s1),sum(s1) from write_and_alter_column_type_write");
+ rec = dataSet.next();
+ assertEquals(512.5, rec.getFields().get(0).getDoubleV(), 0.001);
+ assertEquals(524800.0, rec.getFields().get(1).getDoubleV(), 0.001);
+ assertFalse(dataSet.hasNext());
+ }
+
+ // can get statistics information
+ dataSet =
+ session.executeQueryStatement("select count(*) from write_and_alter_column_type_write");
+ rec = dataSet.next();
+ assertEquals(1024, rec.getFields().get(0).getLongV());
+ assertFalse(dataSet.hasNext());
}
private static void accumulatorQueryTestForDateType(ITableSession session, TSDataType newType)
throws StatementExecutionException, IoTDBConnectionException {
- if (newType != TSDataType.STRING && newType != TSDataType.TEXT) {
- return;
- }
-
log.info("Test the result that after transfered newType:");
SessionDataSet dataSet =
session.executeQueryStatement(
- "select first(s1),last(s1) from construct_and_alter_column_type");
+ "select min(s1),max(s1),first(s1),last(s1) from construct_and_alter_column_type");
RowRecord rec = dataSet.next();
- int[] expectedValue = {19700102, 19721021};
- if (newType != TSDataType.BOOLEAN) {
- for (int i = 0; i < 2; i++) {
- if (newType == TSDataType.STRING || newType == TSDataType.TEXT) {
- log.info(
- "i is {}, expected value: {}, actual value: {}",
- i,
- TSDataType.getDateStringValue(expectedValue[i]),
- // rec.getFields().get(i).getBinaryV().toString());
- rec.getFields().get(i).getStringValue());
- assertEquals(
- TSDataType.getDateStringValue(expectedValue[i]),
- rec.getFields().get(i).getBinaryV().toString());
- }
- }
+ Object[] expectedValue = new String[] {"1970-01-02", "1972-10-21", "1970-01-02", "1972-10-21"};
+
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(i, expectedValue[i], rec.getFields().get(i).toString());
+ assertEquals(String.valueOf(expectedValue[i]), rec.getFields().get(i).toString());
}
// can use statistics information
@@ -2207,6 +2553,17 @@
assertFalse(dataSet.hasNext());
}
+ private static void assertExpectLog(int i, Object expectedValue, Object actualValue) {
+ StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
+ String callerMethodName = stackTraceElements[2].getMethodName();
+ log.info(
+ "[{}] i is {}, expected value: {}, actual value: {}",
+ callerMethodName,
+ i,
+ expectedValue,
+ actualValue);
+ }
+
private static void writeWithTablets(
long timestamp,
Object dataValue,
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/FileLoaderUtils.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/FileLoaderUtils.java
index 70f3ce5..9b341dc 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/FileLoaderUtils.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/FileLoaderUtils.java
@@ -472,10 +472,10 @@
(AbstractAlignedChunkMetadata) chunkMetaData;
for (int i = 0; i < alignedChunkMetadata.getValueChunkMetadataList().size(); i++) {
if (alignedChunkMetadata.getValueChunkMetadataList().get(i) != null) {
- if (!SchemaUtils.isUsingSameColumn(
+ if (!SchemaUtils.isUsingSameStatistics(
alignedChunkMetadata.getValueChunkMetadataList().get(i).getDataType(),
targetDataTypeList.get(i))
- && targetDataTypeList.get(i).equals(TSDataType.STRING)) {
+ && !SchemaUtils.canUseStatisticsAfterAlter(targetDataTypeList.get(i))) {
isModified = true;
alignedChunkMetadata.getValueChunkMetadataList().get(i).setModified(true);
}
@@ -484,8 +484,8 @@
IChunkLoader chunkLoader = alignedChunkMetadata.getChunkLoader();
chunkReader = chunkLoader.getChunkReader(alignedChunkMetadata, globalTimeFilter);
} else {
- if (!SchemaUtils.isUsingSameColumn(chunkMetaData.getDataType(), targetDataTypeList.get(0))
- && targetDataTypeList.get(0).equals(TSDataType.STRING)) {
+ if (!SchemaUtils.isUsingSameStatistics(chunkMetaData.getDataType(), targetDataTypeList.get(0))
+ && !SchemaUtils.canUseStatisticsAfterAlter(targetDataTypeList.get(0))) {
isModified = true;
chunkMetaData.setModified(true);
}
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/SeriesScanUtil.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/SeriesScanUtil.java
index a44a43d..1e1cffb 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/SeriesScanUtil.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/source/SeriesScanUtil.java
@@ -511,18 +511,18 @@
(AbstractAlignedChunkMetadata) chunkMetadata;
for (int i = 0; i < alignedChunkMetadata.getValueChunkMetadataList().size(); i++) {
if ((alignedChunkMetadata.getValueChunkMetadataList().get(i) != null)
- && !SchemaUtils.isUsingSameColumn(
+ && !SchemaUtils.isUsingSameStatistics(
alignedChunkMetadata.getValueChunkMetadataList().get(i).getDataType(),
getTsDataTypeList().get(i))
- && getTsDataTypeList().get(i).equals(TSDataType.STRING)) {
+ && !SchemaUtils.canUseStatisticsAfterAlter(getTsDataTypeList().get(i))) {
alignedChunkMetadata.getValueChunkMetadataList().get(i).setModified(true);
}
}
chunkMetadata = alignedChunkMetadata;
} else if (chunkMetadata instanceof ChunkMetadata) {
- if (!SchemaUtils.isUsingSameColumn(
+ if (!SchemaUtils.isUsingSameStatistics(
chunkMetadata.getDataType(), getTsDataTypeList().get(0))
- && getTsDataTypeList().get(0).equals(TSDataType.STRING)) {
+ && !SchemaUtils.canUseStatisticsAfterAlter(getTsDataTypeList().get(0))) {
chunkMetadata.setModified(true);
}
}
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/utils/SchemaUtils.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/utils/SchemaUtils.java
index e1d1aa5..6044b23 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/utils/SchemaUtils.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/utils/SchemaUtils.java
@@ -24,6 +24,7 @@
import org.apache.iotdb.db.queryengine.plan.statement.component.Ordering;
import org.apache.iotdb.db.utils.constant.SqlConstant;
+import com.google.common.collect.ImmutableSet;
import org.apache.tsfile.enums.TSDataType;
import org.apache.tsfile.file.metadata.AbstractAlignedChunkMetadata;
import org.apache.tsfile.file.metadata.AbstractAlignedTimeSeriesMetadata;
@@ -46,12 +47,16 @@
import java.util.List;
import java.util.Map;
import java.util.Objects;
+import java.util.Set;
import static org.apache.iotdb.db.queryengine.execution.operator.AggregationUtil.addPartialSuffix;
public class SchemaUtils {
private static final Map<TSDataType, Class> dataTypeColumnClassMap;
+ private static final Map<TSDataType, Class> dataTypeColumnStatisticsClassMap;
+ private static final Set<TSDataType> canNotUseStatisticAfterAlterClassSet =
+ ImmutableSet.of(TSDataType.STRING, TSDataType.TEXT, TSDataType.BLOB);
public static final Logger logger = LoggerFactory.getLogger(SchemaUtils.class);
private static final Binary EMPTY_BINARY = new Binary("", StandardCharsets.UTF_8);
@@ -66,6 +71,13 @@
dataTypeColumnClassMap.put(TSDataType.STRING, BinaryColumn.class);
dataTypeColumnClassMap.put(TSDataType.BLOB, BinaryColumn.class);
dataTypeColumnClassMap.put(TSDataType.TEXT, BinaryColumn.class);
+
+ dataTypeColumnStatisticsClassMap = new HashMap<>();
+ dataTypeColumnStatisticsClassMap.put(TSDataType.INT32, IntColumn.class);
+ dataTypeColumnStatisticsClassMap.put(TSDataType.DATE, IntColumn.class);
+
+ dataTypeColumnStatisticsClassMap.put(TSDataType.INT64, LongColumn.class);
+ dataTypeColumnStatisticsClassMap.put(TSDataType.TIMESTAMP, LongColumn.class);
}
private SchemaUtils() {}
@@ -294,17 +306,38 @@
if (originalDataType == dataType) {
return true;
}
+ if (!dataTypeColumnClassMap.containsKey(originalDataType)
+ || !dataTypeColumnClassMap.containsKey(dataType)) {
+ return false;
+ }
return Objects.equals(
dataTypeColumnClassMap.get(originalDataType), dataTypeColumnClassMap.get(dataType));
}
+ public static boolean isUsingSameStatistics(TSDataType originalDataType, TSDataType dataType) {
+ if (originalDataType == dataType) {
+ return true;
+ }
+ if (!dataTypeColumnStatisticsClassMap.containsKey(originalDataType)
+ || !dataTypeColumnStatisticsClassMap.containsKey(dataType)) {
+ return false;
+ }
+ return Objects.equals(
+ dataTypeColumnStatisticsClassMap.get(originalDataType),
+ dataTypeColumnStatisticsClassMap.get(dataType));
+ }
+
+ public static boolean canUseStatisticsAfterAlter(TSDataType dataType) {
+ return !canNotUseStatisticAfterAlterClassSet.contains(dataType);
+ }
+
public static void changeMetadataModified(
TimeseriesMetadata timeseriesMetadata, TSDataType targetDataType) {
if (timeseriesMetadata == null) {
return;
}
- if (!SchemaUtils.isUsingSameColumn(timeseriesMetadata.getTsDataType(), targetDataType)
- && ((targetDataType == TSDataType.STRING) || (targetDataType == TSDataType.TEXT))) {
+ if (!SchemaUtils.isUsingSameStatistics(timeseriesMetadata.getTsDataType(), targetDataType)
+ && !SchemaUtils.canUseStatisticsAfterAlter(targetDataType)) {
timeseriesMetadata.setModified(true);
List<IChunkMetadata> chunkMetadataList = timeseriesMetadata.getChunkMetadataList();
if (chunkMetadataList != null) {
@@ -328,10 +361,9 @@
for (TimeseriesMetadata timeseriesMetadata :
alignedTimeSeriesMetadata.getValueTimeseriesMetadataList()) {
if ((timeseriesMetadata != null)
- && !SchemaUtils.isUsingSameColumn(
+ && !SchemaUtils.isUsingSameStatistics(
timeseriesMetadata.getTsDataType(), targetDataTypeList.get(i))
- && ((targetDataTypeList.get(i) == TSDataType.STRING)
- || (targetDataTypeList.get(i) == TSDataType.TEXT))) {
+ && !SchemaUtils.canUseStatisticsAfterAlter(targetDataTypeList.get(i))) {
timeseriesMetadata.setModified(true);
alignedTimeSeriesMetadata.setModified(true);
List<IChunkMetadata> chunkMetadataList = timeseriesMetadata.getChunkMetadataList();
@@ -353,8 +385,8 @@
return;
}
- if (!SchemaUtils.isUsingSameColumn(timeseriesMetadata.getTsDataType(), targetDataType)
- && ((targetDataType == TSDataType.STRING) || (targetDataType == TSDataType.TEXT))) {
+ if (!SchemaUtils.isUsingSameStatistics(timeseriesMetadata.getTsDataType(), targetDataType)
+ && !SchemaUtils.canUseStatisticsAfterAlter(targetDataType)) {
timeseriesMetadata.setModified(true);
List<IChunkMetadata> chunkMetadataList = timeseriesMetadata.getChunkMetadataList();
if (chunkMetadataList != null) {
@@ -372,8 +404,8 @@
if (chunkMetadata == null) {
return;
}
- if (!SchemaUtils.isUsingSameColumn(sourceDataType, targetDataType)
- && ((targetDataType == TSDataType.STRING) || (targetDataType == TSDataType.TEXT))) {
+ if (!SchemaUtils.isUsingSameStatistics(sourceDataType, targetDataType)
+ && !SchemaUtils.canUseStatisticsAfterAlter(targetDataType)) {
chunkMetadata.setModified(true);
}
}
@@ -388,9 +420,9 @@
int i = 0;
for (IChunkMetadata iChunkMetadata : chunkMetadata.getValueChunkMetadataList()) {
if ((iChunkMetadata != null)
- && !SchemaUtils.isUsingSameColumn(sourceDataType, targetDataTypeList.get(i))
- && ((targetDataTypeList.get(i) == TSDataType.STRING)
- || (targetDataTypeList.get(i) == TSDataType.TEXT))) {
+ && !SchemaUtils.isUsingSameStatistics(
+ iChunkMetadata.getDataType(), targetDataTypeList.get(i))
+ && !SchemaUtils.canUseStatisticsAfterAlter(targetDataTypeList.get(i))) {
iChunkMetadata.setModified(true);
chunkMetadata.setModified(true);
}
