duckdb 0.4.1-dev368.0 → 0.4.1-dev396.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 "40e47cd36"
-#define DUCKDB_VERSION "v0.4.1-dev368"
+#define DUCKDB_SOURCE_ID "8c2ffa6e1"
+#define DUCKDB_VERSION "v0.4.1-dev396"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -1060,6 +1060,8 @@ struct LogicalType {
 
 	DUCKDB_API void Verify() const;
 
+	DUCKDB_API bool IsValid() const;
+
 private:
 	LogicalTypeId id_;
 	PhysicalType physical_type_;
@@ -1364,9 +1366,11 @@ enum class ExceptionType {
 	FATAL = 30, // Fatal exception: fatal exceptions are non-recoverable, and render the entire DB in an unusable state
 	INTERNAL =
 	    31, // Internal exception: exception that indicates something went wrong internally (i.e. bug in the code base)
-	INVALID_INPUT = 32, // Input or arguments error
-	OUT_OF_MEMORY = 33, // out of memory
-	PERMISSION = 34     // insufficient permissions
+	INVALID_INPUT = 32,          // Input or arguments error
+	OUT_OF_MEMORY = 33,          // out of memory
+	PERMISSION = 34,             // insufficient permissions
+	PARAMETER_NOT_RESOLVED = 35, // parameter types could not be resolved
+	PARAMETER_NOT_ALLOWED = 36   // parameter types not allowed
 };
 
 class Exception : public std::exception {
@@ -1607,6 +1611,24 @@ public:
 	DUCKDB_API ValueOutOfRangeException(const PhysicalType varType, const idx_t length);
 };
 
+class ParameterNotAllowedException : public StandardException {
+public:
+	DUCKDB_API explicit ParameterNotAllowedException(const string &msg);
+
+	template <typename... Args>
+	explicit ParameterNotAllowedException(const string &msg, Args... params)
+	    : ParameterNotAllowedException(ConstructMessage(msg, params...)) {
+	}
+};
+
+//! Special exception that should be thrown in the binder if parameter types could not be resolved
+//! This will cause prepared statements to be forcibly rebound with the actual parameter values
+//! This exception is fatal if thrown outside of the binder (i.e. it should never be thrown outside of the binder)
+class ParameterNotResolvedException : public Exception {
+public:
+	DUCKDB_API explicit ParameterNotResolvedException();
+};
+
 } // namespace duckdb
 
 
@@ -6676,14 +6698,11 @@ public:
 	//! Bind a scalar function from the set of functions and input arguments. Returns the index of the chosen function,
 	//! returns DConstants::INVALID_INDEX and sets error if none could be found
 	DUCKDB_API static idx_t BindFunction(const string &name, vector<ScalarFunction> &functions,
-	                                     vector<LogicalType> &arguments, string &error, bool &cast_parameters);
+	                                     vector<LogicalType> &arguments, string &error);
 	DUCKDB_API static idx_t BindFunction(const string &name, vector<ScalarFunction> &functions,
-	                                     vector<unique_ptr<Expression>> &arguments, string &error,
-	                                     bool &cast_parameters);
+	                                     vector<unique_ptr<Expression>> &arguments, string &error);
 	//! Bind an aggregate function from the set of functions and input arguments. Returns the index of the chosen
 	//! function, returns DConstants::INVALID_INDEX and sets error if none could be found
-	DUCKDB_API static idx_t BindFunction(const string &name, vector<AggregateFunction> &functions,
-	                                     vector<LogicalType> &arguments, string &error, bool &cast_parameters);
 	DUCKDB_API static idx_t BindFunction(const string &name, vector<AggregateFunction> &functions,
 	                                     vector<LogicalType> &arguments, string &error);
 	DUCKDB_API static idx_t BindFunction(const string &name, vector<AggregateFunction> &functions,
@@ -6751,8 +6770,7 @@ public:
 	DUCKDB_API hash_t Hash() const;
 
 	//! Cast a set of expressions to the arguments of this function
-	DUCKDB_API void CastToFunctionArguments(vector<unique_ptr<Expression>> &children,
-	                                        bool cast_parameter_expressions = true);
+	DUCKDB_API void CastToFunctionArguments(vector<unique_ptr<Expression>> &children);
 
 	DUCKDB_API string ToString() override;
 };
@@ -7717,9 +7735,10 @@ public:
 	                                                            vector<unique_ptr<Expression>> children, string &error,
 	                                                            bool is_operator = false, Binder *binder = nullptr);
 
-	DUCKDB_API static unique_ptr<BoundFunctionExpression>
-	BindScalarFunction(ClientContext &context, ScalarFunction bound_function, vector<unique_ptr<Expression>> children,
-	                   bool is_operator = false, bool cast_parameters = true);
+	DUCKDB_API static unique_ptr<BoundFunctionExpression> BindScalarFunction(ClientContext &context,
+	                                                                         ScalarFunction bound_function,
+	                                                                         vector<unique_ptr<Expression>> children,
+	                                                                         bool is_operator = false);
 
 	DUCKDB_API bool operator==(const ScalarFunction &rhs) const;
 	DUCKDB_API bool operator!=(const ScalarFunction &rhs) const;
@@ -9501,8 +9520,7 @@ public:
 	DUCKDB_API static unique_ptr<BoundAggregateExpression>
 	BindAggregateFunction(ClientContext &context, AggregateFunction bound_function,
 	                      vector<unique_ptr<Expression>> children, unique_ptr<Expression> filter = nullptr,
-	                      bool is_distinct = false, unique_ptr<BoundOrderModifier> order_bys = nullptr,
-	                      bool cast_parameters = true);
+	                      bool is_distinct = false, unique_ptr<BoundOrderModifier> order_bys = nullptr);
 
 	DUCKDB_API static unique_ptr<FunctionData> BindSortedAggregate(AggregateFunction &bound_function,
 	                                                               vector<unique_ptr<Expression>> &children,
@@ -12862,6 +12880,7 @@ public:
 
 public:
 	LogicalType source_type() {
+		D_ASSERT(child->return_type.IsValid());
 		return child->return_type;
 	}
 
@@ -13145,6 +13164,49 @@ public:
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/expression/bound_parameter_data.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+struct BoundParameterData {
+	BoundParameterData() {
+	}
+	BoundParameterData(Value val) : value(move(val)), return_type(value.type()) {
+	}
+
+	Value value;
+	LogicalType return_type;
+};
+
+using bound_parameter_map_t = unordered_map<idx_t, shared_ptr<BoundParameterData>>;
+
+struct BoundParameterMap {
+	BoundParameterMap(vector<BoundParameterData> &parameter_data) : parameter_data(parameter_data) {
+	}
+
+	bound_parameter_map_t parameters;
+	vector<BoundParameterData> &parameter_data;
+
+	LogicalType GetReturnType(idx_t index) {
+		if (index >= parameter_data.size()) {
+			return LogicalTypeId::UNKNOWN;
+		}
+		return parameter_data[index].return_type;
+	}
+};
+
+} // namespace duckdb
 
 
 namespace duckdb {
@@ -13154,9 +13216,14 @@ public:
 	explicit BoundParameterExpression(idx_t parameter_nr);
 
 	idx_t parameter_nr;
-	Value *value;
+	shared_ptr<BoundParameterData> parameter_data;
 
 public:
+	//! Invalidate a bound parameter expression - forcing a rebind on any subsequent filters
+	DUCKDB_API static void Invalidate(Expression &expr);
+	//! Invalidate all parameters within an expression
+	DUCKDB_API static void InvalidateRecursive(Expression &expr);
+
 	bool IsScalar() const override;
 	bool HasParameter() const override;
 	bool IsFoldable() const override;
@@ -13168,6 +13235,7 @@ public:
 
 	unique_ptr<Expression> Copy() override;
 };
+
 } // namespace duckdb
 
 //===----------------------------------------------------------------------===//
@@ -14355,6 +14423,7 @@ struct CreateInfo;
 struct BoundCreateTableInfo;
 struct BoundCreateFunctionInfo;
 struct CommonTableExpressionInfo;
+struct BoundParameterMap;
 
 enum class BindingMode : uint8_t { STANDARD_BINDING, EXTRACT_NAMES };
 
@@ -14402,9 +14471,7 @@ public:
 	//! vector)
 	vector<CorrelatedColumnInfo> correlated_columns;
 	//! The set of parameter expressions bound by this binder
-	vector<BoundParameterExpression *> *parameters;
-	//! The types of the prepared statement parameters, if any
-	vector<LogicalType> *parameter_types;
+	BoundParameterMap *parameters;
 	//! Statement properties
 	StatementProperties properties;
 	//! The alias for the currently processing subquery, if it exists
@@ -14481,8 +14548,7 @@ public:
 	void AddTableName(string table_name);
 	const unordered_set<string> &GetTableNames();
 
-	//! Removes the BoundParameterExpressions from Binder::parameters if they occur in 'expressions'
-	void RemoveParameters(vector<unique_ptr<Expression>> &expressions);
+	void SetCanContainNulls(bool can_contain_nulls);
 
 private:
 	//! The parent binder (if any)
@@ -14529,6 +14595,8 @@ private:
 	BoundStatement Bind(CreateStatement &stmt);
 	BoundStatement Bind(DropStatement &stmt);
 	BoundStatement Bind(AlterStatement &stmt);
+	BoundStatement Bind(PrepareStatement &stmt);
+	BoundStatement Bind(ExecuteStatement &stmt);
 	BoundStatement Bind(TransactionStatement &stmt);
 	BoundStatement Bind(PragmaStatement &stmt);
 	BoundStatement Bind(ExplainStatement &stmt);
@@ -23796,7 +23864,9 @@ public:
 			return entry.children[0]->ToString() + "[" + entry.children[1]->ToString() + ":" +
 			       entry.children[2]->ToString() + "]";
 		case ExpressionType::STRUCT_EXTRACT: {
-			D_ASSERT(entry.children[1]->type == ExpressionType::VALUE_CONSTANT);
+			if (entry.children[1]->type != ExpressionType::VALUE_CONSTANT) {
+				return string();
+			}
 			auto child_string = entry.children[1]->ToString();
 			D_ASSERT(child_string.size() >= 3);
 			D_ASSERT(child_string[0] == '\'' && child_string[child_string.size() - 1] == '\'');
@@ -23847,6 +23917,8 @@ public:
 
 	string ToString() const override;
 
+	static bool Equals(const ParameterExpression *a, const ParameterExpression *b);
+
 	unique_ptr<ParsedExpression> Copy() const override;
 	hash_t Hash() const override;