Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* 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 com.hazelcast.org.apache.calcite.adapter.enumerable;
import com.hazelcast.org.apache.calcite.plan.RelOptCluster;
import com.hazelcast.org.apache.calcite.plan.RelTraitSet;
import com.hazelcast.org.apache.calcite.rel.RelCollation;
import com.hazelcast.org.apache.calcite.rel.RelCollationTraitDef;
import com.hazelcast.org.apache.calcite.rel.RelCollations;
import com.hazelcast.org.apache.calcite.rel.RelFieldCollation;
import com.hazelcast.org.apache.calcite.rel.RelNode;
import com.hazelcast.org.apache.calcite.rel.core.Aggregate;
import com.hazelcast.org.apache.calcite.rel.core.AggregateCall;
import com.hazelcast.org.apache.calcite.rex.RexUtil;
import com.hazelcast.org.apache.calcite.util.ImmutableBitSet;
import com.hazelcast.org.apache.calcite.util.Pair;
import com.hazelcast.org.apache.calcite.util.Util;
import com.hazelcast.org.apache.calcite.util.mapping.Mappings;
import com.hazelcast.com.google.common.collect.ImmutableList;
import java.util.ArrayList;
import java.util.List;
/** Sort based physical implementation of {@link Aggregate} in
* {@link EnumerableConvention enumerable calling convention}. */
public class EnumerableSortedAggregate extends Aggregate implements EnumerableRel {
public EnumerableSortedAggregate(
RelOptCluster cluster,
RelTraitSet traitSet,
RelNode input,
ImmutableBitSet groupSet,
List groupSets,
List aggCalls) {
super(cluster, traitSet, ImmutableList.of(), input, groupSet, groupSets, aggCalls);
assert getConvention() instanceof EnumerableConvention;
}
@Override public EnumerableSortedAggregate copy(RelTraitSet traitSet, RelNode input,
ImmutableBitSet groupSet,
List groupSets, List aggCalls) {
return new EnumerableSortedAggregate(getCluster(), traitSet, input,
groupSet, groupSets, aggCalls);
}
@Override public Pair> passThroughTraits(
final RelTraitSet required) {
if (!isSimple(this)) {
return null;
}
RelTraitSet inputTraits = getInput().getTraitSet();
RelCollation collation = required.getTrait(RelCollationTraitDef.INSTANCE);
ImmutableBitSet requiredKeys = ImmutableBitSet.of(RelCollations.ordinals(collation));
ImmutableBitSet groupKeys = ImmutableBitSet.range(groupSet.cardinality());
Mappings.TargetMapping mapping = Mappings.source(groupSet.toList(),
input.getRowType().getFieldCount());
if (requiredKeys.equals(groupKeys)) {
RelCollation inputCollation = RexUtil.apply(mapping, collation);
return Pair.of(required, ImmutableList.of(inputTraits.replace(inputCollation)));
} else if (groupKeys.contains(requiredKeys)) {
// group by a,b,c order by c,b
List list = new ArrayList<>(collation.getFieldCollations());
groupKeys.except(requiredKeys).forEach(k -> list.add(new RelFieldCollation(k)));
RelCollation aggCollation = RelCollations.of(list);
RelCollation inputCollation = RexUtil.apply(mapping, aggCollation);
return Pair.of(traitSet.replace(aggCollation),
ImmutableList.of(inputTraits.replace(inputCollation)));
}
// Group keys doesn't contain all the required keys, e.g.
// group by a,b order by a,b,c
// nothing we can do to propagate traits to child nodes.
return null;
}
public Result implement(EnumerableRelImplementor implementor, Prefer pref) {
throw Util.needToImplement("EnumerableSortedAggregate");
}
}