Java Code Examples for org.apache.calcite.sql.SqlIdentifier#getSimple()

/**
 * Finds a {@link org.apache.calcite.schema.CalciteSchema.TypeEntry} in a
 * given schema whose type has the given name, possibly qualified.
 *
 * @param rootSchema root schema
 * @param typeName name of the type, may be qualified or fully-qualified
 *
 * @return TypeEntry with a table with the given name, or null
 */
public static CalciteSchema.TypeEntry getTypeEntry(
    CalciteSchema rootSchema, SqlIdentifier typeName) {
  final String name;
  final List<String> path;
  if (typeName.isSimple()) {
    path = ImmutableList.of();
    name = typeName.getSimple();
  } else {
    path = Util.skipLast(typeName.names);
    name = Util.last(typeName.names);
  }
  CalciteSchema schema = rootSchema;
  for (String p : path) {
    if (schema == rootSchema
        && SqlNameMatchers.withCaseSensitive(true).matches(p, schema.getName())) {
      continue;
    }
    schema = schema.getSubSchema(p, true);
  }
  return schema == null ? null : schema.getType(name, false);
}
 

public SqlNode visit(SqlIdentifier id) {
	// Aliases, e.g. 'select a as x, b from t order by x'.
	if (id.isSimple()
		&& getConformance().isSortByAlias()) {
		String alias = id.getSimple();
		final SqlValidatorNamespace selectNs = getNamespace(select);
		final RelDataType rowType =
			selectNs.getRowTypeSansSystemColumns();
		final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
		RelDataTypeField field = nameMatcher.field(rowType, alias);
		if (field != null) {
			return nthSelectItem(
				field.getIndex(),
				id.getParserPosition());
		}
	}

	// No match. Return identifier unchanged.
	return getScope().fullyQualify(id).identifier;
}
 

public SqlNode visit(SqlIdentifier id) {
	// Aliases, e.g. 'select a as x, b from t order by x'.
	if (id.isSimple()
		&& getConformance().isSortByAlias()) {
		String alias = id.getSimple();
		final SqlValidatorNamespace selectNs = getNamespace(select);
		final RelDataType rowType =
			selectNs.getRowTypeSansSystemColumns();
		final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
		RelDataTypeField field = nameMatcher.field(rowType, alias);
		if (field != null) {
			return nthSelectItem(
				field.getIndex(),
				id.getParserPosition());
		}
	}

	// No match. Return identifier unchanged.
	return getScope().fullyQualify(id).identifier;
}
 

@Override
public void lookupOperatorOverloads(
		SqlIdentifier opName,
		SqlFunctionCategory category,
		SqlSyntax syntax,
		List<SqlOperator> operatorList,
		SqlNameMatcher nameMatcher) {
	if (!opName.isSimple()) {
		return;
	}

	// We lookup only user functions via CatalogOperatorTable. Built in functions should
	// go through BasicOperatorTable
	if (isNotUserFunction(category)) {
		return;
	}

	String name = opName.getSimple();
	Optional<FunctionLookup.Result> candidateFunction = functionCatalog.lookupFunction(name);

	candidateFunction.flatMap(lookupResult ->
		convertToSqlFunction(category, name, lookupResult.getFunctionDefinition())
	).ifPresent(operatorList::add);
}
 

@Override
public void lookupOperatorOverloads(
		SqlIdentifier opName,
		SqlFunctionCategory category,
		SqlSyntax syntax,
		List<SqlOperator> operatorList,
		SqlNameMatcher nameMatcher) {
	if (!opName.isSimple()) {
		return;
	}

	// We lookup only user functions via CatalogOperatorTable. Built in functions should
	// go through BasicOperatorTable
	if (isNotUserFunction(category)) {
		return;
	}

	String name = opName.getSimple();
	Optional<FunctionLookup.Result> candidateFunction = functionCatalog.lookupFunction(name);

	candidateFunction.flatMap(lookupResult ->
		convertToSqlFunction(category, name, lookupResult.getFunctionDefinition())
	).ifPresent(operatorList::add);
}
 

/**
 * Finds a {@link org.apache.calcite.jdbc.CalciteSchema.TypeEntry} in a
 * given schema whose type has the given name, possibly qualified.
 *
 * @param rootSchema root schema
 * @param typeName name of the type, may be qualified or fully-qualified
 *
 * @return TypeEntry with a table with the given name, or null
 */
public static CalciteSchema.TypeEntry getTypeEntry(
    CalciteSchema rootSchema, SqlIdentifier typeName) {
  final String name;
  final List<String> path;
  if (typeName.isSimple()) {
    path = ImmutableList.of();
    name = typeName.getSimple();
  } else {
    path = Util.skipLast(typeName.names);
    name = Util.last(typeName.names);
  }
  CalciteSchema schema = rootSchema;
  for (String p : path) {
    if (schema == rootSchema
        && SqlNameMatchers.withCaseSensitive(true).matches(p, schema.getName())) {
      continue;
    }
    schema = schema.getSubSchema(p, true);
  }
  return schema == null ? null : schema.getType(name, false);
}
 

@Override
public void lookupOperatorOverloads(
		SqlIdentifier opName,
		SqlFunctionCategory category,
		SqlSyntax syntax,
		List<SqlOperator> operatorList,
		SqlNameMatcher nameMatcher) {
	if (!opName.isSimple()) {
		return;
	}

	// We lookup only user functions via CatalogOperatorTable. Built in functions should
	// go through BasicOperatorTable
	if (isNotUserFunction(category)) {
		return;
	}

	String name = opName.getSimple();
	Optional<FunctionLookup.Result> candidateFunction = functionCatalog.lookupFunction(
		UnresolvedIdentifier.of(name));

	candidateFunction.flatMap(lookupResult ->
		convertToSqlFunction(category, name, lookupResult.getFunctionDefinition())
	).ifPresent(operatorList::add);
}
 

protected SqlWindow getWindowByName(
	SqlIdentifier id,
	SqlValidatorScope scope) {
	SqlWindow window = null;
	if (id.isSimple()) {
		final String name = id.getSimple();
		window = scope.lookupWindow(name);
	}
	if (window == null) {
		throw newValidationError(id, RESOURCE.windowNotFound(id.toString()));
	}
	return window;
}
 

@Override public SqlNode visit(SqlIdentifier id) {
	if (id.isSimple()
		&& (havingExpr
			    ? validator.getConformance().isHavingAlias()
			    : validator.getConformance().isGroupByAlias())) {
		String name = id.getSimple();
		SqlNode expr = null;
		final SqlNameMatcher nameMatcher =
			validator.catalogReader.nameMatcher();
		int n = 0;
		for (SqlNode s : select.getSelectList()) {
			final String alias = SqlValidatorUtil.getAlias(s, -1);
			if (alias != null && nameMatcher.matches(alias, name)) {
				expr = s;
				n++;
			}
		}
		if (n == 0) {
			return super.visit(id);
		} else if (n > 1) {
			// More than one column has this alias.
			throw validator.newValidationError(id,
				RESOURCE.columnAmbiguous(name));
		}
		if (havingExpr && validator.isAggregate(root)) {
			return super.visit(id);
		}
		expr = stripAs(expr);
		if (expr instanceof SqlIdentifier) {
			expr = getScope().fullyQualify((SqlIdentifier) expr).identifier;
		}
		return expr;
	}
	return super.visit(id);
}
 

protected SqlWindow getWindowByName(
	SqlIdentifier id,
	SqlValidatorScope scope) {
	SqlWindow window = null;
	if (id.isSimple()) {
		final String name = id.getSimple();
		window = scope.lookupWindow(name);
	}
	if (window == null) {
		throw newValidationError(id, RESOURCE.windowNotFound(id.toString()));
	}
	return window;
}
 

@Override public SqlNode visit(SqlIdentifier id) {
	if (id.isSimple()
		&& (havingExpr
			    ? validator.getConformance().isHavingAlias()
			    : validator.getConformance().isGroupByAlias())) {
		String name = id.getSimple();
		SqlNode expr = null;
		final SqlNameMatcher nameMatcher =
			validator.catalogReader.nameMatcher();
		int n = 0;
		for (SqlNode s : select.getSelectList()) {
			final String alias = SqlValidatorUtil.getAlias(s, -1);
			if (alias != null && nameMatcher.matches(alias, name)) {
				expr = s;
				n++;
			}
		}
		if (n == 0) {
			return super.visit(id);
		} else if (n > 1) {
			// More than one column has this alias.
			throw validator.newValidationError(id,
				RESOURCE.columnAmbiguous(name));
		}
		if (havingExpr && validator.isAggregate(root)) {
			return super.visit(id);
		}
		expr = stripAs(expr);
		if (expr instanceof SqlIdentifier) {
			SqlIdentifier sid = (SqlIdentifier) expr;
			final SqlIdentifier fqId = getScope().fullyQualify(sid).identifier;
			expr = expandDynamicStar(sid, fqId);
		}
		return expr;
	}
	return super.visit(id);
}
 

private static String findSinkName(SqlInsert sqlInsert) {
    SqlNode target = sqlInsert.getTargetTable();
    SqlKind targetKind = target.getKind();
    if (targetKind != SqlKind.IDENTIFIER) {
        throw new IllegalArgumentException("invalid insert SQL, sql:" + sqlInsert.toString());
    }
    SqlIdentifier identifier = (SqlIdentifier)target;
    return identifier.getSimple();
}
 

private static String idToRef(FromNode from, SqlIdentifier id) {
  if (isSimpleID(id)) {
    // TODO: need to check if quotes are correct
    return id.getSimple();
  } else {
    SqlIdentifier finalId = id;
    // removing unnecessary table prefix from col ref.
    if (id.names.size() > from.alias.names.size()) {
      boolean isPrefix = true;
      for (int i = 0; i < from.alias.names.size(); i++) {
        String an = from.alias.names.get(i);
        String idn = id.names.get(i);
        if (!an.equals(idn)) {
          isPrefix = false;
          break;
        }
      }
      if (isPrefix) {
        finalId = id.getComponent(from.alias.names.size(), id.names.size());
      }
    }
    if (!finalId.isSimple()) {
      throw new IllegalArgumentException("expected a simple type column name (directly or prefixed with table name/alias)");
    }
    return finalId.getSimple();
  }
}
 

public void lookupOperatorOverloads(SqlIdentifier opName,
    SqlFunctionCategory category, SqlSyntax syntax,
    List<SqlOperator> operatorList, SqlNameMatcher nameMatcher) {
  // NOTE jvs 3-Mar-2005:  ignore category until someone cares

  String simpleName;
  if (opName.names.size() > 1) {
    if (opName.names.get(opName.names.size() - 2).equals(IS_NAME)) {
      // per SQL99 Part 2 Section 10.4 Syntax Rule 7.b.ii.1
      simpleName = Util.last(opName.names);
    } else {
      return;
    }
  } else {
    simpleName = opName.getSimple();
  }

  final Collection<SqlOperator> list =
      lookUpOperators(simpleName, syntax, nameMatcher);
  if (list.isEmpty()) {
    return;
  }
  for (SqlOperator op : list) {
    if (op.getSyntax() == syntax) {
      operatorList.add(op);
    } else if (syntax == SqlSyntax.FUNCTION
        && op instanceof SqlFunction) {
      // this special case is needed for operators like CAST,
      // which are treated as functions but have special syntax
      operatorList.add(op);
    }
  }

  // REVIEW jvs 1-Jan-2005:  why is this extra lookup required?
  // Shouldn't it be covered by search above?
  switch (syntax) {
  case BINARY:
  case PREFIX:
  case POSTFIX:
    for (SqlOperator extra
        : lookUpOperators(simpleName, syntax, nameMatcher)) {
      // REVIEW: should only search operators added during this method?
      if (extra != null && !operatorList.contains(extra)) {
        operatorList.add(extra);
      }
    }
    break;
  }
}
 

private SqlAlterTableSetOption(SqlParserPos pos, SqlIdentifier table, SqlIdentifier scope, SqlIdentifier name, SqlNode value) {
  super(pos, scope.getSimple(), name, value);
  this.table = table;
}
 

@Override
public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
	final SqlIdentifier typeName = getTypeName();
	String name = typeName.getSimple();
	if (typeName instanceof ExtendedSqlType) {
		typeName.unparse(writer, leftPrec, rightPrec);
	} else if (SqlTypeName.get(name) != null) {
		SqlTypeName sqlTypeName = SqlTypeName.get(name);
		writer.keyword(name);
		if (sqlTypeName.allowsPrec() && this.getPrecision() >= 0) {
			SqlWriter.Frame frame = writer.startList(SqlWriter.FrameTypeEnum.FUN_CALL, "(", ")");
			writer.print(this.getPrecision());
			if (sqlTypeName.allowsScale() && this.getScale() >= 0) {
				writer.sep(",", true);
				writer.print(this.getScale());
			}

			writer.endList(frame);
		}

		if (this.getCharSetName() != null) {
			writer.keyword("CHARACTER SET");
			writer.identifier(this.getCharSetName(), false);
		}

		if (this.getCollectionsTypeName() != null) {
			// Fix up nullable attribute if this is a collection type.
			if (elementNullable != null && !elementNullable) {
				writer.keyword("NOT NULL");
			}
			writer.keyword(this.getCollectionsTypeName().getSimple());
		}
	} else if (name.startsWith("_")) {
		writer.keyword(name.substring(1));
	} else {
		this.getTypeName().unparse(writer, leftPrec, rightPrec);
	}
	if (getNullable() != null && !getNullable()) {
		writer.keyword("NOT NULL");
	}
}
 

public void lookupOperatorOverloads(SqlIdentifier opName,
    SqlFunctionCategory category,
    SqlSyntax syntax,
    List<SqlOperator> operatorList) {
  // NOTE jvs 3-Mar-2005:  ignore category until someone cares

  String simpleName;
  if (opName.names.size() > 1) {
    if (opName.names.get(opName.names.size() - 2).equals(IS_NAME)) {
      // per SQL99 Part 2 Section 10.4 Syntax Rule 7.b.ii.1
      simpleName = Util.last(opName.names);
    } else {
      return;
    }
  } else {
    simpleName = opName.getSimple();
  }

  // Always look up built-in operators case-insensitively. Even in sessions
  // with unquotedCasing=UNCHANGED and caseSensitive=true.
  final Collection<SqlOperator> list =
      operators.get(new Key(simpleName, syntax));
  if (list.isEmpty()) {
    return;
  }
  for (SqlOperator op : list) {
    if (op.getSyntax() == syntax) {
      operatorList.add(op);
    } else if (syntax == SqlSyntax.FUNCTION
        && op instanceof SqlFunction) {
      // this special case is needed for operators like CAST,
      // which are treated as functions but have special syntax
      operatorList.add(op);
    }
  }

  // REVIEW jvs 1-Jan-2005:  why is this extra lookup required?
  // Shouldn't it be covered by search above?
  switch (syntax) {
  case BINARY:
  case PREFIX:
  case POSTFIX:
    for (SqlOperator extra : operators.get(new Key(simpleName, syntax))) {
      // REVIEW: should only search operators added during this method?
      if (extra != null && !operatorList.contains(extra)) {
        operatorList.add(extra);
      }
    }
    break;
  }
}