duckdb 0.8.2-dev3250.0 → 0.8.2-dev3300.0

package/src/duckdb/src/parser/transform/statement/transform_create_index.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/parser/expression/columnref_expression.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/statement/create_statement.hpp"
 #include "duckdb/parser/parsed_data/create_index_info.hpp"
 #include "duckdb/parser/tableref/basetableref.hpp"
@@ -7,18 +8,6 @@
 
 namespace duckdb {
 
-static IndexType StringToIndexType(const string &str) {
-	string upper_str = StringUtil::Upper(str);
-	if (upper_str == "INVALID") {
-		return IndexType::INVALID;
-	} else if (upper_str == "ART") {
-		return IndexType::ART;
-	} else {
-		throw ConversionException("No IndexType conversion from string '%s'", upper_str);
-	}
-	return IndexType::INVALID;
-}
-
 vector<unique_ptr<ParsedExpression>> Transformer::TransformIndexParameters(duckdb_libpgquery::PGList &list,
                                                                            const string &relation_name) {
 	vector<unique_ptr<ParsedExpression>> expressions;
@@ -56,7 +45,16 @@ unique_ptr<CreateStatement> Transformer::TransformCreateIndex(duckdb_libpgquery:
 
 	info->expressions = TransformIndexParameters(*stmt.indexParams, stmt.relation->relname);
 
-	info->index_type = StringToIndexType(string(stmt.accessMethod));
+	auto index_type_name = StringUtil::Upper(string(stmt.accessMethod));
+
+	if (index_type_name == "ART") {
+		info->index_type = IndexType::ART;
+	} else {
+		info->index_type = IndexType::EXTENSION;
+	}
+
+	info->index_type_name = index_type_name;
+
 	if (stmt.relation->schemaname) {
 		info->schema = stmt.relation->schemaname;
 	}
@@ -69,6 +67,22 @@ unique_ptr<CreateStatement> Transformer::TransformCreateIndex(duckdb_libpgquery:
 	} else {
 		throw NotImplementedException("Index without a name not supported yet!");
 	}
+
+	// Parse the options list
+	if (stmt.options) {
+		duckdb_libpgquery::PGListCell *cell;
+		for_each_cell(cell, stmt.options->head) {
+			auto def_elem = PGPointerCast<duckdb_libpgquery::PGDefElem>(cell->data.ptr_value);
+			Value val;
+			if (def_elem->arg) {
+				val = TransformValue(*PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg))->value;
+			} else {
+				val = Value::BOOLEAN(true);
+			}
+			info->options[StringUtil::Lower(def_elem->defname)] = std::move(val);
+		}
+	}
+
 	for (auto &expr : info->expressions) {
 		info->parsed_expressions.emplace_back(expr->Copy());
 	}

package/src/duckdb/src/planner/binder/statement/bind_export.cpp

@@ -11,6 +11,9 @@
 #include "duckdb/planner/operator/logical_set_operation.hpp"
 #include "duckdb/parser/parsed_data/exported_table_data.hpp"
 #include "duckdb/parser/constraints/foreign_key_constraint.hpp"
+#include "duckdb/parser/expression/cast_expression.hpp"
+#include "duckdb/parser/tableref/basetableref.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
 
 #include "duckdb/common/string_util.hpp"
 #include <algorithm>
@@ -96,6 +99,18 @@ string CreateFileName(const string &id_suffix, TableCatalogEntry &table, const s
 	return StringUtil::Format("%s_%s%s.%s", schema, name, id_suffix, extension);
 }
 
+unique_ptr<QueryNode> CreateSelectStatement(CopyStatement &stmt, vector<unique_ptr<ParsedExpression>> select_list) {
+	auto ref = make_uniq<BaseTableRef>();
+	ref->catalog_name = stmt.info->catalog;
+	ref->schema_name = stmt.info->schema;
+	ref->table_name = stmt.info->table;
+
+	auto statement = make_uniq<SelectNode>();
+	statement->from_table = std::move(ref);
+	statement->select_list = std::move(select_list);
+	return std::move(statement);
+}
+
 BoundStatement Binder::Bind(ExportStatement &stmt) {
 	// COPY TO a file
 	auto &config = DBConfig::GetConfig(context);
@@ -163,7 +178,15 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 		info->table = table.name;
 
 		// We can not export generated columns
+		vector<unique_ptr<ParsedExpression>> expressions;
 		for (auto &col : table.GetColumns().Physical()) {
+			auto expression = make_uniq_base<ParsedExpression, ColumnRefExpression>(col.GetName());
+			auto is_supported = copy_function.function.supports_type;
+			if (is_supported && !is_supported(col.Type())) {
+				expression =
+				    make_uniq_base<ParsedExpression, CastExpression>(LogicalType::VARCHAR, std::move(expression));
+			}
+			expressions.push_back(std::move(expression));
 			info->select_list.push_back(col.GetName());
 		}
 
@@ -181,17 +204,19 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 		// generate the copy statement and bind it
 		CopyStatement copy_stmt;
 		copy_stmt.info = std::move(info);
+		copy_stmt.select_statement = CreateSelectStatement(copy_stmt, std::move(expressions));
 
 		auto copy_binder = Binder::CreateBinder(context, this);
 		auto bound_statement = copy_binder->Bind(copy_stmt);
+		auto plan = std::move(bound_statement.plan);
+
 		if (child_operator) {
 			// use UNION ALL to combine the individual copy statements into a single node
-			auto copy_union =
-			    make_uniq<LogicalSetOperation>(GenerateTableIndex(), 1, std::move(child_operator),
-			                                   std::move(bound_statement.plan), LogicalOperatorType::LOGICAL_UNION);
+			auto copy_union = make_uniq<LogicalSetOperation>(GenerateTableIndex(), 1, std::move(child_operator),
+			                                                 std::move(plan), LogicalOperatorType::LOGICAL_UNION);
 			child_operator = std::move(copy_union);
 		} else {
-			child_operator = std::move(bound_statement.plan);
+			child_operator = std::move(plan);
 		}
 	}
 

package/src/duckdb/src/planner/operator/logical_extension_operator.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/planner/operator/logical_extension_operator.hpp"
+#include "duckdb/execution/column_binding_resolver.hpp"
 #include "duckdb/main/config.hpp"
 #include "duckdb/common/serializer/format_serializer.hpp"
 #include "duckdb/common/serializer/format_deserializer.hpp"
@@ -18,6 +19,20 @@ unique_ptr<LogicalExtensionOperator> LogicalExtensionOperator::Deserialize(Logic
 	throw SerializationException("No serialization method exists for extension: " + extension_name);
 }
 
+void LogicalExtensionOperator::ResolveColumnBindings(ColumnBindingResolver &res, vector<ColumnBinding> &bindings) {
+	// general case
+	// first visit the children of this operator
+	for (auto &child : children) {
+		res.VisitOperator(*child);
+	}
+	// now visit the expressions of this operator to resolve any bound column references
+	for (auto &expression : expressions) {
+		res.VisitExpression(&expression);
+	}
+	// finally update the current set of bindings to the current set of column bindings
+	bindings = GetColumnBindings();
+}
+
 void LogicalExtensionOperator::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
 	serializer.WriteProperty(200, "extension_name", GetExtensionName());

package/src/duckdb/src/storage/index.cpp

@@ -4,7 +4,6 @@
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/storage/table/append_state.hpp"
-#include "duckdb/execution/index/art/art.hpp"
 
 namespace duckdb {
 
@@ -47,42 +46,21 @@ void Index::Delete(DataChunk &entries, Vector &row_identifiers) {
 }
 
 bool Index::MergeIndexes(Index &other_index) {
-
 	IndexLock state;
 	InitializeLock(state);
-
-	switch (this->type) {
-	case IndexType::ART:
-		return Cast<ART>().MergeIndexes(state, other_index);
-	default:
-		throw InternalException("Unimplemented index type for merge");
-	}
+	return MergeIndexes(state, other_index);
 }
 
 string Index::VerifyAndToString(const bool only_verify) {
-
 	IndexLock state;
 	InitializeLock(state);
-
-	switch (this->type) {
-	case IndexType::ART:
-		return Cast<ART>().VerifyAndToString(state, only_verify);
-	default:
-		throw InternalException("Unimplemented index type for VerifyAndToString");
-	}
+	return VerifyAndToString(state, only_verify);
 }
 
 void Index::Vacuum() {
-
 	IndexLock state;
 	InitializeLock(state);
-
-	switch (this->type) {
-	case IndexType::ART:
-		return Cast<ART>().Vacuum(state);
-	default:
-		throw InternalException("Unimplemented index type for vacuum");
-	}
+	Vacuum(state);
 }
 
 void Index::ExecuteExpressions(DataChunk &input, DataChunk &result) {

package/src/duckdb/src/storage/local_storage.cpp

@@ -25,7 +25,6 @@ LocalTableStorage::LocalTableStorage(DataTable &table)
 	table.info->indexes.Scan([&](Index &index) {
 		D_ASSERT(index.type == IndexType::ART);
 		auto &art = index.Cast<ART>();
-		;
 		if (art.constraint_type != IndexConstraintType::NONE) {
 			// unique index: create a local ART index that maintains the same unique constraint
 			vector<unique_ptr<Expression>> unbound_expressions;

package/src/duckdb/src/storage/serialization/serialize_create_info.cpp

@@ -81,6 +81,8 @@ void CreateIndexInfo::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(204, "parsed_expressions", parsed_expressions);
 	serializer.WriteProperty(205, "names", names);
 	serializer.WriteProperty(206, "column_ids", column_ids);
+	serializer.WriteProperty(207, "options", options);
+	serializer.WriteProperty(208, "index_type_name", index_type_name);
 }
 
 unique_ptr<CreateInfo> CreateIndexInfo::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -92,6 +94,8 @@ unique_ptr<CreateInfo> CreateIndexInfo::FormatDeserialize(FormatDeserializer &de
 	deserializer.ReadProperty(204, "parsed_expressions", result->parsed_expressions);
 	deserializer.ReadProperty(205, "names", result->names);
 	deserializer.ReadProperty(206, "column_ids", result->column_ids);
+	deserializer.ReadProperty(207, "options", result->options);
+	deserializer.ReadProperty(208, "index_type_name", result->index_type_name);
 	return std::move(result);
 }
 

package/src/duckdb/src/storage/storage_info.cpp

@@ -2,7 +2,7 @@
 
 namespace duckdb {
 
-const uint64_t VERSION_NUMBER = 55;
+const uint64_t VERSION_NUMBER = 56;
 
 struct StorageVersionInfo {
 	const char *version_name;

package/src/duckdb/ub_src_execution_operator_schema.cpp

@@ -2,7 +2,7 @@
 
 #include "src/execution/operator/schema/physical_attach.cpp"
 
-#include "src/execution/operator/schema/physical_create_index.cpp"
+#include "src/execution/operator/schema/physical_create_art_index.cpp"
 
 #include "src/execution/operator/schema/physical_create_schema.cpp"
 

package/test/test_all_types.test.ts

@@ -159,7 +159,7 @@ const correct_answer_map: Record<string, any[]> = {
   map: ["{}", "{key1=🦆🦆🦆🦆🦆🦆, key2=goose}", null],
   union: ['Frank', '5', null],
 
-  time_tz: ["00:00:00+00", "23:59:59.999999+00", null],
+  time_tz: ["00:00:00-1559", "23:59:59.999999+1559", null],
   interval: [
     timedelta({
       days: 0,