nodejs create_table (#75)

node/src/test/test.ts

@@ -14,67 +14,94 @@
 
 import { describe } from 'mocha'
 import { assert } from 'chai'
+import { track } from 'temp'
 
 import * as lancedb from '../index'
 
 describe('LanceDB client', function () {
-  describe('open a connection to lancedb', function () {
-    const con = lancedb.connect('.../../sample-lancedb')
-
-    it('should have a valid url', function () {
-      assert.equal(con.uri, '.../../sample-lancedb')
+  describe('when creating a connection to lancedb', function () {
+    it('should have a valid url', async function () {
+      const uri = await createTestDB()
+      const con = await lancedb.connect(uri)
+      assert.equal(con.uri, uri)
     })
 
-    it('should return the existing table names', function () {
-      assert.deepEqual(con.tableNames(), ['my_table'])
+    it('should return the existing table names', async function () {
+      const uri = await createTestDB()
+      const con = await lancedb.connect(uri)
+      assert.deepEqual(await con.tableNames(), ['vectors'])
+    })
+  })
+
+  describe('when querying an existing dataset', function () {
+    it('should open a table', async function () {
+      const uri = await createTestDB()
+      const con = await lancedb.connect(uri)
+      const table = await con.openTable('vectors')
+      assert.equal(table.name, 'vectors')
     })
 
-    describe('open a table from a connection', function () {
-      const tablePromise = con.openTable('my_table')
+    it('execute a query', async function () {
+      const uri = await createTestDB()
+      const con = await lancedb.connect(uri)
+      const table = await con.openTable('vectors')
+      const results = await table.search([0.1, 0.3]).execute()
 
-      it('should have a valid name', async function () {
-        const table = await tablePromise
-        assert.equal(table.name, 'my_table')
-      })
+      assert.equal(results.length, 2)
+      assert.equal(results[0].price, 10)
+      const vector = results[0].vector as Float32Array
+      assert.approximately(vector[0], 0.0, 0.2)
+      assert.approximately(vector[0], 0.1, 0.3)
+    })
 
-      class MyResult {
-        vector: Float32Array = new Float32Array(0)
-        price: number = 0
-        item: string = ''
-      }
+    it('limits # of results', async function () {
+      const uri = await createTestDB()
+      const con = await lancedb.connect(uri)
+      const table = await con.openTable('vectors')
+      const results = await table.search([0.1, 0.3]).limit(1).execute()
+      assert.equal(results.length, 1)
+      assert.equal(results[0].id, 1)
+    })
 
-      it('execute a query', async function () {
-        const table = await tablePromise
-        const builder = table.search([0.1, 0.3])
-        const results = await builder.execute() as MyResult[]
+    it('uses a filter', async function () {
+      const uri = await createTestDB()
+      const con = await lancedb.connect(uri)
+      const table = await con.openTable('vectors')
+      const results = await table.search([0.1, 0.3]).filter('id == 2').execute()
+      assert.equal(results.length, 1)
+      assert.equal(results[0].id, 2)
+    })
+  })
 
-        assert.equal(results.length, 2)
-        assert.equal(results[0].item, 'foo')
-        assert.equal(results[0].price, 10)
-        assert.approximately(results[0].vector[0], 3.1, 0.1)
-        assert.approximately(results[0].vector[1], 4.1, 0.1)
-      })
+  describe('when creating a new dataset', function () {
+    it('creates a new table from javascript objects', async function () {
+      const dir = await track().mkdir('lancejs')
+      const con = await lancedb.connect(dir)
 
-      it('execute a query and type cast the result', async function () {
-        const table = await tablePromise
+      const data = [
+        { id: 1, vector: [0.1, 0.2], price: 10 },
+        { id: 2, vector: [1.1, 1.2], price: 50 }
+      ]
 
-        const builder = table.search([0.1, 0.3])
-        const results = await builder.execute_cast<MyResult>()
-        assert.equal(results.length, 2)
-        assert.equal(results[0].item, 'foo')
-        assert.equal(results[0].price, 10)
-        assert.approximately(results[0].vector[0], 3.1, 0.1)
-        assert.approximately(results[0].vector[1], 4.1, 0.1)
-      })
+      const tableName = `vectors_${Math.floor(Math.random() * 100)}`
+      const table = await con.createTable(tableName, data)
+      assert.equal(table.name, tableName)
 
-      it('limits # of results', async function () {
-        const table = await tablePromise
-        const builder = table.search([0.1, 0.3])
-        builder.limit = 1
-        const results = await builder.execute() as MyResult[]
-
-        assert.equal(results.length, 1)
-      })
+      const results = await table.search([0.1, 0.3]).execute()
+      assert.equal(results.length, 2)
     })
   })
 })
+
+async function createTestDB (): Promise<string> {
+  const dir = await track().mkdir('lancejs')
+  const con = await lancedb.connect(dir)
+
+  const data = [
+    { id: 1, vector: [0.1, 0.2], name: 'foo', price: 10, is_active: true },
+    { id: 2, vector: [1.1, 1.2], name: 'bar', price: 50, is_active: false }
+  ]
+
+  await con.createTable('vectors', data)
+  return dir
+}