dataMine Lambda Repository Manager

 

Initialization and Repository Extents

You initialize the dataMineLib for use in your application by specifying one or more repository extents that will contain the datamine. Each repository extent is a Analytic Information Server object repository object. Object repository objects manage the storage and retrieval of Analytic Information Server objects to and from a disk file. To initialize dataMineLib for use, you call the dataMineLib with a Structure argument as shown in the following example:

;;Initilize a dataMineLib for use
		(setq myExtents #{reference: "reference.db" blackboard: "blackboard.db"})
		(datMineLambda myExtents)

The structure myExtents contains the list of object repository extents that constitute the "datamine" the dataMineLib will manage. In this example there are two extents specified. The first is named reference: and the file containing the repository extent is "reference.db". The second is named blackboard: and the file containing the repository extent is "blackboard.db".

Once initialized, you can call functions on the dataMineLib and its child Lambdas and dataMineLib.miner. The functions in dataMineLib allow the creation, update and deletion of tables in the repository extents managed by dataMineLib. In addition, the dataMineLib.open function returns a table cursors object that provides a rich interface for the manipulation of tables in the dataMineLib repository extents. These table cursors come in three flavors; memory:, static: and disk:. Memory cursors load the content of an entire table into memory, static cursors provide buffered read access to a table and a disk cursor provides buffered read / unbuffered write access to a table. See the section Table Cursors for a detailed review of the table cursor object. In reading the detailed reference of dataMineLib functions provided in this section it will prove useful to have reviewed the section on Table Cursors. Many of the dataMineLib functions are simple wrappers for a sequence of functions executed on a Table Cursor.

Mobile Extents

The dataMineLib datamine is comprised of one or repository extents and each repository extent contains one or more tables. Repository extents are mobile in the sense that they can be used in different datamines at different times. Consider the example below:

;; Use the same extent in two different datamines
		;; Define and initilize dataMineLib on the first datamine
		(setq datamine #{yearly: "yearly.db" blackboard: "blackboard.db"})
		(dataMineLib datamine); Initialize the dataMineLib
		
		;.. do some work on the open datamine
		
		;; Define and initilize dataMineLib on the second datamine
		(setq datamine #{monthly: "monthly.db" blackboard: "blackboard.db" })
		(dataMineLib datamine); Initialize the dataMineLib
		
		;.. do some work on the open datamine
		

In the preceding example the dataMineLib was initialized against a datamine consisting of two repository extents; yearly: and blackboard:. Later the dataMineLib was initialized again against a datamine consisting of two repository extents: montly: and blackboard:. The blackboard: extent was included in both datamines. This is an example of a mobile extent.

Mobile extents are very useful because they allow you to construct datamine's from a reusable collection of extents as required by your data analysis needs. However there are some issues that you need to keep in mind when using mobile extents:

Transaction Support

The dataMineLib provides transaction support for each repository extent. Each repository extent in the datamine maintains a transaction count. Various dataMineLib functions and Table Cursor functions increment/decrement the transaction the count. When the transaction count is incremented from a value of 0 to 1 a transaction is begun on the repository extent. When the transaction count is decremented from 1 to 0 a commit is performed on the repository extent, making all of the writes into the repository extent that have occurred since the transaction began permanent. Some dataMineLib functions are atomic. An atomic operation means that they increment the transaction count, perform their operation on the repository extent, and then decrement the transaction count before they return. Other dataMineLib functions increment the transaction count and expect some other subsequent dataMineLib functions to be called that will decrement the transaction count. The best example of these kinds of functions are the dataMineLib.open and dataMineLib.close functions that create and close table cursors.

Transaction support is most important to understand in reference to the use of table cursors. Table cursors come in three flavors; memory, disk or static. Updates to table cursor rows are possible only for memory and disk cursors. Changes made to a memory cursor are not automatically saved to the object repository and for this reason opening a memory cursor does not increment the transaction count. A static cursor is essentially read only and it also does not increment the transaction count. Disk cursors allow writes to the object repository and thus increment the transaction count when they are created. Calling close on the disk cursor decrements the open transaction count. Many dataMineLib functions may be called between the creation of the table cursor, with open, and its eventual close.

This makes it important to remember that the scope of transactions in dataMineLib is at the object repository level. In fact, you rollback an open transaction on a repository by calling (dataMineLib.rollback extentNum). All writes to the object repository since the first currently opened disk cursor will be rolled back. Consider this situation:
A disk cursor is opened on TABLE1. >>open transactions=1
A disk cursor is opened on TABLE2. >>open tranasctions=2
Rows in TABLE2 are modified and written to the object repository.
The disk cursor on TABLE2 is closed. >>open transactions=1
dataMineLib.rollback is called.

The changes made to TABLE2 are reversed. In the example above, the object repository transaction started with the opening of the disk cursor on TABLE1. This meant that the writes performed on the TABLE2 disk cursor became part of that transaction.

dataMineLib

Invoke the dataMineLib Lambda to initialize the datamine for use. An argument is passed specifying the object repository extents that will constitute the datamine. After this initial call, the dataMineLib is ready for use.

The dataMineLib manages one or more repository extents. Each repository extent contains zero or more tables. Tables have a defined schema of columns. Each table may have zero or more rows of data. Row objects are object vectors of variable length.

The initialization call to dataMineLib must contain an argument specifying the datamine repository extents that comprise the datamine. Up to 100 repository extents can be allocated.
Type: Function
Syntax: (dataMineLib extentStructure  compress: )
Transaction: NA

extentStructure A structure of repository extent file and path names.
compress: An optional argument. The symbol compress: specifies all repository extents are to use compression.
Returns true

Syntax: (dataMineLib filterSource)
Transaction: NA

FilterSource The javaScript source which is to be parsed into a Analytic Information Server parse tree.
Returns true

Syntax: (dataMineLib)
Transaction: NA

Uses the global variable _dataMineExtents as the structure of repository extent file and path names. _dataMineExtents is created by dataMineLib.
Returns true

When To Use

The (dataMineLib extentStructure) call is required before any other dataMineLib functions can be called.

Example1

This example initializes a datamine with three extents. Each extent must specify the complete path and file name. Extents may be placed on different physical devices as database management strategy requires. Each extent supports up to 2 gigabytes of storage space.

(define dm #{reference: "reference.db"
blackboard1: "blackboard1.db"
blackboard2: "blackboard2.db"
}) ;; end dm
(dataMineLib dm) ;;Returns true

Notes and Hints

The start up script should contain code to this effect, or the client application should issue code like this at startup.

Example2

This example parses a datamine javaScript source string into a Analytic Information Server universal parse tree. In this mode, the dataMineLib is a substitute for the Lisp parser. After parsing the parse tree may be sent to morph and compile to produce a javaScript Lambda.

(setq filterLambda (compile (morph (dataMineLib "filter sort Name"))))

Notes and Hints

This example creates a filter Lambda from the specified javaScript source string.

addTableColumn

The addTableColumn function adds a new column to the table with the specified name. The column is added to the end of the table columns already defined. The addTableColumn function is not available on meta tables or member tables (member tables belong to meta tables and must share the same column definitions). The addTableColumn function will fail with an error if a disk or static cursor is open on the table.
Type: Function
Syntax: (dataMineLib.addTableColumn tableName colName1…colNameN)
Transaction: Atomic.

tableName A symbol or string containing the name of the table to which a column is to be added. If the specified table name must already exist in the datamine.
colName1…colNameN One or more arguments specifying column names. At least one column name must be supplied. Each argument is a symbol or string containing a column name.
Returns true.

clearCursors

The clearCursors function closes all table cursors.
Type: Function
Syntax: (dataMineLib.clearCursors)
Transaction: Transaction count reduced to zero and commit called as necessary.

clearDataMine

The clearDataMine function clears the datamine. All tables in all repository extents are deleted.
Type: Function
Syntax: (dataMineLib.clearDataMine)
Transaction: Forced Commit, Transaction count is zeroed

clearMemoPad

The clearMemoPad function calls clearCursors. Use clearCursors in new applications.
Type: Function
Syntax: (dataMineLib.clearMemoPad)

close

The closefunction closes a table cursor.
Type: Function
Syntax: (dataMineLib.close cursor save: )
Transaction: Decrements transaction count only on disk cursor

cursor The transaction cursor object returned from an open function.
save: An optional argument available only for disk cursor. The symbol save: causes the cursors view directory to be saved. Without this option, the view directories will only be saved if updates to the table have occurred.
Returns true

compileLambda

The compileLambda function returns a new datamine Lambda from the specified source string. The new Lambda is compiled using the javaScript language, and may be a scoring Lambda, or a filter Lambda.
Type: Function
Syntax: (dataMineLib.compileLambda javaString)
Transaction: NA

javaString The javaScript source to be compiled into a data mine Lambda.
Returns The compiled datamine Lambda.

createMetaTable

The createMetaTable function creates a new meta table with the specified name that will reference the rows of the specified member tables. The meta table is created in the repository extent, and associated with the logical database name, previously specified in the last usingForCreate function. The createMetaTable function will fail if there are any open disk or static cursors on the meta table's member tables. Meta tables create a star join index that provides a unique index to all records referenced by the meta table. The first component of the star join index is a key that identifies the underlying member table the record resides in and the second component of the key is a unique column value found in member table rows.
Type: Function
Syntax: (dataMineLib.createMetaTable tableName memberTables rowKeyColumn maxRowKeys )
Transaction: Atomic

tableName A symbol or string containing the name of the meta table to create. If the specified table name already exists in the datamine it will be replaced.
memberTables A directory of table names keyed by the TableKey. A table key can be of any type. Table keys do not have to be present in the underlying table.
rowKeyColumn A symbol or string containing the name of the column in the member tables that contains a uniuqe row identifier within the member table. This rowKeyColumn does not have to be unique across all member tables.
maxRowKeys A numeric argument specifying the maximum number of unique keys that will appear in all member tables. Do not set this value unnecessarily large as excessive memory usage will result.
Returns True.

The createMetaTable Lambda marks each table specified in the memberTables directory as a member table belonging to the new meta table. Member tables may reside in different extents. Member tables may belong to only one meta table. Once created, a meta table may only be opened with a disk cursor. You may not open a disk or static cursor on a member table while a cursor is open on the owning meta table. You may not open a cursor on a meta table while a disk or static cursor is open on one of its member tables. Updates performed on a member table are reflected in it's owning meta table. Updates performed on a meta table are reflected on its member tables. You may open a memory cursor on a member table at any time but the memory cursor save function is disabled.

The last member table added to a meta table is treated differently than previously added member tables. Member tables other than the last added member table are restricted to updates that do not change the length of the member table and that do not add or remove existing unique row IDs. For example, disk cursors opened on member tables (except the last member table) do not allow inserts, appends (writing past current record count) or deletions. Memory cursors opened on member tables do not support the save function. A full range of operations are allowed on the last member table added to a meta table.

Other important meta table related functions include:

Note: Because disk and static cursors on member and meta tables can not be open at the same time, meta tables do not share the buffering of their member tables. However, buffering is available on meta tables.

Example1

;;Create a meta table on two existing tables
(setq td (new Directory:))
(setq td[#Aug,28,1986] Summary860828:)
(setq td[#Feb,28,1986] Summary860228:)
(dataMineLib.createMetaTable allSummaryTables: td ID: 3000); Create the meta table

createTable

The createTable function creates a new table with the specified name and columns. The table is created in the repository extent, and associated with the logical database name, previously specified in the last usingForCreate function.

Type: Function
Syntax: (dataMineLib.createTable tableName colName1…colNameN )
Transaction: Atomic

tableName A symbol or string containing the name of the table to create. If the specified table name already exists in the datamine, a "tableExists" error is raised.
colName1…colNameN Optional arguments. Zero or more symbols or strings naming the new table's columns.
Returns true.

Syntax: (dataMineLib.createTable tableName colNameVector )
Transaction: Atomic

tableName A symbol or string containing the name of the table to create. If the specified table name already exists in the datamine, a "tableExists" error is raised.
colNameVector Optional argument. A vector containing symbols or strings naming the new table's columns.
Returns true.

Use createTable without any column names when you need to create a new table into which you are about to do a importTab.

currentTable

The currentTable property contains a reference to a cursor object being filtered or scored. If no table is being currently filtered or scored, the currentTable property will contain #void. The currentTable property is used frequently in the built in javaScript compiler.
Type: Variable
Syntax: dataMineLib.currentTable
Transaction: NA

deleteRecord

The deleteRecord function deletes a row from the specified table in the datamine. The delete function will fail with an error if there is an open disk cursor on the same table. deleteRecord is not available on meta tables.
Type: Function
Syntax: (dataMineLib.deleteRecord tableName rowIndex)
Transaction: Atomic
Side Effect: If any static cursors are open on the same table they are each reset.

tableName A symbol or string containing the name of the table from which the record is to be deleted.
rowIndex The row index of the row to be deleted.
Returns true.

Note: deleteRecord opens an unbuffered disk cursor, deletes the specified row and then closes the disk cursor.

dropTable

The dropTable function deletes one or more specified tables from the datamine. The dropTable function will fail with an error if there are any open cursors on a table being dropped..
Type: Function
Syntax: (dataMineLib.dropTable tableName1 … tableNameN)
Transaction: Atomic

tableName1..tableNameN One or more symbols or strings containing the names of tables to be deleted.
Returns true

exportTab

The exportTab function exports the contents of the specified table into a ASCII tab delimited file. The column names of the table will be placed in the first row of the exported file.
Type: Function
Syntax: (dataMineLib.exportTab tableName asciiFile)
Transaction: NA

tableName A symbol or string containing the name of the table.
asciiFile A string containing the path and file name of the export file. (The first row will contain the column names).
Returns true

filterTable

The filterTable function runs the specified javaScript Lambda against the specified datamine table. If a source string is provided, the new Lambda is compiled using the javaScript language, and may be a scoring Lambda, or a filter Lambda. The filterTable function will fail with an error if there is an open disk cursor on the table. filterTable is not available on meta tables.
Type: Function
Syntax: (dataMineLib.filterTable tableName javaLambda)
Transaction: Atomic
Side Effect: If any static cursors are open on the same table they are each reset.

tableName A symbol or string containing the name of the table to be filtered.
javaLambda The javaScript Lambda to be run against the table specified.
Returns true

Syntax: (dataMineLib.filterTable tableName javaString)
Transaction: NA

tableName A symbol or string containing the name of the table to be filtered.
javaString The javaScript source string to be compiled and run against the table specified.
Returns true

The filter passed to filterTable is responsible for issuing a command to make the filtering permanent in the table's bckVector.

Note: filterTable opens an unbuffered disk cursor, runs the specified javaScript commands, and the closes the disk cursor.

getExtentNames

The getExtentNames function returns a vector containing the names of all physical database extents allocated in the datamine.
Type: Function
Syntax: (dataMineLib.getExtentNames)
Transaction: NA

Returns A Vector of the datamine's repository extent names is returned.

getTableDatabaseName

The getTableDatabaseName function returns the database name associated with the specified table.
Type: Function
Syntax: (dataMineLib.getTableDatabaseName tableName)
Transaction: NA

tableName A symbol or string containing the table name.
Returns The database name associated with the specified table.

getTableNames

The getTableNames function returns a vector containing the names of all of the tables currently present in the datamine or the names of the tables associated with a specified database.
Type: Function
Syntax: (dataMineLib.getTableNames databaseName)
Transaction: NA

databaseName An optional argument. A symbol or string containing a database name.
Returns A Vector of datamine table names.

importTab

The importTab function imports a specified ASCII tab delimited file into a table. The column names must be the first row in the ASCII data file. The importTab function will fail with an error if there is an open disk cursor on the table. importTab is not available on meta tables.
Type: Function
Syntax: (dataMineLib.importTab tableName option asciiFile)
Transaction: Atomic
Side Effect: If any static cursors are open on the same table they are each reset

tableName A symbol or string containing the name of the table into which the ASCII tab delimited rows are to be imported.
option If overwrite: the table is cleared before import. If append: the ASCII tab delimited rows are appended to the table.
asciiFile A string containing the path and file name of the ASCII tab delimited import data (the first row must contain the column names).
Returns true

isTable

The isTable function returns true if the specified table exists in the datamine.
Type: Function
Syntax: (dataMineLib.isTable tableName)
Transaction: NA

tableName A symbol or string containing the name of a table.
Returns Returns true if the specified table exits.

mergeTables

The mergeTables function allows two tables to be updated by logically combining information from both tables. The result of mergeTables is the specified pair of tables are logically combined according to the merge Lambda supplied by the caller. The caller specifies two table names, a merge field name and a merge Lambda. Prior to calling mergeTables, both tables should already be sorted in ascending order on the specified merge field. Rows are read from both tables in sequential order. When two rows have matching merge fields (the merge field name is specified by the caller), both rows are passed to the specified merge Lambda (also specified by the caller). The merge Lambda expects two row arguments, and logically combines information from both rows. The matching, altered rows are written back to the tables. The mergeTables function will fail with an error if a disk cursor is open on either table. mergeTables is not available on meta tables.
Type: Function
Syntax: (dataMineLib.mergeTables tableName1 tableName2 mergeField mergeLambda)
Transaction: Atomic
Side Effect: If any static cursors are open on the tables they are each reset

tableName1 A symbol or string containing the name of the table, in the datamine, which is to be logically combined (based upon a matching merge field).
tableName2 A symbol or string containing the name of the table, in the datamine, which is to be logically combined (based upon a matching merge field).
mergeField A symbol or string containing the name of the merge field. Any two rows, which have matching values in this field, will be logically combined.
mergeLambda An Lambda expecting two row arguments which logically merges information between two rows.
Returns true

Note: mergeTables opens both tables as unbuffered disk cursors to perform the merge. The cursors are closed after the merge is complete.

mergeThreeTables

Use mergeThreeTables to logically combine information from two input tables into an output table based on a specified merge field and merge Lambda. Prior to calling mergeThreeTables, both input tables should be sorted in ascending order on the specified merge field. When input rows from the two input tables have matching content, both input rows, together with a template for the output row, are passed to the specified merge Lambda. The output row returned from the merge Lambda is written to the output table. The mergeThreeTables function will fail with an error if there is an open disk cursor on the output table. The output table can not be a meta table.

Type: Function
Syntax: (dataMineLib.mergeThreeTables tableName1 tableName2 tableName3 mergeField mergeLambda)
Transaction: Atomic
Side Effect: If any static cursors are open on the output table they are each reset

tableName1 A symbol or string contain the name of the first input table, in the datamine, which is to be logically combined (based upon a matching merge field).
tableName2 A symbol or string containing the name of the second input table, in the datamine, which is to be logically combined (based upon a matching merge field).
tableName3 A symbol or string containing the name of the output table, in the datamine, which is to be updated (based upon logically combined information from the two matching input rows).
mergeField A symbol or string containing the name of the merge field. Any two input rows, which have matching values in this field, will be logically combined into an output row.
mergeLambda An Lambda expecting three row arguments which logically merges information from two rows into the third.
Returns true

Note: Table1 and Table2 are opened as unbuffered static cursors. Table3 is opened as an unbuffered disk cursor. All cursors are closed after the merge is complete.

open

The open function returns a cursor for the specified table. Cursors come in three flavors; memory, static and disk. Multiple cursors may be opened concurrently on the same table with the restriction that only one disk cursor per table may be opened. Memory cursors read the entire table into memory. Static cursors provide buffered read only access to the table. Disk cursors provide buffered read, unbuffered write access to the table.
Type: Function
Syntax: (dataMineLib.open tableName cursorType columns bufSize)
Transaction: Increments transaction count on disk cursors only.

tableName A symbol or string containing the name of the table to open a cursor on.
cursorType An optional symbol that is one of disk: static: or memory: The default is disk:
columns An optional vector of columns names to read. Memory cursors only! The default is all columns.
bufSize An optional number of rows to buffer. Static and disk cursors only!
-1 for no buffering.
0 to use previously specified buffer size.
The default is -1 .
Returns

A cursor for the specified table

Disk and static cursors opened on the same table share a read buffer. This buffer can improve random access read performance of these cursors. If you intend to open a file and read it sequentually you should open the cursor with a bufSize of -1. This way the the contents of the existing buffer, if any, on that table will not be flushed and the overhead of managing the buffer during the read will be avoided. Memory cursors read the entire table content into memory on open. This can be very expensive and memory requirements should be considered by the application programmer to ensure that available memory is not exceeded.

Examples

;;This example opens a memory cursor on the specified columns:
(dataMineLib.open tableName memory: #(Name: Salary:))
;;This example opens a disk cursor with a 1000 row buffer:
(dataMineLib.open tableName disk: 1000)
;;This example opens a disk cursor with a 1000 row buffer:
(dataMineLib.open tableName disk: 1000)
;;This example attempts to open a memory cursor
;;with a buffer and will return an error:
(dataMineLib.open tableName memory: 1000)
;;This example attempts to open a disk cursor with a
;;columns argument and will return an error: (dataMineLib.open tableName disk: #(Name: Salary:))

readRecord

The read Record function reads a row from the specified table in the datamine.
Type: Function
Syntax: (dataMineLib.readRecord tableName rowIndex)
Transaction: NA

tableName A symbol or string containing the name of the table.
rowIndex The index of the row read.
Returns

A copy of the row object.

Note: readRecord opens a buffered static cursor, reads the specified row and then closes the cursor.

recordDetails

The recordDetails function converts a row from a table into an HTML page. The resulting HTML page displays the details of the specified row.
Type: Function
Syntax: (dataMineLib.recordDetails tableCursor rowIndex)
Tranaction: NA

tableCursor The table cursor.
rowIndex The index of the row.
Returns The HTML page showing the details of the specified row.

renameTable

The renameTable function renames a table with the specified new name. The renameTable function will fail with an error if there are any open cursors on the table.
Type: Function
Syntax: (dataMineLib.renameTable oldTableName newTableName)
Transaction: Atomic

oldTableName A symbol or string containing the current name of the table. If the specified table name does not exist, a "tableDoesNotExist" error is raised.
newTableName A symbol or string containing the new table name. If the new table name already exists in the datamine, a "tableExists" error is raised.
Returns true.

setTableDatabaseName

The setTableDatabaseName function changes the database name associated with the specified table. If the database name does not yet exist then it will be created. The setTableDatabaseName function will fail if there are any open cursors on the table.
Type: Function
Syntax: (dataMineLib.setTableDatabaseName tableName databaseName)
Transaction: Atomic

tableName A symbol or string containing the name of the table.
databaseName A symbol or string containing the database name.
Returns true.

sortTable

The sortTable function is primarily used to sort a table and update the table's bckVector in the object repository. Unlike most other dataMineLib functions it does not use the cursor interface. The sortTable function has a number of other useful options as defined below. The sortTable function will fail with an error if there are any open disk or static cursors on the table.
Type: Function
Syntax: (dataMineLib.sortTable tableName sortSpec noSave: noSort: returnVector: returnVectorAndKeys:)
Transaction: Atomic

tableName A symbol or string containing the name of the table.
sortSpec A structure containing a sort specification for the bckVector of the table. Each element of the structure contains a column name and a Ascending or Descending specifier. See examples below.
noSave: A symbol argument specifying that the result of the sort operation is not to be saved to the object repository.
noSort: A symbol argument specifying that no sort should be performed. This option is provided so that the sortTable function may be used polymorphically by the createMetaTable function.
returnOption An optional symbol argument of returnVector: or returnVectorAndKeys:. The returnVector: option causes sortTable to return a copy of the bckVector to the caller. bckVector is a vector of numbers containing the frame ids of each row record object in the table. The returnVectorAndKeys: option causes sortTable to return the sort vector. The sort vector contains row structures with the sort column contents and one additional column containing the frame id of the row record object.
Returns See returnOption.

The sortTable function is the fastest way of creating a persistent sort on a table. It uses much less memory than performing the sort function on a memory cursor. In general, the sortTable function uses more memory than performing the sort function on a disk cursor opened with no buffering but less memory than a disk cursor opened with even a modest level of buffering.

systemCheck

The systemCheck function performs a systems check on the datamine. An error is returned if any abnormalities are found.
Type: Function
Syntax: (dataMineLib.systemCheck)

updateTable

The updateTable function runs the specified update Lambda against the table causing a permanent change to the table. The update Lambda must be a javaScript Lambda expecting one argument (the table row to be updated). Each row in the specified table is read and passed to the update Lambda. The update Lambda updates the row as specified and the updated row is written back to the table. The updateTable function with fail with an error if there are any open disk cursors on the table. updateTable is not available on meta tables.
Type: Function
Syntax: (dataMineLib.updateTable tableName updateSource)
Transaction: Atomic
Side Effect: The view directory of the table is cleared. If any static cursors are open on the same table they are each reset.

tableName A symbol or string containing the current name of the table.
updateSource The source code for the update Lambda to be run.
Returns true

Syntax: (dataMineLib.updateTable tableName updateLambda)
Transaction: Atomic

tableName A symbol or string containing the current name of the table.
updateLambda The update Lambda to be run against the table.
Returns true

Note: updateTable opens an unbuffered disk cursor, updates each record in the cursor's bckVector, then closes the disk cursor.

usingForCreate

The usingForCreate function sets the repository extent and database name for subsequently created tables. Use the createTable function to create new tables.
Type: Function
Syntax: (dataMineLib.usingForCreate extentName databaseName)
Transaction: NA

extentName A symbol or name containing the name of the repository extent.
databaseName A symbol or name containing the name of the database.
Returns True

Example1

This example initializes the dataMineLib, calls usingForCreate and then calls createTable.

;; Initialize the datamine.
(setq _dataMineExtents #{reference: "reference.db" blackboard: "blackboard.db"})
(dataMineLib _dataMineExtents)
;; Set the physical area and logical database name for all new tables.
(dataMineLib.usingForCreate reference: "Sales Data")
;; Create a new table
(dataMineLib.createTable salesSummary: #(Date: Amount:))

In the example above the repository extent reference: contains a table named salesSummary: that belongs to the database "Sales Data".

writeRecord

The writeRecord function writes a row to the specified table in the datamine. The writeRecord function will fail with an error if there is an open disk cursor on the table. writeRecord is not available on meta tables.
Type: Function
Syntax: (dataMineLib.writeRecord tableName rowIndex record)
Transaction: Atomic
Side Effect: The view directory of the table is cleared. If any static cursors are open on the same table they are each reset

tableName A symbol or string containing the table name of the table.
rowIndex The index of the row to be written.
Returns true.

Note: writeRecord opens an unbuffered disk cursor, writes the record and then closes the disk cursor.