Relation

Companion object Relation

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] ------------------------------------------------------------------------------

Linear Supertypes

Serializable, Error, Table, Tabular, AnyRef, Any

Known Subclasses

RelationF

Ordering

Alphabetic
By Inheritance

Inherited

Relation
Serializable
Error
Table
Tabular
AnyRef
Any

Hide All
Show All

Visibility

Public
All

Instance Constructors

new Relation(name: String, colName: Seq[String], col: Vector[Vec] = null, 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

def !=[T](cv: (String, T))(implicit arg0: ClassTag[T]): Relation
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
def <[T <: Ordered[T]](cv: (String, T))(implicit arg0: ClassTag[T]): Relation
def <=[T <: Ordered[T]](cv: (String, T))(implicit arg0: ClassTag[T]): Relation
def ==[T](cv: (String, T))(implicit arg0: ClassTag[T]): Relation
Return the relation whose rows are equal to 'value' in the column with the given name.
Return the relation whose rows are equal to 'value' in the column with the given name.
cv
the (column-name, value) pair, e.g., ("time", 5.00)
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def >[T <: Ordered[T]](cv: (String, T))(implicit arg0: ClassTag[T]): Relation
def >=[T <: Ordered[T]](cv: (String, T))(implicit arg0: ClassTag[T]): Relation
def add(tuple: Row): Unit
Add 'tuple' to 'this' relation as a new row.
Add 'tuple' to 'this' relation as a new row. It uses 'col2' as a temp 'col' to improve performance.
tuple
an aggregation of columns values (new row)

Definition Classes
Relation → Table
Annotations
@throws( classOf [Exception] )
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[lang]
Definition Classes
AnyRef
Annotations
@throws( ... ) @native() @HotSpotIntrinsicCandidate()
var col: Vector[Vec]
def colEmpty: Boolean
Determine whether all of the columns in the relation are empty.
val colName: Seq[String]
def colNames: Seq[String]
Return the names of columns in the relation.
Return the names of columns in the relation.

Definition Classes
Relation → Table
def cols: Int
Return the size in terms of number of columns in the relation.
Return the size in terms of number of columns in the relation.

Definition Classes
Relation → Table
def colsMap: Map[String, Int]
Return the mapping from column names to column positions.
Return the mapping from column names to column positions.

Definition Classes
Relation → Table
def column(cName: String): Vec
Return the column in the relation with column name 'cName'.
Return the column in the relation with column name 'cName'.
cName
column name used to retrieve the column vector

Definition Classes
Relation → Table
def columns: Vector[Vec]
Return all of the columns in the relation.
Return all of the columns in the relation.

Definition Classes
Relation → Table
def compress(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
Relation → Table
def contains(tuple: Row): Boolean
Determine whether 'this' relation contains a row matching the given 'tuple'.
Determine whether 'this' relation contains a row matching the given 'tuple'.
tuple
an aggregation of columns values (potential row)

Definition Classes
Relation → Table
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.
Delete the rows from 'this' relation that satisfy the predicates. FIX - handle all 24 domain types
T
the predicate type
p
tuple(1): column name, tuple(2): predicate (T => Boolean)

Definition Classes
Relation → Table
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.
Return the domains for the columns in the relation.

Definition Classes
Relation → Table
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

Definition Classes
Relation → Table
See also
en.wikipedia.org/wiki/Relational_algebra
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def exists: Boolean
Determine whether any rows/tuples exist in 'this' relation.
var fKeys: Seq[(String, String, Int)]
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() @HotSpotIntrinsicCandidate()
def groupBy(cName: String*): Relation
Group 'this' relation by the specified column names, returning 'this' relation.
Group 'this' relation by the specified column names, returning 'this' relation.
cName
the group column names

Definition Classes
Relation → Table
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@native() @HotSpotIntrinsicCandidate()
def incompatible(r2: Table): Boolean
Determine whether 'this' relation and 'r2' are incompatible by having differing numbers of columns or differing domain strings.
Determine whether 'this' relation and 'r2' are incompatible by having differing numbers of columns or differing domain strings.
r2
the other relation/table

Definition Classes
Relation → Table
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'.
Intersect 'this' relation and 'r2'. Check that the two relations are compatible. Use index to finish intersect operation.
_r2
the other relation

Definition Classes
Relation → Table
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)

Definition Classes
Relation → Table
def join(cName: Seq[String], _r2: Table): Relation
Join 'this' relation and 'r2' by performing a "natural-join".
Join 'this' relation and 'r2' by performing a "natural-join". Rows from both relations are compared requiring 'cName' values to be equal.
cName
the common join column names for both relation
_r2
the rhs relation in the join operation

Definition Classes
Relation → Table
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.
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 → Table
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
Join 'this' relation and 'r2' by performing an "equi-join", use index to join
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

Definition Classes
Relation → Table
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

Definition Classes
Relation → Table
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 materialize(): Relation
Materialize the relation by copying the temporary 'col2' into 'col'.
Materialize the relation by copying the temporary 'col2' into 'col'. It needs to be called by the end of the relation construction.
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').
Take the difference of 'this' relation and 'r2' ('this - r2'). Check that the two relations are compatible.
r2
the other relation

Definition Classes
Relation → Table
def minus2(_r2: Table): Relation
Take the difference of 'this' relation and 'r2' ('this - r2').
Take the difference of 'this' relation and 'r2' ('this - r2'). Check that the two relations are compatible. Indexed based minus.
_r2
the other relation
val name: String
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@native() @HotSpotIntrinsicCandidate()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@native() @HotSpotIntrinsicCandidate()
def orderBy(_cName: String*): Relation
Order (ascending) the rows in the relation by the selected columns '_cName'.
Order (ascending) the rows in the relation 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
Relation → Table
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.
Select elements from column 'cName' in 'this' relation that satisfy the predicate 'p' and project onto that column.
cName
the name of the column used for selection
p
the predicate (Boolean function) to be satisfied

Definition Classes
Relation → Table
def pisigmaD(cName: String, p: (Double) ⇒ Boolean): Relation

Definition Classes
Relation → Table
def pisigmaI(cName: String, p: (Int) ⇒ Boolean): Relation

Definition Classes
Relation → Table
def pisigmaL(cName: String, p: (Long) ⇒ Boolean): Relation

Definition Classes
Relation → Table
def pisigmaQ(cName: String, p: (Rational) ⇒ Boolean): Relation

Definition Classes
Relation → Table
def pisigmaR(cName: String, p: (Real) ⇒ Boolean): Relation

Definition Classes
Relation → Table
def pisigmaS(cName: String, p: (StrNum) ⇒ Boolean): Relation

Definition Classes
Relation → Table
def product(r2: Table): Relation
Compute the Cartesian product of this' relation and 'r2' ('this × r2').
Compute the Cartesian product of this' relation and 'r2' ('this × r2').
r2
the second relation

Definition Classes
Relation → Table
def project(cPos: Seq[Int], cName: Seq[String] = null): Relation
Project onto the columns with the given column positions using the given column names.
Project onto the columns with the given column positions using the given column names.
cPos
the positions of the columns to project onto
cName
the names of the columns to project onto

Definition Classes
Relation → Table
def project(cName: String*): Relation
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
Relation → Table
def rename(newName: String): Relation
Rename 'this' table, returning a shallow copy of 'this' table.
Rename 'this' table, returning a shallow copy of 'this' table.
newName
the new name for the table.

Definition Classes
Relation → Table
def reverseOrderBy(_cName: String*): Relation
Order (descending) the rows in the relation by the selected columns '_cName'.
Order (descending) the rows in the relation 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
Relation → Table
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'.
Create a row by pulling values from all columns at position 'i'.
i
the 'i'th position

Definition Classes
Relation → Table
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.
Return the size in terms of number of rows in the relation.

Definition Classes
Relation → Table
def save(): Unit
Save 'this' relation in a file using serialization.
Save 'this' relation in a file using serialization.

Definition Classes
Relation → Table
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'.
Select elements from columns in 'cName' in 'this' relation that satisfy the predicate 'p'.
cName
the name of the column used for selection
p
the predicate (Boolean function) to be satisfied

Definition Classes
Relation → Table
def selectAt(pos: Seq[Int]): Relation
Select across all columns at the specified column positions.
Select across all columns at the specified column positions.
pos
the specified column positions

Definition Classes
Relation → Table
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'.
Select the positions of elements from columns in 'cName' in 'this' relation that satisfy the predicate 'p'.
cName
the name of the column used for selection
p
the predicate (Boolean function) to be satisfied

Definition Classes
Relation → Table
def selectD(cName: String, p: (Double) ⇒ Boolean): Seq[Int]

Definition Classes
Relation → Table
def selectI(cName: String, p: (Int) ⇒ Boolean): Seq[Int]

Definition Classes
Relation → Table
def selectL(cName: String, p: (Long) ⇒ Boolean): Seq[Int]

Definition Classes
Relation → Table
def selectQ(cName: String, p: (Rational) ⇒ Boolean): Seq[Int]

Definition Classes
Relation → Table
def selectR(cName: String, p: (Real) ⇒ Boolean): Seq[Int]

Definition Classes
Relation → Table
def selectS(cName: String, p: (StrNum) ⇒ Boolean): Seq[Int]

Definition Classes
Relation → Table
def selectT(cName: String, p: (TimeNum) ⇒ Boolean): Seq[Int]
def show(limit: Int = Int.MaxValue): Unit
Show 'this' relation row by row.
Show 'this' relation row by row.
limit
the limit on the number of rows to display

Definition Classes
Relation → Tabular
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 (Boolean function) 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'.
Select elements from columns in 'cName' in 'this' relation that satisfy the predicate 'p'.
cName
the name of the column used for selection
p
the predicate (Boolean function) to be satisfied

Definition Classes
Relation → Table
def sigmaD(cName: String, p: (Double) ⇒ Boolean): Relation

Definition Classes
Relation → Table
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

Definition Classes
Relation → Table
def sigmaL(cName: String, p: (Long) ⇒ Boolean): Relation

Definition Classes
Relation → Table
def sigmaQ(cName: String, p: (Rational) ⇒ Boolean): Relation

Definition Classes
Relation → Table
def sigmaR(cName: String, p: (Real) ⇒ Boolean): Relation

Definition Classes
Relation → Table
def sigmaS(cName: String, p: (StrNum) ⇒ Boolean): Relation

Definition Classes
Relation → Table
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

Definition Classes
Relation → Table
def toMatriD2(colPos: Seq[Int] = null, kind: MatrixKind = DENSE): MatriD
Convert 'this' relation into a matrix of double.
Convert 'this' relation into a matrix of double. It will convert strings to double.
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

Definition Classes
Relation → Table
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 → Table
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 → Table
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

Definition Classes
Relation → Table
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 = 0): 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 = 0): 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 = 0): 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 toVectorC(colName: String): VectorC
Convert the 'colName' column of 'this' relation into a vector of complex numbers.
Convert the 'colName' column of 'this' relation into a vector of complex numbers.
colName
the column name to use for the vector

Definition Classes
Relation → Table
def toVectorC(colPos: Int = 0): VectorC
Convert the 'colPos' column of 'this' relation into a vector of complex numbers.
Convert the 'colPos' column of 'this' relation into a vector of complex numbers.
colPos
the column position to use for the vector

Definition Classes
Relation → Table
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 → Table
def toVectorD(colPos: Int = 0): 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 → Table
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 → Table
def toVectorI(colPos: Int = 0): 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 → Table
def toVectorL(colName: String): VectorL
Convert the 'colName' column of 'this' relation into a vector of long integers.
Convert the 'colName' column of 'this' relation into a vector of long integers.
colName
the column name to use for the vector

Definition Classes
Relation → Table
def toVectorL(colPos: Int = 0): VectorL
Convert the 'colPos' column of 'this' relation into a vector of long integers.
Convert the 'colPos' column of 'this' relation into a vector of long integers.
colPos
the column position to use for the vector

Definition Classes
Relation → Table
def toVectorQ(colName: String): VectorQ
Convert the 'colName' column of 'this' relation into a vector of rational numbers.
Convert the 'colName' column of 'this' relation into a vector of rational numbers.
colName
the column name to use for the vector

Definition Classes
Relation → Table
def toVectorQ(colPos: Int = 0): VectorQ
Convert the 'colPos' column of 'this' relation into a vector of rational numbers.
Convert the 'colPos' column of 'this' relation into a vector of rational numbers.
colPos
the column position to use for the vector

Definition Classes
Relation → Table
def toVectorR(colName: String): VectorR
Convert the 'colName' column of 'this' relation into a vector of real number.
Convert the 'colName' column of 'this' relation into a vector of real number.
colName
the column name to use for the vector

Definition Classes
Relation → Table
def toVectorR(colPos: Int = 0): VectorR
Convert the 'colPos' column of 'this' relation into a vector of real number.
Convert the 'colPos' column of 'this' relation into a vector of real number.
colPos
the column position to use for the vector

Definition Classes
Relation → Table
def toVectorS(colName: String): VectorS
Convert the 'colName' column of 'this' relation into a vector of string-num.
Convert the 'colName' column of 'this' relation into a vector of string-num.
colName
the column name to use for the vector

Definition Classes
Relation → Table
def toVectorS(colPos: Int = 0): VectorS
Convert the 'colPos' column of 'this' relation into a vector of string-num.
Convert the 'colPos' column of 'this' relation into a vector of string-num.
colPos
the column position to use for the vector

Definition Classes
Relation → Table
def toVectorT(colName: String): VectorT
Convert the 'colName' column of 'this' relation into a vector of time-num.
Convert the 'colName' column of 'this' relation into a vector of time-num.
colName
the column name to use for the vector

Definition Classes
Relation → Table
def toVectorT(colPos: Int = 0): VectorT
Convert the 'colPos' column of 'this' relation into a vector of time-num.
Convert the 'colPos' column of 'this' relation into a vector of time-num.
colPos
the column position to use for the vector

Definition Classes
Relation → Table
def uncompress(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
Relation → Table
def union(r2: Table): Relation
Union 'this' relation and 'r2'.
Union 'this' relation and 'r2'. Check that the two relations are compatible. If they are not, return the first 'this' relation.
r2
the other relation

Definition Classes
Relation → Table
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

Definition Classes
Relation → Table
def update[T](cName: String, func: (T) ⇒ T, matchVal: T): Unit
Update the column named 'cName' using function 'func' for elements with value 'matchStr'.
Update the column named 'cName' using function 'func' for elements with value 'matchStr'.
T
type of the column
cName
the name of the column to be updated
func
the function used to assign updated values
matchVal
the value to be matched to elements

Definition Classes
Relation → Table
def update[T](cName: String, newVal: T, matchVal: T): Unit
Update the column named 'cName' using function 'func' for elements with value 'matchStr'.
Update the column named 'cName' using function 'func' for elements with value 'matchStr'.
T
type of the column
cName
the name of the column to be updated
newVal
the value used to assign updated values
matchVal
the value to be matched to elements

Definition Classes
Relation → Table
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(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def writeCSV(fileName: String): Unit
Write 'this' relation into a CSV file with each row written to a line.
Write 'this' relation into a CSV file with each row written to a line.
fileName
the file name of the data file

Definition Classes
Relation → Table
def writeJSON(fileName: String): Unit
Write 'this' relation into a JSON file.
Write 'this' relation into a JSON file.
fileName
the file name of the data file

Definition Classes
Relation → Table
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 (Boolean function) 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

Inherited from Error

Value Members

final def flaw(method: String, message: String): Unit

Definition Classes
Error

Inherited from Table

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 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
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 indices: Range
Return the range of index values for the table.
Return the range of index values for the table.

Definition Classes
Table
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 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 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 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 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 (Boolean function) to be satisfied

Definition Classes
Table
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 ×(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 (Boolean function) 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

Inherited from AnyRef

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def clone(): AnyRef

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( ... ) @native() @HotSpotIntrinsicCandidate()
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@native() @HotSpotIntrinsicCandidate()
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@native() @HotSpotIntrinsicCandidate()
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@native() @HotSpotIntrinsicCandidate()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@native() @HotSpotIntrinsicCandidate()
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def finalize(): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] ) @Deprecated
Deprecated

Inherited from Any

Value Members

final def asInstanceOf[T0]: T0

Definition Classes
Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any

Ungrouped

def !=[T](cv: (String, T))(implicit arg0: ClassTag[T]): Relation
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
def <[T <: Ordered[T]](cv: (String, T))(implicit arg0: ClassTag[T]): Relation
def <=[T <: Ordered[T]](cv: (String, T))(implicit arg0: ClassTag[T]): Relation
def ==[T](cv: (String, T))(implicit arg0: ClassTag[T]): Relation
Return the relation whose rows are equal to 'value' in the column with the given name.
Return the relation whose rows are equal to 'value' in the column with the given name.
cv
the (column-name, value) pair, e.g., ("time", 5.00)
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def >[T <: Ordered[T]](cv: (String, T))(implicit arg0: ClassTag[T]): Relation
def >=[T <: Ordered[T]](cv: (String, T))(implicit arg0: ClassTag[T]): Relation
def add(tuple: Row): Unit
Add 'tuple' to 'this' relation as a new row.
Add 'tuple' to 'this' relation as a new row. It uses 'col2' as a temp 'col' to improve performance.
tuple
an aggregation of columns values (new row)

Definition Classes
Relation → Table
Annotations
@throws( classOf [Exception] )
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[lang]
Definition Classes
AnyRef
Annotations
@throws( ... ) @native() @HotSpotIntrinsicCandidate()
var col: Vector[Vec]
def colEmpty: Boolean
Determine whether all of the columns in the relation are empty.
val colName: Seq[String]
def colNames: Seq[String]
Return the names of columns in the relation.
Return the names of columns in the relation.

Definition Classes
Relation → Table
def cols: Int
Return the size in terms of number of columns in the relation.
Return the size in terms of number of columns in the relation.

Definition Classes
Relation → Table
def colsMap: Map[String, Int]
Return the mapping from column names to column positions.
Return the mapping from column names to column positions.

Definition Classes
Relation → Table
def column(cName: String): Vec
Return the column in the relation with column name 'cName'.
Return the column in the relation with column name 'cName'.
cName
column name used to retrieve the column vector

Definition Classes
Relation → Table
def columns: Vector[Vec]
Return all of the columns in the relation.
Return all of the columns in the relation.

Definition Classes
Relation → Table
def compress(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
Relation → Table
def contains(tuple: Row): Boolean
Determine whether 'this' relation contains a row matching the given 'tuple'.
Determine whether 'this' relation contains a row matching the given 'tuple'.
tuple
an aggregation of columns values (potential row)

Definition Classes
Relation → Table
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.
Delete the rows from 'this' relation that satisfy the predicates. FIX - handle all 24 domain types
T
the predicate type
p
tuple(1): column name, tuple(2): predicate (T => Boolean)

Definition Classes
Relation → Table
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.
Return the domains for the columns in the relation.

Definition Classes
Relation → Table
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

Definition Classes
Relation → Table
See also
en.wikipedia.org/wiki/Relational_algebra
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def exists: Boolean
Determine whether any rows/tuples exist in 'this' relation.
var fKeys: Seq[(String, String, Int)]
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() @HotSpotIntrinsicCandidate()
def groupBy(cName: String*): Relation
Group 'this' relation by the specified column names, returning 'this' relation.
Group 'this' relation by the specified column names, returning 'this' relation.
cName
the group column names

Definition Classes
Relation → Table
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@native() @HotSpotIntrinsicCandidate()
def incompatible(r2: Table): Boolean
Determine whether 'this' relation and 'r2' are incompatible by having differing numbers of columns or differing domain strings.
Determine whether 'this' relation and 'r2' are incompatible by having differing numbers of columns or differing domain strings.
r2
the other relation/table

Definition Classes
Relation → Table
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'.
Intersect 'this' relation and 'r2'. Check that the two relations are compatible. Use index to finish intersect operation.
_r2
the other relation

Definition Classes
Relation → Table
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)

Definition Classes
Relation → Table
def join(cName: Seq[String], _r2: Table): Relation
Join 'this' relation and 'r2' by performing a "natural-join".
Join 'this' relation and 'r2' by performing a "natural-join". Rows from both relations are compared requiring 'cName' values to be equal.
cName
the common join column names for both relation
_r2
the rhs relation in the join operation

Definition Classes
Relation → Table
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.
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 → Table
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
Join 'this' relation and 'r2' by performing an "equi-join", use index to join
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

Definition Classes
Relation → Table
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

Definition Classes
Relation → Table
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 materialize(): Relation
Materialize the relation by copying the temporary 'col2' into 'col'.
Materialize the relation by copying the temporary 'col2' into 'col'. It needs to be called by the end of the relation construction.
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').
Take the difference of 'this' relation and 'r2' ('this - r2'). Check that the two relations are compatible.
r2
the other relation

Definition Classes
Relation → Table
def minus2(_r2: Table): Relation
Take the difference of 'this' relation and 'r2' ('this - r2').
Take the difference of 'this' relation and 'r2' ('this - r2'). Check that the two relations are compatible. Indexed based minus.
_r2
the other relation
val name: String
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@native() @HotSpotIntrinsicCandidate()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@native() @HotSpotIntrinsicCandidate()
def orderBy(_cName: String*): Relation
Order (ascending) the rows in the relation by the selected columns '_cName'.
Order (ascending) the rows in the relation 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
Relation → Table
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.
Select elements from column 'cName' in 'this' relation that satisfy the predicate 'p' and project onto that column.
cName
the name of the column used for selection
p
the predicate (Boolean function) to be satisfied

Definition Classes
Relation → Table
def pisigmaD(cName: String, p: (Double) ⇒ Boolean): Relation

Definition Classes
Relation → Table
def pisigmaI(cName: String, p: (Int) ⇒ Boolean): Relation

Definition Classes
Relation → Table
def pisigmaL(cName: String, p: (Long) ⇒ Boolean): Relation

Definition Classes
Relation → Table
def pisigmaQ(cName: String, p: (Rational) ⇒ Boolean): Relation

Definition Classes
Relation → Table
def pisigmaR(cName: String, p: (Real) ⇒ Boolean): Relation

Definition Classes
Relation → Table
def pisigmaS(cName: String, p: (StrNum) ⇒ Boolean): Relation

Definition Classes
Relation → Table
def product(r2: Table): Relation
Compute the Cartesian product of this' relation and 'r2' ('this × r2').
Compute the Cartesian product of this' relation and 'r2' ('this × r2').
r2
the second relation

Definition Classes
Relation → Table
def project(cPos: Seq[Int], cName: Seq[String] = null): Relation
Project onto the columns with the given column positions using the given column names.
Project onto the columns with the given column positions using the given column names.
cPos
the positions of the columns to project onto
cName
the names of the columns to project onto

Definition Classes
Relation → Table
def project(cName: String*): Relation
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
Relation → Table
def rename(newName: String): Relation
Rename 'this' table, returning a shallow copy of 'this' table.
Rename 'this' table, returning a shallow copy of 'this' table.
newName
the new name for the table.

Definition Classes
Relation → Table
def reverseOrderBy(_cName: String*): Relation
Order (descending) the rows in the relation by the selected columns '_cName'.
Order (descending) the rows in the relation 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
Relation → Table
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'.
Create a row by pulling values from all columns at position 'i'.
i
the 'i'th position

Definition Classes
Relation → Table
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.
Return the size in terms of number of rows in the relation.

Definition Classes
Relation → Table
def save(): Unit
Save 'this' relation in a file using serialization.
Save 'this' relation in a file using serialization.

Definition Classes
Relation → Table
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'.
Select elements from columns in 'cName' in 'this' relation that satisfy the predicate 'p'.
cName
the name of the column used for selection
p
the predicate (Boolean function) to be satisfied

Definition Classes
Relation → Table
def selectAt(pos: Seq[Int]): Relation
Select across all columns at the specified column positions.
Select across all columns at the specified column positions.
pos
the specified column positions

Definition Classes
Relation → Table
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'.
Select the positions of elements from columns in 'cName' in 'this' relation that satisfy the predicate 'p'.
cName
the name of the column used for selection
p
the predicate (Boolean function) to be satisfied

Definition Classes
Relation → Table
def selectD(cName: String, p: (Double) ⇒ Boolean): Seq[Int]

Definition Classes
Relation → Table
def selectI(cName: String, p: (Int) ⇒ Boolean): Seq[Int]

Definition Classes
Relation → Table
def selectL(cName: String, p: (Long) ⇒ Boolean): Seq[Int]

Definition Classes
Relation → Table
def selectQ(cName: String, p: (Rational) ⇒ Boolean): Seq[Int]

Definition Classes
Relation → Table
def selectR(cName: String, p: (Real) ⇒ Boolean): Seq[Int]

Definition Classes
Relation → Table
def selectS(cName: String, p: (StrNum) ⇒ Boolean): Seq[Int]

Definition Classes
Relation → Table
def selectT(cName: String, p: (TimeNum) ⇒ Boolean): Seq[Int]
def show(limit: Int = Int.MaxValue): Unit
Show 'this' relation row by row.
Show 'this' relation row by row.
limit
the limit on the number of rows to display

Definition Classes
Relation → Tabular
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 (Boolean function) 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'.
Select elements from columns in 'cName' in 'this' relation that satisfy the predicate 'p'.
cName
the name of the column used for selection
p
the predicate (Boolean function) to be satisfied

Definition Classes
Relation → Table
def sigmaD(cName: String, p: (Double) ⇒ Boolean): Relation

Definition Classes
Relation → Table
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

Definition Classes
Relation → Table
def sigmaL(cName: String, p: (Long) ⇒ Boolean): Relation

Definition Classes
Relation → Table
def sigmaQ(cName: String, p: (Rational) ⇒ Boolean): Relation

Definition Classes
Relation → Table
def sigmaR(cName: String, p: (Real) ⇒ Boolean): Relation

Definition Classes
Relation → Table
def sigmaS(cName: String, p: (StrNum) ⇒ Boolean): Relation

Definition Classes
Relation → Table
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

Definition Classes
Relation → Table
def toMatriD2(colPos: Seq[Int] = null, kind: MatrixKind = DENSE): MatriD
Convert 'this' relation into a matrix of double.
Convert 'this' relation into a matrix of double. It will convert strings to double.
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

Definition Classes
Relation → Table
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 → Table
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 → Table
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

Definition Classes
Relation → Table
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 = 0): 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 = 0): 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 = 0): 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 toVectorC(colName: String): VectorC
Convert the 'colName' column of 'this' relation into a vector of complex numbers.
Convert the 'colName' column of 'this' relation into a vector of complex numbers.
colName
the column name to use for the vector

Definition Classes
Relation → Table
def toVectorC(colPos: Int = 0): VectorC
Convert the 'colPos' column of 'this' relation into a vector of complex numbers.
Convert the 'colPos' column of 'this' relation into a vector of complex numbers.
colPos
the column position to use for the vector

Definition Classes
Relation → Table
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 → Table
def toVectorD(colPos: Int = 0): 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 → Table
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 → Table
def toVectorI(colPos: Int = 0): 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 → Table
def toVectorL(colName: String): VectorL
Convert the 'colName' column of 'this' relation into a vector of long integers.
Convert the 'colName' column of 'this' relation into a vector of long integers.
colName
the column name to use for the vector

Definition Classes
Relation → Table
def toVectorL(colPos: Int = 0): VectorL
Convert the 'colPos' column of 'this' relation into a vector of long integers.
Convert the 'colPos' column of 'this' relation into a vector of long integers.
colPos
the column position to use for the vector

Definition Classes
Relation → Table
def toVectorQ(colName: String): VectorQ
Convert the 'colName' column of 'this' relation into a vector of rational numbers.
Convert the 'colName' column of 'this' relation into a vector of rational numbers.
colName
the column name to use for the vector

Definition Classes
Relation → Table
def toVectorQ(colPos: Int = 0): VectorQ
Convert the 'colPos' column of 'this' relation into a vector of rational numbers.
Convert the 'colPos' column of 'this' relation into a vector of rational numbers.
colPos
the column position to use for the vector

Definition Classes
Relation → Table
def toVectorR(colName: String): VectorR
Convert the 'colName' column of 'this' relation into a vector of real number.
Convert the 'colName' column of 'this' relation into a vector of real number.
colName
the column name to use for the vector

Definition Classes
Relation → Table
def toVectorR(colPos: Int = 0): VectorR
Convert the 'colPos' column of 'this' relation into a vector of real number.
Convert the 'colPos' column of 'this' relation into a vector of real number.
colPos
the column position to use for the vector

Definition Classes
Relation → Table
def toVectorS(colName: String): VectorS
Convert the 'colName' column of 'this' relation into a vector of string-num.
Convert the 'colName' column of 'this' relation into a vector of string-num.
colName
the column name to use for the vector

Definition Classes
Relation → Table
def toVectorS(colPos: Int = 0): VectorS
Convert the 'colPos' column of 'this' relation into a vector of string-num.
Convert the 'colPos' column of 'this' relation into a vector of string-num.
colPos
the column position to use for the vector

Definition Classes
Relation → Table
def toVectorT(colName: String): VectorT
Convert the 'colName' column of 'this' relation into a vector of time-num.
Convert the 'colName' column of 'this' relation into a vector of time-num.
colName
the column name to use for the vector

Definition Classes
Relation → Table
def toVectorT(colPos: Int = 0): VectorT
Convert the 'colPos' column of 'this' relation into a vector of time-num.
Convert the 'colPos' column of 'this' relation into a vector of time-num.
colPos
the column position to use for the vector

Definition Classes
Relation → Table
def uncompress(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
Relation → Table
def union(r2: Table): Relation
Union 'this' relation and 'r2'.
Union 'this' relation and 'r2'. Check that the two relations are compatible. If they are not, return the first 'this' relation.
r2
the other relation

Definition Classes
Relation → Table
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

Definition Classes
Relation → Table
def update[T](cName: String, func: (T) ⇒ T, matchVal: T): Unit
Update the column named 'cName' using function 'func' for elements with value 'matchStr'.
Update the column named 'cName' using function 'func' for elements with value 'matchStr'.
T
type of the column
cName
the name of the column to be updated
func
the function used to assign updated values
matchVal
the value to be matched to elements

Definition Classes
Relation → Table
def update[T](cName: String, newVal: T, matchVal: T): Unit
Update the column named 'cName' using function 'func' for elements with value 'matchStr'.
Update the column named 'cName' using function 'func' for elements with value 'matchStr'.
T
type of the column
cName
the name of the column to be updated
newVal
the value used to assign updated values
matchVal
the value to be matched to elements

Definition Classes
Relation → Table
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(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def writeCSV(fileName: String): Unit
Write 'this' relation into a CSV file with each row written to a line.
Write 'this' relation into a CSV file with each row written to a line.
fileName
the file name of the data file

Definition Classes
Relation → Table
def writeJSON(fileName: String): Unit
Write 'this' relation into a JSON file.
Write 'this' relation into a JSON file.
fileName
the file name of the data file

Definition Classes
Relation → Table
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 (Boolean function) 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
def finalize(): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] ) @Deprecated
Deprecated

Packages

Relation

Companion object Relation

class Relation extends Table with Error with Serializable

Instance Constructors

Value Members

Deprecated Value Members

Inherited from Error

Value Members

Inherited from Table

Value Members

Inherited from AnyRef

Value Members

Inherited from Any

Value Members

Ungrouped

Packages

Relation 

Companion object Relation

class Relation extends Table with Error with Serializable

Instance Constructors

Value Members

Deprecated Value Members

Inherited from Error

Value Members

Inherited from Table

Value Members

Inherited from AnyRef

Value Members

Inherited from Any

Value Members

Ungrouped

Relation