class RelationF extends Relation
The RelationF class create a relation/data frame by extending the Relation class,
and provides high order functions such as map and reduce.
FIX - should extend Tabular, not Relation
- Alphabetic
- By Inheritance
- RelationF
- Relation
- Serializable
- Error
- Table
- Tabular
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
-
new
RelationF(name: String, colName: Seq[String], col: Vector[Vec], key: Int = 0, domain: String = null, fKeys: Seq[(String, String, Int)] = null)
- name
the name of the relation
- colName
the names of columns
- col
the Scala Vector of columns making up the columnar relation
- key
the column number for the primary key (< 0 => no primary key)
- domain
an optional string indicating domains for columns (e.g., 'SD' = 'StrNum', 'Double')
- fKeys
an optional sequence of foreign keys - Seq (column name, ref table name, ref column position)
Value Members
-
def
-(r2: Table): Table
Take the difference of 'this' table and 'r2' ('this - r2').
Take the difference of 'this' table and 'r2' ('this - r2'). Check that the two tables are compatible.
- r2
the other table
- Definition Classes
- Table
-
def
add(tuple: Row): Unit
Add 'tuple' to 'this' relation as a new row.
-
def
avg(cName: String): Any
Return the mean of the values in column 'cName'.
-
var
col: Vector[Vec]
- Definition Classes
- Relation
-
val
colName: Seq[String]
- Definition Classes
- Relation
-
def
colNames: Seq[String]
Return the names of columns in the relation.
-
def
cols: Int
Return the size in terms of number of columns in the relation.
-
def
colsMap: Map[String, Int]
Return the mapping from column names to column positions.
-
def
column(cName: String): Vec
Return the column in the relation with column name 'cName'.
-
def
columns: Vector[Vec]
Return all of the columns in the relation.
-
def
compress(cName: String*): Unit
Compress the selected columns 'cName' in 'this' table.
-
def
contains(tuple: Row): Boolean
Determine whether 'this' relation contains a row matching the given 'tuple'.
-
def
count(cName: String): Int
Return the number of values in column 'cName'.
-
def
delete[T](p: Predicate[T]*): Relation
Delete the rows from 'this' relation that satisfy the predicates.
-
val
domain: String
- Definition Classes
- Relation
-
def
domains: String
Return the domains for the columns in the relation.
-
def
epi(aggCol: AggColumn*)(cName: String*): Table
Aggregate/project on the given columns (an extended projection operator that applies aggregate operators to aggregation columns and regular projection to projection columns).
Aggregate/project on the given columns (an extended projection operator that applies aggregate operators to aggregation columns and regular projection to projection columns).
- aggCol
the columns to aggregate on: (aggregate function, new column name, old column name)*
- cName
the other columns to project on
- Definition Classes
- Table
- See also
en.wikipedia.org/wiki/Relational_algebra
-
def
epiAny(aggF: Seq[AggFunction], funName: Seq[String], aggFAttr: Seq[String], cName: String*): Relation
Method 'epiAny' is a special case of epi.
Method 'epiAny' is a special case of epi. When the projected columns can not be decided by the group by columns, only one representative will be shown for each group. FIX - change name
- aggF
the aggregate functions you want to use
- funName
the newly created aggregate columns'names
- aggFAttr
the columns you want to use of correspondent aggregate functions
- cName
the columns you want to project on
- Definition Classes
- Relation
-
def
eproject(aggCol: AggColumn*)(cName: String*): Relation
Aggregate/project on the given columns (an extended projection operator that applies aggregate operators to aggregation columns and regular projection to projection columns).
Aggregate/project on the given columns (an extended projection operator that applies aggregate operators to aggregation columns and regular projection to projection columns).
- aggCol
the columns to aggregate on: (aggregate function, new column name, old column name)*
- cName
the other columns to project on
-
var
fKeys: Seq[(String, String, Int)]
- Definition Classes
- Relation
-
def
filter[T](p: Predicate[T]*): RelationF
Filter the
RelationFobject by predicate 'p'.Filter the
RelationFobject by predicate 'p'. FIX - what are the effects of this method ???- T
predicate type
- p
the predicate used to filter
-
final
def
flaw(method: String, message: String): Unit
- Definition Classes
- Error
-
def
fold[T](initvalue: T, f: (T, T) ⇒ T, colName: String): RelationF
Fold on column using function 'f'.
Fold on column using function 'f'.
- T
the type of the column
- initvalue
the initial starting value of the fold
- f
function to apply on the column
- colName
column to fold on
-
def
generateIndex(reset: Boolean = false): Unit
The 'generateIndex' method helps, e.g., the 'popTable', methods to generate an index for the table.
The 'generateIndex' method helps, e.g., the 'popTable', methods to generate an index for the table.
- reset
if reset is true, use old index to build new index; otherwise, create new index
- Definition Classes
- Relation
-
def
groupBy(cName: String*): Relation
Group 'this' relation by the specified column names, returning 'this' relation.
-
def
incompatible(r2: Table): Boolean
Determine whether 'this' relation and 'r2' are incompatible by having differing numbers of columns or differing domain strings.
-
def
indices: Range
Return the range of index values for the table.
Return the range of index values for the table.
- Definition Classes
- Table
-
def
intersect(_r2: Table): Relation
Intersect 'this' relation and 'r2'.
-
def
intersect2(r2: Table): Relation
Intersect 'this' relation and 'r2'.
Intersect 'this' relation and 'r2'. Check that the two relations are compatible. Slower and only to be used if there is no index.
- r2
the other relation
- Definition Classes
- Relation
-
def
join[T](_r2: Table, p0: Predicate2[T], p: Predicate2[T]*): Relation
The theta join, handle the predicates in where are connect by "and" (where a....and b....).
The theta join, handle the predicates in where are connect by "and" (where a....and b....).
- _r2
the second relation
- p0
the first theta join predicate (r1 cName, r2 cName, predicate to compare these two column)
- p
the rest of theta join predicates (r1 cName, r2 cName, predicates to compare these two column)
-
def
join(cName: Seq[String], _r2: Table): Relation
Join 'this' relation and 'r2' by performing a "natural-join".
-
def
join(cName1: Seq[String], cName2: Seq[String], r2: Table): Relation
Join 'this' relation and 'r2' by performing an "equi-join".
Join 'this' relation and 'r2' by performing an "equi-join". Rows from both relations are compared requiring 'cName1' values to equal 'cName2' values. Disambiguate column names by appending "2" to the end of any duplicate column name. FIX - only allows single attribute in join condition
- cName1
the join column names of this relation (e.g., the Foreign Key)
- cName2
the join column names of relation r2 (e.g., the Primary Key)
- r2
the rhs relation in the join operation
-
def
join(cName1: String, cName2: String, r2: Table): Table
Join 'this' table and 'r2' by performing an "equi-join".
Join 'this' table and 'r2' by performing an "equi-join". Rows from both tables are compared requiring 'cName1' values to equal 'cName2' values. Disambiguate column names by appending "2" to the end of any duplicate column name.
- cName1
the join column name of this table (e.g., the Foreign Key)
- cName2
the join column name of table r2 (e.g., the Primary Key)
- r2
the rhs table in the join operation
- Definition Classes
- Table
-
def
join(cName: String, r2: Table): Table
Join 'this' table and 'r2' by performing a "natural-join".
Join 'this' table and 'r2' by performing a "natural-join". Rows from both tables are compared requiring 'cName' values to be equal.
- cName
the common join column name for both table
- r2
the rhs table in the join operation
- Definition Classes
- Table
-
def
join(r2: Table): Table
Join 'this' table and 'r2' by performing a "natural-join".
Join 'this' table and 'r2' by performing a "natural-join". Rows from both tables are compared requiring agreement on common attributes (column names).
- r2
the rhs table in the join operation
- Definition Classes
- Table
-
def
joinindex(cName1: Seq[String], cName2: Seq[String], _r2: Table): Relation
Join 'this' relation and 'r2' by performing an "equi-join", use index to join FIX - only allows single attribute in join condition
Join 'this' relation and 'r2' by performing an "equi-join", use index to join FIX - only allows single attribute in join condition
- cName1
the join column names of this relation (e.g., the Foreign Key)
- cName2
the join column names of relation r2 (e.g., the Primary Key)
- _r2
the rhs relation in the join operation
- Definition Classes
- Relation
-
val
key: Int
- Definition Classes
- Relation
-
def
leftJoin(thres: Double = 0.001)(cName1: String, cName2: String, r2: Table): Relation
Join 'this' relation and 'r2' by performing an "apprimate left-join".
Join 'this' relation and 'r2' by performing an "apprimate left-join". Rows from both relations are compared requiring 'cName1' values to apprximately equal 'cName2' values. Disambiguate column names by appending "2" to the end of any duplicate column name. All rows from the left table are maintained with missing values indicators used where needed.
- thres
the approximate equality threshold
- cName1
the join column names of this relation (e.g., the Foreign Key)
- cName2
the join column names of relation r2 (e.g., the Primary Key)
- r2
the rhs relation in the join operation
-
def
leftJoin(cp1: Int, cp2: Int, r2: Relation): Relation
Join 'this' relation and 'r2' by performing a "left join".
Join 'this' relation and 'r2' by performing a "left join". Rows from both relations are compared requiring 'cp1' values to equal 'cp2' values. This method returns all the rows from 'this' relation, and the matched rows from relation 'r2'. It adds a 'null' tuples for the unmatched rows of relation 'r2' FIX: It requires relations 'this' and 'r2' to be sorted on column 'cp1' and 'cp2' resp., as it uses Sort-Merge join
- cp1
the position of the join column of this relation
- cp2
the position of the join column of 'r2' relation
- r2
the rhs relation in the join operation
- Definition Classes
- Relation
-
def
leftJoin(cName1: String, cName2: String, r2: Table): Relation
Join 'this' relation and 'r2' by performing an "left-join".
Join 'this' relation and 'r2' by performing an "left-join". Rows from both relations are compared requiring 'cName1' values to equal 'cName2' values. Disambiguate column names by appending "2" to the end of any duplicate column name. All rows from the left table are maintained with missing values indicators used where needed.
- cName1
the join column names of this relation (e.g., the Foreign Key)
- cName2
the join column names of relation r2 (e.g., the Primary Key)
- r2
the rhs relation in the join operation
-
def
leftJoinApx(cp1: Int, cp2: Int, r2: Relation): Relation
Join 'this' relation and 'r2' by performing a "left join".
Join 'this' relation and 'r2' by performing a "left join". Rows from both relations are compared requiring 'cp1' values to approximately equal 'cp2' values. This method returns all the rows from 'this' relation, and the matched rows from relation 'r2'. It adds a 'null' tuples for the unmatched rows of relation 'r2' FIX: It requires relations 'this' and 'r2' to be sorted on column 'cp1' and 'cp2' resp., as it uses Sort-Merge join
- cp1
the position of the join column of this relation
- cp2
the position of the join column of 'r2' relation
- r2
the rhs relation in the join operation
- Definition Classes
- Relation
-
def
map[T](f: (T) ⇒ T, colName: String): RelationF
Map a column to a new column according to function 'f'.
Map a column to a new column according to function 'f'.
- T
the type of the column
- f
the transformation function to apply
- colName
the column to apply map function
-
def
max(cName: String): Any
Return the maximum value in column 'cName'.
-
def
mean(cName: String): Any
- Definition Classes
- Relation
-
def
min(cName: String): Any
Return the minimum value in column 'cName'.
-
def
minus(r2: Table): Relation
Take the difference of 'this' relation and 'r2' ('this - r2').
-
val
name: String
- Definition Classes
- Relation
-
def
orderBy(_cName: String*): Relation
Order (ascending) the rows in the relation by the selected columns '_cName'.
-
def
parjoin(cName1: Seq[String], cName2: Seq[String], _r2: Relation, k: Int): Relation
Parallel Join 'this' relation and 'r2' by performing an equi join on cName1 = cName2 and into k -threads seperate the lhs into k part join with rhs.
Parallel Join 'this' relation and 'r2' by performing an equi join on cName1 = cName2 and into k -threads seperate the lhs into k part join with rhs. FIX - move to .par package
- cName1
the join column names of lhs relation
- cName2
the join column names of rhs relation
- _r2
the rhs relation in the join operation
- k
parallel run into k parts
- Definition Classes
- Relation
-
def
pi(cPos: Seq[Int], cName: Seq[String] = null): Table
Project onto the columns with the given column positions.
Project onto the columns with the given column positions.
- cPos
the column positions to project onto
- cName
the optional new names for the columns to project onto
- Definition Classes
- Table
-
def
pi(cName: String*): Table
Project onto the columns with the given column names.
Project onto the columns with the given column names.
- cName
the names of the columns to project onto
- Definition Classes
- Table
-
def
pisigmaC(cName: String, p: (Complex) ⇒ Boolean): Relation
Select elements from column 'cName' in 'this' relation that satisfy the predicate 'p' and project onto that column.
- def pisigmaD(cName: String, p: (Double) ⇒ Boolean): Relation
- def pisigmaI(cName: String, p: (Int) ⇒ Boolean): Relation
- def pisigmaL(cName: String, p: (Long) ⇒ Boolean): Relation
- def pisigmaQ(cName: String, p: (Rational) ⇒ Boolean): Relation
- def pisigmaR(cName: String, p: (Real) ⇒ Boolean): Relation
- def pisigmaS(cName: String, p: (StrNum) ⇒ Boolean): Relation
-
def
product(r2: Table): Relation
Compute the Cartesian product of this' relation and 'r2' ('this × r2').
-
def
project(cPos: Seq[Int], cName: Seq[String] = null): Relation
Project onto the columns with the given column positions using the given column names.
-
def
project(cName: String*): Relation
Project onto the columns with the given column names.
-
def
reduce[T](f: (T, T) ⇒ T, colName: String): RelationF
Reduce on column using function 'f'.
Reduce on column using function 'f'.
- T
the type of the column
- f
the transformation function to apply
- colName
the column to apply map function
-
def
rename(newName: String): Relation
Rename 'this' table, returning a shallow copy of 'this' table.
-
def
reverseOrderBy(_cName: String*): Relation
Order (descending) the rows in the relation by the selected columns '_cName'.
-
def
rightJoin(cp1: Int, cp2: Int, r2: Relation): Relation
Join 'this' relation and 'r2' by performing a "right join".
Join 'this' relation and 'r2' by performing a "right join". Rows from both relations are compared requiring 'cp1' values to equal 'cp2' values. This method returns all the rows from 'this' relation, and the matched rows from relation 'r2'. It adds a 'null' tuples for the unmatched rows of relation 'r2'
- cp1
the position of the join column of this relation
- cp2
the position of the join column of 'r2' relation
- r2
the rhs relation in the join operation
- Definition Classes
- Relation
-
def
rightJoin(cName1: String, cName2: String, r2: Table): Table
Join 'this' table and 'r2' by performing an "right-join".
Join 'this' table and 'r2' by performing an "right-join". Rows from both tables are compared requiring 'cName1' values to equal 'cName2' values. Disambiguate column names by appending "2" to the end of any duplicate column name. All rows from the right table are maintained with missing values indicators used where needed.
- cName1
the join column names of this table (e.g., the Foreign Key)
- cName2
the join column names of table r2 (e.g., the Primary Key)
- r2
the rhs table in the join operation
- Definition Classes
- Table
-
def
rightJoinApx(cp1: Int, cp2: Int, r2: Relation): Relation
Join 'this' relation and 'r2' by performing a "right join".
Join 'this' relation and 'r2' by performing a "right join". Rows from both relations are compared requiring 'cp1' values to approximately equal 'cp2' values. This method returns all the rows from 'this' relation, and the matched rows from relation 'r2'. It adds a 'null' tuples for the unmatched rows of relation 'r2'
- cp1
the position of the join column of this relation
- cp2
the position of the join column of 'r2' relation
- r2
the rhs relation in the join operation
- Definition Classes
- Relation
-
def
row(i: Int): Row
Create a row by pulling values from all columns at position 'i'.
-
def
row(sos: Seq[String], _typ: String): Row
Create a row by pulling values from an array of strings and converting elements to their appropriate types.
Create a row by pulling values from an array of strings and converting elements to their appropriate types.
- sos
the sequence of strings holding the values
- _typ
the string of corresponding types, e.g., 'SDI'
- Definition Classes
- Table
- Annotations
- @throws( classOf [Exception] )
-
def
rows: Int
Return the size in terms of number of rows in the relation.
-
def
save(): Unit
Save 'this' relation in a file using serialization.
-
def
select[T](cName: String, p: (T) ⇒ Boolean)(implicit arg0: ClassTag[T]): Relation
Select elements from columns in 'cName' in 'this' relation that satisfy the predicate 'p'.
-
def
selectAt(pos: Seq[Int]): Relation
Select across all columns at the specified column positions.
-
def
selectC(cName: String, p: (Complex) ⇒ Boolean): Seq[Int]
Select the positions of elements from columns in 'cName' in 'this' relation that satisfy the predicate 'p'.
- def selectD(cName: String, p: (Double) ⇒ Boolean): Seq[Int]
- def selectI(cName: String, p: (Int) ⇒ Boolean): Seq[Int]
- def selectL(cName: String, p: (Long) ⇒ Boolean): Seq[Int]
- def selectQ(cName: String, p: (Rational) ⇒ Boolean): Seq[Int]
- def selectR(cName: String, p: (Real) ⇒ Boolean): Seq[Int]
- def selectS(cName: String, p: (StrNum) ⇒ Boolean): Seq[Int]
-
def
selectT(cName: String, p: (TimeNum) ⇒ Boolean): Seq[Int]
- Definition Classes
- Relation
-
def
show(limit: Int = Int.MaxValue): Unit
Show 'this' relation row by row.
-
def
showFk(): Unit
Show 'this' relation's foreign keys.
Show 'this' relation's foreign keys.
- Definition Classes
- Relation
-
def
sigma[T](cName: String, p: (T) ⇒ Boolean)(implicit arg0: ClassTag[T]): Table
Select elements from columns in 'cName' in 'this' table that satisfy the predicate 'p'.
Select elements from columns in 'cName' in 'this' table that satisfy the predicate 'p'.
- cName
the name of the column used for selection
- p
the predicate (
Booleanfunction) to be satisfied
- Definition Classes
- Table
-
def
sigmaC(cName: String, p: (Complex) ⇒ Boolean): Relation
Select elements from columns in 'cName' in 'this' relation that satisfy the predicate 'p'.
- def sigmaD(cName: String, p: (Double) ⇒ Boolean): Relation
-
def
sigmaDpar(cName: String, p: (Double) ⇒ Boolean): Relation
The parellel version of 'selectD'.
The parellel version of 'selectD'. FIX - move to .par package
- cName
column to select on
- p
predicate to select
- Definition Classes
- Relation
- def sigmaI(cName: String, p: (Int) ⇒ Boolean): Relation
- def sigmaL(cName: String, p: (Long) ⇒ Boolean): Relation
- def sigmaQ(cName: String, p: (Rational) ⇒ Boolean): Relation
- def sigmaR(cName: String, p: (Real) ⇒ Boolean): Relation
- def sigmaS(cName: String, p: (StrNum) ⇒ Boolean): Relation
-
def
sum(cName: String): Any
Return the sum of the values in column 'cName'.
-
def
toMap(keyColName: Seq[String], valColName: String): Map[Seq[Any], Any]
Convert the given columns within 'this' relation to a map: 'keyColName' -> 'valColName'.
Convert the given columns within 'this' relation to a map: 'keyColName' -> 'valColName'.
- keyColName
the key column names
- Definition Classes
- Relation
-
def
toMap(keyColPos: Seq[Int], valColPos: Int): Map[Seq[Any], Any]
Convert the given columns within 'this' relation to a map: 'keyColPos' -> 'valColPos'.
Convert the given columns within 'this' relation to a map: 'keyColPos' -> 'valColPos'.
- keyColPos
the key column positions
- valColPos
the value column positions
- Definition Classes
- Relation
-
def
toMatriD(colPos: Seq[Int], kind: MatrixKind = DENSE): MatriD
Convert 'this' relation into a matrix of doubles, e.g.,
Convert 'this' relation into a matrix of doubles, e.g.,
in the regression equation: 'xb = y' create matrix 'xy'
- colPos
the column positions to use for the matrix
- kind
the kind of matrix to create
- Definition Classes
- Relation
-
def
toMatriDD(colPos: Seq[Int], colPosV: Int, kind: MatrixKind = DENSE): (MatriD, VectorD)
Convert 'this' relation into a matrix of doubles and a vector of doubles.
Convert 'this' relation into a matrix of doubles and a vector of doubles.
in the regression equation: 'xb = y' create matrix 'x' and vector 'y'
- colPos
the column positions to use for the matrix
- colPosV
the column position to use for the vector
- kind
the kind of matrix to create
- Definition Classes
- Relation
-
def
toMatriDI(colPos: Seq[Int], colPosV: Int, kind: MatrixKind = DENSE): (MatriD, VectorI)
Convert 'this' relation into a matrix of doubles and a vector of integers.
Convert 'this' relation into a matrix of doubles and a vector of integers.
in the regression equation: 'xb = y' create matrix 'x' and vector 'y'
- colPos
the column positions to use for the matrix
- colPosV
the column position to use for the vector
- kind
the kind of matrix to create
- Definition Classes
- Relation
-
def
toMatriI(colPos: Seq[Int], kind: MatrixKind = DENSE): MatriI
Convert 'this' relation into a matrix of integers.
Convert 'this' relation into a matrix of integers.
in the regression equation: 'xb = y' create matrix 'xy'
- colPos
the column positions to use for the matrix
- kind
the kind of matrix to create
- Definition Classes
- Relation
-
def
toMatriI2(colPos: Seq[Int] = null, kind: MatrixKind = DENSE): MatriI
Convert 'this' relation into a matrix of integers.
Convert 'this' relation into a matrix of integers. It will convert doubles and strings to integers.
in the regression equation: 'xb = y' create matrix 'xy'
- colPos
the column positions to use for the matrix
- kind
the kind of matrix to create
- Definition Classes
- Relation
-
def
toMatriII(colPos: Seq[Int], colPosV: Int, kind: MatrixKind = DENSE): (MatriI, VectorI)
Convert 'this' relation into a matrix of integers and a vector of integers.
Convert 'this' relation into a matrix of integers and a vector of integers.
in the regression equation: 'xb = y' create matrix 'x' and vector 'y'
- colPos
the column positions to use for the matrix
- colPosV
the column position to use for the vector
- kind
the kind of matrix to create
- Definition Classes
- Relation
-
def
toRleVectorD(colName: String): RleVectorD
Convert the 'colName' column of 'this' relation into a vector of doubles.
Convert the 'colName' column of 'this' relation into a vector of doubles.
- colName
the column name to use for the vector
- Definition Classes
- Relation
-
def
toRleVectorD(colPos: Int): RleVectorD
Convert the 'colPos' column of 'this' relation into a vector of doubles.
Convert the 'colPos' column of 'this' relation into a vector of doubles.
- colPos
the column position to use for the vector
- Definition Classes
- Relation
-
def
toRleVectorI(colName: String): RleVectorI
Convert the 'colName' column of 'this' relation into a vector of integers.
Convert the 'colName' column of 'this' relation into a vector of integers.
- colName
the column name to use for the vector
- Definition Classes
- Relation
-
def
toRleVectorI(colPos: Int): RleVectorI
Convert the 'colPos' column of 'this' relation into a vector of integers.
Convert the 'colPos' column of 'this' relation into a vector of integers.
- colPos
the column position to use for the vector
- Definition Classes
- Relation
-
def
toRleVectorS(colName: String): RleVectorS
Convert the 'colName' column of 'this' relation into a vector of integers.
Convert the 'colName' column of 'this' relation into a vector of integers.
- colName
the column name to use for the vector
- Definition Classes
- Relation
-
def
toRleVectorS(colPos: Int): RleVectorS
Convert the 'colPos' column of 'this' relation into a vector of integers.
Convert the 'colPos' column of 'this' relation into a vector of integers.
- colPos
the column position to use for the vector
- Definition Classes
- Relation
-
def
toString(): String
Convert 'this' relation into a string column by column.
Convert 'this' relation into a string column by column.
- Definition Classes
- Relation → AnyRef → Any
-
def
toVectorD(colName: String): VectorD
Convert the 'colName' column of 'this' relation into a vector of doubles.
Convert the 'colName' column of 'this' relation into a vector of doubles.
- colName
the column name to use for the vector
- Definition Classes
- Relation
-
def
toVectorD(colPos: Int): VectorD
Convert the 'colPos' column of 'this' relation into a vector of doubles.
Convert the 'colPos' column of 'this' relation into a vector of doubles.
- colPos
the column position to use for the vector
- Definition Classes
- Relation
-
def
toVectorI(colName: String): VectorI
Convert the 'colName' column of 'this' relation into a vector of integers.
Convert the 'colName' column of 'this' relation into a vector of integers.
- colName
the column name to use for the vector
- Definition Classes
- Relation
-
def
toVectorI(colPos: Int): VectorI
Convert the 'colPos' column of 'this' relation into a vector of integers.
Convert the 'colPos' column of 'this' relation into a vector of integers.
- colPos
the column position to use for the vector
- Definition Classes
- Relation
-
def
toVectorS(colName: String): VectorS
Convert the 'colName' column of 'this' relation into a vector of integers.
Convert the 'colName' column of 'this' relation into a vector of integers.
- colName
the column name to use for the vector
- Definition Classes
- Relation
-
def
toVectorS(colPos: Int): VectorS
Convert the 'colPos' column of 'this' relation into a vector of integers.
Convert the 'colPos' column of 'this' relation into a vector of integers.
- colPos
the column position to use for the vector
- Definition Classes
- Relation
-
def
uncompress(cName: String*): Unit
Uncompress the selected columns 'cName' in 'this' table.
-
def
union(r2: Table): Relation
Union 'this' relation and 'r2'.
-
def
update[T](cName: String, func: (T) ⇒ T, pred: (T) ⇒ Boolean): Unit
Update the column named 'cName' using function 'func' for elements where the predicate 'pred' evaluates to true.
Update the column named 'cName' using function 'func' for elements where the predicate 'pred' evaluates to true.
- T
type of the column
- cName
the name of the column to be updated
- func
the function used to assign updated values
- pred
the predicated used to select elements for update
-
def
update[T](cName: String, func: (T) ⇒ T, matchVal: T): Unit
Update the column named 'cName' using function 'func' for elements with value 'matchStr'.
-
def
update[T](cName: String, newVal: T, matchVal: T): Unit
Update the column named 'cName' using function 'func' for elements with value 'matchStr'.
-
def
variance(cName: String): Any
Return the variance of the values in column 'cName'.
-
def
writeCSV(fileName: String): Unit
Write 'this' relation into a CSV file with each row written to a line.
-
def
writeJSON(fileName: String): Unit
Write 'this' relation into a JSON file.
-
def
×(r2: Table): Table
Compute the Cartesian product of 'this' table and 'r2' ('this × r2').
Compute the Cartesian product of 'this' table and 'r2' ('this × r2').
- r2
the second table
- Definition Classes
- Table
-
def
Π(aggCol: AggColumn*)(cName: String*): Table
Aggregate/project on the given columns (an extended projection operator that applies aggregate operators to aggregation columns and regular projection to projection columns).
Aggregate/project on the given columns (an extended projection operator that applies aggregate operators to aggregation columns and regular projection to projection columns).
- aggCol
the columns to aggregate on: (aggregate function, new column name, old column name)*
- cName
the other columns to project on
- Definition Classes
- Table
- See also
en.wikipedia.org/wiki/Relational_algebra
-
def
γ(cName: String*): Table
Group 'this' table by specified column names, returning 'this' table.
Group 'this' table by specified column names, returning 'this' table.
- cName
group columns
- Definition Classes
- Table
-
def
ζ(cName: String*): Unit
Compress the selected columns 'cName' in 'this' table.
Compress the selected columns 'cName' in 'this' table.
- cName
the names of the columns to be compressed
- Definition Classes
- Table
-
def
ζζ(cName: String*): Unit
Uncompress the selected columns 'cName' in 'this' table.
Uncompress the selected columns 'cName' in 'this' table.
- cName
the names of the columns to be uncompressed
- Definition Classes
- Table
-
def
π(cPos: Seq[Int], cName: Seq[String] = null): Table
Project onto the columns with the given column positions.
Project onto the columns with the given column positions.
- cPos
the column positions to project onto
- cName
the optional new names for the columns to project onto
- Definition Classes
- Table
-
def
π(cName: String*): Table
Project onto the columns with the given column names.
Project onto the columns with the given column names.
- cName
the names of the columns to project onto
- Definition Classes
- Table
-
def
σ[T](cName: String, p: (T) ⇒ Boolean)(implicit arg0: ClassTag[T]): Table
Select elements from columns in 'cName' in 'this' table that satisfy the predicate 'p'.
Select elements from columns in 'cName' in 'this' table that satisfy the predicate 'p'.
- cName
the name of the column used for selection
- p
the predicate (
Booleanfunction) to be satisfied
- Definition Classes
- Table
-
def
ω(cName: String*): Table
Order (ascending) the rows in the table by the selected columns 'cName'.
Order (ascending) the rows in the table by the selected columns 'cName'. A stable sorting is used to allow sorting on multiple columns.
- cName
the column names that are to be sorted
- Definition Classes
- Table
-
def
ωω(cName: String*): Table
Order (descending) the rows in the table by the selected columns 'cName'.
Order (descending) the rows in the table by the selected columns 'cName'. A stable sorting is used to allow sorting on multiple columns.
- cName
the column names that are to be sorted
- Definition Classes
- Table
-
def
⋂(r2: Table): Table
Intersect 'this' table and 'r2'.
Intersect 'this' table and 'r2'. Check that the two tables are compatible.
- r2
the other table
- Definition Classes
- Table
-
def
⋃(r2: Table): Table
Union 'this' table and 'r2'.
Union 'this' table and 'r2'. Check that the two tables are compatible.
- r2
the other table
- Definition Classes
- Table
-
def
⋈[T](r2: Table, p0: Predicate2[T], p: Predicate2[T]*): Table
The theta join, handle the predicates in where are connect by "and" (where a....and b....).
The theta join, handle the predicates in where are connect by "and" (where a....and b....).
- r2
the second table
- p0
the first theta join predicate (r1 cName, r2 cName, predicate to compare these two column)
- p
the rest of theta join predicates (r1 cName, r2 cName, predicates to compare these two column)
- Definition Classes
- Table
-
def
⋈(cNames1: Seq[String], cNames2: Seq[String], r2: Table): Table
Join 'this' table and 'r2' by performing an "equi-join".
Join 'this' table and 'r2' by performing an "equi-join". Rows from both tables are compared requiring 'cName1' values to equal 'cName2' values. Disambiguate column names by appending "2" to the end of any duplicate column name.
- cNames1
the join column names of this table (e.g., the Foreign Key)
- cNames2
the join column names of table r2 (e.g., the Primary Key)
- r2
the rhs table in the join operation
- Definition Classes
- Table
-
def
⋈(cName1: String, cName2: String, r2: Table): Table
Join 'this' table and 'r2' by performing an "equi-join".
Join 'this' table and 'r2' by performing an "equi-join". Rows from both tables are compared requiring 'cName1' values to equal 'cName2' values. Disambiguate column names by appending "2" to the end of any duplicate column name.
- cName1
the join column name of this table (e.g., the Foreign Key)
- cName2
the join column name of table r2 (e.g., the Primary Key)
- r2
the rhs table in the join operation
- Definition Classes
- Table
-
def
⋈(cNames: Seq[String], r2: Table): Table
Join 'this' table and 'r2' by performing a "natural-join".
Join 'this' table and 'r2' by performing a "natural-join". Rows from both tables are compared requiring 'cName' values to be equal.
- cNames
the common join column names for both table
- r2
the rhs table in the join operation
- Definition Classes
- Table
-
def
⋈(cName: String, r2: Table): Table
Join 'this' table and 'r2' by performing a "natural-join".
Join 'this' table and 'r2' by performing a "natural-join". Rows from both tables are compared requiring 'cName' values to be equal.
- cName
the common join column name for both table
- r2
the rhs table in the join operation
- Definition Classes
- Table
-
def
⋈(r2: Table): Table
Join 'this' table and 'r2' by performing a "natural-join".
Join 'this' table and 'r2' by performing a "natural-join". Rows from both tables are compared requiring agreement on common attributes (column names).
- r2
the rhs table in the join operation
- Definition Classes
- Table
-
def
⋉(thres: Double = 0.01)(cName1: String, cName2: String, r2: Table): Table
Join 'this' table and 'r2' by performing an "apprimate left-join".
Join 'this' table and 'r2' by performing an "apprimate left-join". Rows from both tables are compared requiring 'cName1' values to apprximately equal 'cName2' values. Disambiguate column names by appending "2" to the end of any duplicate column name. All rows from the left table are maintained with missing values indicators used where needed.
- cName1
the join column names of this table (e.g., the Foreign Key)
- cName2
the join column names of table r2 (e.g., the Primary Key)
- r2
the rhs table in the join operation
- Definition Classes
- Table
-
def
⋉(cName1: String, cName2: String, r2: Table): Table
Join 'this' table and 'r2' by performing an "left-join".
Join 'this' table and 'r2' by performing an "left-join". Rows from both tables are compared requiring 'cName1' values to equal 'cName2' values. Disambiguate column names by appending "2" to the end of any duplicate column name. All rows from the left table are maintained with missing values indicators used where needed. Note: although this is the semi-join symbol, due to Unicode limitations, it is used for left-join.
- cName1
the join column names of this table (e.g., the Foreign Key)
- cName2
the join column names of table r2 (e.g., the Primary Key)
- r2
the rhs table in the join operation
- Definition Classes
- Table
-
def
⋊(cName1: String, cName2: String, r2: Table): Table
Join 'this' table and 'r2' by performing an "right-join".
Join 'this' table and 'r2' by performing an "right-join". Rows from both tables are compared requiring 'cName1' values to equal 'cName2' values. Disambiguate column names by appending "2" to the end of any duplicate column name. All rows from the right table are maintained with missing values indicators used where needed.
- cName1
the join column names of this table (e.g., the Foreign Key)
- cName2
the join column names of table r2 (e.g., the Primary Key)
- r2
the rhs table in the join operation
- Definition Classes
- Table