All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.hazelcast.shaded.org.apache.calcite.plan.RelTraitSet Maven / Gradle / Ivy

There is a newer version: 5.5.0
Show newest version
/*
 * 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.shaded.org.apache.calcite.plan;

import com.hazelcast.shaded.org.apache.calcite.rel.RelCollation;
import com.hazelcast.shaded.org.apache.calcite.rel.RelCollationTraitDef;
import com.hazelcast.shaded.org.apache.calcite.rel.RelDistribution;
import com.hazelcast.shaded.org.apache.calcite.rel.RelDistributionTraitDef;
import com.hazelcast.shaded.org.apache.calcite.util.mapping.Mappings;

import com.hazelcast.shaded.com.google.common.collect.ImmutableList;

import com.hazelcast.shaded.org.checkerframework.checker.nullness.qual.Nullable;

import java.util.AbstractList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Supplier;

/**
 * RelTraitSet represents an ordered set of {@link RelTrait}s.
 */
public final class RelTraitSet extends AbstractList {
  private static final RelTrait[] EMPTY_TRAITS = new RelTrait[0];

  //~ Instance fields --------------------------------------------------------

  private final Cache cache;
  private final RelTrait[] traits;
  private @Nullable String string;
  /** Caches the hash code for the traits. */
  private int hash; // Default to 0

  //~ Constructors -----------------------------------------------------------

  /**
   * Constructs a RelTraitSet with the given set of RelTraits.
   *
   * @param cache  Trait set cache (and indirectly cluster) that this set
   *               belongs to
   * @param traits Traits
   */
  private RelTraitSet(Cache cache, RelTrait[] traits) {
    // NOTE: We do not copy the array. It is important that the array is not
    //   shared. However, since this constructor is private, we assume that
    //   the caller has made a copy.
    this.cache = cache;
    this.traits = traits;
  }

  //~ Methods ----------------------------------------------------------------

  /**
   * Creates an empty trait set.
   *
   * 

It has a new cache, which will be shared by any trait set created from * it. Thus each empty trait set is the start of a new ancestral line. */ public static RelTraitSet createEmpty() { return new RelTraitSet(new Cache(), EMPTY_TRAITS); } /** * Retrieves a RelTrait from the set. * * @param index 0-based index into ordered RelTraitSet * @return the RelTrait * @throws ArrayIndexOutOfBoundsException if index greater than or equal to * {@link #size()} or less than 0. */ public RelTrait getTrait(int index) { return traits[index]; } /** * Retrieves a list of traits from the set. * * @param index 0-based index into ordered RelTraitSet * @return the RelTrait * @throws ArrayIndexOutOfBoundsException if index greater than or equal to * {@link #size()} or less than 0. */ public List getTraits(int index) { final RelTrait trait = traits[index]; if (trait instanceof RelCompositeTrait) { //noinspection unchecked return ((RelCompositeTrait) trait).traitList(); } else { //noinspection unchecked return ImmutableList.of((E) trait); } } @Override public RelTrait get(int index) { return getTrait(index); } /** * Returns whether a given kind of trait is enabled. */ public boolean isEnabled(RelTraitDef traitDef) { return getTrait(traitDef) != null; } /** * Retrieves a RelTrait of the given type from the set. * * @param traitDef the type of RelTrait to retrieve * @return the RelTrait, or null if not found */ public @Nullable T getTrait(RelTraitDef traitDef) { int index = findIndex(traitDef); if (index >= 0) { //noinspection unchecked return (T) getTrait(index); } return null; } /** * Retrieves a list of traits of the given type from the set. * *

Only valid for traits that support multiple entries. (E.g. collation.) * * @param traitDef the type of RelTrait to retrieve * @return the RelTrait, or null if not found */ public @Nullable List getTraits( RelTraitDef traitDef) { int index = findIndex(traitDef); if (index >= 0) { //noinspection unchecked return (List) getTraits(index); } return null; } /** * Replaces an existing RelTrait in the set. * Returns a different trait set; does not modify this trait set. * * @param index 0-based index into ordered RelTraitSet * @param trait the new RelTrait * @return the old RelTrait at the index */ public RelTraitSet replace(int index, RelTrait trait) { assert traits[index].getTraitDef() == trait.getTraitDef() : "RelTrait has different RelTraitDef than replacement"; RelTrait canonizedTrait = canonize(trait); if (traits[index] == canonizedTrait) { return this; } RelTrait[] newTraits = traits.clone(); newTraits[index] = canonizedTrait; return cache.getOrAdd(new RelTraitSet(cache, newTraits)); } /** * Returns a trait set consisting of the current set plus a new trait. * *

If the set does not contain a trait of the same {@link RelTraitDef}, * the trait is ignored, and this trait set is returned. * * @param trait the new trait * @return New set * @see #plus(RelTrait) */ public RelTraitSet replace( RelTrait trait) { // Quick check for common case if (containsShallow(traits, trait)) { return this; } final RelTraitDef traitDef = trait.getTraitDef(); int index = findIndex(traitDef); if (index < 0) { // Trait is not present. Ignore it. return this; } return replace(index, trait); } /** Returns whether an element occurs within an array. * *

Uses {@code ==}, not {@link #equals}. Nulls are allowed. */ private static boolean containsShallow(T[] ts, RelTrait seek) { for (T t : ts) { if (t == seek) { return true; } } return false; } /** Replaces the trait(s) of a given type with a list of traits of the same * type. * *

The list must not be empty, and all traits must be of the same type. */ public RelTraitSet replace(List traits) { assert !traits.isEmpty(); final RelTraitDef def = traits.get(0).getTraitDef(); return replace(RelCompositeTrait.of(def, traits)); } /** Replaces the trait(s) of a given type with a list of traits of the same * type. * *

The list must not be empty, and all traits must be of the same type. */ public RelTraitSet replace(RelTraitDef def, List traits) { return replace(RelCompositeTrait.of(def, traits)); } /** If a given multiple trait is enabled, replaces it by calling the given * function. */ public RelTraitSet replaceIfs(RelTraitDef def, Supplier> traitSupplier) { int index = findIndex(def); if (index < 0) { return this; // trait is not enabled; ignore it } final List traitList = traitSupplier.get(); if (traitList == null) { return replace(index, def.getDefault()); } return replace(index, RelCompositeTrait.of(def, traitList)); } /** If a given trait is enabled, replaces it by calling the given function. */ public RelTraitSet replaceIf(RelTraitDef def, Supplier traitSupplier) { int index = findIndex(def); if (index < 0) { return this; // trait is not enabled; ignore it } T traitList = traitSupplier.get(); if (traitList == null) { traitList = def.getDefault(); } return replace(index, traitList); } /** * Applies a mapping to this traitSet. * * @param mapping Mapping * @return traitSet with mapping applied */ public RelTraitSet apply(Mappings.TargetMapping mapping) { RelTrait[] newTraits = new RelTrait[traits.length]; for (int i = 0; i < traits.length; i++) { newTraits[i] = traits[i].apply(mapping); } return cache.getOrAdd(new RelTraitSet(cache, newTraits)); } /** * Returns whether all the traits are default trait value. */ public boolean isDefault() { for (final RelTrait trait : traits) { if (trait != trait.getTraitDef().getDefault()) { return false; } } return true; } /** * Returns whether all the traits except {@link Convention} * are default trait value. */ public boolean isDefaultSansConvention() { for (final RelTrait trait : traits) { if (trait.getTraitDef() == ConventionTraitDef.INSTANCE) { continue; } if (trait != trait.getTraitDef().getDefault()) { return false; } } return true; } /** * Returns whether all the traits except {@link Convention} * equals with traits in {@code other} traitSet. */ public boolean equalsSansConvention(RelTraitSet other) { if (this == other) { return true; } if (this.size() != other.size()) { return false; } for (int i = 0; i < traits.length; i++) { if (traits[i].getTraitDef() == ConventionTraitDef.INSTANCE) { continue; } // each trait should be canonized already if (traits[i] != other.traits[i]) { return false; } } return true; } /** * Returns a new traitSet with same traitDefs with * current traitSet, but each trait is the default * trait value. */ public RelTraitSet getDefault() { RelTrait[] newTraits = new RelTrait[traits.length]; for (int i = 0; i < traits.length; i++) { newTraits[i] = traits[i].getTraitDef().getDefault(); } return cache.getOrAdd(new RelTraitSet(cache, newTraits)); } /** * Returns a new traitSet with same traitDefs with * current traitSet, but each trait except {@link Convention} * is the default trait value. {@link Convention} trait * remains the same with current traitSet. */ public RelTraitSet getDefaultSansConvention() { RelTrait[] newTraits = new RelTrait[traits.length]; for (int i = 0; i < traits.length; i++) { if (traits[i].getTraitDef() == ConventionTraitDef.INSTANCE) { newTraits[i] = traits[i]; } else { newTraits[i] = traits[i].getTraitDef().getDefault(); } } return cache.getOrAdd(new RelTraitSet(cache, newTraits)); } /** * Returns {@link Convention} trait defined by * {@link ConventionTraitDef#INSTANCE}, or null if the * {@link ConventionTraitDef#INSTANCE} is not registered * in this traitSet. */ public @Nullable Convention getConvention() { return getTrait(ConventionTraitDef.INSTANCE); } /** * Returns {@link RelDistribution} trait defined by * {@link RelDistributionTraitDef#INSTANCE}, or null if the * {@link RelDistributionTraitDef#INSTANCE} is not registered * in this traitSet. */ @SuppressWarnings("unchecked") public @Nullable T getDistribution() { return (@Nullable T) getTrait(RelDistributionTraitDef.INSTANCE); } /** * Returns {@link RelCollation} trait defined by * {@link RelCollationTraitDef#INSTANCE}, or null if the * {@link RelCollationTraitDef#INSTANCE} is not registered * in this traitSet. */ @SuppressWarnings("unchecked") public @Nullable T getCollation() { return (@Nullable T) getTrait(RelCollationTraitDef.INSTANCE); } /** * Returns the size of the RelTraitSet. * * @return the size of the RelTraitSet. */ @Override public int size() { return traits.length; } /** * Converts a trait to canonical form. * *

After canonization, t1.equals(t2) if and only if t1 == t2. * * @param trait Trait * @return Trait in canonical form */ public T canonize(T trait) { if (trait == null) { // Return "trait" makes the input type to be the same as the output type, // so checkerframework is happy return trait; } if (trait instanceof RelCompositeTrait) { // Composite traits are canonized on creation //noinspection unchecked return trait; } //noinspection unchecked return (T) trait.getTraitDef().canonize(trait); } /** * Compares two RelTraitSet objects for equality. * * @param obj another RelTraitSet * @return true if traits are equal and in the same order, false otherwise */ @Override public boolean equals(@Nullable Object obj) { if (this == obj) { return true; } if (!(obj instanceof RelTraitSet)) { return false; } RelTraitSet that = (RelTraitSet) obj; if (this.hash != 0 && that.hash != 0 && this.hash != that.hash) { return false; } if (traits.length != that.traits.length) { return false; } for (int i = 0; i < traits.length; i++) { if (traits[i] != that.traits[i]) { return false; } } return true; } @Override public int hashCode() { if (hash == 0) { hash = Arrays.hashCode(traits); } return hash; } /** * Returns whether this trait set satisfies another trait set. * *

For that to happen, each trait satisfies the corresponding trait in the * other set. In particular, each trait set satisfies itself, because each * trait subsumes itself. * *

Intuitively, if a relational expression is needed that has trait set * S (A, B), and trait set S1 (A1, B1) subsumes S, then any relational * expression R in S1 meets that need. * *

For example, if we need a relational expression that has * trait set S = {enumerable convention, sorted on [C1 asc]}, and R * has {enumerable convention, sorted on [C3], [C1, C2]}. R has two * sort keys, but one them [C1, C2] satisfies S [C1], and that is enough. * * @param that another RelTraitSet * @return whether this trait set satisfies other trait set * * @see org.apache.calcite.plan.RelTrait#satisfies(RelTrait) */ public boolean satisfies(RelTraitSet that) { if (this == that) { return true; } final int n = Math.min( this.size(), that.size()); for (int i = 0; i < n; i++) { RelTrait thisTrait = this.traits[i]; RelTrait thatTrait = that.traits[i]; if (!thisTrait.satisfies(thatTrait)) { return false; } } return true; } /** * Compares two RelTraitSet objects to see if they match for the purposes of * firing a rule. A null RelTrait within a RelTraitSet indicates a wildcard: * any RelTrait in the other RelTraitSet will match. If one RelTraitSet is * smaller than the other, comparison stops when the last RelTrait from the * smaller set has been examined and the remaining RelTraits in the larger * set are assumed to match. * * @param that another RelTraitSet * @return true if the RelTraitSets match, false otherwise */ public boolean matches(RelTraitSet that) { final int n = Math.min( this.size(), that.size()); for (int i = 0; i < n; i++) { RelTrait thisTrait = this.traits[i]; RelTrait thatTrait = that.traits[i]; if ((thisTrait == null) || (thatTrait == null)) { continue; } if (thisTrait != thatTrait) { return false; } } return true; } /** * Returns whether this trait set contains a given trait. * * @param trait Sought trait * @return Whether set contains given trait */ public boolean contains(RelTrait trait) { for (RelTrait relTrait : traits) { if (trait == relTrait) { return true; } } return false; } /** * Returns whether this trait set contains the given trait, or whether the * trait is not present because its {@link RelTraitDef} is not enabled. * Returns false if another trait of the same {@code RelTraitDef} is * present. * * @param trait Trait * @return Whether trait is present, or is absent because disabled */ public boolean containsIfApplicable(RelTrait trait) { // Note that '==' is sufficient, because trait should be canonized. final RelTrait trait1 = getTrait(trait.getTraitDef()); return trait1 == null || trait1 == trait; } /** * Returns whether this trait set comprises precisely the list of given * traits. * * @param relTraits Traits * @return Whether this trait set's traits are the same as the argument */ public boolean comprises(RelTrait... relTraits) { return Arrays.equals(traits, relTraits); } @Override public String toString() { if (string == null) { string = computeString(); } return string; } /** * Outputs the traits of this set as a String. Traits are output in order, * separated by periods. */ String computeString() { StringBuilder s = new StringBuilder(); for (int i = 0; i < traits.length; i++) { final RelTrait trait = traits[i]; if (i > 0) { s.append('.'); } if ((trait == null) && (traits.length == 1)) { // Special format for a list containing a single null trait; // otherwise its string appears as "null", which is the same // as if the whole trait set were null, and so confusing. s.append("{null}"); } else { s.append(trait); } } return s.toString(); } /** * Finds the index of a trait of a given type in this set. * * @param traitDef Sought trait definition * @return index of trait, or -1 if not found */ private int findIndex(RelTraitDef traitDef) { for (int i = 0; i < traits.length; i++) { RelTrait trait = traits[i]; if ((trait != null) && (trait.getTraitDef() == traitDef)) { return i; } } return -1; } /** * Returns this trait set with a given trait added or overridden. Does not * modify this trait set. * * @param trait Trait * @return Trait set with given trait */ public RelTraitSet plus(RelTrait trait) { if (contains(trait)) { return this; } int i = findIndex(trait.getTraitDef()); if (i >= 0) { return replace(i, trait); } final RelTrait canonizedTrait = canonize(trait); assert canonizedTrait != null; RelTrait[] newTraits = new RelTrait[traits.length + 1]; System.arraycopy(traits, 0, newTraits, 0, traits.length); newTraits[traits.length] = canonizedTrait; return cache.getOrAdd(new RelTraitSet(cache, newTraits)); } public RelTraitSet plusAll(RelTrait[] traits) { RelTraitSet t = this; for (RelTrait trait : traits) { t = t.plus(trait); } return t; } public RelTraitSet merge(RelTraitSet additionalTraits) { return plusAll(additionalTraits.traits); } /** Returns a list of traits that are in {@code traitSet} but not in this * RelTraitSet. */ public ImmutableList difference(RelTraitSet traitSet) { final ImmutableList.Builder builder = ImmutableList.builder(); final int n = Math.min( this.size(), traitSet.size()); for (int i = 0; i < n; i++) { RelTrait thisTrait = this.traits[i]; RelTrait thatTrait = traitSet.traits[i]; if (thisTrait != thatTrait) { builder.add(thatTrait); } } return builder.build(); } /** Returns whether there are any composite traits in this set. */ public boolean allSimple() { for (RelTrait trait : traits) { if (trait instanceof RelCompositeTrait) { return false; } } return true; } /** Returns a trait set similar to this one but with all composite traits * flattened. */ public RelTraitSet simplify() { RelTraitSet x = this; for (int i = 0; i < traits.length; i++) { final RelTrait trait = traits[i]; if (trait instanceof RelCompositeTrait) { x = x.replace(i, ((RelCompositeTrait) trait).size() == 1 ? ((RelCompositeTrait) trait).trait(0) : trait.getTraitDef().getDefault()); } } return x; } /** Cache of trait sets. */ private static class Cache { final Map map = new HashMap<>(); Cache() { } RelTraitSet getOrAdd(RelTraitSet t) { RelTraitSet exist = map.putIfAbsent(t, t); return exist == null ? t : exist; } } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy