This is an automated email from the ASF dual-hosted git repository.
jiangtian pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/iotdb.git
The following commit(s) were added to refs/heads/master by this push:
new f445132b2ee 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)
f445132b2ee is described below
commit f445132b2ee00787dab1bec2e99576a783bb5afb
Author: libo <[email protected]>
AuthorDate: Mon Feb 2 15:44:24 2026 +0800
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.
---
.../db/it/schema/IoTDBAlterTimeSeriesTypeIT.java | 1399 +++++++++++++++-----
.../it/schema/IoTDBAlterColumnTypeIT.java | 805 +++++++----
.../execution/operator/source/FileLoaderUtils.java | 8 +-
.../execution/operator/source/SeriesScanUtil.java | 8 +-
.../org/apache/iotdb/db/utils/SchemaUtils.java | 56 +-
5 files changed, 1720 insertions(+), 556 deletions(-)
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 d199dded371..3effc3a8b83 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 @@ public class IoTDBAlterTimeSeriesTypeIT {
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 @@ public class IoTDBAlterTimeSeriesTypeIT {
testAlignDeviceSequenceDataQuery(from, to);
testAlignDeviceUnSequenceDataQuery(from, to);
testAlignDeviceUnSequenceOverlappedDataQuery(from, to);
+
+ doWriteAndAlterWriteForAccumulatorQuery(from, to);
}
}
}
@@ -295,7 +295,8 @@ public class IoTDBAlterTimeSeriesTypeIT {
}
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 @@ public class IoTDBAlterTimeSeriesTypeIT {
}
}
+ 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 @@ public class IoTDBAlterTimeSeriesTypeIT {
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 @@ public class IoTDBAlterTimeSeriesTypeIT {
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 @@ public class IoTDBAlterTimeSeriesTypeIT {
}
// 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 @@ public class IoTDBAlterTimeSeriesTypeIT {
}
// 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 @@ public class IoTDBAlterTimeSeriesTypeIT {
}
// 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 @@ public class IoTDBAlterTimeSeriesTypeIT {
}
// 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 @@ public class IoTDBAlterTimeSeriesTypeIT {
"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 @@ public class IoTDBAlterTimeSeriesTypeIT {
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};
+ 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(
+ 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));
+ }
}
- 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};
+ 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());
+ }
}
- }
-
- 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: {}",
+ 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, expectedValue[i]).toString(),
- rec.getFields().get(i).toString());
+ genValue(newType, (int) expectedValue[i]),
+ unsupportMinMaxRec.getFields().get(i).toString());
assertEquals(
- genValue(newType, expectedValue[i]).toString(),
rec.getFields().get(i).toString());
+ 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));
}
}
-
- 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 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 @@ public class IoTDBAlterTimeSeriesTypeIT {
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};
+ 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(
+ 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));
+ }
}
- }
- 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());
+ 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(
- new Binary(genValue(from, expectedValue[i]).toString(),
StandardCharsets.UTF_8),
- rec.getFields().get(i).getBinaryV());
+ 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 {
- log.info(
- "i is {}, expected value: {}, actual value: {}",
- i,
- newType.castFromSingleValue(from, genValue(from,
expectedValue[i])),
- rec.getFields().get(i).getBinaryV());
+ 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(
- newType.castFromSingleValue(from, genValue(from,
expectedValue[i])),
- rec.getFields().get(i).getBinaryV());
+ genValue(newType, (int) expectedValue[i]),
+ rec.getFields().get(i).getObjectValue(newType));
}
- } else {
- log.info(
- "i is {}, expected value: {}, actual value: {}",
+ 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 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,
- genValue(newType, expectedValue[i]).toString(),
+ newType.castFromSingleValue(from, genValue(from, (int)
expectedValue[i])),
rec.getFields().get(i).toString());
assertEquals(
- genValue(newType, expectedValue[i]).toString(),
rec.getFields().get(i).toString());
+ 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;
+ }
- assertFalse(dataSet.hasNext());
+ // 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);
+ }
- 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());
+ 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;
+ }
- // can use statistics information
+ // test avg and sum
+ if (newType.isNumeric()) {
dataSet =
session.executeQueryStatement(
- "select count(*) from "
+ "select avg(s1),sum(s1) from "
+ database
- + ".construct_and_alter_column_type where time > 0");
+ + ".write_and_alter_column_type_write where time > 512");
rec = dataSet.next();
- assertEquals(1024, rec.getFields().get(0).getLongV());
+ 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 + ".");
+ }
- // can't use statistics information
+ 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 count(*) from "
+ "select
min_value(s1),max_value(s1),first_value(s1),last_value(s1) from "
+ database
- + ".construct_and_alter_column_type where time > 10000");
+ + ".write_and_alter_column_type_write");
rec = dataSet.next();
- assertEquals(0, rec.getFields().get(0).getLongV());
+ 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 @@ public class IoTDBAlterTimeSeriesTypeIT {
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 53f15a192e8..0903a0a3a0d 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 @@ public class IoTDBAlterColumnTypeIT {
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 @@ public class IoTDBAlterColumnTypeIT {
testAlignDeviceSequenceDataQuery(from, to);
testAlignDeviceUnSequenceDataQuery(from, to);
testAlignDeviceUnSequenceOverlappedDataQuery(from, to);
+
+ doWriteAndAlterWriteForAccumulatorQuery(from, to);
}
}
}
@@ -320,6 +320,75 @@ public class IoTDBAlterColumnTypeIT {
}
}
+ 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 @@ public class IoTDBAlterColumnTypeIT {
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 @@ public class IoTDBAlterColumnTypeIT {
}
// 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 @@ public class IoTDBAlterColumnTypeIT {
}
// 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,74 +1998,217 @@ public class IoTDBAlterColumnTypeIT {
private static void standardAccumulatorQueryTest(ITableSession session,
TSDataType newType)
throws StatementExecutionException, IoTDBConnectionException {
- if (newType == TSDataType.DATE) {
- throw new NotSupportedException("Not supported DATE type.");
+ 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;
}
- 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 {
+ // test avg and sum
+ if (newType.isNumeric()) {
dataSet =
session.executeQueryStatement(
- "select min(s1),max(s1),first(s1),last(s1) from
construct_and_alter_column_type");
+ "select avg(s1),sum(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};
- }
+ 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 != 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: {}",
+ // can use 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 standardAccumulatorQueryTest(
+ 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
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());
+ }
+ break;
+ case DOUBLE:
+ expectedValue = new Integer[] {1, 999, 1, 1024};
+ for (int i = 0; i < 4; i++) {
+ assertExpectLog(
i,
- genValue(newType, expectedValue[i]).toString(),
+ newType.castFromSingleValue(from, genValue(from, (int)
expectedValue[i])),
rec.getFields().get(i).toString());
assertEquals(
- genValue(newType, expectedValue[i]).toString(),
rec.getFields().get(i).toString());
+ newType.castFromSingleValue(from, genValue(from, (int)
expectedValue[i])),
+ rec.getFields().get(i).getObjectValue(newType));
}
- }
+ 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());
+ }
+ 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 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
+ // can get statistics information
dataSet =
session.executeQueryStatement(
"select count(*) from construct_and_alter_column_type where time >
0");
@@ -2048,146 +2225,315 @@ public class IoTDBAlterColumnTypeIT {
assertFalse(dataSet.hasNext());
}
- private static void standardAccumulatorQueryTest(
+ private static void standardAccumulatorQueryByTimeOnlyInvolveOldDataTypeTest(
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
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());
}
- }
- } 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:
+ 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));
}
- }
-
- 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());
- assertEquals(
- genValue(newType, expectedValue[i]).toString(),
rec.getFields().get(i).toString());
- }
+ 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;
+ }
- assertFalse(dataSet.hasNext());
+ // 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 + ".");
+ }
- 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());
+ 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;
+ }
- // 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 write_and_alter_column_type_write
where time > 512");
rec = dataSet.next();
- assertEquals(1024, rec.getFields().get(0).getLongV());
+ 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 + ".");
+ }
- // can't use statistics information
+ 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 count(*) from construct_and_alter_column_type where time
> 10000");
+ "select avg(s1),sum(s1) from write_and_alter_column_type_write");
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
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 @@ public class IoTDBAlterColumnTypeIT {
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 70f3ce5e0e6..9b341dc9971 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 @@ public class FileLoaderUtils {
(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 @@ public class FileLoaderUtils {
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 a44a43d0f17..1e1cffba5ff 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 @@ public class SeriesScanUtil implements Accountable {
(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 e1d1aa59849..6044b2331d1 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.commons.exception.MetadataException;
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.HashMap;
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 @@ public class SchemaUtils {
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 @@ public class SchemaUtils {
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 @@ public class SchemaUtils {
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 @@ public class SchemaUtils {
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 @@ public class SchemaUtils {
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 @@ public class SchemaUtils {
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);
}
