class Relation extends Table with Error with Serializable
The Relation class stores and operates on vectors. The vectors form the
columns of the columnar relational datastore. Columns may have any of the
following types:
C - Complex - VectorC - 128 bit complex number a + bi
D - Double - VectorD - 64 bit double precision floating point number
I - Int - VectorI - 32 bit integer
L - Long - VectorL - 64 bit long integer
Q - Rational - VectorQ - 128 bit ratio of two long integers
R - Real - VectorR - 128 bit quad precision floating point number
S - StrNum - VectorS - variable length numeric string
T - TimeNum - VectorT - 96 bit time Instant = (Long, Int)
FIX - (1) don't allow (public) var (2) avoid unchecked or incomplete .asInstanceOf [T] ------------------------------------------------------------------------------
- Alphabetic
- By Inheritance
- Relation
- Serializable
- Error
- Table
- Tabular
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
-
new
Relation(name: String, colName: Seq[String], col: Vector[Vec], key: Int = 0, domain: String = null, fKeys: Seq[(String, String, Int)] = null, enter: Boolean = true)
- 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)
- enter
whether to enter the newly created relation into the
Catalog
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
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
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
add(tuple: Row): Unit
Add 'tuple' to 'this' relation as a new row.
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
avg(cName: String): Any
Return the mean of the values in column 'cName'.
Return the mean of the values in column 'cName'.
- cName
the column name
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
- var col: Vector[Vec]
- val colName: Seq[String]
-
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'.
Return the number of values in column 'cName'.
- cName
the column name
-
def
delete[T](p: Predicate[T]*): Relation
Delete the rows from 'this' relation that satisfy the predicates.
-
def
disambiguate(cn1: Seq[String], cn2: Seq[String]): Seq[String]
Combine two sequences of column names and disambiguate any repeated names by appending "2".
Combine two sequences of column names and disambiguate any repeated names by appending "2".
- cn1
the first sequence of column names
- cn2
the second sequence of column names
- Attributes
- protected
- Definition Classes
- Table
- val domain: String
-
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
-
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
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- var fKeys: Seq[(String, String, Int)]
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
final
def
flaw(method: String, message: String): Unit
- Definition Classes
- Error
-
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
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
groupBy(cName: String*): Relation
Group 'this' relation by the specified column names, returning 'this' relation.
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
incompatible(r2: Table): Boolean
Determine whether 'this' relation and 'r2' are incompatible by having differing numbers of columns or differing domain strings.
-
val
index: Map[KeyType, Row]
- Attributes
- protected
-
val
indextoKey: HashMap[Int, KeyType]
- Attributes
- protected
-
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
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
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
- val key: Int
-
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
-
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
-
def
max(cName: String): Any
Return the maximum value in column 'cName'.
Return the maximum value in column 'cName'.
- cName
the column name
- def mean(cName: String): Any
-
def
min(cName: String): Any
Return the minimum value in column 'cName'.
Return the minimum value in column 'cName'.
- cName
the column name
-
def
minus(r2: Table): Relation
Take the difference of 'this' relation and 'r2' ('this - r2').
- val name: String
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
orderBy(_cName: String*): Relation
Order (ascending) the rows in the relation by the selected columns '_cName'.
-
var
orderedIndex: Vector[KeyType]
- Attributes
- protected
-
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
-
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
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
-
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
-
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]
-
def
show(limit: Int = Int.MaxValue): Unit
Show 'this' relation row by row.
-
def
showFk(): Unit
Show 'this' relation's foreign keys.
-
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
- 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'.
Return the sum of the values in column 'cName'.
- cName
the column name
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
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
-
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
-
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
-
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
-
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
-
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
-
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
-
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
-
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
-
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
-
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
-
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
-
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
-
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
-
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
-
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
-
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
-
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
-
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
-
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
-
def
uncompress(cName: String*): Unit
Uncompress the selected columns 'cName' in 'this' table.
-
def
union(r2: Table): Relation
Union 'this' relation and 'r2'.
-
def
uniq_union(cn1: Seq[String], cn2: Seq[String]): Seq[String]
Combine two sequences of column names, keeping all names from 'cn1' and only those in 'cn2' that are not repeats (i.e., not already in 'cn1').
Combine two sequences of column names, keeping all names from 'cn1' and only those in 'cn2' that are not repeats (i.e., not already in 'cn1').
- cn1
the first sequence of column names
- cn2
the second sequence of column names
- Attributes
- protected
- Definition Classes
- Table
-
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'.
Return the variance of the values in column 'cName'.
- cName
the column name
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
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