code stringlengths 25 201k | docstring stringlengths 19 96.2k | func_name stringlengths 0 235 | language stringclasses 1 value | repo stringlengths 8 51 | path stringlengths 11 314 | url stringlengths 62 377 | license stringclasses 7 values |
|---|---|---|---|---|---|---|---|
@Override
public RexNode convertCall(SqlRexContext cx, SqlCall call) {
// TIMESTAMP_SUB(timestamp, interval)
// => timestamp - count * INTERVAL '1' UNIT
final RexBuilder rexBuilder = cx.getRexBuilder();
final SqlBasicCall operandCall = call.operand(1);
SqlIntervalQualifier qualifier = operandCall.operand(1);
final RexNode op1 = cx.convertExpression(operandCall.operand(0));
final RexNode op2 = cx.convertExpression(call.operand(0));
final TimeFrame timeFrame = cx.getValidator().validateTimeFrame(qualifier);
final TimeUnit unit = first(timeFrame.unit(), TimeUnit.EPOCH);
final RexNode interval2Sub;
switch (unit) {
// Fractional second units are converted to seconds using their associated
// multiplier.
case MICROSECOND:
case NANOSECOND:
interval2Sub =
divide(
rexBuilder,
multiply(
rexBuilder,
rexBuilder.makeIntervalLiteral(
BigDecimal.ONE, qualifier),
op1),
BigDecimal.ONE.divide(
unit.multiplier, RoundingMode.UNNECESSARY));
break;
default:
interval2Sub =
multiply(
rexBuilder,
rexBuilder.makeIntervalLiteral(unit.multiplier, qualifier),
op1);
}
return rexBuilder.makeCall(SqlInternalOperators.MINUS_DATE2, op2, interval2Sub);
} | Convertlet that handles the BigQuery {@code TIMESTAMP_SUB} function. | convertCall | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java | Apache-2.0 |
@Override
public RexNode convertCall(SqlRexContext cx, SqlCall call) {
// The standard TIMESTAMPDIFF and BigQuery's TIMESTAMP_DIFF have two key
// differences. The first being the order of the subtraction, outlined
// below. The second is that BigQuery truncates each timestamp to the
// specified time unit before the difference is computed.
//
// In fact, all BigQuery functions (TIMESTAMP_DIFF, DATETIME_DIFF,
// DATE_DIFF) truncate before subtracting when applied to date intervals
// (DAY, WEEK, ISOWEEK, MONTH, YEAR, etc.)
//
// For example, if computing the number of weeks between two timestamps,
// one occurring on a Saturday and the other occurring the next day on
// Sunday, their week difference is 1. This is because the first timestamp
// is truncated to the previous Sunday. This is done by making calls to
// TIMESTAMP_TRUNC and the difference is then computed using their
// results.
//
// TIMESTAMPDIFF(unit, t1, t2)
// => (t2 - t1) UNIT
// TIMESTAMP_DIFF(t1, t2, unit)
// => (t1 - t2) UNIT
SqlIntervalQualifier qualifier;
final boolean preTruncate;
final RexNode op1;
final RexNode op2;
if (call.operand(0).getKind() == SqlKind.INTERVAL_QUALIFIER) {
qualifier = call.operand(0);
preTruncate = false;
op1 = cx.convertExpression(call.operand(1));
op2 = cx.convertExpression(call.operand(2));
} else {
qualifier = call.operand(2);
preTruncate = qualifier.isDate();
op1 = cx.convertExpression(call.operand(1));
op2 = cx.convertExpression(call.operand(0));
}
final RexBuilder rexBuilder = cx.getRexBuilder();
final RelDataTypeFactory typeFactory = cx.getTypeFactory();
final TimeFrame timeFrame = cx.getValidator().validateTimeFrame(qualifier);
final TimeUnit unit = first(timeFrame.unit(), TimeUnit.EPOCH);
UnaryOperator<RexNode> truncateFn = UnaryOperator.identity();
if (unit == TimeUnit.EPOCH && qualifier.timeFrameName != null) {
// Custom time frames have a different path. They are kept as names, and
// then handled by Java functions.
final RexLiteral timeFrameName = rexBuilder.makeLiteral(qualifier.timeFrameName);
// This additional logic accounts for BigQuery truncating prior to
// computing the difference.
if (preTruncate) {
truncateFn =
e ->
rexBuilder.makeCall(
e.getType(),
SqlLibraryOperators.TIMESTAMP_TRUNC,
ImmutableList.of(e, timeFrameName));
}
return rexBuilder.makeCall(
cx.getValidator().getValidatedNodeType(call),
SqlStdOperatorTable.TIMESTAMP_DIFF,
ImmutableList.of(
timeFrameName, truncateFn.apply(op1), truncateFn.apply(op2)));
}
if (preTruncate) {
// The timestamps should be truncated unless the time unit is HOUR, in
// which case only the whole number of hours between the timestamps
// should be returned.
final RexNode timeUnit = cx.convertExpression(qualifier);
truncateFn =
e ->
rexBuilder.makeCall(
e.getType(),
SqlLibraryOperators.TIMESTAMP_TRUNC,
ImmutableList.of(e, timeUnit));
}
BigDecimal multiplier = BigDecimal.ONE;
BigDecimal divider = BigDecimal.ONE;
SqlTypeName sqlTypeName =
unit == TimeUnit.NANOSECOND ? SqlTypeName.BIGINT : SqlTypeName.INTEGER;
switch (unit) {
case MICROSECOND:
case MILLISECOND:
case NANOSECOND:
case WEEK:
multiplier = BigDecimal.valueOf(DateTimeUtils.MILLIS_PER_SECOND);
divider = unit.multiplier;
qualifier =
new SqlIntervalQualifier(
TimeUnit.SECOND, null, qualifier.getParserPosition());
break;
case QUARTER:
case CENTURY:
case MILLENNIUM:
divider = unit.multiplier;
qualifier =
new SqlIntervalQualifier(
TimeUnit.MONTH, null, qualifier.getParserPosition());
break;
default:
qualifier = new SqlIntervalQualifier(unit, null, qualifier.getParserPosition());
break;
}
final RelDataType intervalType =
typeFactory.createTypeWithNullability(
typeFactory.createSqlIntervalType(qualifier),
op1.getType().isNullable() || op2.getType().isNullable());
final RexNode call2 =
rexBuilder.makeCall(
intervalType,
SqlStdOperatorTable.MINUS_DATE,
ImmutableList.of(truncateFn.apply(op2), truncateFn.apply(op1)));
final RelDataType intType =
typeFactory.createTypeWithNullability(
typeFactory.createSqlType(sqlTypeName),
SqlTypeUtil.containsNullable(call2.getType()));
RexNode e = rexBuilder.makeCast(intType, call2);
return rexBuilder.multiplyDivide(e, multiplier, divider);
} | Convertlet that handles the {@code TIMESTAMPDIFF} function. | convertCall | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java | Apache-2.0 |
private static Config getConfig(Context context) {
final Config config = context.maybeUnwrap(Config.class).orElse(Config.DEFAULT);
boolean simplify = Hook.REL_BUILDER_SIMPLIFY.get(config.simplify());
return config.withSimplify(simplify);
} | Derives the Config to be used for this RelBuilder.
<p>Overrides {@link RelBuilder.Config#simplify} if {@link Hook#REL_BUILDER_SIMPLIFY} is set. | getConfig | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RelBuilder transform(UnaryOperator<Config> transform) {
final Context context = Contexts.of(struct, transform.apply(config));
return new RelBuilder(context, cluster, relOptSchema);
} | Creates a copy of this RelBuilder, with the same state as this, applying a transform to the
config. | transform | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public <R> R let(Function<RelBuilder, R> consumer) {
return consumer.apply(this);
} | Performs an action on this RelBuilder.
<p>For example, consider the following code:
<blockquote>
<pre>
RelNode filterAndRename(RelBuilder relBuilder, RelNode rel,
RexNode condition, List<String> fieldNames) {
relBuilder.push(rel)
.filter(condition);
if (fieldNames != null) {
relBuilder.rename(fieldNames);
}
return relBuilder
.build();</pre>
</blockquote>
<p>The pipeline is disrupted by the 'if'. The {@code let} method allows you to perform the
flow as a single pipeline:
<blockquote>
<pre>
RelNode filterAndRename(RelBuilder relBuilder, RelNode rel,
RexNode condition, List<String> fieldNames) {
return relBuilder.push(rel)
.filter(condition)
.let(r -> fieldNames == null ? r : r.rename(fieldNames))
.build();</pre>
</blockquote>
<p>In pipelined cases such as this one, the lambda must return this RelBuilder. But {@code
let} return values of other types. | let | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
@Override
public String toString() {
return stack.stream()
.map(frame -> RelOptUtil.toString(frame.rel))
.collect(Collectors.joining(""));
} | Converts this RelBuilder to a string. The string is the string representation of all of the
RelNodes on the stack. | toString | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RelBuilder adoptConvention(Convention convention) {
this.struct = convention.getRelFactories();
return this;
} | Returns new RelBuilder that adopts the convention provided. RelNode will be created with such
convention if corresponding factory is provided. | adoptConvention | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexBuilder getRexBuilder() {
return cluster.getRexBuilder();
} | Returns the builder for {@link RexNode} expressions. | getRexBuilder | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public static RelBuilderFactory proto(final Context context) {
return (cluster, schema) -> new RelBuilder(context, cluster, schema);
} | Creates a {@link RelBuilderFactory}, a partially-created RelBuilder. Just add a {@link
RelOptCluster} and a {@link RelOptSchema} | proto | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RelBuilder push(RelNode node) {
stack.push(new Frame(node));
return this;
} | Adds a relational expression to be the input to the next relational expression constructed.
<p>This method is usual when you want to weave in relational expressions that are not
supported by the builder. If, while creating such expressions, you need to use previously
built expressions as inputs, call {@link #build()} to pop those inputs. | push | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
private void replaceTop(RelNode node) {
final Frame frame = stack.pop();
stack.push(new Frame(node, frame.fields));
} | Adds a rel node to the top of the stack while preserving the field names and aliases. | replaceTop | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public int size() {
return stack.size();
} | Returns the size of the stack. | size | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RelNode build() {
return stack.pop().rel;
} | Returns the final relational expression.
<p>Throws if the stack is empty. | build | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
private int inputOffset(int inputCount, int inputOrdinal) {
int offset = 0;
for (int i = 0; i < inputOrdinal; i++) {
offset += peek(inputCount, i).getRowType().getFieldCount();
}
return offset;
} | Returns the number of fields in all inputs before (to the left of) the given input.
@param inputCount Number of inputs
@param inputOrdinal Input ordinal | inputOffset | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public <E> E with(RelNode r, Function<RelBuilder, E> fn) {
try {
push(r);
return fn.apply(this);
} finally {
stack.pop();
}
} | Evaluates an expression with a relational expression temporarily on the stack. | with | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public <E> E withSimplifier(
BiFunction<RelBuilder, RexSimplify, RexSimplify> simplifierTransform,
Function<RelBuilder, E> fn) {
final RexSimplify previousSimplifier = this.simplifier;
try {
this.simplifier = simplifierTransform.apply(this, previousSimplifier);
return fn.apply(this);
} finally {
this.simplifier = previousSimplifier;
}
} | Performs an action with a temporary simplifier. | withSimplifier | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public <E> E withPredicates(RelMetadataQuery mq, Function<RelBuilder, E> fn) {
final RelOptPredicateList predicates = mq.getPulledUpPredicates(peek());
return withSimplifier((r, s) -> s.withPredicates(predicates), fn);
} | Performs an action using predicates of the {@link #peek() current node} to simplify. | withPredicates | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RelBuilder variable(Holder<RexCorrelVariable> v) {
v.set(
(RexCorrelVariable)
getRexBuilder().makeCorrel(peek().getRowType(), cluster.createCorrel()));
return this;
} | Creates a correlation variable for the current input, and writes it into a Holder. | variable | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexInputRef field(String fieldName) {
return field(1, 0, fieldName);
} | Creates a reference to a field by name.
<p>Equivalent to {@code field(1, 0, fieldName)}.
@param fieldName Field name | field | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexInputRef field(int inputCount, int inputOrdinal, String fieldName) {
final Frame frame = peek_(inputCount, inputOrdinal);
final List<String> fieldNames = Pair.left(frame.fields());
int i = fieldNames.indexOf(fieldName);
if (i >= 0) {
return field(inputCount, inputOrdinal, i);
} else {
throw new IllegalArgumentException(
"field [" + fieldName + "] not found; input fields are: " + fieldNames);
}
} | Creates a reference to a field of given input relational expression by name.
@param inputCount Number of inputs
@param inputOrdinal Input ordinal
@param fieldName Field name | field | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexInputRef field(int fieldOrdinal) {
return (RexInputRef) field(1, 0, fieldOrdinal, false);
} | Creates a reference to an input field by ordinal.
<p>Equivalent to {@code field(1, 0, ordinal)}.
@param fieldOrdinal Field ordinal | field | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexInputRef field(int inputCount, int inputOrdinal, int fieldOrdinal) {
return (RexInputRef) field(inputCount, inputOrdinal, fieldOrdinal, false);
} | Creates a reference to a field of a given input relational expression by ordinal.
@param inputCount Number of inputs
@param inputOrdinal Input ordinal
@param fieldOrdinal Field ordinal within input | field | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
private RexNode field(int inputCount, int inputOrdinal, int fieldOrdinal, boolean alias) {
final Frame frame = peek_(inputCount, inputOrdinal);
final RelNode input = frame.rel;
final RelDataType rowType = input.getRowType();
if (fieldOrdinal < 0 || fieldOrdinal > rowType.getFieldCount()) {
throw new IllegalArgumentException(
"field ordinal ["
+ fieldOrdinal
+ "] out of range; input fields are: "
+ rowType.getFieldNames());
}
final RelDataTypeField field = rowType.getFieldList().get(fieldOrdinal);
final int offset = inputOffset(inputCount, inputOrdinal);
final RexInputRef ref =
cluster.getRexBuilder().makeInputRef(field.getType(), offset + fieldOrdinal);
final RelDataTypeField aliasField = frame.fields().get(fieldOrdinal);
if (!alias || field.getName().equals(aliasField.getName())) {
return ref;
} else {
return alias(ref, aliasField.getName());
}
} | As {@link #field(int, int, int)}, but if {@code alias} is true, the method may apply an alias
to make sure that the field has the same name as in the input frame. If no alias is applied
the expression is definitely a {@link RexInputRef}. | field | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexNode field(String alias, String fieldName) {
return field(1, alias, fieldName);
} | Creates a reference to a field of the current record which originated in a relation with a
given alias. | field | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexNode field(int inputCount, String alias, String fieldName) {
requireNonNull(alias, "alias");
requireNonNull(fieldName, "fieldName");
final List<String> fields = new ArrayList<>();
for (int inputOrdinal = 0; inputOrdinal < inputCount; ++inputOrdinal) {
final Frame frame = peek_(inputOrdinal);
for (Ord<Field> p : Ord.zip(frame.fields)) {
// If alias and field name match, reference that field.
if (p.e.left.contains(alias) && p.e.right.getName().equals(fieldName)) {
return field(inputCount, inputCount - 1 - inputOrdinal, p.i);
}
fields.add(
String.format(
Locale.ROOT,
"{aliases=%s,fieldName=%s}",
p.e.left,
p.e.right.getName()));
}
}
throw new IllegalArgumentException(
"{alias="
+ alias
+ ",fieldName="
+ fieldName
+ "} "
+ "field not found; fields are: "
+ fields);
} | Creates a reference to a field which originated in a relation with the given alias. Searches
for the relation starting at the top of the stack. | field | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexNode field(RexNode e, String name) {
return getRexBuilder().makeFieldAccess(e, name, false);
} | Returns a reference to a given field of a record-valued expression. | field | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public ImmutableList<RexNode> fields() {
return fields(1, 0);
} | Returns references to the fields of the top input. | fields | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public ImmutableList<RexNode> fields(int inputCount, int inputOrdinal) {
final RelNode input = peek(inputCount, inputOrdinal);
final RelDataType rowType = input.getRowType();
final ImmutableList.Builder<RexNode> nodes = ImmutableList.builder();
for (int fieldOrdinal : Util.range(rowType.getFieldCount())) {
nodes.add(field(inputCount, inputOrdinal, fieldOrdinal));
}
return nodes.build();
} | Returns references to the fields of a given input. | fields | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public ImmutableList<RexNode> fields(RelCollation collation) {
final ImmutableList.Builder<RexNode> nodes = ImmutableList.builder();
for (RelFieldCollation fieldCollation : collation.getFieldCollations()) {
RexNode node = field(fieldCollation.getFieldIndex());
switch (fieldCollation.direction) {
case DESCENDING:
node = desc(node);
break;
default:
break;
}
switch (fieldCollation.nullDirection) {
case FIRST:
node = nullsFirst(node);
break;
case LAST:
node = nullsLast(node);
break;
default:
break;
}
nodes.add(node);
}
return nodes.build();
} | Returns references to fields for a given collation. | fields | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public ImmutableList<RexNode> fields(List<? extends Number> ordinals) {
final ImmutableList.Builder<RexNode> nodes = ImmutableList.builder();
for (Number ordinal : ordinals) {
RexNode node = field(1, 0, ordinal.intValue(), false);
nodes.add(node);
}
return nodes.build();
} | Returns references to fields for a given list of input ordinals. | fields | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public ImmutableList<RexNode> fields(ImmutableBitSet ordinals) {
return fields(ordinals.asList());
} | Returns references to fields for a given bit set of input ordinals. | fields | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public ImmutableList<RexNode> fields(Iterable<String> fieldNames) {
final ImmutableList.Builder<RexNode> builder = ImmutableList.builder();
for (String fieldName : fieldNames) {
builder.add(field(fieldName));
}
return builder.build();
} | Returns references to fields identified by name. | fields | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public ImmutableList<RexNode> fields(Mappings.TargetMapping mapping) {
return fields(Mappings.asListNonNull(mapping));
} | Returns references to fields identified by a mapping. | fields | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexNode dot(RexNode node, String fieldName) {
final RexBuilder builder = cluster.getRexBuilder();
return builder.makeFieldAccess(node, fieldName, true);
} | Creates an access to a field by name. | dot | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexNode dot(RexNode node, int fieldOrdinal) {
final RexBuilder builder = cluster.getRexBuilder();
return builder.makeFieldAccess(node, fieldOrdinal);
} | Creates an access to a field by ordinal. | dot | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexNode in(RexNode arg, RexNode... ranges) {
return in(arg, ImmutableList.copyOf(ranges));
} | Creates an IN predicate with a list of values.
<p>For example,
<pre>{@code
b.scan("Emp")
.filter(b.in(b.field("deptno"), b.literal(10), b.literal(20)))
}</pre>
is equivalent to SQL
<pre>{@code
SELECT *
FROM Emp
WHERE deptno IN (10, 20)
}</pre> | in | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexNode in(RexNode arg, Iterable<? extends RexNode> ranges) {
return getRexBuilder().makeIn(arg, ImmutableList.copyOf(ranges));
} | Creates an IN predicate with a list of values.
<p>For example,
<pre>{@code
b.scan("Emps")
.filter(
b.in(b.field("deptno"),
Arrays.asList(b.literal(10), b.literal(20))))
}</pre>
<p>is equivalent to the SQL
<pre>{@code
SELECT *
FROM Emps
WHERE deptno IN (10, 20)
}</pre> | in | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
@Experimental
public RexSubQuery in(RelNode rel, Iterable<? extends RexNode> nodes) {
return RexSubQuery.in(rel, ImmutableList.copyOf(nodes));
} | Creates an IN predicate with a sub-query. | in | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
@Experimental
public RexNode in(RexNode arg, Function<RelBuilder, RelNode> f) {
final RelNode rel = f.apply(this);
return RexSubQuery.in(rel, ImmutableList.of(arg));
} | Creates an IN predicate with a sub-query.
<p>For example,
<pre>{@code
b.scan("Emps")
.filter(
b.in(b.field("deptno"),
b2 -> b2.scan("Depts")
.filter(
b2.eq(b2.field("location"), b2.literal("Boston")))
.project(b.field("deptno"))
.build()))
}</pre>
<p>is equivalent to the SQL
<pre>{@code
SELECT *
FROM Emps
WHERE deptno IN (SELECT deptno FROM Dept WHERE location = 'Boston')
}</pre> | in | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
@Experimental
public RexNode all(RexNode node, SqlOperator op, Function<RelBuilder, RelNode> f) {
return not(some_(node, op.kind.negateNullSafe(), f));
} | Creates an ALL predicate.
<p>For example,
<pre>{@code
b.scan("Emps")
.filter(
b.all(b.field("commission"),
SqlStdOperatorTable.GREATER_THAN,
b2 -> b2.scan("Emps")
.filter(
b2.eq(b2.field("job"), b2.literal("Manager")))
.project(b2.field("sal"))
.build()))
}</pre>
<p>is equivalent to the SQL
<pre>{@code
SELECT *
FROM Emps
WHERE commission > ALL (SELECT sal FROM Emps WHERE job = 'Manager')
}</pre>
<p>Calcite translates {@code ALL} predicates to {@code NOT SOME}. The following SQL is
equivalent to the previous:
<pre>{@code
SELECT *
FROM Emps
WHERE NOT (commission <= SOME (SELECT sal FROM Emps WHERE job = 'Manager'))
}</pre> | all | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
@Experimental
public RexSubQuery exists(Function<RelBuilder, RelNode> f) {
final RelNode rel = f.apply(this);
return RexSubQuery.exists(rel);
} | Creates an EXISTS predicate.
<p>For example,
<pre>{@code
b.scan("Depts")
.filter(
b.exists(b2 ->
b2.scan("Emps")
.filter(
b2.eq(b2.field("job"), b2.literal("Manager")))
.build()))
}</pre>
<p>is equivalent to the SQL
<pre>{@code
SELECT *
FROM Depts
WHERE EXISTS (SELECT 1 FROM Emps WHERE job = 'Manager')
}</pre> | exists | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
@Experimental
public RexSubQuery unique(Function<RelBuilder, RelNode> f) {
final RelNode rel = f.apply(this);
return RexSubQuery.unique(rel);
} | Creates a UNIQUE predicate.
<p>For example,
<pre>{@code
b.scan("Depts")
.filter(
b.exists(b2 ->
b2.scan("Emps")
.filter(
b2.eq(b2.field("job"), b2.literal("Manager")))
.project(b2.field("deptno")
.build()))
}</pre>
<p>is equivalent to the SQL
<pre>{@code
SELECT *
FROM Depts
WHERE UNIQUE (SELECT deptno FROM Emps WHERE job = 'Manager')
}</pre> | unique | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
@Experimental
public RexSubQuery scalarQuery(Function<RelBuilder, RelNode> f) {
return RexSubQuery.scalar(f.apply(this));
} | Creates a scalar sub-query.
<p>For example,
<pre>{@code
b.scan("Depts")
.project(
b.field("deptno")
b.scalarQuery(b2 ->
b2.scan("Emps")
.aggregate(
b2.eq(b2.field("job"), b2.literal("Manager")))
.build()))
}</pre>
<p>is equivalent to the SQL
<pre>{@code
SELECT deptno, (SELECT MAX(sal) FROM Emps)
FROM Depts
}</pre> | scalarQuery | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
@Experimental
public RexSubQuery arrayQuery(Function<RelBuilder, RelNode> f) {
return RexSubQuery.array(f.apply(this));
} | Creates an ARRAY sub-query.
<p>For example,
<pre>{@code
b.scan("Depts")
.project(
b.field("deptno")
b.arrayQuery(b2 ->
b2.scan("Emps")
.build()))
}</pre>
<p>is equivalent to the SQL
<pre>{@code
SELECT deptno, ARRAY (SELECT * FROM Emps)
FROM Depts
}</pre> | arrayQuery | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
@Experimental
public RexSubQuery multisetQuery(Function<RelBuilder, RelNode> f) {
return RexSubQuery.multiset(f.apply(this));
} | Creates a MULTISET sub-query.
<p>For example,
<pre>{@code
b.scan("Depts")
.project(
b.field("deptno")
b.multisetQuery(b2 ->
b2.scan("Emps")
.build()))
}</pre>
<p>is equivalent to the SQL
<pre>{@code
SELECT deptno, MULTISET (SELECT * FROM Emps)
FROM Depts
}</pre> | multisetQuery | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
@Experimental
public RexSubQuery mapQuery(Function<RelBuilder, RelNode> f) {
return RexSubQuery.map(f.apply(this));
} | Creates a MAP sub-query.
<p>For example,
<pre>{@code
b.scan("Depts")
.project(
b.field("deptno")
b.multisetQuery(b2 ->
b2.scan("Emps")
.project(b2.field("empno"), b2.field("job"))
.build()))
}</pre>
<p>is equivalent to the SQL
<pre>{@code
SELECT deptno, MAP (SELECT empno, job FROM Emps)
FROM Depts
}</pre> | mapQuery | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexNode and(Iterable<? extends RexNode> operands) {
return RexUtil.composeConjunction(getRexBuilder(), operands);
} | Creates an AND.
<p>Simplifies the expression a little: {@code e AND TRUE} becomes {@code e}; {@code e AND e2
AND NOT e} becomes {@code e2}. | and | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexNode isNotDistinctFrom(RexNode operand0, RexNode operand1) {
return RelOptUtil.isDistinctFrom(getRexBuilder(), operand0, operand1, true);
} | Creates an expression equivalent to "{@code o0 IS NOT DISTINCT FROM o1}". It is also
equivalent to "{@code o0 = o1 OR (o0 IS NULL AND o1 IS NULL)}". | isNotDistinctFrom | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexNode isDistinctFrom(RexNode operand0, RexNode operand1) {
return RelOptUtil.isDistinctFrom(getRexBuilder(), operand0, operand1, false);
} | Creates an expression equivalent to {@code o0 IS DISTINCT FROM o1}. It is also equivalent to
"{@code NOT (o0 = o1 OR (o0 IS NULL AND o1 IS NULL))}. | isDistinctFrom | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexNode isNotNull(RexNode operand) {
return call(SqlStdOperatorTable.IS_NOT_NULL, operand);
} | Creates an {@code IS NOT NULL}. | isNotNull | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexNode cast(RexNode expr, SqlTypeName typeName) {
final RelDataType type = cluster.getTypeFactory().createSqlType(typeName);
return cluster.getRexBuilder().makeCast(type, expr);
} | Creates an expression that casts an expression to a given type. | cast | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexNode cast(RexNode expr, SqlTypeName typeName, int precision) {
final RelDataType type = cluster.getTypeFactory().createSqlType(typeName, precision);
return cluster.getRexBuilder().makeCast(type, expr);
} | Creates an expression that casts an expression to a type with a given name and precision or
length. | cast | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexNode cast(RexNode expr, SqlTypeName typeName, int precision, int scale) {
final RelDataType type = cluster.getTypeFactory().createSqlType(typeName, precision, scale);
return cluster.getRexBuilder().makeCast(type, expr);
} | Creates an expression that casts an expression to a type with a given name, precision and
scale. | cast | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexNode alias(RexNode expr, String alias) {
final RexNode aliasLiteral = literal(alias);
switch (expr.getKind()) {
case AS:
final RexCall call = (RexCall) expr;
if (call.operands.get(1).equals(aliasLiteral)) {
// current alias is correct
return expr;
}
expr = call.operands.get(0);
// strip current (incorrect) alias, and fall through
default:
return call(SqlStdOperatorTable.AS, expr, aliasLiteral);
}
} | Returns an expression wrapped in an alias.
<p>This method is idempotent: If the expression is already wrapped in the correct alias, does
nothing; if wrapped in an incorrect alias, removes the incorrect alias and applies the
correct alias.
@see #project | alias | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexNode nullsLast(RexNode node) {
return call(SqlStdOperatorTable.NULLS_LAST, node);
} | Converts a sort expression to nulls last. | nullsLast | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexNode nullsFirst(RexNode node) {
return call(SqlStdOperatorTable.NULLS_FIRST, node);
} | Converts a sort expression to nulls first. | nullsFirst | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexWindowBound unboundedPreceding() {
return RexWindowBounds.UNBOUNDED_PRECEDING;
} | Creates an {@code UNBOUNDED PRECEDING} window bound, for use in methods such as {@link
OverCall#rowsFrom(RexWindowBound)} and {@link OverCall#rangeBetween(RexWindowBound,
RexWindowBound)}. | unboundedPreceding | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexWindowBound preceding(RexNode bound) {
return RexWindowBounds.preceding(bound);
} | Creates a {@code bound PRECEDING} window bound, for use in methods such as {@link
OverCall#rowsFrom(RexWindowBound)} and {@link OverCall#rangeBetween(RexWindowBound,
RexWindowBound)}. | preceding | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexWindowBound currentRow() {
return RexWindowBounds.CURRENT_ROW;
} | Creates a {@code CURRENT ROW} window bound, for use in methods such as {@link
OverCall#rowsFrom(RexWindowBound)} and {@link OverCall#rangeBetween(RexWindowBound,
RexWindowBound)}. | currentRow | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexWindowBound following(RexNode bound) {
return RexWindowBounds.following(bound);
} | Creates a {@code bound FOLLOWING} window bound, for use in methods such as {@link
OverCall#rowsFrom(RexWindowBound)} and {@link OverCall#rangeBetween(RexWindowBound,
RexWindowBound)}. | following | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexWindowBound unboundedFollowing() {
return RexWindowBounds.UNBOUNDED_FOLLOWING;
} | Creates an {@code UNBOUNDED FOLLOWING} window bound, for use in methods such as {@link
OverCall#rowsFrom(RexWindowBound)} and {@link OverCall#rangeBetween(RexWindowBound,
RexWindowBound)}. | unboundedFollowing | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public GroupKey groupKey(
Iterable<? extends RexNode> nodes,
Iterable<? extends Iterable<? extends RexNode>> nodeLists) {
return groupKey_(nodes, nodeLists);
} | Creates a group key with grouping sets. | groupKey | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public GroupKey groupKey(int... fieldOrdinals) {
return groupKey(fields(ImmutableIntList.of(fieldOrdinals)));
} | Creates a group key of fields identified by ordinal. | groupKey | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public GroupKey groupKey(String... fieldNames) {
return groupKey(fields(ImmutableList.copyOf(fieldNames)));
} | Creates a group key of fields identified by name. | groupKey | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public GroupKey groupKey(ImmutableBitSet groupSet) {
return groupKey_(groupSet, ImmutableList.of(groupSet));
} | Creates a group key, identified by field positions in the underlying relational expression.
<p>This method of creating a group key does not allow you to group on new expressions, only
column projections, but is efficient, especially when you are coming from an existing {@link
Aggregate}. | groupKey | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public GroupKey groupKey(
ImmutableBitSet groupSet, Iterable<? extends ImmutableBitSet> groupSets) {
return groupKey_(groupSet, ImmutableList.copyOf(groupSets));
} | Creates a group key with grouping sets, both identified by field positions in the underlying
relational expression.
<p>This method of creating a group key does not allow you to group on new expressions, only
column projections, but is efficient, especially when you are coming from an existing {@link
Aggregate}.
<p>It is possible for {@code groupSet} to be strict superset of all {@code groupSets}. For
example, in the pseudo SQL
<pre>{@code
GROUP BY 0, 1, 2
GROUPING SETS ((0, 1), 0)
}</pre>
<p>column 2 does not appear in either grouping set. This is not valid SQL. We can approximate
in actual SQL by adding an extra grouping set and filtering out using {@code HAVING}, as
follows:
<pre>{@code
GROUP BY GROUPING SETS ((0, 1, 2), (0, 1), 0)
HAVING GROUPING_ID(0, 1, 2) <> 0
}</pre> | groupKey | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public AggCall aggregateCall(AggregateCall a) {
return aggregateCall(
a.getAggregation(),
a.isDistinct(),
a.isApproximate(),
a.ignoreNulls(),
a.filterArg < 0 ? null : field(a.filterArg),
a.distinctKeys == null ? null : fields(a.distinctKeys),
fields(a.collation),
a.name,
fields(a.getArgList()));
} | Creates a call to an aggregate function as a copy of an {@link AggregateCall}. | aggregateCall | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public AggCall aggregateCall(AggregateCall a, Mapping mapping) {
return aggregateCall(
a.getAggregation(),
a.isDistinct(),
a.isApproximate(),
a.ignoreNulls(),
a.filterArg < 0 ? null : field(Mappings.apply(mapping, a.filterArg)),
a.distinctKeys == null ? null : fields(Mappings.apply(mapping, a.distinctKeys)),
fields(RexUtil.apply(mapping, a.collation)),
a.name,
fields(Mappings.apply2(mapping, a.getArgList())));
} | Creates a call to an aggregate function as a copy of an {@link AggregateCall}, applying a
mapping. | aggregateCall | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
protected AggCall aggregateCall(
SqlAggFunction aggFunction,
boolean distinct,
boolean approximate,
boolean ignoreNulls,
@Nullable RexNode filter,
@Nullable ImmutableList<RexNode> distinctKeys,
ImmutableList<RexNode> orderKeys,
@Nullable String alias,
ImmutableList<RexNode> operands) {
return new AggCallImpl(
aggFunction,
distinct,
approximate,
ignoreNulls,
filter,
alias,
operands,
distinctKeys,
orderKeys);
} | Creates a call to an aggregate function with all applicable operands. | aggregateCall | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public AggCall countStar(@Nullable String alias) {
return count(false, alias);
} | Creates a call to the {@code COUNT(*)} aggregate function. | countStar | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public AggCall sum(RexNode operand) {
return sum(false, null, operand);
} | Creates a call to the {@code SUM} aggregate function. | sum | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public AggCall sum(boolean distinct, @Nullable String alias, RexNode operand) {
return aggregateCall(
SqlStdOperatorTable.SUM,
distinct,
false,
false,
null,
null,
ImmutableList.of(),
alias,
ImmutableList.of(operand));
} | Creates a call to the {@code SUM} aggregate function, optionally distinct and with an alias. | sum | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public AggCall avg(RexNode operand) {
return avg(false, null, operand);
} | Creates a call to the {@code AVG} aggregate function. | avg | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public AggCall avg(boolean distinct, @Nullable String alias, RexNode operand) {
return aggregateCall(
SqlStdOperatorTable.AVG,
distinct,
false,
false,
null,
null,
ImmutableList.of(),
alias,
ImmutableList.of(operand));
} | Creates a call to the {@code AVG} aggregate function, optionally distinct and with an alias. | avg | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public AggCall min(RexNode operand) {
return min(null, operand);
} | Creates a call to the {@code MIN} aggregate function. | min | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public AggCall min(@Nullable String alias, RexNode operand) {
return aggregateCall(
SqlStdOperatorTable.MIN,
false,
false,
false,
null,
null,
ImmutableList.of(),
alias,
ImmutableList.of(operand));
} | Creates a call to the {@code MIN} aggregate function, optionally with an alias. | min | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public AggCall max(RexNode operand) {
return max(null, operand);
} | Creates a call to the {@code MAX} aggregate function, optionally with an alias. | max | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public AggCall max(@Nullable String alias, RexNode operand) {
return aggregateCall(
SqlStdOperatorTable.MAX,
false,
false,
false,
null,
null,
ImmutableList.of(),
alias,
ImmutableList.of(operand));
} | Creates a call to the {@code MAX} aggregate function. | max | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexNode patternField(String alpha, RelDataType type, int i) {
return getRexBuilder().makePatternFieldRef(alpha, type, i);
} | Creates a reference to a given field of the pattern.
@param alpha the pattern name
@param type Type of field
@param i Ordinal of field
@return Reference to field of pattern | patternField | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexNode patternExclude(RexNode node) {
final RelDataType t = getTypeFactory().createSqlType(SqlTypeName.NULL);
return getRexBuilder()
.makeCall(t, SqlStdOperatorTable.PATTERN_EXCLUDE, ImmutableList.of(node));
} | Creates a call that creates an exclude pattern; for use in {@link #match}. | patternExclude | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RelBuilder snapshot(RexNode period) {
final Frame frame = stack.pop();
final RelNode snapshot = struct.snapshotFactory.createSnapshot(frame.rel, period);
stack.push(new Frame(snapshot, frame.fields));
return this;
} | Creates a {@link Snapshot} of a given snapshot period.
<p>Returns this builder.
@param period Name of table (can optionally be qualified) | snapshot | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
private static @Nullable Set<RelColumnMapping> getColumnMappings(SqlOperator op) {
SqlReturnTypeInference inference = op.getReturnTypeInference();
if (inference instanceof TableFunctionReturnTypeInference) {
return ((TableFunctionReturnTypeInference) inference).getColumnMappings();
} else {
return null;
}
} | Gets column mappings of the operator.
@param op operator instance
@return column mappings associated with this function | getColumnMappings | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RexNode cursor(int inputCount, int ordinal) {
if (inputCount <= ordinal || ordinal < 0) {
throw new IllegalArgumentException("bad input count or ordinal");
}
// Refer to the "ordinal"th input as if it were a field
// (because that's how things are laid out inside a TableFunctionScan)
final RelNode input = peek(inputCount, ordinal);
return call(
SqlStdOperatorTable.CURSOR,
getRexBuilder().makeInputRef(input.getRowType(), ordinal));
} | Creates a RexCall to the {@code CURSOR} function by ordinal.
@param inputCount Number of inputs
@param ordinal The reference to the relational input
@return RexCall to CURSOR function | cursor | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RelBuilder filter(RexNode... predicates) {
return filter(ImmutableSet.of(), ImmutableList.copyOf(predicates));
} | Creates a {@link Filter} of an array of predicates.
<p>The predicates are combined using AND, and optimized in a similar way to the {@link #and}
method. If the result is TRUE no filter is created. | filter | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RelBuilder filter(Iterable<? extends RexNode> predicates) {
return filter(ImmutableSet.of(), predicates);
} | Creates a {@link Filter} of a list of predicates.
<p>The predicates are combined using AND, and optimized in a similar way to the {@link #and}
method. If the result is TRUE no filter is created. | filter | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RelBuilder filter(Iterable<CorrelationId> variablesSet, RexNode... predicates) {
return filter(variablesSet, ImmutableList.copyOf(predicates));
} | Creates a {@link Filter} of a list of correlation variables and an array of predicates.
<p>The predicates are combined using AND, and optimized in a similar way to the {@link #and}
method. If the result is TRUE no filter is created. | filter | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RelBuilder filter(
Iterable<CorrelationId> variablesSet, Iterable<? extends RexNode> predicates) {
final RexNode conjunctionPredicates;
if (config.simplify()) {
conjunctionPredicates = simplifier.simplifyFilterPredicates(predicates);
} else {
conjunctionPredicates = RexUtil.composeConjunction(simplifier.rexBuilder, predicates);
}
if (conjunctionPredicates == null || conjunctionPredicates.isAlwaysFalse()) {
return empty();
}
if (conjunctionPredicates.isAlwaysTrue()) {
return this;
}
final Frame frame = stack.pop();
final RelNode filter =
struct.filterFactory.createFilter(
frame.rel, conjunctionPredicates, ImmutableSet.copyOf(variablesSet));
stack.push(new Frame(filter, frame.fields));
return this;
} | Creates a {@link Filter} of a list of correlation variables and a list of predicates.
<p>The predicates are combined using AND, and optimized in a similar way to the {@link #and}
method. If simplification is on and the result is TRUE, no filter is created. | filter | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RelBuilder project(RexNode... nodes) {
return project(ImmutableList.copyOf(nodes));
} | Creates a {@link Project} of the given expressions. | project | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RelBuilder project(Iterable<? extends RexNode> nodes) {
return project(nodes, ImmutableList.of());
} | Creates a {@link Project} of the given list of expressions.
<p>Infers names as would {@link #project(Iterable, Iterable)} if all suggested names were
null.
@param nodes Expressions | project | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RelBuilder project(
Iterable<? extends RexNode> nodes, Iterable<? extends @Nullable String> fieldNames) {
return project(nodes, fieldNames, false);
} | Creates a {@link Project} of the given list of expressions and field names.
@param nodes Expressions
@param fieldNames field names for expressions | project | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RelBuilder project(
Iterable<? extends RexNode> nodes,
Iterable<? extends @Nullable String> fieldNames,
boolean force) {
return project(nodes, fieldNames, force, ImmutableSet.of());
} | Creates a {@link Project} of the given list of expressions, using the given names.
<p>Names are deduced as follows:
<ul>
<li>If the length of {@code fieldNames} is greater than the index of the current entry in
{@code nodes}, and the entry in {@code fieldNames} is not null, uses it; otherwise
<li>If an expression projects an input field, or is a cast an input field, uses the input
field name; otherwise
<li>If an expression is a call to {@link SqlStdOperatorTable#AS} (see {@link #alias}),
removes the call but uses the intended alias.
</ul>
<p>After the field names have been inferred, makes the field names unique by appending
numeric suffixes.
@param nodes Expressions
@param fieldNames Suggested field names
@param force create project even if it is identity | project | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RelBuilder project(
Iterable<? extends RexNode> nodes,
Iterable<? extends @Nullable String> fieldNames,
boolean force,
Iterable<CorrelationId> variablesSet) {
return project_(nodes, fieldNames, ImmutableList.of(), force, variablesSet);
} | The same with {@link #project(Iterable, Iterable, boolean)}, with additional variablesSet
param.
@param nodes Expressions
@param fieldNames Suggested field names
@param force create project even if it is identity
@param variablesSet Correlating variables that are set when reading a row from the input, and
which may be referenced from the projection expressions | project | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RelBuilder projectPlus(RexNode... nodes) {
return projectPlus(ImmutableList.copyOf(nodes));
} | Creates a {@link Project} of all original fields, plus the given expressions. | projectPlus | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RelBuilder projectPlus(Iterable<? extends RexNode> nodes) {
return project(Iterables.concat(fields(), nodes));
} | Creates a {@link Project} of all original fields, plus the given list of expressions. | projectPlus | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RelBuilder projectExcept(RexNode... expressions) {
return projectExcept(ImmutableList.copyOf(expressions));
} | Creates a {@link Project} of all original fields, except the given expressions.
@throws IllegalArgumentException if the given expressions contain duplicates or there is an
expression that does not match an existing field | projectExcept | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RelBuilder projectExcept(Iterable<RexNode> expressions) {
List<RexNode> allExpressions = new ArrayList<>(fields());
Set<RexNode> excludeExpressions = new HashSet<>();
for (RexNode excludeExp : expressions) {
if (!excludeExpressions.add(excludeExp)) {
throw new IllegalArgumentException(
"Input list contains duplicates. Expression "
+ excludeExp
+ " exists multiple times.");
}
if (!allExpressions.remove(excludeExp)) {
throw new IllegalArgumentException(
"Expression " + excludeExp.toString() + " not found.");
}
}
return this.project(allExpressions);
} | Creates a {@link Project} of all original fields, except the given list of expressions.
@throws IllegalArgumentException if the given expressions contain duplicates or there is an
expression that does not match an existing field | projectExcept | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
private RelBuilder project_(
Iterable<? extends RexNode> nodes,
Iterable<? extends @Nullable String> fieldNames,
Iterable<RelHint> hints,
boolean force,
Iterable<CorrelationId> variablesSet) {
final Frame frame = requireNonNull(peek_(), "frame stack is empty");
final RelDataType inputRowType = frame.rel.getRowType();
final List<RexNode> nodeList = Lists.newArrayList(nodes);
final Set<CorrelationId> variables = ImmutableSet.copyOf(variablesSet);
// Perform a quick check for identity. We'll do a deeper check
// later when we've derived column names.
if (!force && Iterables.isEmpty(fieldNames) && RexUtil.isIdentity(nodeList, inputRowType)) {
return this;
}
final List<@Nullable String> fieldNameList = Lists.newArrayList(fieldNames);
while (fieldNameList.size() < nodeList.size()) {
fieldNameList.add(null);
}
// Do not merge projection when top projection has correlation variables
bloat:
if (frame.rel instanceof Project && config.bloat() >= 0 && variables.isEmpty()) {
final Project project = (Project) frame.rel;
// Populate field names. If the upper expression is an input ref and does
// not have a recommended name, use the name of the underlying field.
for (int i = 0; i < fieldNameList.size(); i++) {
if (fieldNameList.get(i) == null) {
final RexNode node = nodeList.get(i);
if (node instanceof RexInputRef) {
final RexInputRef ref = (RexInputRef) node;
fieldNameList.set(
i, project.getRowType().getFieldNames().get(ref.getIndex()));
}
}
}
final List<RexNode> newNodes =
RelOptUtil.pushPastProjectUnlessBloat(nodeList, project, config.bloat());
if (newNodes == null) {
// The merged expression is more complex than the input expressions.
// Do not merge.
break bloat;
}
// Carefully build a list of fields, so that table aliases from the input
// can be seen for fields that are based on a RexInputRef.
final Frame frame1 = stack.pop();
final List<Field> fields = new ArrayList<>();
for (RelDataTypeField f : project.getInput().getRowType().getFieldList()) {
fields.add(new Field(ImmutableSet.of(), f));
}
for (Pair<RexNode, Field> pair : Pair.zip(project.getProjects(), frame1.fields)) {
switch (pair.left.getKind()) {
case INPUT_REF:
final int i = ((RexInputRef) pair.left).getIndex();
final Field field = fields.get(i);
final ImmutableSet<String> aliases = pair.right.left;
fields.set(i, new Field(aliases, field.right));
break;
default:
break;
}
}
stack.push(new Frame(project.getInput(), ImmutableList.copyOf(fields)));
final ImmutableSet.Builder<RelHint> mergedHints = ImmutableSet.builder();
mergedHints.addAll(project.getHints());
mergedHints.addAll(hints);
// Keep bottom projection's variablesSet.
return project_(
newNodes,
fieldNameList,
mergedHints.build(),
force,
ImmutableSet.copyOf(project.getVariablesSet()));
}
// Simplify expressions.
if (config.simplify()) {
for (int i = 0; i < nodeList.size(); i++) {
nodeList.set(i, simplifier.simplifyPreservingType(nodeList.get(i)));
}
}
// Replace null names with generated aliases.
for (int i = 0; i < fieldNameList.size(); i++) {
if (fieldNameList.get(i) == null) {
fieldNameList.set(i, inferAlias(nodeList, nodeList.get(i), i));
}
}
final ImmutableList.Builder<Field> fields = ImmutableList.builder();
final Set<String> uniqueNameList =
getTypeFactory().getTypeSystem().isSchemaCaseSensitive()
? new HashSet<>()
: new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
// calculate final names and build field list
for (int i = 0; i < fieldNameList.size(); ++i) {
final RexNode node = nodeList.get(i);
String name = fieldNameList.get(i);
String originalName = name;
Field field;
if (name == null || uniqueNameList.contains(name)) {
int j = 0;
if (name == null) {
j = i;
}
do {
name = SqlValidatorUtil.F_SUGGESTER.apply(originalName, j, j++);
} while (uniqueNameList.contains(name));
fieldNameList.set(i, name);
}
RelDataTypeField fieldType = new RelDataTypeFieldImpl(name, i, node.getType());
switch (node.getKind()) {
case INPUT_REF:
// preserve rel aliases for INPUT_REF fields
final int index = ((RexInputRef) node).getIndex();
field = new Field(frame.fields.get(index).left, fieldType);
break;
default:
field = new Field(ImmutableSet.of(), fieldType);
break;
}
uniqueNameList.add(name);
fields.add(field);
}
if (!force && RexUtil.isIdentity(nodeList, inputRowType)) {
if (fieldNameList.equals(inputRowType.getFieldNames())) {
// Do not create an identity project if it does not rename any fields
return this;
} else {
// create "virtual" row type for project only rename fields
stack.pop();
// Ignore the hints.
stack.push(new Frame(frame.rel, fields.build()));
}
return this;
}
// If the expressions are all literals, and the input is a Values with N
// rows, replace with a Values with same tuple N times.
if (config.simplifyValues()
&& frame.rel instanceof Values
&& nodeList.stream().allMatch(e -> e instanceof RexLiteral)) {
final Values values = (Values) build();
final RelDataTypeFactory.Builder typeBuilder = getTypeFactory().builder();
Pair.forEach(
fieldNameList,
nodeList,
(name, expr) -> typeBuilder.add(requireNonNull(name, "name"), expr.getType()));
@SuppressWarnings({"unchecked", "rawtypes"})
final List<RexLiteral> tuple = (List<RexLiteral>) (List) nodeList;
return values(Collections.nCopies(values.tuples.size(), tuple), typeBuilder.build());
}
final RelNode project =
struct.projectFactory.createProject(
frame.rel,
ImmutableList.copyOf(hints),
ImmutableList.copyOf(nodeList),
fieldNameList,
variables);
stack.pop();
stack.push(new Frame(project, fields.build()));
return this;
} | Creates a {@link Project} of the given list of expressions, using the given names.
<p>Names are deduced as follows:
<ul>
<li>If the length of {@code fieldNames} is greater than the index of the current entry in
{@code nodes}, and the entry in {@code fieldNames} is not null, uses it; otherwise
<li>If an expression projects an input field, or is a cast an input field, uses the input
field name; otherwise
<li>If an expression is a call to {@link SqlStdOperatorTable#AS} (see {@link #alias}),
removes the call but uses the intended alias.
</ul>
<p>After the field names have been inferred, makes the field names unique by appending
numeric suffixes.
@param nodes Expressions
@param fieldNames Suggested field names
@param hints Hints
@param force create project even if it is identity | project_ | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RelBuilder projectNamed(
Iterable<? extends RexNode> nodes,
@Nullable Iterable<? extends @Nullable String> fieldNames,
boolean force) {
return projectNamed(nodes, fieldNames, force, ImmutableSet.of());
} | Creates a {@link Project} of the given expressions and field names, and optionally
optimizing.
<p>If {@code fieldNames} is null, or if a particular entry in {@code fieldNames} is null,
derives field names from the input expressions.
<p>If {@code force} is false, and the input is a {@code Project}, and the expressions make
the trivial projection ($0, $1, ...), modifies the input.
@param nodes Expressions
@param fieldNames Suggested field names, or null to generate
@param force Whether to create a renaming Project if the projections are trivial | projectNamed | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RelBuilder projectNamed(
Iterable<? extends RexNode> nodes,
@Nullable Iterable<? extends @Nullable String> fieldNames,
boolean force,
Iterable<CorrelationId> variablesSet) {
@SuppressWarnings({"unchecked", "rawtypes"})
final List<? extends RexNode> nodeList =
nodes instanceof List ? (List) nodes : ImmutableList.copyOf(nodes);
final List<@Nullable String> fieldNameList =
fieldNames == null
? null
: fieldNames instanceof List
? (List<@Nullable String>) fieldNames
: ImmutableNullableList.copyOf(fieldNames);
final RelNode input = peek();
final RelDataType rowType =
RexUtil.createStructType(
cluster.getTypeFactory(),
nodeList,
fieldNameList,
SqlValidatorUtil.F_SUGGESTER);
if (!force && RexUtil.isIdentity(nodeList, input.getRowType())) {
if (input instanceof Project && fieldNames != null) {
// Rename columns of child projection if desired field names are given.
final Frame frame = stack.pop();
final Project childProject = (Project) frame.rel;
final Project newInput =
childProject.copy(
childProject.getTraitSet(),
childProject.getInput(),
childProject.getProjects(),
rowType);
stack.push(new Frame(newInput.attachHints(childProject.getHints()), frame.fields));
}
if (input instanceof Values && fieldNameList != null) {
// Rename columns of child values if desired field names are given.
final Frame frame = stack.pop();
final Values values = (Values) frame.rel;
final RelDataTypeFactory.Builder typeBuilder = getTypeFactory().builder();
Pair.forEach(
fieldNameList,
rowType.getFieldList(),
(name, field) ->
typeBuilder.add(requireNonNull(name, "name"), field.getType()));
final RelDataType newRowType = typeBuilder.build();
final RelNode newValues =
struct.valuesFactory.createValues(cluster, newRowType, values.tuples);
stack.push(new Frame(newValues, frame.fields));
}
} else {
project(nodeList, rowType.getFieldNames(), force, variablesSet);
}
return this;
} | Creates a {@link Project} of the given expressions and field names, and optionally
optimizing.
<p>If {@code fieldNames} is null, or if a particular entry in {@code fieldNames} is null,
derives field names from the input expressions.
<p>If {@code force} is false, and the input is a {@code Project}, and the expressions make
the trivial projection ($0, $1, ...), modifies the input.
@param nodes Expressions
@param fieldNames Suggested field names, or null to generate
@param force Whether to create a renaming Project if the projections are trivial
@param variablesSet Correlating variables that are set when reading a row from the input, and
which may be referenced from the projection expressions | projectNamed | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
public RelBuilder uncollect(List<String> itemAliases, boolean withOrdinality) {
Frame frame = stack.pop();
stack.push(
new Frame(
new Uncollect(
cluster,
cluster.traitSetOf(Convention.NONE),
frame.rel,
withOrdinality,
requireNonNull(itemAliases, "itemAliases"))));
return this;
} | Creates an {@link Uncollect} with given item aliases.
@param itemAliases Operand item aliases, never null
@param withOrdinality If {@code withOrdinality}, the output contains an extra {@code
ORDINALITY} column | uncollect | java | apache/flink | flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | https://github.com/apache/flink/blob/master/flink-table/flink-table-planner/src/main/java/org/apache/calcite/tools/RelBuilder.java | Apache-2.0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.