duckdb 0.8.2-dev2700.0 → 0.8.2-dev2842.0

package/package.json

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

package/src/duckdb/extension/icu/icu-makedate.cpp

@@ -1,4 +1,6 @@
+#include "duckdb/common/operator/add.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/common/operator/subtract.hpp"
 #include "duckdb/common/types/date.hpp"
 #include "duckdb/common/types/time.hpp"
 #include "duckdb/common/types/timestamp.hpp"
@@ -66,7 +68,11 @@ struct ICUMakeDate : public ICUDateFunc {
 struct ICUMakeTimestampTZFunc : public ICUDateFunc {
 	template <typename T>
 	static inline timestamp_t Operation(icu::Calendar *calendar, T yyyy, T mm, T dd, T hr, T mn, double ss) {
-		const auto year = yyyy + (yyyy < 0);
+		const auto year = Cast::Operation<T, int32_t>(AddOperator::Operation<T, T, T>(yyyy, (yyyy < 0)));
+		const auto month = Cast::Operation<T, int32_t>(SubtractOperatorOverflowCheck::Operation<T, T, T>(mm, 1));
+		const auto day = Cast::Operation<T, int32_t>(dd);
+		const auto hour = Cast::Operation<T, int32_t>(hr);
+		const auto min = Cast::Operation<T, int32_t>(mn);
 
 		const auto secs = Cast::Operation<double, int32_t>(ss);
 		ss -= secs;
@@ -74,11 +80,11 @@ struct ICUMakeTimestampTZFunc : public ICUDateFunc {
 		const auto millis = int32_t(ss);
 		int64_t micros = std::round((ss - millis) * Interval::MICROS_PER_MSEC);
 
-		calendar->set(UCAL_YEAR, int32_t(year));
-		calendar->set(UCAL_MONTH, int32_t(mm - 1));
-		calendar->set(UCAL_DATE, int32_t(dd));
-		calendar->set(UCAL_HOUR_OF_DAY, int32_t(hr));
-		calendar->set(UCAL_MINUTE, int32_t(mn));
+		calendar->set(UCAL_YEAR, year);
+		calendar->set(UCAL_MONTH, month);
+		calendar->set(UCAL_DATE, day);
+		calendar->set(UCAL_HOUR_OF_DAY, hour);
+		calendar->set(UCAL_MINUTE, min);
 		calendar->set(UCAL_SECOND, secs);
 		calendar->set(UCAL_MILLISECOND, millis);
 

package/src/duckdb/extension/json/include/json_deserializer.hpp

@@ -48,7 +48,7 @@ private:
 	void ThrowTypeError(yyjson_val *val, const char *expected);
 
 	// Set the 'tag' of the property to read
-	void SetTag(const char *tag) final;
+	void SetTag(const field_id_t field_id, const char *tag) final;
 
 	//===--------------------------------------------------------------------===//
 	// Nested Types Hooks

package/src/duckdb/extension/json/include/json_serializer.hpp

@@ -42,7 +42,7 @@ public:
 		return stack.front();
 	};
 
-	void SetTag(const char *tag) final;
+	void SetTag(const field_id_t field_id, const char *tag) final;
 
 	//===--------------------------------------------------------------------===//
 	// Nested Types Hooks

package/src/duckdb/extension/json/json_deserializer.cpp

@@ -3,7 +3,7 @@
 
 namespace duckdb {
 
-void JsonDeserializer::SetTag(const char *tag) {
+void JsonDeserializer::SetTag(const field_id_t field_id, const char *tag) {
 	current_tag = tag;
 }
 
@@ -122,11 +122,11 @@ void JsonDeserializer::OnMapEntryBegin() {
 }
 
 void JsonDeserializer::OnMapKeyBegin() {
-	SetTag("key");
+	SetTag(100, "key");
 }
 
 void JsonDeserializer::OnMapValueBegin() {
-	SetTag("value");
+	SetTag(101, "value");
 }
 
 void JsonDeserializer::OnMapEntryEnd() {
@@ -146,11 +146,11 @@ void JsonDeserializer::OnPairBegin() {
 }
 
 void JsonDeserializer::OnPairKeyBegin() {
-	SetTag("key");
+	SetTag(100, "key");
 }
 
 void JsonDeserializer::OnPairValueBegin() {
-	SetTag("value");
+	SetTag(101, "value");
 }
 
 void JsonDeserializer::OnPairEnd() {
@@ -271,9 +271,9 @@ interval_t JsonDeserializer::ReadInterval() {
 	}
 	Push(val);
 	interval_t result;
-	ReadProperty("months", result.months);
-	ReadProperty("days", result.days);
-	ReadProperty("micros", result.micros);
+	ReadProperty(100, "months", result.months);
+	ReadProperty(101, "days", result.days);
+	ReadProperty(102, "micros", result.micros);
 	Pop();
 	return result;
 }
@@ -285,8 +285,8 @@ hugeint_t JsonDeserializer::ReadHugeInt() {
 	}
 	Push(val);
 	hugeint_t result;
-	ReadProperty("upper", result.upper);
-	ReadProperty("lower", result.lower);
+	ReadProperty(100, "upper", result.upper);
+	ReadProperty(101, "lower", result.lower);
 	Pop();
 	return result;
 }

package/src/duckdb/extension/json/json_scan.cpp

@@ -999,12 +999,12 @@ unique_ptr<FunctionData> JSONScan::Deserialize(PlanDeserializationState &state,
 void JSONScan::FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
                                const TableFunction &function) {
 	auto &bind_data = bind_data_p->Cast<JSONScanData>();
-	serializer.WriteProperty("scan_data", bind_data);
+	serializer.WriteProperty(100, "scan_data", bind_data);
 }
 
 unique_ptr<FunctionData> JSONScan::FormatDeserialize(FormatDeserializer &deserializer, TableFunction &function) {
 	unique_ptr<JSONScanData> result;
-	deserializer.ReadProperty("scan_data", result);
+	deserializer.ReadProperty(100, "scan_data", result);
 	return std::move(result);
 }
 

package/src/duckdb/extension/json/json_serializer.cpp

@@ -19,7 +19,8 @@ void JsonSerializer::PushValue(yyjson_mut_val *val) {
 	}
 }
 
-void JsonSerializer::SetTag(const char *tag) {
+void JsonSerializer::SetTag(const field_id_t field_id, const char *tag) {
+	(void)field_id;
 	current_tag = yyjson_mut_strcpy(doc, tag);
 }
 
@@ -63,11 +64,11 @@ void JsonSerializer::OnMapEntryBegin() {
 }
 
 void JsonSerializer::OnMapKeyBegin() {
-	SetTag("key");
+	SetTag(100, "key");
 }
 
 void JsonSerializer::OnMapValueBegin() {
-	SetTag("value");
+	SetTag(101, "value");
 }
 
 void JsonSerializer::OnMapEntryEnd() {
@@ -127,11 +128,11 @@ void JsonSerializer::OnPairBegin() {
 }
 
 void JsonSerializer::OnPairKeyBegin() {
-	SetTag("key");
+	SetTag(100, "key");
 }
 
 void JsonSerializer::OnPairValueBegin() {
-	SetTag("value");
+	SetTag(101, "value");
 }
 
 void JsonSerializer::OnPairEnd() {
@@ -190,8 +191,8 @@ void JsonSerializer::WriteValue(hugeint_t value) {
 	auto val = yyjson_mut_obj(doc);
 	PushValue(val);
 	stack.push_back(val);
-	WriteProperty("upper", value.upper);
-	WriteProperty("lower", value.lower);
+	WriteProperty(100, "upper", value.upper);
+	WriteProperty(101, "lower", value.lower);
 	stack.pop_back();
 }
 
@@ -209,9 +210,9 @@ void JsonSerializer::WriteValue(interval_t value) {
 	auto val = yyjson_mut_obj(doc);
 	PushValue(val);
 	stack.push_back(val);
-	WriteProperty("months", value.months);
-	WriteProperty("days", value.days);
-	WriteProperty("micros", value.micros);
+	WriteProperty(100, "months", value.months);
+	WriteProperty(101, "days", value.days);
+	WriteProperty(102, "micros", value.micros);
 	stack.pop_back();
 }
 

package/src/duckdb/extension/json/serialize_json.cpp

@@ -12,51 +12,51 @@
 namespace duckdb {
 
 void BufferedJSONReaderOptions::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("format", format);
-	serializer.WriteProperty("record_type", record_type);
-	serializer.WriteProperty("compression", compression);
-	serializer.WriteProperty("file_options", file_options);
+	serializer.WriteProperty(100, "format", format);
+	serializer.WriteProperty(101, "record_type", record_type);
+	serializer.WriteProperty(102, "compression", compression);
+	serializer.WriteProperty(103, "file_options", file_options);
 }
 
 BufferedJSONReaderOptions BufferedJSONReaderOptions::FormatDeserialize(FormatDeserializer &deserializer) {
 	BufferedJSONReaderOptions result;
-	deserializer.ReadProperty("format", result.format);
-	deserializer.ReadProperty("record_type", result.record_type);
-	deserializer.ReadProperty("compression", result.compression);
-	deserializer.ReadProperty("file_options", result.file_options);
+	deserializer.ReadProperty(100, "format", result.format);
+	deserializer.ReadProperty(101, "record_type", result.record_type);
+	deserializer.ReadProperty(102, "compression", result.compression);
+	deserializer.ReadProperty(103, "file_options", result.file_options);
 	return result;
 }
 
 void JSONScanData::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("json_type", type);
-	serializer.WriteProperty("options", options);
-	serializer.WriteProperty("reader_bind", reader_bind);
-	serializer.WriteProperty("files", files);
-	serializer.WriteProperty("ignore_errors", ignore_errors);
-	serializer.WriteProperty("maximum_object_size", maximum_object_size);
-	serializer.WriteProperty("auto_detect", auto_detect);
-	serializer.WriteProperty("sample_size", sample_size);
-	serializer.WriteProperty("max_depth", max_depth);
-	serializer.WriteProperty("transform_options", transform_options);
-	serializer.WriteProperty("names", names);
-	serializer.WriteProperty("date_format", GetDateFormat());
-	serializer.WriteProperty("timestamp_format", GetTimestampFormat());
+	serializer.WriteProperty(100, "json_type", type);
+	serializer.WriteProperty(101, "options", options);
+	serializer.WriteProperty(102, "reader_bind", reader_bind);
+	serializer.WriteProperty(103, "files", files);
+	serializer.WriteProperty(104, "ignore_errors", ignore_errors);
+	serializer.WriteProperty(105, "maximum_object_size", maximum_object_size);
+	serializer.WriteProperty(106, "auto_detect", auto_detect);
+	serializer.WriteProperty(107, "sample_size", sample_size);
+	serializer.WriteProperty(108, "max_depth", max_depth);
+	serializer.WriteProperty(109, "transform_options", transform_options);
+	serializer.WriteProperty(110, "names", names);
+	serializer.WriteProperty(111, "date_format", GetDateFormat());
+	serializer.WriteProperty(112, "timestamp_format", GetTimestampFormat());
 }
 
 unique_ptr<JSONScanData> JSONScanData::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto type = deserializer.ReadProperty<JSONScanType>("json_type");
-	auto options = deserializer.ReadProperty<BufferedJSONReaderOptions>("options");
-	auto reader_bind = deserializer.ReadProperty<MultiFileReaderBindData>("reader_bind");
-	auto files = deserializer.ReadProperty<vector<string>>("files");
-	auto ignore_errors = deserializer.ReadProperty<bool>("ignore_errors");
-	auto maximum_object_size = deserializer.ReadProperty<idx_t>("maximum_object_size");
-	auto auto_detect = deserializer.ReadProperty<bool>("auto_detect");
-	auto sample_size = deserializer.ReadProperty<idx_t>("sample_size");
-	auto max_depth = deserializer.ReadProperty<idx_t>("max_depth");
-	auto transform_options = deserializer.ReadProperty<JSONTransformOptions>("transform_options");
-	auto names = deserializer.ReadProperty<vector<string>>("names");
-	auto date_format = deserializer.ReadProperty<string>("date_format");
-	auto timestamp_format = deserializer.ReadProperty<string>("timestamp_format");
+	auto type = deserializer.ReadProperty<JSONScanType>(100, "json_type");
+	auto options = deserializer.ReadProperty<BufferedJSONReaderOptions>(101, "options");
+	auto reader_bind = deserializer.ReadProperty<MultiFileReaderBindData>(102, "reader_bind");
+	auto files = deserializer.ReadProperty<vector<string>>(103, "files");
+	auto ignore_errors = deserializer.ReadProperty<bool>(104, "ignore_errors");
+	auto maximum_object_size = deserializer.ReadProperty<idx_t>(105, "maximum_object_size");
+	auto auto_detect = deserializer.ReadProperty<bool>(106, "auto_detect");
+	auto sample_size = deserializer.ReadProperty<idx_t>(107, "sample_size");
+	auto max_depth = deserializer.ReadProperty<idx_t>(108, "max_depth");
+	auto transform_options = deserializer.ReadProperty<JSONTransformOptions>(109, "transform_options");
+	auto names = deserializer.ReadProperty<vector<string>>(110, "names");
+	auto date_format = deserializer.ReadProperty<string>(111, "date_format");
+	auto timestamp_format = deserializer.ReadProperty<string>(112, "timestamp_format");
 	auto result = duckdb::unique_ptr<JSONScanData>(new JSONScanData(deserializer.Get<ClientContext &>(), std::move(files), std::move(date_format), std::move(timestamp_format)));
 	result->type = type;
 	result->options = options;
@@ -72,20 +72,20 @@ unique_ptr<JSONScanData> JSONScanData::FormatDeserialize(FormatDeserializer &des
 }
 
 void JSONTransformOptions::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("strict_cast", strict_cast);
-	serializer.WriteProperty("error_duplicate_key", error_duplicate_key);
-	serializer.WriteProperty("error_missing_key", error_missing_key);
-	serializer.WriteProperty("error_unknown_key", error_unknown_key);
-	serializer.WriteProperty("delay_error", delay_error);
+	serializer.WriteProperty(100, "strict_cast", strict_cast);
+	serializer.WriteProperty(101, "error_duplicate_key", error_duplicate_key);
+	serializer.WriteProperty(102, "error_missing_key", error_missing_key);
+	serializer.WriteProperty(103, "error_unknown_key", error_unknown_key);
+	serializer.WriteProperty(104, "delay_error", delay_error);
 }
 
 JSONTransformOptions JSONTransformOptions::FormatDeserialize(FormatDeserializer &deserializer) {
 	JSONTransformOptions result;
-	deserializer.ReadProperty("strict_cast", result.strict_cast);
-	deserializer.ReadProperty("error_duplicate_key", result.error_duplicate_key);
-	deserializer.ReadProperty("error_missing_key", result.error_missing_key);
-	deserializer.ReadProperty("error_unknown_key", result.error_unknown_key);
-	deserializer.ReadProperty("delay_error", result.delay_error);
+	deserializer.ReadProperty(100, "strict_cast", result.strict_cast);
+	deserializer.ReadProperty(101, "error_duplicate_key", result.error_duplicate_key);
+	deserializer.ReadProperty(102, "error_missing_key", result.error_missing_key);
+	deserializer.ReadProperty(103, "error_unknown_key", result.error_unknown_key);
+	deserializer.ReadProperty(104, "delay_error", result.delay_error);
 	return result;
 }
 

package/src/duckdb/extension/parquet/parquet_extension.cpp

@@ -201,8 +201,9 @@ public:
 
 		for (auto &option : info.options) {
 			auto loption = StringUtil::Lower(option.first);
-			if (loption == "compression" || loption == "codec") {
-				// CODEC option has no effect on parquet read: we determine codec from the file
+			if (loption == "compression" || loption == "codec" || loption == "row_group_size") {
+				// CODEC/COMPRESSION and ROW_GROUP_SIZE options have no effect on parquet read.
+				// These options are determined from the file.
 				continue;
 			} else if (loption == "binary_as_string") {
 				parquet_options.binary_as_string = true;
@@ -437,19 +438,19 @@ public:
 	static void ParquetScanFormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
 	                                       const TableFunction &function) {
 		auto &bind_data = bind_data_p->Cast<ParquetReadBindData>();
-		serializer.WriteProperty("files", bind_data.files);
-		serializer.WriteProperty("types", bind_data.types);
-		serializer.WriteProperty("names", bind_data.names);
-		serializer.WriteProperty("parquet_options", bind_data.parquet_options);
+		serializer.WriteProperty(100, "files", bind_data.files);
+		serializer.WriteProperty(101, "types", bind_data.types);
+		serializer.WriteProperty(102, "names", bind_data.names);
+		serializer.WriteProperty(103, "parquet_options", bind_data.parquet_options);
 	}
 
 	static unique_ptr<FunctionData> ParquetScanFormatDeserialize(FormatDeserializer &deserializer,
 	                                                             TableFunction &function) {
 		auto &context = deserializer.Get<ClientContext &>();
-		auto files = deserializer.ReadProperty<vector<string>>("files");
-		auto types = deserializer.ReadProperty<vector<LogicalType>>("types");
-		auto names = deserializer.ReadProperty<vector<string>>("names");
-		auto parquet_options = deserializer.ReadProperty<ParquetOptions>("parquet_options");
+		auto files = deserializer.ReadProperty<vector<string>>(100, "files");
+		auto types = deserializer.ReadProperty<vector<LogicalType>>(101, "types");
+		auto names = deserializer.ReadProperty<vector<string>>(102, "names");
+		auto parquet_options = deserializer.ReadProperty<ParquetOptions>(103, "parquet_options");
 		return ParquetScanBindInternal(context, files, types, names, parquet_options);
 	}
 

package/src/duckdb/extension/parquet/serialize_parquet.cpp

@@ -10,16 +10,16 @@
 namespace duckdb {
 
 void ParquetOptions::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("binary_as_string", binary_as_string);
-	serializer.WriteProperty("file_row_number", file_row_number);
-	serializer.WriteProperty("file_options", file_options);
+	serializer.WriteProperty(100, "binary_as_string", binary_as_string);
+	serializer.WriteProperty(101, "file_row_number", file_row_number);
+	serializer.WriteProperty(102, "file_options", file_options);
 }
 
 ParquetOptions ParquetOptions::FormatDeserialize(FormatDeserializer &deserializer) {
 	ParquetOptions result;
-	deserializer.ReadProperty("binary_as_string", result.binary_as_string);
-	deserializer.ReadProperty("file_row_number", result.file_row_number);
-	deserializer.ReadProperty("file_options", result.file_options);
+	deserializer.ReadProperty(100, "binary_as_string", result.binary_as_string);
+	deserializer.ReadProperty(101, "file_row_number", result.file_row_number);
+	deserializer.ReadProperty(102, "file_options", result.file_options);
 	return result;
 }
 

package/src/duckdb/src/common/adbc/adbc.cpp

@@ -586,16 +586,14 @@ AdbcStatusCode StatementExecuteQuery(struct AdbcStatement *statement, struct Arr
 
 // this is a nop for us
 AdbcStatusCode StatementPrepare(struct AdbcStatement *statement, struct AdbcError *error) {
-	auto status = SetErrorMaybe(statement, error, "Missing statement object");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!statement) {
+		SetError(error, "Missing statement object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
-
-	status = SetErrorMaybe(statement->private_data, error, "Invalid statement object");
-	if (status != ADBC_STATUS_OK) {
-		return status;
+	if (!error) {
+		SetError(error, "Missing error object");
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
-
 	return ADBC_STATUS_OK;
 }
 
@@ -687,10 +685,6 @@ AdbcStatusCode QueryInternal(struct AdbcConnection *connection, struct ArrowArra
 AdbcStatusCode ConnectionGetObjects(struct AdbcConnection *connection, int depth, const char *catalog,
                                     const char *db_schema, const char *table_name, const char **table_type,
                                     const char *column_name, struct ArrowArrayStream *out, struct AdbcError *error) {
-	if (depth != 0) {
-		SetError(error, "Depth parameter not yet supported");
-		return ADBC_STATUS_NOT_IMPLEMENTED;
-	}
 	if (catalog != nullptr) {
 		if (strcmp(catalog, "duckdb") == 0) {
 			SetError(error, "catalog must be NULL or 'duckdb'");
@@ -702,16 +696,53 @@ AdbcStatusCode ConnectionGetObjects(struct AdbcConnection *connection, int depth
 		SetError(error, "Table types parameter not yet supported");
 		return ADBC_STATUS_NOT_IMPLEMENTED;
 	}
+	std::string query;
+	switch (depth) {
+	case ADBC_OBJECT_DEPTH_CATALOGS:
+		SetError(error, "ADBC_OBJECT_DEPTH_CATALOGS not yet supported");
+		return ADBC_STATUS_NOT_IMPLEMENTED;
+	case ADBC_OBJECT_DEPTH_DB_SCHEMAS:
+		// Return metadata on catalogs and schemas.
+		query = duckdb::StringUtil::Format(R"(
+				SELECT table_schema db_schema_name
+				FROM information_schema.columns
+				WHERE table_schema LIKE '%s' AND table_name LIKE '%s' AND column_name LIKE '%s' ;
+				)",
+		                                   db_schema ? db_schema : "%", table_name ? table_name : "%",
+		                                   column_name ? column_name : "%");
+		break;
+	case ADBC_OBJECT_DEPTH_TABLES:
+		// Return metadata on catalogs, schemas, and tables.
+		query = duckdb::StringUtil::Format(R"(
+				SELECT table_schema db_schema_name, LIST(table_schema_list) db_schema_tables
+				FROM (
+					SELECT table_schema, { table_name : table_name} table_schema_list
+					FROM information_schema.columns
+					WHERE table_schema LIKE '%s' AND table_name LIKE '%s' AND column_name LIKE '%s'  GROUP BY table_schema, table_name
+					) GROUP BY table_schema;
+				)",
+		                                   db_schema ? db_schema : "%", table_name ? table_name : "%",
+		                                   column_name ? column_name : "%");
+		break;
+	case ADBC_OBJECT_DEPTH_COLUMNS:
+		// Return metadata on catalogs, schemas, tables, and columns.
+		query = duckdb::StringUtil::Format(R"(
+				SELECT table_schema db_schema_name, LIST(table_schema_list) db_schema_tables
+				FROM (
+					SELECT table_schema, { table_name : table_name, table_columns : LIST({column_name : column_name, ordinal_position : ordinal_position + 1, remarks : ''})} table_schema_list
+					FROM information_schema.columns
+					WHERE table_schema LIKE '%s' AND table_name LIKE '%s' AND column_name LIKE '%s' GROUP BY table_schema, table_name
+					) GROUP BY table_schema;
+				)",
+		                                   db_schema ? db_schema : "%", table_name ? table_name : "%",
+		                                   column_name ? column_name : "%");
+		break;
+	default:
+		SetError(error, "Invalid value of Depth");
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
 
-	auto q = duckdb::StringUtil::Format(R"(
-SELECT table_schema db_schema_name, LIST(table_schema_list) db_schema_tables FROM (
-	SELECT table_schema, { table_name : table_name, table_columns : LIST({column_name : column_name, ordinal_position : ordinal_position + 1, remarks : ''})} table_schema_list FROM information_schema.columns WHERE table_schema LIKE '%s' AND table_name LIKE '%s' AND column_name LIKE '%s' GROUP BY table_schema, table_name
-	) GROUP BY table_schema;
-)",
-	                                    db_schema ? db_schema : "%", table_name ? table_name : "%",
-	                                    column_name ? column_name : "%");
-
-	return QueryInternal(connection, out, q.c_str(), error);
+	return QueryInternal(connection, out, query.c_str(), error);
 }
 
 AdbcStatusCode ConnectionGetTableTypes(struct AdbcConnection *connection, struct ArrowArrayStream *out,

package/src/duckdb/src/common/adbc/driver_manager.cpp

@@ -304,7 +304,12 @@ AdbcStatusCode AdbcConnectionGetObjects(struct AdbcConnection *connection, int d
                                         const char *db_schema, const char *table_name, const char **table_types,
                                         const char *column_name, struct ArrowArrayStream *stream,
                                         struct AdbcError *error) {
-	if (!connection->private_driver) {
+	if (!connection) {
+		SetError(error, "connection can't be null");
+		return ADBC_STATUS_INVALID_STATE;
+	}
+	if (!connection->private_data) {
+		SetError(error, "connection must be initialized");
 		return ADBC_STATUS_INVALID_STATE;
 	}
 	return connection->private_driver->ConnectionGetObjects(connection, depth, catalog, db_schema, table_name,
@@ -474,7 +479,12 @@ AdbcStatusCode AdbcStatementNew(struct AdbcConnection *connection, struct AdbcSt
 }
 
 AdbcStatusCode AdbcStatementPrepare(struct AdbcStatement *statement, struct AdbcError *error) {
-	if (!statement->private_driver) {
+	auto status = SetErrorMaybe(statement, error, "Missing statement object");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
+	status = SetErrorMaybe(statement->private_data, error, "Invalid statement object");
+	if (status != ADBC_STATUS_OK) {
 		return ADBC_STATUS_INVALID_STATE;
 	}
 	return statement->private_driver->StatementPrepare(statement, error);

package/src/duckdb/src/common/enum_util.cpp

@@ -3872,6 +3872,8 @@ const char* EnumUtil::ToChars<PendingExecutionResult>(PendingExecutionResult val
 		return "RESULT_NOT_READY";
 	case PendingExecutionResult::EXECUTION_ERROR:
 		return "EXECUTION_ERROR";
+	case PendingExecutionResult::NO_TASKS_AVAILABLE:
+		return "NO_TASKS_AVAILABLE";
 	default:
 		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
 	}
@@ -3888,6 +3890,9 @@ PendingExecutionResult EnumUtil::FromString<PendingExecutionResult>(const char *
 	if (StringUtil::Equals(value, "EXECUTION_ERROR")) {
 		return PendingExecutionResult::EXECUTION_ERROR;
 	}
+	if (StringUtil::Equals(value, "NO_TASKS_AVAILABLE")) {
+		return PendingExecutionResult::NO_TASKS_AVAILABLE;
+	}
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 

package/src/duckdb/src/common/extra_type_info.cpp

@@ -426,7 +426,7 @@ shared_ptr<ExtraTypeInfo> EnumTypeInfo::Deserialize(FieldReader &reader) {
 }
 
 shared_ptr<ExtraTypeInfo> EnumTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto enum_size = deserializer.ReadProperty<idx_t>("enum_size");
+	auto enum_size = deserializer.ReadProperty<idx_t>(200, "enum_size");
 	auto enum_internal_type = EnumTypeInfo::DictType(enum_size);
 	switch (enum_internal_type) {
 	case PhysicalType::UINT8:
@@ -476,7 +476,7 @@ void EnumTypeInfo::Serialize(FieldWriter &writer) const {
 
 void EnumTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
 	ExtraTypeInfo::FormatSerialize(serializer);
-	serializer.WriteProperty("dict_size", dict_size);
+	serializer.WriteProperty(200, "dict_size", dict_size);
 	((Vector &)values_insert_order).FormatSerialize(serializer, dict_size); // NOLINT - FIXME
 }
 

package/src/duckdb/src/common/serializer/binary_deserializer.cpp

@@ -2,7 +2,8 @@
 
 namespace duckdb {
 
-void BinaryDeserializer::SetTag(const char *tag) {
+void BinaryDeserializer::SetTag(const field_id_t field_id, const char *tag) {
+	current_field_id = field_id;
 	current_tag = tag;
 	stack.back().read_field_count++;
 	if (stack.back().read_field_count > stack.back().expected_field_count) {
@@ -14,12 +15,13 @@ void BinaryDeserializer::SetTag(const char *tag) {
 // Nested Types Hooks
 //===--------------------------------------------------------------------===//
 void BinaryDeserializer::OnObjectBegin() {
+	auto expected_field_id = ReadPrimitive<field_id_t>();
 	auto expected_field_count = ReadPrimitive<uint32_t>();
 	auto expected_size = ReadPrimitive<uint64_t>();
 	D_ASSERT(expected_field_count > 0);
 	D_ASSERT(expected_size > 0);
-
-	stack.emplace_back(expected_field_count, expected_size);
+	D_ASSERT(expected_field_id == current_field_id);
+	stack.emplace_back(expected_field_count, expected_size, expected_field_id);
 }
 
 void BinaryDeserializer::OnObjectEnd() {

package/src/duckdb/src/common/serializer/binary_serializer.cpp

@@ -2,9 +2,9 @@
 
 namespace duckdb {
 
-void BinarySerializer::SetTag(const char *tag) {
+void BinarySerializer::SetTag(const field_id_t field_id, const char *tag) {
+	current_field_id = field_id;
 	current_tag = tag;
-
 	// Increment the number of fields
 	stack.back().field_count++;
 }
@@ -45,6 +45,9 @@ void BinarySerializer::OnMapEnd(idx_t count) {
 
 void BinarySerializer::OnObjectBegin() {
 	stack.push_back(State({0, 0, data.size()}));
+	// Store the field id
+	Write<field_id_t>(current_field_id);
+	// Store the offset so we can patch the field count and size later
 	Write<uint32_t>(0); // Placeholder for the field count
 	Write<uint64_t>(0); // Placeholder for the size
 }
@@ -52,9 +55,11 @@ void BinarySerializer::OnObjectBegin() {
 void BinarySerializer::OnObjectEnd() {
 	auto &frame = stack.back();
 	// Patch the field count and size
-	auto message_start = &data[frame.offset];
-	Store<uint32_t>(frame.field_count, message_start);
-	Store<uint64_t>(frame.size, message_start + sizeof(uint32_t));
+	auto ptr = &data[frame.offset];
+	ptr += sizeof(field_id_t); // Skip the field id
+	Store<uint32_t>(frame.field_count, ptr);
+	ptr += sizeof(uint32_t); // Skip the field count
+	Store<uint64_t>(frame.size, ptr);
 	stack.pop_back();
 }
 

package/src/duckdb/src/common/types/column/column_data_collection.cpp

@@ -1069,13 +1069,13 @@ void ColumnDataCollection::FormatSerialize(FormatSerializer &serializer) const {
 			}
 		}
 	}
-	serializer.WriteProperty("types", types);
-	serializer.WriteProperty("values", values);
+	serializer.WriteProperty(100, "types", types);
+	serializer.WriteProperty(101, "values", values);
 }
 
 unique_ptr<ColumnDataCollection> ColumnDataCollection::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto types = deserializer.ReadProperty<vector<LogicalType>>("types");
-	auto values = deserializer.ReadProperty<vector<vector<Value>>>("values");
+	auto types = deserializer.ReadProperty<vector<LogicalType>>(100, "types");
+	auto values = deserializer.ReadProperty<vector<vector<Value>>>(101, "values");
 
 	auto collection = make_uniq<ColumnDataCollection>(Allocator::DefaultAllocator(), types);
 	if (values.empty()) {