org.apache.iotdb.db.utils.CommonUtils Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.iotdb.db.utils;
import org.apache.iotdb.commons.utils.TestOnly;
import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.queryengine.plan.execution.IQueryExecution;
import org.apache.iotdb.db.utils.constant.SqlConstant;
import org.apache.iotdb.service.rpc.thrift.TSAggregationQueryReq;
import org.apache.iotdb.service.rpc.thrift.TSFastLastDataQueryForOneDeviceReq;
import org.apache.iotdb.service.rpc.thrift.TSFetchResultsReq;
import org.apache.iotdb.service.rpc.thrift.TSLastDataQueryReq;
import org.apache.iotdb.service.rpc.thrift.TSRawDataQueryReq;
import org.apache.iotdb.tsfile.common.conf.TSFileConfig;
import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
import org.apache.iotdb.tsfile.utils.Binary;
import com.google.common.base.Throwables;
import io.airlift.airline.Cli;
import io.airlift.airline.Help;
import io.airlift.airline.ParseArgumentsMissingException;
import io.airlift.airline.ParseArgumentsUnexpectedException;
import io.airlift.airline.ParseCommandMissingException;
import io.airlift.airline.ParseCommandUnrecognizedException;
import io.airlift.airline.ParseOptionConversionException;
import io.airlift.airline.ParseOptionMissingException;
import io.airlift.airline.ParseOptionMissingValueException;
import org.apache.commons.lang3.StringUtils;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
@SuppressWarnings("java:S106") // for console outputs
public class CommonUtils {
private static final int MAX_SLOW_NATIVE_API_OUTPUT_NUM = 10;
private static final String UNKNOWN_RESULT = "UNKNOWN";
private CommonUtils() {}
public static Object parseValue(TSDataType dataType, String value) throws QueryProcessException {
try {
if ("null".equals(value) || "NULL".equals(value)) {
return null;
}
switch (dataType) {
case BOOLEAN:
return parseBoolean(value);
case INT32:
try {
return Integer.parseInt(StringUtils.trim(value));
} catch (NumberFormatException e) {
throw new NumberFormatException(
"data type is not consistent, input " + value + ", registered " + dataType);
}
case INT64:
try {
return Long.parseLong(StringUtils.trim(value));
} catch (NumberFormatException e) {
throw new NumberFormatException(
"data type is not consistent, input " + value + ", registered " + dataType);
}
case FLOAT:
float f;
try {
f = Float.parseFloat(value);
} catch (NumberFormatException e) {
throw new NumberFormatException(
"data type is not consistent, input " + value + ", registered " + dataType);
}
if (Float.isInfinite(f)) {
throw new NumberFormatException("The input float value is Infinity");
}
return f;
case DOUBLE:
double d;
try {
d = Double.parseDouble(value);
} catch (NumberFormatException e) {
throw new NumberFormatException(
"data type is not consistent, input " + value + ", registered " + dataType);
}
if (Double.isInfinite(d)) {
throw new NumberFormatException("The input double value is Infinity");
}
return d;
case TEXT:
if ((value.startsWith(SqlConstant.QUOTE) && value.endsWith(SqlConstant.QUOTE))
|| (value.startsWith(SqlConstant.DQUOTE) && value.endsWith(SqlConstant.DQUOTE))) {
if (value.length() == 1) {
return new Binary(value, TSFileConfig.STRING_CHARSET);
} else {
return new Binary(
value.substring(1, value.length() - 1), TSFileConfig.STRING_CHARSET);
}
}
return new Binary(value, TSFileConfig.STRING_CHARSET);
default:
throw new QueryProcessException("Unsupported data type:" + dataType);
}
} catch (NumberFormatException e) {
throw new QueryProcessException(e.getMessage());
}
}
public static boolean checkCanCastType(TSDataType src, TSDataType dest) {
if (Objects.isNull(src)) {
return true;
}
switch (src) {
case INT32:
if (dest == TSDataType.INT64 || dest == TSDataType.FLOAT || dest == TSDataType.DOUBLE) {
return true;
}
case INT64:
if (dest == TSDataType.DOUBLE) {
return true;
}
case FLOAT:
if (dest == TSDataType.DOUBLE) {
return true;
}
}
return false;
}
public static Object castValue(TSDataType srcDataType, TSDataType destDataType, Object value) {
if (Objects.isNull(value)) {
return null;
}
switch (srcDataType) {
case INT32:
if (destDataType == TSDataType.INT64) {
value = (long) ((int) value);
} else if (destDataType == TSDataType.FLOAT) {
value = (float) ((int) value);
} else if (destDataType == TSDataType.DOUBLE) {
value = (double) ((int) value);
}
break;
case INT64:
if (destDataType == TSDataType.DOUBLE) {
value = (double) ((long) value);
}
break;
case FLOAT:
if (destDataType == TSDataType.DOUBLE) {
value = (double) ((float) value);
}
break;
}
return value;
}
public static Object castArray(TSDataType srcDataType, TSDataType destDataType, Object value) {
switch (srcDataType) {
case INT32:
if (destDataType == TSDataType.INT64) {
value = Arrays.stream((int[]) value).mapToLong(Long::valueOf).toArray();
} else if (destDataType == TSDataType.FLOAT) {
int[] tmp = (int[]) value;
float[] result = new float[tmp.length];
for (int i = 0; i < tmp.length; i++) {
result[i] = (float) tmp[i];
}
value = result;
} else if (destDataType == TSDataType.DOUBLE) {
value = Arrays.stream((int[]) value).mapToDouble(Double::valueOf).toArray();
}
break;
case INT64:
if (destDataType == TSDataType.DOUBLE) {
value = Arrays.stream((long[]) value).mapToDouble(Double::valueOf).toArray();
}
break;
case FLOAT:
if (destDataType == TSDataType.DOUBLE) {
float[] tmp = (float[]) value;
double[] result = new double[tmp.length];
for (int i = 0; i < tmp.length; i++) {
result[i] = tmp[i];
}
value = result;
}
break;
}
return value;
}
@TestOnly
public static Object parseValueForTest(TSDataType dataType, String value)
throws QueryProcessException {
try {
switch (dataType) {
case BOOLEAN:
return parseBoolean(value);
case INT32:
return Integer.parseInt(value);
case INT64:
return Long.parseLong(value);
case FLOAT:
return Float.parseFloat(value);
case DOUBLE:
return Double.parseDouble(value);
case TEXT:
return new Binary(value, TSFileConfig.STRING_CHARSET);
default:
throw new QueryProcessException("Unsupported data type:" + dataType);
}
} catch (NumberFormatException e) {
throw new QueryProcessException(e.getMessage());
}
}
private static boolean parseBoolean(String value) throws QueryProcessException {
value = value.toLowerCase();
if (SqlConstant.BOOLEAN_FALSE_NUM.equals(value) || SqlConstant.BOOLEAN_FALSE.equals(value)) {
return false;
}
if (SqlConstant.BOOLEAN_TRUE_NUM.equals(value) || SqlConstant.BOOLEAN_TRUE.equals(value)) {
return true;
}
throw new QueryProcessException("The BOOLEAN should be true/TRUE, false/FALSE or 0/1");
}
public static String getContentOfRequest(
org.apache.thrift.TBase request, IQueryExecution queryExecution) {
if (queryExecution == null) {
return UNKNOWN_RESULT;
}
String executeSql = queryExecution.getExecuteSQL().orElse("");
if (!executeSql.isEmpty()) {
return executeSql;
} else if (request == null) {
return UNKNOWN_RESULT;
} else if (request instanceof TSRawDataQueryReq) {
TSRawDataQueryReq req = (TSRawDataQueryReq) request;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < Math.min(req.getPathsSize(), MAX_SLOW_NATIVE_API_OUTPUT_NUM); i++) {
sb.append(i == 0 ? "" : ",").append(req.getPaths().get(i));
}
return String.format(
"Request name: TSRawDataQueryReq, paths size: %s, starTime: %s, "
+ "endTime: %s, some paths: %s",
req.getPathsSize(), req.getStartTime(), req.getEndTime(), sb);
} else if (request instanceof TSLastDataQueryReq) {
TSLastDataQueryReq req = (TSLastDataQueryReq) request;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < Math.min(req.getPathsSize(), MAX_SLOW_NATIVE_API_OUTPUT_NUM); i++) {
sb.append(i == 0 ? "" : ",").append(req.getPaths().get(i));
}
return String.format(
"Request name: TSLastDataQueryReq, paths size: %s, some paths: %s",
req.getPathsSize(), sb);
} else if (request instanceof TSAggregationQueryReq) {
TSAggregationQueryReq req = (TSAggregationQueryReq) request;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < Math.min(req.getPathsSize(), MAX_SLOW_NATIVE_API_OUTPUT_NUM); i++) {
sb.append(i == 0 ? "" : ",")
.append(req.getAggregations().get(i))
.append(":")
.append(req.getPaths().get(i));
}
return String.format(
"Request name: TSAggregationQueryReq, startTime: %s, endTime: %s, "
+ "paths size: %s, some paths: %s",
req.getStartTime(), req.getEndTime(), req.getPathsSize(), sb);
} else if (request instanceof TSFastLastDataQueryForOneDeviceReq) {
TSFastLastDataQueryForOneDeviceReq req = (TSFastLastDataQueryForOneDeviceReq) request;
return String.format(
"Request name: TSFastLastDataQueryForOneDeviceReq, "
+ "db: %s, deviceId: %s, sensorSize: %s, sensors: %s",
req.getDb(), req.getDeviceId(), req.getSensorsSize(), req.getSensors());
} else if (request instanceof TSFetchResultsReq) {
TSFetchResultsReq req = (TSFetchResultsReq) request;
StringBuilder sb = new StringBuilder();
for (int i = 0;
i < Math.min(queryExecution.getOutputValueColumnCount(), MAX_SLOW_NATIVE_API_OUTPUT_NUM);
i++) {
sb.append(i == 0 ? "" : ",")
.append(queryExecution.getDatasetHeader().getRespColumns().get(i));
}
return String.format(
"Request name: TSFetchResultsReq, "
+ "queryId: %s, output value column count: %s, fetchSize: %s, "
+ "some response headers: %s",
req.getQueryId(), queryExecution.getOutputValueColumnCount(), req.getFetchSize(), sb);
} else {
return UNKNOWN_RESULT;
}
}
public static int runCli(
List> commands,
String[] args,
String cliName,
String cliDescription) {
Cli.CliBuilder builder = Cli.builder(cliName);
builder.withDescription(cliDescription).withDefaultCommand(Help.class).withCommands(commands);
Cli parser = builder.build();
int status = 0;
try {
Runnable parse = parser.parse(args);
parse.run();
} catch (IllegalArgumentException
| IllegalStateException
| ParseArgumentsMissingException
| ParseArgumentsUnexpectedException
| ParseOptionConversionException
| ParseOptionMissingException
| ParseOptionMissingValueException
| ParseCommandMissingException
| ParseCommandUnrecognizedException e) {
badUse(e);
status = 1;
} catch (Exception e) {
err(Throwables.getRootCause(e));
status = 2;
}
return status;
}
private static void badUse(Exception e) {
System.out.println("node-tool: " + e.getMessage());
System.out.println("See 'node-tool help' or 'node-tool help '.");
}
private static void err(Throwable e) {
System.err.println("error: " + e.getMessage());
System.err.println("-- StackTrace --");
System.err.println(Throwables.getStackTraceAsString(e));
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy