/** * Create a new <tt>PhysicalDataSourceConstraint</tt> instance with a new subset of metric names. * <p> * The new set of metric names will be an intersection between old metric names and * a user provided set of metric names * * @param metricNames The set of metric columns that are to be intersected with metric names in * <tt>this DataSourceConstraint</tt> * * @return the new <tt>PhysicalDataSourceConstraint</tt> instance with a new subset of metric names */ @Override public PhysicalDataSourceConstraint withMetricIntersection(Set<String> metricNames) { Set<String> nonIntersectingMetric = getMetricNames().stream() .filter(metricName -> !metricNames.contains(metricName)) .collect(Collectors.toSet()); Set<String> resultColumnNames = this.allColumnPhysicalNames.stream() .filter(name -> !nonIntersectingMetric.contains(name)) .collect(Collectors.toSet()); return new PhysicalDataSourceConstraint(super.withMetricIntersection(metricNames), resultColumnNames); } }
@Override public SimplifiedIntervalList getAvailableIntervals(PhysicalDataSourceConstraint constraint) { Set<String> requestColumns = constraint.getAllColumnPhysicalNames(); if (requestColumns.isEmpty()) { return new SimplifiedIntervalList(); } // Need to ensure requestColumns is not empty in order to prevent returning null by reduce operation return requestColumns.stream() .map(physicalName -> getAllAvailableIntervals().getOrDefault( physicalName, new SimplifiedIntervalList() )) .reduce(SimplifiedIntervalList::intersect) .orElse(new SimplifiedIntervalList()); }
/** * Given a <tt>DataSourceConstraint</tt> - DSC1, construct a map from each availability, A, in this MetricUnion to * its <tt>DataSourceConstraint</tt>, DSC2. * <p> * DSC2 is constructed as the intersection of metric columns between DSC1 and * A's available metric columns. There are cases in which the intersection is empty; this method filters out * map entries that maps to <tt>DataSourceConstraint</tt> with empty set of metric names. * * @param constraint The data constraint whose contained metric columns will be intersected with availabilities' * metric columns * * @return A map from <tt>Availability</tt> to <tt>DataSourceConstraint</tt> with non-empty metric names */ private Map<Availability, PhysicalDataSourceConstraint> constructSubConstraint( PhysicalDataSourceConstraint constraint ) { return availabilitiesToMetricNames.entrySet().stream() .map(entry -> new AbstractMap.SimpleEntry<>( entry.getKey(), constraint.withMetricIntersection(entry.getValue()) ) ) .filter(entry -> !entry.getValue().getMetricNames().isEmpty()) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); }
/** * Create a constrained copy of this table. * * @param constraint The dataSourceConstraint which narrows the view of the underlying availability * * @return a constrained table whose availability and serialization are narrowed by this constraint */ @Override public ConstrainedTable withConstraint(DataSourceConstraint constraint) { validateConstraintSchema(constraint); return new ConstrainedTable(this, new PhysicalDataSourceConstraint(constraint, getSchema())); }
@Override public SimplifiedIntervalList getAvailableIntervals(PhysicalDataSourceConstraint constraint) { Set<String> dataSourceMetricNames = availabilitiesToMetricNames.values().stream() .flatMap(Set::stream) .collect(Collectors.toSet()); // If the table is configured with a column that is not supported by the underlying data sources if (!constraint.getMetricNames().stream().allMatch(dataSourceMetricNames::contains)) { return new SimplifiedIntervalList(); } return constructSubConstraint(constraint).entrySet().stream() .map(entry -> entry.getKey().getAvailableIntervals(entry.getValue())) .reduce(SimplifiedIntervalList::intersect).orElse(new SimplifiedIntervalList()); }
@Override public SimplifiedIntervalList getAvailableIntervals(DataSourceConstraint constraint) { validateConstraintSchema(constraint); return getAvailability().getAvailableIntervals(new PhysicalDataSourceConstraint(constraint, getSchema())); }
/** * Constructor. * * @param sourceTable The table being constrained * @param constraint The constraint being applied */ public ConstrainedTable(ConfigPhysicalTable sourceTable, DataSourceConstraint constraint) { this.constraint = constraint; this.sourceTable = sourceTable; Availability sourceAvailability = sourceTable.getAvailability(); PhysicalDataSourceConstraint physicalDataSourceConstraint = new PhysicalDataSourceConstraint( constraint, sourceTable.getSchema() ); availableIntervals = new SimplifiedIntervalList( sourceAvailability.getAvailableIntervals(physicalDataSourceConstraint) ); allAvailableIntervals = Collections.unmodifiableMap( mapToSchemaAvailability( sourceAvailability.getAllAvailableIntervals(), getSchema() ) ); dataSourceNames = Collections.unmodifiableSet( sourceAvailability.getDataSourceNames(physicalDataSourceConstraint) ); }