in seatunnel-transforms-v2/src/main/java/org/apache/seatunnel/transform/sql/zeta/ZetaSQLType.java [95:259]
public SeaTunnelDataType<?> getExpressionType(Expression expression) {
if (expression instanceof NullValue) {
return BasicType.VOID_TYPE;
}
if (expression instanceof SignedExpression) {
return getExpressionType(((SignedExpression) expression).getExpression());
}
if (expression instanceof DoubleValue) {
return BasicType.DOUBLE_TYPE;
}
if (expression instanceof LongValue) {
long longVal = ((LongValue) expression).getValue();
if (longVal <= Integer.MAX_VALUE && longVal >= Integer.MIN_VALUE) {
return BasicType.INT_TYPE;
}
return BasicType.LONG_TYPE;
}
if (expression instanceof StringValue) {
return BasicType.STRING_TYPE;
}
if (expression instanceof Column) {
Column columnExp = (Column) expression;
String columnName = columnExp.getColumnName();
int index = inputRowType.indexOf(columnName, false);
if (index == -1
&& columnName.startsWith(ZetaSQLEngine.ESCAPE_IDENTIFIER)
&& columnName.endsWith(ZetaSQLEngine.ESCAPE_IDENTIFIER)) {
columnName = columnName.substring(1, columnName.length() - 1);
index = inputRowType.indexOf(columnName, false);
}
if (index == -1
&& ("true".equalsIgnoreCase(columnName)
|| "false".equalsIgnoreCase(columnName))) {
return BasicType.BOOLEAN_TYPE;
}
if (index != -1) {
return inputRowType.getFieldType(index);
} else {
// fullback logical to handel struct query.
String fullyQualifiedName = columnExp.getFullyQualifiedName();
String[] columnNames = fullyQualifiedName.split("\\.");
int deep = columnNames.length;
SeaTunnelRowType parRowType = inputRowType;
SeaTunnelDataType<?> filedTypeRes = null;
for (int i = 0; i < deep; i++) {
String key = columnNames[i];
int idx = parRowType.indexOf(key, false);
if (idx == -1
&& key.startsWith(ZetaSQLEngine.ESCAPE_IDENTIFIER)
&& key.endsWith(ZetaSQLEngine.ESCAPE_IDENTIFIER)) {
key = key.substring(1, key.length() - 1);
idx = parRowType.indexOf(key, false);
}
if (idx == -1) {
throw new IllegalArgumentException(
String.format("can't find field [%s]", fullyQualifiedName));
}
filedTypeRes = parRowType.getFieldType(idx);
if (filedTypeRes instanceof SeaTunnelRowType) {
parRowType = (SeaTunnelRowType) filedTypeRes;
} else if (filedTypeRes instanceof MapType) {
if (i < deep - 2) {
throw new IllegalArgumentException(
"For now, when you query map field with inner query, it must be latest field or latest struct field! Please modify your query!");
}
if (i == deep - 1) {
return filedTypeRes;
} else {
return ((MapType<?, ?>) filedTypeRes).getValueType();
}
}
}
return filedTypeRes;
}
}
if (expression instanceof Function) {
return getFunctionType((Function) expression);
}
if (expression instanceof TrimFunction) {
return BasicType.STRING_TYPE;
}
if (expression instanceof TimeKeyExpression) {
return getTimeKeyExprType((TimeKeyExpression) expression);
}
if (expression instanceof ExtractExpression) {
return BasicType.INT_TYPE;
}
if (expression instanceof Parenthesis) {
Parenthesis parenthesis = (Parenthesis) expression;
return getExpressionType(parenthesis.getExpression());
}
if (expression instanceof Concat) {
return BasicType.STRING_TYPE;
}
if (expression instanceof CaseExpression) {
return getCaseType((CaseExpression) expression);
}
if (expression instanceof ComparisonOperator
|| expression instanceof IsNullExpression
|| expression instanceof InExpression
|| expression instanceof LikeExpression
|| expression instanceof AndExpression
|| expression instanceof OrExpression
|| expression instanceof NotEqualsTo) {
return BasicType.BOOLEAN_TYPE;
}
if (expression instanceof CastExpression) {
return getCastType((CastExpression) expression);
}
if (expression instanceof BinaryExpression) {
BinaryExpression binaryExpression = (BinaryExpression) expression;
SeaTunnelDataType<?> leftType = getExpressionType(binaryExpression.getLeftExpression());
SeaTunnelDataType<?> rightType =
getExpressionType(binaryExpression.getRightExpression());
if ((leftType.getSqlType() == SqlType.TINYINT
|| leftType.getSqlType() == SqlType.SMALLINT
|| leftType.getSqlType() == SqlType.INT)
&& (rightType.getSqlType() == SqlType.TINYINT
|| rightType.getSqlType() == SqlType.SMALLINT
|| rightType.getSqlType() == SqlType.INT)) {
return BasicType.INT_TYPE;
}
if ((leftType.getSqlType() == SqlType.TINYINT
|| leftType.getSqlType() == SqlType.SMALLINT
|| leftType.getSqlType() == SqlType.INT
|| leftType.getSqlType() == SqlType.BIGINT)
&& rightType.getSqlType() == SqlType.BIGINT) {
return BasicType.LONG_TYPE;
}
if ((rightType.getSqlType() == SqlType.TINYINT
|| rightType.getSqlType() == SqlType.SMALLINT
|| rightType.getSqlType() == SqlType.INT
|| rightType.getSqlType() == SqlType.BIGINT)
&& leftType.getSqlType() == SqlType.BIGINT) {
return BasicType.LONG_TYPE;
}
if (leftType.getSqlType() == SqlType.DECIMAL
|| rightType.getSqlType() == SqlType.DECIMAL) {
int precision = 0;
int scale = 0;
if (leftType.getSqlType() == SqlType.DECIMAL) {
DecimalType decimalType = (DecimalType) leftType;
precision = decimalType.getPrecision();
scale = decimalType.getScale();
}
if (rightType.getSqlType() == SqlType.DECIMAL) {
DecimalType decimalType = (DecimalType) rightType;
precision = Math.max(decimalType.getPrecision(), precision);
scale = Math.max(decimalType.getScale(), scale);
}
return new DecimalType(precision, scale);
}
if ((leftType.getSqlType() == SqlType.FLOAT || leftType.getSqlType() == SqlType.DOUBLE)
|| (rightType.getSqlType() == SqlType.FLOAT
|| rightType.getSqlType() == SqlType.DOUBLE)) {
return BasicType.DOUBLE_TYPE;
}
}
throw new TransformException(
CommonErrorCodeDeprecated.UNSUPPORTED_OPERATION,
String.format("Unsupported SQL Expression: %s ", expression.toString()));
}