content: /*
   * 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.linq4j.Ord;
  import org.apache.calcite.rel.type.RelDataType;
  import org.apache.calcite.sql.SqlCall;
  import org.apache.calcite.sql.SqlCallBinding;
  import org.apache.calcite.sql.SqlCharStringLiteral;
  import org.apache.calcite.sql.SqlCollation;
  import org.apache.calcite.sql.SqlKind;
  import org.apache.calcite.sql.SqlLiteral;
  import org.apache.calcite.sql.SqlNode;
  import org.apache.calcite.sql.SqlOperatorBinding;
  import org.apache.calcite.sql.SqlSpecialOperator;
  import org.apache.calcite.sql.SqlUtil;
  import org.apache.calcite.sql.SqlWriter;
  import org.apache.calcite.sql.parser.SqlParserPos;
  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.SqlTypeName;
  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.BitString;
  import org.apache.calcite.util.NlsString;
  import org.apache.calcite.util.Util;
  
  import java.util.List;
  
  import static org.apache.calcite.linq4j.Nullness.castNonNull;
  import static org.apache.calcite.util.Static.RESOURCE;
  
  /**
   * Internal operator, by which the parser represents a continued string literal.
   *
   * <p>The string fragments are {@link SqlLiteral} objects, all of the same type,
   * collected as the operands of an {@link SqlCall} using this operator. After
   * validation, the fragments will be concatenated into a single literal.
   *
   * <p>For a chain of {@link org.apache.calcite.sql.SqlCharStringLiteral}
   * objects, a {@link SqlCollation} object is attached only to the head of the
   * chain.
   */
  public class SqlLiteralChainOperator extends SqlSpecialOperator {
    //~ Constructors -----------------------------------------------------------
  
    SqlLiteralChainOperator() {
      super(
          "$LiteralChain",
          SqlKind.LITERAL_CHAIN,
          80,
          true,
  
          // precedence tighter than the * and || operators
          ReturnTypes.ARG0,
          InferTypes.FIRST_KNOWN,
          OperandTypes.VARIADIC);
    }
  
    //~ Methods ----------------------------------------------------------------
  
    // all operands must be the same type
    private static boolean argTypesValid(SqlCallBinding callBinding) {
      if (callBinding.getOperandCount() < 2) {
        return true; // nothing to compare
      }
      RelDataType firstType = null;
      for (Ord<SqlNode> operand : Ord.zip(callBinding.operands())) {
        RelDataType type = SqlTypeUtil.deriveType(callBinding, operand.e);
        if (operand.i == 0) {
          firstType = type;
        } else if (!SqlTypeUtil.sameNamedType(castNonNull(firstType), type)) {
          return false;
        }
      }
      return true;
    }
  
    @Override public boolean checkOperandTypes(
        SqlCallBinding callBinding,
        boolean throwOnFailure) {
      if (!argTypesValid(callBinding)) {
        if (throwOnFailure) {
          throw callBinding.newValidationSignatureError();
        }
        return false;
      }
      return true;
    }
  
    // Result type is the same as all the args, but its size is the
    // total size.
    // REVIEW mb 8/8/04: Possibly this can be achieved by combining
    // the strategy useFirstArgType with a new transformer.
    @Override public RelDataType inferReturnType(
        SqlOperatorBinding opBinding) {
      // Here we know all the operands have the same type,
      // which has a size (precision), but not a scale.
      RelDataType ret = opBinding.getOperandType(0);
      SqlTypeName typeName = ret.getSqlTypeName();
      assert typeName.allowsPrecNoScale()
          : "LiteralChain has impossible operand type "
          + typeName;
      int size = 0;
      for (RelDataType type : opBinding.collectOperandTypes()) {
        size += type.getPrecision();
        assert type.getSqlTypeName() == typeName;
      }
      return opBinding.getTypeFactory().createSqlType(typeName, size);
    }
  
    @Override public String getAllowedSignatures(String opName) {
      return opName + "(...)";
    }
  
    @Override public void validateCall(
        SqlCall call,
        SqlValidator validator,
        SqlValidatorScope scope,
        SqlValidatorScope operandScope) {
      // per the SQL std, each string fragment must be on a different line
      final List<SqlNode> operandList = call.getOperandList();
      for (int i = 1; i < operandList.size(); i++) {
        SqlParserPos prevPos = operandList.get(i - 1).getParserPosition();
        final SqlNode operand = operandList.get(i);
        SqlParserPos pos = operand.getParserPosition();
        if (pos.getLineNum() <= prevPos.getLineNum()) {
          throw validator.newValidationError(operand,
              RESOURCE.stringFragsOnSameLine());
        }
      }
    }
  
    @Override public void unparse(
        SqlWriter writer,
        SqlCall call,
        int leftPrec,
        int rightPrec) {
      final SqlWriter.Frame frame = writer.startList("", "");
      SqlCollation collation = null;
      for (Ord<SqlNode> operand : Ord.zip(call.getOperandList())) {
        SqlLiteral rand = (SqlLiteral) operand.e;
        if (operand.i > 0) {
          // SQL:2003 says there must be a newline between string
          // fragments.
          writer.newlineAndIndent();
        }
        if (rand instanceof SqlCharStringLiteral) {
          final NlsString nls = rand.getValueAs(NlsString.class);
          if (operand.i == 0) {
            collation = nls.getCollation();
  
            // print with prefix
            writer.literal(nls.asSql(true, false, writer.getDialect()));
          } else {
            // print without prefix
            writer.literal(nls.asSql(false, false, writer.getDialect()));
          }
        } else if (operand.i == 0) {
          // print with prefix
          rand.unparse(writer, leftPrec, rightPrec);
        } else {
          // print without prefix
          if (rand.getTypeName() == SqlTypeName.BINARY) {
            BitString bs = rand.getValueAs(BitString.class);
            writer.literal("'" + bs.toHexString() + "'");
          } else {
            writer.literal("'" + rand.toValue() + "'");
          }
        }
      }
      if (collation != null) {
        collation.unparse(writer);
      }
      writer.endList(frame);
    }
  
    /**
     * Concatenates the operands of a call to this operator.
     */
    public static SqlLiteral concatenateOperands(SqlCall call) {
      final List<SqlNode> operandList = call.getOperandList();
      assert !operandList.isEmpty();
      assert operandList.get(0) instanceof SqlLiteral
          : operandList.get(0).getClass();
      return SqlUtil.concatenateLiterals(
          Util.cast(operandList, SqlLiteral.class));
    }
  }
  