LokiJS

https://techfort.github.io/LokiJS/
Admin
LokiJS is an in-memory JavaScript database with support for collections, queries, indexing, and...
Tokens:119,771
Snippets:934
Trust Score:9.7
Update:1 week ago
Show doc for...
Tokens:
Raw
### Full examples of using loki indexed adapter

Source: https://techfort.github.io/LokiJS/tutorial-Persistence%20Adapters.html

Shows how to save, load, list, delete, delete partitions, and get catalog summary using the Loki Indexed adapter. The save example uses 'finance' as the app context and 'test' as the database name; if appContext is omitted, 'loki' is used. The loadDatabase example passes a callback that logs 'done'. The getDatabaseList callback receives an array of string names. deleteDatabase removes the 'finance'/'test' entry. deleteDatabasePartitions deletes all partitions or pages derived from the base filename. getCatalogSummary provides entries with app, key, and size properties.

```javascript
  // Save : will save App/Key/Val as 'finance'/'test'/{serializedDb}
  // if appContect ('finance' in this example) is omitted, 'loki' will be used
  var idbAdapter = new lokiIndexedAdapter('finance');
  var db = new loki('test', { adapter: idbAdapter });
  var coll = db.addCollection('testColl');
  coll.insert({test: 'val'});
  db.saveDatabase();  // could pass callback if needed for async complete

  // Load database
  var idbAdapter = new LokiIndexedAdapter('finance');
  var db = new loki('test', { adapter: idbAdapter });
  db.loadDatabase({}, function(result) {
    console.log('done');
  });

  // Get database list
  var idbAdapter = new LokiIndexedAdapter('finance');
  idbAdapter.getDatabaseList(function(result) {
    // result is array of string names for that appcontext ('finance')
    result.forEach(function(str) {
      console.log(str);
    });
  });

  // Delete database
  var idbAdapter = new LokiIndexedAdapter('finance');
  idbAdapter.deleteDatabase('test'); // delete 'finance'/'test' value from catalog

  // Delete database partitions and/or pages
  // This deletes all partitions or pages derived from this base filename
  var idbAdapter = new LokiIndexedAdapter('finance');
  idbAdapter.deleteDatabasePartitions('test'); 

  // Summary
  var idbAdapter = new LokiIndexedAdapter('finance');
  idbAdapter.getCatalogSummary(function(entries) {
    entries.forEach(function(obj) {
      console.log("app : " + obj.app);
      console.log("key : " + obj.key);
      console.log("size : " + obj.size);
    });
  });
```

--------------------------------

### Install LokiJS with Bower

Source: https://techfort.github.io/LokiJS/tutorial-Loki%20Angular.html

Install the LokiJS library using Bower. This is the first step to use the Lokiwork service.

```bash
bower install lokijs
```

--------------------------------

### loadDatabase example with callback

Source: https://techfort.github.io/LokiJS/Loki.html

Example of loading a database using db.loadDatabase with a callback that logs errors or success. The callback receives an error object if loading fails.

```javascript
db.loadDatabase({}, function(err) {
  if (err) {
    console.log("error : " + err);
  }
  else {
    console.log("database loaded.");
  }
});
```

--------------------------------

### Further Example: Add Collection with Full JSON Object

Source: https://techfort.github.io/LokiJS/tutorial-Loki%20Angular.html

A complete example of adding a collection using a JSON object assigned to a variable. This is shown as a further example.

```javascript
var collection = {  
  "db":"settings",
  "collection": "globals" ,
  "documents" :
  [  
       {
      "name": "user settings",
      "brands" : true,
      "face" : "You now it"
       }
  ]
};
   Lokiwork.addCollection(collection);
```

--------------------------------

### $finite query example

Source: https://techfort.github.io/LokiJS/tutorial-Query%20Examples.html

Filters documents where a property is numeric or non-numeric. The example returns all docs where isFinite(doc.age) is true.

```javascript
// return all docs where isFinite(doc.age) === true
var results = users.find({ age: { $finite: true }});
```

--------------------------------

### Autosave with autoload example

Source: https://techfort.github.io/LokiJS/tutorial-Persistence%20Adapters.html

Configures a Loki database with autoload and autosave, using a callback to initialize the database if it does not exist.

```javascript
var idbAdapter = new lokiIndexedAdapter('loki');
    var db = new loki('test.db', 
      {
        autoload: true,
        autoloadCallback : loadHandler,
        autosave: true, 
        autosaveInterval: 10000, // 10 seconds
        adapter: idbAdapter
      }); 

    function loadHandler() {
      // if database did not exist it will be empty so I will intitialize here
      var coll = db.getCollection('entries');
      if (coll === null) {
        coll = db.addCollection('entries');
      }
    }
```

--------------------------------

### Autosave/Autoload Quickstart with LokiFsAdapter

Source: https://techfort.github.io/LokiJS/tutorial-Persistence%20Adapters.html

Configures a LokiJS database with autoload and autosave using the default LokiFsAdapter. The autoloadCallback initializes the database and runs bootstrap logic after loading.

```javascript
var db = new loki('quickstart.db', {
    autoload: true,
    autoloadCallback : databaseInitialize,
    autosave: true, 
    autosaveInterval: 4000
});

// implement the autoloadback referenced in loki constructor
function databaseInitialize() {
  var entries = db.getCollection("entries");
  if (entries === null) {
    entries = db.addCollection("entries");
  }

  // kick off any program logic or start listening to external events
  runProgramLogic();
}

// example method with any bootstrap logic to run after database initialized
function runProgramLogic() {
  var entryCount = db.getCollection("entries").count();
  console.log("number of entries in database : " + entryCount);
}
```

--------------------------------

### Binary index example with collection.find()

Source: https://techfort.github.io/LokiJS/tutorial-Indexing%20and%20Query%20performance.html

Shows how to create a binary index on the 'location' property and use find() with an equality query. Binary indices support $eq, $aeq, $lt, $lte, $gt, $gte, $between, and $in operations.

```javascript
var coll = db.addCollection('users', {
  indices: ['location']
});

// after inserting records you might use equality or range ops,
// such as this implicit (strict) $eq op :
var results = users.find({ location:  'Himinbjörg' });
```

--------------------------------

### eqJoin example

Source: https://techfort.github.io/LokiJS/lokijs.js.html

Example of using Resultset.eqJoin to join orders with product information. It creates a database, adds collections, inserts sample data, defines a map function, and performs the join.

```javascript
var db = new loki('sandbox.db');

var products = db.addCollection('products');
var orders = db.addCollection('orders');

products.insert({ productId: "100234", name: "flywheel energy storage", unitCost: 19999.99 });
products.insert({ productId: "140491", name: "300F super capacitor", unitCost: 129.99 });
products.insert({ productId: "271941", name: "fuel cell", unitCost: 3999.99 });
products.insert({ productId: "174592", name: "390V 3AH lithium bank", unitCost: 4999.99 });

orders.insert({ orderDate : new Date("12/1/2017").getTime(), prodId: "174592", qty: 2, customerId: 2 });
orders.insert({ orderDate : new Date("4/15/2016").getTime(), prodId: "271941", qty: 1, customerId: 1 });
orders.insert({ orderDate : new Date("3/12/2017").getTime(), prodId: "140491", qty: 4, customerId: 4 });
orders.insert({ orderDate : new Date("7/31/2017").getTime(), prodId: "100234", qty: 7, customerId: 3 });
orders.insert({ orderDate : new Date("8/3/2016").getTime(), prodId: "174592", qty: 3, customerId: 5 });

var mapfun = function(left, right) {
  return {
    orderId: left.$loki,
    orderDate: new Date(left.orderDate) + '',
    customerId: left.customerId,
    qty: left.qty,
    productId: left.prodId,
    prodName: right.name,
    prodCost: right.unitCost,
    orderTotal: +((right.unitCost * left.qty).toFixed(2))
  };
};

// join orders with relevant product info via eqJoin
var orderSummary = orders.chain().eqJoin(products, "prodId", "productId", mapfun).data();

console.log(orderSummary);
```

--------------------------------

### $len query example

Source: https://techfort.github.io/LokiJS/tutorial-Query%20Examples.html

Filters documents where a string property has a specified length. The example returns documents where 'name' is a 9 character string.

```javascript
users.insert([
  { name: 'odin', weapons: ['gungnir', 'draupnir'] },
  { name: 'thor', weapons: 'mjolnir' },
  { name: 'svafrlami', weapons: ['tyrfing'] },
  { name: 'arngrim', weapons: ['tyrfing'] }
]);

// returns docs where 'name' is a 9 character string (svafrllami)
var results = users.find({ 'name' : { '$len' : 9 } });
```

--------------------------------

### Reference mode adapter example

Source: https://techfort.github.io/LokiJS/tutorial-Persistence%20Adapters.html

Example of a custom LokiJS adapter supporting 'reference' mode. Set 'mode' to 'reference' and implement exportDatabase() and loadDatabase() methods. The exportDatabase method receives a database reference and must call the callback with an error or null. The loadDatabase method must reconstruct a database and call the callback with a serialized string or Loki instance.

```javascript
function YourAdapter() {
   this.mode = "reference";
}

YourAdapter.prototype.exportDatabase = function(dbname, dbref, callback) {
  this.customSaveLogic(dbref);

  var success = true; // make your own determinations

  if (success) {
    callback(null);
  }
  else {
    callback(new Error("some error occurred."));
  }
}

// reference mode uses the same loadDatabase method signature
YourAdapter.prototype.loadDatabase = function(dbname, callback) {
  // do some magic to reconstruct a new loki database object instance from wherever
  var newDatabase = this.customLoadLogic();

  var success = true; // make you own determinations

  // once reconstructed, loki will expect either a serialized response or a Loki object instance to reinflate from
  if (success) {
    callback(newSerialized);
  }
  else {
    callback(new Error("some error"));
  }
}
```

--------------------------------

### checkAllIndexes example

Source: https://techfort.github.io/LokiJS/Collection.html

Checks all binary indices on a collection and logs any invalid index names. The example passes repair, randomSampling, and randomSamplingFactor options to checkAllIndexes.

```javascript
// check all indices on a collection, returns array of invalid index names
var result = coll.checkAllIndexes({ repair: true, randomSampling: true, randomSamplingFactor: 0.15 });
if (result.length > 0) {
  results.forEach(function(name) { 
    console.log('problem encountered with index : ' + name); 
  });
}     
```

--------------------------------

### LokiIndexedAdapter console usage examples

Source: https://techfort.github.io/LokiJS/loki-indexed-adapter.js.html

Shows how to use the adapter for management and diagnostics via the console. Methods log results to console when no callback is passed.

```javascript
adapter.getDatabaseList(); // with no callback passed, this method will log results to console
adapter.saveDatabase('UserDatabase', JSON.stringify(myDb));
adapter.loadDatabase('UserDatabase'); // will log the serialized db to console
adapter.deleteDatabase('UserDatabase');
```

--------------------------------

### LokiIndexedAdapter loadDatabase example

Source: https://techfort.github.io/LokiJS/loki-indexed-adapter.js.html

Loads a serialized database from the catalog using the adapter. The callback receives the serialized db string or null if not found.

```javascript
// LOAD
var idbAdapter = new LokiIndexedAdapter('finance');
var db = new loki('test', { adapter: idbAdapter });
  db.loadDatabase(function(result) {
  console.log('done');
});
```

--------------------------------

### where(fun) query example

Source: https://techfort.github.io/LokiJS/Collection.html

Queries the collection by supplying a JavaScript filter function. The example filters documents where the 'legs' property equals 8.

```javascript
var results = coll.where(function(obj) {
  return obj.legs === 8;
});
```

--------------------------------

### LokiCatalog Constructor and initializeLokiCatalog - IndexedDB Setup

Source: https://techfort.github.io/LokiJS/loki-indexed-adapter.js.html

Defines the LokiCatalog class used by LokiIndexedAdapter for persistence. The constructor initializes the database reference and calls initializeLokiCatalog. The initializeLokiCatalog method opens the 'LokiCatalog' database with version 1, deletes the 'LokiAKV' object store if it exists, and recreates it with indexes on 'app', 'key', and a unique 'appkey' index to simulate a composite key.

```javascript
    function LokiCatalog(callback)
    {
      this.db = null;
      this.initializeLokiCatalog(callback);
    }

    LokiCatalog.prototype.initializeLokiCatalog = function(callback) {
      var openRequest = indexedDB.open('LokiCatalog', 1);
      var cat = this;

      // If database doesn't exist yet or its version is lower than our version specified above (2nd param in line above)
      openRequest.onupgradeneeded = function(e) {
        var thisDB = e.target.result;
        if (thisDB.objectStoreNames.contains('LokiAKV')) {
          thisDB.deleteObjectStore('LokiAKV');
        }

        if(!thisDB.objectStoreNames.contains('LokiAKV')) {
          var objectStore = thisDB.createObjectStore('LokiAKV', { keyPath: 'id', autoIncrement:true });
          objectStore.createIndex('app', 'app', {unique:false});
          objectStore.createIndex('key', 'key', {unique:false});
          // hack to simulate composite key since overhead is low (main size should be in val field)
          // user (me) required to duplicate the app and key into comma delimited appkey field off object
          // This will allow retrieving single record with that composite key as well as
          // still supporting opening cursors on app or key alone
          objectStore.createIndex('appkey', 'appkey', {unique:true});
        }
      };
    };
```

--------------------------------

### mapReduce example

Source: https://techfort.github.io/LokiJS/lokijs.js.html

Example of using Resultset.mapReduce to sum order totals. The map function extracts orderTotal from each order, and the reduce function sums them.

```javascript
var mapfun = function(order) {
  return order.orderTotal;
};
var reducefun = function(array) {
  var grandTotal = 0;
  array.forEach(function(orderTotal) { grandTotal += orderTotal; });
  return grandTotal;
}
var grandOrderTotal = orders.chain().mapReduce(mapfun, reducefun);
console.log(grandOrderTotal);
```

--------------------------------

### $size query example

Source: https://techfort.github.io/LokiJS/tutorial-Query%20Examples.html

Filters documents where an array property has a specified size. Does not work for strings. The example returns documents where 'weapons' is a 2-element array.

```javascript
users.insert([
  { name: 'odin', weapons: ['gungnir', 'draupnir'] },
  { name: 'thor', weapons: 'mjolnir' },
  { name: 'svafrlami', weapons: ['tyrfing'] },
  { name: 'arngrim', weapons: ['tyrfing'] }
]);

// returns docs where 'weapons' are 2-element arrays (odin)
var results = users.find({ 'weapons' : { '$size' : 2 } });
```

--------------------------------

### LokiIndexedAdapter constructor example

Source: https://techfort.github.io/LokiJS/loki-indexed-adapter.js.html

Creates a new LokiIndexedAdapter instance with an optional application name context. The appname defaults to 'loki' if not provided.

```javascript
var idbAdapter = new LokiIndexedAdapter('finance');
```

--------------------------------

### Autosave example with LokiIndexedAdapter

Source: https://techfort.github.io/LokiJS/tutorial-Persistence%20Adapters.html

Configures a Loki database with autosave enabled, saving every 10 seconds using an IndexedDB adapter.

```javascript
var idbAdapter = new LokiIndexedAdapter('loki');
    var db = new loki('test', 
      {
        autosave: true, 
        autosaveInterval: 10000, // 10 seconds
        adapter: idbAdapter
      });
```

--------------------------------

### saveDatabase example with callback

Source: https://techfort.github.io/LokiJS/Loki.html

Example of saving a database using db.saveDatabase with a callback that logs errors or success. The callback receives an error object if saving fails.

```javascript
db.saveDatabase(function(err) {
  if (err) {
    console.log("error : " + err);
  }
  else {
    console.log("database saved.");
  }
});
```

--------------------------------

### Resultset.limit example: find two oldest users

Source: https://techfort.github.io/LokiJS/lokijs.js.html

Returns a copy of the resultset limited by qty for subsequent chain operations. The example finds the two oldest users by chaining simplesort with descending order and limit(2).

```javascript
var result = users.chain().simplesort("age", true).limit(2).data();
```

--------------------------------

### LokiFsStructuredAdapter Example

Source: https://techfort.github.io/LokiJS/tutorial-Persistence%20Adapters.html

Uses the LokiFsStructuredAdapter for high performance and scalability, streaming the database line by line and saving each collection to its own file. Configures autoload and autosave with a callback that initializes a collection and inserts sample data.

```javascript
const loki = require("lokijs");
const lfsa = require('../src/loki-fs-structured-adapter.js');

var adapter = new lfsa();
var db = new loki('sandbox.db', { 
  adapter : adapter,
  autoload: true,
  autoloadCallback : databaseInitialize,
  autosave: true, 
  autosaveInterval: 4000
});

function databaseInitialize() {
  var log = db.getCollection("log");

  if (log === null) {
    db.addCollection("log");
  }

  // log some random event data as part of our example
  log.insert({ event: 'dbinit', dt: (new Date()).getTime() });
}
```

--------------------------------

### List databases with LokiIndexedAdapter

Source: https://techfort.github.io/LokiJS/loki-indexed-adapter.js.html

Example usage of getDatabaseList: retrieves an array of database names for the current app context and logs each name.

```javascript
idbAdapter.getDatabaseList(function(result) {
  // result is array of string names for that appcontext ('finance')
  result.forEach(function(str) {
    console.log(str);
  });
});
```

--------------------------------

### Core find, resultset chaining, and where method examples

Source: https://techfort.github.io/LokiJS/tutorial-Query%20Examples.html

Three equivalent ways to query documents with Age >= 40: using the collection's find method, chaining find on a resultset, and using the where method with a JavaScript predicate.

```javascript
// Core collection 'find' method
var results = coll.find({'Age': {'$gte': 40}});

// Resultset chaining
results = coll.chain().find({'Age': {'$gte': 40}}).data();

// Core collection 'where' method
results = coll.where(function(obj) {
    return obj.Age >= 40;
});
```

--------------------------------

### No Persistence Example (In-Memory)

Source: https://techfort.github.io/LokiJS/tutorial-Persistence%20Adapters.html

Creates a LokiJS database entirely in memory without persistence. Inserts documents into a collection and queries with a filter, logging the result to the console.

```javascript
const loki = require("lokijs");

var db = new loki("quickstart.db");
var users = db.addCollection("users");

users.insert({name:'odin', age: 50});
users.insert({name:'thor', age: 35});

var result = users.find({ age : { $lte: 35 } });

// dumps array with 1 doc (thor) to console
console.log(result);
```

--------------------------------

### Examples of using loki Indexed adapter from console

Source: https://techfort.github.io/LokiJS/tutorial-Persistence%20Adapters.html

Shows console usage for management and diagnostics. When no callback is passed, methods like getDatabaseList and getCatalogSummary log results to the console. saveDatabase stores a serialized database under a given key, loadDatabase logs the serialized db, and deleteDatabase removes the entry.

```javascript
  // CONSOLE USAGE : if using from console for management/diagnostic, here are a few examples :
  var adapter = new LokiIndexedAdapter('loki');  // or whatever appContext you want to use
  adapter.getDatabaseList(); // with no callback passed, this method will log results to console
  adapter.saveDatabase('UserDatabase', JSON.stringify(myDb));
  adapter.loadDatabase('UserDatabase'); // will log the serialized db to console
  adapter.deleteDatabase('UserDatabase');
  adapter.getCatalogSummary(); // gets list of all keys along with their sizes
```

--------------------------------

### loadDatabase method - reads database catalog and loads collections

Source: https://techfort.github.io/LokiJS/loki-fs-structured-adapter.js.html

This method reads the database catalog file (dbname) and, if it exists, parses the JSON to get the collections array, then recursively loads each collection file. If the file does not exist, it calls the callback with null.

```javascript
      self.dbref = JSON.parse(line);
    }
  });

  // when that is done, examine its collection array to sequence loading each
  rl.on('close', function() {
    if (self.dbref.collections.length > 0) {
      self.loadNextCollection(dbname, 0, function() {
        callback(self.dbref);
      });
    }
  });
}
else {
  // file does not exist, so callback with null
  callback(null);
}
});
};
```

--------------------------------

### new LokiPartitioningAdapter(adapter, optionsopt)

Source: https://techfort.github.io/LokiJS/LokiPartitioningAdapter.html

Constructor for LokiPartitioningAdapter. Initializes the adapter with a reference to a non-reference mode adapter and optional configuration for partitioning and paging.

```APIDOC
## new LokiPartitioningAdapter(adapter, optionsopt)

### Description
Creates a new LokiPartitioningAdapter instance. This adapter converts a non-reference mode adapter into a reference mode adapter that can perform destructuring and partitioning. Each collection is stored in its own key/save, and only dirty collections are saved. Paging mode can be enabled to handle large collections.

### Parameters
- **adapter** (object) - Required - Reference to a 'non-reference' mode loki adapter instance.
- **options** (object) - Optional - Configuration options for partitioning and paging.

#### Options Properties
- **paging** (bool) - Optional - Default: false. Set to true to enable paging collection data.
- **pageSize** (int) - Optional - Default: 25MB. Limit the size of strings passed to inner adapter.
- **delimiter** (string) - Optional - Override the default delimiter.

### Source
- lokijs.js, line 1914
```

--------------------------------

### Create a LokiJS database

Source: https://techfort.github.io/LokiJS/index.html

Creates a LokiJS database instance named 'example.db'. This is the first step before adding collections.

```javascript
var db = new loki('example.db');
```

--------------------------------

### $type query example

Source: https://techfort.github.io/LokiJS/tutorial-Query%20Examples.html

Filters documents where a property is of a specified type. The example returns documents where 'weapons' is a string (non-array).

```javascript
users.insert([
  { name: 'odin', weapons: ['gungnir', 'draupnir'] },
  { name: 'thor', weapons: 'mjolnir' },
  { name: 'svafrlami', weapons: ['tyrfing'] },
  { name: 'arngrim', weapons: ['tyrfing'] }
]);

// returns docs with (non-array) string value for 'weapons' (mjolnir)
var results = users.find({ 'weapons' : { '$type' : 'string' } });
```

--------------------------------

### get(id, returnPosition) → {object|array|null}

Source: https://techfort.github.io/LokiJS/Collection.html

Gets a document by its $loki id. Faster than other methods due to the searching algorithm.

```APIDOC
## get(id, returnPosition) → {object|array|null}

### Description
Get by Id - faster than other methods because of the searching algorithm.

### Method
get

### Parameters
- **id** (int) - Required - $loki id of document you want to retrieve.
- **returnPosition** (boolean) - Required - If 'true' we will return [object, position].

### Returns
Object reference if document was found, null if not, or an array if 'returnPosition' was passed.

Type: object | array | null

### Source
- lokijs.js, line 6117
```

--------------------------------

### Add Document with Lokiwork.addDocument

Source: https://techfort.github.io/LokiJS/tutorial-Loki%20Angular.html

Add a new document to a collection. The example shows passing a variable doc_obj; the comment indicates an example below.

```javascript
Lokiwork.addDocument("settings", "globals", doc_obj); //example below
```

--------------------------------

### LokiIndexedAdapter saveDatabase example

Source: https://techfort.github.io/LokiJS/loki-indexed-adapter.js.html

Saves a serialized database to the catalog under the app name and database name. The example shows the App/Key/Val structure.

```javascript
// SAVE : will save App/Key/Val as 'finance'/'test'/{serializedDb}
var idbAdapter = new LokiIndexedAdapter('finance');
```

--------------------------------

### loadDatabase(options, callback)

Source: https://techfort.github.io/LokiJS/lokijs.js.html

Loads the database from the configured persistence adapter. This method handles manual loading from file system, local storage, or adapter (such as indexeddb). It utilizes loki configuration options to determine which persistence method to use, or environment detection if configuration was not provided. To avoid contention with any throttledSaves, it will drain the save queue first. If you are configured with autosave, you do not need to call this method yourself.

```APIDOC
## loadDatabase(options, callback)

### Description
Loads the database from the configured persistence adapter. This method handles manual loading from file system, local storage, or adapter (such as indexeddb). It utilizes loki configuration options to determine which persistence method to use, or environment detection if configuration was not provided. To avoid contention with any throttledSaves, it will drain the save queue first. If you are configured with autosave, you do not need to call this method yourself.

### Method
loadDatabase

### Parameters
#### Options (object)
- **recursiveWait** (boolean) - Optional - (default: true) wait recursively until no saves are queued
- **recursiveWaitLimit** (boolean) - Optional - (default: false) limit our recursive waiting to a duration
- **recursiveWaitLimitDelay** (int) - Optional - (default: 2000) cutoff in ms to stop recursively re-draining

#### Callback (function)
- **callback** (function) - Optional - user supplied async callback / error handler

### Example
```javascript
db.loadDatabase({}, function(err) {
  if (err) {
    console.log("error : " + err);
  }
  else {
    console.log("database loaded.");
  }
});
```

### Response
#### Success
- **err** (null) - No error, load successful.

#### Error
- **err** (Error) - Error object if load failed.

```

--------------------------------

### new Loki(filename, options)

Source: https://techfort.github.io/LokiJS/Loki.html

Creates a new Loki database instance. The constructor accepts a filename and optional configuration options for environment, autosave, autoload, and serialization.

```APIDOC
## new Loki(filename, options)

### Description
Creates a new Loki database instance.

### Constructor
new Loki(filename, options)

### Parameters
- **filename** (string) - Required - Name of the file to be saved to.
- **options** (object) - Optional - Configuration options object.

#### Options Properties
- **env** (string) - Optional - Override environment detection as 'NODEJS', 'BROWSER', 'CORDOVA'.
- **verbose** (boolean) - Optional - Enable console output. Default: false.
- **autosave** (boolean) - Optional - Enables autosave. Default: false.
- **autosaveInterval** (int) - Optional - Time interval (in milliseconds) between saves (if dirty). Default: 5000.
- **autoload** (boolean) - Optional - Enables autoload on loki instantiation. Default: false.
- **autoloadCallback** (function) - Optional - User callback called after database load.
- **adapter** (adapter) - Optional - An instance of a loki persistence adapter.
- **serializationMethod** (string) - Optional - ['normal', 'pretty', 'destructured']. Default: 'normal'.
- **destructureDelimiter** (string) - Optional - String delimiter used for destructured serialization.
- **throttledSaves** (boolean) - Optional - Debounces multiple calls to saveDatabase. Default: true.

### Implements
- LokiEventEmitter

### Source
- lokijs.js, line 764
```

--------------------------------

### $undefinedin query example

Source: https://techfort.github.io/LokiJS/tutorial-Query%20Examples.html

Filters documents where the 'maker' property is not defined on the passed object. The example returns documents with maker 'mjolnir' and 'tyrfing'.

```javascript
// returns mjolnir and tyrfing where the 'dwarves' val is not a property on our passed object
var results = items.find({maker: { $undefinedin: { elves: 'rule' } } });
```

--------------------------------

### configureOptions(options, initialConfig)

Source: https://techfort.github.io/LokiJS/Loki.html

Allows reconfiguring database options.

```APIDOC
## configureOptions(options, initialConfig)

### Description
Allows reconfiguring database options.

### Method
configureOptions

### Parameters
- **options** (object) - Required - Configuration options to apply to loki db object.
- **initialConfig** (boolean) - Required - (internal) true is passed when loki ctor is invoking.

#### Options Properties
- **env** (string) - Override environment detection as 'NODEJS', 'BROWSER', 'CORDOVA'.
- **verbose** (boolean) - Enable console output (default is 'false').
- **autosave** (boolean) - Enables autosave.
- **autosaveInterval** (int) - Time interval (in milliseconds) between saves (if dirty).
- **autoload** (boolean) - Enables autoload on loki instantiation.
- **autoloadCallback** (function) - User callback called after database load.
- **adapter** (adapter) - An instance of a loki persistence adapter.
- **serializationMethod** (string) - ['normal', 'pretty', 'destructured'].
- **destructureDelimiter** (string) - String delimiter used for destructured serialization.

### Source
- lokijs.js, line 905
```

--------------------------------

### $containsNone query example

Source: https://techfort.github.io/LokiJS/tutorial-Query%20Examples.html

Filters documents where a property contains none of the provided values. The example returns documents with 'weapons' not containing 'gungnir' or 'mjolnir'.

```javascript
users.insert({ name : 'odin', weapons : ['gungnir', 'draupnir']});
users.insert({ name : 'thor', weapons : ['mjolnir']});
users.insert({ name : 'svafrlami', weapons : ['tyrfing']});
users.insert({ name : 'arngrim', weapons : ['tyrfing']});

// returns 'svafrlami' and 'arngrim'
results = users.find({ 'weapons' : { '$containsNone' : ['gungnir', 'mjolnir'] } });
```

--------------------------------

### Add Collection with Lokiwork.addCollection

Source: https://techfort.github.io/LokiJS/tutorial-Loki%20Angular.html

Add a new collection to a database using a JSON object. The example shows passing a variable item; a further example is provided below.

```javascript
Lokiwork.addCollection(item); // example below
```

--------------------------------

### new Collection(name, optionsopt)

Source: https://techfort.github.io/LokiJS/Collection.html

Creates a new Collection instance that handles documents of the same type. Accepts a collection name and optional configuration options.

```APIDOC
## new Collection(name, optionsopt)

### Description
Collection class that handles documents of same type

### Parameters
| Name | Type | Attributes | Description |
|------|------|------------|-------------|
| `name` | string | | collection name |
| `options` | array | object | <optional> (optional) array of property names to be indicized OR a configuration object |

#### Properties
| Name | Type | Attributes | Default | Description |
|------|------|------------|---------|-------------|
| `unique` | array | <optional> | [] | array of property names to define unique constraints for |
| `exact` | array | <optional> | [] | array of property names to define exact constraints for |
| `indices` | array | <optional> | [] | array property names to define binary indexes for |
| `adaptiveBinaryIndices` | boolean | <optional> | true | collection indices will be actively rebuilt rather than lazily |
| `asyncListeners` | boolean | <optional> | false | whether listeners are invoked asynchronously |
| `disableMeta` | boolean | <optional> | false | set to true to disable meta property on documents |
| `disableChangesApi` | boolean | <optional> | true | set to false to enable Changes API |
| `disableDeltaChangesApi` | boolean | <optional> | true | set to false to enable Delta Changes API (requires Changes API, forces cloning) |
| `autoupdate` | boolean | <optional> | false | use Object.observe to update objects automatically |
| `clone` | boolean | <optional> | false | specify whether inserts and queries clone to/from user |
| `serializableIndices` | boolean | <optional> | true[] | converts date values on binary indexed properties to epoch time |
| `cloneMethod` | string | <optional> | 'parse-stringify' | 'parse-stringify', 'jquery-extend-deep', 'shallow', 'shallow-assign' |
| `ttl` | int | <optional> | | age of document (in ms.) before document is considered aged/stale. |
| `ttlInterval` | int | <optional> | | time interval for clearing out 'aged' documents; not set by default. |

### Implements
- LokiEventEmitter

### Source
- lokijs.js, line 4654

### See
- Loki#addCollection for normal creation of collections
```

--------------------------------

### Instantiate LokiIndexedAdapter and create Loki database

Source: https://techfort.github.io/LokiJS/tutorial-Persistence%20Adapters.html

Create a LokiIndexedAdapter with an 'App' context (e.g., 'finance') and pass it to a new Loki database instance. The database name 'test' becomes the key in IndexedDB.

```javascript
var idbAdapter = new LokiIndexedAdapter('finance');
var db = new loki('test', { adapter: idbAdapter });
```

--------------------------------

### Open IndexedDB and set onsuccess/onerror handlers

Source: https://techfort.github.io/LokiJS/loki-indexed-adapter.js.html

Sets up the onsuccess and onerror handlers for the IndexedDB open request. On success, assigns the database to cat.db and invokes the callback. On error, throws the event.

```javascript
openRequest.onsuccess = function(e) {
  cat.db = e.target.result;

  if (typeof (callback) === 'function') callback(cat);
};

openRequest.onerror = function(e) {
  throw e;
};
```

--------------------------------

### Create a DynamicView and apply filters

Source: https://techfort.github.io/LokiJS/DynamicView.html

Shows how to create a DynamicView using Collection.addDynamicView, apply a find filter and a where filter, and retrieve the results with data().

```javascript
var mydv = mycollection.addDynamicView('test');  // default is non-persistent
mydv.applyFind({ 'doors' : 4 });
mydv.applyWhere(function(obj) { return obj.name === 'Toyota'; });
var results = mydv.data();
```

--------------------------------

### Lookup using autogenerated $loki column

Source: https://techfort.github.io/LokiJS/tutorial-Indexing%20and%20Query%20performance.html

Shows how to insert a document and retrieve it using the auto-generated $loki id with the get() method. After insertion, the object gets a $loki property.

```javascript
var users = db.addCollection("users");
var resultObj = users.insert({username:"Heimdallr"});

// now that our object has been inserted, it will have a $loki property added onto it
var heimdallr = users.get(resultObj.$loki);
```

--------------------------------

### new LokiFsAdapter()

Source: https://techfort.github.io/LokiJS/LokiFsAdapter.html

Constructor for the LokiFsAdapter class. Creates a new instance of the adapter.

```APIDOC
## new LokiFsAdapter()

### Description
Creates a new LokiFsAdapter instance. This adapter persists LokiJS database data using the Node.js fs module.

### Constructor
`new LokiFsAdapter()`

### Parameters
None.

### Source
- lokijs.js, line 2248
```

--------------------------------

### $containsAny query example

Source: https://techfort.github.io/LokiJS/tutorial-Query%20Examples.html

Filters documents where a property contains any of the provided values. Use when property is an array and compare value is an array. The example returns documents with 'weapons' containing 'tyrfing' or 'mjolnir'.

```javascript
users.insert({ name : 'odin', weapons : ['gungnir', 'draupnir']});
users.insert({ name : 'thor', weapons : ['mjolnir']});
users.insert({ name : 'svafrlami', weapons : ['tyrfing']});
users.insert({ name : 'arngrim', weapons : ['tyrfing']});

// returns 'svafrlami', 'arngrim', and 'thor' documents
results = users.find({ 'weapons' : { '$containsAny' : ['tyrfing', 'mjolnir'] } });
```

--------------------------------

### Loki.prototype.configureOptions

Source: https://techfort.github.io/LokiJS/lokijs.js.html

Configures the Loki instance with user-provided options, setting up persistence adapters, autosave, autoload, and serialization settings.

```APIDOC
## Loki.prototype.configureOptions

### Description
Configures the Loki instance with user-provided options, setting up persistence adapters, autosave, autoload, and serialization settings.

### Method
configureOptions(options, initialConfig)

### Parameters
- **options** (object) - Required - Configuration options for the Loki instance.
  - **autosave** (boolean) - Optional - Enables autosave.
  - **autosaveInterval** (int) - Optional - Time interval (in milliseconds) between saves (if dirty).
  - **autoload** (boolean) - Optional - Enables autoload on loki instantiation.
  - **autoloadCallback** (function) - Optional - User callback called after database load.
  - **adapter** (adapter) - Optional - An instance of a loki persistence adapter.
  - **serializationMethod** (string) - Optional - ['normal', 'pretty', 'destructured'].
  - **destructureDelimiter** (string) - Optional - String delimiter used for destructured serialization.
- **initialConfig** (boolean) - Optional - (internal) true is passed when loki ctor is invoking.

### Description
This method processes the options object to set up persistence, autosave, autoload, and serialization settings. It also sets default persistence methods based on the environment if no adapter is specified.
```

--------------------------------

### $contains query example

Source: https://techfort.github.io/LokiJS/tutorial-Query%20Examples.html

Filters documents where a property contains the provided value. Works with strings (substring match), arrays (value existence), and objects (property existence). The example returns documents with 'weapons' containing 'tyrfing'.

```javascript
users.insert({ name : 'odin', weapons : ['gungnir', 'draupnir']});
users.insert({ name : 'thor', weapons : ['mjolnir']});
users.insert({ name : 'svafrlami', weapons : ['tyrfing']});
users.insert({ name : 'arngrim', weapons : ['tyrfing']});

// returns 'svafrlami' and 'arngrim' documents
var results = users.find({ 'weapons' : { '$contains' : 'tyrfing' } });
```

--------------------------------

### Basic partitioning with LokiIndexedAdapter

Source: https://techfort.github.io/LokiJS/tutorial-Persistence%20Adapters.html

Creates a LokiPartitioningAdapter wrapping a LokiIndexedAdapter and uses it as the adapter for a Loki database. This splits the database per collection, raising Chrome's IndexedDB chunk limit from per-db to per-collection.

```javascript
var idbAdapter = new LokiIndexedAdapter('appAdapter');
var pa = new loki.LokiPartitioningAdapter(idbAdapter);

var db = new loki('sandbox.db', { adapter: pa });
```

--------------------------------

### $or query example

Source: https://techfort.github.io/LokiJS/tutorial-Query%20Examples.html

Filters documents meeting any of the nested subexpressions.

```javascript
// fetch documents matching any of the sub-expressions
var results = coll.find({
  '$or': [{ 
      'age' : {
        '$gte': '40'
      }
    },{
      'name' : 'Thor'
    }]
});
```

--------------------------------

### LokiIndexedAdapter.prototype.getCatalogSummary - Retrieve Catalog Summary

Source: https://techfort.github.io/LokiJS/loki-indexed-adapter.js.html

Retrieves all keys in the catalog along with their sizes. Lazily initializes the catalog if needed. For each entry, it computes a size estimate by doubling the app and key lengths and adding the value length plus one. Results are passed to the callback as an array of objects with app, key, and size properties, or logged to console if no callback is provided.

```javascript
      var appName = this.app;
      var adapter = this;

      // lazy open/create db reference
      if (this.catalog === null || this.catalog.db === null) {
        this.catalog = new LokiCatalog(function(cat) {
          adapter.catalog = cat;

          adapter.getCatalogSummary(callback);
        });

        return;
      }

      // catalog already initialized
      // get all keys for current appName, and transpose results so just string array
      this.catalog.getAllKeys(function(results) {
        var entries = [];
        var obj,
          size,
          oapp,
          okey,
          oval;

        for(var idx = 0; idx < results.length; idx++) {
          obj = results[idx];
          oapp = obj.app || '';
          okey = obj.key || '';
          oval = obj.val || '';

          // app and key are composited into an appkey column so we will mult by 2
          size = oapp.length * 2 + okey.length * 2 + oval.length + 1;

          entries.push({ "app": obj.app, "key": obj.key, "size": size });
        }

        if (typeof (callback) === 'function') {
          callback(entries);
        }
        else {
          entries.forEach(function(obj) {
            console.log(obj);
          });
        }
      });
    };
```

--------------------------------

### Get Collection with Lokiwork.getCollection

Source: https://techfort.github.io/LokiJS/tutorial-Loki%20Angular.html

Retrieve a collection from a database by name.

```javascript
Lokiwork.getCollection('settings', 'globals');
```

--------------------------------

### Get Current Document with Lokiwork.getCurrentDoc

Source: https://techfort.github.io/LokiJS/tutorial-Loki%20Angular.html

Retrieve the currently set document from the Lokiwork service.

```javascript
Lokiwork.getCurrentDoc();
```

--------------------------------

### Collection.prototype.startTransaction

Source: https://techfort.github.io/LokiJS/lokijs.js.html

Starts a transaction if the collection is transactional. Caches the current data and indexes for rollback.

```APIDOC
## Collection.prototype.startTransaction()

### Description
Starts a transaction if the collection is transactional. Caches the current data and indexes for rollback. Also propagates to dynamic views.

### Method
startTransaction

### Parameters
None

### Returns
- **undefined** - No return value.

### Example
```javascript
collection.startTransaction();
```
```

--------------------------------

### loadDatabase(dbname, callback)

Source: https://techfort.github.io/LokiJS/LokiFsStructuredAdapter.html

Loads a database from the filesystem and outputs an un-prototype db object reference.

```APIDOC
## loadDatabase(dbname, callback)

### Description
Loki persistence adapter interface function which outputs un-prototype db object reference to load from.

### Method
N/A (SDK method)

### Parameters
- **dbname** (string) - Required - The name of the database to retrieve.
- **callback** (function) - Required - Callback should accept string param containing db object reference.

### Returns
No return value documented.
```

--------------------------------

### rollback()

Source: https://techfort.github.io/LokiJS/lokijs.js.html

Rolls back a transaction. Restores the resultset to the state saved at the start of the transaction.

```APIDOC
## rollback()

### Description
Rolls back a transaction. Restores the resultset to the state saved at the start of the transaction.

### Method
rollback

### Returns
- **DynamicView** - this DynamicView object, for further chain ops.
```

--------------------------------

### new LokiLocalStorageAdapter()

Source: https://techfort.github.io/LokiJS/LokiLocalStorageAdapter.html

Creates a new instance of the LokiLocalStorageAdapter, which persists data to the browser's local storage.

```APIDOC
## new LokiLocalStorageAdapter()

### Description
Creates a new LokiLocalStorageAdapter instance. This adapter persists LokiJS databases to the web browser's local storage object.

### Constructor
`new LokiLocalStorageAdapter()`

### Parameters
None.

### Source
- lokijs.js, line 2324

```

--------------------------------

### Get Document by Identifier with Lokiwork.getDoc

Source: https://techfort.github.io/LokiJS/tutorial-Loki%20Angular.html

Retrieve a specific document from a collection using a document identifier object.

```javascript
Lokiwork.getDoc("settings", "globals", {name:"user settings"});
```

--------------------------------

### loadDatabase(options, callbackopt)

Source: https://techfort.github.io/LokiJS/Loki.html

Manually loads the database from file system, local storage, or an adapter. This method drains the save queue to avoid contention with throttled saves.

```APIDOC
## loadDatabase(options, callbackopt)

### Description
Handles manually loading from file system, local storage, or adapter (such as indexeddb). This method utilizes loki configuration options (if provided) to determine which persistence method to use, or environment detection (if configuration was not provided). To avoid contention with any throttledSaves, it drains the save queue first. If you are configured with autosave, you do not need to call this method yourself.

### Method
loadDatabase

### Parameters
#### options (object) - Required
- **recursiveWait** (boolean) - (default: true) wait recursively until no saves are queued
- **recursiveWaitLimit** (bool) - (default: false) limit our recursive waiting to a duration
- **recursiveWaitLimitDelay** (int) - (default: 2000) cutoff in ms to stop recursively re-draining

#### callback (function) - Optional
(Optional) user supplied async callback / error handler

### Example
```
db.loadDatabase({}, function(err) {
  if (err) {
    console.log("error : " + err);
  }
  else {
    console.log("database loaded.");
  }
});
```
```

--------------------------------

### Simple chaining query

Source: https://techfort.github.io/LokiJS/index.html

Chains a find and a simplesort to get documents with age >= 35 sorted by name.

```javascript
var results = users.chain().find({ age: {'$gte': 35} }).simplesort('name').data();
```

--------------------------------

### Delete database with LokiIndexedAdapter

Source: https://techfort.github.io/LokiJS/loki-indexed-adapter.js.html

Example usage of deleteDatabase: deletes the 'finance'/'test' value from the catalog. The callback is executed after deletion.

```javascript
// DELETE DATABASE
// delete 'finance'/'test' value from catalog
idbAdapter.deleteDatabase('test', function {
  // database deleted
});
```
Tokens:
Raw