duckdb 0.8.2-dev2842.0 → 0.8.2-dev3007.0

package/src/duckdb/src/main/capi/prepared-c.cpp

@@ -139,52 +139,65 @@ duckdb_state duckdb_clear_bindings(duckdb_prepared_statement prepared_statement)
 	return DuckDBSuccess;
 }
 
-static duckdb_state duckdb_bind_value(duckdb_prepared_statement prepared_statement, idx_t param_idx, Value val) {
+duckdb_state duckdb_bind_value(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_value val) {
+	auto value = reinterpret_cast<Value *>(val);
 	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
 	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
 		return DuckDBError;
 	}
 	if (param_idx <= 0 || param_idx > wrapper->statement->n_param) {
+		wrapper->statement->error =
+		    duckdb::InvalidInputException("Can not bind to parameter number %d, statement only has %d parameter(s)",
+		                                  param_idx, wrapper->statement->n_param);
 		return DuckDBError;
 	}
 	auto identifier = duckdb_parameter_name_internal(prepared_statement, param_idx);
-	wrapper->values[identifier] = val;
+	wrapper->values[identifier] = *value;
 	return DuckDBSuccess;
 }
 
 duckdb_state duckdb_bind_parameter_index(duckdb_prepared_statement prepared_statement, idx_t *param_idx_out,
-                                         const char *name) {
+                                         const char *name_p) {
 	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
 	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
 		return DuckDBError;
 	}
-	auto &statement = wrapper->statement;
-	auto entry = statement->named_param_map.find(name);
-	if (entry == statement->named_param_map.end()) {
+	if (!name_p || !param_idx_out) {
 		return DuckDBError;
 	}
-	*param_idx_out = entry->second;
-	return DuckDBSuccess;
+	auto name = std::string(name_p);
+	for (auto &pair : wrapper->statement->named_param_map) {
+		if (duckdb::StringUtil::CIEquals(pair.first, name)) {
+			*param_idx_out = pair.second;
+			return DuckDBSuccess;
+		}
+	}
+	return DuckDBError;
 }
 
 duckdb_state duckdb_bind_boolean(duckdb_prepared_statement prepared_statement, idx_t param_idx, bool val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::BOOLEAN(val));
+	auto value = Value::BOOLEAN(val);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_int8(duckdb_prepared_statement prepared_statement, idx_t param_idx, int8_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::TINYINT(val));
+	auto value = Value::TINYINT(val);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_int16(duckdb_prepared_statement prepared_statement, idx_t param_idx, int16_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::SMALLINT(val));
+	auto value = Value::SMALLINT(val);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_int32(duckdb_prepared_statement prepared_statement, idx_t param_idx, int32_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::INTEGER(val));
+	auto value = Value::INTEGER(val);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_int64(duckdb_prepared_statement prepared_statement, idx_t param_idx, int64_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::BIGINT(val));
+	auto value = Value::BIGINT(val);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 static hugeint_t duckdb_internal_hugeint(duckdb_hugeint val) {
@@ -195,53 +208,65 @@ static hugeint_t duckdb_internal_hugeint(duckdb_hugeint val) {
 }
 
 duckdb_state duckdb_bind_hugeint(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_hugeint val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::HUGEINT(duckdb_internal_hugeint(val)));
+	auto value = Value::HUGEINT(duckdb_internal_hugeint(val));
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_uint8(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint8_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::UTINYINT(val));
+	auto value = Value::UTINYINT(val);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_uint16(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint16_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::USMALLINT(val));
+	auto value = Value::USMALLINT(val);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_uint32(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint32_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::UINTEGER(val));
+	auto value = Value::UINTEGER(val);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_uint64(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint64_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::UBIGINT(val));
+	auto value = Value::UBIGINT(val);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_float(duckdb_prepared_statement prepared_statement, idx_t param_idx, float val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::FLOAT(val));
+	auto value = Value::FLOAT(val);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_double(duckdb_prepared_statement prepared_statement, idx_t param_idx, double val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::DOUBLE(val));
+	auto value = Value::DOUBLE(val);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_date(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_date val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::DATE(date_t(val.days)));
+	auto value = Value::DATE(date_t(val.days));
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_time(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_time val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::TIME(dtime_t(val.micros)));
+	auto value = Value::TIME(dtime_t(val.micros));
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_timestamp(duckdb_prepared_statement prepared_statement, idx_t param_idx,
                                    duckdb_timestamp val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::TIMESTAMP(timestamp_t(val.micros)));
+	auto value = Value::TIMESTAMP(timestamp_t(val.micros));
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_interval(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_interval val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::INTERVAL(val.months, val.days, val.micros));
+	auto value = Value::INTERVAL(val.months, val.days, val.micros);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_varchar(duckdb_prepared_statement prepared_statement, idx_t param_idx, const char *val) {
 	try {
-		return duckdb_bind_value(prepared_statement, param_idx, Value(val));
+		auto value = Value(val);
+		return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 	} catch (...) {
 		return DuckDBError;
 	}
@@ -250,7 +275,8 @@ duckdb_state duckdb_bind_varchar(duckdb_prepared_statement prepared_statement, i
 duckdb_state duckdb_bind_varchar_length(duckdb_prepared_statement prepared_statement, idx_t param_idx, const char *val,
                                         idx_t length) {
 	try {
-		return duckdb_bind_value(prepared_statement, param_idx, Value(std::string(val, length)));
+		auto value = Value(std::string(val, length));
+		return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 	} catch (...) {
 		return DuckDBError;
 	}
@@ -259,19 +285,23 @@ duckdb_state duckdb_bind_varchar_length(duckdb_prepared_statement prepared_state
 duckdb_state duckdb_bind_decimal(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_decimal val) {
 	auto hugeint_val = duckdb_internal_hugeint(val.value);
 	if (val.width > duckdb::Decimal::MAX_WIDTH_INT64) {
-		return duckdb_bind_value(prepared_statement, param_idx, Value::DECIMAL(hugeint_val, val.width, val.scale));
+		auto value = Value::DECIMAL(hugeint_val, val.width, val.scale);
+		return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 	}
 	auto value = hugeint_val.lower;
-	return duckdb_bind_value(prepared_statement, param_idx, Value::DECIMAL((int64_t)value, val.width, val.scale));
+	auto duck_val = Value::DECIMAL((int64_t)value, val.width, val.scale);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&duck_val);
 }
 
 duckdb_state duckdb_bind_blob(duckdb_prepared_statement prepared_statement, idx_t param_idx, const void *data,
                               idx_t length) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::BLOB(duckdb::const_data_ptr_cast(data), length));
+	auto value = Value::BLOB(duckdb::const_data_ptr_cast(data), length);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_null(duckdb_prepared_statement prepared_statement, idx_t param_idx) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value());
+	auto value = Value();
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_execute_prepared(duckdb_prepared_statement prepared_statement, duckdb_result *out_result) {

package/src/duckdb/src/main/chunk_scan_state.cpp

@@ -3,6 +3,12 @@
 
 namespace duckdb {
 
+ChunkScanState::ChunkScanState() {
+}
+
+ChunkScanState::~ChunkScanState() {
+}
+
 idx_t ChunkScanState::CurrentOffset() const {
 	return offset;
 }

package/src/duckdb/src/main/client_context.cpp

@@ -317,7 +317,7 @@ ClientContext::CreatePreparedStatement(ClientContextLock &lock, const string &qu
 	if (values) {
 		auto &parameter_values = *values;
 		for (auto &value : parameter_values) {
-			planner.parameter_data.emplace(value);
+			planner.parameter_data.emplace(value.first, BoundParameterData(value.second));
 		}
 	}
 

package/src/duckdb/src/optimizer/topn_optimizer.cpp

@@ -12,6 +12,13 @@ bool TopN::CanOptimize(LogicalOperator &op) {
 	    op.children[0]->type == LogicalOperatorType::LOGICAL_ORDER_BY) {
 		auto &limit = op.Cast<LogicalLimit>();
 
+		// When there are some expressions in the limit operator,
+		// we shouldn't use this optimizations. Because of the expressions
+		// will be lost when it convert to TopN operator.
+		if (limit.limit || limit.offset) {
+			return false;
+		}
+
 		// This optimization doesn't apply when OFFSET is present without LIMIT
 		// Or if offset is not constant
 		if (limit.limit_val != NumericLimits<int64_t>::Maximum() || limit.offset) {

package/src/duckdb/src/parser/transform/constraint/transform_constraint.cpp

@@ -17,8 +17,58 @@ static void ParseSchemaTableNameFK(duckdb_libpgquery::PGRangeVar *input, Foreign
 	fk_info.table = input->relname;
 }
 
+static bool ForeignKeyActionSupported(char action) {
+	switch (action) {
+	case PG_FKCONSTR_ACTION_NOACTION:
+	case PG_FKCONSTR_ACTION_RESTRICT:
+		return true;
+	case PG_FKCONSTR_ACTION_CASCADE:
+	case PG_FKCONSTR_ACTION_SETDEFAULT:
+	case PG_FKCONSTR_ACTION_SETNULL:
+		return false;
+	default:
+		D_ASSERT(false);
+	}
+	return false;
+}
+
+static unique_ptr<ForeignKeyConstraint>
+TransformForeignKeyConstraint(duckdb_libpgquery::PGConstraint *constraint,
+                              optional_ptr<const string> override_fk_column = nullptr) {
+	D_ASSERT(constraint);
+	if (!ForeignKeyActionSupported(constraint->fk_upd_action) ||
+	    !ForeignKeyActionSupported(constraint->fk_del_action)) {
+		throw ParserException("FOREIGN KEY constraints cannot use CASCADE, SET NULL or SET DEFAULT");
+	}
+	ForeignKeyInfo fk_info;
+	fk_info.type = ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
+	ParseSchemaTableNameFK(constraint->pktable, fk_info);
+	vector<string> pk_columns, fk_columns;
+	if (override_fk_column) {
+		D_ASSERT(!constraint->fk_attrs);
+		fk_columns.emplace_back(*override_fk_column);
+	} else if (constraint->fk_attrs) {
+		for (auto kc = constraint->fk_attrs->head; kc; kc = kc->next) {
+			fk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
+		}
+	}
+	if (constraint->pk_attrs) {
+		for (auto kc = constraint->pk_attrs->head; kc; kc = kc->next) {
+			pk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
+		}
+	}
+	if (!pk_columns.empty() && pk_columns.size() != fk_columns.size()) {
+		throw ParserException("The number of referencing and referenced columns for foreign keys must be the same");
+	}
+	if (fk_columns.empty()) {
+		throw ParserException("The set of referencing and referenced columns for foreign keys must be not empty");
+	}
+	return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, std::move(fk_info));
+}
+
 unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGListCell *cell) {
 	auto constraint = reinterpret_cast<duckdb_libpgquery::PGConstraint *>(cell->data.ptr_value);
+	D_ASSERT(constraint);
 	switch (constraint->contype) {
 	case duckdb_libpgquery::PG_CONSTR_UNIQUE:
 	case duckdb_libpgquery::PG_CONSTR_PRIMARY: {
@@ -36,27 +86,9 @@ unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGLis
 		}
 		return make_uniq<CheckConstraint>(TransformExpression(constraint->raw_expr));
 	}
-	case duckdb_libpgquery::PG_CONSTR_FOREIGN: {
-		ForeignKeyInfo fk_info;
-		fk_info.type = ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
-		ParseSchemaTableNameFK(constraint->pktable, fk_info);
-		vector<string> pk_columns, fk_columns;
-		for (auto kc = constraint->fk_attrs->head; kc; kc = kc->next) {
-			fk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
-		}
-		if (constraint->pk_attrs) {
-			for (auto kc = constraint->pk_attrs->head; kc; kc = kc->next) {
-				pk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
-			}
-		}
-		if (!pk_columns.empty() && pk_columns.size() != fk_columns.size()) {
-			throw ParserException("The number of referencing and referenced columns for foreign keys must be the same");
-		}
-		if (fk_columns.empty()) {
-			throw ParserException("The set of referencing and referenced columns for foreign keys must be not empty");
-		}
-		return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, std::move(fk_info));
-	}
+	case duckdb_libpgquery::PG_CONSTR_FOREIGN:
+		return TransformForeignKeyConstraint(constraint);
+
 	default:
 		throw NotImplementedException("Constraint type not handled yet!");
 	}
@@ -96,23 +128,8 @@ unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGLis
 			                      "dictionary, pfor, bitpacking or fsst");
 		}
 		return nullptr;
-	case duckdb_libpgquery::PG_CONSTR_FOREIGN: {
-		ForeignKeyInfo fk_info;
-		fk_info.type = ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
-		ParseSchemaTableNameFK(constraint->pktable, fk_info);
-
-		vector<string> pk_columns, fk_columns;
-		fk_columns.emplace_back(column.Name().c_str());
-		if (constraint->pk_attrs) {
-			for (auto kc = constraint->pk_attrs->head; kc; kc = kc->next) {
-				pk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
-			}
-		}
-		if (!pk_columns.empty() && pk_columns.size() != fk_columns.size()) {
-			throw ParserException("The number of referencing and referenced columns for foreign keys must be the same");
-		}
-		return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, std::move(fk_info));
-	}
+	case duckdb_libpgquery::PG_CONSTR_FOREIGN:
+		return TransformForeignKeyConstraint(constraint, &column.Name());
 	default:
 		throw NotImplementedException("Constraint not implemented!");
 	}

package/src/duckdb/src/storage/compression/bitpacking.cpp

@@ -220,7 +220,7 @@ public:
 	void SubtractFrameOfReference(T_INNER *buffer, T_INNER frame_of_reference) {
 		static_assert(IsIntegral<T_INNER>::value, "Integral type required.");
 		for (idx_t i = 0; i < compression_buffer_idx; i++) {
-			buffer[i] -= frame_of_reference;
+			buffer[i] -= static_cast<typename MakeUnsigned<T_INNER>::type>(frame_of_reference);
 		}
 	}
 

package/src/duckdb/ub_src_common_adbc_nanoarrow.cpp

@@ -0,0 +1,8 @@
+#include "src/common/adbc/nanoarrow/metadata.cpp"
+
+#include "src/common/adbc/nanoarrow/schema.cpp"
+
+#include "src/common/adbc/nanoarrow/allocator.cpp"
+
+#include "src/common/adbc/nanoarrow/single_batch_array_stream.cpp"
+

package/src/duckdb_node.hpp

@@ -7,6 +7,7 @@
 #include <unordered_map>
 
 #include "duckdb/common/vector.hpp"
+#include "duckdb/common/arrow/arrow.hpp"
 
 using duckdb::vector;
 

package/src/statement.cpp

@@ -174,7 +174,7 @@ static Napi::Value convert_col_val(Napi::Env &env, duckdb::Value dval, duckdb::L
 			duckdb::Hugeint::NegateInPlace(val); // remove signing bit
 		}
 		D_ASSERT(val.upper >= 0);
-		const uint64_t words[] = {val.lower, (uint64_t)val.upper};
+		const uint64_t words[] = {val.lower, static_cast<uint64_t>(val.upper)};
 		value = Napi::BigInt::New(env, negative, 2, words);
 	} break;
 	case duckdb::LogicalTypeId::DECIMAL: {