duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/src/include/duckdb/parser/column_definition.hpp

@@ -31,7 +31,8 @@ public:
 
 public:
 	//! default_value
-	const unique_ptr<ParsedExpression> &DefaultValue() const;
+	const ParsedExpression &DefaultValue() const;
+	bool HasDefaultValue() const;
 	void SetDefaultValue(unique_ptr<ParsedExpression> default_value);
 
 	//! type
@@ -43,6 +44,10 @@ public:
 	DUCKDB_API const string &Name() const;
 	void SetName(const string &name);
 
+	//! comment
+	DUCKDB_API const Value &Comment() const;
+	void SetComment(const Value &comment);
+
 	//! compression_type
 	const duckdb::CompressionType &CompressionType() const;
 	void SetCompressionType(duckdb::CompressionType compression_type);
@@ -97,6 +102,8 @@ private:
 	//! The default value of the column (for non-generated columns)
 	//! The generated column expression (for generated columns)
 	unique_ptr<ParsedExpression> expression;
+	//! Comment on this column
+	Value comment;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/function_expression.hpp

@@ -63,9 +63,9 @@ public:
 
 public:
 	template <class T, class BASE, class ORDER_MODIFIER = OrderModifier>
-	static string ToString(const T &entry, const string &schema, const string &function_name, bool is_operator = false,
-	                       bool distinct = false, BASE *filter = nullptr, ORDER_MODIFIER *order_bys = nullptr,
-	                       bool export_state = false, bool add_alias = false) {
+	static string ToString(const T &entry, const string &catalog, const string &schema, const string &function_name,
+	                       bool is_operator = false, bool distinct = false, BASE *filter = nullptr,
+	                       ORDER_MODIFIER *order_bys = nullptr, bool export_state = false, bool add_alias = false) {
 		if (is_operator) {
 			// built-in operator
 			D_ASSERT(!distinct);
@@ -82,7 +82,14 @@ public:
 			}
 		}
 		// standard function call
-		string result = schema.empty() ? function_name : schema + "." + function_name;
+		string result;
+		if (!catalog.empty()) {
+			result += KeywordHelper::WriteOptionallyQuoted(catalog) + ".";
+		}
+		if (!schema.empty()) {
+			result += KeywordHelper::WriteOptionallyQuoted(schema) + ".";
+		}
+		result += function_name;
 		result += "(";
 		if (distinct) {
 			result += "DISTINCT ";

package/src/duckdb/src/include/duckdb/parser/expression/lambda_expression.hpp

@@ -8,15 +8,16 @@
 
 #pragma once
 
-#include "duckdb/parser/parsed_expression.hpp"
+#include "duckdb/common/unordered_set.hpp"
 #include "duckdb/common/vector.hpp"
+#include "duckdb/parser/parsed_expression.hpp"
 
 namespace duckdb {
 
 //! LambdaExpression represents either:
-//!  1. A lambda operator that can be used for e.g. mapping an expression to a list
-//!  2. An OperatorExpression with the "->" operator
-//! Lambda expressions are written in the form of "params -> expr", e.g. "x -> x + 1"
+//! 	1. A lambda function that can be used for, e.g., mapping an expression to a list
+//! 	2. An OperatorExpression with the "->" operator (JSON)
+//! Lambda expressions are written in the form of "params -> expr", e.g., "x -> x + 1"
 class LambdaExpression : public ParsedExpression {
 public:
 	static constexpr const ExpressionClass TYPE = ExpressionClass::LAMBDA;
@@ -24,18 +25,24 @@ public:
 public:
 	LambdaExpression(unique_ptr<ParsedExpression> lhs, unique_ptr<ParsedExpression> expr);
 
-	// we need the context to determine if this is a list of column references or an expression (for JSON)
+	//! The LHS of a lambda expression or the JSON "->"-operator. We need the context
+	//! to determine if the LHS is a list of column references (lambda parameters) or an expression (JSON)
 	unique_ptr<ParsedExpression> lhs;
-
-	vector<unique_ptr<ParsedExpression>> params;
+	//! The lambda or JSON expression (RHS)
 	unique_ptr<ParsedExpression> expr;
 
 public:
-	string ToString() const override;
+	//! Returns a vector to the column references in the LHS expression, and fills the error message,
+	//! if the LHS is not a valid lambda parameter list
+	vector<reference<ParsedExpression>> ExtractColumnRefExpressions(string &error_message);
+	//! Returns the error message for an invalid lambda parameter list
+	static string InvalidParametersErrorMessage();
+	//! Returns true, if the column_name is a lambda parameter name
+	static bool IsLambdaParameter(const vector<unordered_set<string>> &lambda_params, const string &column_name);
 
+	string ToString() const override;
 	static bool Equal(const LambdaExpression &a, const LambdaExpression &b);
 	hash_t Hash() const override;
-
 	unique_ptr<ParsedExpression> Copy() const override;
 
 	void Serialize(Serializer &serializer) const override;

package/src/duckdb/src/include/duckdb/parser/expression/lambdaref_expression.hpp

@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression/lambdaref_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/parser/parsed_expression.hpp"
+#include "duckdb/common/optional_ptr.hpp"
+
+namespace duckdb {
+
+struct DummyBinding;
+
+//! Represents a reference to a lambda parameter
+class LambdaRefExpression : public ParsedExpression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::LAMBDA_REF;
+
+public:
+	//! Constructs a LambdaRefExpression from a lambda_idx and a column_name. We do not specify a table name,
+	//! because we use dummy tables to bind lambda parameters
+	LambdaRefExpression(idx_t lambda_idx, string column_name_p);
+
+	//! The index of the lambda parameter in the lambda_bindings vector
+	idx_t lambda_idx;
+	//! The name of the lambda parameter (in a specific Binding in lambda_bindings)
+	string column_name;
+
+public:
+	bool IsScalar() const override;
+	string GetName() const override;
+	string ToString() const override;
+	hash_t Hash() const override;
+	unique_ptr<ParsedExpression> Copy() const override;
+
+	//! Traverses the lambda_bindings to find a matching binding for the column_name
+	static unique_ptr<ParsedExpression> FindMatchingBinding(optional_ptr<vector<DummyBinding>> &lambda_bindings,
+	                                                        const string &parameter_name);
+
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(Deserializer &deserializer);
+};
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/list.hpp

@@ -4,6 +4,7 @@
 #include "duckdb/parser/expression/cast_expression.hpp"
 #include "duckdb/parser/expression/collate_expression.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
+#include "duckdb/parser/expression/lambdaref_expression.hpp"
 #include "duckdb/parser/expression/comparison_expression.hpp"
 #include "duckdb/parser/expression/conjunction_expression.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"

package/src/duckdb/src/include/duckdb/parser/expression/window_expression.hpp

@@ -25,6 +25,9 @@ enum class WindowBoundary : uint8_t {
 	EXPR_FOLLOWING_RANGE = 8
 };
 
+//! Represents the window exclusion mode
+enum class WindowExcludeMode : uint8_t { NO_OTHER = 0, CURRENT_ROW = 1, GROUP = 2, TIES = 3 };
+
 const char *ToString(WindowBoundary value);
 
 //! The WindowExpression represents a window function in the query. They are a special case of aggregates which is why
@@ -52,9 +55,13 @@ public:
 	unique_ptr<ParsedExpression> filter_expr;
 	//! True to ignore NULL values
 	bool ignore_nulls;
+	//! Whether or not the aggregate function is distinct, only used for aggregates
+	bool distinct;
 	//! The window boundaries
 	WindowBoundary start = WindowBoundary::INVALID;
 	WindowBoundary end = WindowBoundary::INVALID;
+	//! The EXCLUDE clause
+	WindowExcludeMode exclude_clause = WindowExcludeMode::NO_OTHER;
 
 	unique_ptr<ParsedExpression> start_expr;
 	unique_ptr<ParsedExpression> end_expr;
@@ -86,8 +93,11 @@ public:
 		string result = schema.empty() ? function_name : schema + "." + function_name;
 		result += "(";
 		if (entry.children.size()) {
-			result += StringUtil::Join(entry.children, entry.children.size(), ", ",
-			                           [](const unique_ptr<BASE> &child) { return child->ToString(); });
+			//	Only one DISTINCT is allowed (on the first argument)
+			int distincts = entry.distinct ? 0 : 1;
+			result += StringUtil::Join(entry.children, entry.children.size(), ", ", [&](const unique_ptr<BASE> &child) {
+				return (distincts++ ? "" : "DISTINCT ") + child->ToString();
+			});
 		}
 		// Lead/Lag extra arguments
 		if (entry.offset_expr.get()) {
@@ -204,6 +214,23 @@ public:
 			result += to;
 		}
 
+		if (entry.exclude_clause != WindowExcludeMode::NO_OTHER) {
+			result += " EXCLUDE ";
+		}
+		switch (entry.exclude_clause) {
+		case WindowExcludeMode::CURRENT_ROW:
+			result += "CURRENT ROW";
+			break;
+		case WindowExcludeMode::GROUP:
+			result += "GROUP";
+			break;
+		case WindowExcludeMode::TIES:
+			result += "TIES";
+			break;
+		default:
+			break;
+		}
+
 		result += ")";
 
 		return result;

package/src/duckdb/src/include/duckdb/parser/parsed_data/alter_info.hpp

@@ -22,7 +22,8 @@ enum class AlterType : uint8_t {
 	ALTER_SEQUENCE = 3,
 	CHANGE_OWNERSHIP = 4,
 	ALTER_SCALAR_FUNCTION = 5,
-	ALTER_TABLE_FUNCTION = 6
+	ALTER_TABLE_FUNCTION = 6,
+	SET_COMMENT = 7
 };
 
 struct AlterEntryData {

package/src/duckdb/src/include/duckdb/parser/parsed_data/alter_table_info.hpp

@@ -37,6 +37,26 @@ public:
 	unique_ptr<AlterInfo> Copy() const override;
 };
 
+//===--------------------------------------------------------------------===//
+// Set Comment
+//===--------------------------------------------------------------------===//
+struct SetCommentInfo : public AlterInfo {
+	SetCommentInfo(CatalogType entry_catalog_type, string entry_catalog, string entry_schema, string entry_name,
+	               Value new_comment_value_p, OnEntryNotFound if_not_found);
+
+	CatalogType entry_catalog_type;
+	Value comment_value;
+
+public:
+	CatalogType GetCatalogType() const override;
+	unique_ptr<AlterInfo> Copy() const override;
+
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<AlterInfo> Deserialize(Deserializer &deserializer);
+
+	explicit SetCommentInfo();
+};
+
 //===--------------------------------------------------------------------===//
 // Alter Table
 //===--------------------------------------------------------------------===//
@@ -50,7 +70,8 @@ enum class AlterTableType : uint8_t {
 	SET_DEFAULT = 6,
 	FOREIGN_KEY_CONSTRAINT = 7,
 	SET_NOT_NULL = 8,
-	DROP_NOT_NULL = 9
+	DROP_NOT_NULL = 9,
+	SET_COLUMN_COMMENT = 10
 };
 
 struct AlterTableInfo : public AlterInfo {
@@ -66,7 +87,7 @@ public:
 	static unique_ptr<AlterInfo> Deserialize(Deserializer &deserializer);
 
 protected:
-	AlterTableInfo(AlterTableType type);
+	explicit AlterTableInfo(AlterTableType type);
 };
 
 //===--------------------------------------------------------------------===//
@@ -186,6 +207,30 @@ private:
 	ChangeColumnTypeInfo();
 };
 
+//===--------------------------------------------------------------------===//
+// SetColumnCommentInfo
+//===--------------------------------------------------------------------===//
+struct SetColumnCommentInfo : public AlterTableInfo {
+	SetColumnCommentInfo(AlterEntryData data, string column_name, Value comment_value);
+	~SetColumnCommentInfo() override;
+
+	//! The column name to alter
+	string column_name;
+	//! The target type of the column
+	Value comment;
+
+public:
+	unique_ptr<AlterInfo> Copy() const override;
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<AlterTableInfo> Deserialize(Deserializer &deserializer);
+
+	string GetColumnName() const override {
+		return column_name;
+	};
+
+	explicit SetColumnCommentInfo();
+};
+
 //===--------------------------------------------------------------------===//
 // SetDefaultInfo
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/parser/parsed_data/attach_info.hpp

@@ -12,6 +12,7 @@
 #include "duckdb/common/vector.hpp"
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/common/types/value.hpp"
+#include "duckdb/common/enums/on_create_conflict.hpp"
 
 namespace duckdb {
 
@@ -29,6 +30,8 @@ public:
 	string path;
 	//! Set of (key, value) options
 	unordered_map<string, Value> options;
+	//! What to do on create conflict
+	OnCreateConflict on_conflict = OnCreateConflict::ERROR_ON_CONFLICT;
 
 public:
 	unique_ptr<AttachInfo> Copy() const;

package/src/duckdb/src/include/duckdb/parser/parsed_data/bound_pragma_info.hpp

@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/bound_pragma_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/parser/parsed_data/pragma_info.hpp"
+#include "duckdb/function/pragma_function.hpp"
+
+namespace duckdb {
+
+struct BoundPragmaInfo {
+	BoundPragmaInfo(PragmaFunction function_p, vector<Value> parameters_p, named_parameter_map_t named_parameters_p)
+	    : function(std::move(function_p)), parameters(std::move(parameters_p)),
+	      named_parameters(std::move(named_parameters_p)) {
+	}
+
+	PragmaFunction function;
+	//! Parameter list (if any)
+	vector<Value> parameters;
+	//! Named parameter list (if any)
+	named_parameter_map_t named_parameters;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/comment_on_info.hpp

@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/comment_on_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/enums/catalog_type.hpp"
+#include "duckdb/common/types/value.hpp"
+#include "duckdb/parser/parsed_data/parse_info.hpp"
+#include "duckdb/parser/qualified_name.hpp"
+
+namespace duckdb {
+
+struct CommentOnInfo : public ParseInfo {
+public:
+	static constexpr const ParseInfoType TYPE = ParseInfoType::COMMENT_ON_INFO;
+
+public:
+	CommentOnInfo();
+
+	//! Catalog type to comment on
+	CatalogType type;
+
+	//! The catalog name of the entry to comment on
+	string catalog;
+	//! The schema name of the entry to comment on
+	string schema;
+	//! The name of the entry to comment on
+	string name;
+
+	//! The comment, can be NULL or a string
+	Value comment;
+
+public:
+	unique_ptr<CommentOnInfo> Copy() const;
+
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_index_info.hpp

@@ -8,42 +8,41 @@
 
 #pragma once
 
-#include "duckdb/parser/parsed_data/create_info.hpp"
-#include "duckdb/common/enums/index_type.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
+#include "duckdb/common/enums/index_constraint_type.hpp"
+#include "duckdb/common/types/value.hpp"
 #include "duckdb/common/vector.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
+#include "duckdb/parser/parsed_data/create_info.hpp"
 #include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/function/table_function.hpp"
 
 namespace duckdb {
 
 struct CreateIndexInfo : public CreateInfo {
-	CreateIndexInfo() : CreateInfo(CatalogType::INDEX_ENTRY) {
-	}
+	CreateIndexInfo();
+	CreateIndexInfo(const CreateIndexInfo &info);
 
-	//! Index Type (e.g., B+-tree, Skip-List, ...)
-	IndexType index_type;
-	//! Name of the Index
+	//! The table name of the underlying table
+	string table;
+	//! The name of the index
 	string index_name;
-	//! Name of the Index type
-	string index_type_name;
-	//! Index Constraint Type
+
+	//! Options values (WITH ...)
+	case_insensitive_map_t<Value> options;
+
+	//! The index type (ART, B+-tree, Skip-List, ...)
+	string index_type;
+	//! The index constraint type
 	IndexConstraintType constraint_type;
-	//! The table to create the index on
-	string table;
-	//! Set of expressions to index by
+	//! The column ids of the indexed table
+	vector<column_t> column_ids;
+	//! The set of expressions to index by
 	vector<unique_ptr<ParsedExpression>> expressions;
 	vector<unique_ptr<ParsedExpression>> parsed_expressions;
 
-	//! Types used for the CREATE INDEX scan
+	//! The types of the logical columns (necessary for scanning the table during CREATE INDEX)
 	vector<LogicalType> scan_types;
-	//! The names of the columns, used for the CREATE INDEX scan
+	//! The names of the logical columns (necessary for scanning the table during CREATE INDEX)
 	vector<string> names;
-	//! Column IDs needed for index creation
-	vector<column_t> column_ids;
-
-	//! Options values (WITH ...)
-	case_insensitive_map_t<Value> options;
 
 public:
 	DUCKDB_API unique_ptr<CreateInfo> Copy() const override;

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_info.hpp

@@ -11,21 +11,12 @@
 #include "duckdb/common/enums/catalog_type.hpp"
 #include "duckdb/parser/parsed_data/parse_info.hpp"
 #include "duckdb/common/enum_util.hpp"
+#include "duckdb/common/enums/on_create_conflict.hpp"
+#include "duckdb/common/types/value.hpp"
 
 namespace duckdb {
 struct AlterInfo;
 
-enum class OnCreateConflict : uint8_t {
-	// Standard: throw error
-	ERROR_ON_CONFLICT,
-	// CREATE IF NOT EXISTS, silently do nothing on conflict
-	IGNORE_ON_CONFLICT,
-	// CREATE OR REPLACE
-	REPLACE_ON_CONFLICT,
-	// Update on conflict - only support for functions. Add a function overload if the function already exists.
-	ALTER_ON_CONFLICT
-};
-
 struct CreateInfo : public ParseInfo {
 public:
 	static constexpr const ParseInfoType TYPE = ParseInfoType::CREATE_INFO;
@@ -52,6 +43,8 @@ public:
 	bool internal;
 	//! The SQL string of the CREATE statement
 	string sql;
+	//! User provided comment
+	Value comment;
 
 public:
 	void Serialize(Serializer &serializer) const override;
@@ -62,6 +55,7 @@ public:
 	DUCKDB_API void CopyProperties(CreateInfo &other) const;
 	//! Generates an alter statement from the create statement - used for OnCreateConflict::ALTER_ON_CONFLICT
 	DUCKDB_API virtual unique_ptr<AlterInfo> GetAlterInfo() const;
+
 	virtual string ToString() const {
 		throw InternalException("ToString not supported for this type of CreateInfo: '%s'",
 		                        EnumUtil::ToString(info_type));

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_schema_info.hpp

@@ -25,6 +25,29 @@ public:
 
 	DUCKDB_API void Serialize(Serializer &serializer) const override;
 	DUCKDB_API static unique_ptr<CreateInfo> Deserialize(Deserializer &deserializer);
+
+	string ToString() const override {
+		string ret = "";
+		switch (on_conflict) {
+		case OnCreateConflict::ALTER_ON_CONFLICT: {
+			ret += "CREATE SCHEMA " + schema + " ON CONFLICT INSERT OR REPLACE;";
+			break;
+		}
+		case OnCreateConflict::IGNORE_ON_CONFLICT: {
+			ret += "CREATE SCHEMA " + schema + " IF NOT EXISTS;";
+			break;
+		}
+		case OnCreateConflict::REPLACE_ON_CONFLICT: {
+			ret += "CREATE OR REPLACE SCHEMA " + schema + ";";
+			break;
+		}
+		case OnCreateConflict::ERROR_ON_CONFLICT: {
+			ret += "CREATE SCHEMA " + schema + ";";
+			break;
+		}
+		}
+		return ret;
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_secret_info.hpp

@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/create_secret_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/main/secret/secret.hpp"
+#include "duckdb/common/enums/catalog_type.hpp"
+#include "duckdb/parser/column_definition.hpp"
+#include "duckdb/parser/parsed_data/parse_info.hpp"
+#include "duckdb/parser/parsed_data/create_info.hpp"
+#include "duckdb/common/enums/on_entry_not_found.hpp"
+#include "duckdb/common/named_parameter_map.hpp"
+
+namespace duckdb {
+
+struct CreateSecretInfo : public CreateInfo {
+public:
+	static constexpr const ParseInfoType TYPE = ParseInfoType::CREATE_SECRET_INFO;
+
+public:
+	explicit CreateSecretInfo(OnCreateConflict on_conflict, SecretPersistType persist_type);
+	//! How to handle conflict
+	OnCreateConflict on_conflict;
+	//! Whether the secret can be persisted
+	SecretPersistType persist_type;
+	//! The type of secret
+	string type;
+	//! Which storage to use (empty for default)
+	string storage_type;
+	//! (optionally) the provider of the secret credentials
+	string provider;
+	//! (optionally) the name of the secret
+	string name;
+	//! (optionally) the scope of the secret
+	vector<string> scope;
+	//! Named parameter list (if any)
+	case_insensitive_map_t<Value> options;
+
+	unique_ptr<CreateInfo> Copy() const;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_table_info.hpp

@@ -30,7 +30,7 @@ struct CreateTableInfo : public CreateInfo {
 	ColumnList columns;
 	//! List of constraints on the table
 	vector<unique_ptr<Constraint>> constraints;
-	//! CREATE TABLE from QUERY
+	//! CREATE TABLE as QUERY
 	unique_ptr<SelectStatement> query;
 
 public:
@@ -38,6 +38,8 @@ public:
 
 	DUCKDB_API void Serialize(Serializer &serializer) const override;
 	DUCKDB_API static unique_ptr<CreateInfo> Deserialize(Deserializer &deserializer);
+
+	string ToString() const override;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_type_info.hpp

@@ -31,6 +31,8 @@ public:
 
 	DUCKDB_API void Serialize(Serializer &serializer) const override;
 	DUCKDB_API static unique_ptr<CreateInfo> Deserialize(Deserializer &deserializer);
+
+	string ToString() const override;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_view_info.hpp

@@ -27,6 +27,8 @@ public:
 	vector<string> aliases;
 	//! Return types
 	vector<LogicalType> types;
+	//! Names of the query
+	vector<string> names;
 	//! The SelectStatement of the view
 	unique_ptr<SelectStatement> query;
 
@@ -37,6 +39,8 @@ public:
 	DUCKDB_API static unique_ptr<CreateViewInfo> FromSelect(ClientContext &context, unique_ptr<CreateViewInfo> info);
 	//! Gets a bound CreateViewInfo object from a CREATE VIEW statement
 	DUCKDB_API static unique_ptr<CreateViewInfo> FromCreateView(ClientContext &context, const string &sql);
+	//! Parse a SELECT statement from a SQL string
+	DUCKDB_API static unique_ptr<SelectStatement> ParseSelect(const string &sql);
 
 	DUCKDB_API void Serialize(Serializer &serializer) const override;
 	DUCKDB_API static unique_ptr<CreateInfo> Deserialize(Deserializer &deserializer);