Modifier and Type | Field and Description |
---|---|
static Bag |
SystemFunctions.bsp_empty_bag |
(package private) Bag |
XPathParser.MRDataHandler.children |
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)
|
Bag |
Bag.addAll(Bag b)
add the elements of a Bag to the end of this Bag
|
static Bag |
MapReduceAlgebra.closure(Function loop,
Bag init,
int max_num)
transitive closure: repeat the loop until the new set is equal to the previous set
or until we reach the max num of steps
|
static Bag |
MapReduceAlgebra.cmap(Function f,
Bag s)
lazy concat-map (stream-based)
|
static Bag |
Plan.collect(DataSet x)
The collect physical operator
|
Bag |
MRQLFileInputFormat.collect(DataSet x,
boolean strip)
materialize the entire dataset into a Bag
|
static Bag |
Plan.collect(DataSet x,
boolean strip)
The collect physical operator
|
static Bag |
MapReduceAlgebra.crossProduct(Function mx,
Function my,
Function r,
Bag X,
Bag Y)
A cross-product
|
static Bag |
SystemFunctions.distribute(MR_string peerName,
Bag s) |
Bag |
Evaluator.distribute(MR_string peerName,
Bag s)
distribute a bag among peers in BSP mode
|
(package private) static Bag |
Interpreter.evalM(Tree e,
Environment env)
evaluate MRQL physical operators in memory (returns a Bag)
|
(package private) static Bag |
Interpreter.evalMM(Tree e,
Environment env)
evaluate MRQL physical operators in memory (returns a Bag)
|
(package private) static Bag |
Interpreter.evalS(Tree e,
Environment env)
evaluate MRQL physical operators in memory (returns a Bag)
|
static Bag |
SystemFunctions.except(Bag x,
Bag y) |
static Bag |
MapReduceAlgebra.filter(Function p,
Function f,
Bag s)
lazy filter combined with a map
|
static Bag |
MapReduceAlgebra.generator(int source_num,
long min,
long max)
generate a lazy bag of long numbers {min...max} and tag each lon number with a source num
|
static Bag |
MapReduceAlgebra.generator(long min,
long max)
generate a lazy bag of long numbers {min...max}
|
static Bag |
MapReduceAlgebra.groupBy(Bag s)
strict group-by
|
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 Bag |
MapReduceAlgebra.hash_join(Function kx,
Function ky,
Function f,
Bag X,
Bag Y)
A hash-based equi-join
|
static Bag |
SystemFunctions.intersect(Bag x,
Bag y) |
static Bag |
Bag.lazy_read(DataInput in)
a lazy input serializer for a Bag (it doesn't need to cache a Bag in memory)
|
static Bag |
MapReduceAlgebra.map(Function f,
Bag s)
lazy map
|
static Bag |
MapReduceAlgebra.mapJoin(Function kx,
Function ky,
Function r,
Bag X,
Bag Y)
The fragment-replicate join (map-side join)
|
static Bag |
MapReduceAlgebra.mapReduce(Function m,
Function r,
Bag s)
the MapReduce operation
|
static Bag |
MapReduceAlgebra.mapReduce2(Function mx,
Function my,
Function r,
Bag X,
Bag Y)
A map-reduce operation with two mappers (a join)
|
static Bag |
SystemFunctions.materialize(Bag x) |
Bag |
MRQLFileInputFormat.materialize(org.apache.hadoop.fs.Path path)
materialize the input file into a memory Bag
|
static Bag |
Plan.merge(DataSource s)
merge the sorted files of the data source
|
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 Bag |
Config.parse_args(String[] args,
org.apache.hadoop.conf.Configuration conf)
read configuration parameters from the Main args
|
Bag |
JsonFormatParser.parse(String s) |
Bag |
Parser.parse(String s) |
Bag |
XMLParser.parse(String s) |
Bag |
LineParser.parse(String line) |
static Bag |
MapReduceAlgebra.parsedSource(int source_num,
Parser parser,
String file,
Trees args)
parse a text document using a given parser and tag output data with a source num
|
static Bag |
MapReduceAlgebra.parsedSource(int source_num,
String parser,
String file,
Trees args)
parse a text document using a given parser and tag output data with a source num
|
static Bag |
MapReduceAlgebra.parsedSource(Parser parser,
String file,
Trees args)
parse a text document using a given parser
|
static Bag |
MapReduceAlgebra.parsedSource(String parser,
String file,
Trees args)
parse a text document using a given parser
|
static Bag |
SystemFunctions.plus(Bag x,
Bag y) |
static Bag |
SystemFunctions.range(Bag b,
MR_int mi,
MR_int mj) |
static Bag |
MapReduceAlgebra.read_binary(int source_num,
String file)
read the contents of a dumped local binary file and tag data with a source num
|
static Bag |
Bag.read(DataInput in)
the input serializer for Bag
|
static Bag |
MapReduceAlgebra.repeat(Function loop,
Bag init,
int max_num)
repeat the loop until all termination conditions are true or until we reach the max num of steps
|
Bag |
Bag.set(int n,
MRData value)
replace the n'th element of a Bag with a new value
|
Bag |
Bag.union(Bag s)
concatenate the elements of a given Bag to the elements of this Bag.
|
static Bag |
SystemFunctions.union(Bag x,
Bag y) |
Bag |
XPathParser.MRDataHandler.value() |
static Bag |
SystemFunctions.XMLattribute(MR_string tagname,
Bag nodes) |
static Bag |
SystemFunctions.XMLattributes(MR_string tagname,
Bag nodes) |
static Bag |
SystemFunctions.XMLattributes(MR_string tagname,
Union node) |
static Bag |
SystemFunctions.XMLchildren(MR_string tagname,
Bag nodes) |
static Bag |
SystemFunctions.XMLchildren(MR_string tagname,
Union node) |
Modifier and Type | Method and Description |
---|---|
Bag |
Bag.addAll(Bag b)
add the elements of a Bag to the end of this Bag
|
static MRData |
MapReduceAlgebra.aggregate(Function accumulator,
MRData zero,
Bag s)
aggregate the Bag elements
|
static MR_bool |
SystemFunctions.all(Bag x) |
static MRData |
MapReduceAlgebra.BSP(int[] source,
Function superstep,
MRData init_state,
boolean order,
Bag[] inputs)
The BSP operation
|
static Bag |
MapReduceAlgebra.closure(Function loop,
Bag init,
int max_num)
transitive closure: repeat the loop until the new set is equal to the previous set
or until we reach the max num of steps
|
static Bag |
MapReduceAlgebra.cmap(Function f,
Bag s)
lazy concat-map (stream-based)
|
static MR_long |
SystemFunctions.count(Bag s) |
static Bag |
MapReduceAlgebra.crossProduct(Function mx,
Function my,
Function r,
Bag X,
Bag Y)
A cross-product
|
static Bag |
SystemFunctions.distribute(MR_string peerName,
Bag s) |
Bag |
Evaluator.distribute(MR_string peerName,
Bag s)
distribute a bag among peers in BSP mode
|
static Bag |
SystemFunctions.except(Bag x,
Bag y) |
static MR_bool |
SystemFunctions.exists(Bag s) |
static DataSet |
Plan.fileCache(Bag s)
The cache operator that dumps a bag into an HDFS file
|
static Bag |
MapReduceAlgebra.filter(Function p,
Function f,
Bag s)
lazy filter combined with a map
|
static MRData |
SystemFunctions.fold(Lambda c,
MRData z,
Bag s) |
static Bag |
MapReduceAlgebra.groupBy(Bag s)
strict group-by
|
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 Bag |
MapReduceAlgebra.hash_join(Function kx,
Function ky,
Function f,
Bag X,
Bag Y)
A hash-based equi-join
|
static MRData |
SystemFunctions.index(Bag b,
MR_int mi) |
static Bag |
SystemFunctions.intersect(Bag x,
Bag y) |
static Bag |
MapReduceAlgebra.map(Function f,
Bag s)
lazy map
|
static Bag |
MapReduceAlgebra.mapJoin(Function kx,
Function ky,
Function r,
Bag X,
Bag Y)
The fragment-replicate join (map-side join)
|
static Bag |
MapReduceAlgebra.mapReduce(Function m,
Function r,
Bag s)
the MapReduce operation
|
static Bag |
MapReduceAlgebra.mapReduce2(Function mx,
Function my,
Function r,
Bag X,
Bag Y)
A map-reduce operation with two mappers (a join)
|
static Bag |
SystemFunctions.materialize(Bag 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 Bag |
SystemFunctions.plus(Bag x,
Bag y) |
static Bag |
SystemFunctions.range(Bag b,
MR_int mi,
MR_int mj) |
static Bag |
MapReduceAlgebra.repeat(Function loop,
Bag init,
int max_num)
repeat the loop until all termination conditions are true or until we reach the max num of steps
|
static MR_bool |
SystemFunctions.some(Bag x) |
static MR_string |
SystemFunctions.text(Bag nodes) |
Bag |
Bag.union(Bag s)
concatenate the elements of a given Bag to the elements of this Bag.
|
static Bag |
SystemFunctions.union(Bag x,
Bag y) |
static Bag |
SystemFunctions.XMLattribute(MR_string tagname,
Bag nodes) |
static Bag |
SystemFunctions.XMLattributes(MR_string tagname,
Bag nodes) |
static Bag |
SystemFunctions.XMLchildren(MR_string tagname,
Bag nodes) |
Copyright © 2013–2014 The Apache Software Foundation. All rights reserved.