core/src/main/java/org/apache/calcite/sql/fun/SqlLikeOperator.java

/*
 * 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.calcite.sql.fun;

import org.apache.calcite.sql.SqlCall;
import org.apache.calcite.sql.SqlCallBinding;
import org.apache.calcite.sql.SqlKind;
import org.apache.calcite.sql.SqlNode;
import org.apache.calcite.sql.SqlOperandCountRange;
import org.apache.calcite.sql.SqlOperator;
import org.apache.calcite.sql.SqlSpecialOperator;
import org.apache.calcite.sql.SqlWriter;
import org.apache.calcite.sql.parser.SqlParserPos;
import org.apache.calcite.sql.parser.SqlParserUtil;
import org.apache.calcite.sql.type.InferTypes;
import org.apache.calcite.sql.type.OperandTypes;
import org.apache.calcite.sql.type.ReturnTypes;
import org.apache.calcite.sql.type.SqlOperandCountRanges;
import org.apache.calcite.sql.type.SqlTypeUtil;
import org.apache.calcite.sql.validate.SqlValidator;
import org.apache.calcite.sql.validate.SqlValidatorScope;
import org.apache.calcite.util.Litmus;

/**
 * An operator describing the <code>LIKE</code> and <code>SIMILAR</code>
 * operators.
 *
 * <p>Syntax of the two operators:
 *
 * <ul>
 * <li><code>src-value [NOT] LIKE pattern-value [ESCAPE
 * escape-value]</code></li>
 * <li><code>src-value [NOT] SIMILAR pattern-value [ESCAPE
 * escape-value]</code></li>
 * </ul>
 *
 * <p><b>NOTE</b> If the <code>NOT</code> clause is present the
 * {@link org.apache.calcite.sql.parser.SqlParser parser} will generate a
 * equivalent to <code>NOT (src LIKE pattern ...)</code>
 */
public class SqlLikeOperator extends SqlSpecialOperator {
  //~ Instance fields --------------------------------------------------------

  private final boolean negated;
  private final boolean caseSensitive;

  //~ Constructors -----------------------------------------------------------

  /**
   * Creates a SqlLikeOperator.
   *
   * @param name        Operator name
   * @param kind        Kind
   * @param negated     Whether this is 'NOT LIKE'
   * @param caseSensitive Whether this operator ignores the case of its operands
   */
  SqlLikeOperator(
      String name,
      SqlKind kind,
      boolean negated,
      boolean caseSensitive) {
    // LIKE is right-associative, because that makes it easier to capture
    // dangling ESCAPE clauses: "a like b like c escape d" becomes
    // "a like (b like c escape d)".
    super(
        name,
        kind,
        32,
        false,
        ReturnTypes.BOOLEAN_NULLABLE,
        InferTypes.FIRST_KNOWN,
        OperandTypes.STRING_SAME_SAME_SAME);
    if (!caseSensitive && kind != SqlKind.LIKE) {
      throw new IllegalArgumentException("Only (possibly negated) "
          + SqlKind.LIKE + " can be made case-insensitive, not " + kind);
    }

    this.negated = negated;
    this.caseSensitive = caseSensitive;
  }

  //~ Methods ----------------------------------------------------------------

  /**
   * Returns whether this is the 'NOT LIKE' operator.
   *
   * @return whether this is 'NOT LIKE'
   *
   * @see #not()
   */
  public boolean isNegated() {
    return negated;
  }

  /**
   * Returns whether this operator matches the case of its operands.
   * For example, returns true for {@code LIKE} and false for {@code ILIKE}.
   *
   * @return whether this operator matches the case of its operands
   */
  public boolean isCaseSensitive() {
    return caseSensitive;
  }

  @Override public SqlOperator not() {
    return of(kind, !negated, caseSensitive);
  }

  private static SqlOperator of(SqlKind kind, boolean negated,
      boolean caseSensitive) {
    switch (kind) {
    case SIMILAR:
      return negated
          ? SqlStdOperatorTable.NOT_SIMILAR_TO
          : SqlStdOperatorTable.SIMILAR_TO;
    case RLIKE:
      return negated
          ? SqlLibraryOperators.NOT_RLIKE
          : SqlLibraryOperators.RLIKE;
    case LIKE:
      if (caseSensitive) {
        return negated
            ? SqlStdOperatorTable.NOT_LIKE
            : SqlStdOperatorTable.LIKE;
      } else {
        return negated
            ? SqlLibraryOperators.NOT_ILIKE
            : SqlLibraryOperators.ILIKE;
      }
    default:
      throw new AssertionError("unexpected " + kind);
    }
  }

  @Override public SqlOperandCountRange getOperandCountRange() {
    return SqlOperandCountRanges.between(2, 3);
  }

  @Override public boolean checkOperandTypes(
      SqlCallBinding callBinding,
      boolean throwOnFailure) {
    switch (callBinding.getOperandCount()) {
    case 2:
      if (!OperandTypes.STRING_SAME_SAME.checkOperandTypes(
          callBinding,
          throwOnFailure)) {
        return false;
      }
      break;
    case 3:
      if (!OperandTypes.STRING_SAME_SAME_SAME.checkOperandTypes(
          callBinding,
          throwOnFailure)) {
        return false;
      }

      // calc implementation should
      // enforce the escape character length to be 1
      break;
    default:
      throw new AssertionError("unexpected number of args to "
          + callBinding.getCall() + ": " + callBinding.getOperandCount());
    }

    return SqlTypeUtil.isCharTypeComparable(
        callBinding,
        callBinding.operands(),
        throwOnFailure);
  }

  @Override public void validateCall(SqlCall call, SqlValidator validator,
      SqlValidatorScope scope, SqlValidatorScope operandScope) {
    super.validateCall(call, validator, scope, operandScope);
  }

  @Override public boolean validRexOperands(int count, Litmus litmus) {
    if (negated) {
      litmus.fail("unsupported negated operator {}", this);
    }
    return super.validRexOperands(count, litmus);
  }

  @Override public void unparse(
      SqlWriter writer,
      SqlCall call,
      int leftPrec,
      int rightPrec) {
    final SqlWriter.Frame frame = writer.startList("", "");
    call.operand(0).unparse(writer, getLeftPrec(), getRightPrec());
    writer.sep(getName());

    call.operand(1).unparse(writer, getLeftPrec(), getRightPrec());
    if (call.operandCount() == 3) {
      writer.sep("ESCAPE");
      call.operand(2).unparse(writer, getLeftPrec(), getRightPrec());
    }
    writer.endList(frame);
  }

  @Override public ReduceResult reduceExpr(
      final int opOrdinal,
      TokenSequence list) {
    // Example:
    //   a LIKE b || c ESCAPE d || e AND f
    // |  |    |      |      |      |
    //  exp0    exp1          exp2
    SqlNode exp0 = list.node(opOrdinal - 1);
    SqlOperator op = list.op(opOrdinal);
    assert op instanceof SqlLikeOperator;
    SqlNode exp1 =
        SqlParserUtil.toTreeEx(
            list,
            opOrdinal + 1,
            getRightPrec(),
            SqlKind.ESCAPE);
    SqlNode exp2 = null;
    if ((opOrdinal + 2) < list.size()) {
      if (list.isOp(opOrdinal + 2)) {
        final SqlOperator op2 = list.op(opOrdinal + 2);
        if (op2.getKind() == SqlKind.ESCAPE) {
          exp2 =
              SqlParserUtil.toTreeEx(
                  list,
                  opOrdinal + 3,
                  getRightPrec(),
                  SqlKind.ESCAPE);
        }
      }
    }
    final SqlNode[] operands;
    final int end;
    if (exp2 != null) {
      operands = new SqlNode[]{exp0, exp1, exp2};
      end = opOrdinal + 4;
    } else {
      operands = new SqlNode[]{exp0, exp1};
      end = opOrdinal + 2;
    }
    SqlCall call = createCall(SqlParserPos.sum(operands), operands);
    return new ReduceResult(opOrdinal - 1, end, call);
  }
}