qminer
Version:
A C++ based data analytics platform for processing large-scale real-time streams containing structured and unstructured data
948 lines (947 loc) • 228 kB
HTML
<!doctype html>
<html>
<head>
<meta name="generator" content="JSDoc 3">
<meta charset="utf-8">
<title>Source: qminerdoc.js</title>
<link rel="stylesheet" href="https://brick.a.ssl.fastly.net/Karla:400,400i,700,700i" type="text/css">
<link rel="stylesheet" href="https://brick.a.ssl.fastly.net/Noto+Serif:400,400i,700,700i" type="text/css">
<link rel="stylesheet" href="https://brick.a.ssl.fastly.net/Inconsolata:500" type="text/css">
<link href="css/baseline.css" rel="stylesheet">
</head>
<body onload="prettyPrint()">
<nav id="jsdoc-navbar" role="navigation" class="jsdoc-navbar">
<div id="jsdoc-navbar-container">
<div id="jsdoc-navbar-content">
<a href="index.html" class="jsdoc-navbar-package-name">Home</a>
</div>
</div>
</nav>
<div id="jsdoc-body-container">
<div id="jsdoc-content">
<div id="jsdoc-content-container">
<div id="jsdoc-banner" role="banner">
</div>
<div id="jsdoc-main" role="main">
<header class="page-header">
<h1>Source: qminerdoc.js</h1>
</header>
<article>
<pre class="prettyprint linenums"><code>/**
* Copyright (c) 2015, Jozef Stefan Institute, Quintelligence d.o.o. and contributors
* All rights reserved.
*
* This source code is licensed under the FreeBSD license found in the
* LICENSE file in the root directory of this source tree.
*/
/**
* QMiner module.
* @module qm
* @example
* // import module
* var qm = require('qminer');
*/
/**
* Creates a directory structure.
* @param {string} [configPath='qm.conf'] - The path to configuration file.
* @param {boolean} [overwrite=false] - If you want to overwrite the configuration file.
* @param {number} [portN=8080] - The number of the port. Currently not used.
* @param {number} [cacheSize=1024] - Sets available memory for indexing (in MB).
*/
exports.config = function(configPath, overwrite, portN, cacheSize) {}
/**
* Creates an empty base.
* @param {string} [configPath='qm.conf'] - Configuration file path.
* @param {string} [schemaPath=''] - Schema file path.
* @param {boolean} [clear=false] - Clear the existing db folder.
* @returns {module:qm.Base} The newly created base.
*/
exports.create = function (configPath, schemaPath, clear) { return Object.create(require('qminer').Base.prototype); }
/**
* Opens a base.
* @param {string} [configPath='qm.conf'] - The configuration file path.
* @param {boolean} [readOnly=false] - Open in read-only mode.
* @returns {module:qm.Base} The loaded base.
*/
exports.open = function (configPath, readOnly) { return Object.create(require('qminer').Base.prototype); }
/**
* Set verbosity of QMiner internals.
* @param {number} [level=0] - verbosity level. Possible options:
* &lt;br>1. `0` - No output,
* &lt;br>2. `1` - Log output,
* &lt;br>3. `2` - Log and debug output.
*/
exports.verbosity = function (level) { }
/**
* Returns an JSON with two properties: "byClass" and "total". The "byClass" value is a JSON where
* each key is a class ID and each value is of the form { newFromCpp: number, newFromJs: number, destructorCalls: number}
* and the value of "total" is of the same form (aggregated over "byClass")
*/
exports.stats = function () { }
/**
* @typedef {Object} QMinerFlags
* The object containing the QMiner compile flags.
* @property {string} buildTime - The module build time.
* @property {boolean} win - True, if the module is compiled for Windows.
* @property {boolean} linux - True, if the module is compiled for Linux.
* @property {boolean} darwin - True, if the module is compiled for Darwin.
* @property {boolean} x86 - True, if the module is compiled for x86 system.
* @property {boolean} x64 - True, if the module is compiled for x64 system.
* @property {boolean} omp - True, if the module is compiled for omp.
* @property {boolean} debug - True, if the module is compiled for debug mode.
* @property {boolean} gcc - True, if the module is compiled for gcc.
* @property {boolean} clang - True, if the module is compiled for clang.
* @property {boolean} blas - True, if the module is compiled with Blas.
* @property {boolean} blas_intel - True, if the module is compiled with Intel Blas.
* @property {boolean} blas_amd - True, if the module is compiled with AMD Blas.
* @property {boolean} blas_openblas - True, if the module is compiled with OpenBLAS.
* @property {boolean} lapacke - True, if the module is compiled with Lapacke.
*/
/**
* Returns an object with all compile flags. Type {@link module:qm~QMinerFlags}.
* @example
* // import qm module
* var qm = require('qminer');
* // get the compile flags
* var flags = qm.flags;
*/
exports.flags = { buildTime: "", win: true, linux: true, darwin: true, x86: true, x64: true, omp: true, debug: true, gcc: true, clang: true, blas: true, blas_intel: true, blas_amd: true, blas_openblas: true, lapacke: true };
/**
* Returns the module version.
* @returns {string} The module version.
* @example
* // import qm module
* var qm = require('qminer');
* // get the module version
* var version = qm.version;
*/
exports.version = '';
/**
* @typedef {Object} BaseConstructorParam
* Base constructor parameter used for {@link module:qm.Base}.
* @property {string} [mode='openReadOnly'] - Base access mode. Can be one of the following:
* &lt;br>1. `'create'` - Sets up the db folder,
* &lt;br>2. `'createClean'` - Cleans db folder and then sets it up,
* &lt;br>3. `'open'` - Opens the db with read/write permissions,
* &lt;br>4. `'openReadOnly'` - Opens the db in read only mode.
* @property {number} [indexCache=1024] - The ammount of memory reserved for indexing (in MB).
* @property {number} [storeCache=1024] - The ammount of memory reserved for store cache (in MB).
* @property {string} [schemaPath=''] - The path to schema definition file.
* @property {Array&lt;module:qm~SchemaDef>} [schema=[]] - Schema definition object array.
* @property {string} [dbPath='./db/'] - The path to db directory.
*/
/**
* @typedef {Object} SchemaDef
* Store schema definition used in {@link module:qm~BaseConstructorParam}.
* @property {string} name - The name of the store. Store name can be composed by from English letters, numbers, _ or $ characters. It can only begin with a character.
* @property {Array&lt;module:qm~SchemaFieldDef>} fields - The array of field descriptors.
* @property {Array&lt;module:qm~SchemaJoinDef>} [joins=[]] - The array of join descriptors, used for linking records from different stores.
* @property {Array&lt;module:qm~SchemaKeyDef>} [keys=[]] - The array of key descriptors. Keys define how records are indexed, which is needed for search using the query language.
* @property {module:qm~SchemaTimeWindowDef} [timeWindow] - Time window description. Stores can have a window, which is used by garbage collector to delete records once they fall out of the time window. Window can be defined by number of records or by time.
* @example
* var qm = require('qminer');
* // create a simple movies store, where each record contains only the movie title.
* var base = new qm.Base({
* mode: 'createClean',
* schema: [{
* name: "Movies",
* fields: [{ name: "title", type: "string" }]
* }]
* });
* base.close();
*/
/**
* @typedef {Object} SchemaFieldDef
* Store schema field definition used in {@link module:qm~SchemaDef}.
* @property {string} name - The name of the field.
* @property {string} type - The type of the field. Possible options:
* &lt;br>1. `'int'` - Signed 32-bit integer,
* &lt;br>2. `'uint64'` - Unsigned 64-bit integer,
* &lt;br>3. `'int_v'` - Array of signed 32-bit integers,
* &lt;br>4. `'string'` - String,
* &lt;br>5. `'string_v'` - Array of strings,
* &lt;br>6. `'bool'` - Boolean,
* &lt;br>7. `'float'` - Double precision flating point number,
* &lt;br>8. `'float_pair'` - A pair of floats, useful for storing geo coordinates,
* &lt;br>9. `'float_v'` - Array of floats,
* &lt;br>10. `'datetime'` - Date and time format, stored in a form of miliseconds since 1600,
* &lt;br>11. `'num_sp_v'` - Array of [`int`, `float`] pairs. See constructor array for {@link module:la.SparseVector},
* &lt;br>12. `'json'` - this field can be an arbitrary object and will be internally serialized into string using JSON notation,
* &lt;br>13. `'blob'` - Binary buffer, used for storing binary data,
* @property {boolean} [primary=false] - Field which can be used to identify record. There can be only one primary field in a store. There can be at most one record for each value of the primary field. Currently following fields can be marked as primary: `int`, `uint64`, `string`, `float`, `datetime`. Primary fields of type `string` are also used for record querying using {@link module:qm.Store#recordByName}.
* @property {boolean} [null=false] - When set to true, null is a possible value for a field (allow missing values).
* @property {string} [store='memory'] - Defines where to store the field. Possible options
* &lt;br>1. `'memory'` - Stores the values in RAM.
* &lt;br>2 `'cache'` - Stores the values on disk, with a layer of FIFO cache in RAM, storing the most recently used values.
* @property {Object} [default] - Default value for field when not given for a new record.
* @property {boolean} [codebook=false] - Useful when many records have only few different values of this field. If set to true, then a separate table of all values is kept, and records only point to this table (replacing variable string field in record serialisation with fixed-length integer). Useful to decrease memory footprint, and faster to update. (STRING FIELD TYPE SPECIFIC).
* @property {boolean} [shortstring=false] - Useful for string shorter then 127 characters (STRING FIELD TYPE SPECIFIC).
* @example
* var qm = require('qminer');
* var base = new qm.Base({
* mode: 'createClean',
* schema: [
* { name: 'NewsArticles',
* fields: [
* { name: "ID", primary: true, type: "string", shortstring: true },
* { name: "Source", type: "string", codebook: true },
* { name: "DateTime", type: "datetime" },
* { name: "Title", type: "string", store: "cache" },
* { name: "Tokens", type: "string_v", store: "cache", null: true },
* { name: "Vector", type: "num_sp_v", store: "cache", null: true }]
* }
* ]
* });
* // add a record:
* // - we set the date using the ISO string representation
* // - we set the string vector Tokens with an array of strings
* // - we set the numeric sparse vector Vector with an array of two element arrays
* // (index, value), see the sparse vector constructor {@link module:la.SparseVector}
* base.store('NewsArticles').push({
* ID: 't12344',
* Source: 's1234',
* DateTime: '2015-01-01T00:05:00',
* Title: 'the title',
* Tokens: ['token1', 'token2'],
* Vector: [[0,1], [1,1]]});
* base.close();
*/
/**
* @typedef {Object} SchemaJoinDef
* Store schema join definition used in {@link module:qm~SchemaDef}.
* @property {string} name - The name of the join.
* @property {string} type - Join types. Possible options:
* &lt;br>1. `'field'` - Points to zero or one record and is implemented as an additional hidden field of type `uint64`, which can hold the ID of the record it links to. Accessing the records join returns a record.
* &lt;br>2. `'index'` - Point to any number of records and is implemented using the inverted index, where for each record a list (vector) of linked records is kept. Accessing the records join returns a record set.
* &lt;b>Important:&lt;/b> The records given to this join field must be in an array.
*
* @property {string} store - The store name from which the linked records are.
* @example
* var qm = require('qminer');
* // Create two stores: People which stores only names of persons and Movies, which stores only titles.
* // Each person can direct zero or more movies, so we use an index join named 'directed' and
* // each movie has a single director, so we use a field join 'director'. The joins are
* // inverses of each other. The inverse join simplifies the linking, since only one join needs
* // to be specified, and the other direction can be linked automatically (in the example
* // below we specify only the 'director' link and the 'directed' join is updated automatically).
* //
* var base = new qm.Base({
* mode: 'createClean',
* schema: [
* { name: 'People',
* fields: [{ name: 'name', type: 'string', primary: true }],
* joins: [{ name: 'directed', 'type': 'index', 'store': 'Movies', 'inverse': 'director' }] },
* { name: 'Movies',
* fields: [{ name: 'title', type: 'string', primary: true }],
* joins: [{ name: 'director', 'type': 'field', 'store': 'People', 'inverse': 'directed' }] }
* ]
* });
* // Adds a movie, automatically adds 'Jim Jarmusch' to People, sets the 'director' join (field join)
* // and automatically updates the index join 'directed', since it's an inverse join of 'director'
* base.store('Movies').push({ title: 'Broken Flowers', director: { name: 'Jim Jarmusch' } });
*
* // Adds a movie, sets the 'director' join, updates the index join of 'Jim Jarmusch'
* base.store('Movies').push({ title: 'Coffee and Cigarettes', director: { name: 'Jim Jarmusch' } });
* // Adds movie, automatically adds 'Lars von Trier' to People, sets the 'director' join
* // and 'directed' inverse join (automatically)
* base.store('Movies').push({ title: 'Dogville', director: { name: 'Lars von Trier' } });
*
* // Adds a person, sets the 'directed' join with multiple movies ('directed' is of type 'index', movies must be given in an array)
* base.store('People').push({ name: 'Christopher Nolan', directed: [{ title: 'Inception' }, { title: 'Interstellar' }] });
*
* var movie = base.store('Movies')[0]; // get the first movie (Broken Flowers)
* // Each movie has a property corresponding to the join name: 'director'.
* // Accessing the property returns a {@link module:qm.Record} from the store People.
* var person = movie.director; // get the director
* var personName = person.name; // get person's name ('Jim Jarmusch')
*
* // Each person has a property corresponding to the join name: 'directed'.
* // Accessing the property returns a {@link module:qm.RecSet} from the store People.
* var movies = person.directed; // get all the movies the person directed.
* movies.each(function (movie) { var title = movie.title; });
* // Gets the following titles:
* // 'Broken Flowers'
* // 'Coffee and Cigarettes'
* base.close();
*/
/**
* @typedef {Object} SchemaKeyDef
* Store schema key definition used in {@link module:qm~SchemaDef}.
* @property {string} field - The name of the field that will be indexed.
* @property {string} type - Key type. Possible options:
* &lt;br>1. `'value'` - Indexes records using an inverted index using full value of the field (no processing).
* The key type supports `'string'`, `'string_v'` and `'datetime'` fields types.
* &lt;br>2. `'text'` - Indexes string fields by using a tokenizer and text processing. Supported by `'string'` fields.
* &lt;br>3. `'location'`- Indexes records as points on a sphere and enables nearest-neighbour queries. Supported by `'float_pair'` type fields.
* @property {string} [name] - Allows using a different name for the key in search queries. This allows for multiple keys to be put against the same field. Default value is the name of the field.
* @property {string} [vocabulary] - Defines the name of the vocabulary used to store the tokens or values. This can be used indicate to several keys to use the same vocabulary, to save on memory. Supported by `'value'` and `'text'` keys.
* @property {string} [tokenize] - Defines the tokenizer that is used for tokenizing the values stored in indexed fields. Tokenizer uses same parameters as in bag-of-words feature extractor. Default is english stopword list and no stemmer. Supported by `'text'` keys.
* @example
* var qm = require('qminer');
* // Create a store People which stores only names of persons.
* var base = new qm.Base({
* mode: 'createClean',
* schema: [
* { name: 'People',
* fields: [{ name: 'name', type: 'string', primary: true }],
* keys: [
* { field: 'name', type: 'value'},
* { field: 'name', name: 'nameText', type: 'text'}
* ]
* }
* ]
* });
*
* base.store('People').push({name : 'John Smith'});
* base.store('People').push({name : 'Mary Smith'});
* // search based on indexed values
* base.search({$from : 'People', name: 'John Smith'}); // Return the record set containing 'John Smith'
* // search based on indexed values
* base.search({$from : 'People', name: 'Smith'}); // Returns the empty record set
* // search based on text indexing
* base.search({$from : 'People', nameText: 'Smith'}); // Returns both records
* base.close();
*/
/**
* @typedef {Object} SchemaTimeWindowDef
* Stores can have a window, which is used by garbage collector to delete records once they
* fall out of the time window. Window can be defined by number of records or by time.
* Window defined by parameter window, its value being the number of records to be kept. Used in {@link module:qm~SchemaDef}.
* &lt;br>&lt;b>Important:&lt;/b> {@link module:qm.Base#garbageCollect} must be called manually to remove records outside time window.
* @property {number} duration - The size of the time window (in number of units).
* @property {string} unit - Defines in which units the window size is specified. Possible options are `'second'`, `'minute'`, `'hour'`, `'day'`, `'week'` or `'month'`.
* @property {string} [field] - Name of the datetime field, which defines the time of the record. In case it is not given, the insert time is used in its place.
* @example &lt;caption>Define window by number of records&lt;/caption>
* var qm = require('qminer');
* // create base
* var base = new qm.Base({ mode: 'createClean' });
* // create store with window
* base.createStore({
* "name": "TestStore",
* "fields": [
* { "name": "DateTime", "type": "datetime" },
* { "name": "Measurement", "type": "float" }
* ],
* window: 3,
* });
*
* // push 5 records into created store
* for (var i = 0; i &lt; 5; i++) {
* var rec = {
* "DateTime": new Date().toISOString(),
* "Measurement": i
* };
* base.store("TestStore").push(rec);
* }
*
* // check number of records in store
* base.store("TestStore").allRecords.length; // 5
* // clean base with garbage collector
* base.garbageCollect();
* // check number of records in store
* base.store("TestStore").allRecords.length; // 3
* base.close();
*
* @example &lt;caption>Define window by time&lt;/caption>
* var qm = require('qminer');
* // create base
* var base = new qm.Base({ mode: 'createClean' });
* // create store with window
* base.createStore({
* "name": "TestStore",
* "fields": [
* { "name": "DateTime", "type": "datetime" },
* { "name": "Measurement", "type": "float" }
* ],
* timeWindow: {
* duration: 2,
* unit: "hour",
* field: "DateTime"
* }
* });
*
* // push 5 records into created store
* for (var i = 0; i &lt; 5; i++) {
* var rec = {
* "DateTime": new Date(new Date().getTime() + i * 60 * 60 * 1001).toISOString(),
* "Measurement": i
* };
* base.store("TestStore").push(rec);
* }
*
* // check number of records in store
* base.store("TestStore").allRecords.length; // 5
* // clean base with garbage collector
* base.garbageCollect();
* // check number of records in store
* base.store("TestStore").allRecords.length; // 2
* base.close();
*/
/**
* Base
* @classdesc Represents the database and holds stores.
* @class
* @param {module:qm~BaseConstructorParam} paramObj - The base constructor parameter object.
* @example
* // import qm module
* var qm = require('qminer');
* // using a constructor, in open mode
* var base = new qm.Base({ mode: 'open' });
* base.close();
*/
exports.Base = function (paramObj) { return Object.create(require('qminer').Base.prototype); };
/**
* Closes the database.
* @returns {null} No value is returned.
* @example
* // import qm module
* var qm = require('qminer');
* // using a constructor, in open mode
* var base = new qm.Base({ mode: 'open' });
* // close the database
* base.close();
*/
exports.Base.prototype.close = function () { return null; }
/**
* Checks if the base is closed.
* @returns {Boolean} Returns `true`, if the base is closed.
* @example
* // import qm module
* var qm = require('qminer');
* // using a constructor, in open mode
* var base = new qm.Base({ mode: 'open' });
* // check if the base is closed
* var closed = base.isClosed();
* // close the database
* base.close();
*/
exports.Base.prototype.isClosed = function () { return true; }
/**
* Returns the store with the specified name.
* @param {string} name - Store name.
* @returns {module:qm.Store} The store.
* @example
* // import qm module
* var qm = require('qminer');
* // create a base with two stores
* var base = new qm.Base({
* mode: "createClean",
* schema: [
* {
* name: "KwikEMart",
* fields: [
* { name: "Worker", type: "string" },
* { name: "Groceries", type: "string_v" }
* ]
* },
* {
* name: "NuclearPowerplant",
* fields: [
* { name: "Owner", type: "string" },
* { name: "NumberOfAccidents", type: "int" },
* { name: "Workers", type: "string_v" }
* ]
* }]
* });
* // get the "KwikEMart" store
* var store = base.store("KwikEMart"); // returns the store with the name "KwikEMart"
* base.close();
*/
exports.Base.prototype.store = function (name) { return Object.create(require('qminer').Store.prototype); }
/**
* Checks if there is a store.
* @param {string} name - Store name.
* @returns {boolean} True, if there exists a store with the store `name`. Otherwise, false.
* @example
* // import qm module
* var qm = require('qminer');
* // create a base with two stores
* var base = new qm.Base({
* mode: "createClean",
* schema: [
* {
* name: "KwikEMart",
* fields: [
* { name: "Worker", type: "string" },
* { name: "Groceries", type: "string_v" }
* ]
* },
* {
* name: "NuclearPowerplant",
* fields: [
* { name: "Owner", type: "string" },
* { name: "NumberOfAccidents", type: "int" },
* { name: "Workers", type: "string_v" }
* ]
* }]
* });
* // get the "KwikEMart" store
* var exists = base.isStore("KwikEMart"); // true
* base.close();
*/
exports.Base.prototype.isStore = function (name) { return false; }
/**
* Returns a list of store descriptors.
* @returns {Array.&lt;object>} An array of store descriptors. The store descriptor `storeDesc` contains the properties:
* &lt;br>1. `storeDesc.storeId` - The store ID. Type `number`.
* &lt;br>2. `storeDesc.storeName` - Store name. Type `string`.
* &lt;br>3. `storeDesc.storeRecords` - Number of records in store. Type `number`.
* &lt;br>4. `storeDesc.fields` - The store field schema. Type &lt;code>Array of &lt;a href="module-qm.html#~SchemaFieldDef">module:qm.SchemaFieldDef&lt;/a>&lt;/code>.
* &lt;br>5. `storeDesc.keys` - The store key schema. Type &lt;code>Array of &lt;a href="module-qm.html#~SchemaKeyDef">module:qm.SchemaKeyDef&lt;/a>&lt;/code>.
* &lt;br>6. `storeDesc.joins` - The store join schema. Type &lt;code>Array of &lt;a href="module-qm.html#~SchemaJoinDef">module:qm.SchemaJoinDef&lt;/a>&lt;/code>.
* @example
* // import qm module
* var qm = require('qminer');
* // create a base with two stores
* var base = new qm.Base({
* mode: "createClean",
* schema: [
* {
* name: "KwikEMart",
* fields: [
* { name: "Worker", type: "string" },
* { name: "Groceries", type: "string_v" }
* ]
* },
* {
* name: "NuclearPowerplant",
* fields: [
* { name: "Owner", type: "string" },
* { name: "NumberOfAccidents", type: "int" },
* { name: "Workers", type: "string_v" }
* ]
* }]
* });
* // get the list of store descriptors
* var exists = base.getStoreList();
* base.close();
*/
exports.Base.prototype.getStoreList = function () { return [{storeId: 0, storeName:'', storeRecords: 0, fields: [{}], keys: [{}], joins: [{}]}]; }
/**
* Creates a new store.
* @param {Array.&lt;module:qm~SchemaDef>} storeDef - The definition of the store(s).
* @param {number} [storeSizeInMB = 1024] - The reserved size of the store(s).
* @returns {(module:qm.Store | Array.&lt;module:qm.Store>)} - Returns a store or an array of stores (if the schema definition was an array).
* @example
* // import qm module
* var qm = require('qminer');
* // create a new base with one store
* var base = new qm.Base({
* mode: "createClean",
* schema: [
* {
* name: "Superheroes",
* fields: [
* { name: "Name", type: "string" },
* { name: "Superpowers", type: "string_v" },
* { name: "YearsActive", type: "int" }
* ]
* }]
* });
* // create a new store called "Supervillains" in the base
* base.createStore({
* name: "Supervillians",
* fields: [
* { name: "Name", type: "string" },
* { name: "Superpowers", type: "string_v" },
* { name: "YearsActive", type: "int" }
* ]
* });
* // create two new stores called "Cities" and "Leagues"
* base.createStore([
* {
* name: "Cities",
* fields: [
* { name: "Name", type: "string", primary: true },
* { name: "Population", type: "int" }
* ]
* },
* {
* name: "Leagues",
* fields: [
* { name: "Name", type: "string" },
* { name: "Members", type: "string_v" }
* ]
* }
* ]);
* base.close();
*/
exports.Base.prototype.createStore = function (storeDef, storeSizeInMB) { return storeDef instanceof Array ? [Object.create(require('qminer').Store.prototype)] : Object.create(require('qminer').Store.prototype) ;}
/**
* @typedef {object} QueryObject
* The object used for querying records with {@link module:qm.Base#search}.
* How to construct a query is found on the &lt;a href="https://github.com/qminer/qminer/wiki/Query-Language">QMiner Wiki page&lt;/a>.
*/
/**
* Makes a query search and returns a record set.
* @param {module:qm~QueryObject} query - Query language JSON object.
* @returns {module:qm.RecordSet} The record set that matches the search criterion.
*/
exports.Base.prototype.search = function (query) { return Object.create(require('qminer').RecordSet.prototype); }
/**
* Calls qminer garbage collector to remove records outside time windows. For application example see {@link module:qm~SchemaTimeWindowDef}.
* @param {number} [max_time=-1] - Maximal number of time each store can spend on cleaning backlog in milisecons. If -1 then no limit is applied.
*/
exports.Base.prototype.garbageCollect = function () { }
/**
* Base saves dirty data given some time window.
* @param {number} [window=500] - Length of available time window in miliseconds.
* @returns {number} Number of records it flushed.
* @example
* // import qm module
* var qm = require('qminer');
* // create a base with two stores
* var base = new qm.Base({
* mode: "createClean",
* schema: [
* {
* name: "KwikEMart",
* fields: [
* { name: "Worker", type: "string" },
* { name: "Groceries", type: "string_v" }
* ]
* },
* {
* name: "NuclearPowerplant",
* fields: [
* { name: "Owner", type: "string" },
* { name: "NumberOfAccidents", type: "int" },
* { name: "Workers", type: "string_v" }
* ]
* }]
* });
* // call the garbage collector
* base.partialFlush();
* base.close();
*/
exports.Base.prototype.partialFlush = function () { return 0; }
/**
* @typedef {object} PerformanceStat
* The performance statistics used to describe {@link module:qm~PerformanceStatBase} and {@link module:qm~PerformanceStatStore}.
* @property {number} alloc_count - \\ TODO: Add the description
* @property {number} alloc_size - \\ TODO: Add the description
* @property {number} alloc_unused_size - \\ TODO: Add the description
* @property {number} avg_get_len - \\ TODO: Add the description
* @property {number} avg_put_len - \\ TODO: Add the description
* @property {number} avg_get_new_len - \\ TODO: Add the description
* @property {number} dels - \\ TODO: Add the description
* @property {number} gets - \\ TODO: Add the description
* @property {number} puts - \\ TODO: Add the description
* @property {number} puts_new - \\ TODO: Add the description
* @property {number} released_count - \\ TODO: Add the description
* @property {number} released_size - \\ TODO: Add the description
* @property {number} size_changes - \\ TODO: Add the description
*/
/**
* @typedef {object} PerformanceStatStore
* The performance statistics of the store found in {@link module:qm~PerformanceStatBase}.
* @property {string} name - Store name.
* @property {module:qm~PerformanceStat} blob_storage_memory - \\ TODO: Add the description
* @property {module:qm~PerformanceStat} blob_storage_cache - \\ TODO: Add the description
*/
/**
* @typedef {object} PerformanceStatBase
* The performance statistics that is returned by {@link module:qm.Base#getStats}.
* @property {Array.&lt;module:qm~PerformanceStatStore>} stores - The performance statistics of the stores in base. \\ TODO: Check if this is right
* @property {object} gix_stats - The statistics of the base. \\ TODO: Check if this is right
* @property {number} gix_stats.avg_len - The average length. \\ TODO: Check if this is right
* @property {number} gix_stats.cache_all - The number of cache. \\ TODO: Check if this is right
* @property {number} gix_stats.cache_all_loaded_perc - \\ TODO: Add the description
* @property {number} gix_stats.cache_dirty - \\ TODO: Add the description
* @property {number} gix_stats.cache_dirty_loaded_perc - \\ TODO: Add the description
* @property {number} gix_stats.mem_sed - \\ TODO: Add the description
* @property {module:qm~PerformanceStat} gix_blob - \\ TODO: Add the description
*/
/**
* Retrieves performance statistics for qminer.
* @returns {module:qm~PerformanceStatBase} The performance statistics.
* @example
* // import qm module
* var qm = require('qminer');
* // create a base with two stores
* var base = new qm.Base({
* mode: "createClean",
* schema: [
* {
* name: "KwikEMart",
* fields: [
* { name: "Worker", type: "string" },
* { name: "Groceries", type: "string_v" }
* ]
* },
* {
* name: "NuclearPowerplant",
* fields: [
* { name: "Owner", type: "string" },
* { name: "NumberOfAccidents", type: "int" },
* { name: "Workers", type: "string_v" }
* ]
* }]
* });
* // call the garbage collector
* base.getStats();
* base.close();
*/
exports.Base.prototype.getStats = function () { }
/**
* Gets the stream aggregate of the given name.
* @param {string} saName - The name of the stream aggregate.
* @returns {module:qm.StreamAggr} The stream aggregate whose name is `saName`.
* @example
* // import qm module
* var qm = require('qminer');
* // create a simple base containing one store
* var base = new qm.Base({
* mode: "createClean",
* schema: [{
* name: "People",
* fields: [
* { name: "Name", type: "string" },
* { name: "Gendre", type: "string" },
* ]
* },
* {
* name: "Laser",
* fields: [
* { name: "Time", type: "datetime" },
* { name: "WaveLength", type: "float" }
* ]
* }]
* });
*
* // create a new time series window buffer stream aggregator for 'Laser' store (with the JSON object)
* var wavelength = {
* name: "WaveLengthLaser",
* type: "timeSeriesWinBuf",
* store: "Laser",
* timestamp: "Time",
* value: "WaveLength",
* winsize: 10000
* }
* var sa = base.store("Laser").addStreamAggr(wavelength);
* // get the stream aggregate with the name 'Laser'
* var streamAggr = base.getStreamAggr('WaveLengthLaser');
* base.close();
*/
exports.Base.prototype.getStreamAggr = function (saName) { return Object.create(require('qminer').StreamAggr.prototype); }
/**
* Gets an array of the stream aggregate names in the base.
* @returns {Array.&lt;string>} The array containing the stream aggregate names.
* @example
* // import qm module
* var qm = require('qminer');
* // create a simple base containing one store
* var base = new qm.Base({
* mode: "createClean",
* schema: [{
* name: "People",
* fields: [
* { name: "Name", type: "string" },
* { name: "Gendre", type: "string" },
* ]
* },
* {
* name: "Laser",
* fields: [
* { name: "Time", type: "datetime" },
* { name: "WaveLength", type: "float" }
* ]
* }]
* });
*
* // create a new stream aggregator for 'People' store, get the length of the record name (with the function object)
* var aggr = new qm.StreamAggr(base, new function () {
* var length = 0;
* this.name = 'nameLength',
* this.onAdd = function (rec) {
* length = rec.Name.length;
* };
* this.saveJson = function (limit) {
* return { val: length };
* }
* }, "People");
*
* // create a new time series window buffer stream aggregator for 'Laser' store (with the JSON object)
* var wavelength = {
* name: "WaveLengthLaser",
* type: "timeSeriesWinBuf",
* store: "Laser",
* timestamp: "Time",
* value: "WaveLength",
* winsize: 10000
* }
* var sa = base.store("Laser").addStreamAggr(wavelength);
* // get the stream aggregates names
* var streamAggrNames = base.getStreamAggrNames();
* base.close();
*/
exports.Base.prototype.getStreamAggrNames = function () { return [""]; }
/**
* Retrieves performance statistics for stream aggregates.
*/
exports.Base.prototype.getStreamAggrStats = function () { }
/**
* Stores are containers of records. &lt;br>
* &lt;b>Factory pattern:&lt;/b> this class cannot be construced using the new keyword. This class is constructed when
* calling a specific method or attribute, e.g. constructing the {@link module:qm.Base} using schema or with the
* {@link module:qm.Base#createStore}.
* @class
* @example &lt;caption>Creating a store with createStore function&lt;/caption>
* // import qm module
* var qm = require('qminer');
* // factory based construction using base.createStore
* var base = new qm.Base({ mode: 'createClean' });
* base.createStore([{
* name: "People",
* fields: [
* { name: "Name", type: "string", primary: true },
* { name: "Gender", type: "string", shortstring: true },
* { name: "Age", type: "int" }
* ],
* joins: [
* { name: "ActedIn", type: "index", store: "Movies", inverse: "Actor" },
* { name: "Directed", type: "index", store: "Movies", inverse: "Director" }
* ],
* keys: [
* { field: "Name", type: "text" },
* { field: "Gender", type: "value" }
* ]
* },
* {
* name: "Movies",
* fields: [
* { name: "Title", type: "string", primary: true },
* { name: "Plot", type: "string", store: "cache" },
* { name: "Year", type: "int" },
* { name: "Rating", type: "float" },
* { name: "Genres", type: "string_v", codebook: true }
* ],
* joins: [
* { name: "Actor", type: "index", store: "People", inverse: "ActedIn" },
* { name: "Director", type: "index", store: "People", inverse: "Directed" }
* ],
* keys: [
* { field: "Title", type: "value" },
* { field: "Plot", type: "text", vocabulary: "voc_01" },
* { field: "Genres", type: "value" }
* ]
* }]);
* base.close();
* @example &lt;caption>Creating store with schema in base constructor&lt;/caption>
* // import qm module
* var qm = require('qminer');
* // using the base constructor
* var base = new qm.Base({
* mode: "createClean",
* schema: [{
* name: "Class",
* fields: [
* { name: "Name", type: "string" },
* { name: "StudyGroup", type: "string" }
* ]
* }]
* });
* base.close();
*/
exports.Store = function (base, storeDef) { return Object.create(require('qminer').Store.prototype); };
/**
* Returns a record from the store.
* @param {string} recName - Record name.
* @returns {(module:qm.Record | null)} Returns the record. If the record doesn't exist, it returns `null`.
* @example
* // import qm module
* var qm = require('qminer');
* // create a base containing the store Class. Let the Name field be the primary field.
* var base = new qm.Base({
* mode: "createClean",
* schema: [{
* name: "Class",
* fields: [
* { name: "Name", type: "string", primary: true },
* { name: "StudyGroup", type: "string" }
* ]
* }]
* });
* // add some records to the store
* base.store("Class").push({ Name: "Dean", StudyGroup: "A" });
* base.store("Class").push({ Name: "Chang", StudyGroup: "D" });
* base.store("Class").push({ Name: "Magnitude", StudyGroup: "C" });
* base.store("Class").push({ Name: "Leonard", StudyGroup: "B" });
* // get the record with the name "Magnitude"
* var record = base.store("Class").recordByName("Magnitude");
* base.close();
*/
exports.Store.prototype.recordByName = function (recName) { return Object.create(require('qminer').Record.prototype); };
/**
* Executes a function on each record in store.
* @param {function} callback - Function to be executed. It takes two parameters:
* &lt;br>1. `rec` - The current record. Type {@link module:qm.Record}.
* &lt;br>2. `idx` - The index of the current record (&lt;i>optional&lt;/i>). Type `number`.
* @returns {module:qm.Store} Self.
* @example
* // import qm module
* var qm = require('qminer');
* // create a base containing the store Class
* var base = new qm.Base({
* mode: "createClean",
* schema: [{
* name: "Class",
* fields: [
* { name: "Name", type: "string" },
* { name: "StudyGroup", type: "string" }
* ]
* }]
* });
* // add some records to the store
* base.store("Class").push({ Name: "Abed", StudyGroup: "A" });
* base.store("Class").push({ Name: "Annie", StudyGroup: "B" });
* base.store("Class").push({ Name: "Britta", StudyGroup: "C" });
* base.store("Class").push({ Name: "Jeff", StudyGroup: "A" });
* // change the StudyGroup of all records of store Class to A
* base.store("Class").each(function (rec) { rec.StudyGroup = "A"; }); // all records in Class are now in study group A
* base.close();
*/
exports.Store.prototype.each = function (callback) { return Object.create(require('qminer').Store.prototype); }
/**
* Creates an array of function outputs created from the store records.
* @param {function} callback - Function that generates the array. It takes two parameters:
* &lt;br>1. `rec` - The current record. Type {@link module:qm.Record}.
* &lt;br>2. `idx` - The index of the current record (&lt;i>optional&lt;/i>). Type `number`.
* @returns {Array&lt;Object>} The array created by the callback function.
* @example
* // import qm module
* var qm = require('qminer');
* // create a base containing the store Class
* var base = new qm.Base({
* mode: "createClean",
* schema: [{
* name: "Class",
* fields: [
* { name: "Name", type: "string" },
* { name: "StudyGroup", type: "string" }
* ]
* }]
* });
* // add some records to the store
* base.store("Class").push({ Name: "Shirley", StudyGroup: "A" });
* base.store("Class").push({ Name: "Troy", StudyGroup: "B" });
* base.store("Class").push({ Name: "Chang", StudyGroup: "C" });
* base.store("Class").push({ Name: "Pierce", StudyGroup: "A" });
* // make an array of record names
* var arr = base.store("Class").map(function (rec) { return rec.Name; }); // returns an array ["Shirley", "Troy", "Chang", "Pierce"]
* base.close();
*/
exports.Store.prototype.map = function (callback) {}
/**
* Adds a record to the store.
* @param {object} rec - The added record. The record must be a object corresponding to store schema created at store creation using {@link module:qm~SchemaDef}.
* @param {boolean} [triggerEvents=true] - If true, all stream aggregate callbacks `onAdd` will be called after the record is inserted. If false, no stream aggregate will be updated.
* @returns {number} The ID of the added record.
* @example
* // import qm module
* var qm = require('qminer');
* // create a new base containing two stores
* var base = new qm.Base({
* mode: "createClean",
* schema: [
* {