scalation
API
Generated with
scalation/scalation/scalation.database

scalation.database

package scalation.database

Members list

Packages

package scalation.database.graph
package scalation.database.graph_pm
package scalation.database.graph_relation
package scalation.database.logic
package scalation.database.mugraph_pm
package scalation.database.relation
package scalation.database.table
package scalation.database.triplegraph

Type members

Classlikes

class BinTree[T](val elem: T)(implicit evidence$1: ClassTag[T])

Attributes

Supertypes
class Object
trait Matchable
class Any
object BpNode

The BpNode companion object provides settings for node sizes.

The BpNode companion object provides settings for node sizes.

Attributes

Companion
class
Supertypes
class Object
trait Matchable
class Any
Self type
BpNode.type
class BpNode(var keys: Int, val isLeaf: Boolean, DLINK: Boolean) extends Serializable

The BpNode class defines nodes of size order that that may be stored in a B+tree. Keys have type ValueType and may reference values of Any type.

The BpNode class defines nodes of size order that that may be stored in a B+tree. Keys have type ValueType and may reference values of Any type.

Value parameters

DLINK

whether the leaf nodes support linkage in both directions (ref(0) & pre)

isLeaf

whether this node is a leaf

keys

number of active keys

Attributes

Companion
object
Supertypes
trait Serializable
class Object
trait Matchable
class Any
class BpTreeMap[V]()(implicit evidence$1: ClassTag[V]) extends AbstractMap[ValueType, V], SortedMap[ValueType, V], Serializable

The BpTreeMap class provides sorted maps that use the B+Tree Data Structure. Inserts may cause the splitting of nodes, while deletes may cause borrowing if keys or merging of nodes.

The BpTreeMap class provides sorted maps that use the B+Tree Data Structure. Inserts may cause the splitting of nodes, while deletes may cause borrowing if keys or merging of nodes.

Type parameters

V

the type of the values assigned to keys in this sorted map

Attributes

Supertypes
trait Serializable
trait SortedMap[ValueType, V]
trait SortedMapOps[ValueType, V, SortedMap, SortedMap[ValueType, V]]
trait SortedMap[ValueType, V]
trait SortedMapFactoryDefaults[ValueType, V, SortedMap, Iterable, Map]
trait SortedMapOps[ValueType, V, SortedMap, SortedMap[ValueType, V]]
trait SortedOps[ValueType, SortedMap[ValueType, V]]
class AbstractMap[ValueType, V]
trait Map[ValueType, V]
trait MapOps[ValueType, V, Map, SortedMap[ValueType, V]]
trait Shrinkable[ValueType]
trait Builder[(ValueType, V), SortedMap[ValueType, V]]
trait Growable[(ValueType, V)]
trait Clearable
trait Cloneable[SortedMap[ValueType, V]]
trait Cloneable
trait Iterable[(ValueType, V)]
class AbstractMap[ValueType, V]
trait Map[ValueType, V]
trait Equals
trait MapFactoryDefaults[ValueType, V, Map, Iterable]
trait MapOps[ValueType, V, Map, SortedMap[ValueType, V]]
trait PartialFunction[ValueType, V]
trait ValueType => V
class AbstractIterable[(ValueType, V)]
trait Iterable[(ValueType, V)]
trait IterableFactoryDefaults[(ValueType, V), Iterable]
trait IterableOps[(ValueType, V), Iterable, SortedMap[ValueType, V]]
trait IterableOnceOps[(ValueType, V), Iterable, SortedMap[ValueType, V]]
trait IterableOnce[(ValueType, V)]
class Object
trait Matchable
class Any
Show all
case class FD(x: Attrs, y: Attrs)

The FD case class is used to represent a Functional Dependency (x -> y).

The FD case class is used to represent a Functional Dependency (x -> y).

Value parameters

x

the Left-Hand Side (LHS) attributes of the FD

y

the Right-Hand Side (RHS) attributes of the FD

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
class HashMultiMap[K, V](initialCap: Int, loadFactor: Double)(implicit evidence$1: ClassTag[K], evidence$2: ClassTag[V]) extends Serializable

The HashMultiMap class provides hash maps that use the Separate Chaining algorithm. It build on HashMap allowing values to multi-valued Set [V] and can be used for building Non-Unique Indices.

The HashMultiMap class provides hash maps that use the Separate Chaining algorithm. It build on HashMap allowing values to multi-valued Set [V] and can be used for building Non-Unique Indices.

Type parameters

K

the type of the keys contained in this hash map

V

the base-type of the values assigned to keys in this hash map

Value parameters

initialCap

the initial hash table size (number of slots)

loadFactor

the load factor (number of keys over number of slots)

Attributes

See also

scala.collection.mutable.HashMap

Supertypes
trait Serializable
class Object
trait Matchable
class Any
trait Identifiable(_name: String, val id: Int)

The Identifiable trait provides unique identification for objects.

The Identifiable trait provides unique identification for objects.

Value parameters

_name

the name of the object

id

the globally unique integer identifier (may use auto-gen)

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
class Edge
class Link
class Transport
class EdgeType
class Vertex
class Junction
class Resource
class Sink
class WaitQueue
class VertexType
class Model
class BankModel
class SimAgent
class Customer
class Reporter
class Call
class Car
class Car
class Bus
class Gate
class Source
Show all
object Identifiable

The Identifiable object is used to generate unique identifiers.

The Identifiable object is used to generate unique identifiers.

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
class JHashMap[K, V](initialCap: Int, loadFactor: Float)(implicit evidence$1: ClassTag[K], evidence$2: ClassTag[V]) extends Serializable

The JHashMap class provides hash maps that use the Separate Chaining algorithm with several optimizations. It uses on Java's HashMap and can be used for building Unique Indices.

The JHashMap class provides hash maps that use the Separate Chaining algorithm with several optimizations. It uses on Java's HashMap and can be used for building Unique Indices.

Type parameters

K

the type of the keys contained in this hash map

V

the base-type of the values assigned to keys in this hash map

Value parameters

initialCap

the initial hash table size (number of slots)

loadFactor

the load factor (number of keys over number of slots)

Attributes

See also

java.util.HashMap

Supertypes
trait Serializable
class Object
trait Matchable
class Any
class JHashMultiMap[K, V](initialCap: Int, loadFactor: Float)(implicit evidence$1: ClassTag[K], evidence$2: ClassTag[V]) extends Serializable

The JHashMultiMap class provides hash maps that use the Separate Chaining algorithm with several optimizations. It build on Java's HashMap allowing values to multi-valued Set [V] and can be used for building Non-Unique Indices.

The JHashMultiMap class provides hash maps that use the Separate Chaining algorithm with several optimizations. It build on Java's HashMap allowing values to multi-valued Set [V] and can be used for building Non-Unique Indices.

Type parameters

K

the type of the keys contained in this hash map

V

the base-type of the values assigned to keys in this hash map

Value parameters

initialCap

the initial hash table size (number of slots)

loadFactor

the load factor (number of keys over number of slots)

Attributes

See also

java.util.HashMap

Supertypes
trait Serializable
class Object
trait Matchable
class Any
class JTreeMap[K, V](implicit evidence$1: ClassTag[K], evidence$2: ClassTag[V], val ord: Ordering[K]) extends Serializable

The TreeMMap class provides tree maps that use the Red-Black Tree algorithm. It uses on Java's TreeMap and can be used for building Unique Indices.

The TreeMMap class provides tree maps that use the Red-Black Tree algorithm. It uses on Java's TreeMap and can be used for building Unique Indices.

Type parameters

K

the type of the keys contained in this tree map

V

the base-type of the values assigned to keys in this tree map

Value parameters

ord

the implicit ordering used to compare objects of type K

Attributes

See also

java.util.TreeMap

Supertypes
trait Serializable
class Object
trait Matchable
class Any
class JTreeMultiMap[K, V](implicit evidence$1: ClassTag[K], evidence$2: ClassTag[V], val ord: Ordering[K]) extends Serializable

The TreeMultiMap class provides tree maps that use the Red-Black Tree algorithm. It build on Java's TreeMap allowing values to multi-valued Set [V] and can be used for building Non-Unique Indices.

The TreeMultiMap class provides tree maps that use the Red-Black Tree algorithm. It build on Java's TreeMap allowing values to multi-valued Set [V] and can be used for building Non-Unique Indices.

Type parameters

K

the type of the keys contained in this tree map

V

the base-type of the values assigned to keys in this tree map

Value parameters

ord

the implicit ordering used to compare objects of type K

Attributes

See also

java.util.TreeMap

Supertypes
trait Serializable
class Object
trait Matchable
class Any
case class KeyType(key: ArrayBuffer[ValueType])

The KeyType class provides a key type for handling both non-composite and composite keys. A key is a minimal set of attributes that can be used to uniquely identify a tuple.

The KeyType class provides a key type for handling both non-composite and composite keys. A key is a minimal set of attributes that can be used to uniquely identify a tuple.

Value parameters

key

the key values stored in an array buffer

Attributes

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object KeyType

The KeyType companion object provides Ordering for KeyType via the compare method. Create a given instance for use as an implicit parameter.

The KeyType companion object provides Ordering for KeyType via the compare method. Create a given instance for use as an implicit parameter.

Attributes

Companion
class
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
KeyType.type
class LinHashMap[K, V](order: Int, loadFac: (Double, Double))(implicit evidence$1: ClassTag[K], evidence$2: ClassTag[V]) extends AbstractMap[K, V], Serializable

The LinHashMap class provides hash maps that use the Linear Hashing algorithm. A hash table is created that is an expandable array-list (ArrayBuffer) of buckets. Inserts may cause the allocation of overflow buckets as well as the splitting of home buckets. Uses the SRI rule: Split, Rehash, and then Insert.

The LinHashMap class provides hash maps that use the Linear Hashing algorithm. A hash table is created that is an expandable array-list (ArrayBuffer) of buckets. Inserts may cause the allocation of overflow buckets as well as the splitting of home buckets. Uses the SRI rule: Split, Rehash, and then Insert.

Type parameters

K

the type of the keys contained in this hash map

V

the type of the values assigned to keys in this hash map

Value parameters

loadFac

the (lower, upper) bound on the load factor (# keys over # home slots)

order

the number of slots per bucket

Attributes

Supertypes
trait Serializable
class AbstractMap[K, V]
trait Map[K, V]
trait MapOps[K, V, Map, Map[K, V]]
trait Shrinkable[K]
trait Builder[(K, V), Map[K, V]]
trait Growable[(K, V)]
trait Clearable
trait Cloneable[Map[K, V]]
trait Cloneable
trait Iterable[(K, V)]
class AbstractMap[K, V]
trait Map[K, V]
trait Equals
trait MapFactoryDefaults[K, V, Map, Iterable]
trait MapOps[K, V, Map, Map[K, V]]
trait PartialFunction[K, V]
trait K => V
class AbstractIterable[(K, V)]
trait Iterable[(K, V)]
trait IterableFactoryDefaults[(K, V), Iterable]
trait IterableOps[(K, V), Iterable, Map[K, V]]
trait IterableOnceOps[(K, V), Iterable, Map[K, V]]
trait IterableOnce[(K, V)]
class Object
trait Matchable
class Any
Show all
Known subtypes
class LinHashMultiMap[K, V]
class LinHashMultiMap[K, V](order: Int, loadFactor: (Double, Double))(implicit evidence$1: ClassTag[K], evidence$2: ClassTag[V]) extends LinHashMap[K, Set[V]]

The LinHashMultiMap class provides hash maps that use the Linear Hashing algorithm. It build on LinHashMap allowing values to multi-valued Set [V] and can be used for building Non-Unique Indices.

The LinHashMultiMap class provides hash maps that use the Linear Hashing algorithm. It build on LinHashMap allowing values to multi-valued Set [V] and can be used for building Non-Unique Indices.

Type parameters

K

the type of the keys contained in this hash map

V

the base-type of the values assigned to keys in this hash map

Value parameters

loadFactor

the (lower, upper) bound on the load factor (# keys over # home slots)

order

the number of slots per bucket

Attributes

See also

scalation.database.LinHashMap

Supertypes
class LinHashMap[K, Set[V]]
trait Serializable
class AbstractMap[K, Set[V]]
trait Map[K, Set[V]]
trait MapOps[K, Set[V], Map, Map[K, Set[V]]]
trait Shrinkable[K]
trait Builder[(K, Set[V]), Map[K, Set[V]]]
trait Growable[(K, Set[V])]
trait Clearable
trait Cloneable[Map[K, Set[V]]]
trait Cloneable
trait Iterable[(K, Set[V])]
class AbstractMap[K, Set[V]]
trait Map[K, Set[V]]
trait Equals
trait MapFactoryDefaults[K, Set[V], Map, Iterable]
trait MapOps[K, Set[V], Map, Map[K, Set[V]]]
trait PartialFunction[K, Set[V]]
trait K => Set[V]
class AbstractIterable[(K, Set[V])]
trait Iterable[(K, Set[V])]
trait IterableFactoryDefaults[(K, Set[V]), Iterable]
trait IterableOps[(K, Set[V]), Iterable, Map[K, Set[V]]]
trait IterableOnceOps[(K, Set[V]), Iterable, Map[K, Set[V]]]
trait IterableOnce[(K, Set[V])]
class Object
trait Matchable
class Any
Show all
object MakeSchema

The MakeSchema object provides helper methods for making database schema. It attempts to infers the domain (data-type) for a column of data, e.g., from a csv file or database table. The domain for a column is inferred by examining the data elements in a sample from its vector (VectorS).

The MakeSchema object provides helper methods for making database schema. It attempts to infers the domain (data-type) for a column of data, e.g., from a csv file or database table. The domain for a column is inferred by examining the data elements in a sample from its vector (VectorS).

Attributes

See also

makeSchemaTest2 for an example of making a schema for a datafile.

Supertypes
class Object
trait Matchable
class Any
Self type
MakeSchema.type
object MaxSpanningTree

The MaxSpanningTree object provides factory methods for building Maximum Spanning Trees. The adjacent matrix's edge weights are negated to produce maximum.

The MaxSpanningTree object provides factory methods for building Maximum Spanning Trees. The adjacent matrix's edge weights are negated to produce maximum.

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
class MinSpanningTree(g: Graph, undirected: Boolean)

The MinSpanningTree class is used to build minimum cost spanning trees from graphs. Edge cost/weights are given by edge labels. MinSpanningTree implements Prim's algorithm. scalation.PriorityQueue ScalaTion's extension adds increaseKey, printInOrder

The MinSpanningTree class is used to build minimum cost spanning trees from graphs. Edge cost/weights are given by edge labels. MinSpanningTree implements Prim's algorithm. scalation.PriorityQueue ScalaTion's extension adds increaseKey, printInOrder

Value parameters

g

the digraph to build the spanning tree from

undirected

whether the graph is already undirected

Attributes

See also
Companion
object
Supertypes
class Object
trait Matchable
class Any
object MinSpanningTree

The MinSpanningTree companion object provides factory methods for building Minimum Spanning Trees.

The MinSpanningTree companion object provides factory methods for building Minimum Spanning Trees.

Attributes

Companion
class
Supertypes
class Object
trait Matchable
class Any
Self type
class Normalization(r: Attrs, fd: ArrayBuffer[FD])

The Normalization class provides methods useful in normalization theory that can be used to assist in designing relational databases. These include Closure, Superkey, Key, Losslessness, Dependency Preservation, BCNF Decomposition, Minimal Cover, and 3NF Synthesis.

The Normalization class provides methods useful in normalization theory that can be used to assist in designing relational databases. These include Closure, Superkey, Key, Losslessness, Dependency Preservation, BCNF Decomposition, Minimal Cover, and 3NF Synthesis.

Value parameters

fd

the given collection of Functional Dependencies (FDs)

r

the schema or complete set of attributes R

Attributes

See also

scalation.SetExt, scalation.database.BinTree`

Supertypes
class Object
trait Matchable
class Any
class SpanningTree(g: MatrixD)

The SpanningTree class is used to build spanning trees from graphs.

The SpanningTree class is used to build spanning trees from graphs.

Value parameters

g

the digraph (adjacency matrix) to build the spanning tree from

Attributes

Supertypes
class Object
trait Matchable
class Any
trait Spatial(val pos: VectorD) extends PartiallyOrdered[Spatial]

The Spatial trait provides spatial coordinates that are spatially partially ordered.

The Spatial trait provides spatial coordinates that are spatially partially ordered.

Value parameters

pos

the spatial Euclidean coordinate vector for the spatial object

Attributes

Supertypes
trait PartiallyOrdered[Spatial]
class Object
trait Matchable
class Any
Known subtypes
class Edge
class Link
class Transport
class Vertex
class Junction
class Resource
class Sink
class WaitQueue
class SimAgent
class Customer
class Reporter
class Call
class Car
class Car
class Bus
class Gate
class Source
Show all
object TNode

The TNode object defines an indent function and flag indicating whether to indent.

The TNode object defines an indent function and flag indicating whether to indent.

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
TNode.type
trait TNode

The TNode trait allows a hierarchy/tree structure to be created for any types that extend it, e.g., may be used to create a type hierarchy that follows single inheritence producing a multi-way tree.

The TNode trait allows a hierarchy/tree structure to be created for any types that extend it, e.g., may be used to create a type hierarchy that follows single inheritence producing a multi-way tree.

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
class KGTable
trait Tabular[T <: Tabular[T]](val name: String, val schema: Schema, val domain: Domain, val key: Schema) extends Serializable

The Tabular trait defines relational algebra operators. Supported domains/data-types are 'D'ouble, 'I'nt, 'L'ong, 'S'tring, and 'T'imeNum. 'D' - Double - VectorD - 64 bit double precision floating point number 'I' - Int - VectorI - 32 bit integer 'L' - Long - VectorL - 64 bit long integer 'S' - String - VectorS - variable length numeric string 'X' - String - VectorS - variable length numeric string (for 2x column width) 'T' - TimeNum - VectorT - time numbers for date-time Note: Uses F-Bounded Polymorphism so extending classes don't need to cast

The Tabular trait defines relational algebra operators. Supported domains/data-types are 'D'ouble, 'I'nt, 'L'ong, 'S'tring, and 'T'imeNum. 'D' - Double - VectorD - 64 bit double precision floating point number 'I' - Int - VectorI - 32 bit integer 'L' - Long - VectorL - 64 bit long integer 'S' - String - VectorS - variable length numeric string 'X' - String - VectorS - variable length numeric string (for 2x column width) 'T' - TimeNum - VectorT - time numbers for date-time Note: Uses F-Bounded Polymorphism so extending classes don't need to cast

Value parameters

domain

the domains/data-types for the attributes ('D', 'I', 'L', 'S', 'X', 'T')

key

the attributes forming the primary key

name

the name of the table

schema

the attributes for the table

Attributes

Companion
object
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Known subtypes
class Relation
class Table
class GTable
class KGTable
class LTable
class VTable
Show all
object Tabular

The Tabular companion object provides methods supporting prefix forms for unary relational algebra operators. Example: prefix form vs. postfix form.

The Tabular companion object provides methods supporting prefix forms for unary relational algebra operators. Example: prefix form vs. postfix form.

π("cname, ccity")(σ("balance < amount")(customer ⋈ deposit ⋈ loan))

(customer ⋈ deposit ⋈ loan).σ("balance < amount").π("cname, ccity")

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
Tabular.type
trait Temporal(var time: Double) extends Ordered[Temporal]

The Temporal trait provides time coordinates that are temporally ordered.

The Temporal trait provides time coordinates that are temporally ordered.

Value parameters

time

the time coordinate for the temporal object

Attributes

See also

scalation.TimeNum

Supertypes
trait Ordered[Temporal]
trait Comparable[Temporal]
class Object
trait Matchable
class Any
Known subtypes
class SimAgent
class Customer
class Reporter
class Call
class Car
class Car
class Bus
class Gate
class Source
Show all
object TimeInterval

The TimeInterval companion object provides factory functions for creating time-intervals.

The TimeInterval companion object provides factory functions for creating time-intervals.

Attributes

Companion
class
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
case class TimeInterval(t1: TimeNum, t2: TimeNum)

The TimeIntervalclass implements Allen's Interval Algebra (first 13). Basic: equals Main: before, meets, overlaps, during, starts, finishes Converse: after, metBy, overlapBy, contains, startBy, finishBy Merge: merge, mergeGap, conflict

The TimeIntervalclass implements Allen's Interval Algebra (first 13). Basic: equals Main: before, meets, overlaps, during, starts, finishes Converse: after, metBy, overlapBy, contains, startBy, finishBy Merge: merge, mergeGap, conflict

Value parameters

t1

the time of the start of the interval (inclusive)

t2

the time of the end of the interval (inclusive)

Attributes

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object TimeOfWeek

The TimeOfWeek companion object provide factory functions for creating instances of TimeOfWeek.

The TimeOfWeek companion object provide factory functions for creating instances of TimeOfWeek.

Attributes

Companion
class
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
TimeOfWeek.type
case class TimeOfWeek(day: Int, second: Long)

The TimeOfWeek class keeps track relative date-time within a week, e.g., for a weekly schedule.

The TimeOfWeek class keeps track relative date-time within a week, e.g., for a weekly schedule.

Value parameters

day

the day of the week (Mon -> 1, ... Sun -> 7)

time

the time of day in seconds (0 to 86399)

Attributes

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object Tree

The Tree companion object provides methods for building trees.

The Tree companion object provides methods for building trees.

Attributes

Companion
class
Supertypes
class Object
trait Matchable
class Any
Self type
Tree.type
class Tree(val root: TreeNode, depth: Int, val name: String)

The Tree class provides a data structure for multi-way trees.

The Tree class provides a data structure for multi-way trees.

Value parameters

depth

the estimated average depth of the tree

name

the name of the tree

root

the root node of the tree

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
class TreeMultiMap[K, V](implicit evidence$1: ClassTag[K], evidence$2: ClassTag[V], val ord: Ordering[K]) extends Serializable

The TreeMultiMap class provides tree maps that use the Red-Black Tree algorithm. It build on TreeMap allowing values to multi-valued Set [V] and can be used for building Non-Unique Indices.

The TreeMultiMap class provides tree maps that use the Red-Black Tree algorithm. It build on TreeMap allowing values to multi-valued Set [V] and can be used for building Non-Unique Indices.

Type parameters

K

the type of the keys contained in this tree map

V

the base-type of the values assigned to keys in this tree map

Value parameters

ord

the implicit ordering used to compare objects of type K

Attributes

See also

scala.collection.mutable.TreeMap

Supertypes
trait Serializable
class Object
trait Matchable
class Any
class TreeNode(val nid: Int, val lev: Int, var label: ValueType, var ord: Int)

The TreeNode class is for a node in a tree.

The TreeNode class is for a node in a tree.

Value parameters

label

the node/incoming edge label

lev

the level of the node in the tree

nid

the unique identifier for the node

ord

the birth order

Attributes

Supertypes
class Object
trait Matchable
class Any
final class bpNodeTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class bpNodeTest2

Attributes

Supertypes
class Object
trait Matchable
class Any
final class bpNodeTest3

Attributes

Supertypes
class Object
trait Matchable
class Any
final class bpTreeMapTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class bpTreeMapTest2

Attributes

Supertypes
class Object
trait Matchable
class Any
final class bpTreeMapTest3

Attributes

Supertypes
class Object
trait Matchable
class Any
final class bpTreeMapTest4

Attributes

Supertypes
class Object
trait Matchable
class Any
final class javaMapTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class linHashMapTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class makeSchemaTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class makeSchemaTest2

Attributes

Supertypes
class Object
trait Matchable
class Any
final class minSpanningTreeTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class minSpanningTreeTest2

Attributes

Supertypes
class Object
trait Matchable
class Any
final class minSpanningTreeTest3

Attributes

Supertypes
class Object
trait Matchable
class Any
final class minSpanningTreeTest4

Attributes

Supertypes
class Object
trait Matchable
class Any
final class multiMapTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class normalizationTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class normalizationTest2

Attributes

Supertypes
class Object
trait Matchable
class Any
final class normalizationTest3

Attributes

Supertypes
class Object
trait Matchable
class Any
final class normalizationTest4

Attributes

Supertypes
class Object
trait Matchable
class Any
final class normalizationTest5

Attributes

Supertypes
class Object
trait Matchable
class Any
final class normalizationTest6

Attributes

Supertypes
class Object
trait Matchable
class Any
final class normalizationTest7

Attributes

Supertypes
class Object
trait Matchable
class Any
final class normalizationTest8

Attributes

Supertypes
class Object
trait Matchable
class Any
final class spanningTreeTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class tNodeTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class timeIntervalTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class timeIntervalTest2

Attributes

Supertypes
class Object
trait Matchable
class Any
final class timeIntervalTest3

Attributes

Supertypes
class Object
trait Matchable
class Any
final class timeOfWeekTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class treeTest

Attributes

Supertypes
class Object
trait Matchable
class Any
final class treeTest2

Attributes

Supertypes
class Object
trait Matchable
class Any
final class treeTest3

Attributes

Supertypes
class Object
trait Matchable
class Any

Types

type APredicate = ValueType => Boolean
type APredicate2 = (String, String, (ValueType, ValueType) => Boolean)
type AggFunction = (Array[ValueType]) => ValueType
type Attrs = SortedSet[Char]
type Domain = Array[Char]
type Pair = (Int, Int)
type Predicate = Tuple => Boolean
type Predicate2 = (Tuple, Tuple) => Boolean
type Row = Vector[ValueType]
type Schema = Array[String]

Type definitions for components of the relational model.

Type definitions for components of the relational model.

Attributes

See also

ValueType in scalation package

type Tuple = Array[ValueType]

Value members

Concrete methods

def !=(x: ValueType, y: ValueType): Boolean
def <(x: ValueType, y: ValueType): Boolean
def <=(x: ValueType, y: ValueType): Boolean
def ==(x: ValueType, y: ValueType): Boolean

Definitions of comparison operators for ValueType.

Definitions of comparison operators for ValueType.

Attributes

def >(x: ValueType, y: ValueType): Boolean
def >=(x: ValueType, y: ValueType): Boolean
def bpNodeTest(): Unit

The bpNodeTest main function tests the BpNode class by inserting random key values and testing a leaf node split.

The bpNodeTest main function tests the BpNode class by inserting random key values and testing a leaf node split.

runMain scalation.database.bpNodeTest

Attributes

def bpNodeTest2(): Unit

The bpNodeTest2 main function tests the BpNode class by inserting random key values and testing a internal node split.

The bpNodeTest2 main function tests the BpNode class by inserting random key values and testing a internal node split.

runMain scalation.database.bpNodeTest2

Attributes

def bpNodeTest3(): Unit

The bpNodeTest3 main function tests the BpNode class by inserting random and removing key values.

The bpNodeTest3 main function tests the BpNode class by inserting random and removing key values.

runMain scalation.database.bpNodeTest3

Attributes

def bpTreeMapTest(): Unit

The bpTreeMapTest main function used for testing the BpTreeMap class by inserting increasing key values.

The bpTreeMapTest main function used for testing the BpTreeMap class by inserting increasing key values.

runMain scalation.database.bpTreeMapTest

Attributes

def bpTreeMapTest2(): Unit

The bpTreeMapTest2 main function used for testing the BpTreeMap class by inserting random key values.

The bpTreeMapTest2 main function used for testing the BpTreeMap class by inserting random key values.

runMain scalation.database.bpTreeMapTest2

Attributes

def bpTreeMapTest3(): Unit

The bpTreeMapTest3 main function used for testing the BpTreeMap class by inserting keys and values into B+Trees, one representing each of two lanes.

The bpTreeMapTest3 main function used for testing the BpTreeMap class by inserting keys and values into B+Trees, one representing each of two lanes.

runMain scalation.database.bpTreeMapTest3

Attributes

def bpTreeMapTest4(): Unit

The bpTreeMapTest4 main function used for testing the BpTreeMap class by inserting keys and values into B+Trees, one representing each of two lanes.

The bpTreeMapTest4 main function used for testing the BpTreeMap class by inserting keys and values into B+Trees, one representing each of two lanes.

runMain scalation.database.bpTreeMapTest4

Attributes

def disambiguate(sch1: Schema, sch2: Schema): Schema

Combine two schemas and disambiguate any repeated names by appending "2".

Combine two schemas and disambiguate any repeated names by appending "2".

Value parameters

sch1

the first schema

sch2

the second schema

Attributes

def equ(x: ValueType, y: ValueType): Boolean
def javaMapTest(): Unit

The javaMapTest main function used for testing the Java-Map classes.

The javaMapTest main function used for testing the Java-Map classes.

runMain scalation.database.javaMapTest

Attributes

def linHashMapTest(): Unit

The linHashMapTest main function used for testing the LinHashMap class.

The linHashMapTest main function used for testing the LinHashMap class.

runMain scalation.database.linHashMapTest

Attributes

def makeSchemaTest(): Unit

The makeSchemaTest main function tests the MakeSchema object on several columns of data.

The makeSchemaTest main function tests the MakeSchema object on several columns of data.

runMain scalation.database.makeSchemaTest

Attributes

def makeSchemaTest2(): Unit

The makeSchemaTest2 main function tests the MakeSchema object on several rows of data from a datafile with the goal of making a database derived from Tabular

The makeSchemaTest2 main function tests the MakeSchema object on several rows of data from a datafile with the goal of making a database derived from Tabular

Value parameters

domain

the domains/data-types for the attributes ('D', 'I', 'L', 'S', 'X', 'T')

key

the attributes forming the primary key trait Tabular [T <: Tabular [T]] (val name: String, val schema: Schema, val domain: Domain, val key: Schema)

runMain scalation.database.makeSchemaTest2

name

the name of the table

schema

the attributes for the table

Attributes

See also

github.com/scalation/data/blob/master/traffic/d04_text_station_5min_2022_10_04.csv#L7

Tabular, and table.Table

inline def meet(x: Schema, y: Schema): Schema

Efficient alternative to Scala's 'intersect' method.

Efficient alternative to Scala's 'intersect' method.

Value parameters

x

the first schema (array/set of attributes)

y

the schema schema (array/set of attributes)

Attributes

See also

StrictOptimizedSeqOps

def minSpanningTreeTest: Unit

The minSpanningTreeTest main function tests the MinSpanningTree class.

The minSpanningTreeTest main function tests the MinSpanningTree class.

Attributes

See also

www.cse.ust.hk/~dekai/271/notes/L07/L07.pdf

runMain scalation.database.minSpanningTreeTest

def minSpanningTreeTest2(): Unit

The minSpanningTreeTest2 main function tests the MinSpanningTree class. This test the Maximum Spanning Tree option.

The minSpanningTreeTest2 main function tests the MinSpanningTree class. This test the Maximum Spanning Tree option.

Attributes

See also

www.cse.ust.hk/~dekai/271/notes/L07/L07.pdf

runMain scalation.database.minSpanningTreeTest2

def minSpanningTreeTest3(): Unit

The minSpanningTreeTest3 main function tests the MinSpanningTree class by building a graph from an adjacency matrix called cmi for Conditional Mutual Information and creating a minimum spanning tree from it.

The minSpanningTreeTest3 main function tests the MinSpanningTree class by building a graph from an adjacency matrix called cmi for Conditional Mutual Information and creating a minimum spanning tree from it.

Attributes

See also

scalation.modeling.classifying.BayesClassifier

runMain scalation.database.minSpanningTreeTest3

def minSpanningTreeTest4(): Unit

The minSpanningTreeTest4 main function tests the MinSpanningTree class by building a graph from an adjacency matrix called cmi for Conditional Mutual Information and creating a maximum spanning tree from it.

The minSpanningTreeTest4 main function tests the MinSpanningTree class by building a graph from an adjacency matrix called cmi for Conditional Mutual Information and creating a maximum spanning tree from it.

Attributes

See also

scalation.modeling.classifying.BayesClassifier

runMain scalation.database.minSpanningTreeTest4

def multiMapTest(): Unit

The multiMapTest main function used for testing the Multi-Map classes.

The multiMapTest main function used for testing the Multi-Map classes.

runMain scalation.database.multiMapTest

Attributes

def ne(x: ValueType, y: ValueType): Boolean
def neq(x: ValueType, y: ValueType): Boolean
def normalizationTest(): Unit

The normalizationTest main method tests the Normalization class. For this example all FD are preserved.

The normalizationTest main method tests the Normalization class. For this example all FD are preserved.

runMain scalation.database.normalizationTest

Attributes

def normalizationTest2(): Unit

The normalizationTest2 main method tests the Normalization class. For this example some FDs may not be preserved.

The normalizationTest2 main method tests the Normalization class. For this example some FDs may not be preserved.

fd = sid -> sname address phone A -> BCD cid -> cname desc hours pid E -> FGHI pid -> pname rank I -> JK sid cid -> grade AE -> L

Comment out line (1) => success Comment out line (2) => Dependency Preservation fails Comment out lines (1 and 2) => Losslessness and Dependency Preservation fail

runMain scalation.database.normalizationTest2

Attributes

def normalizationTest3(): Unit

The normalizationTest3 main method tests the Normalization class. This example tests the BCNF Decomposition Algorithm and 3NF Synthesis Algorithm. U = Course, Teacher, Student, Grade, Hour, Room

The normalizationTest3 main method tests the Normalization class. This example tests the BCNF Decomposition Algorithm and 3NF Synthesis Algorithm. U = Course, Teacher, Student, Grade, Hour, Room

fd = C -> T CS -> G HR -> C HS -> R HT -> R

runMain scalation.database.normalizationTest3

Attributes

def normalizationTest4(): Unit

The normalizationTest4 main method tests the Normalization class. This example tests the 3NF Synthesis Algorithm.

The normalizationTest4 main method tests the Normalization class. This example tests the 3NF Synthesis Algorithm.

fd = C -> ST Cname -> Street cciTy A -> BCN Accno -> Bname Cname balaNce B -> EY Bname -> assEts bcitY L -> BCM Loanno -> Bname Cname aMount

runMain scalation.database.normalizationTest4

Attributes

def normalizationTest5(): Unit

The normalizationTest5 main method tests the Normalization class. This example tests the Minimal Cover Algorithm.

The normalizationTest5 main method tests the Normalization class. This example tests the Minimal Cover Algorithm.

fd = C -> ST Cname -> Street cciTy A -> BCN Accno -> Bname Cname balaNce B -> EY Bname -> assEts bcitY L -> BCM Loanno -> bname cname aMount

runMain scalation.database.normalizationTest5

Attributes

def normalizationTest6(): Unit

The normalizationTest6 main method tests the Normalization class. This example tests the Dependency Preservation of db design p.

The normalizationTest6 main method tests the Normalization class. This example tests the Dependency Preservation of db design p.

fd = A -> B B -> C C -> D D -> A p = { AB, BC, CD }

runMain scalation.database.normalizationTest6

Attributes

def normalizationTest7(): Unit

The normalizationTest7 main method tests the Normalization class. This example tests the Dependency Preservation of db design p. Compare with Test6.

The normalizationTest7 main method tests the Normalization class. This example tests the Dependency Preservation of db design p. Compare with Test6.

fd = A -> B // same FD as Test6 B -> C // same FD as Test6 D -> C // LHS & RHS swapped for this FD A -> D // LHS & RHS swapped for this FD p = { AB, BC, CD }

runMain scalation.database.normalizationTest7

Attributes

def normalizationTest8(): Unit

The normalizationTest8 main method tests the Normalization class. This example tests the findKey method (see Example 2 from FindKey paper).

The normalizationTest8 main method tests the Normalization class. This example tests the findKey method (see Example 2 from FindKey paper).

fd = AD -> B AB -> E C -> D B -> C AC -> F

runMain scalation.database.normalizationTest8

Attributes

def parseCond(condition: String): (Array[String], Boolean)

Split a condition string into three tokens: "atr op value". e.g., "cname == 'John Doe'", "accno == 123", "balance > 1000.00", "cname == cname"

Split a condition string into three tokens: "atr op value". e.g., "cname == 'John Doe'", "accno == 123", "balance > 1000.00", "cname == cname"

Value parameters

condition

the simple condition string to parse

Attributes

def spanningTreeTest(): Unit

The spanningTreeTest object is used to test the SpanningTree class.

The spanningTreeTest object is used to test the SpanningTree class.

Attributes

See also

scalation.modeling.classifying.BayesClassifier

runMain scalation.database.spanningTreeTest

def strim(str: String, sep: Char): Array[String]

Split and trim the comma-separated names contained in the given string str.

Split and trim the comma-separated names contained in the given string str.

Value parameters

sep

the separation character

str

the string to split and trim

Attributes

inline def subset(x: Schema, y: Schema): Boolean

Return whether schema x is a subset-of schema y.

Return whether schema x is a subset-of schema y.

Value parameters

x

the first schema (array/set of attributes)

y

the schema schema (array/set of attributes)

Attributes

def tNodeTest(): Unit

The tNodeTest main function is used to test TNode.

The tNodeTest main function is used to test TNode.

runMain scalation.database.nodeTest

Attributes

def timeIntervalTest(): Unit

The timeIntervalTest main function is used to test the TimeInterval class. Tests the Basic and Main operators: Basic: equal Main: before, meets, overlaps, starts, during, finishes

The timeIntervalTest main function is used to test the TimeInterval class. Tests the Basic and Main operators: Basic: equal Main: before, meets, overlaps, starts, during, finishes

runMain scalation.database.timeIntervalTest

Attributes

def timeIntervalTest2(): Unit

The timeIntervalTest2 main function is used to test the TimeInterval class. Tests the Converse Merge operators. Convere: after, metBy, overlapBy, contains, startBy, finishBy Merge: merge, mergeGap

The timeIntervalTest2 main function is used to test the TimeInterval class. Tests the Converse Merge operators. Convere: after, metBy, overlapBy, contains, startBy, finishBy Merge: merge, mergeGap

runMain scalation.database.timeIntervalTest2

Attributes

def timeIntervalTest3(): Unit

The timeIntervalTest3 main function is used to test the TimeInterval class. Tests for a time conflict between a student's class schedule and assigned lab.

The timeIntervalTest3 main function is used to test the TimeInterval class. Tests for a time conflict between a student's class schedule and assigned lab.

Attributes

See also

scalation.database.table.TA_AssignmentDB

runMain scalation.database.timeIntervalTest3

def timeOfWeekTest(): Unit

The timeOfWeekTest main function is use to test the TimeOfWeek class.

The timeOfWeekTest main function is use to test the TimeOfWeek class.

runMain scalation.database.timeOfWeekTest

Attributes

def treeTest(): Unit

The treeTest main function test2 the Tree class by randomly building a tree.

The treeTest main function test2 the Tree class by randomly building a tree.

runMain scalation.database.treeTest

Attributes

def treeTest2(): Unit

The treeTest2 main function tests the Tree class by manually building a tree.

The treeTest2 main function tests the Tree class by manually building a tree.

runMain scalation.database.treeTest2

Attributes

def treeTest3(): Unit

The treeTest3 main function tests the Tree class by manually building a tree.

The treeTest3 main function tests the Tree class by manually building a tree.

runMain scalation.database.treeTest3

Attributes

Concrete fields

val BASE_DIR: String

The base directory for data files

The base directory for data files

Attributes

Generated with