Modifier and Type | Class and Description |
---|---|
class |
Bag
A sequence of MRData.
|
class |
Inv |
class |
Lambda
an anonymous function encapsulated as MRData
|
class |
MR_bool
a container for boolean values
|
class |
MR_byte
a container for byte values
|
class |
MR_char
a container for a char
|
class |
MR_dataset
a wrapper of a DataSet (stored in HDFS) as an MRData
|
class |
MR_double
a container for double values
|
class |
MR_float
a container for float values
|
class |
MR_int
a container for int values
|
class |
MR_long
a container for long values
|
class |
MR_more_bsp_steps
used for BSP synchronization when a peer needs to do more steps
|
class |
MR_short
a container for short values
|
class |
MR_string
a container for strings
|
class |
MR_sync
used for BSP synchronization
|
class |
MR_variable
a template variable; should appear only in a template
|
(package private) static class |
MRContainer.MR_EOLB |
class |
Tuple
a container for Tuples
|
class |
Union
union values are tagged values, where tag is the descriminator
|
Modifier and Type | Field and Description |
---|---|
(package private) MRData |
MRContainer.data |
static MRData |
MRContainer.end_of_lazy_bag |
(package private) static MRData |
Interpreter.false_value |
(package private) static MRData |
SystemFunctions.null_value |
(package private) static MRData |
Interpreter.null_value |
(package private) static MRData |
Interpreter.true_value |
(package private) MRData[] |
Tuple.tuple |
MRData |
Environment.value |
Modifier and Type | Method and Description |
---|---|
static MRData |
MapReduceAlgebra.aggregate(Function accumulator,
MRData zero,
Bag s)
aggregate the Bag elements
|
abstract MRData |
Evaluator.aggregate(Tree acc_fnc,
Tree zero,
Tree plan,
Environment env)
The Aggregate physical operator
|
static MRData |
SystemFunctions.avg_aggr(Bag s)
used in avg
|
static MRData |
MapReduceAlgebra.BSP(int[] source,
Function superstep,
MRData init_state,
boolean order,
Bag[] inputs)
The BSP operation
|
MRData |
Evaluator.bsp(Tree plan,
Environment env)
run a BSP task
|
static MRData |
ClassImporter.call(int method_number,
MRData... args)
call a system method with a given number over MRData
|
static MRData |
SystemFunctions.coerce(MRData from,
MR_int type)
coerce a basic type to a new type indicated by the basic type number
|
(package private) MRData |
MRContainer.data() |
static MRData |
SystemFunctions.elem(Bag s) |
abstract MRData |
Function.eval(MRData arg)
Evaluate the anonymous function from MRData to MRData
|
(package private) static MRData |
Interpreter.evalE(Tree e)
evaluate an MRQL expression in memory
|
(package private) static MRData |
Interpreter.evalE(Tree e,
Environment env)
evaluate an MRQL expression in memory and print tracing info
|
static MRData |
TopLevel.expression(Tree e)
translate, evaluate, and print the results of an MRQL expression e
|
static MRData |
TopLevel.expression(Tree e,
boolean print)
translate and evaluate an MRQL expression into MRData
|
MRData |
Tuple.first()
the first element of the tuple
|
static MRData |
MapReduceAlgebra.fold(Function acc,
MRData zero,
Bag s)
general reduction using an accumulator function and a zero element
|
static MRData |
SystemFunctions.fold(Lambda c,
MRData z,
Bag s) |
MRData |
Tuple.get(int i)
the i'th element of the tuple
|
MRData |
Bag.get(int n)
get the n'th element of a Bag (cache it in memory if necessary)
|
static MRData |
MapReduceAlgebra.getCache(int loc)
return the cache element at location loc
|
static MRData |
Plan.getCache(int loc)
return the cache element at location loc
|
static MRData |
SystemFunctions.index(Bag b,
MR_int mi) |
static MRData |
SystemFunctions.join_key(Bag xs,
Bag ys)
return the join key from a matching pair in the join reducer
|
static MRData |
Interpreter.lookup_distributed_binding(String v)
retrieve a global variable binding available to all nodes
|
static MRData |
Interpreter.lookup_global_binding(String v)
retrieve a global variable binding
|
MRData |
Bag.map_find(MRData key)
if this Bag is a Map from keys to values (a Bag of (key,value) pairs),
find the value with the given key; raise an error if not found
|
static MRData |
MapReduceAlgebra.materialize(MRData x) |
static MRData |
MRQL.query(String query)
evaluate an MRQL query in a string
|
static MRData |
MapReduceAlgebra.read_binary(String file)
read the contents of a dumped local binary file
|
static MRData |
MRContainer.read(DataInput in) |
MRData |
DataSet.reduce(MRData zero,
Function acc)
accumulate all dataset values
|
MRData |
DataSource.reduce(MRData zero,
Function acc)
accumulate all datasource values
|
MRData |
Tuple.second()
the second element of the tuple
|
MRData |
Tuple.set(int i,
MRData data,
MRData ret)
replace the i'th element of a tuple with new data and return a new value
|
static MRData |
MapReduceAlgebra.setCache(int loc,
MRData value,
MRData ret)
set the cache element at location loc to value and return ret
|
static MRData |
Plan.setCache(int loc,
MRData value,
MRData ret)
set the cache element at location loc to value and return ret
|
static MRData |
Interpreter.trace(long count,
Tree type,
MRData value) |
MRData |
Inv.value() |
MRData |
Union.value() |
static MRData |
Interpreter.variable_lookup(String v,
Environment environment)
retrieve variable binding
|
Modifier and Type | Method and Description |
---|---|
Iterator<MRData> |
Bag.iterator()
return the Bag Iterator
|
List<MRData> |
DataSet.take(int num)
return the first num values
|
List<MRData> |
DataSource.take(int num)
return the first num values
|
Modifier and Type | Method and Description |
---|---|
Bag |
Bag.add_element(MRData x)
add a new value to a Bag (cache it in memory if necessary)
|
void |
Bag.add(MRData x)
add a new value to a Bag (cache it in memory if necessary)
|
static MRData |
MapReduceAlgebra.aggregate(Function accumulator,
MRData zero,
Bag s)
aggregate the Bag elements
|
static MR_double |
SystemFunctions.avg_value(MRData value)
used in avg
|
static MRData |
MapReduceAlgebra.BSP(int[] source,
Function superstep,
MRData init_state,
boolean order,
Bag[] inputs)
The BSP operation
|
static MRData |
ClassImporter.call(int method_number,
MRData... args)
call a system method with a given number over MRData
|
static MRData |
SystemFunctions.coerce(MRData from,
MR_int type)
coerce a basic type to a new type indicated by the basic type number
|
int |
Inv.compareTo(MRData x) |
int |
MR_double.compareTo(MRData x) |
int |
MRContainer.MR_EOLB.compareTo(MRData x) |
int |
Union.compareTo(MRData x) |
int |
MR_float.compareTo(MRData x) |
int |
MR_variable.compareTo(MRData x) |
int |
MR_more_bsp_steps.compareTo(MRData x) |
int |
MR_bool.compareTo(MRData x) |
int |
MR_char.compareTo(MRData x) |
int |
MR_dataset.compareTo(MRData x) |
int |
MR_byte.compareTo(MRData x) |
int |
Tuple.compareTo(MRData x) |
int |
MR_string.compareTo(MRData x) |
int |
Bag.compareTo(MRData x)
compare this Bag with a given Bag by comparing their associated elements
|
int |
Lambda.compareTo(MRData x) |
int |
MR_sync.compareTo(MRData x) |
int |
MR_short.compareTo(MRData x) |
int |
MR_long.compareTo(MRData x) |
int |
MR_int.compareTo(MRData x) |
boolean |
Bag.contains(MRData x)
does this Bag contain an element?
Cache this Bag in memory befor tetsing if necessary
|
void |
Evaluator.dump_text(String file,
Tree type,
MRData data)
dump MRQL data into a text CVS file
|
void |
Evaluator.dump(String file,
Tree type,
MRData data)
dump MRQL data into a sequence file
|
static void |
MapReduceAlgebra.dump(String file,
Tree type,
MRData value)
Dump the value of some type to a binary local file;
The type is dumped to a separate file.type
|
static MR_bool |
SystemFunctions.eq(MRData x,
MRData y) |
abstract MRData |
Function.eval(MRData arg)
Evaluate the anonymous function from MRData to MRData
|
static MRData |
MapReduceAlgebra.fold(Function acc,
MRData zero,
Bag s)
general reduction using an accumulator function and a zero element
|
static MRData |
SystemFunctions.fold(Lambda c,
MRData z,
Bag s) |
static MR_bool |
SystemFunctions.geq(MRData x,
MRData y) |
static Bag |
MapReduceAlgebra.groupByJoin(Function kx,
Function ky,
Function gx,
Function gy,
Function acc,
MRData zero,
Function r,
Bag X,
Bag Y)
An equi-join combined with a group-by (see GroupByJoinPlan)
|
static MR_bool |
SystemFunctions.gt(MRData x,
MRData y) |
static MR_long |
SystemFunctions.hash_code(MRData x) |
static Inv |
SystemFunctions.inv(MRData x) |
static MR_bool |
SystemFunctions.leq(MRData x,
MRData y) |
static MR_bool |
SystemFunctions.lt(MRData x,
MRData y) |
boolean |
Bag.map_contains(MRData key)
if this Bag is a Map from keys to values (a Bag of (key,value) pairs),
does it contain a given key?
|
MRData |
Bag.map_find(MRData key)
if this Bag is a Map from keys to values (a Bag of (key,value) pairs),
find the value with the given key; raise an error if not found
|
static MRData |
MapReduceAlgebra.materialize(MRData x) |
static MR_bool |
SystemFunctions.member(MRData e,
Bag s) |
static Bag |
MapReduceAlgebra.mergeGroupByJoin(Function kx,
Function ky,
Function gx,
Function gy,
Function acc,
MRData zero,
Function r,
Bag X,
Bag Y)
An equi-join combined with a group-by implemented using a sort-merge join
combined with hash-based groupby/aggregation
|
static Bag |
MapReduceAlgebra.mergeGroupByJoin2(Function kx,
Function ky,
Function gx,
Function gy,
Function acc,
MRData zero,
Function r,
Bag X,
Bag Y)
An equi-join combined with a group-by implemented using hashing
|
static MR_bool |
SystemFunctions.neq(MRData x,
MRData y) |
static void |
Interpreter.new_distributed_binding(String var,
MRData value)
insert a new global variable binding visible to all nodes
|
static void |
Interpreter.new_global_binding(String var,
MRData value)
insert a new global variable binding
|
(package private) static String |
Printer.print(MRData x,
Tree type)
An MRData printer based on type information
|
MRData |
DataSet.reduce(MRData zero,
Function acc)
accumulate all dataset values
|
MRData |
DataSource.reduce(MRData zero,
Function acc)
accumulate all datasource values
|
static Tree |
Printer.reify(MRData x,
Tree type)
given an MRData value, construct an expression that builds this data
|
void |
Environment.replace(String n,
MRData v) |
Tuple |
Tuple.set(int i,
MRData data)
replace the i'th element of a tuple with new data
|
Bag |
Bag.set(int n,
MRData value)
replace the n'th element of a Bag with a new value
|
MRData |
Tuple.set(int i,
MRData data,
MRData ret)
replace the i'th element of a tuple with new data and return a new value
|
void |
MRContainer.set(MRData v) |
static MRData |
MapReduceAlgebra.setCache(int loc,
MRData value,
MRData ret)
set the cache element at location loc to value and return ret
|
static MRData |
Plan.setCache(int loc,
MRData value,
MRData ret)
set the cache element at location loc to value and return ret
|
static MR_string |
SystemFunctions.string(MRData x) |
abstract Bag |
Evaluator.toBag(MRData data)
Coerce a persistent collection to a Bag
|
static MRData |
Interpreter.trace(long count,
Tree type,
MRData value) |
Constructor and Description |
---|
Bag(MRData... as)
in-memory Bag construction (an ArrayList) initialized with data
|
Environment(String n,
MRData v,
Environment next) |
Inv(MRData v) |
MRContainer(MRData d) |
Tuple(MRData... as) |
Union(byte tag,
MRData value) |
Constructor and Description |
---|
Bag(List<MRData> as)
in-memory Bag construction (an ArrayList) initialized with data
|
Copyright © 2013-2016 The Apache Software Foundation. All Rights Reserved.