Public

<init>

rewriteRangePartitionChannel

Gson

Making http requests using okhttp

A BufferedInputStream adds functionality to another input stream-namely, the
ability to buffer the i

java.io.BufferedInputStream

Represents a command that can be executed. Often used to run code in a different
Thread.

java.lang.Runnable

HashSet is an implementation of a Set. All optional operations (adding and
removing) are supported. 

java.util.HashSet

This is the central class in the log4j package. Most logging operations, except
configuration, are d

org.apache.log4j.Logger

org.hamcrest.core.IsNull

The org.slf4j.Logger interface is the main user entry point of SLF4J API. It is
expected that loggin

org.slf4j.Logger

getResourceAsStream

getContentResolver

findViewById

/**
	 * Translates the given program to an OptimizedPlan. The optimized plan describes for each operator
	 * which strategy to use (such as hash join versus sort-merge join), what data exchange method to use
	 * (local pipe forward, shuffle, broadcast), what exchange mode to use (pipelined, batch),
	 * where to cache intermediate results, etc,
	 *
	 * The optimization happens in multiple phases:
	 * <ol>
	 *     <li>Create optimizer dag implementation of the program.
	 *
	 *     <tt>OptimizerNode</tt> representations of the PACTs, assign parallelism and compute size estimates.</li>
	 * <li>Compute interesting properties and auxiliary structures.</li>
	 * <li>Enumerate plan alternatives. This cannot be done in the same step as the interesting property computation (as
	 * opposed to the Database approaches), because we support plans that are not trees.</li>
	 * </ol>
	 * 
	 * @param program The program to be translated.
	 * @param postPasser The function to be used for post passing the optimizer's plan and setting the
	 *                   data type specific serialization routines.
	 * @return The optimized plan.
	 * 
	 * @throws CompilerException
	 *         Thrown, if the plan is invalid or the optimizer encountered an inconsistent
	 *         situation during the compilation process.
	 */

// the first step in the compilation is to create the optimizer plan representation

// 1) It creates an optimizer plan node for each operator

// 3) It looks for hints about local strategies and channel types and

// sets the types and strategies accordingly

// 4) It makes estimates about the data volume of the data sources and

// propagates those estimates through the plan

// if we have a plan with multiple data sinks, add logical optimizer nodes that have two data-sinks as children

// each until we have only a single root node. This allows to transparently deal with the nodes with

"Bug: The optimizer plan representation has no sinks."

// now that we have all nodes created and recorded which ones consume memory, tell the nodes their minimal

// guaranteed memory, for further cost estimations. We assume an equal distribution of memory among consumer tasks

// We need to enforce that union nodes always forward their output to their successor.

// Any partitioning must be either pushed before or done after the union, but not on the union's output.

// We are dealing with operator DAGs, rather than operator trees.

// That requires us to deviate at some points from the classical DB optimizer algorithms.

// This step builds auxiliary structures to help track branches and joins in the DAG

// Propagate the interesting properties top-down through the graph

// perform a sanity check: the root may not have any unclosed branches

"Bug: Logic for branching plans (non-tree plans) has an error, and does not "

"track the re-joining of branches correctly."

// the final step is now to generate the actual plan alternatives

"Error in compiler: more than one best plan was created!"

// check if the best plan's root is a data sink (single sink plan)

// if so, directly take it. if it is a sink joiner node, get its contained sinks

// post pass the plan. this is the phase where the serialization and comparator code is set

How to use org.apache.flink.optimizer.traversals.RangePartitionRewriterconstructor

Best Java code snippets using org.apache.flink.optimizer.traversals.RangePartitionRewriter.<init> (Showing top 5 results out of 315)

How to use
org.apache.flink.optimizer.traversals.RangePartitionRewriter
constructor