duckdb 0.5.1-dev56.0 → 0.5.1-dev72.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.5.1-dev56.0",
+  "version": "0.5.1-dev72.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -620,7 +620,88 @@ public:
 
 } // namespace duckdb
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// extension_functions.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+struct ExtensionFunction {
+	char function[48];
+	char extension[48];
+};
+
+static constexpr ExtensionFunction EXTENSION_FUNCTIONS[] = {
+    {"->>", "json"},
+    {"array_to_json", "json"},
+    {"create_fts_index", "fts"},
+    {"dbgen", "tpch"},
+    {"drop_fts_index", "fts"},
+    {"dsdgen", "tpcds"},
+    {"excel_text", "excel"},
+    {"from_json", "json"},
+    {"from_json_strict", "json"},
+    {"from_substrait", "substrait"},
+    {"get_substrait", "substrait"},
+    {"get_substrait_json", "substrait"},
+    {"icu_calendar_names", "icu"},
+    {"icu_sort_key", "icu"},
+    {"json", "json"},
+    {"json_array", "json"},
+    {"json_array_length", "json"},
+    {"json_extract", "json"},
+    {"json_extract_path", "json"},
+    {"json_extract_path_text", "json"},
+    {"json_extract_string", "json"},
+    {"json_group_array", "json"},
+    {"json_group_object", "json"},
+    {"json_group_structure", "json"},
+    {"json_merge_patch", "json"},
+    {"json_object", "json"},
+    {"json_quote", "json"},
+    {"json_structure", "json"},
+    {"json_transform", "json"},
+    {"json_transform_strict", "json"},
+    {"json_type", "json"},
+    {"json_valid", "json"},
+    {"make_timestamptz", "icu"},
+    {"parquet_metadata", "parquet"},
+    {"parquet_scan", "parquet"},
+    {"parquet_schema", "parquet"},
+    {"pg_timezone_names", "icu"},
+    {"postgres_attach", "postgres_scanner"},
+    {"postgres_scan", "postgres_scanner"},
+    {"postgres_scan_pushdown", "postgres_scanner"},
+    {"read_json_objects", "json"},
+    {"read_ndjson_objects", "json"},
+    {"read_parquet", "parquet"},
+    {"row_to_json", "json"},
+    {"sqlite_attach", "sqlite_scanner"},
+    {"sqlite_scan", "sqlite_scanner"},
+    {"stem", "fts"},
+    {"text", "excel"},
+    {"to_json", "json"},
+    {"tpcds", "tpcds"},
+    {"tpcds_answers", "tpcds"},
+    {"tpcds_queries", "tpcds"},
+    {"tpch", "tpch"},
+    {"tpch_answers", "tpch"},
+    {"tpch_queries", "tpch"},
+    {"visualize_diff_profiling_output", "visualizer"},
+    {"visualize_json_profiling_output", "visualizer"},
+    {"visualize_last_profiling_output", "visualizer"},
+};
+} // namespace duckdb
 
+#include <algorithm>
 namespace duckdb {
 
 string SimilarCatalogEntry::GetQualifiedName() const {
@@ -823,6 +904,16 @@ SimilarCatalogEntry Catalog::SimilarEntryInSchemas(ClientContext &context, const
 	return {most_similar.first, most_similar.second, schema_of_most_similar};
 }
 
+string FindExtension(const string &function_name) {
+	auto size = sizeof(EXTENSION_FUNCTIONS) / sizeof(ExtensionFunction);
+	auto it = std::lower_bound(
+	    EXTENSION_FUNCTIONS, EXTENSION_FUNCTIONS + size, function_name,
+	    [](const ExtensionFunction &element, const string &value) { return element.function < value; });
+	if (it != EXTENSION_FUNCTIONS + size && it->function == function_name) {
+		return it->extension;
+	}
+	return "";
+}
 CatalogException Catalog::CreateMissingEntryException(ClientContext &context, const string &entry_name,
                                                       CatalogType type, const vector<SchemaCatalogEntry *> &schemas,
                                                       QueryErrorContext error_context) {
@@ -836,7 +927,12 @@ CatalogException Catalog::CreateMissingEntryException(ClientContext &context, co
 		}
 	});
 	auto unseen_entry = SimilarEntryInSchemas(context, entry_name, type, unseen_schemas);
-
+	auto extension_name = FindExtension(entry_name);
+	if (!extension_name.empty()) {
+		return CatalogException("Function with name %s is not on the catalog, but it exists in the %s extension. To "
+		                        "Install and Load the extension, run: INSTALL %s; LOAD %s;",
+		                        entry_name, extension_name, extension_name, extension_name);
+	}
 	string did_you_mean;
 	if (unseen_entry.Found() && unseen_entry.distance < entry.distance) {
 		did_you_mean = "\nDid you mean \"" + unseen_entry.GetQualifiedName() + "\"?";
@@ -35676,7 +35772,10 @@ struct SortConstants {
 
 struct SortLayout {
 public:
+	SortLayout() {
+	}
 	explicit SortLayout(const vector<BoundOrderByNode> &orders);
+	SortLayout GetPrefixComparisonLayout(idx_t num_prefix_cols) const;
 
 public:
 	idx_t column_count;
@@ -37327,6 +37426,32 @@ SortLayout::SortLayout(const vector<BoundOrderByNode> &orders)
 	blob_layout.Initialize(blob_layout_types);
 }
 
+SortLayout SortLayout::GetPrefixComparisonLayout(idx_t num_prefix_cols) const {
+	SortLayout result;
+	result.column_count = num_prefix_cols;
+	result.all_constant = true;
+	result.comparison_size = 0;
+	for (idx_t col_idx = 0; col_idx < num_prefix_cols; col_idx++) {
+		result.order_types.push_back(order_types[col_idx]);
+		result.order_by_null_types.push_back(order_by_null_types[col_idx]);
+		result.logical_types.push_back(logical_types[col_idx]);
+
+		result.all_constant = result.all_constant && constant_size[col_idx];
+		result.constant_size.push_back(constant_size[col_idx]);
+
+		result.comparison_size += column_sizes[col_idx];
+		result.column_sizes.push_back(column_sizes[col_idx]);
+
+		result.prefix_lengths.push_back(prefix_lengths[col_idx]);
+		result.stats.push_back(stats[col_idx]);
+		result.has_null.push_back(has_null[col_idx]);
+	}
+	result.entry_size = entry_size;
+	result.blob_layout = blob_layout;
+	result.sorting_to_blob_col = sorting_to_blob_col;
+	return result;
+}
+
 LocalSortState::LocalSortState() : initialized(false) {
 }
 
@@ -64930,12 +65055,14 @@ public:
 
 	WindowGlobalHashGroup(BufferManager &buffer_manager, const Orders &partitions, const Orders &orders,
 	                      const Types &payload_types, idx_t max_mem, bool external)
-	    : memory_per_thread(max_mem), count(0), partition_layout(partitions) {
+	    : memory_per_thread(max_mem), count(0) {
 
 		RowLayout payload_layout;
 		payload_layout.Initialize(payload_types);
 		global_sort = make_unique<GlobalSortState>(buffer_manager, orders, payload_layout);
 		global_sort->external = external;
+
+		partition_layout = global_sort->sort_layout.GetPrefixComparisonLayout(partitions.size());
 	}
 
 	void Combine(LocalSortState &local_sort) {

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 "c96d09d7b"
-#define DUCKDB_VERSION "v0.5.1-dev56"
+#define DUCKDB_SOURCE_ID "62c4acd27"
+#define DUCKDB_VERSION "v0.5.1-dev72"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //