duckdb 0.7.2-dev899.0 → 0.7.2-dev921.0

package/lib/duckdb.d.ts

@@ -100,7 +100,7 @@ export class Connection {
   unregister_udf(name: string, callback: Callback<any>): void;
 
   stream(sql: any, ...args: any[]): QueryResult;
-  arrowIPCStream(sql: any, ...args: any[]): IpcResultStreamIterator;
+  arrowIPCStream(sql: any, ...args: any[]): Promise<IpcResultStreamIterator>;
 
   register_buffer(name: string, array: ArrowIterable, force: boolean, callback?: Callback<void>): void;
   unregister_buffer(name: string, callback?: Callback<void>): void;

package/lib/duckdb.js

@@ -189,7 +189,7 @@ Connection.prototype.arrowIPCAll = function (sql) {
  * @arg sql
  * @param {...*} params
  * @param callback
- * @return IpcResultStreamIterator
+ * @return Promise<IpcResultStreamIterator>
  */
 Connection.prototype.arrowIPCStream = async function (sql) {
     const query = "SELECT * FROM to_arrow_ipc((" + sql + "));";

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.7.2-dev899.0",
+  "version": "0.7.2-dev921.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/src/execution/operator/join/physical_blockwise_nl_join.cpp

@@ -130,8 +130,10 @@ OperatorResultType PhysicalBlockwiseNLJoin::ExecuteInternal(ExecutionContext &co
 	}
 
 	// now perform the actual join
-	// we perform a cross product, then execute the expression directly on the cross product' result
+	// we perform a cross product, then execute the expression directly on the cross product result
 	idx_t result_count = 0;
+	bool found_match[STANDARD_VECTOR_SIZE] = {false};
+
 	do {
 		auto result = state.cross_product.Execute(input, *intermediate_chunk);
 		if (result == OperatorResultType::NEED_MORE_INPUT) {
@@ -142,39 +144,58 @@ OperatorResultType PhysicalBlockwiseNLJoin::ExecuteInternal(ExecutionContext &co
 				state.left_outer.ConstructLeftJoinResult(input, *intermediate_chunk);
 				state.left_outer.Reset();
 			}
+
+			if (join_type == JoinType::SEMI) {
+				PhysicalJoin::ConstructSemiJoinResult(input, chunk, found_match);
+			}
+			if (join_type == JoinType::ANTI) {
+				PhysicalJoin::ConstructAntiJoinResult(input, chunk, found_match);
+			}
+
 			return OperatorResultType::NEED_MORE_INPUT;
 		}
 
 		// now perform the computation
 		result_count = state.executor.SelectExpression(*intermediate_chunk, state.match_sel);
+
+		// handle anti and semi joins with different logic
 		if (result_count > 0) {
 			// found a match!
-			// check if the cross product is scanning the LHS or the RHS in its entirety
-			if (!state.cross_product.ScanLHS()) {
-				// set the match flags in the LHS
-				state.left_outer.SetMatches(state.match_sel, result_count);
-				// set the match flag in the RHS
-				gstate.right_outer.SetMatch(state.cross_product.ScanPosition() + state.cross_product.PositionInChunk());
+			// handle anti semi join conditions first
+			if (join_type == JoinType::ANTI || join_type == JoinType::SEMI) {
+				if (state.cross_product.ScanLHS()) {
+					found_match[state.cross_product.PositionInChunk()] = true;
+				} else {
+					for (idx_t i = 0; i < result_count; i++) {
+						found_match[state.match_sel.get_index(i)] = true;
+					}
+				}
+				intermediate_chunk->Reset();
+				// trick the loop to continue as semi and anti joins will never produce more output than
+				// the LHS cardinality
+				result_count = 0;
 			} else {
-				// set the match flag in the LHS
-				state.left_outer.SetMatch(state.cross_product.PositionInChunk());
-				// set the match flags in the RHS
-				gstate.right_outer.SetMatches(state.match_sel, result_count, state.cross_product.ScanPosition());
+				// check if the cross product is scanning the LHS or the RHS in its entirety
+				if (!state.cross_product.ScanLHS()) {
+					// set the match flags in the LHS
+					state.left_outer.SetMatches(state.match_sel, result_count);
+					// set the match flag in the RHS
+					gstate.right_outer.SetMatch(state.cross_product.ScanPosition() +
+					                            state.cross_product.PositionInChunk());
+				} else {
+					// set the match flag in the LHS
+					state.left_outer.SetMatch(state.cross_product.PositionInChunk());
+					// set the match flags in the RHS
+					gstate.right_outer.SetMatches(state.match_sel, result_count, state.cross_product.ScanPosition());
+				}
+				intermediate_chunk->Slice(state.match_sel, result_count);
 			}
-			intermediate_chunk->Slice(state.match_sel, result_count);
 		} else {
 			// no result: reset the chunk
 			intermediate_chunk->Reset();
 		}
 	} while (result_count == 0);
 
-	if (join_type == JoinType::SEMI || join_type == JoinType::ANTI) {
-		for (idx_t col_idx = 0; col_idx < chunk.ColumnCount(); col_idx++) {
-			chunk.data[col_idx].Reference(intermediate_chunk->data[col_idx]);
-		}
-		chunk.SetCardinality(*intermediate_chunk);
-	}
-
 	return OperatorResultType::HAVE_MORE_OUTPUT;
 }
 

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev899"
+#define DUCKDB_VERSION "0.7.2-dev921"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "88b1bfa74d"
+#define DUCKDB_SOURCE_ID "227bd4bddc"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_cross_product.hpp

@@ -60,10 +60,12 @@ public:
 
 	OperatorResultType Execute(DataChunk &input, DataChunk &output);
 
+	// returns if the left side is scanned as a constant vector
 	bool ScanLHS() {
 		return scan_input_chunk;
 	}
 
+	// returns the position in the chunk of chunk scanned as a constant input vector
 	idx_t PositionInChunk() {
 		return position_in_chunk;
 	}