case class Relation(name: String, colName: Seq[String], col: Vector[Vec], key: Int = 0, domain: String = null, fKeys: Seq[(String, String, Int)] = null) extends Table with Error with Product 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
- 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)
- Alphabetic
- By Inheritance
- Relation
- Serializable
- Serializable
- Product
- Equals
- Error
- Table
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
-
new
Relation(name: String, colName: Seq[String], col: Vector[Vec], key: Int = 0, domain: String = null, fKeys: Seq[(String, String, Int)] = null)
- name
the name of the relation
- colName
the names of columns
- col
the Scala Vector of columns making up the columnar relation
- key
the column number for the primary key (< 0 => no primary key)
- domain
an optional string indicating domains for columns (e.g., 'SD' = 'StrNum', 'Double')
- fKeys
an optional sequence of foreign keys - Seq (column name, ref table name, ref column position)
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
def
-(_r2: Table): Relation
Take the difference of 'this' relation and 'r2' ('this - r2').
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
><(_r2: Table): Relation
Join 'this' relation and 'r2 by performing a "natural-join".
-
def
add(tuple: Row): Unit
Add 'tuple' to 'this' relation as a new row.
-
def
add_2(tuple: Row): Unit
Add 'tuple' to 'this' relation as a new row.
Add 'tuple' to 'this' relation as a new row. Type is determined by sampling values for columns
- tuple
an aggregation of columns values (new row)
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
- var col: Vector[Vec]
- val colName: Seq[String]
-
def
cols: Int
Return the size in terms of number of columns in the relation.
-
def
contains(tuple: Row): Boolean
Determine whether 'this' relation contains a row matching the given 'tuple'.
-
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
- Definition Classes
- Table
- val domain: String
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- var fKeys: Seq[(String, String, Int)]
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
final
def
flaw(method: String, message: String): Unit
- Definition Classes
- Error
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
incompatible(_r2: Table): Boolean
Determine whether 'this' relation and 'r2' are incompatible by having differing numbers of columns or differing domain strings.
-
def
indices: Range
Return the range of index values for the relation.
Return the range of index values for the relation.
- Definition Classes
- Table
-
def
intersect(_r2: Table): Relation
Intersect 'this' relation and 'r2'.
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
join(cName: Seq[String], _r2: Table): Relation
Join 'this' relation and 'r2 by performing a "natural-join".
-
def
join(cName1: String, cName2: 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 string of join column names of this relation (e.g., the Foreign Key)
- cName2
the string of join column names of relation r2 (e.g., the Primary Key)
- r2
the rhs relation in the join operation
-
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)
- val key: Int
- val name: String
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
pi(cPos: Seq[Int], cName: Seq[String] = null): Relation
Project onto the columns with the given column positions.
-
def
pi(cName: String*): Relation
Project onto the columns with the given column names.
-
def
pisigmaC(cName: String, p: (Complex) ⇒ Boolean): Relation
Select elements from column 'cName' in 'this' relation that satisfy the predicate 'p' and project onto that column.
- def pisigmaD(cName: String, p: (Double) ⇒ Boolean): Relation
- def pisigmaI(cName: String, p: (Int) ⇒ Boolean): Relation
- def pisigmaL(cName: String, p: (Long) ⇒ Boolean): Relation
- def pisigmaQ(cName: String, p: (Rational) ⇒ Boolean): Relation
- def pisigmaR(cName: String, p: (Real) ⇒ Boolean): Relation
- def pisigmaS(cName: String, p: (StrNum) ⇒ Boolean): Relation
-
def
row(i: Int): Row
Create a row by pulling values from all columns at position 'i'.
-
def
row(sos: Seq[String], _typ: String): Row
Create a row by pulling values from an array of strings and converting elements to their appropriate types.
Create a row by pulling values from an array of strings and converting elements to their appropriate types.
- sos
the sequence of strings holding the values
- _typ
the string of corresponding types, e.g., 'SDI'
- Definition Classes
- Table
-
def
rows: Int
Return the size in terms of number of rows in the relation.
-
def
save(): Unit
Save 'this' relation in a file using serialization.
-
def
selectAt(pos: Seq[Int]): Relation
Select across all columns at the specified column positions.
-
def
selectC(cName: String, p: (Complex) ⇒ Boolean): Seq[Int]
Select the positions of elements from columns in 'cName' in 'this' relation that satisfy the predicate 'p'.
- def selectD(cName: String, p: (Double) ⇒ Boolean): Seq[Int]
- def selectI(cName: String, p: (Int) ⇒ Boolean): Seq[Int]
- def selectL(cName: String, p: (Long) ⇒ Boolean): Seq[Int]
- def selectQ(cName: String, p: (Rational) ⇒ Boolean): Seq[Int]
- def selectR(cName: String, p: (Real) ⇒ Boolean): Seq[Int]
- def selectS(cName: String, p: (StrNum) ⇒ Boolean): Seq[Int]
-
def
show(): Unit
Show 'this' relation row by row.
-
def
showFk(): Unit
Show 'this' relation's foreign keys.
-
def
sigma[T](cName: String, p: (T) ⇒ Boolean): Relation
Select elements from columns in 'cName' in 'this' relation that satisfy the predicate 'p'.
-
def
sigmaC(cName: String, p: (Complex) ⇒ Boolean): Relation
Select elements from columns in 'cName' in 'this' relation that satisfy the predicate 'p'.
- def sigmaD(cName: String, p: (Double) ⇒ Boolean): Relation
- def sigmaI(cName: String, p: (Int) ⇒ Boolean): Relation
- def sigmaL(cName: String, p: (Long) ⇒ Boolean): Relation
- def sigmaQ(cName: String, p: (Rational) ⇒ Boolean): Relation
- def sigmaR(cName: String, p: (Real) ⇒ Boolean): Relation
- def sigmaS(cName: String, p: (StrNum) ⇒ Boolean): Relation
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toMap(keyColName: Seq[String], valColName: String): Map[Seq[Any], Any]
Convert the given columns within 'this' relation to a map: 'keyColName' -> 'valColName'.
Convert the given columns within 'this' relation to a map: 'keyColName' -> 'valColName'.
- keyColName
the key column names
-
def
toMap(keyColPos: Seq[Int], valColPos: Int): Map[Seq[Any], Any]
Convert the given columns within 'this' relation to a map: 'keyColPos' -> 'valColPos'.
Convert the given columns within 'this' relation to a map: 'keyColPos' -> 'valColPos'.
- keyColPos
the key column positions
- valColPos
the value column positions
-
def
toMatriD(colPos: Seq[Int], kind: MatrixKind = DENSE): MatriD
Convert 'this' relation into a matrix of doubles, e.g.,
Convert 'this' relation into a matrix of doubles, e.g.,
in the regression equation: 'xb = y' create matrix 'xy'
- colPos
the column positions to use for the matrix
- kind
the kind of matrix to create
-
def
toMatriDD(colPos: Seq[Int], colPosV: Int, kind: MatrixKind = DENSE): (MatriD, VectorD)
Convert 'this' relation into a matrix of doubles and a vector of doubles.
Convert 'this' relation into a matrix of doubles and a vector of doubles.
in the regression equation: 'xb = y' create matrix 'x' and vector 'y'
- colPos
the column positions to use for the matrix
- colPosV
the column position to use for the vector
- kind
the kind of matrix to create
-
def
toMatriDI(colPos: Seq[Int], colPosV: Int, kind: MatrixKind = DENSE): (MatriD, VectorI)
Convert 'this' relation into a matrix of doubles and a vector of integers.
Convert 'this' relation into a matrix of doubles and a vector of integers.
in the regression equation: 'xb = y' create matrix 'x' and vector 'y'
- colPos
the column positions to use for the matrix
- colPosV
the column position to use for the vector
- kind
the kind of matrix to create
-
def
toMatriI(colPos: Seq[Int], kind: MatrixKind = DENSE): MatriI
Convert 'this' relation into a matrix of integers.
Convert 'this' relation into a matrix of integers.
in the regression equation: 'xb = y' create matrix 'xy'
- colPos
the column positions to use for the matrix
- kind
the kind of matrix to create
-
def
toMatriI2(colPos: Seq[Int] = null, kind: MatrixKind = DENSE): MatriI
Convert 'this' relation into a matrix of integers.
Convert 'this' relation into a matrix of integers. It will convert doubles and strings to integers.
in the regression equation: 'xb = y' create matrix 'xy'
- colPos
the column positions to use for the matrix
- kind
the kind of matrix to create
-
def
toMatriII(colPos: Seq[Int], colPosV: Int, kind: MatrixKind = DENSE): (MatriI, VectorI)
Convert 'this' relation into a matrix of integers and a vector of integers.
Convert 'this' relation into a matrix of integers and a vector of integers.
in the regression equation: 'xb = y' create matrix 'x' and vector 'y'
- colPos
the column positions to use for the matrix
- colPosV
the column position to use for the vector
- kind
the kind of matrix to create
-
def
toString(): String
Convert 'this' relation into a string column by column.
Convert 'this' relation into a string column by column.
- Definition Classes
- Relation → AnyRef → Any
-
def
toVectorD(colName: String): VectorD
Convert the 'colName' column of 'this' relation into a vector of doubles.
Convert the 'colName' column of 'this' relation into a vector of doubles.
- colName
the column name to use for the vector
-
def
toVectorD(colPos: Int): VectorD
Convert the 'colPos' column of 'this' relation into a vector of doubles.
Convert the 'colPos' column of 'this' relation into a vector of doubles.
- colPos
the column position to use for the vector
-
def
toVectorI(colName: String): VectorI
Convert the 'colName' column of 'this' relation into a vector of integers.
Convert the 'colName' column of 'this' relation into a vector of integers.
- colName
the column name to use for the vector
-
def
toVectorI(colPos: Int): VectorI
Convert the 'colPos' column of 'this' relation into a vector of integers.
Convert the 'colPos' column of 'this' relation into a vector of integers.
- colPos
the column position to use for the vector
-
def
toVectorS(colName: String): VectorS
Convert the 'colName' column of 'this' relation into a vector of integers.
Convert the 'colName' column of 'this' relation into a vector of integers.
- colName
the column name to use for the vector
-
def
toVectorS(colPos: Int): VectorS
Convert the 'colPos' column of 'this' relation into a vector of integers.
Convert the 'colPos' column of 'this' relation into a vector of integers.
- colPos
the column position to use for the vector
-
def
union(_r2: Table): Relation
Union 'this' relation and 'r2'.
-
def
uniq_union(cn1: Seq[String], cn2: Seq[String]): Seq[String]
Combine two sequences of column names, keeping all names from 'cn1' and only those in 'cn2' that are not repeats (i.e., not already in 'cn1').
Combine two sequences of column names, keeping all names from 'cn1' and only those in 'cn2' that are not repeats (i.e., not already in 'cn1').
- cn1
the first sequence of column names
- cn2
the second sequence of column names
- Definition Classes
- Table
-
def
update[T](cName: String, func: () ⇒ String, matchStr: String): 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'.
- cName
the name of the column to be updated
- func
the function used to assign updated values
- matchStr
the string to be matched to elements
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
def
writeCSV(fileName: String): Unit
Write 'this' relation into a CSV file with each row written to a line.
-
def
writeJSON(fileName: String): Unit
Write 'this' relation into a JSON file.
-
def
π(cName: String*): Relation
Project onto the columns with the given column names.
-
def
σ[T](cName: String, p: (T) ⇒ Boolean): Relation
Select elements from columns in 'cName' in 'this' relation that satisfy the predicate 'p'.
-
def
⋂(r2: Table): Relation
Intersect 'this' relation and 'r2'.
-
def
⋃(r2: Table): Relation
Union 'this' relation and 'r2'.
-
def
⋈(r2: Table): Relation
Join 'this' relation and 'r2 by performing a "natural-join".