Add and export getSchema function (#363)

* Add and export getSchema function

* more unit tests

* handle type assertions outside of getSchema; simplify unit tests

* move comment

* use inferred instead of shouldCoerce; use input instead of source

* aaand update tests too

* simplification

Author: Annie Zhang

src/index.js

@@ -10,5 +10,6 @@ export {
   isDatabaseClient,
   __table as applyDataTableOperations,
   getTypeValidator,
-  inferSchema
+  inferSchema,
+  getSchema
 } from "./table.js";

src/table.js

@@ -617,18 +617,24 @@ export function coerceToType(value, type) {
   }
 }
 
+export function getSchema(source) {
+  const {columns} = source;
+  let {schema} = source;
+  if (!isQueryResultSetSchema(schema)) {
+    schema = inferSchema(source, isQueryResultSetColumns(columns) ? columns : undefined);
+    return {schema, inferred: true};
+  }
+  return {schema, inferred: false};
+}
+
 // This function applies table cell operations to an in-memory table (array of
 // objects); it should be equivalent to the corresponding SQL query. TODO Use
 // DuckDBClient for data arrays, too, and then we wouldn’t need our own __table
 // function to do table operations on in-memory data?
 export function __table(source, operations) {
   const input = source;
-  let {schema, columns} = source;
-  let inferredSchema = false;
-  if (!isQueryResultSetSchema(schema)) {
-    schema = inferSchema(source, isQueryResultSetColumns(columns) ? columns : undefined);
-    inferredSchema = true;
-  }
+  let {columns} = source;
+  let {schema, inferred} = getSchema(source);
   // Combine column types from schema with user-selected types in operations
   const types = new Map(schema.map(({name, type}) => [name, type]));
   if (operations.types) {
@@ -640,7 +646,7 @@ export function __table(source, operations) {
       if (colIndex > -1) schema[colIndex] = {...schema[colIndex], type};
     }
     source = source.map(d => coerceRow(d, types, schema));
-  } else if (inferredSchema) {
+  } else if (inferred) {
     // Coerce data according to new schema, unless that happened due to
     // operations.types, above.
     source = source.map(d => coerceRow(d, types, schema));

test/table-test.js

@@ -3,7 +3,8 @@ import {
   getTypeValidator,
   inferSchema,
   makeQueryTemplate,
-  __table
+  __table,
+  getSchema
 } from "../src/table.js";
 import assert from "assert";
 
@@ -805,13 +806,37 @@ describe("__table", () => {
       "b",
       "c"
     ]);
-    source.schema = [
-      {name: "a", type: "integer", inferred: "integer"},
+    assert.deepStrictEqual(__table(source, operations).schema, [
+      {name: "nameA", type: "integer", inferred: "integer"},
+      {name: "b", type: "integer", inferred: "integer"},
+      {name: "c", type: "integer", inferred: "integer"}
+    ]);
+  });
+
+  it("__table type assertions", () => {
+    const operations = {
+      ...EMPTY_TABLE_DATA.operations,
+      types: [{name: "a", type: "string"}]
+    };
+    const expected = [
+      {a: "1", b: 2, c: 3},
+      {a: "2", b: 4, c: 6},
+      {a: "3", b: 6, c: 9}
+    ];
+    expected.schema = [
+      {name: "a", type: "string", inferred: "integer"},
       {name: "b", type: "integer", inferred: "integer"},
       {name: "c", type: "integer", inferred: "integer"}
     ];
+    assert.deepStrictEqual(__table(source, operations), expected);
+    source.columns = ["a", "b", "c"];
+    assert.deepStrictEqual(__table(source, operations).columns, [
+      "a",
+      "b",
+      "c"
+    ]);
     assert.deepStrictEqual(__table(source, operations).schema, [
-      {name: "nameA", type: "integer", inferred: "integer"},
+      {name: "a", type: "string", inferred: "integer"},
       {name: "b", type: "integer", inferred: "integer"},
       {name: "c", type: "integer", inferred: "integer"}
     ]);
@@ -1213,3 +1238,45 @@ describe("coerceToType", () => {
   // Note: if type is "raw", coerceToType() will not be called. Instead, values
   // will be returned from coerceRow().
 });
+
+describe("getSchema", () => {
+  let source;
+
+  beforeEach(() => {
+    source = [
+      {a: 1, b: "foo"},
+      {a: 2, b: "bar"}
+    ];
+    source.schema = [
+      {name: "a", type: "integer", inferred: "integer"},
+      {name: "b", type: "string", inferred: "string"}
+    ];
+  });
+
+
+  it("respects schema from source, if one exists", () => {
+    const {schema, inferred} = getSchema(source);
+    assert.strictEqual(inferred, false);
+    assert.strictEqual(schema, source.schema);
+  });
+
+  it("infers schema if source has no schema", () => {
+    source.schema = undefined;
+    const {schema, inferred} = getSchema(source);
+    assert.strictEqual(inferred, true);
+    assert.deepStrictEqual(schema,[
+      {name: "a", type: "integer", inferred: "integer"},
+      {name: "b", type: "string", inferred: "string"}
+    ]);
+  });
+
+  it("infers schema if schema is invalid", () => {
+    source.schema = ["number"];
+    const {schema, inferred} = getSchema(source);
+    assert.strictEqual(inferred, true);
+    assert.deepStrictEqual(schema,[
+      {name: "a", type: "integer", inferred: "integer"},
+      {name: "b", type: "string", inferred: "string"}
+    ]);
+  });
+});