From de326d12f208e4a38b9b66870f240b5f1c68d355 Mon Sep 17 00:00:00 2001 From: Gian Merlino Date: Tue, 13 Nov 2018 13:39:00 -0800 Subject: [PATCH] SQL: Add "POSITION" function. (#6596) Also add a "fromIndex" argument to the strpos expression function. There are some -1 and +1 adjustment terms due to the fact that the strpos expression behaves like Java indexOf (0-indexed), but the POSITION SQL function is 1-indexed. --- .../java/io/druid/math/expr/Function.java | 14 +++- .../java/io/druid/math/expr/FunctionTest.java | 4 + docs/content/misc/math-expr.md | 2 +- docs/content/querying/sql.md | 3 +- .../builtin/PositionOperatorConversion.java | 76 +++++++++++++++++++ .../calcite/planner/DruidOperatorTable.java | 2 + .../calcite/expression/ExpressionsTest.java | 36 +++++++++ 7 files changed, 132 insertions(+), 5 deletions(-) create mode 100644 sql/src/main/java/io/druid/sql/calcite/expression/builtin/PositionOperatorConversion.java diff --git a/common/src/main/java/io/druid/math/expr/Function.java b/common/src/main/java/io/druid/math/expr/Function.java index 0e067583cfcf..62b9742cd5ab 100644 --- a/common/src/main/java/io/druid/math/expr/Function.java +++ b/common/src/main/java/io/druid/math/expr/Function.java @@ -939,14 +939,22 @@ public String name() @Override public ExprEval apply(List args, Expr.ObjectBinding bindings) { - if (args.size() != 2) { - throw new IAE("Function[%s] needs 2 arguments", name()); + if (args.size() < 2 || args.size() > 3) { + throw new IAE("Function[%s] needs 2 or 3 arguments", name()); } final String haystack = Strings.nullToEmpty(args.get(0).eval(bindings).asString()); final String needle = Strings.nullToEmpty(args.get(1).eval(bindings).asString()); - return ExprEval.of(haystack.indexOf(needle)); + final int fromIndex; + + if (args.size() >= 3) { + fromIndex = args.get(2).eval(bindings).asInt(); + } else { + fromIndex = 0; + } + + return ExprEval.of(haystack.indexOf(needle, fromIndex)); } } diff --git a/common/src/test/java/io/druid/math/expr/FunctionTest.java b/common/src/test/java/io/druid/math/expr/FunctionTest.java index 2351dcf16b4a..ee6da141956f 100644 --- a/common/src/test/java/io/druid/math/expr/FunctionTest.java +++ b/common/src/test/java/io/druid/math/expr/FunctionTest.java @@ -89,6 +89,10 @@ public void testStrlen() public void testStrpos() { assertExpr("strpos(x, 'o')", 1L); + assertExpr("strpos(x, 'o', 0)", 1L); + assertExpr("strpos(x, 'o', 1)", 1L); + assertExpr("strpos(x, 'o', 2)", 2L); + assertExpr("strpos(x, 'o', 3)", -1L); assertExpr("strpos(x, '')", 0L); assertExpr("strpos(x, 'x')", -1L); } diff --git a/docs/content/misc/math-expr.md b/docs/content/misc/math-expr.md index 9b2e94c5a90c..3f8ce8d1759a 100644 --- a/docs/content/misc/math-expr.md +++ b/docs/content/misc/math-expr.md @@ -52,7 +52,7 @@ The following built-in functions are available. |replace|replace(expr, pattern, replacement) replaces pattern with replacement| |substring|substring(expr, index, length) behaves like java.lang.String's substring| |strlen|strlen(expr) returns length of a string in UTF-16 code units| -|strpos|strpos(haystack, needle) returns the position of the needle within the haystack, with indexes starting from 0. If the needle is not found then the function returns -1.| +|strpos|strpos(haystack, needle[, fromIndex]) returns the position of the needle within the haystack, with indexes starting from 0. The search will begin at fromIndex, or 0 if fromIndex is not specified. If the needle is not found then the function returns -1.| |trim|trim(expr[, chars]) remove leading and trailing characters from `expr` if they are present in `chars`. `chars` defaults to ' ' (space) if not provided.| |ltrim|ltrim(expr[, chars]) remove leading characters from `expr` if they are present in `chars`. `chars` defaults to ' ' (space) if not provided.| |rtrim|rtrim(expr[, chars]) remove trailing characters from `expr` if they are present in `chars`. `chars` defaults to ' ' (space) if not provided.| diff --git a/docs/content/querying/sql.md b/docs/content/querying/sql.md index 6a42e5045464..39dbe795a487 100644 --- a/docs/content/querying/sql.md +++ b/docs/content/querying/sql.md @@ -131,9 +131,10 @@ String functions accept strings, and return a type appropriate to the function. |`STRLEN(expr)`|Synonym for `LENGTH`.| |`LOOKUP(expr, lookupName)`|Look up expr in a registered [query-time lookup table](lookups.html).| |`LOWER(expr)`|Returns expr in all lowercase.| +|`POSITION(needle IN haystack [FROM fromIndex])`|Returns the index of needle within haystack, with indexes starting from 1. The search will begin at fromIndex, or 1 if fromIndex is not specified. If the needle is not found, returns 0.| |`REGEXP_EXTRACT(expr, pattern, [index])`|Apply regular expression pattern and extract a capture group, or null if there is no match. If index is unspecified or zero, returns the substring that matched the pattern.| |`REPLACE(expr, pattern, replacement)`|Replaces pattern with replacement in expr, and returns the result.| -|`STRPOS(haystack, needle)`|Returns the index of needle within haystack, starting from 1. If the needle is not found, returns 0.| +|`STRPOS(haystack, needle)`|Returns the index of needle within haystack, with indexes starting from 1. If the needle is not found, returns 0.| |`SUBSTRING(expr, index, [length])`|Returns a substring of expr starting at index, with a max length, both measured in UTF-16 code units.| |`SUBSTR(expr, index, [length])`|Synonym for SUBSTRING.| |`TRIM([BOTH \| LEADING \| TRAILING] [ FROM] expr)`|Returns expr with characters removed from the leading, trailing, or both ends of "expr" if they are in "chars". If "chars" is not provided, it defaults to " " (a space). If the directional argument is not provided, it defaults to "BOTH".| diff --git a/sql/src/main/java/io/druid/sql/calcite/expression/builtin/PositionOperatorConversion.java b/sql/src/main/java/io/druid/sql/calcite/expression/builtin/PositionOperatorConversion.java new file mode 100644 index 000000000000..385fd7afd89e --- /dev/null +++ b/sql/src/main/java/io/druid/sql/calcite/expression/builtin/PositionOperatorConversion.java @@ -0,0 +1,76 @@ +/* + * Licensed to Metamarkets Group Inc. (Metamarkets) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. Metamarkets 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 io.druid.sql.calcite.expression.builtin; + +import com.google.common.collect.ImmutableList; +import io.druid.java.util.common.StringUtils; +import io.druid.sql.calcite.expression.DruidExpression; +import io.druid.sql.calcite.expression.OperatorConversions; +import io.druid.sql.calcite.expression.SqlOperatorConversion; +import io.druid.sql.calcite.planner.PlannerContext; +import io.druid.sql.calcite.table.RowSignature; +import org.apache.calcite.rex.RexNode; +import org.apache.calcite.sql.SqlOperator; +import org.apache.calcite.sql.fun.SqlStdOperatorTable; + +public class PositionOperatorConversion implements SqlOperatorConversion +{ + private static final DruidExpression ZERO = DruidExpression.fromExpression("0"); + + @Override + public SqlOperator calciteOperator() + { + return SqlStdOperatorTable.POSITION; + } + + @Override + public DruidExpression toDruidExpression( + final PlannerContext plannerContext, + final RowSignature rowSignature, + final RexNode rexNode + ) + { + return OperatorConversions.convertCall( + plannerContext, + rowSignature, + rexNode, + druidExpressions -> { + final DruidExpression fromIndexExpression; + if (druidExpressions.size() > 2) { + fromIndexExpression = DruidExpression.fromExpression( + StringUtils.format("(%s - 1)", druidExpressions.get(2).getExpression()) + ); + } else { + fromIndexExpression = ZERO; + } + + return DruidExpression.fromExpression( + StringUtils.format( + "(%s + 1)", + DruidExpression.functionCall( + "strpos", + ImmutableList.of(druidExpressions.get(1), druidExpressions.get(0), fromIndexExpression) + ) + ) + ); + } + ); + } +} diff --git a/sql/src/main/java/io/druid/sql/calcite/planner/DruidOperatorTable.java b/sql/src/main/java/io/druid/sql/calcite/planner/DruidOperatorTable.java index b2ea2e183d76..618d68f39fcc 100644 --- a/sql/src/main/java/io/druid/sql/calcite/planner/DruidOperatorTable.java +++ b/sql/src/main/java/io/druid/sql/calcite/planner/DruidOperatorTable.java @@ -47,6 +47,7 @@ import io.druid.sql.calcite.expression.builtin.FloorOperatorConversion; import io.druid.sql.calcite.expression.builtin.LTrimOperatorConversion; import io.druid.sql.calcite.expression.builtin.MillisToTimestampOperatorConversion; +import io.druid.sql.calcite.expression.builtin.PositionOperatorConversion; import io.druid.sql.calcite.expression.builtin.RTrimOperatorConversion; import io.druid.sql.calcite.expression.builtin.RegexpExtractOperatorConversion; import io.druid.sql.calcite.expression.builtin.ReinterpretOperatorConversion; @@ -144,6 +145,7 @@ public class DruidOperatorTable implements SqlOperatorTable .add(new MillisToTimestampOperatorConversion()) .add(new ReinterpretOperatorConversion()) .add(new RegexpExtractOperatorConversion()) + .add(new PositionOperatorConversion()) .add(new StrposOperatorConversion()) .add(new SubstringOperatorConversion()) .add(new AliasedOperatorConversion(new SubstringOperatorConversion(), "SUBSTR")) diff --git a/sql/src/test/java/io/druid/sql/calcite/expression/ExpressionsTest.java b/sql/src/test/java/io/druid/sql/calcite/expression/ExpressionsTest.java index da1a509509c4..2d0288e2bafb 100644 --- a/sql/src/test/java/io/druid/sql/calcite/expression/ExpressionsTest.java +++ b/sql/src/test/java/io/druid/sql/calcite/expression/ExpressionsTest.java @@ -197,6 +197,42 @@ public void testStrpos() ); } + @Test + public void testPosition() + { + testExpression( + rexBuilder.makeCall( + SqlStdOperatorTable.POSITION, + rexBuilder.makeLiteral("oo"), + inputRef("s") + ), + DruidExpression.fromExpression("(strpos(\"s\",'oo',0) + 1)"), + 2L + ); + + testExpression( + rexBuilder.makeCall( + SqlStdOperatorTable.POSITION, + rexBuilder.makeLiteral("oo"), + inputRef("s"), + rexBuilder.makeExactLiteral(BigDecimal.valueOf(2)) + ), + DruidExpression.fromExpression("(strpos(\"s\",'oo',(2 - 1)) + 1)"), + 2L + ); + + testExpression( + rexBuilder.makeCall( + SqlStdOperatorTable.POSITION, + rexBuilder.makeLiteral("oo"), + inputRef("s"), + rexBuilder.makeExactLiteral(BigDecimal.valueOf(3)) + ), + DruidExpression.fromExpression("(strpos(\"s\",'oo',(3 - 1)) + 1)"), + 0L + ); + } + @Test public void testPower() {