duckdb 0.3.2-dev1288.0 → 0.3.2-dev1306.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.2-dev1288.0",
+  "version": "0.3.2-dev1306.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -4687,6 +4687,37 @@ data_ptr_t Allocator::ReallocateData(data_ptr_t pointer, idx_t size) {
 
 
 
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/result_arrow_wrapper.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+class ResultArrowArrayStreamWrapper {
+public:
+	explicit ResultArrowArrayStreamWrapper(unique_ptr<QueryResult> result, idx_t approx_batch_size);
+	ArrowArrayStream stream;
+	unique_ptr<QueryResult> result;
+	std::string last_error;
+	idx_t vectors_per_chunk;
+
+private:
+	static int MyStreamGetSchema(struct ArrowArrayStream *stream, struct ArrowSchema *out);
+	static int MyStreamGetNext(struct ArrowArrayStream *stream, struct ArrowArray *out);
+	static void MyStreamRelease(struct ArrowArrayStream *stream);
+	static const char *MyStreamGetLastError(struct ArrowArrayStream *stream);
+};
+} // namespace duckdb
+
 namespace duckdb {
 
 ArrowSchemaWrapper::~ArrowSchemaWrapper() {
@@ -4737,8 +4768,8 @@ void ArrowArrayStreamWrapper::GetSchema(ArrowSchemaWrapper &schema) {
 	// LCOV_EXCL_STOP
 }
 
-unique_ptr<ArrowArrayWrapper> ArrowArrayStreamWrapper::GetNextChunk() {
-	auto current_chunk = make_unique<ArrowArrayWrapper>();
+shared_ptr<ArrowArrayWrapper> ArrowArrayStreamWrapper::GetNextChunk() {
+	auto current_chunk = make_shared<ArrowArrayWrapper>();
 	if (arrow_array_stream.get_next(&arrow_array_stream, &current_chunk->arrow_array)) { // LCOV_EXCL_START
 		throw InvalidInputException("arrow_scan: get_next failed(): %s", string(GetError()));
 	} // LCOV_EXCL_STOP
@@ -30174,7 +30205,29 @@ struct SelCache {
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/types/arrow_aux_data.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+struct ArrowAuxiliaryData : VectorAuxiliaryData {
+	explicit ArrowAuxiliaryData(shared_ptr<ArrowArrayWrapper> arrow_array_p)
+	    : VectorAuxiliaryData(VectorAuxiliaryDataType::ARROW_AUXILIARY), arrow_array(std::move(arrow_array_p)) {
 
+	                                                                     };
+	~ArrowAuxiliaryData() override {};
+	shared_ptr<ArrowArrayWrapper> arrow_array;
+};
+} // namespace duckdb
 
 
 namespace duckdb {
@@ -30443,6 +30496,7 @@ struct DuckDBArrowArrayHolder {
 	vector<DuckDBArrowArrayChildHolder> children = {};
 	vector<ArrowArray *> children_ptrs = {};
 	array<const void *, 1> buffers = {{nullptr}};
+	vector<shared_ptr<ArrowArrayWrapper>> arrow_original_array;
 };
 
 static void ReleaseDuckDBArrowArray(ArrowArray *array) {
@@ -30869,7 +30923,12 @@ void DataChunk::ToArrowArray(ArrowArray *out_array) {
 		InitializeChild(child_holder, size());
 		auto &vector = child_holder.vector;
 		auto &child = child_holder.array;
-
+		auto vec_buffer = data[col_idx].GetBuffer();
+		if (vec_buffer->GetAuxiliaryData() &&
+		    vec_buffer->GetAuxiliaryDataType() == VectorAuxiliaryDataType::ARROW_AUXILIARY) {
+			auto arrow_aux_data = (ArrowAuxiliaryData *)vec_buffer->GetAuxiliaryData();
+			root_holder->arrow_original_array.push_back(arrow_aux_data->arrow_array);
+		}
 		//! We could, in theory, output other types of vectors here, currently only FLAT Vectors
 		SetArrowChild(child_holder, GetTypes()[col_idx], data[col_idx], size());
 		SetChildValidityMask(*vector, child);
@@ -58342,8 +58401,8 @@ bool BufferedCSVReader::ReadBuffer(idx_t &start) {
 	while (remaining > buffer_read_size) {
 		buffer_read_size *= 2;
 	}
-	if (remaining + buffer_read_size > MAXIMUM_CSV_LINE_SIZE) {
-		throw InvalidInputException("Maximum line size of %llu bytes exceeded!", MAXIMUM_CSV_LINE_SIZE);
+	if (remaining + buffer_read_size > options.maximum_line_size) {
+		throw InvalidInputException("Maximum line size of %llu bytes exceeded!", options.maximum_line_size);
 	}
 	buffer = unique_ptr<char[]>(new char[buffer_read_size + remaining + 1]);
 	buffer_size = remaining + buffer_read_size;
@@ -90093,7 +90152,7 @@ struct ArrowScanState : public FunctionOperatorData {
 	explicit ArrowScanState(unique_ptr<ArrowArrayWrapper> current_chunk) : chunk(move(current_chunk)) {
 	}
 	unique_ptr<ArrowArrayStreamWrapper> stream;
-	unique_ptr<ArrowArrayWrapper> chunk;
+	shared_ptr<ArrowArrayWrapper> chunk;
 	idx_t chunk_offset = 0;
 	vector<column_t> column_ids;
 	//! Store child vectors for Arrow Dictionary Vectors (col-idx,vector)
@@ -90172,6 +90231,7 @@ private:
 
 
 
+
 #include <map>
 
 namespace duckdb {
@@ -91146,6 +91206,8 @@ void ArrowTableFunction::ArrowToDuckDB(ArrowScanState &scan_state,
 		if (array.length != scan_state.chunk->arrow_array.length) {
 			throw InvalidInputException("arrow_scan: array length mismatch");
 		}
+		output.data[idx].GetBuffer()->SetAuxiliaryData(make_unique<ArrowAuxiliaryData>(scan_state.chunk),
+		                                               VectorAuxiliaryDataType::ARROW_AUXILIARY);
 		if (array.dictionary) {
 			ColumnArrowToDuckDBDictionary(output.data[idx], array, scan_state, output.size(), arrow_convert_data,
 			                              col_idx, arrow_convert_idx);
@@ -91497,6 +91559,8 @@ static bool ParseBaseOption(BufferedCSVReaderOptions &options, string &loption,
 		options.compression = FileCompressionTypeFromString(ParseString(set));
 	} else if (loption == "skip") {
 		options.skip_rows = ParseInteger(set);
+	} else if (loption == "max_line_size" || loption == "maximum_line_size") {
+		options.maximum_line_size = ParseInteger(set);
 	} else {
 		// unrecognized option in base CSV
 		return false;
@@ -92801,6 +92865,8 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, vector<Value
 			result->include_file_name = BooleanValue::Get(kv.second);
 		} else if (loption == "skip") {
 			options.skip_rows = kv.second.GetValue<int64_t>();
+		} else if (loption == "max_line_size" || loption == "maximum_line_size") {
+			options.maximum_line_size = kv.second.GetValue<int64_t>();
 		} else {
 			throw InternalException("Unrecognized parameter %s", kv.first);
 		}
@@ -92907,6 +92973,8 @@ static void ReadCSVAddNamedParameters(TableFunction &table_function) {
 	table_function.named_parameters["compression"] = LogicalType::VARCHAR;
 	table_function.named_parameters["filename"] = LogicalType::BOOLEAN;
 	table_function.named_parameters["skip"] = LogicalType::BIGINT;
+	table_function.named_parameters["max_line_size"] = LogicalType::VARCHAR;
+	table_function.named_parameters["maximum_line_size"] = LogicalType::VARCHAR;
 }
 
 double CSVReaderProgress(ClientContext &context, const FunctionData *bind_data_p) {
@@ -121200,6 +121268,10 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalCros
 
 namespace duckdb {
 
+static bool IsCompareDistinct(ExpressionType type) {
+	return type == ExpressionType::COMPARE_DISTINCT_FROM || type == ExpressionType::COMPARE_NOT_DISTINCT_FROM;
+}
+
 bool StatisticsPropagator::ExpressionIsConstant(Expression &expr, const Value &val) {
 	if (expr.GetExpressionClass() != ExpressionClass::BOUND_CONSTANT) {
 		return false;
@@ -121227,8 +121299,10 @@ void StatisticsPropagator::SetStatisticsNotNull(ColumnBinding binding) {
 
 void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics &stats, ExpressionType comparison_type,
                                                   const Value &constant) {
-	// any comparison filter removes all null values
-	stats.validity_stats = make_unique<ValidityStatistics>(false);
+	// regular comparisons removes all null values
+	if (!IsCompareDistinct(comparison_type)) {
+		stats.validity_stats = make_unique<ValidityStatistics>(false);
+	}
 	if (!stats.type.IsNumeric()) {
 		// don't handle non-numeric columns here (yet)
 		return;
@@ -121264,9 +121338,11 @@ void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics &stats, Express
 
 void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics &lstats, BaseStatistics &rstats,
                                                   ExpressionType comparison_type) {
-	// any comparison filter removes all null values
-	lstats.validity_stats = make_unique<ValidityStatistics>(false);
-	rstats.validity_stats = make_unique<ValidityStatistics>(false);
+	// regular comparisons removes all null values
+	if (!IsCompareDistinct(comparison_type)) {
+		lstats.validity_stats = make_unique<ValidityStatistics>(false);
+		rstats.validity_stats = make_unique<ValidityStatistics>(false);
+	}
 	D_ASSERT(lstats.type == rstats.type);
 	if (!lstats.type.IsNumeric()) {
 		// don't handle non-numeric columns here (yet)
@@ -121312,6 +121388,7 @@ void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics &lstats, BaseSt
 		}
 		break;
 	case ExpressionType::COMPARE_EQUAL:
+	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
 		// LEFT = RIGHT
 		// only the tightest bounds pass
 		// so if we have e.g. left = [-50, 250] and right = [-100, 100]
@@ -121337,10 +121414,11 @@ void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics &lstats, BaseSt
 void StatisticsPropagator::UpdateFilterStatistics(Expression &left, Expression &right, ExpressionType comparison_type) {
 	// first check if either side is a bound column ref
 	// any column ref involved in a comparison will not be null after the comparison
-	if (left.type == ExpressionType::BOUND_COLUMN_REF) {
+	bool compare_distinct = IsCompareDistinct(comparison_type);
+	if (!compare_distinct && left.type == ExpressionType::BOUND_COLUMN_REF) {
 		SetStatisticsNotNull(((BoundColumnRefExpression &)left).binding);
 	}
-	if (right.type == ExpressionType::BOUND_COLUMN_REF) {
+	if (!compare_distinct && right.type == ExpressionType::BOUND_COLUMN_REF) {
 		SetStatisticsNotNull(((BoundColumnRefExpression &)right).binding);
 	}
 	// check if this is a comparison between a constant and a column ref
@@ -153477,8 +153555,9 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		join->children.push_back(move(plan->children[1]));
 		return move(join);
 	}
+	case LogicalOperatorType::LOGICAL_ANY_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		auto &join = (LogicalComparisonJoin &)*plan;
+		auto &join = (LogicalJoin &)*plan;
 		D_ASSERT(plan->children.size() == 2);
 		// check the correlated expressions in the children of the join
 		bool left_has_correlation = has_correlated_expressions.find(plan->children[0].get())->second;
@@ -153503,6 +153582,13 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 				plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]));
 				return plan;
 			}
+		} else if (join.join_type == JoinType::RIGHT) {
+			// left outer join
+			if (!left_has_correlation) {
+				// only right has correlation: push into right
+				plan->children[1] = PushDownDependentJoinInternal(move(plan->children[1]));
+				return plan;
+			}
 		} else if (join.join_type == JoinType::MARK) {
 			if (right_has_correlation) {
 				throw Exception("MARK join with correlation in RHS not supported");
@@ -153518,27 +153604,42 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		}
 		// both sides have correlation
 		// push into both sides
-		// NOTE: for OUTER JOINS it matters what the BASE BINDING is after the join
-		// for the LEFT OUTER JOIN, we want the LEFT side to be the base binding after we push
-		// because the RIGHT binding might contain NULL values
 		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]));
 		auto left_binding = this->base_binding;
 		plan->children[1] = PushDownDependentJoinInternal(move(plan->children[1]));
 		auto right_binding = this->base_binding;
+		// NOTE: for OUTER JOINS it matters what the BASE BINDING is after the join
+		// for the LEFT OUTER JOIN, we want the LEFT side to be the base binding after we push
+		// because the RIGHT binding might contain NULL values
 		if (join.join_type == JoinType::LEFT) {
 			this->base_binding = left_binding;
+		} else if (join.join_type == JoinType::RIGHT) {
+			this->base_binding = right_binding;
 		}
 		// add the correlated columns to the join conditions
 		for (idx_t i = 0; i < correlated_columns.size(); i++) {
-			JoinCondition cond;
-
-			cond.left = make_unique<BoundColumnRefExpression>(
+			auto left = make_unique<BoundColumnRefExpression>(
 			    correlated_columns[i].type, ColumnBinding(left_binding.table_index, left_binding.column_index + i));
-			cond.right = make_unique<BoundColumnRefExpression>(
+			auto right = make_unique<BoundColumnRefExpression>(
 			    correlated_columns[i].type, ColumnBinding(right_binding.table_index, right_binding.column_index + i));
-			cond.comparison = ExpressionType::COMPARE_EQUAL;
-			cond.null_values_are_equal = true;
-			join.conditions.push_back(move(cond));
+
+			if (join.type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
+				JoinCondition cond;
+				cond.left = move(left);
+				cond.right = move(right);
+				cond.comparison = ExpressionType::COMPARE_EQUAL;
+				cond.null_values_are_equal = true;
+
+				auto &comparison_join = (LogicalComparisonJoin &)join;
+				comparison_join.conditions.push_back(move(cond));
+			} else {
+				auto &any_join = (LogicalAnyJoin &)join;
+				auto comparison = make_unique<BoundComparisonExpression>(ExpressionType::COMPARE_NOT_DISTINCT_FROM,
+				                                                         move(left), move(right));
+				auto conjunction = make_unique<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND,
+				                                                           move(comparison), move(any_join.condition));
+				any_join.condition = move(conjunction);
+			}
 		}
 		// then we replace any correlated expressions with the corresponding entry in the correlated_map
 		RewriteCorrelatedExpressions rewriter(right_binding, correlated_map);
@@ -222743,12 +222844,17 @@ static void allocate_new(parser_state *state, size_t n) {
 
 void *palloc(size_t n) {
 	// we need to align our pointers for the sanitizer
-	auto aligned_n = ((n + 7) / 8) * 8;
+	auto allocate_n = n + sizeof(size_t);
+	auto aligned_n = ((allocate_n + 7) / 8) * 8;
 	if (pg_parser_state.malloc_pos + aligned_n > PG_MALLOC_SIZE) {
 		allocate_new(&pg_parser_state, aligned_n);
 	}
 
-	void *ptr = pg_parser_state.malloc_ptrs[pg_parser_state.malloc_ptr_idx - 1] + pg_parser_state.malloc_pos;
+	// store the length of the allocation
+	char *base_ptr = pg_parser_state.malloc_ptrs[pg_parser_state.malloc_ptr_idx - 1] + pg_parser_state.malloc_pos;
+	memcpy(base_ptr, &n, sizeof(size_t));
+	// store the actual pointer
+	char *ptr = (char*) base_ptr + sizeof(size_t);
 	memset(ptr, 0, n);
 	pg_parser_state.malloc_pos += aligned_n;
 	return ptr;
@@ -222861,7 +222967,14 @@ void *palloc0fast(size_t n) { // very fast
 	return palloc(n);
 }
 void *repalloc(void *ptr, size_t n) {
-	return palloc(n);
+	// get the length of the allocation
+	size_t old_len;
+	char *old_len_ptr = (char *) ptr - sizeof(size_t);
+	memcpy((void *) &old_len, old_len_ptr, sizeof(size_t));
+	// re-allocate and copy the data
+	void *new_buf = palloc(n);
+	memcpy(new_buf, ptr, old_len);
+	return new_buf;
 }
 char *NameListToString(PGList *names) {
 	throw std::runtime_error("NameListToString NOT IMPLEMENTED");