duckdb 0.5.1-dev61.0 → 0.5.1-dev88.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.5.1-dev61.0",
+  "version": "0.5.1-dev88.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() + "\"?";
@@ -47605,11 +47701,36 @@ Value Value::CreateValue(dtime_t value) {
 	return Value::TIME(value);
 }
 
+template <>
+Value Value::CreateValue(dtime_tz_t value) {
+	return Value::TIMETZ(value);
+}
+
 template <>
 Value Value::CreateValue(timestamp_t value) {
 	return Value::TIMESTAMP(value);
 }
 
+template <>
+Value Value::CreateValue(timestamp_sec_t value) {
+	return Value::TIMESTAMPSEC(value);
+}
+
+template <>
+Value Value::CreateValue(timestamp_ms_t value) {
+	return Value::TIMESTAMPMS(value);
+}
+
+template <>
+Value Value::CreateValue(timestamp_ns_t value) {
+	return Value::TIMESTAMPNS(value);
+}
+
+template <>
+Value Value::CreateValue(timestamp_tz_t value) {
+	return Value::TIMESTAMPTZ(value);
+}
+
 template <>
 Value Value::CreateValue(const char *value) {
 	return Value(string(value));
@@ -49182,19 +49303,6 @@ void Vector::Resize(idx_t cur_size, idx_t new_size) {
 	}
 }
 
-// FIXME Just like DECIMAL, it's important that type_info gets considered when determining whether or not to cast
-// just comparing internal type is not always enough
-static bool ValueShouldBeCast(const LogicalType &incoming, const LogicalType &target) {
-	if (incoming.InternalType() != target.InternalType()) {
-		return true;
-	}
-	if (incoming.id() == LogicalTypeId::DECIMAL && incoming.id() == target.id()) {
-		//! Compare the type_info
-		return incoming != target;
-	}
-	return false;
-}
-
 void Vector::SetValue(idx_t index, const Value &val) {
 	if (GetVectorType() == VectorType::DICTIONARY_VECTOR) {
 		// dictionary: apply dictionary and forward to child
@@ -49202,10 +49310,11 @@ void Vector::SetValue(idx_t index, const Value &val) {
 		auto &child = DictionaryVector::Child(*this);
 		return child.SetValue(sel_vector.get_index(index), val);
 	}
-	if (ValueShouldBeCast(val.type(), GetType())) {
+	if (val.type() != GetType()) {
 		SetValue(index, val.CastAs(GetType()));
 		return;
 	}
+	D_ASSERT(val.type().InternalType() == GetType().InternalType());
 
 	validity.EnsureWritable();
 	validity.Set(index, !val.IsNull());
@@ -49456,7 +49565,10 @@ Value Vector::GetValue(const Vector &v_p, idx_t index_p) {
 	auto value = GetValueInternal(v_p, index_p);
 	// set the alias of the type to the correct value, if there is a type alias
 	if (v_p.GetType().HasAlias()) {
-		value.type().SetAlias(v_p.GetType().GetAlias());
+		value.type().CopyAuxInfo(v_p.GetType());
+	}
+	if (v_p.GetType().id() != LogicalTypeId::AGGREGATE_STATE && value.type().id() != LogicalTypeId::AGGREGATE_STATE) {
+		D_ASSERT(v_p.GetType() == value.type());
 	}
 	return value;
 }
@@ -51523,6 +51635,7 @@ public:
 				if (!alias.empty()) {
 					return false;
 				}
+				//! We only need to compare aliases when both types have them in this case
 				return true;
 			}
 			if (alias != other_p->alias) {
@@ -51536,8 +51649,7 @@ public:
 		if (type != other_p->type) {
 			return false;
 		}
-		auto &other = (ExtraTypeInfo &)*other_p;
-		return alias == other.alias && EqualsInternal(other_p);
+		return alias == other_p->alias && EqualsInternal(other_p);
 	}
 	//! Serializes a ExtraTypeInfo to a stand-alone binary blob
 	virtual void Serialize(FieldWriter &writer) const {};
@@ -52216,10 +52328,7 @@ LogicalType LogicalType::Deserialize(Deserializer &source) {
 	return LogicalType(id, move(info));
 }
 
-bool LogicalType::operator==(const LogicalType &rhs) const {
-	if (id_ != rhs.id_) {
-		return false;
-	}
+bool LogicalType::EqualTypeInfo(const LogicalType &rhs) const {
 	if (type_info_.get() == rhs.type_info_.get()) {
 		return true;
 	}
@@ -52231,6 +52340,13 @@ bool LogicalType::operator==(const LogicalType &rhs) const {
 	}
 }
 
+bool LogicalType::operator==(const LogicalType &rhs) const {
+	if (id_ != rhs.id_) {
+		return false;
+	}
+	return EqualTypeInfo(rhs);
+}
+
 } // namespace duckdb
 
 
@@ -93315,21 +93431,21 @@ AggregateFunction GetHistogramFunction(const LogicalType &type) {
 	case LogicalType::VARCHAR:
 		return GetMapType<HistogramStringFunctor, string, IS_ORDERED>(type);
 	case LogicalType::TIMESTAMP:
-		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, timestamp_t, IS_ORDERED>(type);
 	case LogicalType::TIMESTAMP_TZ:
-		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, timestamp_tz_t, IS_ORDERED>(type);
 	case LogicalType::TIMESTAMP_S:
-		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, timestamp_sec_t, IS_ORDERED>(type);
 	case LogicalType::TIMESTAMP_MS:
-		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, timestamp_ms_t, IS_ORDERED>(type);
 	case LogicalType::TIMESTAMP_NS:
-		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, timestamp_ns_t, IS_ORDERED>(type);
 	case LogicalType::TIME:
-		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, dtime_t, IS_ORDERED>(type);
 	case LogicalType::TIME_TZ:
-		return GetMapType<HistogramFunctor, int64_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, dtime_tz_t, IS_ORDERED>(type);
 	case LogicalType::DATE:
-		return GetMapType<HistogramFunctor, int32_t, IS_ORDERED>(type);
+		return GetMapType<HistogramFunctor, date_t, IS_ORDERED>(type);
 	default:
 		throw InternalException("Unimplemented histogram aggregate");
 	}
@@ -103278,12 +103394,49 @@ static void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vect
 			    result, state_vector.state_vector, count);
 			break;
 		case PhysicalType::INT32:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int32_t>(
-			    result, state_vector.state_vector, count);
+			if (key_type.id() == LogicalTypeId::DATE) {
+				FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, date_t>(
+				    result, state_vector.state_vector, count);
+			} else {
+				FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int32_t>(
+				    result, state_vector.state_vector, count);
+			}
 			break;
 		case PhysicalType::INT64:
-			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int64_t>(
-			    result, state_vector.state_vector, count);
+			switch (key_type.id()) {
+			case LogicalTypeId::TIME:
+				FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, dtime_t>(
+				    result, state_vector.state_vector, count);
+				break;
+			case LogicalTypeId::TIME_TZ:
+				FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, dtime_tz_t>(
+				    result, state_vector.state_vector, count);
+				break;
+			case LogicalTypeId::TIMESTAMP:
+				FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, timestamp_t>(
+				    result, state_vector.state_vector, count);
+				break;
+			case LogicalTypeId::TIMESTAMP_MS:
+				FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, timestamp_ms_t>(
+				    result, state_vector.state_vector, count);
+				break;
+			case LogicalTypeId::TIMESTAMP_NS:
+				FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, timestamp_ns_t>(
+				    result, state_vector.state_vector, count);
+				break;
+			case LogicalTypeId::TIMESTAMP_SEC:
+				FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, timestamp_sec_t>(
+				    result, state_vector.state_vector, count);
+				break;
+			case LogicalTypeId::TIMESTAMP_TZ:
+				FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, timestamp_tz_t>(
+				    result, state_vector.state_vector, count);
+				break;
+			default:
+				FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, int64_t>(
+				    result, state_vector.state_vector, count);
+				break;
+			}
 			break;
 		case PhysicalType::FLOAT:
 			FUNCTION_FUNCTOR::template ListExecuteFunction<FinalizeValueFunctor, float>(

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 "8a4d0609c"
-#define DUCKDB_VERSION "v0.5.1-dev61"
+#define DUCKDB_SOURCE_ID "0d13deb75"
+#define DUCKDB_VERSION "v0.5.1-dev88"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -670,7 +670,7 @@ struct date_t { // NOLINT
 
 //! Type used to represent time (microseconds)
 struct dtime_t { // NOLINT
-    int64_t micros;
+	int64_t micros;
 
 	dtime_t() = default;
 	explicit inline dtime_t(int64_t micros_p) : micros(micros_p) {}
@@ -705,9 +705,11 @@ struct dtime_t { // NOLINT
 	static inline dtime_t allballs() {return dtime_t(0); } // NOLINT
 };
 
+struct dtime_tz_t : public dtime_t {};
+
 //! Type used to represent timestamps (seconds,microseconds,milliseconds or nanoseconds since 1970-01-01)
 struct timestamp_t { // NOLINT
-    int64_t value;
+	int64_t value;
 
 	timestamp_t() = default;
 	explicit inline timestamp_t(int64_t value_p) : value(value_p) {}
@@ -738,6 +740,11 @@ struct timestamp_t { // NOLINT
 	static inline timestamp_t epoch() {return timestamp_t(0); } // NOLINT
 };
 
+struct timestamp_tz_t : public timestamp_t {};
+struct timestamp_ns_t : public timestamp_t {};
+struct timestamp_ms_t : public timestamp_t {};
+struct timestamp_sec_t : public timestamp_t {};
+
 struct interval_t {
 	int32_t months;
 	int32_t days;
@@ -1021,6 +1028,10 @@ struct LogicalType {
 	inline const ExtraTypeInfo *AuxInfo() const {
 		return type_info_.get();
 	}
+	inline void CopyAuxInfo(const LogicalType& other) {
+		type_info_ = other.type_info_;
+	}
+	bool EqualTypeInfo(const LogicalType& rhs) const;
 
 	// copy assignment
 	inline LogicalType& operator=(const LogicalType &other) {
@@ -1047,6 +1058,16 @@ struct LogicalType {
 	//! Deserializes a blob back into an LogicalType
 	DUCKDB_API static LogicalType Deserialize(Deserializer &source);
 
+	DUCKDB_API static bool TypeIsTimestamp(LogicalTypeId id) {
+		return (id == LogicalTypeId::TIMESTAMP ||
+				id == LogicalTypeId::TIMESTAMP_MS ||
+				id == LogicalTypeId::TIMESTAMP_NS ||
+				id == LogicalTypeId::TIMESTAMP_SEC ||
+				id == LogicalTypeId::TIMESTAMP_TZ);
+	}
+	DUCKDB_API static bool TypeIsTimestamp(const LogicalType& type) {
+		return TypeIsTimestamp(type.id());
+	}
 	DUCKDB_API string ToString() const;
 	DUCKDB_API bool IsIntegral() const;
 	DUCKDB_API bool IsNumeric() const;
@@ -1263,6 +1284,87 @@ struct aggregate_state_t {
 
 } // namespace duckdb
 
+namespace std {
+
+	//! Date
+	template <>
+	struct hash<duckdb::date_t>
+	{
+		std::size_t operator()(const duckdb::date_t& k) const
+		{
+			using std::hash;
+			return hash<int32_t>()((int32_t)k);
+		}
+	};
+
+	//! Time
+	template <>
+	struct hash<duckdb::dtime_t>
+	{
+		std::size_t operator()(const duckdb::dtime_t& k) const
+		{
+			using std::hash;
+			return hash<int64_t>()((int64_t)k);
+		}
+	};
+	template <>
+	struct hash<duckdb::dtime_tz_t>
+	{
+		std::size_t operator()(const duckdb::dtime_tz_t& k) const
+		{
+			using std::hash;
+			return hash<int64_t>()((int64_t)k);
+		}
+	};
+
+	//! Timestamp
+	template <>
+	struct hash<duckdb::timestamp_t>
+	{
+		std::size_t operator()(const duckdb::timestamp_t& k) const
+		{
+			using std::hash;
+			return hash<int64_t>()((int64_t)k);
+		}
+	};
+	template <>
+	struct hash<duckdb::timestamp_ms_t>
+	{
+		std::size_t operator()(const duckdb::timestamp_ms_t& k) const
+		{
+			using std::hash;
+			return hash<int64_t>()((int64_t)k);
+		}
+	};
+	template <>
+	struct hash<duckdb::timestamp_ns_t>
+	{
+		std::size_t operator()(const duckdb::timestamp_ns_t& k) const
+		{
+			using std::hash;
+			return hash<int64_t>()((int64_t)k);
+		}
+	};
+	template <>
+	struct hash<duckdb::timestamp_sec_t>
+	{
+		std::size_t operator()(const duckdb::timestamp_sec_t& k) const
+		{
+			using std::hash;
+			return hash<int64_t>()((int64_t)k);
+		}
+	};
+	template <>
+	struct hash<duckdb::timestamp_tz_t>
+	{
+		std::size_t operator()(const duckdb::timestamp_tz_t& k) const
+		{
+			using std::hash;
+			return hash<int64_t>()((int64_t)k);
+		}
+	};
+}
+
 
 namespace duckdb {
 
@@ -3161,8 +3263,18 @@ Value DUCKDB_API Value::CreateValue(date_t value);
 template <>
 Value DUCKDB_API Value::CreateValue(dtime_t value);
 template <>
+Value DUCKDB_API Value::CreateValue(dtime_tz_t value);
+template <>
 Value DUCKDB_API Value::CreateValue(timestamp_t value);
 template <>
+Value DUCKDB_API Value::CreateValue(timestamp_sec_t value);
+template <>
+Value DUCKDB_API Value::CreateValue(timestamp_ms_t value);
+template <>
+Value DUCKDB_API Value::CreateValue(timestamp_ns_t value);
+template <>
+Value DUCKDB_API Value::CreateValue(timestamp_tz_t value);
+template <>
 Value DUCKDB_API Value::CreateValue(const char *value);
 template <>
 Value DUCKDB_API Value::CreateValue(string value);