duckdb 0.9.3-dev0.0 → 0.9.3-dev3.0

package/src/duckdb/src/function/table/system/pragma_table_info.cpp

@@ -17,10 +17,12 @@
 namespace duckdb {
 
 struct PragmaTableFunctionData : public TableFunctionData {
-	explicit PragmaTableFunctionData(CatalogEntry &entry_p) : entry(entry_p) {
+	explicit PragmaTableFunctionData(CatalogEntry &entry_p, bool is_table_info)
+	    : entry(entry_p), is_table_info(is_table_info) {
 	}
 
 	CatalogEntry &entry;
+	bool is_table_info;
 };
 
 struct PragmaTableOperatorData : public GlobalTableFunctionState {
@@ -29,63 +31,176 @@ struct PragmaTableOperatorData : public GlobalTableFunctionState {
 	idx_t offset;
 };
 
-static unique_ptr<FunctionData> PragmaTableInfoBind(ClientContext &context, TableFunctionBindInput &input,
-                                                    vector<LogicalType> &return_types, vector<string> &names) {
+struct ColumnConstraintInfo {
+	bool not_null = false;
+	bool pk = false;
+	bool unique = false;
+};
+
+static Value DefaultValue(const ColumnDefinition &def) {
+	if (def.Generated()) {
+		return Value(def.GeneratedExpression().ToString());
+	}
+	if (!def.HasDefaultValue()) {
+		return Value();
+	}
+	auto &value = def.DefaultValue();
+	return Value(value.ToString());
+}
+
+struct PragmaTableInfoHelper {
+	static void GetSchema(vector<LogicalType> &return_types, vector<string> &names) {
+		names.emplace_back("cid");
+		return_types.emplace_back(LogicalType::INTEGER);
+
+		names.emplace_back("name");
+		return_types.emplace_back(LogicalType::VARCHAR);
+
+		names.emplace_back("type");
+		return_types.emplace_back(LogicalType::VARCHAR);
+
+		names.emplace_back("notnull");
+		return_types.emplace_back(LogicalType::BOOLEAN);
+
+		names.emplace_back("dflt_value");
+		return_types.emplace_back(LogicalType::VARCHAR);
+
+		names.emplace_back("pk");
+		return_types.emplace_back(LogicalType::BOOLEAN);
+	}
+
+	static void GetTableColumns(const ColumnDefinition &column, ColumnConstraintInfo constraint_info, DataChunk &output,
+	                            idx_t index) {
+		// return values:
+		// "cid", PhysicalType::INT32
+		output.SetValue(0, index, Value::INTEGER((int32_t)column.Oid()));
+		// "name", PhysicalType::VARCHAR
+		output.SetValue(1, index, Value(column.Name()));
+		// "type", PhysicalType::VARCHAR
+		output.SetValue(2, index, Value(column.Type().ToString()));
+		// "notnull", PhysicalType::BOOL
+		output.SetValue(3, index, Value::BOOLEAN(constraint_info.not_null));
+		// "dflt_value", PhysicalType::VARCHAR
+		output.SetValue(4, index, DefaultValue(column));
+		// "pk", PhysicalType::BOOL
+		output.SetValue(5, index, Value::BOOLEAN(constraint_info.pk));
+	}
+
+	static void GetViewColumns(idx_t i, const string &name, const LogicalType &type, DataChunk &output, idx_t index) {
+		// return values:
+		// "cid", PhysicalType::INT32
+		output.SetValue(0, index, Value::INTEGER((int32_t)i));
+		// "name", PhysicalType::VARCHAR
+		output.SetValue(1, index, Value(name));
+		// "type", PhysicalType::VARCHAR
+		output.SetValue(2, index, Value(type.ToString()));
+		// "notnull", PhysicalType::BOOL
+		output.SetValue(3, index, Value::BOOLEAN(false));
+		// "dflt_value", PhysicalType::VARCHAR
+		output.SetValue(4, index, Value());
+		// "pk", PhysicalType::BOOL
+		output.SetValue(5, index, Value::BOOLEAN(false));
+	}
+};
+
+struct PragmaShowHelper {
+	static void GetSchema(vector<LogicalType> &return_types, vector<string> &names) {
+		names.emplace_back("column_name");
+		return_types.emplace_back(LogicalType::VARCHAR);
+
+		names.emplace_back("column_type");
+		return_types.emplace_back(LogicalType::VARCHAR);
+
+		names.emplace_back("null");
+		return_types.emplace_back(LogicalType::VARCHAR);
 
-	names.emplace_back("cid");
-	return_types.emplace_back(LogicalType::INTEGER);
+		names.emplace_back("key");
+		return_types.emplace_back(LogicalType::VARCHAR);
 
-	names.emplace_back("name");
-	return_types.emplace_back(LogicalType::VARCHAR);
+		names.emplace_back("default");
+		return_types.emplace_back(LogicalType::VARCHAR);
 
-	names.emplace_back("type");
-	return_types.emplace_back(LogicalType::VARCHAR);
+		names.emplace_back("extra");
+		return_types.emplace_back(LogicalType::VARCHAR);
+	}
 
-	names.emplace_back("notnull");
-	return_types.emplace_back(LogicalType::BOOLEAN);
+	static void GetTableColumns(const ColumnDefinition &column, ColumnConstraintInfo constraint_info, DataChunk &output,
+	                            idx_t index) {
+		// "column_name", PhysicalType::VARCHAR
+		output.SetValue(0, index, Value(column.Name()));
+		// "column_type", PhysicalType::VARCHAR
+		output.SetValue(1, index, Value(column.Type().ToString()));
+		// "null", PhysicalType::VARCHAR
+		output.SetValue(2, index, Value(constraint_info.not_null ? "NO" : "YES"));
+		// "key", PhysicalType::VARCHAR
+		Value key;
+		if (constraint_info.pk || constraint_info.unique) {
+			key = Value(constraint_info.pk ? "PRI" : "UNI");
+		}
+		output.SetValue(3, index, key);
+		// "default", VARCHAR
+		output.SetValue(4, index, DefaultValue(column));
+		// "extra", VARCHAR
+		output.SetValue(5, index, Value());
+	}
 
-	names.emplace_back("dflt_value");
-	return_types.emplace_back(LogicalType::VARCHAR);
+	static void GetViewColumns(idx_t i, const string &name, const LogicalType &type, DataChunk &output, idx_t index) {
+		// "column_name", PhysicalType::VARCHAR
+		output.SetValue(0, index, Value(name));
+		// "column_type", PhysicalType::VARCHAR
+		output.SetValue(1, index, Value(type.ToString()));
+		// "null", PhysicalType::VARCHAR
+		output.SetValue(2, index, Value("YES"));
+		// "key", PhysicalType::VARCHAR
+		output.SetValue(3, index, Value());
+		// "default", VARCHAR
+		output.SetValue(4, index, Value());
+		// "extra", VARCHAR
+		output.SetValue(5, index, Value());
+	}
+};
 
-	names.emplace_back("pk");
-	return_types.emplace_back(LogicalType::BOOLEAN);
+template <bool IS_PRAGMA_TABLE_INFO>
+static unique_ptr<FunctionData> PragmaTableInfoBind(ClientContext &context, TableFunctionBindInput &input,
+                                                    vector<LogicalType> &return_types, vector<string> &names) {
+	if (IS_PRAGMA_TABLE_INFO) {
+		PragmaTableInfoHelper::GetSchema(return_types, names);
+	} else {
+		PragmaShowHelper::GetSchema(return_types, names);
+	}
 
 	auto qname = QualifiedName::Parse(input.inputs[0].GetValue<string>());
 
 	// look up the table name in the catalog
 	Binder::BindSchemaOrCatalog(context, qname.catalog, qname.schema);
 	auto &entry = Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, qname.catalog, qname.schema, qname.name);
-	return make_uniq<PragmaTableFunctionData>(entry);
+	return make_uniq<PragmaTableFunctionData>(entry, IS_PRAGMA_TABLE_INFO);
 }
 
 unique_ptr<GlobalTableFunctionState> PragmaTableInfoInit(ClientContext &context, TableFunctionInitInput &input) {
 	return make_uniq<PragmaTableOperatorData>();
 }
 
-static void CheckConstraints(TableCatalogEntry &table, const ColumnDefinition &column, bool &out_not_null,
-                             bool &out_pk) {
-	out_not_null = false;
-	out_pk = false;
+static ColumnConstraintInfo CheckConstraints(TableCatalogEntry &table, const ColumnDefinition &column) {
+	ColumnConstraintInfo result;
 	// check all constraints
-	// FIXME: this is pretty inefficient, it probably doesn't matter
 	for (auto &constraint : table.GetConstraints()) {
 		switch (constraint->type) {
 		case ConstraintType::NOT_NULL: {
 			auto &not_null = constraint->Cast<NotNullConstraint>();
 			if (not_null.index == column.Logical()) {
-				out_not_null = true;
+				result.not_null = true;
 			}
 			break;
 		}
 		case ConstraintType::UNIQUE: {
 			auto &unique = constraint->Cast<UniqueConstraint>();
-			if (unique.is_primary_key) {
-				if (unique.index == column.Logical()) {
-					out_pk = true;
-				}
-				if (std::find(unique.columns.begin(), unique.columns.end(), column.GetName()) != unique.columns.end()) {
-					out_pk = true;
-				}
+			bool &constraint_info = unique.is_primary_key ? result.pk : result.unique;
+			if (unique.index == column.Logical()) {
+				constraint_info = true;
+			}
+			if (std::find(unique.columns.begin(), unique.columns.end(), column.GetName()) != unique.columns.end()) {
+				constraint_info = true;
 			}
 			break;
 		}
@@ -93,9 +208,11 @@ static void CheckConstraints(TableCatalogEntry &table, const ColumnDefinition &c
 			break;
 		}
 	}
+	return result;
 }
 
-static void PragmaTableInfoTable(PragmaTableOperatorData &data, TableCatalogEntry &table, DataChunk &output) {
+static void PragmaTableInfoTable(PragmaTableOperatorData &data, TableCatalogEntry &table, DataChunk &output,
+                                 bool is_table_info) {
 	if (data.offset >= table.GetColumns().LogicalColumnCount()) {
 		// finished returning values
 		return;
@@ -106,31 +223,22 @@ static void PragmaTableInfoTable(PragmaTableOperatorData &data, TableCatalogEntr
 	output.SetCardinality(next - data.offset);
 
 	for (idx_t i = data.offset; i < next; i++) {
-		bool not_null, pk;
 		auto index = i - data.offset;
 		auto &column = table.GetColumn(LogicalIndex(i));
 		D_ASSERT(column.Oid() < (idx_t)NumericLimits<int32_t>::Maximum());
-		CheckConstraints(table, column, not_null, pk);
+		auto constraint_info = CheckConstraints(table, column);
 
-		// return values:
-		// "cid", PhysicalType::INT32
-		output.SetValue(0, index, Value::INTEGER((int32_t)column.Oid()));
-		// "name", PhysicalType::VARCHAR
-		output.SetValue(1, index, Value(column.Name()));
-		// "type", PhysicalType::VARCHAR
-		output.SetValue(2, index, Value(column.Type().ToString()));
-		// "notnull", PhysicalType::BOOL
-		output.SetValue(3, index, Value::BOOLEAN(not_null));
-		// "dflt_value", PhysicalType::VARCHAR
-		Value def_value = column.DefaultValue() ? Value(column.DefaultValue()->ToString()) : Value();
-		output.SetValue(4, index, def_value);
-		// "pk", PhysicalType::BOOL
-		output.SetValue(5, index, Value::BOOLEAN(pk));
+		if (is_table_info) {
+			PragmaTableInfoHelper::GetTableColumns(column, constraint_info, output, index);
+		} else {
+			PragmaShowHelper::GetTableColumns(column, constraint_info, output, index);
+		}
 	}
 	data.offset = next;
 }
 
-static void PragmaTableInfoView(PragmaTableOperatorData &data, ViewCatalogEntry &view, DataChunk &output) {
+static void PragmaTableInfoView(PragmaTableOperatorData &data, ViewCatalogEntry &view, DataChunk &output,
+                                bool is_table_info) {
 	if (data.offset >= view.types.size()) {
 		// finished returning values
 		return;
@@ -143,21 +251,13 @@ static void PragmaTableInfoView(PragmaTableOperatorData &data, ViewCatalogEntry
 	for (idx_t i = data.offset; i < next; i++) {
 		auto index = i - data.offset;
 		auto type = view.types[i];
-		auto &name = view.aliases[i];
-		// return values:
-		// "cid", PhysicalType::INT32
+		auto &name = i < view.aliases.size() ? view.aliases[i] : view.names[i];
 
-		output.SetValue(0, index, Value::INTEGER((int32_t)i));
-		// "name", PhysicalType::VARCHAR
-		output.SetValue(1, index, Value(name));
-		// "type", PhysicalType::VARCHAR
-		output.SetValue(2, index, Value(type.ToString()));
-		// "notnull", PhysicalType::BOOL
-		output.SetValue(3, index, Value::BOOLEAN(false));
-		// "dflt_value", PhysicalType::VARCHAR
-		output.SetValue(4, index, Value());
-		// "pk", PhysicalType::BOOL
-		output.SetValue(5, index, Value::BOOLEAN(false));
+		if (is_table_info) {
+			PragmaTableInfoHelper::GetViewColumns(i, name, type, output, index);
+		} else {
+			PragmaShowHelper::GetViewColumns(i, name, type, output, index);
+		}
 	}
 	data.offset = next;
 }
@@ -167,10 +267,10 @@ static void PragmaTableInfoFunction(ClientContext &context, TableFunctionInput &
 	auto &state = data_p.global_state->Cast<PragmaTableOperatorData>();
 	switch (bind_data.entry.type) {
 	case CatalogType::TABLE_ENTRY:
-		PragmaTableInfoTable(state, bind_data.entry.Cast<TableCatalogEntry>(), output);
+		PragmaTableInfoTable(state, bind_data.entry.Cast<TableCatalogEntry>(), output, bind_data.is_table_info);
 		break;
 	case CatalogType::VIEW_ENTRY:
-		PragmaTableInfoView(state, bind_data.entry.Cast<ViewCatalogEntry>(), output);
+		PragmaTableInfoView(state, bind_data.entry.Cast<ViewCatalogEntry>(), output, bind_data.is_table_info);
 		break;
 	default:
 		throw NotImplementedException("Unimplemented catalog type for pragma_table_info");
@@ -179,7 +279,9 @@ static void PragmaTableInfoFunction(ClientContext &context, TableFunctionInput &
 
 void PragmaTableInfo::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(TableFunction("pragma_table_info", {LogicalType::VARCHAR}, PragmaTableInfoFunction,
-	                              PragmaTableInfoBind, PragmaTableInfoInit));
+	                              PragmaTableInfoBind<true>, PragmaTableInfoInit));
+	set.AddFunction(TableFunction("pragma_show", {LogicalType::VARCHAR}, PragmaTableInfoFunction,
+	                              PragmaTableInfoBind<false>, PragmaTableInfoInit));
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/table/system/test_all_types.cpp

@@ -26,6 +26,7 @@ vector<TestType> TestAllTypesFun::GetTestTypes(bool use_large_enum) {
 	result.emplace_back(LogicalType::INTEGER, "int");
 	result.emplace_back(LogicalType::BIGINT, "bigint");
 	result.emplace_back(LogicalType::HUGEINT, "hugeint");
+	result.emplace_back(LogicalType::UHUGEINT, "uhugeint");
 	result.emplace_back(LogicalType::UTINYINT, "utinyint");
 	result.emplace_back(LogicalType::USMALLINT, "usmallint");
 	result.emplace_back(LogicalType::UINTEGER, "uint");
@@ -195,7 +196,7 @@ vector<TestType> TestAllTypesFun::GetTestTypes(bool use_large_enum) {
 	map_struct1.push_back(make_pair("value", Value("🦆🦆🦆🦆🦆🦆")));
 	child_list_t<Value> map_struct2;
 	map_struct2.push_back(make_pair("key", Value("key2")));
-	map_struct2.push_back(make_pair("key", Value("goose")));
+	map_struct2.push_back(make_pair("value", Value("goose")));
 
 	vector<Value> map_values;
 	map_values.push_back(Value::STRUCT(map_struct1));

package/src/duckdb/src/function/table/system_functions.cpp

@@ -16,8 +16,6 @@ void BuiltinFunctions::RegisterSQLiteFunctions() {
 	PragmaStorageInfo::RegisterFunction(*this);
 	PragmaMetadataInfo::RegisterFunction(*this);
 	PragmaDatabaseSize::RegisterFunction(*this);
-	PragmaLastProfilingOutput::RegisterFunction(*this);
-	PragmaDetailedProfilingOutput::RegisterFunction(*this);
 	PragmaUserAgent::RegisterFunction(*this);
 
 	DuckDBColumnsFun::RegisterFunction(*this);
@@ -29,6 +27,9 @@ void BuiltinFunctions::RegisterSQLiteFunctions() {
 	DuckDBSchemasFun::RegisterFunction(*this);
 	DuckDBDependenciesFun::RegisterFunction(*this);
 	DuckDBExtensionsFun::RegisterFunction(*this);
+	DuckDBMemoryFun::RegisterFunction(*this);
+	DuckDBOptimizersFun::RegisterFunction(*this);
+	DuckDBSecretsFun::RegisterFunction(*this);
 	DuckDBSequencesFun::RegisterFunction(*this);
 	DuckDBSettingsFun::RegisterFunction(*this);
 	DuckDBTablesFun::RegisterFunction(*this);

package/src/duckdb/src/function/table/table_scan.cpp

@@ -1,21 +1,23 @@
 #include "duckdb/function/table/table_scan.hpp"
 
 #include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
+#include "duckdb/catalog/dependency_list.hpp"
 #include "duckdb/common/mutex.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/execution/index/art/art.hpp"
+#include "duckdb/function/function_set.hpp"
+#include "duckdb/main/attached_database.hpp"
 #include "duckdb/main/client_config.hpp"
 #include "duckdb/optimizer/matcher/expression_matcher.hpp"
 #include "duckdb/planner/expression/bound_between_expression.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/storage/data_table.hpp"
-#include "duckdb/transaction/local_storage.hpp"
-#include "duckdb/transaction/duck_transaction.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/catalog/dependency_list.hpp"
-#include "duckdb/function/function_set.hpp"
 #include "duckdb/storage/table/scan_state.hpp"
-#include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
+#include "duckdb/transaction/duck_transaction.hpp"
+#include "duckdb/transaction/local_storage.hpp"
+#include "duckdb/main/client_data.hpp"
 
 namespace duckdb {
 
@@ -77,6 +79,9 @@ static unique_ptr<LocalTableFunctionState> TableScanInitLocal(ExecutionContext &
 		auto &tsgs = gstate->Cast<TableScanGlobalState>();
 		result->all_columns.Initialize(context.client, tsgs.scanned_types);
 	}
+
+	result->scan_state.options.force_fetch_row = ClientConfig::GetConfig(context.client).force_fetch_row;
+
 	return std::move(result);
 }
 
@@ -117,6 +122,8 @@ static void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, Da
 	auto &state = data_p.local_state->Cast<TableScanLocalState>();
 	auto &transaction = DuckTransaction::Get(context, bind_data.table.catalog);
 	auto &storage = bind_data.table.GetStorage();
+
+	state.scan_state.options.force_fetch_row = ClientConfig::GetConfig(context).force_fetch_row;
 	do {
 		if (bind_data.is_create_index) {
 			storage.CreateIndexScan(state.scan_state, output,
@@ -181,8 +188,9 @@ idx_t TableScanGetBatchIndex(ClientContext &context, const FunctionData *bind_da
 	return 0;
 }
 
-BindInfo TableScanGetBindInfo(const FunctionData *bind_data) {
-	return BindInfo(ScanType::TABLE);
+BindInfo TableScanGetBindInfo(const optional_ptr<FunctionData> bind_data_p) {
+	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
+	return BindInfo(bind_data.table);
 }
 
 void TableScanDependency(DependencyList &entries, const FunctionData *bind_data_p) {
@@ -221,6 +229,8 @@ static unique_ptr<GlobalTableFunctionState> IndexScanInitGlobal(ClientContext &c
 	auto result = make_uniq<IndexScanGlobalState>(row_id_data);
 	auto &local_storage = LocalStorage::Get(context, bind_data.table.catalog);
 
+	result->local_storage_state.options.force_fetch_row = ClientConfig::GetConfig(context).force_fetch_row;
+
 	result->column_ids.reserve(input.column_ids.size());
 	for (auto &id : input.column_ids) {
 		result->column_ids.push_back(GetStorageIndex(bind_data.table, id));
@@ -295,117 +305,55 @@ void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, Fun
 		// no indexes or no filters: skip the pushdown
 		return;
 	}
+
+	// Lazily initialize any unknown indexes that might have been loaded by an extension
+	storage.info->InitializeIndexes(context);
+
 	// behold
 	storage.info->indexes.Scan([&](Index &index) {
 		// first rewrite the index expression so the ColumnBindings align with the column bindings of the current table
 
-		if (index.unbound_expressions.size() > 1) {
+		if (index.IsUnknown()) {
+			// unknown index: skip
+			return false;
+		}
+
+		if (index.index_type != ART::TYPE_NAME) {
+			// only ART indexes are supported for now
+			return false;
+		}
+
+		auto &art_index = index.Cast<ART>();
+
+		if (art_index.unbound_expressions.size() > 1) {
 			// NOTE: index scans are not (yet) supported for compound index keys
 			return false;
 		}
 
-		auto index_expression = index.unbound_expressions[0]->Copy();
+		auto index_expression = art_index.unbound_expressions[0]->Copy();
 		bool rewrite_possible = true;
-		RewriteIndexExpression(index, get, *index_expression, rewrite_possible);
+		RewriteIndexExpression(art_index, get, *index_expression, rewrite_possible);
 		if (!rewrite_possible) {
 			// could not rewrite!
 			return false;
 		}
 
-		Value low_value, high_value, equal_value;
-		ExpressionType low_comparison_type = ExpressionType::INVALID, high_comparison_type = ExpressionType::INVALID;
 		// try to find a matching index for any of the filter expressions
+		auto &transaction = Transaction::Get(context, bind_data.table.catalog);
+
 		for (auto &filter : filters) {
-			auto &expr = *filter;
-
-			// create a matcher for a comparison with a constant
-			ComparisonExpressionMatcher matcher;
-			// match on a comparison type
-			matcher.expr_type = make_uniq<ComparisonExpressionTypeMatcher>();
-			// match on a constant comparison with the indexed expression
-			matcher.matchers.push_back(make_uniq<ExpressionEqualityMatcher>(*index_expression));
-			matcher.matchers.push_back(make_uniq<ConstantExpressionMatcher>());
-
-			matcher.policy = SetMatcher::Policy::UNORDERED;
-
-			vector<reference<Expression>> bindings;
-			if (matcher.Match(expr, bindings)) {
-				// range or equality comparison with constant value
-				// we can use our index here
-				// bindings[0] = the expression
-				// bindings[1] = the index expression
-				// bindings[2] = the constant
-				auto &comparison = bindings[0].get().Cast<BoundComparisonExpression>();
-				auto constant_value = bindings[2].get().Cast<BoundConstantExpression>().value;
-				auto comparison_type = comparison.type;
-				if (comparison.left->type == ExpressionType::VALUE_CONSTANT) {
-					// the expression is on the right side, we flip them around
-					comparison_type = FlipComparisonExpression(comparison_type);
-				}
-				if (comparison_type == ExpressionType::COMPARE_EQUAL) {
-					// equality value
-					// equality overrides any other bounds so we just break here
-					equal_value = constant_value;
-					break;
-				} else if (comparison_type == ExpressionType::COMPARE_GREATERTHANOREQUALTO ||
-				           comparison_type == ExpressionType::COMPARE_GREATERTHAN) {
-					// greater than means this is a lower bound
-					low_value = constant_value;
-					low_comparison_type = comparison_type;
+			auto index_state = art_index.TryInitializeScan(transaction, *index_expression, *filter);
+			if (index_state != nullptr) {
+				if (art_index.Scan(transaction, storage, *index_state, STANDARD_VECTOR_SIZE, bind_data.result_ids)) {
+					// use an index scan!
+					bind_data.is_index_scan = true;
+					get.function = TableScanFunction::GetIndexScanFunction();
 				} else {
-					// smaller than means this is an upper bound
-					high_value = constant_value;
-					high_comparison_type = comparison_type;
-				}
-			} else if (expr.type == ExpressionType::COMPARE_BETWEEN) {
-				// BETWEEN expression
-				auto &between = expr.Cast<BoundBetweenExpression>();
-				if (!between.input->Equals(*index_expression)) {
-					// expression doesn't match the current index expression
-					continue;
-				}
-				if (between.lower->type != ExpressionType::VALUE_CONSTANT ||
-				    between.upper->type != ExpressionType::VALUE_CONSTANT) {
-					// not a constant comparison
-					continue;
+					bind_data.result_ids.clear();
 				}
-				low_value = (between.lower->Cast<BoundConstantExpression>()).value;
-				low_comparison_type = between.lower_inclusive ? ExpressionType::COMPARE_GREATERTHANOREQUALTO
-				                                              : ExpressionType::COMPARE_GREATERTHAN;
-				high_value = (between.upper->Cast<BoundConstantExpression>()).value;
-				high_comparison_type = between.upper_inclusive ? ExpressionType::COMPARE_LESSTHANOREQUALTO
-				                                               : ExpressionType::COMPARE_LESSTHAN;
-				break;
+				return true;
 			}
 		}
-		if (!equal_value.IsNull() || !low_value.IsNull() || !high_value.IsNull()) {
-			// we can scan this index using this predicate: try a scan
-			auto &transaction = Transaction::Get(context, bind_data.table.catalog);
-			unique_ptr<IndexScanState> index_state;
-			if (!equal_value.IsNull()) {
-				// equality predicate
-				index_state =
-				    index.InitializeScanSinglePredicate(transaction, equal_value, ExpressionType::COMPARE_EQUAL);
-			} else if (!low_value.IsNull() && !high_value.IsNull()) {
-				// two-sided predicate
-				index_state = index.InitializeScanTwoPredicates(transaction, low_value, low_comparison_type, high_value,
-				                                                high_comparison_type);
-			} else if (!low_value.IsNull()) {
-				// less than predicate
-				index_state = index.InitializeScanSinglePredicate(transaction, low_value, low_comparison_type);
-			} else {
-				D_ASSERT(!high_value.IsNull());
-				index_state = index.InitializeScanSinglePredicate(transaction, high_value, high_comparison_type);
-			}
-			if (index.Scan(transaction, storage, *index_state, STANDARD_VECTOR_SIZE, bind_data.result_ids)) {
-				// use an index scan!
-				bind_data.is_index_scan = true;
-				get.function = TableScanFunction::GetIndexScanFunction();
-			} else {
-				bind_data.result_ids.clear();
-			}
-			return true;
-		}
 		return false;
 	});
 }
@@ -456,6 +404,7 @@ TableFunction TableScanFunction::GetIndexScanFunction() {
 	scan_function.get_batch_index = nullptr;
 	scan_function.projection_pushdown = true;
 	scan_function.filter_pushdown = false;
+	scan_function.get_bind_info = TableScanGetBindInfo;
 	scan_function.serialize = TableScanSerialize;
 	scan_function.deserialize = TableScanDeserialize;
 	return scan_function;
@@ -472,7 +421,7 @@ TableFunction TableScanFunction::GetFunction() {
 	scan_function.to_string = TableScanToString;
 	scan_function.table_scan_progress = TableScanProgress;
 	scan_function.get_batch_index = TableScanGetBatchIndex;
-	scan_function.get_batch_info = TableScanGetBindInfo;
+	scan_function.get_bind_info = TableScanGetBindInfo;
 	scan_function.projection_pushdown = true;
 	scan_function.filter_pushdown = true;
 	scan_function.filter_prune = true;
@@ -481,15 +430,6 @@ TableFunction TableScanFunction::GetFunction() {
 	return scan_function;
 }
 
-optional_ptr<TableCatalogEntry> TableScanFunction::GetTableEntry(const TableFunction &function,
-                                                                 const optional_ptr<FunctionData> bind_data_p) {
-	if (function.function != TableScanFunc || !bind_data_p) {
-		return nullptr;
-	}
-	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
-	return &bind_data.table;
-}
-
 void TableScanFunction::RegisterFunction(BuiltinFunctions &set) {
 	TableFunctionSet table_scan_set("seq_scan");
 	table_scan_set.AddFunction(GetFunction());

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,12 +1,13 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "v0.9.2"
+#define DUCKDB_VERSION "v0.10.0"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "3c695d7ba9"
+#define DUCKDB_SOURCE_ID "20b1486d11"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/common/platform.h"
 
 #include <cstdint>
 
@@ -64,48 +65,7 @@ const char *DuckDB::LibraryVersion() {
 }
 
 string DuckDB::Platform() {
-#if defined(DUCKDB_CUSTOM_PLATFORM)
-	return DUCKDB_QUOTE_DEFINE(DUCKDB_CUSTOM_PLATFORM);
-#endif
-#if defined(DUCKDB_WASM_VERSION)
-	// DuckDB-Wasm requires CUSTOM_PLATFORM to be defined
-	static_assert(0, "DUCKDB_WASM_VERSION should rely on CUSTOM_PLATFORM being provided");
-#endif
-	string os = "linux";
-#if INTPTR_MAX == INT64_MAX
-	string arch = "amd64";
-#elif INTPTR_MAX == INT32_MAX
-	string arch = "i686";
-#else
-#error Unknown pointer size or missing size macros!
-#endif
-	string postfix = "";
-
-#ifdef _WIN32
-	os = "windows";
-#elif defined(__APPLE__)
-	os = "osx";
-#endif
-#if defined(__aarch64__) || defined(__ARM_ARCH_ISA_A64)
-	arch = "arm64";
-#endif
-
-#if !defined(_GLIBCXX_USE_CXX11_ABI) || _GLIBCXX_USE_CXX11_ABI == 0
-	if (os == "linux") {
-		postfix = "_gcc4";
-	}
-#endif
-#if defined(__ANDROID__)
-	postfix += "_android"; // using + because it may also be gcc4
-#endif
-#ifdef __MINGW32__
-	postfix = "_mingw";
-#endif
-// this is used for the windows R builds which use a separate build environment
-#ifdef DUCKDB_PLATFORM_RTOOLS
-	postfix = "_rtools";
-#endif
-	return os + "_" + arch + postfix;
+	return DuckDBPlatform();
 }
 
 struct PragmaPlatformData : public GlobalTableFunctionState {