| /* |
| * 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 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 org.apache.tsfile.common.conf.TSFileConfig; |
| import org.apache.tsfile.enums.TSDataType; |
| import org.apache.tsfile.utils.Binary; |
| |
| 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<Class<? extends Runnable>> commands, |
| String[] args, |
| String cliName, |
| String cliDescription) { |
| Cli.CliBuilder<Runnable> builder = Cli.builder(cliName); |
| |
| builder.withDescription(cliDescription).withDefaultCommand(Help.class).withCommands(commands); |
| |
| Cli<Runnable> 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 <command>'."); |
| } |
| |
| private static void err(Throwable e) { |
| System.err.println("error: " + e.getMessage()); |
| System.err.println("-- StackTrace --"); |
| System.err.println(Throwables.getStackTraceAsString(e)); |
| } |
| } |