duckdb 1.1.0 → 1.1.1

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

@@ -241,12 +241,16 @@ public:
 	};
 
 	//! Get JSON value using JSON path query (safe, checks the path query)
-	static inline yyjson_val *Get(yyjson_val *val, const string_t &path_str) {
+	static inline yyjson_val *Get(yyjson_val *val, const string_t &path_str, bool integral_argument) {
 		auto ptr = path_str.GetData();
 		auto len = path_str.GetSize();
 		if (len == 0) {
 			return GetUnsafe(val, ptr, len);
 		}
+		if (integral_argument) {
+			auto str = "$[" + path_str.GetString() + "]";
+			return GetUnsafe(val, str.c_str(), str.length());
+		}
 		switch (*ptr) {
 		case '/': {
 			// '/' notation must be '\0'-terminated
@@ -260,9 +264,15 @@ public:
 			}
 			return GetUnsafe(val, ptr, len);
 		}
-		default:
-			auto str = "/" + string(ptr, len);
-			return GetUnsafe(val, str.c_str(), len + 1);
+		default: {
+			string path;
+			if (memchr(ptr, '"', len)) {
+				path = "/" + string(ptr, len);
+			} else {
+				path = "$.\"" + path_str.GetString() + "\"";
+			}
+			return GetUnsafe(val, path.c_str(), path.length());
+		}
 		}
 	}
 

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

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "json_functions.hpp"
 
@@ -88,11 +89,18 @@ public:
 			}
 		} else { // Columnref path
 			D_ASSERT(info.path_type == JSONCommon::JSONPathType::REGULAR);
-			auto &paths = args.data[1];
+			unique_ptr<Vector> casted_paths;
+			if (args.data[1].GetType().id() == LogicalTypeId::VARCHAR) {
+				casted_paths = make_uniq<Vector>(args.data[1]);
+			} else {
+				casted_paths = make_uniq<Vector>(LogicalTypeId::VARCHAR);
+				VectorOperations::DefaultCast(args.data[1], *casted_paths, args.size(), true);
+			}
 			BinaryExecutor::ExecuteWithNulls<string_t, string_t, T>(
-			    inputs, paths, result, args.size(), [&](string_t input, string_t path, ValidityMask &mask, idx_t idx) {
+			    inputs, *casted_paths, result, args.size(),
+			    [&](string_t input, string_t path, ValidityMask &mask, idx_t idx) {
 				    auto doc = JSONCommon::ReadDocument(input, JSONCommon::READ_FLAG, lstate.json_allocator.GetYYAlc());
-				    auto val = JSONCommon::Get(doc->root, path);
+				    auto val = JSONCommon::Get(doc->root, path, args.data[1].GetType().IsIntegral());
 				    if (SET_NULL_IF_NOT_FOUND && !val) {
 					    mask.SetInvalid(idx);
 					    return T {};

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

@@ -27,7 +27,7 @@ static DefaultMacro json_macros[] = {
      "json_group_structure",
      {"x", nullptr},
      {{nullptr, nullptr}},
-     "json_structure(json_group_array(x))->'0'"},
+     "json_structure(json_group_array(x))->0"},
     {DEFAULT_SCHEMA, "json", {"x", nullptr}, {{nullptr, nullptr}}, "json_extract(x, '$')"},
     {nullptr, nullptr, {nullptr}, {{nullptr, nullptr}}, nullptr}};
 

package/src/duckdb/extension/json/json_functions/json_extract.cpp

@@ -6,9 +6,17 @@ static inline string_t ExtractFromVal(yyjson_val *val, yyjson_alc *alc, Vector &
 	return JSONCommon::WriteVal<yyjson_val>(val, alc);
 }
 
-static inline string_t ExtractStringFromVal(yyjson_val *val, yyjson_alc *alc, Vector &, ValidityMask &, idx_t) {
-	return yyjson_is_str(val) ? string_t(unsafe_yyjson_get_str(val), unsafe_yyjson_get_len(val))
-	                          : JSONCommon::WriteVal<yyjson_val>(val, alc);
+static inline string_t ExtractStringFromVal(yyjson_val *val, yyjson_alc *alc, Vector &, ValidityMask &mask, idx_t idx) {
+	switch (yyjson_get_tag(val)) {
+	case YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE:
+		mask.SetInvalid(idx);
+		return string_t {};
+	case YYJSON_TYPE_STR | YYJSON_SUBTYPE_NOESC:
+	case YYJSON_TYPE_STR | YYJSON_SUBTYPE_NONE:
+		return string_t(unsafe_yyjson_get_str(val), unsafe_yyjson_get_len(val));
+	default:
+		return JSONCommon::WriteVal<yyjson_val>(val, alc);
+	}
 }
 
 static void ExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {

package/src/duckdb/extension/json/json_functions/json_value.cpp

@@ -4,6 +4,7 @@ namespace duckdb {
 
 static inline string_t ValueFromVal(yyjson_val *val, yyjson_alc *alc, Vector &, ValidityMask &mask, idx_t idx) {
 	switch (yyjson_get_tag(val)) {
+	case YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE:
 	case YYJSON_TYPE_ARR | YYJSON_SUBTYPE_NONE:
 	case YYJSON_TYPE_OBJ | YYJSON_SUBTYPE_NONE:
 		mask.SetInvalid(idx);
@@ -22,12 +23,12 @@ static void ValueManyFunction(DataChunk &args, ExpressionState &state, Vector &r
 }
 
 static void GetValueFunctionsInternal(ScalarFunctionSet &set, const LogicalType &input_type) {
-	set.AddFunction(ScalarFunction({input_type, LogicalType::BIGINT}, LogicalType::JSON(), ValueFunction,
+	set.AddFunction(ScalarFunction({input_type, LogicalType::BIGINT}, LogicalType::VARCHAR, ValueFunction,
 	                               JSONReadFunctionData::Bind, nullptr, nullptr, JSONFunctionLocalState::Init));
-	set.AddFunction(ScalarFunction({input_type, LogicalType::VARCHAR}, LogicalType::JSON(), ValueFunction,
+	set.AddFunction(ScalarFunction({input_type, LogicalType::VARCHAR}, LogicalType::VARCHAR, ValueFunction,
 	                               JSONReadFunctionData::Bind, nullptr, nullptr, JSONFunctionLocalState::Init));
 	set.AddFunction(ScalarFunction({input_type, LogicalType::LIST(LogicalType::VARCHAR)},
-	                               LogicalType::LIST(LogicalType::JSON()), ValueManyFunction,
+	                               LogicalType::LIST(LogicalType::VARCHAR), ValueManyFunction,
 	                               JSONReadManyFunctionData::Bind, nullptr, nullptr, JSONFunctionLocalState::Init));
 }
 

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

@@ -21,21 +21,25 @@ static JSONPathType CheckPath(const Value &path_val, string &path, size_t &len)
 	const auto path_str_val = path_val.DefaultCastAs(LogicalType::VARCHAR);
 	auto path_str = path_str_val.GetValueUnsafe<string_t>();
 	len = path_str.GetSize();
-	auto ptr = path_str.GetData();
+	const auto ptr = path_str.GetData();
 	// Empty strings and invalid $ paths yield an error
 	if (len == 0) {
 		throw BinderException("Empty JSON path");
 	}
 	JSONPathType path_type = JSONPathType::REGULAR;
-	if (*ptr == '$') {
-		path_type = JSONCommon::ValidatePath(ptr, len, true);
-	}
 	// Copy over string to the bind data
 	if (*ptr == '/' || *ptr == '$') {
 		path = string(ptr, len);
-	} else {
+	} else if (path_val.type().IsIntegral()) {
+		path = "$[" + string(ptr, len) + "]";
+	} else if (memchr(ptr, '"', len)) {
 		path = "/" + string(ptr, len);
-		len++;
+	} else {
+		path = "$.\"" + string(ptr, len) + "\"";
+	}
+	len = path.length();
+	if (*path.c_str() == '$') {
+		path_type = JSONCommon::ValidatePath(path.c_str(), len, true);
 	}
 	return path_type;
 }
@@ -67,7 +71,11 @@ unique_ptr<FunctionData> JSONReadFunctionData::Bind(ClientContext &context, Scal
 			path_type = CheckPath(path_val, path, len);
 		}
 	}
-	bound_function.arguments[1] = LogicalType::VARCHAR;
+	if (arguments[1]->return_type.IsIntegral()) {
+		bound_function.arguments[1] = LogicalType::BIGINT;
+	} else {
+		bound_function.arguments[1] = LogicalType::VARCHAR;
+	}
 	if (path_type == JSONCommon::JSONPathType::WILDCARD) {
 		bound_function.return_type = LogicalType::LIST(bound_function.return_type);
 	}
@@ -117,6 +125,7 @@ unique_ptr<FunctionData> JSONReadManyFunctionData::Bind(ClientContext &context,
 
 JSONFunctionLocalState::JSONFunctionLocalState(Allocator &allocator) : json_allocator(allocator) {
 }
+
 JSONFunctionLocalState::JSONFunctionLocalState(ClientContext &context)
     : JSONFunctionLocalState(BufferAllocator::Get(context)) {
 }

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

@@ -259,6 +259,9 @@ void ColumnReader::PrepareRead(parquet_filter_t &filter) {
 		break;
 	case PageType::DICTIONARY_PAGE:
 		PreparePage(page_hdr);
+		if (page_hdr.dictionary_page_header.num_values < 0) {
+			throw std::runtime_error("Invalid dictionary page header (num_values < 0)");
+		}
 		Dictionary(std::move(block), page_hdr.dictionary_page_header.num_values);
 		break;
 	default:

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

@@ -1209,47 +1209,6 @@ public:
 	}
 };
 
-//===--------------------------------------------------------------------===//
-// Geometry Column Writer
-//===--------------------------------------------------------------------===//
-// This class just wraps another column writer, but also calculates the extent
-// of the geometry column by updating the geodata object with every written
-// vector.
-template <class WRITER_IMPL>
-class GeometryColumnWriter : public WRITER_IMPL {
-	GeoParquetColumnMetadata geo_data;
-	GeoParquetColumnMetadataWriter geo_data_writer;
-	string column_name;
-
-public:
-	void Write(ColumnWriterState &state, Vector &vector, idx_t count) override {
-		// Just write normally
-		WRITER_IMPL::Write(state, vector, count);
-
-		// And update the geodata object
-		geo_data_writer.Update(geo_data, vector, count);
-	}
-	void FinalizeWrite(ColumnWriterState &state) override {
-		WRITER_IMPL::FinalizeWrite(state);
-
-		// Add the geodata object to the writer
-		this->writer.GetGeoParquetData().geometry_columns[column_name] = geo_data;
-	}
-
-public:
-	GeometryColumnWriter(ClientContext &context, ParquetWriter &writer, idx_t schema_idx, vector<string> schema_path_p,
-	                     idx_t max_repeat, idx_t max_define, bool can_have_nulls, string name)
-	    : WRITER_IMPL(writer, schema_idx, std::move(schema_path_p), max_repeat, max_define, can_have_nulls),
-	      geo_data_writer(context), column_name(std::move(name)) {
-
-		auto &geo_data = writer.GetGeoParquetData();
-		if (geo_data.primary_geometry_column.empty()) {
-			// Set the first column to the primary column
-			geo_data.primary_geometry_column = column_name;
-		}
-	}
-};
-
 //===--------------------------------------------------------------------===//
 // String Column Writer
 //===--------------------------------------------------------------------===//
@@ -1563,6 +1522,58 @@ private:
 	}
 };
 
+//===--------------------------------------------------------------------===//
+// WKB Column Writer
+//===--------------------------------------------------------------------===//
+// Used to store the metadata for a WKB-encoded geometry column when writing
+// GeoParquet files.
+class WKBColumnWriterState final : public StringColumnWriterState {
+public:
+	WKBColumnWriterState(ClientContext &context, duckdb_parquet::format::RowGroup &row_group, idx_t col_idx)
+	    : StringColumnWriterState(row_group, col_idx), geo_data(), geo_data_writer(context) {
+	}
+
+	GeoParquetColumnMetadata geo_data;
+	GeoParquetColumnMetadataWriter geo_data_writer;
+};
+
+class WKBColumnWriter final : public StringColumnWriter {
+public:
+	WKBColumnWriter(ClientContext &context_p, ParquetWriter &writer, idx_t schema_idx, vector<string> schema_path_p,
+	                idx_t max_repeat, idx_t max_define, bool can_have_nulls, string name)
+	    : StringColumnWriter(writer, schema_idx, std::move(schema_path_p), max_repeat, max_define, can_have_nulls),
+	      column_name(std::move(name)), context(context_p) {
+
+		this->writer.GetGeoParquetData().RegisterGeometryColumn(column_name);
+	}
+
+	unique_ptr<ColumnWriterState> InitializeWriteState(duckdb_parquet::format::RowGroup &row_group) override {
+		auto result = make_uniq<WKBColumnWriterState>(context, row_group, row_group.columns.size());
+		RegisterToRowGroup(row_group);
+		return std::move(result);
+	}
+	void Write(ColumnWriterState &state, Vector &vector, idx_t count) override {
+		StringColumnWriter::Write(state, vector, count);
+
+		auto &geo_state = state.Cast<WKBColumnWriterState>();
+		geo_state.geo_data_writer.Update(geo_state.geo_data, vector, count);
+	}
+
+	void FinalizeWrite(ColumnWriterState &state) override {
+		StringColumnWriter::FinalizeWrite(state);
+
+		// Add the geodata object to the writer
+		const auto &geo_state = state.Cast<WKBColumnWriterState>();
+
+		// Merge this state's geo column data with the writer's geo column data
+		writer.GetGeoParquetData().FlushColumnMeta(column_name, geo_state.geo_data);
+	}
+
+private:
+	string column_name;
+	ClientContext &context;
+};
+
 //===--------------------------------------------------------------------===//
 // Enum Column Writer
 //===--------------------------------------------------------------------===//
@@ -2234,8 +2245,8 @@ unique_ptr<ColumnWriter> ColumnWriter::CreateWriterRecursive(ClientContext &cont
 	schema_path.push_back(name);
 
 	if (type.id() == LogicalTypeId::BLOB && type.GetAlias() == "WKB_BLOB") {
-		return make_uniq<GeometryColumnWriter<StringColumnWriter>>(context, writer, schema_idx, std::move(schema_path),
-		                                                           max_repeat, max_define, can_have_nulls, name);
+		return make_uniq<WKBColumnWriter>(context, writer, schema_idx, std::move(schema_path), max_repeat, max_define,
+		                                  can_have_nulls, name);
 	}
 
 	switch (type.id()) {

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

@@ -279,6 +279,17 @@ GeoParquetFileMetadata::TryRead(const duckdb_parquet::format::FileMetaData &file
 	return nullptr;
 }
 
+void GeoParquetFileMetadata::FlushColumnMeta(const string &column_name, const GeoParquetColumnMetadata &meta) {
+	// Lock the metadata
+	lock_guard<mutex> glock(write_lock);
+
+	auto &column = geometry_columns[column_name];
+
+	// Combine the metadata
+	column.geometry_types.insert(meta.geometry_types.begin(), meta.geometry_types.end());
+	column.bbox.Combine(meta.bbox);
+}
+
 void GeoParquetFileMetadata::Write(duckdb_parquet::format::FileMetaData &file_meta_data) const {
 
 	yyjson_mut_doc *doc = yyjson_mut_doc_new(nullptr);
@@ -349,6 +360,14 @@ bool GeoParquetFileMetadata::IsGeometryColumn(const string &column_name) const {
 	return geometry_columns.find(column_name) != geometry_columns.end();
 }
 
+void GeoParquetFileMetadata::RegisterGeometryColumn(const string &column_name) {
+	lock_guard<mutex> glock(write_lock);
+	if (primary_geometry_column.empty()) {
+		primary_geometry_column = column_name;
+	}
+	geometry_columns[column_name] = GeoParquetColumnMetadata();
+}
+
 unique_ptr<ColumnReader> GeoParquetFileMetadata::CreateColumnReader(ParquetReader &reader,
                                                                     const LogicalType &logical_type,
                                                                     const SchemaElement &s_ele, idx_t schema_idx_p,

package/src/duckdb/extension/parquet/include/geo_parquet.hpp

@@ -115,7 +115,7 @@ public:
 	void Update(GeoParquetColumnMetadata &meta, Vector &vector, idx_t count);
 };
 
-struct GeoParquetFileMetadata {
+class GeoParquetFileMetadata {
 public:
 	// Try to read GeoParquet metadata. Returns nullptr if not found, invalid or the required spatial extension is not
 	// available.
@@ -123,17 +123,21 @@ public:
 	                                                  ClientContext &context);
 	void Write(duckdb_parquet::format::FileMetaData &file_meta_data) const;
 
-public:
-	// Default to 1.1.0 for now
-	string version = "1.1.0";
-	string primary_geometry_column;
-	unordered_map<string, GeoParquetColumnMetadata> geometry_columns;
+	void FlushColumnMeta(const string &column_name, const GeoParquetColumnMetadata &meta);
+	const unordered_map<string, GeoParquetColumnMetadata> &GetColumnMeta() const;
 
 	unique_ptr<ColumnReader> CreateColumnReader(ParquetReader &reader, const LogicalType &logical_type,
 	                                            const duckdb_parquet::format::SchemaElement &s_ele, idx_t schema_idx_p,
 	                                            idx_t max_define_p, idx_t max_repeat_p, ClientContext &context);
 
 	bool IsGeometryColumn(const string &column_name) const;
+	void RegisterGeometryColumn(const string &column_name);
+
+private:
+	mutex write_lock;
+	string version = "1.1.0";
+	string primary_geometry_column;
+	unordered_map<string, GeoParquetColumnMetadata> geometry_columns;
 };
 
 } // namespace duckdb

package/src/duckdb/extension/parquet/include/templated_column_reader.hpp

@@ -68,9 +68,9 @@ public:
 
 	void Offsets(uint32_t *offsets, uint8_t *defines, uint64_t num_values, parquet_filter_t &filter,
 	             idx_t result_offset, Vector &result) override {
-		if (!dict) {
-			throw IOException(
-			    "Parquet file is likely corrupted, cannot have dictionary offsets without seeing a dictionary first.");
+		if (!dict || dict->len == 0) {
+			throw IOException("Parquet file is likely corrupted, cannot have dictionary offsets without seeing a "
+			                  "non-empty dictionary first.");
 		}
 		if (HasDefines()) {
 			OffsetsInternal<true>(*dict, offsets, defines, num_values, filter, result_offset, result);

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

@@ -350,7 +350,8 @@ ParquetWriter::ParquetWriter(ClientContext &context, FileSystem &fs, string file
 	file_meta_data.version = 1;
 
 	file_meta_data.__isset.created_by = true;
-	file_meta_data.created_by = "DuckDB";
+	file_meta_data.created_by =
+	    StringUtil::Format("DuckDB version %s (build %s)", DuckDB::LibraryVersion(), DuckDB::SourceID());
 
 	file_meta_data.schema.resize(1);
 

package/src/duckdb/src/common/arrow/arrow_converter.cpp

@@ -166,7 +166,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		break;
 	}
 	case LogicalTypeId::VARCHAR:
-		if (type.IsJSONType()) {
+		if (type.IsJSONType() && options.arrow_lossless_conversion) {
 			auto schema_metadata = ArrowSchemaMetadata::MetadataFromName("arrow.json");
 			root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata());
 			child.metadata = root_holder.metadata_info.back().get();

package/src/duckdb/src/common/arrow/arrow_merge_event.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/common/arrow/arrow_merge_event.hpp"
+#include "duckdb/common/arrow/arrow_util.hpp"
 #include "duckdb/storage/storage_info.hpp"
 
 namespace duckdb {

package/src/duckdb/src/common/arrow/arrow_util.cpp

@@ -0,0 +1,60 @@
+#include "duckdb/common/arrow/arrow_util.hpp"
+#include "duckdb/common/arrow/arrow_appender.hpp"
+#include "duckdb/common/types/data_chunk.hpp"
+
+namespace duckdb {
+
+bool ArrowUtil::TryFetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t batch_size, ArrowArray *out,
+                              idx_t &count, ErrorData &error) {
+	count = 0;
+	ArrowAppender appender(scan_state.Types(), batch_size, std::move(options));
+	auto remaining_tuples_in_chunk = scan_state.RemainingInChunk();
+	if (remaining_tuples_in_chunk) {
+		// We start by scanning the non-finished current chunk
+		idx_t cur_consumption = MinValue(remaining_tuples_in_chunk, batch_size);
+		count += cur_consumption;
+		auto &current_chunk = scan_state.CurrentChunk();
+		appender.Append(current_chunk, scan_state.CurrentOffset(), scan_state.CurrentOffset() + cur_consumption,
+		                current_chunk.size());
+		scan_state.IncreaseOffset(cur_consumption);
+	}
+	while (count < batch_size) {
+		if (!scan_state.LoadNextChunk(error)) {
+			if (scan_state.HasError()) {
+				error = scan_state.GetError();
+			}
+			return false;
+		}
+		if (scan_state.ChunkIsEmpty()) {
+			// The scan was successful, but an empty chunk was returned
+			break;
+		}
+		auto &current_chunk = scan_state.CurrentChunk();
+		if (scan_state.Finished() || current_chunk.size() == 0) {
+			break;
+		}
+		// The amount we still need to append into this chunk
+		auto remaining = batch_size - count;
+
+		// The amount remaining, capped by the amount left in the current chunk
+		auto to_append_to_batch = MinValue(remaining, scan_state.RemainingInChunk());
+		appender.Append(current_chunk, 0, to_append_to_batch, current_chunk.size());
+		count += to_append_to_batch;
+		scan_state.IncreaseOffset(to_append_to_batch);
+	}
+	if (count > 0) {
+		*out = appender.Finalize();
+	}
+	return true;
+}
+
+idx_t ArrowUtil::FetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t chunk_size, ArrowArray *out) {
+	ErrorData error;
+	idx_t result_count;
+	if (!TryFetchChunk(scan_state, std::move(options), chunk_size, out, result_count, error)) {
+		error.Throw();
+	}
+	return result_count;
+}
+
+} // namespace duckdb

package/src/duckdb/src/common/arrow/arrow_wrapper.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/common/arrow/arrow_wrapper.hpp"
+#include "duckdb/common/arrow/arrow_util.hpp"
 #include "duckdb/common/arrow/arrow_converter.hpp"
 
 #include "duckdb/common/assert.hpp"
@@ -176,57 +177,4 @@ ResultArrowArrayStreamWrapper::ResultArrowArrayStreamWrapper(unique_ptr<QueryRes
 	stream.get_last_error = ResultArrowArrayStreamWrapper::MyStreamGetLastError;
 }
 
-bool ArrowUtil::TryFetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t batch_size, ArrowArray *out,
-                              idx_t &count, ErrorData &error) {
-	count = 0;
-	ArrowAppender appender(scan_state.Types(), batch_size, std::move(options));
-	auto remaining_tuples_in_chunk = scan_state.RemainingInChunk();
-	if (remaining_tuples_in_chunk) {
-		// We start by scanning the non-finished current chunk
-		idx_t cur_consumption = MinValue(remaining_tuples_in_chunk, batch_size);
-		count += cur_consumption;
-		auto &current_chunk = scan_state.CurrentChunk();
-		appender.Append(current_chunk, scan_state.CurrentOffset(), scan_state.CurrentOffset() + cur_consumption,
-		                current_chunk.size());
-		scan_state.IncreaseOffset(cur_consumption);
-	}
-	while (count < batch_size) {
-		if (!scan_state.LoadNextChunk(error)) {
-			if (scan_state.HasError()) {
-				error = scan_state.GetError();
-			}
-			return false;
-		}
-		if (scan_state.ChunkIsEmpty()) {
-			// The scan was successful, but an empty chunk was returned
-			break;
-		}
-		auto &current_chunk = scan_state.CurrentChunk();
-		if (scan_state.Finished() || current_chunk.size() == 0) {
-			break;
-		}
-		// The amount we still need to append into this chunk
-		auto remaining = batch_size - count;
-
-		// The amount remaining, capped by the amount left in the current chunk
-		auto to_append_to_batch = MinValue(remaining, scan_state.RemainingInChunk());
-		appender.Append(current_chunk, 0, to_append_to_batch, current_chunk.size());
-		count += to_append_to_batch;
-		scan_state.IncreaseOffset(to_append_to_batch);
-	}
-	if (count > 0) {
-		*out = appender.Finalize();
-	}
-	return true;
-}
-
-idx_t ArrowUtil::FetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t chunk_size, ArrowArray *out) {
-	ErrorData error;
-	idx_t result_count;
-	if (!TryFetchChunk(scan_state, std::move(options), chunk_size, out, result_count, error)) {
-		error.Throw();
-	}
-	return result_count;
-}
-
 } // namespace duckdb

package/src/duckdb/src/common/cgroups.cpp

@@ -22,9 +22,7 @@ optional_idx CGroups::GetMemoryLimit(FileSystem &fs) {
 }
 
 optional_idx CGroups::GetCGroupV2MemoryLimit(FileSystem &fs) {
-#ifdef DUCKDB_WASM
-	return optional_idx();
-#else
+#if defined(__linux__) && !defined(DUCKDB_WASM)
 	const char *cgroup_self = "/proc/self/cgroup";
 	const char *memory_max = "/sys/fs/cgroup/%s/memory.max";
 
@@ -45,13 +43,13 @@ optional_idx CGroups::GetCGroupV2MemoryLimit(FileSystem &fs) {
 	}
 
 	return ReadCGroupValue(fs, memory_max_path);
+#else
+	return optional_idx();
 #endif
 }
 
 optional_idx CGroups::GetCGroupV1MemoryLimit(FileSystem &fs) {
-#ifdef DUCKDB_WASM
-	return optional_idx();
-#else
+#if defined(__linux__) && !defined(DUCKDB_WASM)
 	const char *cgroup_self = "/proc/self/cgroup";
 	const char *memory_limit = "/sys/fs/cgroup/memory/%s/memory.limit_in_bytes";
 
@@ -72,13 +70,13 @@ optional_idx CGroups::GetCGroupV1MemoryLimit(FileSystem &fs) {
 	}
 
 	return ReadCGroupValue(fs, memory_limit_path);
+#else
+	return optional_idx();
 #endif
 }
 
 string CGroups::ReadCGroupPath(FileSystem &fs, const char *cgroup_file) {
-#ifdef DUCKDB_WASM
-	return "";
-#else
+#if defined(__linux__) && !defined(DUCKDB_WASM)
 	auto handle = fs.OpenFile(cgroup_file, FileFlags::FILE_FLAGS_READ);
 	char buffer[1024];
 	auto bytes_read = fs.Read(*handle, buffer, sizeof(buffer) - 1);
@@ -90,15 +88,12 @@ string CGroups::ReadCGroupPath(FileSystem &fs, const char *cgroup_file) {
 	if (pos != string::npos) {
 		return content.substr(pos + 2);
 	}
-
-	return "";
 #endif
+	return "";
 }
 
 string CGroups::ReadMemoryCGroupPath(FileSystem &fs, const char *cgroup_file) {
-#ifdef DUCKDB_WASM
-	return "";
-#else
+#if defined(__linux__) && !defined(DUCKDB_WASM)
 	auto handle = fs.OpenFile(cgroup_file, FileFlags::FILE_FLAGS_READ);
 	char buffer[1024];
 	auto bytes_read = fs.Read(*handle, buffer, sizeof(buffer) - 1);
@@ -115,15 +110,12 @@ string CGroups::ReadMemoryCGroupPath(FileSystem &fs, const char *cgroup_file) {
 		}
 		content.erase(0, pos + 1);
 	}
-
-	return "";
 #endif
+	return "";
 }
 
 optional_idx CGroups::ReadCGroupValue(FileSystem &fs, const char *file_path) {
-#ifdef DUCKDB_WASM
-	return optional_idx();
-#else
+#if defined(__linux__) && !defined(DUCKDB_WASM)
 	auto handle = fs.OpenFile(file_path, FileFlags::FILE_FLAGS_READ);
 	char buffer[100];
 	auto bytes_read = fs.Read(*handle, buffer, 99);
@@ -133,15 +125,12 @@ optional_idx CGroups::ReadCGroupValue(FileSystem &fs, const char *file_path) {
 	if (TryCast::Operation<string_t, idx_t>(string_t(buffer), value)) {
 		return optional_idx(value);
 	}
-	return optional_idx();
 #endif
+	return optional_idx();
 }
 
 idx_t CGroups::GetCPULimit(FileSystem &fs, idx_t physical_cores) {
-#ifdef DUCKDB_WASM
-	return physical_cores;
-#else
-
+#if defined(__linux__) && !defined(DUCKDB_WASM)
 	static constexpr const char *cpu_max = "/sys/fs/cgroup/cpu.max";
 	static constexpr const char *cfs_quota = "/sys/fs/cgroup/cpu/cpu.cfs_quota_us";
 	static constexpr const char *cfs_period = "/sys/fs/cgroup/cpu/cpu.cfs_period_us";
@@ -183,6 +172,8 @@ idx_t CGroups::GetCPULimit(FileSystem &fs, idx_t physical_cores) {
 	} else {
 		return physical_cores;
 	}
+#else
+	return physical_cores;
 #endif
 }