duckdb 0.5.2-dev874.0 → 0.5.2-dev880.0

package/.mocharc.json

@@ -0,0 +1,5 @@
+{
+  "extension": ["js", "ts"],
+  "spec": ["test/*.js", "test/*.ts"],
+  "require": "ts-node/register"
+}

package/lib/duckdb.d.ts

@@ -0,0 +1,94 @@
+/**
+ * TypeScript declarations for Node.JS bindings for DuckDb.
+ * See https://duckdb.org/docs/api/nodejs/overview for details
+ * on Node.JS API
+ */
+export class DuckDbError extends Error {
+  errno: number;
+  code: string;
+}
+
+type Callback<T> = (err: DuckDbError | null, res: T) => void;
+
+export type RowData = {
+  [columnName: string]: any;
+};
+
+export type TableData = RowData[];
+
+export class Connection {
+  constructor(db: Database, callback?: Callback<any>);
+
+  all(sql: string, ...args: [...any, Callback<TableData>] | []): void;
+  each(sql: string, ...args: [...any, Callback<RowData>] | []): void;
+  exec(sql: string, ...args: [...any, Callback<void>] | []): void;
+
+  prepare(sql: string, ...args: [...any, Callback<Statement>] | []): Statement;
+  run(sql: string, ...args: [...any, Callback<void>] | []): Statement;
+
+  register(
+    name: string,
+    return_type: string,
+    fun: (...args: any[]) => any
+  ): void;
+
+  register_bulk(
+    name: string,
+    return_type: string,
+    fun: (...args: any[]) => any
+  ): void;
+  unregister(name: string, callback: Callback<any>): void;
+
+  stream(sql: any, ...args: any[]): QueryResult;
+}
+
+export class QueryResult {
+  [Symbol.asyncIterator](): AsyncIterator<RowData>;
+}
+
+export class Database {
+  constructor(path: string, callback?: Callback<any>);
+
+  close(callback: Callback<void>): void;
+
+  connect(): Connection;
+
+  all(sql: string, ...args: [...any, Callback<TableData>] | []): void;
+  each(sql: string, ...args: [...any, Callback<RowData>] | []): void;
+  exec(sql: string, ...args: [...any, Callback<void>] | []): void;
+
+  prepare(sql: string, ...args: [...any, Callback<Statement>] | []): Statement;
+  run(sql: string, ...args: [...any, Callback<void>] | []): Statement;
+
+  register(
+    name: string,
+    return_type: string,
+    fun: (...args: any[]) => any
+  ): void;
+  unregister(name: string, callback: Callback<any>): void;
+}
+
+export class Statement {
+  constructor();
+
+  all(...args: [...any, Callback<TableData>] | []): void;
+  each(...args: [...any, Callback<RowData>] | []): void;
+
+  finalize(callback?: Callback<void>): void;
+
+  run(...args: [...any, Callback<void>] | []): Statement;
+}
+
+export const ERROR: number;
+
+export const OPEN_CREATE: number;
+
+export const OPEN_FULLMUTEX: number;
+
+export const OPEN_PRIVATECACHE: number;
+
+export const OPEN_READONLY: number;
+
+export const OPEN_READWRITE: number;
+
+export const OPEN_SHAREDCACHE: number;

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.5.2-dev874.0",
+  "types": "./lib/duckdb.d.ts",
+  "version": "0.5.2-dev880.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {
@@ -25,15 +26,25 @@
     "test": "test"
   },
   "devDependencies": {
+    "@types/mocha": "^10.0.0",
+    "@types/node": "^18.11.0",
     "aws-sdk": "^2.790.0",
     "chai": "^4.3.6",
     "jsdoc3-parser": "^2.0.0",
-    "mocha": "^8.3.0"
+    "mocha": "^8.3.0",
+    "ts-node": "^10.9.1",
+    "tsconfig-paths": "^4.0.0",
+    "typescript": "^4.8.4"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/cwida/duckdb.git"
   },
+  "ts-node": {
+    "require": [
+      "tsconfig-paths/register"
+    ]
+  },
   "keywords": [
     "database",
     "sql",

package/src/duckdb.cpp

@@ -69964,7 +69964,7 @@ string PhysicalComparisonJoin::ParamsToString() const {
 		string op = ExpressionTypeToOperator(it.comparison);
 		extra_info += it.left->GetName() + " " + op + " " + it.right->GetName() + "\n";
 	}
-	extra_info += "\nEC = " + std::to_string(estimated_props->GetCardinality()) + "\n";
+	extra_info += "\nEC = " + std::to_string(estimated_props->GetCardinality<double>()) + "\n";
 	extra_info += "COST = " + std::to_string(estimated_props->GetCost()) + "\n";
 	return extra_info;
 }
@@ -85747,7 +85747,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOperator &
 	}
 
 	if (op.estimated_props) {
-		plan->estimated_cardinality = op.estimated_props->GetCardinality();
+		plan->estimated_cardinality = op.estimated_props->GetCardinality<idx_t>();
 		plan->estimated_props = op.estimated_props->Copy();
 	} else {
 		plan->estimated_props = make_unique<EstimatedProperties>();
@@ -145624,13 +145624,13 @@ void CardinalityEstimator::InitEquivalentRelations(vector<unique_ptr<FilterInfo>
 }
 
 void CardinalityEstimator::VerifySymmetry(JoinNode *result, JoinNode *entry) {
-	if (result->GetCardinality() != entry->GetCardinality()) {
+	if (result->GetCardinality<double>() != entry->GetCardinality<double>()) {
 		// Currently it's possible that some entries are cartesian joins.
 		// When this is the case, you don't always have symmetry, but
 		// if the cost of the result is less, then just assure the cardinality
 		// is also less, then you have the same effect of symmetry.
-		D_ASSERT(ceil(result->GetCardinality()) <= ceil(entry->GetCardinality()) ||
-		         floor(result->GetCardinality()) <= floor(entry->GetCardinality()));
+		D_ASSERT(ceil(result->GetCardinality<double>()) <= ceil(entry->GetCardinality<double>()) ||
+		         floor(result->GetCardinality<double>()) <= floor(entry->GetCardinality<double>()));
 	}
 }
 
@@ -145647,9 +145647,9 @@ double CardinalityEstimator::ComputeCost(JoinNode *left, JoinNode *right, double
 double CardinalityEstimator::EstimateCrossProduct(const JoinNode *left, const JoinNode *right) {
 	// need to explicity use double here, otherwise auto converts it to an int, then
 	// there is an autocast in the return.
-	return left->GetCardinality() >= (NumericLimits<double>::Maximum() / right->GetCardinality())
+	return left->GetCardinality<double>() >= (NumericLimits<double>::Maximum() / right->GetCardinality<double>())
 	           ? NumericLimits<double>::Maximum()
-	           : left->GetCardinality() * right->GetCardinality();
+	           : left->GetCardinality<double>() * right->GetCardinality<double>();
 }
 
 void CardinalityEstimator::AddRelationColumnMapping(LogicalGet *get, idx_t relation_id) {
@@ -145874,7 +145874,7 @@ void CardinalityEstimator::InitCardinalityEstimatorProps(vector<struct NodeOp> *
 
 void CardinalityEstimator::UpdateTotalDomains(JoinNode *node, LogicalOperator *op) {
 	auto relation_id = node->set->relations[0];
-	relation_attributes[relation_id].cardinality = node->GetCardinality();
+	relation_attributes[relation_id].cardinality = node->GetCardinality<double>();
 	TableCatalogEntry *catalog_table = nullptr;
 	auto get = GetLogicalGet(op);
 	if (get) {
@@ -145906,7 +145906,7 @@ void CardinalityEstimator::UpdateTotalDomains(JoinNode *node, LogicalOperator *o
 			// We decrease the total domain for all columns in the equivalence set because filter pushdown
 			// will mean all columns are affected.
 			if (direct_filter) {
-				count = node->GetCardinality();
+				count = node->GetCardinality<idx_t>();
 			}
 
 			// HLL has estimation error, count can't be greater than cardinality of the table before filters
@@ -145917,7 +145917,7 @@ void CardinalityEstimator::UpdateTotalDomains(JoinNode *node, LogicalOperator *o
 			// No HLL. So if we know there is a direct filter, reduce count to cardinality with filter
 			// otherwise assume the total domain is still the cardinality
 			if (direct_filter) {
-				count = node->GetCardinality();
+				count = node->GetCardinality<idx_t>();
 			} else {
 				count = node->GetBaseTableCardinality();
 			}
@@ -147016,10 +147016,18 @@ bool Deliminator::RemoveInequalityCandidate(unique_ptr<LogicalOperator> *plan, u
 
 namespace duckdb {
 
-double EstimatedProperties::GetCardinality() {
+template <>
+double EstimatedProperties::GetCardinality() const {
 	return cardinality;
 }
-double EstimatedProperties::GetCost() {
+
+template <>
+idx_t EstimatedProperties::GetCardinality() const {
+	auto max_idx_t = NumericLimits<idx_t>::Maximum() - 10000;
+	return MinValue<double>(cardinality, max_idx_t);
+}
+
+double EstimatedProperties::GetCost() const {
 	return cost;
 }
 
@@ -149170,10 +149178,6 @@ unique_ptr<EstimatedProperties> EstimatedProperties::Copy() {
 	return result;
 }
 
-double JoinNode::GetCardinality() const {
-	return estimated_props->GetCardinality();
-}
-
 double JoinNode::GetCost() {
 	return estimated_props->GetCost();
 }
@@ -149203,10 +149207,10 @@ string JoinNode::ToString() {
 	}
 	string result = "-------------------------------\n";
 	result += set->ToString() + "\n";
-	result += "card = " + to_string(GetCardinality()) + "\n";
+	result += "card = " + to_string(GetCardinality<double>()) + "\n";
 	bool is_cartesian = false;
 	if (left && right) {
-		is_cartesian = (GetCardinality() == left->GetCardinality() * right->GetCardinality());
+		is_cartesian = (GetCardinality<double>() == left->GetCardinality<double>() * right->GetCardinality<double>());
 	}
 	result += "cartesian = " + to_string(is_cartesian) + "\n";
 	result += "cost = " + to_string(estimated_props->GetCost()) + "\n";
@@ -149749,14 +149753,14 @@ unique_ptr<JoinNode> JoinOrderOptimizer::CreateJoinTree(JoinRelationSet *set,
 	auto plan = plans.find(set);
 	// if we have already calculated an expected cardinality for this set,
 	// just re-use that cardinality
-	if (left->GetCardinality() < right->GetCardinality()) {
+	if (left->GetCardinality<double>() < right->GetCardinality<double>()) {
 		return CreateJoinTree(set, possible_connections, right, left);
 	}
 	if (plan != plans.end()) {
 		if (!plan->second) {
 			throw InternalException("No plan: internal error in join order optimizer");
 		}
-		expected_cardinality = plan->second->GetCardinality();
+		expected_cardinality = plan->second->GetCardinality<double>();
 		best_connection = possible_connections.back();
 	} else if (possible_connections.empty()) {
 		// cross product
@@ -150121,7 +150125,8 @@ void JoinOrderOptimizer::SolveJoinOrderApproximately() {
 				auto current_plan = plans[join_relations[i]].get();
 				// check if the cardinality is smaller than the smallest two found so far
 				for (idx_t j = 0; j < 2; j++) {
-					if (!smallest_plans[j] || smallest_plans[j]->GetCardinality() > current_plan->GetCardinality()) {
+					if (!smallest_plans[j] ||
+					    smallest_plans[j]->GetCardinality<double>() > current_plan->GetCardinality<double>()) {
 						smallest_plans[j] = current_plan;
 						smallest_index[j] = i;
 						break;
@@ -150256,8 +150261,7 @@ JoinOrderOptimizer::GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted
 		result_relation = node->set;
 		result_operator = move(extracted_relations[node->set->relations[0]]);
 	}
-	auto max_idx_t = NumericLimits<idx_t>::Maximum() - 10000;
-	result_operator->estimated_cardinality = MinValue<idx_t>(node->GetCardinality(), max_idx_t);
+	result_operator->estimated_cardinality = node->GetCardinality<idx_t>();
 	result_operator->has_estimated_cardinality = true;
 	result_operator->estimated_props = node->estimated_props->Copy();
 	// check if we should do a pushdown on this node