eyros 4.6.2

multi-dimensional interval database
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

const RAM = require('random-access-memory')
const eyros = require('../2d')
const fs = require('fs')
const test = require('tape')
const randomBytes = require('crypto').randomBytes

function getId(value) { return value.slice(4,6) }

test('delete with custom ids', async function (t) {
  t.plan(3)
  var db = await eyros({
    storage: RAM,
    getId,
    wasmSource: fs.readFileSync(require.resolve(`../2d.wasm`))
  })
  var insertBatch = []
  for (var i = 0; i < 1000; i++) {
    var point = [
      (Math.random()*2-1)*15,
      (Math.random()*2-1)*15
    ]
    var value = Uint8Array.from(randomBytes(10))
    value[4] = i%256
    value[5] = Math.floor(i/256)
    insertBatch.push({ type: 'insert', point, value })
  }
  await db.batch(insertBatch)

  var bbox = [-10,-10,+10,+10]
  var beforeRows = await collect(await db.query(bbox))
  t.deepEqual(
    beforeRows.map(row => [ round(row[0]), row[1] ]).sort(cmp),
    insertBatch
      .filter(row => intersect(row.point, bbox))
      .map(row => [ round(row.point), row.value ])
      .sort(cmp)
  )

  var deleteBatch = []
  for (var i = 0; i < beforeRows.length; i+=5) {
    var value = beforeRows[i][1]
    deleteBatch.push({
      type: 'delete',
      point: beforeRows[i][0],
      id: getId(value)
    })
  }
  await db.batch(deleteBatch)

  var afterRows = await collect(await db.query(bbox))
  var expected = beforeRows
    .filter((row,i) => i%5 !== 0 && intersect(row[0], bbox))
    .map(row => [ round(row[0]), row[1] ])
    .sort(cmp)
  var observed = afterRows.map(row => [ round(row[0]), row[1] ]).sort(cmp)
  t.equal(observed.length, expected.length)
  t.deepEqual(observed, expected)
})

function intersect (x, bbox) {
  var dim = bbox.length/2
  for (var i = 0; i < dim; i++) {
    if (Array.isArray(x[i])) {
      if (x[i][0] > bbox[i+dim] || x[i][1] < bbox[i]) return false
    } else if (x[i] < bbox[i] || x[i] > bbox[i+dim]) {
      return false
    }
  }
  return true
}

function round (x) {
  if (Array.isArray(x)) return x.map(round)
  var n = 1e2
  return Math.round(x*n)/n
}

function cmp (a, b) {
  return JSON.stringify(a) < JSON.stringify(b) ? -1 : +1
}

async function collect (iter) {
  var row, rows = []
  while (row = await iter.next()) {
    rows.push(row)
  }
  return rows
}