duckdb 0.3.3-dev1140.0 → 0.3.3-dev1226.0

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "7c15866e7"
-#define DUCKDB_VERSION "v0.3.3-dev1140"
+#define DUCKDB_SOURCE_ID "39cfae40b"
+#define DUCKDB_VERSION "v0.3.3-dev1226"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -8012,6 +8012,7 @@ enum class CatalogType : uint8_t {
 	PRAGMA_FUNCTION_ENTRY = 28,
 	COPY_FUNCTION_ENTRY = 29,
 	MACRO_ENTRY = 30,
+	TABLE_MACRO_ENTRY = 31,
 
 	// version info
 	UPDATED_ENTRY = 50,
@@ -12997,7 +12998,7 @@ class QueryNode;
 
 class ScalarFunctionCatalogEntry;
 class AggregateFunctionCatalogEntry;
-class MacroCatalogEntry;
+class ScalarMacroCatalogEntry;
 class CatalogEntry;
 class SimpleFunction;
 
@@ -13033,6 +13034,8 @@ public:
 	//! be added. Defaults to INVALID.
 	LogicalType target_type;
 
+	MacroBinding *macro_binding;
+
 public:
 	unique_ptr<Expression> Bind(unique_ptr<ParsedExpression> &expr, LogicalType *result_type = nullptr,
 	                            bool root_expression = true);
@@ -13079,6 +13082,8 @@ public:
 	virtual BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
 	                                  bool root_expression = false);
 
+	void ReplaceMacroParametersRecursive(unique_ptr<ParsedExpression> &expr);
+
 protected:
 	BindResult BindExpression(BetweenExpression &expr, idx_t depth);
 	BindResult BindExpression(CaseExpression &expr, idx_t depth);
@@ -13101,18 +13106,15 @@ protected:
 	virtual BindResult BindFunction(FunctionExpression &expr, ScalarFunctionCatalogEntry *function, idx_t depth);
 	virtual BindResult BindAggregate(FunctionExpression &expr, AggregateFunctionCatalogEntry *function, idx_t depth);
 	virtual BindResult BindUnnest(FunctionExpression &expr, idx_t depth);
-	virtual BindResult BindMacro(FunctionExpression &expr, MacroCatalogEntry *macro, idx_t depth,
+	virtual BindResult BindMacro(FunctionExpression &expr, ScalarMacroCatalogEntry *macro, idx_t depth,
 	                             unique_ptr<ParsedExpression> *expr_ptr);
 
-	void ReplaceMacroParametersRecursive(unique_ptr<ParsedExpression> &expr);
-
 	virtual string UnsupportedAggregateMessage();
 	virtual string UnsupportedUnnestMessage();
 
 	Binder &binder;
 	ClientContext &context;
 	ExpressionBinder *stored_binder;
-	MacroBinding *macro_binding;
 	vector<BoundColumnReferenceInfo> bound_columns;
 };
 
@@ -13269,6 +13271,8 @@ public:
 	                      const vector<LogicalType> &types, LogicalGet &get);
 	//! Adds a subquery with a given alias to the BindContext.
 	void AddSubquery(idx_t index, const string &alias, SubqueryRef &ref, BoundQueryNode &subquery);
+	//! Adds a subquery with a given alias to the BindContext.
+	void AddSubquery(idx_t index, const string &alias, TableFunctionRef &ref, BoundQueryNode &subquery);
 	//! Adds a base table with the given alias to the BindContext.
 	void AddGenericBinding(idx_t index, const string &alias, const vector<string> &names,
 	                       const vector<LogicalType> &types);
@@ -13344,6 +13348,8 @@ private:
 
 
 
+//#include "duckdb/catalog/catalog_entry/table_macro_catalog_entry.hpp"
+
 namespace duckdb {
 class BoundResultModifier;
 class BoundSelectNode;
@@ -13353,6 +13359,7 @@ class LimitModifier;
 class OrderBinder;
 class TableCatalogEntry;
 class ViewCatalogEntry;
+class TableMacroCatalogEntry;
 
 struct CreateInfo;
 struct BoundCreateTableInfo;
@@ -13536,6 +13543,8 @@ private:
 	BoundStatement Bind(SetStatement &stmt);
 	BoundStatement Bind(LoadStatement &stmt);
 
+	unique_ptr<QueryNode> BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry *macro_func, idx_t depth);
+
 	unique_ptr<BoundQueryNode> BindNode(SelectNode &node);
 	unique_ptr<BoundQueryNode> BindNode(SetOperationNode &node);
 	unique_ptr<BoundQueryNode> BindNode(RecursiveCTENode &node);
@@ -15878,10 +15887,20 @@ The resulting type should be destroyed with `duckdb_destroy_logical_type`.
 This should not be used with `DUCKDB_TYPE_DECIMAL`.
 
 * type: The primitive type to create.
-* returns: The logical type type.
+* returns: The logical type.
 */
 DUCKDB_API duckdb_logical_type duckdb_create_logical_type(duckdb_type type);
 
+/*!
+Creates a `duckdb_logical_type` of type decimal with the specified width and scale
+The resulting type should be destroyed with `duckdb_destroy_logical_type`.
+
+* width: The width of the decimal type
+* scale: The scale of the decimal type
+* returns: The logical type.
+*/
+DUCKDB_API duckdb_logical_type duckdb_create_decimal_type(uint8_t width, uint8_t scale);
+
 /*!
 Retrieves the type class of a `duckdb_logical_type`.
 
@@ -16278,6 +16297,18 @@ Sets the main function of the table function
 DUCKDB_API void duckdb_table_function_set_function(duckdb_table_function table_function,
                                                    duckdb_table_function_t function);
 
+/*!
+Sets whether or not the given table function supports projection pushdown.
+
+If this is set to true, the system will provide a list of all required columns in the `init` stage through
+the `duckdb_init_get_column_count` and `duckdb_init_get_column_index` functions.
+If this is set to false (the default), the system will expect all columns to be projected.
+
+* table_function: The table function
+* pushdown: True if the table function supports projection pushdown, false otherwise.
+*/
+DUCKDB_API void duckdb_table_function_supports_projection_pushdown(duckdb_table_function table_function, bool pushdown);
+
 /*!
 Register the table function object within the given connection.
 
@@ -16379,6 +16410,27 @@ Sets the user-provided init data in the init object. This object can be retrieve
 */
 DUCKDB_API void duckdb_init_set_init_data(duckdb_init_info info, void *init_data, duckdb_delete_callback_t destroy);
 
+/*!
+Returns the number of projected columns.
+
+This function must be used if projection pushdown is enabled to figure out which columns to emit.
+
+* info: The info object
+* returns: The number of projected columns.
+*/
+DUCKDB_API idx_t duckdb_init_get_column_count(duckdb_init_info info);
+
+/*!
+Returns the column index of the projected column at the specified position.
+
+This function must be used if projection pushdown is enabled to figure out which columns to emit.
+
+* info: The info object
+* column_index: The index at which to get the projected column index, from 0..duckdb_init_get_column_count(info)
+* returns: The column index of the projected column.
+*/
+DUCKDB_API idx_t duckdb_init_get_column_index(duckdb_init_info info, idx_t column_index);
+
 /*!
 Report that an error has occurred while calling init.
 
@@ -18827,7 +18879,7 @@ struct CreateFunctionInfo : public CreateInfo {
 	explicit CreateFunctionInfo(CatalogType type, string schema = DEFAULT_SCHEMA) : CreateInfo(type, schema) {
 		D_ASSERT(type == CatalogType::SCALAR_FUNCTION_ENTRY || type == CatalogType::AGGREGATE_FUNCTION_ENTRY ||
 		         type == CatalogType::TABLE_FUNCTION_ENTRY || type == CatalogType::PRAGMA_FUNCTION_ENTRY ||
-		         type == CatalogType::MACRO_ENTRY);
+		         type == CatalogType::MACRO_ENTRY || type == CatalogType::TABLE_MACRO_ENTRY);
 	}
 
 	//! Function name
@@ -23253,6 +23305,8 @@ struct TransactionInfo : public ParseInfo {
 //===----------------------------------------------------------------------===//
 
 
+//! The SelectStatement of the view
+
 
 
 
@@ -23261,25 +23315,33 @@ struct TransactionInfo : public ParseInfo {
 
 namespace duckdb {
 
-class MacroCatalogEntry;
+enum class MacroType : uint8_t { VOID_MACRO = 0, TABLE_MACRO = 1, SCALAR_MACRO = 2 };
 
 class MacroFunction {
 public:
-	explicit MacroFunction(unique_ptr<ParsedExpression> expression);
+	// explicit MacroFunction(unique_ptr<ParsedExpression> expression);
+	MacroFunction(MacroType type);
 
-	//! Check whether the supplied arguments are valid
-	static string ValidateArguments(MacroCatalogEntry &macro_func, FunctionExpression &function_expr,
-	                                vector<unique_ptr<ParsedExpression>> &positionals,
-	                                unordered_map<string, unique_ptr<ParsedExpression>> &defaults);
-	//! The macro expression
-	unique_ptr<ParsedExpression> expression;
+	// MacroFunction(void);
+	// The type
+	MacroType type;
 	//! The positional parameters
 	vector<unique_ptr<ParsedExpression>> parameters;
 	//! The default parameters and their associated values
 	unordered_map<string, unique_ptr<ParsedExpression>> default_parameters;
 
 public:
-	unique_ptr<MacroFunction> Copy();
+	virtual ~MacroFunction() {
+	}
+
+	void CopyProperties(MacroFunction &other);
+
+	virtual unique_ptr<MacroFunction> Copy() = 0;
+
+	static string ValidateArguments(MacroFunction &macro_function, const string &name,
+	                                FunctionExpression &function_expr,
+	                                vector<unique_ptr<ParsedExpression>> &positionals,
+	                                unordered_map<string, unique_ptr<ParsedExpression>> &defaults);
 };
 
 } // namespace duckdb
@@ -23291,6 +23353,9 @@ struct CreateMacroInfo : public CreateFunctionInfo {
 	CreateMacroInfo() : CreateFunctionInfo(CatalogType::MACRO_ENTRY, INVALID_SCHEMA) {
 	}
 
+	CreateMacroInfo(CatalogType type) : CreateFunctionInfo(type, INVALID_SCHEMA) {
+	}
+
 	unique_ptr<MacroFunction> function;
 
 public: