duckdb 0.5.2-dev2236.0 → 0.5.2-dev2245.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.5.2-dev2236.0",
+  "version": "0.5.2-dev2245.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -10467,6 +10467,8 @@ string LogicalOperatorToString(LogicalOperatorType type) {
 		return "LOAD";
 	case LogicalOperatorType::LOGICAL_INVALID:
 		break;
+	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:
+		return "CUSTOM_OP";
 	}
 	return "INVALID";
 }
@@ -71833,153 +71835,6 @@ string PhysicalReservoirSample::ParamsToString() const {
 
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/physical_plan_generator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_limit_percent.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! LogicalLimitPercent represents a LIMIT PERCENT clause
-class LogicalLimitPercent : public LogicalOperator {
-public:
-	LogicalLimitPercent(double limit_percent, int64_t offset_val, unique_ptr<Expression> limit,
-	                    unique_ptr<Expression> offset)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_LIMIT_PERCENT), limit_percent(limit_percent),
-	      offset_val(offset_val), limit(move(limit)), offset(move(offset)) {
-	}
-
-	//! Limit percent and offset values in case they are constants, used in optimizations.
-	double limit_percent;
-	int64_t offset_val;
-	//! The maximum amount of elements to emit
-	unique_ptr<Expression> limit;
-	//! The offset from the start to begin emitting elements
-	unique_ptr<Expression> offset;
-
-public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		return children[0]->GetColumnBindings();
-	}
-
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
-
-protected:
-	void ResolveTypes() override {
-		types = children[0]->types;
-	}
-};
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-class ClientContext;
-class ColumnDataCollection;
-
-//! The physical plan generator generates a physical execution plan from a
-//! logical query plan
-class PhysicalPlanGenerator {
-public:
-	explicit PhysicalPlanGenerator(ClientContext &context);
-	~PhysicalPlanGenerator();
-
-	unordered_set<CatalogEntry *> dependencies;
-	//! Recursive CTEs require at least one ChunkScan, referencing the working_table.
-	//! This data structure is used to establish it.
-	unordered_map<idx_t, std::shared_ptr<ColumnDataCollection>> recursive_cte_tables;
-
-public:
-	//! Creates a plan from the logical operator. This involves resolving column bindings and generating physical
-	//! operator nodes.
-	unique_ptr<PhysicalOperator> CreatePlan(unique_ptr<LogicalOperator> logical);
-
-	//! Whether or not we can (or should) use a batch-index based operator for executing the given sink
-	static bool UseBatchIndex(ClientContext &context, PhysicalOperator &plan);
-	//! Whether or not we should preserve insertion order for executing the given sink
-	static bool PreserveInsertionOrder(ClientContext &context, PhysicalOperator &plan);
-
-protected:
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalOperator &op);
-
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalAggregate &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalAnyJoin &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalColumnDataGet &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalComparisonJoin &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalCreate &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalCreateTable &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalCreateIndex &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalCrossProduct &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalDelete &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalDelimGet &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalDelimJoin &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalDistinct &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalDummyScan &expr);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalEmptyResult &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalExpressionGet &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalExport &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalFilter &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalGet &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalLimit &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalLimitPercent &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalOrder &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalTopN &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalProjection &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalInsert &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalCopyToFile &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalExplain &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalSetOperation &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalUpdate &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalPrepare &expr);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalWindow &expr);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalExecute &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalPragma &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalSample &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalSet &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalShow &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalSimple &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalUnnest &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalRecursiveCTE &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalCTERef &op);
-
-	unique_ptr<PhysicalOperator> CreateDistinctOn(unique_ptr<PhysicalOperator> child,
-	                                              vector<unique_ptr<Expression>> distinct_targets);
-
-	unique_ptr<PhysicalOperator> ExtractAggregateExpressions(unique_ptr<PhysicalOperator> child,
-	                                                         vector<unique_ptr<Expression>> &expressions,
-	                                                         vector<unique_ptr<Expression>> &groups);
-
-private:
-	bool PreserveInsertionOrder(PhysicalOperator &plan);
-	bool UseBatchIndex(PhysicalOperator &plan);
-
-private:
-	ClientContext &context;
-};
-} // namespace duckdb
 
 
 
@@ -90586,6 +90441,35 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalWindow &op
 
 
 
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/operator/logical_extension.operator.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+struct LogicalExtensionOperator : public LogicalOperator {
+
+	LogicalExtensionOperator() : LogicalOperator(LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR) {
+	}
+	LogicalExtensionOperator(vector<unique_ptr<Expression>> expressions)
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR, move(expressions)) {
+	}
+
+	virtual unique_ptr<PhysicalOperator> CreatePlan(ClientContext &context, PhysicalPlanGenerator &generator) = 0;
+};
+} // namespace duckdb
+
+
 namespace duckdb {
 
 class DependencyExtractor : public LogicalOperatorVisitor {
@@ -90771,6 +90655,13 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOperator &
 	case LogicalOperatorType::LOGICAL_SET:
 		plan = CreatePlan((LogicalSet &)op);
 		break;
+	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:
+		plan = ((LogicalExtensionOperator &)op).CreatePlan(context, *this);
+
+		if (!plan) {
+			throw InternalException("Missing PhysicalOperator for Extension Operator");
+		}
+		break;
 	default: {
 		throw NotImplementedException("Unimplemented logical operator type!");
 	}
@@ -171799,6 +171690,10 @@ unique_ptr<CreateInfo> CreateInfo::Deserialize(Deserializer &deserializer) {
 	}
 }
 
+unique_ptr<CreateInfo> CreateInfo::Deserialize(Deserializer &source, PlanDeserializationState &state) {
+	return Deserialize(source);
+}
+
 void CreateInfo::CopyProperties(CreateInfo &other) const {
 	other.type = type;
 	other.schema = schema;
@@ -194109,6 +194004,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableFunction &ref) {
 
 
 
+
 #include <algorithm>
 
 namespace duckdb {
@@ -198302,6 +198198,8 @@ unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deseriali
 	case LogicalOperatorType::LOGICAL_LOAD:
 		result = LogicalSimple::Deserialize(state, reader);
 		break;
+	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:
+		throw SerializationException("Invalid type for operator deserialization");
 	case LogicalOperatorType::LOGICAL_INVALID:
 		/* no default here to trigger a warning if we forget to implement deserialize for a new operator */
 		throw SerializationException("Invalid type for operator deserialization");
@@ -200123,7 +200021,23 @@ void Planner::CreatePlan(SQLStatement &statement) {
 		this->plan = nullptr;
 		parameters_resolved = false;
 	} catch (const Exception &ex) {
-		throw;
+		auto &config = DBConfig::GetConfig(context);
+
+		this->plan = nullptr;
+		for (auto &extension_op : config.operator_extensions) {
+			auto bound_statement =
+			    extension_op.Bind(context, *this->binder, extension_op.operator_info.get(), statement);
+			if (bound_statement.plan != nullptr) {
+				this->names = bound_statement.names;
+				this->types = bound_statement.types;
+				this->plan = move(bound_statement.plan);
+				break;
+			}
+		}
+
+		if (!this->plan) {
+			throw;
+		}
 	} catch (std::exception &ex) {
 		throw;
 	}