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
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Relation
  2. Serializable
  3. Error
  4. Table
  5. Tabular
  6. AnyRef
  7. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new Relation(name: String, colName: Seq[String], col: Vector[Vec], key: Int = 0, domain: String = null, fKeys: Seq[(String, String, Int)] = null, enter: Boolean = true)

    name

    the name of the relation

    colName

    the names of columns

    col

    the Scala Vector of columns making up the columnar relation

    key

    the column number for the primary key (< 0 => no primary key)

    domain

    an optional string indicating domains for columns (e.g., 'SD' = 'StrNum', 'Double')

    fKeys

    an optional sequence of foreign keys - Seq (column name, ref table name, ref column position)

    enter

    whether to enter the newly created relation into the Catalog

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. 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
  4. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  5. 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
    RelationTable
    Annotations
    @throws( classOf [Exception] )
  6. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  7. 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

  8. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  9. var col: Vector[Vec]
  10. val colName: Seq[String]
  11. def colNames: Seq[String]

    Return the names of columns in the relation.

    Return the names of columns in the relation.

    Definition Classes
    RelationTable
  12. 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
    RelationTable
  13. 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
    RelationTable
  14. 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
    RelationTable
  15. def columns: Vector[Vec]

    Return all of the columns in the relation.

    Return all of the columns in the relation.

    Definition Classes
    RelationTable
  16. 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
    RelationTable
  17. 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
    RelationTable
  18. 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

  19. 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
    RelationTable
  20. 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
  21. val domain: String
  22. def domains: String

    Return the domains for the columns in the relation.

    Return the domains for the columns in the relation.

    Definition Classes
    RelationTable
  23. 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

  24. 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

  25. 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
    RelationTable
    See also

    en.wikipedia.org/wiki/Relational_algebra

  26. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  27. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  28. var fKeys: Seq[(String, String, Int)]
  29. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  30. final def flaw(method: String, message: String): Unit
    Definition Classes
    Error
  31. 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

  32. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  33. 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
    RelationTable
  34. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  35. 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
    RelationTable
  36. val index: Map[KeyType, Row]
    Attributes
    protected
  37. val indextoKey: HashMap[Int, KeyType]
    Attributes
    protected
  38. def indices: Range

    Return the range of index values for the table.

    Return the range of index values for the table.

    Definition Classes
    Table
  39. 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
    RelationTable
  40. 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

  41. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  42. 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
    RelationTable
  43. 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
    RelationTable
  44. def join(cName1: Seq[String], cName2: Seq[String], r2: Table): Relation

    Join 'this' relation and 'r2' by performing an "equi-join".

    Join 'this' relation and 'r2' by performing an "equi-join". Rows from both relations are compared requiring 'cName1' values to equal 'cName2' values. Disambiguate column names by appending "2" to the end of any duplicate column name. FIX - only allows single attribute in join condition

    cName1

    the join column names of this relation (e.g., the Foreign Key)

    cName2

    the join column names of relation r2 (e.g., the Primary Key)

    r2

    the rhs relation in the join operation

    Definition Classes
    RelationTable
  45. 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
  46. 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
  47. 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
  48. def joinindex(cName1: Seq[String], cName2: Seq[String], _r2: Table): Relation

    Join 'this' relation and 'r2' by performing an "equi-join", use index to join FIX - only allows single attribute in join condition

    Join 'this' relation and 'r2' by performing an "equi-join", use index to join FIX - only allows single attribute in join condition

    cName1

    the join column names of this relation (e.g., the Foreign Key)

    cName2

    the join column names of relation r2 (e.g., the Primary Key)

    _r2

    the rhs relation in the join operation

  49. val key: Int
  50. 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
    RelationTable
  51. 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

  52. 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
    RelationTable
  53. 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

  54. def max(cName: String): Any

    Return the maximum value in column 'cName'.

    Return the maximum value in column 'cName'.

    cName

    the column name

  55. def mean(cName: String): Any
  56. def min(cName: String): Any

    Return the minimum value in column 'cName'.

    Return the minimum value in column 'cName'.

    cName

    the column name

  57. 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
    RelationTable
  58. val name: String
  59. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  60. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  61. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  62. 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
    RelationTable
  63. var orderedIndex: Vector[KeyType]
    Attributes
    protected
  64. 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

  65. 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
  66. 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
  67. 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
    RelationTable
  68. def pisigmaD(cName: String, p: (Double) ⇒ Boolean): Relation
    Definition Classes
    RelationTable
  69. def pisigmaI(cName: String, p: (Int) ⇒ Boolean): Relation
    Definition Classes
    RelationTable
  70. def pisigmaL(cName: String, p: (Long) ⇒ Boolean): Relation
    Definition Classes
    RelationTable
  71. def pisigmaQ(cName: String, p: (Rational) ⇒ Boolean): Relation
    Definition Classes
    RelationTable
  72. def pisigmaR(cName: String, p: (Real) ⇒ Boolean): Relation
    Definition Classes
    RelationTable
  73. def pisigmaS(cName: String, p: (StrNum) ⇒ Boolean): Relation
    Definition Classes
    RelationTable
  74. 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
    RelationTable
  75. 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
    RelationTable
  76. 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
    RelationTable
  77. 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
    RelationTable
  78. 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
    RelationTable
  79. 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

  80. 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
  81. 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

  82. 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
    RelationTable
  83. 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] )
  84. 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
    RelationTable
  85. def save(): Unit

    Save 'this' relation in a file using serialization.

    Save 'this' relation in a file using serialization.

    Definition Classes
    RelationTable
  86. 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
    RelationTable
  87. 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
    RelationTable
  88. 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
    RelationTable
  89. def selectD(cName: String, p: (Double) ⇒ Boolean): Seq[Int]
    Definition Classes
    RelationTable
  90. def selectI(cName: String, p: (Int) ⇒ Boolean): Seq[Int]
    Definition Classes
    RelationTable
  91. def selectL(cName: String, p: (Long) ⇒ Boolean): Seq[Int]
    Definition Classes
    RelationTable
  92. def selectQ(cName: String, p: (Rational) ⇒ Boolean): Seq[Int]
    Definition Classes
    RelationTable
  93. def selectR(cName: String, p: (Real) ⇒ Boolean): Seq[Int]
    Definition Classes
    RelationTable
  94. def selectS(cName: String, p: (StrNum) ⇒ Boolean): Seq[Int]
    Definition Classes
    RelationTable
  95. def selectT(cName: String, p: (TimeNum) ⇒ Boolean): Seq[Int]
  96. 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
    RelationTabular
  97. def showFk(): Unit

    Show 'this' relation's foreign keys.

  98. 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
  99. 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
    RelationTable
  100. def sigmaD(cName: String, p: (Double) ⇒ Boolean): Relation
    Definition Classes
    RelationTable
  101. 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

  102. def sigmaI(cName: String, p: (Int) ⇒ Boolean): Relation
    Definition Classes
    RelationTable
  103. def sigmaL(cName: String, p: (Long) ⇒ Boolean): Relation
    Definition Classes
    RelationTable
  104. def sigmaQ(cName: String, p: (Rational) ⇒ Boolean): Relation
    Definition Classes
    RelationTable
  105. def sigmaR(cName: String, p: (Real) ⇒ Boolean): Relation
    Definition Classes
    RelationTable
  106. def sigmaS(cName: String, p: (StrNum) ⇒ Boolean): Relation
    Definition Classes
    RelationTable
  107. 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

  108. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  109. 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

  110. 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

  111. 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

  112. 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

  113. 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

  114. 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

  115. 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

  116. 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

  117. 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

  118. def toRleVectorD(colPos: Int): RleVectorD

    Convert the 'colPos' column of 'this' relation into a vector of doubles.

    Convert the 'colPos' column of 'this' relation into a vector of doubles.

    colPos

    the column position to use for the vector

  119. 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

  120. def toRleVectorI(colPos: Int): RleVectorI

    Convert the 'colPos' column of 'this' relation into a vector of integers.

    Convert the 'colPos' column of 'this' relation into a vector of integers.

    colPos

    the column position to use for the vector

  121. 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

  122. def toRleVectorS(colPos: Int): RleVectorS

    Convert the 'colPos' column of 'this' relation into a vector of integers.

    Convert the 'colPos' column of 'this' relation into a vector of integers.

    colPos

    the column position to use for the vector

  123. 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
  124. 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

  125. 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

  126. 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

  127. 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

  128. 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

  129. 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

  130. 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
    RelationTable
  131. 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
    RelationTable
  132. 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
  133. 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
    RelationTable
  134. 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
    RelationTable
  135. 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
    RelationTable
  136. 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

  137. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  138. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  139. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  140. 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
    RelationTable
  141. 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
    RelationTable
  142. 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
  143. 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

  144. 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
  145. 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
  146. 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
  147. 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
  148. 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
  149. 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
  150. 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
  151. 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
  152. 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
  153. 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
  154. 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
  155. 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
  156. 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
  157. 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
  158. 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
  159. 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
  160. 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
  161. 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
  162. 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 Serializable

Inherited from Error

Inherited from Table

Inherited from Tabular

Inherited from AnyRef

Inherited from Any

Ungrouped