tajo-common/src/main/java/org/apache/tajo/schema/IdentifierUtil.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.tajo.schema;

import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import org.apache.tajo.TajoConstants;
import org.apache.tajo.schema.IdentifierPolicy.IdentifierCase;
import org.apache.tajo.util.Pair;
import org.apache.tajo.util.StringUtils;

import java.util.HashSet;
import java.util.Locale;
import java.util.Set;

import static org.apache.tajo.schema.Identifier._;
import static org.apache.tajo.schema.IdentifierPolicy.DefaultPolicy;
import static org.apache.tajo.schema.QualifiedIdentifier.$;

/**
 * Util methods for Identifiers
 */
public class IdentifierUtil {

  public final static String IDENTIFIER_DELIMITER_REGEXP = "\\.";
  public final static String IDENTIFIER_DELIMITER = ".";
  public final static String IDENTIFIER_QUOTE_STRING = "\"";
  public final static int MAX_IDENTIFIER_LENGTH = 128;

  public static final Set<String> RESERVED_KEYWORDS_SET = new HashSet<>();
  public static final String [] RESERVED_KEYWORDS = {
      "AS", "ALL", "AND", "ANY", "ASYMMETRIC", "ASC",
      "BOTH",
      "CASE", "CAST", "CREATE", "CROSS", "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP",
      "DESC", "DISTINCT",
      "END", "ELSE", "EXCEPT",
      "FALSE", "FULL", "FROM",
      "GROUP",
      "HAVING",
      "ILIKE", "IN", "INNER", "INTERSECT", "INTO", "IS",
      "JOIN",
      "LEADING", "LEFT", "LIKE", "LIMIT",
      "NATURAL", "NOT", "NULL",
      "ON", "OUTER", "OR", "ORDER",
      "RIGHT",
      "SELECT", "SOME", "SYMMETRIC",
      "TABLE", "THEN", "TRAILING", "TRUE",
      "OVER",
      "UNION", "UNIQUE", "USING",
      "WHEN", "WHERE", "WINDOW", "WITH"
  };

  public static QualifiedIdentifier makeIdentifier(String raw, IdentifierPolicy policy) {
    if (raw == null || raw.equals("")) {
      return $(raw);
    }

    final String [] splitted = raw.split(IDENTIFIER_DELIMITER_REGEXP);
    final ImmutableList.Builder<Identifier> builder = ImmutableList.builder();

    for (String part : splitted) {
      boolean quoted = isDelimited(part, policy);
      if (quoted) {
        builder.add(_(stripQuote(part), true));
      } else {
        builder.add(internIdentifierPart(part, policy));
      }
    }
    return $(builder.build());
  }

  public static Identifier internIdentifierPart(String rawPart, IdentifierPolicy policy) {
    IdentifierCase unquotedIdentifierCase = policy.storesUnquotedIdentifierAs();
    final String interned;
    if (unquotedIdentifierCase == IdentifierCase.LowerCase) {
      interned = rawPart.toLowerCase(Locale.ENGLISH);
    } else if (unquotedIdentifierCase == IdentifierCase.UpperCase) {
      interned = rawPart.toUpperCase(Locale.ENGLISH);
    } else {
      interned = rawPart;
    }

    return _(interned, false);
  }

  /**
   * Normalize an identifier. Normalization means a translation from a identifier to be a refined identifier name.
   *
   * Identifier can be composed of multiple parts as follows:
   * <pre>
   *   database_name.table_name.column_name
   * </pre>
   *
   * Each regular identifier part can be composed alphabet ([a-z][A-Z]), number([0-9]), and underscore([_]).
   * Also, the first letter must be an alphabet character.
   *
   * <code>normalizeIdentifier</code> normalizes each part of an identifier.
   *
   * In detail, for each part, it performs as follows:
   * <ul>
   *   <li>changing a part without double quotation to be lower case letters</li>
   *   <li>eliminating double quotation marks from identifier</li>
   * </ul>
   *
   * @param identifier The identifier to be normalized
   * @return The normalized identifier
   */
  public static String normalizeIdentifier(String identifier) {
    if (identifier == null || identifier.equals("")) {
      return identifier;
    }
    String [] splitted = identifier.split(IDENTIFIER_DELIMITER_REGEXP);

    StringBuilder sb = new StringBuilder();
    boolean first = true;
    for (String part : splitted) {
      if (first) {
        first = false;
      } else {
        sb.append(IDENTIFIER_DELIMITER);
      }
      sb.append(normalizeIdentifierPart(part));
    }
    return sb.toString();
  }

  public static String normalizeIdentifierPart(String part) {
    return isDelimited(part) ? stripQuote(part) : part.toLowerCase();
  }

  /**
   * Denormalize an identifier. Denormalize means a translation from a stored identifier
   * to be a printable identifier name.
   *
   * In detail, for each part, it performs as follows:
   * <ul>
   *   <li>changing a part including upper case character or non-ascii character to be lower case letters</li>
   *   <li>eliminating double quotation marks from identifier</li>
   * </ul>
   *
   * @param identifier The identifier to be normalized
   * @return The denormalized identifier
   */
  public static String denormalizeIdentifier(String identifier) {
    String [] splitted = identifier.split(IDENTIFIER_DELIMITER_REGEXP);

    StringBuilder sb = new StringBuilder();
    boolean first = true;
    for (String part : splitted) {
      if (first) {
        first = false;
      } else {
        sb.append(IDENTIFIER_DELIMITER);
      }
      sb.append(denormalizePart(part));
    }
    return sb.toString();
  }

  public static String denormalizePart(String identifier) {
    if (isShouldBeQuoted(identifier)) {
      return StringUtils.doubleQuote(identifier);
    } else {
      return identifier;
    }
  }

  public static boolean isShouldBeQuoted(String interned) {
    for (char character : interned.toCharArray()) {
      if (Character.isUpperCase(character)) {
        return true;
      }

      if (!StringUtils.isPartOfAnsiSQLIdentifier(character)) {
        return true;
      }

      if (RESERVED_KEYWORDS_SET.contains(interned.toUpperCase())) {
        return true;
      }
    }

    return false;
  }

  public static String stripQuote(String raw) {
    return raw.substring(1, raw.length() - 1);
  }

  public static boolean isDelimited(String raw) {
    return isDelimited(raw, DefaultPolicy());
  }

  public static boolean isDelimited(String raw, IdentifierPolicy policy) {
    char quoteString = policy.getIdentifierQuoteString();
    boolean openQuote = raw.charAt(0) == quoteString;
    boolean closeQuote = raw.charAt(raw.length() - 1) == quoteString;

    // if at least one quote mark exists, the identifier must be grater than equal to 2 characters,
    if (openQuote ^ closeQuote && raw.length() < 2) {
      throw new IllegalArgumentException("Invalid Identifier: " + raw);
    }

    // does not allow the empty identifier (''),
    if (openQuote && closeQuote && raw.length() == 2) {
      throw new IllegalArgumentException("zero-length delimited identifier: " + raw);
    }

    // Ensure the quote open and close
    return openQuote && closeQuote;
  }

  /**
   * True if a given name is a simple identifier, meaning is not a dot-chained name.
   *
   * @param columnOrTableName Column or Table name to be checked
   * @return True if a given name is a simple identifier. Otherwise, it will return False.
   */
  public static boolean isSimpleIdentifier(String columnOrTableName) {
    return columnOrTableName.split(IDENTIFIER_DELIMITER_REGEXP).length == 1;
  }

  public static boolean isFQColumnName(String tableName) {
    return tableName.split(IDENTIFIER_DELIMITER_REGEXP).length == 3;
  }

  public static boolean isFQTableName(String tableName) {
    int lastDelimiterIdx = tableName.lastIndexOf(IDENTIFIER_DELIMITER);
    return lastDelimiterIdx > -1;
  }

  public static String [] splitFQTableName(String qualifiedName) {
    String [] splitted = splitTableName(qualifiedName);
    if (splitted.length == 1) {
      throw new IllegalArgumentException("Table name is expected to be qualified, but was \""
          + qualifiedName + "\".");
    }
    return splitted;
  }

  public static String [] splitTableName(String tableName) {
    int lastDelimiterIdx = tableName.lastIndexOf(IDENTIFIER_DELIMITER);
    if (lastDelimiterIdx > -1) {
      return new String [] {
          tableName.substring(0, lastDelimiterIdx),
          tableName.substring(lastDelimiterIdx + 1, tableName.length())
      };
    } else {
      return new String [] {tableName};
    }
  }

  public static String buildFQName(String... identifiers) {
    boolean first = true;
    StringBuilder sb = new StringBuilder();
    for(String id : identifiers) {
      if (first) {
        first = false;
      } else {
        sb.append(IDENTIFIER_DELIMITER);
      }

      sb.append(id);
    }

    return sb.toString();
  }

  public static Pair<String, String> separateQualifierAndName(String name) {
    Preconditions.checkArgument(isFQTableName(name), "Must be a qualified name.");
    return new Pair<>(extractQualifier(name), extractSimpleName(name));
  }

  /**
   * Extract a qualification name from an identifier.
   *
   * For example, consider a table identifier like 'database1.table1'.
   * In this case, this method extracts 'database1'.
   *
   * @param name The identifier to be extracted
   * @return The extracted qualifier
   */
  public static String extractQualifier(String name) {
    int lastDelimiterIdx = name.lastIndexOf(IDENTIFIER_DELIMITER);
    if (lastDelimiterIdx > -1) {
      return name.substring(0, lastDelimiterIdx);
    } else {
      return TajoConstants.EMPTY_STRING;
    }
  }

  /**
   * Extract a simple name from an identifier.
   *
   * For example, consider a table identifier like 'database1.table1'.
   * In this case, this method extracts 'table1'.
   *
   * @param name The identifier to be extracted
   * @return The extracted simple name
   */
  public static String extractSimpleName(String name) {
    int lastDelimiterIdx = name.lastIndexOf(IDENTIFIER_DELIMITER);
    if (lastDelimiterIdx > -1) {
      // plus one means skipping a delimiter.
      return name.substring(lastDelimiterIdx + 1, name.length());
    } else {
      return name;
    }
  }

  public static String getCanonicalTableName(String databaseName, String tableName) {
    StringBuilder sb = new StringBuilder(databaseName);
    sb.append(IDENTIFIER_DELIMITER);
    sb.append(tableName);
    return sb.toString();
  }
}