duckdb 0.7.2-dev16.0 → 0.7.2-dev314.0

package/src/duckdb/src/include/duckdb/storage/statistics/numeric_stats.hpp

@@ -0,0 +1,157 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/statistics/numeric_stats.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/types/hugeint.hpp"
+#include "duckdb/common/enums/filter_propagate_result.hpp"
+#include "duckdb/common/enums/expression_type.hpp"
+#include "duckdb/common/operator/comparison_operators.hpp"
+#include "duckdb/common/types/value.hpp"
+
+namespace duckdb {
+class BaseStatistics;
+class FieldWriter;
+class FieldReader;
+struct SelectionVector;
+class Vector;
+
+struct NumericValueUnion {
+	union Val {
+		int8_t boolean;
+		int8_t tinyint;
+		int16_t smallint;
+		int32_t integer;
+		int64_t bigint;
+		uint8_t utinyint;
+		uint16_t usmallint;
+		uint32_t uinteger;
+		uint64_t ubigint;
+		hugeint_t hugeint;
+		float float_;
+		double double_;
+	} value_;
+
+	template <class T>
+	T &GetReferenceUnsafe() {
+		throw InternalException("NumericValueUnion::GetReferenceUnsafe called on unsupported type");
+	}
+};
+
+struct NumericStatsData {
+	//! Whether or not the value has a max value
+	bool has_min;
+	//! Whether or not the segment has a min value
+	bool has_max;
+	//! The minimum value of the segment
+	NumericValueUnion min;
+	//! The maximum value of the segment
+	NumericValueUnion max;
+};
+
+struct NumericStats {
+	//! Unknown statistics - i.e. "has_min" is false, "has_max" is false
+	DUCKDB_API static BaseStatistics CreateUnknown(LogicalType type);
+	//! Empty statistics - i.e. "min = MaxValue<type>, max = MinValue<type>"
+	DUCKDB_API static BaseStatistics CreateEmpty(LogicalType type);
+
+	//! Returns true if the stats has a constant value
+	DUCKDB_API static bool IsConstant(const BaseStatistics &stats);
+	//! Returns true if the stats has both a min and max value defined
+	DUCKDB_API static bool HasMinMax(const BaseStatistics &stats);
+	//! Returns true if the stats has a min value defined
+	DUCKDB_API static bool HasMin(const BaseStatistics &stats);
+	//! Returns true if the stats has a max value defined
+	DUCKDB_API static bool HasMax(const BaseStatistics &stats);
+	//! Returns the min value - throws an exception if there is no min value
+	DUCKDB_API static Value Min(const BaseStatistics &stats);
+	//! Returns the max value - throws an exception if there is no max value
+	DUCKDB_API static Value Max(const BaseStatistics &stats);
+	//! Sets the min value of the statistics
+	DUCKDB_API static void SetMin(BaseStatistics &stats, const Value &val);
+	//! Sets the max value of the statistics
+	DUCKDB_API static void SetMax(BaseStatistics &stats, const Value &val);
+
+	//! Check whether or not a given comparison with a constant could possibly be satisfied by rows given the statistics
+	DUCKDB_API static FilterPropagateResult CheckZonemap(const BaseStatistics &stats, ExpressionType comparison_type,
+	                                                     const Value &constant);
+
+	DUCKDB_API static void Merge(BaseStatistics &stats, const BaseStatistics &other_p);
+
+	DUCKDB_API static void Serialize(const BaseStatistics &stats, FieldWriter &writer);
+	DUCKDB_API static BaseStatistics Deserialize(FieldReader &reader, LogicalType type);
+
+	DUCKDB_API static string ToString(const BaseStatistics &stats);
+
+	template <class T>
+	static inline void UpdateValue(T new_value, T &min, T &max) {
+		if (LessThan::Operation(new_value, min)) {
+			min = new_value;
+		}
+		if (GreaterThan::Operation(new_value, max)) {
+			max = new_value;
+		}
+	}
+
+	template <class T>
+	static inline void Update(BaseStatistics &stats, T new_value) {
+		auto &nstats = NumericStats::GetDataUnsafe(stats);
+		UpdateValue<T>(new_value, nstats.min.GetReferenceUnsafe<T>(), nstats.max.GetReferenceUnsafe<T>());
+	}
+
+	static void Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count);
+
+	template <class T>
+	static T GetMinUnsafe(const BaseStatistics &stats) {
+		return NumericStats::Min(stats).template GetValueUnsafe<T>();
+	}
+	template <class T>
+	static T GetMaxUnsafe(const BaseStatistics &stats) {
+		return NumericStats::Max(stats).template GetValueUnsafe<T>();
+	}
+
+private:
+	static NumericStatsData &GetDataUnsafe(BaseStatistics &stats);
+	static const NumericStatsData &GetDataUnsafe(const BaseStatistics &stats);
+	static Value MinOrNull(const BaseStatistics &stats);
+	static Value MaxOrNull(const BaseStatistics &stats);
+	template <class T>
+	static void TemplatedVerify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count);
+};
+
+template <>
+void NumericStats::Update<interval_t>(BaseStatistics &stats, interval_t new_value);
+template <>
+void NumericStats::Update<list_entry_t>(BaseStatistics &stats, list_entry_t new_value);
+
+template <>
+int8_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+int16_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+int32_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+int64_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+hugeint_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+uint8_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+uint16_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+uint32_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+uint64_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+float &NumericValueUnion::GetReferenceUnsafe();
+template <>
+double &NumericValueUnion::GetReferenceUnsafe();
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/statistics/segment_statistics.hpp

@@ -17,15 +17,10 @@ namespace duckdb {
 class SegmentStatistics {
 public:
 	SegmentStatistics(LogicalType type);
-	SegmentStatistics(LogicalType type, unique_ptr<BaseStatistics> statistics);
-
-	LogicalType type;
+	SegmentStatistics(BaseStatistics statistics);
 
 	//! Type-specific statistics of the segment
-	unique_ptr<BaseStatistics> statistics;
-
-public:
-	void Reset();
+	BaseStatistics statistics;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/statistics/string_stats.hpp

@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/statistics/string_stats.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/types/hugeint.hpp"
+#include "duckdb/common/enums/filter_propagate_result.hpp"
+#include "duckdb/common/enums/expression_type.hpp"
+#include "duckdb/common/operator/comparison_operators.hpp"
+
+namespace duckdb {
+class BaseStatistics;
+class FieldWriter;
+class FieldReader;
+struct SelectionVector;
+class Vector;
+
+struct StringStatsData {
+	constexpr static uint32_t MAX_STRING_MINMAX_SIZE = 8;
+
+	//! The minimum value of the segment, potentially truncated
+	data_t min[MAX_STRING_MINMAX_SIZE];
+	//! The maximum value of the segment, potentially truncated
+	data_t max[MAX_STRING_MINMAX_SIZE];
+	//! Whether or not the column can contain unicode characters
+	bool has_unicode;
+	//! Whether or not the maximum string length is known
+	bool has_max_string_length;
+	//! The maximum string length in bytes
+	uint32_t max_string_length;
+};
+
+struct StringStats {
+	//! Unknown statistics - i.e. "has_unicode" is true, "max_string_length" is unknown, "min" is \0, max is \xFF
+	DUCKDB_API static BaseStatistics CreateUnknown(LogicalType type);
+	//! Empty statistics - i.e. "has_unicode" is false, "max_string_length" is 0, "min" is \xFF, max is \x00
+	DUCKDB_API static BaseStatistics CreateEmpty(LogicalType type);
+	//! Whether or not the statistics have a maximum string length defined
+	DUCKDB_API static bool HasMaxStringLength(const BaseStatistics &stats);
+	//! Returns the maximum string length, or throws an exception if !HasMaxStringLength()
+	DUCKDB_API static uint32_t MaxStringLength(const BaseStatistics &stats);
+	//! Whether or not the strings can contain unicode
+	DUCKDB_API static bool CanContainUnicode(const BaseStatistics &stats);
+
+	//! Resets the max string length so HasMaxStringLength() is false
+	DUCKDB_API static void ResetMaxStringLength(BaseStatistics &stats);
+	//! FIXME: make this part of Set on statistics
+	DUCKDB_API static void SetContainsUnicode(BaseStatistics &stats);
+
+	DUCKDB_API static void Serialize(const BaseStatistics &stats, FieldWriter &writer);
+	DUCKDB_API static BaseStatistics Deserialize(FieldReader &reader, LogicalType type);
+
+	DUCKDB_API static string ToString(const BaseStatistics &stats);
+
+	DUCKDB_API static FilterPropagateResult CheckZonemap(const BaseStatistics &stats, ExpressionType comparison_type,
+	                                                     const string &value);
+
+	DUCKDB_API static void Update(BaseStatistics &stats, const string_t &value);
+	DUCKDB_API static void Merge(BaseStatistics &stats, const BaseStatistics &other);
+	DUCKDB_API static void Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count);
+
+private:
+	static StringStatsData &GetDataUnsafe(BaseStatistics &stats);
+	static const StringStatsData &GetDataUnsafe(const BaseStatistics &stats);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/statistics/struct_stats.hpp

@@ -0,0 +1,42 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/statistics/struct_stats.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/exception.hpp"
+
+namespace duckdb {
+class BaseStatistics;
+class FieldWriter;
+class FieldReader;
+struct SelectionVector;
+class Vector;
+
+struct StructStats {
+	DUCKDB_API static void Construct(BaseStatistics &stats);
+	DUCKDB_API static BaseStatistics CreateUnknown(LogicalType type);
+	DUCKDB_API static BaseStatistics CreateEmpty(LogicalType type);
+
+	DUCKDB_API static const BaseStatistics *GetChildStats(const BaseStatistics &stats);
+	DUCKDB_API static const BaseStatistics &GetChildStats(const BaseStatistics &stats, idx_t i);
+	DUCKDB_API static BaseStatistics &GetChildStats(BaseStatistics &stats, idx_t i);
+	DUCKDB_API static void SetChildStats(BaseStatistics &stats, idx_t i, const BaseStatistics &new_stats);
+	DUCKDB_API static void SetChildStats(BaseStatistics &stats, idx_t i, unique_ptr<BaseStatistics> new_stats);
+
+	DUCKDB_API static void Serialize(const BaseStatistics &stats, FieldWriter &writer);
+	DUCKDB_API static BaseStatistics Deserialize(FieldReader &reader, LogicalType type);
+
+	DUCKDB_API static string ToString(const BaseStatistics &stats);
+
+	DUCKDB_API static void Merge(BaseStatistics &stats, const BaseStatistics &other);
+	DUCKDB_API static void Copy(BaseStatistics &stats, const BaseStatistics &other);
+	DUCKDB_API static void Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/string_uncompressed.hpp

@@ -9,7 +9,7 @@
 #include "duckdb/storage/buffer_manager.hpp"
 #include "duckdb/storage/checkpoint/string_checkpoint_state.hpp"
 #include "duckdb/storage/segment/uncompressed.hpp"
-#include "duckdb/storage/statistics/string_statistics.hpp"
+
 #include "duckdb/storage/string_uncompressed.hpp"
 #include "duckdb/storage/table/append_state.hpp"
 #include "duckdb/storage/table/column_segment.hpp"
@@ -173,8 +173,7 @@ public:
 
 public:
 	static inline void UpdateStringStats(SegmentStatistics &stats, const string_t &new_value) {
-		auto &sstats = (StringStatistics &)*stats.statistics;
-		sstats.Update(new_value);
+		StringStats::Update(stats.statistics, new_value);
 	}
 
 	static void SetDictionary(ColumnSegment &segment, BufferHandle &handle, StringDictionaryContainer dict);

package/src/duckdb/src/include/duckdb/storage/table/column_segment.hpp

@@ -57,7 +57,7 @@ public:
 	static unique_ptr<ColumnSegment> CreatePersistentSegment(DatabaseInstance &db, BlockManager &block_manager,
 	                                                         block_id_t id, idx_t offset, const LogicalType &type_p,
 	                                                         idx_t start, idx_t count, CompressionType compression_type,
-	                                                         unique_ptr<BaseStatistics> statistics);
+	                                                         BaseStatistics statistics);
 	static unique_ptr<ColumnSegment> CreateTransientSegment(DatabaseInstance &db, const LogicalType &type, idx_t start,
 	                                                        idx_t segment_size = Storage::BLOCK_SIZE);
 	static unique_ptr<ColumnSegment> CreateSegment(ColumnSegment &other, idx_t start);
@@ -124,7 +124,7 @@ public:
 
 public:
 	ColumnSegment(DatabaseInstance &db, shared_ptr<BlockHandle> block, LogicalType type, ColumnSegmentType segment_type,
-	              idx_t start, idx_t count, CompressionFunction *function, unique_ptr<BaseStatistics> statistics,
+	              idx_t start, idx_t count, CompressionFunction *function, BaseStatistics statistics,
 	              block_id_t block_id, idx_t offset, idx_t segment_size);
 	ColumnSegment(ColumnSegment &other, idx_t start);
 

package/src/duckdb/src/include/duckdb/storage/table/list_column_data.hpp

@@ -61,7 +61,7 @@ public:
 	void GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, TableStorageInfo &result) override;
 
 private:
-	list_entry_t FetchListEntry(idx_t row_idx);
+	uint64_t FetchListOffset(idx_t row_idx);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/table/persistent_table_data.hpp

@@ -12,6 +12,7 @@
 #include "duckdb/common/vector.hpp"
 #include "duckdb/storage/table/segment_tree.hpp"
 #include "duckdb/storage/data_pointer.hpp"
+#include "duckdb/storage/table/table_statistics.hpp"
 
 namespace duckdb {
 class BaseStatistics;
@@ -22,7 +23,7 @@ public:
 	~PersistentTableData();
 
 	vector<RowGroupPointer> row_groups;
-	vector<unique_ptr<BaseStatistics>> column_stats;
+	TableStatistics table_stats;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/table/row_group.hpp

@@ -29,6 +29,7 @@ struct DataTableInfo;
 class ExpressionExecutor;
 class RowGroupWriter;
 class UpdateSegment;
+class TableStatistics;
 class TableStorageInfo;
 class Vector;
 struct ColumnCheckpointState;
@@ -38,7 +39,7 @@ struct VersionNode;
 
 struct RowGroupWriteData {
 	vector<unique_ptr<ColumnCheckpointState>> states;
-	vector<unique_ptr<BaseStatistics>> statistics;
+	vector<BaseStatistics> statistics;
 };
 
 class RowGroup : public SegmentBase {
@@ -69,7 +70,7 @@ private:
 	//! The column data of the row_group
 	vector<shared_ptr<ColumnData>> columns;
 	//! The segment statistics for each of the columns
-	vector<shared_ptr<SegmentStatistics>> stats;
+	vector<SegmentStatistics> stats;
 
 public:
 	DatabaseInstance &GetDatabase();
@@ -132,7 +133,7 @@ public:
 	idx_t Delete(TransactionData transaction, DataTable *table, row_t *row_ids, idx_t count);
 
 	RowGroupWriteData WriteToDisk(PartialBlockManager &manager, const vector<CompressionType> &compression_types);
-	RowGroupPointer Checkpoint(RowGroupWriter &writer, vector<unique_ptr<BaseStatistics>> &global_stats);
+	RowGroupPointer Checkpoint(RowGroupWriter &writer, TableStatistics &global_stats);
 	static void Serialize(RowGroupPointer &pointer, Serializer &serializer);
 	static RowGroupPointer Deserialize(Deserializer &source, const ColumnList &columns);
 

package/src/duckdb/src/include/duckdb/storage/table/row_group_collection.hpp

@@ -78,7 +78,7 @@ public:
 	void UpdateColumn(TransactionData transaction, Vector &row_ids, const vector<column_t> &column_path,
 	                  DataChunk &updates);
 
-	void Checkpoint(TableDataWriter &writer, vector<unique_ptr<BaseStatistics>> &global_stats);
+	void Checkpoint(TableDataWriter &writer, TableStatistics &global_stats);
 
 	void CommitDropColumn(idx_t index);
 	void CommitDropTable();
@@ -93,8 +93,9 @@ public:
 	                                         vector<column_t> bound_columns, Expression &cast_expr);
 	void VerifyNewConstraint(DataTable &parent, const BoundConstraint &constraint);
 
+	void CopyStats(TableStatistics &stats);
 	unique_ptr<BaseStatistics> CopyStats(column_t column_id);
-	void SetStatistics(column_t column_id, const std::function<void(BaseStatistics &)> &set_fun);
+	void SetDistinct(column_t column_id, unique_ptr<DistinctStatistics> distinct_stats);
 
 private:
 	bool IsEmpty(SegmentLock &) const;

package/src/duckdb/src/include/duckdb/storage/table/scan_state.hpp

@@ -64,6 +64,8 @@ struct ColumnScanState {
 	//! We initialize one SegmentScanState per segment, however, if scanning a DataChunk requires us to scan over more
 	//! than one Segment, we need to keep the scan states of the previous segments around
 	vector<unique_ptr<SegmentScanState>> previous_states;
+	//! The last read offset in the child state (used for LIST columns only)
+	idx_t last_offset = 0;
 
 public:
 	//! Move the scan state forward by "count" rows (including all child states)

package/src/duckdb/src/include/duckdb/storage/table/table_statistics.hpp

@@ -14,6 +14,7 @@
 #include "duckdb/storage/statistics/column_statistics.hpp"
 
 namespace duckdb {
+class ColumnList;
 class PersistentTableData;
 
 class TableStatisticsLock {
@@ -38,6 +39,7 @@ public:
 	void MergeStats(idx_t i, BaseStatistics &stats);
 	void MergeStats(TableStatisticsLock &lock, idx_t i, BaseStatistics &stats);
 
+	void CopyStats(TableStatistics &other);
 	unique_ptr<BaseStatistics> CopyStats(idx_t i);
 	ColumnStatistics &GetStats(idx_t i);
 
@@ -45,6 +47,9 @@ public:
 
 	unique_ptr<TableStatisticsLock> GetLock();
 
+	void Serialize(Serializer &serializer);
+	void Deserialize(Deserializer &source, ColumnList &columns);
+
 private:
 	//! The statistics lock
 	mutex stats_lock;

package/src/duckdb/src/include/duckdb.h

@@ -35,7 +35,10 @@
 #endif
 #endif
 
-// duplicate of duckdb/common/constants.hpp
+// API versions
+// if no explicit API version is defined, the latest API version is used
+// Note that using older API versions (i.e. not using DUCKDB_API_LATEST) is deprecated.
+// These will not be supported long-term, and will be removed in future versions.
 #ifndef DUCKDB_API_0_3_1
 #define DUCKDB_API_0_3_1 1
 #endif
@@ -570,6 +573,14 @@ Use `duckdb_result_chunk_count` to figure out how many chunks there are in the r
 */
 DUCKDB_API duckdb_data_chunk duckdb_result_get_chunk(duckdb_result result, idx_t chunk_index);
 
+/*!
+Checks if the type of the internal result is StreamQueryResult.
+
+* result: The result object to check.
+* returns: Whether or not the result object is of the type StreamQueryResult
+*/
+DUCKDB_API bool duckdb_result_is_streaming(duckdb_result result);
+
 /*!
 Returns the number of data chunks present in the result.
 
@@ -1106,6 +1117,21 @@ Note that after calling `duckdb_pending_prepared`, the pending result should alw
 DUCKDB_API duckdb_state duckdb_pending_prepared(duckdb_prepared_statement prepared_statement,
                                                 duckdb_pending_result *out_result);
 
+/*!
+Executes the prepared statement with the given bound parameters, and returns a pending result.
+This pending result will create a streaming duckdb_result when executed.
+The pending result represents an intermediate structure for a query that is not yet fully executed.
+
+Note that after calling `duckdb_pending_prepared_streaming`, the pending result should always be destroyed using
+`duckdb_destroy_pending`, even if this function returns DuckDBError.
+
+* prepared_statement: The prepared statement to execute.
+* out_result: The pending query result.
+* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+*/
+DUCKDB_API duckdb_state duckdb_pending_prepared_streaming(duckdb_prepared_statement prepared_statement,
+                                                          duckdb_pending_result *out_result);
+
 /*!
 Closes the pending result and de-allocates all memory allocated for the result.
 
@@ -2319,6 +2345,28 @@ Returns true if execution of the current query is finished.
 */
 DUCKDB_API bool duckdb_execution_is_finished(duckdb_connection con);
 
+//===--------------------------------------------------------------------===//
+// Streaming Result Interface
+//===--------------------------------------------------------------------===//
+
+/*!
+Fetches a data chunk from the (streaming) duckdb_result. This function should be called repeatedly until the result is
+exhausted.
+
+The result must be destroyed with `duckdb_destroy_data_chunk`.
+
+This function can only be used on duckdb_results created with 'duckdb_pending_prepared_streaming'
+
+If this function is used, none of the other result functions can be used and vice versa (i.e. this function cannot be
+mixed with the legacy result functions or the materialized result functions).
+
+It is not known beforehand how many chunks will be returned by this result.
+
+* result: The result object to fetch the data chunk from.
+* returns: The resulting data chunk. Returns `NULL` if the result has an error.
+*/
+DUCKDB_API duckdb_data_chunk duckdb_stream_fetch_chunk(duckdb_result result);
+
 #ifdef __cplusplus
 }
 #endif

package/src/duckdb/src/include/duckdb.hpp

@@ -11,5 +11,4 @@
 #include "duckdb/main/connection.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/main/query_result.hpp"
-#include "duckdb/main/loadable_extension.hpp"
 #include "duckdb/main/appender.hpp"

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

@@ -9,14 +9,16 @@ using duckdb::PendingQueryResult;
 using duckdb::PendingStatementWrapper;
 using duckdb::PreparedStatementWrapper;
 
-duckdb_state duckdb_pending_prepared(duckdb_prepared_statement prepared_statement, duckdb_pending_result *out_result) {
+duckdb_state duckdb_pending_prepared_internal(duckdb_prepared_statement prepared_statement,
+                                              duckdb_pending_result *out_result, bool allow_streaming) {
 	if (!prepared_statement || !out_result) {
 		return DuckDBError;
 	}
 	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
 	auto result = new PendingStatementWrapper();
+	result->allow_streaming = allow_streaming;
 	try {
-		result->statement = wrapper->statement->PendingQuery(wrapper->values, false);
+		result->statement = wrapper->statement->PendingQuery(wrapper->values, allow_streaming);
 	} catch (const duckdb::Exception &ex) {
 		result->statement = make_unique<PendingQueryResult>(duckdb::PreservedError(ex));
 	} catch (std::exception &ex) {
@@ -28,6 +30,15 @@ duckdb_state duckdb_pending_prepared(duckdb_prepared_statement prepared_statemen
 	return return_value;
 }
 
+duckdb_state duckdb_pending_prepared(duckdb_prepared_statement prepared_statement, duckdb_pending_result *out_result) {
+	return duckdb_pending_prepared_internal(prepared_statement, out_result, false);
+}
+
+duckdb_state duckdb_pending_prepared_streaming(duckdb_prepared_statement prepared_statement,
+                                               duckdb_pending_result *out_result) {
+	return duckdb_pending_prepared_internal(prepared_statement, out_result, true);
+}
+
 void duckdb_destroy_pending(duckdb_pending_result *pending_result) {
 	if (!pending_result || !*pending_result) {
 		return;
@@ -90,7 +101,9 @@ duckdb_state duckdb_execute_pending(duckdb_pending_result pending_result, duckdb
 	if (!wrapper->statement) {
 		return DuckDBError;
 	}
-	auto result = wrapper->statement->Execute();
+
+	std::unique_ptr<duckdb::QueryResult> result;
+	result = wrapper->statement->Execute();
 	wrapper->statement.reset();
 	return duckdb_translate_result(std::move(result), out_result);
 }

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

@@ -292,6 +292,10 @@ bool deprecated_materialize_result(duckdb_result *result) {
 		// already used as a new result set
 		return false;
 	}
+	if (result_data->result_set_type == CAPIResultSetType::CAPI_RESULT_TYPE_STREAMING) {
+		// already used as a streaming result
+		return false;
+	}
 	// materialize as deprecated result set
 	result_data->result_set_type = CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED;
 	auto column_count = result_data->result->ColumnCount();
@@ -413,6 +417,10 @@ idx_t duckdb_row_count(duckdb_result *result) {
 		return 0;
 	}
 	auto &result_data = *((duckdb::DuckDBResultData *)result->internal_data);
+	if (result_data.result->type == duckdb::QueryResultType::STREAM_RESULT) {
+		// We can't know the row count beforehand
+		return 0;
+	}
 	auto &materialized = (duckdb::MaterializedQueryResult &)*result_data.result;
 	return materialized.RowCount();
 }
@@ -463,7 +471,10 @@ idx_t duckdb_result_chunk_count(duckdb_result result) {
 	if (result_data.result_set_type == duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED) {
 		return 0;
 	}
-	D_ASSERT(result_data.result->type == duckdb::QueryResultType::MATERIALIZED_RESULT);
+	if (result_data.result->type != duckdb::QueryResultType::MATERIALIZED_RESULT) {
+		// Can't know beforehand how many chunks are returned.
+		return 0;
+	}
 	auto &materialized = (duckdb::MaterializedQueryResult &)*result_data.result;
 	return materialized.Collection().ChunkCount();
 }
@@ -476,6 +487,10 @@ duckdb_data_chunk duckdb_result_get_chunk(duckdb_result result, idx_t chunk_idx)
 	if (result_data.result_set_type == duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED) {
 		return nullptr;
 	}
+	if (result_data.result->type != duckdb::QueryResultType::MATERIALIZED_RESULT) {
+		// This API is only supported for materialized query results
+		return nullptr;
+	}
 	result_data.result_set_type = duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_MATERIALIZED;
 	auto &materialized = (duckdb::MaterializedQueryResult &)*result_data.result;
 	auto &collection = materialized.Collection();
@@ -487,3 +502,14 @@ duckdb_data_chunk duckdb_result_get_chunk(duckdb_result result, idx_t chunk_idx)
 	collection.FetchChunk(chunk_idx, *chunk);
 	return reinterpret_cast<duckdb_data_chunk>(chunk.release());
 }
+
+bool duckdb_result_is_streaming(duckdb_result result) {
+	if (!result.internal_data) {
+		return false;
+	}
+	if (duckdb_result_error(&result) != nullptr) {
+		return false;
+	}
+	auto &result_data = *((duckdb::DuckDBResultData *)result.internal_data);
+	return result_data.result->type == duckdb::QueryResultType::STREAM_RESULT;
+}

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

@@ -0,0 +1,25 @@
+#include "duckdb/main/capi/capi_internal.hpp"
+#include "duckdb/common/types/timestamp.hpp"
+#include "duckdb/common/allocator.hpp"
+
+duckdb_data_chunk duckdb_stream_fetch_chunk(duckdb_result result) {
+	if (!result.internal_data) {
+		return nullptr;
+	}
+	auto &result_data = *((duckdb::DuckDBResultData *)result.internal_data);
+	if (result_data.result_set_type == duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED) {
+		return nullptr;
+	}
+	if (result_data.result->type != duckdb::QueryResultType::STREAM_RESULT) {
+		// We can only fetch from a StreamQueryResult
+		return nullptr;
+	}
+	result_data.result_set_type = duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_STREAMING;
+	auto &streaming = (duckdb::StreamQueryResult &)*result_data.result;
+	if (!streaming.IsOpen()) {
+		return nullptr;
+	}
+	// FetchRaw ? Do we care about flattening them?
+	auto chunk = streaming.Fetch();
+	return reinterpret_cast<duckdb_data_chunk>(chunk.release());
+}