v0.14.0 & v0.0.3@react

BREAKING CHANGES

removeMany now returns the number of items deleted, not a boolean that states whether all items have been deleted.

If you still need to check whether all entities you provided have been deleted, you can rewrite your removeMany calls.

Before:

const allEntitiesDeleted = await removeMany(table, [{ id: "0" }, { id: "1" }]);

After:

const items = [{ id: "0" }, { id: "1" }];
const numDeleted = await removeMany(table, items);
const allEntitiesDeleted = numDeleted === items.length;

What's Changed

• missing keys in removeWhere is no-op by @retorquere in #30
• Changed removeMany to return number of items deleted

New Contributors

• @retorquere made their first contribution in #30

Full Changelog: v0.13.3...v0.14.0

v0.0.2@react

What's changed

• Fixed #24, where changing the query parameters of useMany exported by the blinkdb@react package did not update watch

v0.13.3

What's changed

⚡ v0.13.3 is primarily a performance release. While blinkDB is a read optimized database, this time we heavily optimized insertions.

• Fixed issue with failing benchmarks. Some benchmarks were throwing errors that were not reported back to the runner, and the benchmarking framework was not running prerequisite hooks on warmup, leading to false reports. These issues have been fixed, and benchmarks like insertMany now report back correctly.
• insertMany performance optimizations. Thanks to @Valerionn, insertMany is now up to +45% faster by removing the need to allocate event objects if no events are registered on insert.
• general performance optimizations. All blinkDB packages now compile directly to ES6, and public functions return Promises directly instead of using the async function modifier. Because this removes the need for TS to include wrapper functions for async code, which is a constant overhead, this resulted in an increase of performance in all public functions in the blinkdb package ranging from +5% (O(n log n) operations like insertMany & upsertMany) to +80% (O(1) operations like count).

As an example, on the insert-many benchmark, BlinkDB went from this:

blinkdb/insert-many.ts --- lokijs is 1.51x faster than blinkdb
┌─────────┬───────────┬───────────────────┬────────────────────┬───────────┬─────────┐
│ (index) │   name    │      ops/sec      │ Average Time (ns)  │  Margin   │ Samples │
├─────────┼───────────┼───────────────────┼────────────────────┼───────────┼─────────┤
│    0    │ 'lokijs'  │ 256.3883418534088 │ 3900333.3488999065 │ '±8.15%'  │   129   │
│    1    │ 'blinkdb' │ 169.8885317147108 │ 5886212.505969931  │ '±17.15%' │   85    │
└─────────┴───────────┴───────────────────┴────────────────────┴───────────┴─────────┘

to this:

blinkdb/insert-many.ts --- blinkdb is 1.04x faster than lokijs
┌─────────┬───────────┬───────────────────┬────────────────────┬───────────┬─────────┐
│ (index) │   name    │      ops/sec      │ Average Time (ns)  │  Margin   │ Samples │
├─────────┼───────────┼───────────────────┼────────────────────┼───────────┼─────────┤
│    0    │ 'blinkdb' │ 310.7162169122418 │ 3218370.801297566  │ '±10.35%' │   156   │
│    1    │ 'lokijs'  │ 298.5117428378887 │ 3349951.9666905203 │ '±9.36%'  │   150   │
└─────────┴───────────┴───────────────────┴────────────────────┴───────────┴─────────┘

Full Changelog: v0.13.2...v0.13.3

v0.13.2

What's changed

• The blinkdb & @blinkdb/react package now target es6 instead of es5 to prevent transpilation of classes.

Full Changelog: v0.13.1...v0.13.2

v0.13.1

What's changed

• Fixed issue with incorrect type causing type inference problems: #20

v0.13.0

What's changed

• 📖 blinkDB has new docs! Check them out at https://blinkdb.io.
• 🚀 The React package @blinkdb/react for blinkDB is out!
  • The documentation is available at https://blinkdb.io/docs/react
• isValidEntity() was implemented for checking if an object is valid for a table. See more here

Full Changelog: v0.12.2...v0.13.0

v0.12.2

What's Changed

• fix: broken filters link on changes.mdx by @ThaisRobba in #17
• fix: export query types #15

New Contributors

• @ThaisRobba made their first contribution in #17

Full Changelog: v0.12.0...v0.12.2

v0.12.0

BREAKING CHANGES

• watch() now returns the method to stop watching changes directly instead of an object with the stop method.

Before:

const { stop } = await watch(...);

After:

const stop = await watch(...);

• All exceptions have been rewritten to custom classes that extend Error, so checking for problems is easier.

Before:

import { insert } from "blinkdb";

try {
  await insert(userTable, ...);
} catch(e) {
  // Check if the error is due to the primary key already existing.
  if(e.message.match(/Primary key .* already in use./g)) {
    console.log("Key in use :(");
  }
}

After:

import { insert, PrimaryKeyAlreadyInUseError } from "blinkdb";

try {
  await insert(userTable, ...);
} catch(e) {
  // Check if the error is due to the primary key already existing.
  if(e instanceof PrimaryKeyAlreadyInUseError) {
    console.log("Key in use :(");
  }
}

What's changed

• update() & updateMany() now return the primary keys of the items updated.
• New upsert(...) & upsertMany(...) that update an entity, or insert it if it's not yet present within the table.
• first() & one() now also accept an id directly as the second parameter, which is a faster method than using a query { where: { id: "<id>" } }.
• watch() has been rewritten with increased performance and correctness.
  • fixed issue with watch() returning incorrect data if a limit is specified.
  • used better algorithm for inserting newer entities into the sorted list instead of inserting & sorting afterwards.

Full Changelog: https://github.com/blinkdb-js/blinkdb/commits/v0.12.0

v0.11.0

v0.11 of BlinkDB arrives with massive improvements to the query engine, specifically for limiting & sorting results.

Before

blinkdb\limit-from.ts --- lokijs is 5.00x faster than blinkdb
┌─────────┬───────────┬───────────────────┬───────────────────┬──────────┬─────────┐
│ (index) │   name    │      ops/sec      │ Average Time (ns) │  Margin  │ Samples │
├─────────┼───────────┼───────────────────┼───────────────────┼──────────┼─────────┤
│    0    │ 'lokijs'  │ 16588.13217232204 │ 60284.06270288466 │ '±1.01%' │  8295   │
│    1    │ 'blinkdb' │ 3319.452529365677 │ 301254.4963825986 │ '±3.59%' │  1668   │
└─────────┴───────────┴───────────────────┴───────────────────┴──────────┴─────────┘
blinkdb\sort-id-asc.ts --- lokijs is 1.22x faster than blinkdb
┌─────────┬───────────┬────────────────────┬───────────────────┬──────────┬─────────┐
│ (index) │   name    │      ops/sec       │ Average Time (ns) │  Margin  │ Samples │
├─────────┼───────────┼────────────────────┼───────────────────┼──────────┼─────────┤
│    0    │ 'lokijs'  │ 1882.3348864078623 │ 531255.0955841558 │ '±2.41%' │   942   │
│    1    │ 'blinkdb' │ 1541.504252178804  │ 648716.9909434716 │ '±7.26%' │   771   │
└─────────┴───────────┴────────────────────┴───────────────────┴──────────┴─────────┘

After

blinkdb\limit-from.ts --- blinkdb is 3.10x faster than lokijs
┌─────────┬───────────┬────────────────────┬────────────────────┬──────────┬─────────┐
│ (index) │   name    │      ops/sec       │ Average Time (ns)  │  Margin  │ Samples │
├─────────┼───────────┼────────────────────┼────────────────────┼──────────┼─────────┤
│    0    │ 'blinkdb' │ 50585.49415326716  │ 19768.513024111937 │ '±8.57%' │  25293  │
│    1    │ 'lokijs'  │ 16296.938372072096 │  61361.218725211   │ '±2.90%' │  8156   │
└─────────┴───────────┴────────────────────┴────────────────────┴──────────┴─────────┘
blinkdb\sort-id-asc.ts --- blinkdb is 2.61x faster than lokijs
┌─────────┬───────────┬────────────────────┬────────────────────┬──────────┬─────────┐
│ (index) │   name    │      ops/sec       │ Average Time (ns)  │  Margin  │ Samples │
├─────────┼───────────┼────────────────────┼────────────────────┼──────────┼─────────┤
│    0    │ 'blinkdb' │ 4057.786560018582  │ 246439.77331213318 │ '±7.94%' │  2029   │
│    1    │ 'lokijs'  │ 1557.6211865036469 │ 642004.6213191763  │ '±2.88%' │   779   │
└─────────┴───────────┴────────────────────┴────────────────────┴──────────┴─────────┘

Implementation details

BlinkDB achieves this massive speedup by exploiting certain edge cases in queries:

• In previous implementations, limiting results with from was performed after all items were retrieved from the underlying btree. from is now respected directly in the btree in all cases where where the query engine uses the primary column for item retrieval.
• Sorting items can be entirely skipped if the query engine retrieved items from the primary column, since the Btree already returns the items sorted.

v0.10.0

What's Changed

• BlinkDB introduces middleware! Hook right into BlinkDB methods with the new use() method, which lets you modify parameters & return values of various functions of BlinkDB. See the docs for more details.

use(userTable, async (ctx) => {
  // Execute code before calling the implementation
  console.log(ctx.action); // Log the method called
  console.log(ctx.params); // Log parameters given to the method

  // Call the native implementation
  const result = await ctx.next(...ctx.params);

  // Execute code after the implementation
  console.log("Everything worked!");

  // Don't forget to return the result ;)
  return result;
})