duckdb 0.2.10-dev488.0 → 0.3.1-dev2.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.2.10-dev488.0",
+  "version": "0.3.1-dev2.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -22120,6 +22120,30 @@ template <>
 bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_vector, string *error_message,
                               bool strict);
 
+//===--------------------------------------------------------------------===//
+// UUID
+//===--------------------------------------------------------------------===//
+struct CastFromUUID {
+	template <class SRC>
+	static inline string_t Operation(SRC input, Vector &result) {
+		throw duckdb::NotImplementedException("Cast from uuid could not be performed!");
+	}
+};
+template <>
+duckdb::string_t CastFromUUID::Operation(duckdb::hugeint_t input, Vector &vector);
+
+struct TryCastToUUID {
+	template <class SRC, class DST>
+	static inline bool Operation(SRC input, DST &result, Vector &result_vector, string *error_message,
+	                             bool strict = false) {
+		throw InternalException("Unsupported type for try cast to uuid");
+	}
+};
+
+template <>
+bool TryCastToUUID::Operation(string_t input, hugeint_t &result, Vector &result_vector, string *error_message,
+                              bool strict);
+
 } // namespace duckdb
 
 //===----------------------------------------------------------------------===//
@@ -23454,6 +23478,7 @@ struct IntervalToStringCast {
 
 
 
+
 #include <cctype>
 #include <cmath>
 #include <cstdlib>
@@ -24700,6 +24725,7 @@ bool TryCastToTimestampSec::Operation(string_t input, timestamp_t &result, bool
 	result = Timestamp::GetEpochSeconds(result);
 	return true;
 }
+
 //===--------------------------------------------------------------------===//
 // Cast From Blob
 //===--------------------------------------------------------------------===//
@@ -24730,6 +24756,26 @@ bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_v
 	return true;
 }
 
+//===--------------------------------------------------------------------===//
+// Cast From UUID
+//===--------------------------------------------------------------------===//
+template <>
+string_t CastFromUUID::Operation(hugeint_t input, Vector &vector) {
+	string_t result = StringVector::EmptyString(vector, 36);
+	UUID::ToString(input, result.GetDataWriteable());
+	result.Finalize();
+	return result;
+}
+
+//===--------------------------------------------------------------------===//
+// Cast To UUID
+//===--------------------------------------------------------------------===//
+template <>
+bool TryCastToUUID::Operation(string_t input, hugeint_t &result, Vector &result_vector, string *error_message,
+                              bool strict) {
+	return UUID::FromString(input.GetString(), result);
+}
+
 //===--------------------------------------------------------------------===//
 // Cast To Date
 //===--------------------------------------------------------------------===//
@@ -37124,6 +37170,93 @@ int64_t Timestamp::GetEpochNanoSeconds(timestamp_t timestamp) {
 } // namespace duckdb
 
 
+namespace duckdb {
+
+bool UUID::FromString(string str, hugeint_t &result) {
+	auto hex2char = [](char ch) -> unsigned char {
+		if (ch >= '0' && ch <= '9') {
+			return ch - '0';
+		}
+		if (ch >= 'a' && ch <= 'f') {
+			return 10 + ch - 'a';
+		}
+		if (ch >= 'A' && ch <= 'F') {
+			return 10 + ch - 'A';
+		}
+		return 0;
+	};
+	auto is_hex = [](char ch) -> bool {
+		return (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F');
+	};
+
+	if (str.empty()) {
+		return false;
+	}
+	int has_braces = 0;
+	if (str.front() == '{') {
+		has_braces = 1;
+	}
+	if (has_braces && str.back() != '}') {
+		return false;
+	}
+
+	result.lower = 0;
+	result.upper = 0;
+	size_t count = 0;
+	for (size_t i = has_braces; i < str.size() - has_braces; ++i) {
+		if (str[i] == '-') {
+			continue;
+		}
+		if (count >= 32 || !is_hex(str[i])) {
+			return false;
+		}
+		if (count >= 16) {
+			result.lower = (result.lower << 4) | hex2char(str[i]);
+		} else {
+			result.upper = (result.upper << 4) | hex2char(str[i]);
+		}
+		count++;
+	}
+	// Flip the first bit to make `order by uuid` same as `order by uuid::varchar`
+	result.upper ^= (int64_t(1) << 63);
+	return count == 32;
+}
+
+void UUID::ToString(hugeint_t input, char *buf) {
+	auto byte_to_hex = [](char byte_val, char *buf, idx_t &pos) {
+		static char const HEX_DIGITS[] = "0123456789abcdef";
+		buf[pos++] = HEX_DIGITS[(byte_val >> 4) & 0xf];
+		buf[pos++] = HEX_DIGITS[byte_val & 0xf];
+	};
+
+	// Flip back before convert to string
+	int64_t upper = input.upper ^ (int64_t(1) << 63);
+	idx_t pos = 0;
+	byte_to_hex(upper >> 56 & 0xFF, buf, pos);
+	byte_to_hex(upper >> 48 & 0xFF, buf, pos);
+	byte_to_hex(upper >> 40 & 0xFF, buf, pos);
+	byte_to_hex(upper >> 32 & 0xFF, buf, pos);
+	buf[pos++] = '-';
+	byte_to_hex(upper >> 24 & 0xFF, buf, pos);
+	byte_to_hex(upper >> 16 & 0xFF, buf, pos);
+	buf[pos++] = '-';
+	byte_to_hex(upper >> 8 & 0xFF, buf, pos);
+	byte_to_hex(upper & 0xFF, buf, pos);
+	buf[pos++] = '-';
+	byte_to_hex(input.lower >> 56 & 0xFF, buf, pos);
+	byte_to_hex(input.lower >> 48 & 0xFF, buf, pos);
+	buf[pos++] = '-';
+	byte_to_hex(input.lower >> 40 & 0xFF, buf, pos);
+	byte_to_hex(input.lower >> 32 & 0xFF, buf, pos);
+	byte_to_hex(input.lower >> 24 & 0xFF, buf, pos);
+	byte_to_hex(input.lower >> 16 & 0xFF, buf, pos);
+	byte_to_hex(input.lower >> 8 & 0xFF, buf, pos);
+	byte_to_hex(input.lower & 0xFF, buf, pos);
+}
+
+} // namespace duckdb
+
+
 namespace duckdb {
 
 ValidityData::ValidityData(idx_t count) : TemplatedValidityData(count) {
@@ -37349,6 +37482,7 @@ hugeint_t ModuloOperator::Operation(hugeint_t left, hugeint_t right);
 
 
 
+
 namespace duckdb {
 
 Value::Value(LogicalType type) : type_(move(type)), is_null(true) {
@@ -37406,6 +37540,8 @@ Value Value::MinimumValue(const LogicalType &type) {
 		return Value::BIGINT(NumericLimits<int64_t>::Minimum());
 	case LogicalTypeId::HUGEINT:
 		return Value::HUGEINT(NumericLimits<hugeint_t>::Minimum());
+	case LogicalTypeId::UUID:
+		return Value::UUID(NumericLimits<hugeint_t>::Minimum());
 	case LogicalTypeId::UTINYINT:
 		return Value::UTINYINT(NumericLimits<uint8_t>::Minimum());
 	case LogicalTypeId::USMALLINT:
@@ -37471,6 +37607,8 @@ Value Value::MaximumValue(const LogicalType &type) {
 		return Value::BIGINT(NumericLimits<int64_t>::Maximum());
 	case LogicalTypeId::HUGEINT:
 		return Value::HUGEINT(NumericLimits<hugeint_t>::Maximum());
+	case LogicalTypeId::UUID:
+		return Value::UUID(NumericLimits<hugeint_t>::Maximum());
 	case LogicalTypeId::UTINYINT:
 		return Value::UTINYINT(NumericLimits<uint8_t>::Maximum());
 	case LogicalTypeId::USMALLINT:
@@ -37563,6 +37701,20 @@ Value Value::HUGEINT(hugeint_t value) {
 	return result;
 }
 
+Value Value::UUID(hugeint_t value) {
+	Value result(LogicalType::UUID);
+	result.value_.hugeint = value;
+	result.is_null = false;
+	return result;
+}
+
+Value Value::UUID(const string &value) {
+	Value result(LogicalType::UUID);
+	result.value_.hugeint = UUID::FromString(value);
+	result.is_null = false;
+	return result;
+}
+
 Value Value::UTINYINT(uint8_t value) {
 	Value result(LogicalType::UTINYINT);
 	result.value_.utinyint = value;
@@ -37945,6 +38097,7 @@ T Value::GetValueInternal() const {
 	case LogicalTypeId::BIGINT:
 		return Cast::Operation<int64_t, T>(value_.bigint);
 	case LogicalTypeId::HUGEINT:
+	case LogicalTypeId::UUID:
 		return Cast::Operation<hugeint_t, T>(value_.hugeint);
 	case LogicalTypeId::DATE:
 		return Cast::Operation<date_t, T>(value_.date);
@@ -38245,6 +38398,8 @@ string Value::ToString() const {
 		return to_string(value_.ubigint);
 	case LogicalTypeId::HUGEINT:
 		return Hugeint::ToString(value_.hugeint);
+	case LogicalTypeId::UUID:
+		return UUID::ToString(value_.hugeint);
 	case LogicalTypeId::FLOAT:
 		return to_string(value_.float_);
 	case LogicalTypeId::DOUBLE:
@@ -38945,6 +39100,7 @@ void Vector::SetValue(idx_t index, const Value &val) {
 		((uint64_t *)data)[index] = val.value_.ubigint;
 		break;
 	case LogicalTypeId::HUGEINT:
+	case LogicalTypeId::UUID:
 		((hugeint_t *)data)[index] = val.value_.hugeint;
 		break;
 	case LogicalTypeId::DECIMAL:
@@ -39077,6 +39233,8 @@ Value Vector::GetValue(idx_t index) const {
 		return Value::TimestampSec(((timestamp_t *)data)[index]);
 	case LogicalTypeId::HUGEINT:
 		return Value::HUGEINT(((hugeint_t *)data)[index]);
+	case LogicalTypeId::UUID:
+		return Value::UUID(((hugeint_t *)data)[index]);
 	case LogicalTypeId::DECIMAL: {
 		auto width = DecimalType::GetWidth(GetType());
 		auto scale = DecimalType::GetScale(GetType());
@@ -40868,6 +41026,7 @@ PhysicalType LogicalType::GetInternalType() {
 	case LogicalTypeId::UBIGINT:
 		return PhysicalType::UINT64;
 	case LogicalTypeId::HUGEINT:
+	case LogicalTypeId::UUID:
 		return PhysicalType::INT128;
 	case LogicalTypeId::FLOAT:
 		return PhysicalType::FLOAT;
@@ -40938,6 +41097,7 @@ const LogicalType LogicalType::UINTEGER = LogicalType(LogicalTypeId::UINTEGER);
 const LogicalType LogicalType::BIGINT = LogicalType(LogicalTypeId::BIGINT);
 const LogicalType LogicalType::UBIGINT = LogicalType(LogicalTypeId::UBIGINT);
 const LogicalType LogicalType::HUGEINT = LogicalType(LogicalTypeId::HUGEINT);
+const LogicalType LogicalType::UUID = LogicalType(LogicalTypeId::UUID);
 const LogicalType LogicalType::FLOAT = LogicalType(LogicalTypeId::FLOAT);
 const LogicalType LogicalType::DOUBLE = LogicalType(LogicalTypeId::DOUBLE);
 const LogicalType LogicalType::DATE = LogicalType(LogicalTypeId::DATE);
@@ -40976,7 +41136,7 @@ const vector<LogicalType> LogicalType::ALL_TYPES = {
     LogicalType::FLOAT,    LogicalType::VARCHAR,   LogicalType::BLOB,      LogicalType::INTERVAL,
     LogicalType::HUGEINT,  LogicalTypeId::DECIMAL, LogicalType::UTINYINT,  LogicalType::USMALLINT,
     LogicalType::UINTEGER, LogicalType::UBIGINT,   LogicalType::TIME,      LogicalTypeId::LIST,
-    LogicalTypeId::STRUCT, LogicalTypeId::MAP};
+    LogicalTypeId::STRUCT, LogicalTypeId::MAP,     LogicalType::UUID};
 
 const LogicalType LOGICAL_ROW_TYPE = LogicalType::BIGINT;
 const PhysicalType ROW_TYPE = PhysicalType::INT64;
@@ -41133,6 +41293,8 @@ string LogicalTypeIdToString(LogicalTypeId id) {
 		return "BIGINT";
 	case LogicalTypeId::HUGEINT:
 		return "HUGEINT";
+	case LogicalTypeId::UUID:
+		return "UUID";
 	case LogicalTypeId::UTINYINT:
 		return "UTINYINT";
 	case LogicalTypeId::USMALLINT:
@@ -41289,6 +41451,8 @@ LogicalTypeId TransformStringToLogicalType(const string &str) {
 		return LogicalTypeId::INTERVAL;
 	} else if (lower_str == "hugeint" || lower_str == "int128") {
 		return LogicalTypeId::HUGEINT;
+	} else if (lower_str == "uuid" || lower_str == "guid") {
+		return LogicalTypeId::UUID;
 	} else if (lower_str == "struct" || lower_str == "row") {
 		return LogicalTypeId::STRUCT;
 	} else if (lower_str == "map") {
@@ -44479,6 +44643,9 @@ static bool StringCastSwitch(Vector &source, Vector &result, idx_t count, bool s
 	case LogicalTypeId::BLOB:
 		return VectorTryCastStringLoop<string_t, string_t, duckdb::TryCastToBlob>(source, result, count, strict,
 		                                                                          error_message);
+	case LogicalTypeId::UUID:
+		return VectorTryCastStringLoop<string_t, hugeint_t, duckdb::TryCastToUUID>(source, result, count, strict,
+		                                                                           error_message);
 	case LogicalTypeId::SQLNULL:
 		return TryVectorNullCast(source, result, count, error_message);
 	default:
@@ -44610,6 +44777,19 @@ static bool IntervalCastSwitch(Vector &source, Vector &result, idx_t count, stri
 	return true;
 }
 
+static bool UUIDCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
+	// now switch on the result type
+	switch (result.GetType().id()) {
+	case LogicalTypeId::VARCHAR:
+		// uuid to varchar
+		VectorStringCast<hugeint_t, duckdb::CastFromUUID>(source, result, count);
+		break;
+	default:
+		return TryVectorNullCast(source, result, count, error_message);
+	}
+	return true;
+}
+
 static bool BlobCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
 	// now switch on the result type
 	switch (result.GetType().id()) {
@@ -44752,6 +44932,8 @@ bool VectorOperations::TryCast(Vector &source, Vector &result, idx_t count, stri
 		return NumericCastSwitch<uint64_t>(source, result, count, error_message);
 	case LogicalTypeId::HUGEINT:
 		return NumericCastSwitch<hugeint_t>(source, result, count, error_message);
+	case LogicalTypeId::UUID:
+		return UUIDCastSwitch(source, result, count, error_message);
 	case LogicalTypeId::DECIMAL:
 		return DecimalCastSwitch(source, result, count, error_message);
 	case LogicalTypeId::FLOAT:
@@ -70569,6 +70751,7 @@ static AggregateFunction GetUnaryAggregate(LogicalType type) {
 	case LogicalTypeId::UBIGINT:
 		return AggregateFunction::UnaryAggregate<MinMaxState<uint64_t>, uint64_t, uint64_t, OP>(type, type);
 	case LogicalTypeId::HUGEINT:
+	case LogicalTypeId::UUID:
 		return AggregateFunction::UnaryAggregate<MinMaxState<hugeint_t>, hugeint_t, hugeint_t, OP>(type, type);
 	case LogicalTypeId::FLOAT:
 		return AggregateFunction::UnaryAggregate<MinMaxState<float>, float, float, OP>(type, type);
@@ -89612,6 +89795,7 @@ void StructPackFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+
 namespace duckdb {
 
 // current_query
@@ -89624,6 +89808,11 @@ struct SystemBindData : public FunctionData {
 	unique_ptr<FunctionData> Copy() override {
 		return make_unique<SystemBindData>(context);
 	}
+
+	static SystemBindData &GetFrom(ExpressionState &state) {
+		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		return (SystemBindData &)*func_expr.bind_info;
+	}
 };
 
 unique_ptr<FunctionData> BindSystemFunction(ClientContext &context, ScalarFunction &bound_function,
@@ -89632,8 +89821,7 @@ unique_ptr<FunctionData> BindSystemFunction(ClientContext &context, ScalarFuncti
 }
 
 static void CurrentQueryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (SystemBindData &)*func_expr.bind_info;
+	auto &info = SystemBindData::GetFrom(state);
 
 	Value val(info.context.query);
 	result.Reference(val);
@@ -89641,13 +89829,16 @@ static void CurrentQueryFunction(DataChunk &input, ExpressionState &state, Vecto
 
 // current_schema
 static void CurrentSchemaFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	Value val(DEFAULT_SCHEMA);
+	Value val(SystemBindData::GetFrom(state).context.catalog_search_path->GetDefault());
 	result.Reference(val);
 }
 
 // current_schemas
 static void CurrentSchemasFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	vector<Value> schema_list = {Value(DEFAULT_SCHEMA)};
+	vector<Value> schema_list;
+	vector<string> search_path = SystemBindData::GetFrom(state).context.catalog_search_path->Get();
+	std::transform(search_path.begin(), search_path.end(), std::back_inserter(schema_list),
+	               [](const string &s) -> Value { return Value(s); });
 	auto val = Value::LIST(schema_list);
 	result.Reference(val);
 }
@@ -89673,9 +89864,10 @@ void SystemFun::RegisterFunction(BuiltinFunctions &set) {
 
 	set.AddFunction(
 	    ScalarFunction("current_query", {}, LogicalType::VARCHAR, CurrentQueryFunction, false, BindSystemFunction));
-	set.AddFunction(ScalarFunction("current_schema", {}, LogicalType::VARCHAR, CurrentSchemaFunction));
 	set.AddFunction(
-	    ScalarFunction("current_schemas", {LogicalType::BOOLEAN}, varchar_list_type, CurrentSchemasFunction));
+	    ScalarFunction("current_schema", {}, LogicalType::VARCHAR, CurrentSchemaFunction, false, BindSystemFunction));
+	set.AddFunction(ScalarFunction("current_schemas", {LogicalType::BOOLEAN}, varchar_list_type, CurrentSchemasFunction,
+	                               false, BindSystemFunction));
 	set.AddFunction(
 	    ScalarFunction("txid_current", {}, LogicalType::BIGINT, TransactionIdCurrent, false, BindSystemFunction));
 	set.AddFunction(ScalarFunction("version", {}, LogicalType::VARCHAR, VersionFunction));
@@ -148128,7 +148320,7 @@ string ValidityStatistics::ToString() {
 
 namespace duckdb {
 
-const uint64_t VERSION_NUMBER = 22;
+const uint64_t VERSION_NUMBER = 25;
 
 } // namespace duckdb
 

package/src/duckdb.hpp

@@ -10,8 +10,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 #pragma once
 #define DUCKDB_AMALGAMATION 1
-#define DUCKDB_SOURCE_ID "f533a8f6d"
-#define DUCKDB_VERSION "0.2.10-dev488"
+#define DUCKDB_SOURCE_ID "97106596e"
+#define DUCKDB_VERSION "0.3.1-dev2"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -908,6 +908,7 @@ enum class LogicalTypeId : uint8_t {
 	POINTER = 51,
 	HASH = 52,
 	VALIDITY = 53,
+	UUID = 54,
 
 	STRUCT = 100,
 	LIST = 101,
@@ -1008,6 +1009,7 @@ public:
 	DUCKDB_API static const LogicalType BLOB;
 	DUCKDB_API static const LogicalType INTERVAL;
 	DUCKDB_API static const LogicalType HUGEINT;
+	DUCKDB_API static const LogicalType UUID;
 	DUCKDB_API static const LogicalType HASH;
 	DUCKDB_API static const LogicalType POINTER;
 	DUCKDB_API static const LogicalType TABLE;
@@ -2537,6 +2539,10 @@ public:
 	DUCKDB_API static Value UBIGINT(uint64_t value);
 	//! Create a hugeint Value from a specified value
 	DUCKDB_API static Value HUGEINT(hugeint_t value);
+	//! Create a uuid Value from a specified value
+	DUCKDB_API static Value UUID(const string &value);
+	//! Create a uuid Value from a specified value
+	DUCKDB_API static Value UUID(hugeint_t value);
 	//! Create a hash Value from a specified value
 	DUCKDB_API static Value HASH(hash_t value);
 	//! Create a pointer Value from a specified value
@@ -11570,6 +11576,48 @@ public:
 	static string ToString(int64_t value, uint8_t scale);
 	static string ToString(hugeint_t value, uint8_t scale);
 };
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/types/uuid.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+//! The UUID class contains static operations for the UUID type
+class UUID {
+public:
+	//! Convert a uuid string to a hugeint object
+	static bool FromString(string str, hugeint_t &result);
+	//! Convert a uuid string to a hugeint object
+	static bool FromCString(const char *str, idx_t len, hugeint_t &result) {
+		return FromString(string(str, 0, len), result);
+	}
+	//! Convert a hugeint object to a uuid style string
+	static void ToString(hugeint_t input, char *buf);
+
+	//! Convert a hugeint object to a uuid style string
+	static string ToString(hugeint_t input) {
+		char buff[36];
+		ToString(input, buff);
+		return string(buff, 36);
+	}
+
+	static hugeint_t FromString(string str) {
+		hugeint_t result;
+		FromString(str, result);
+		return result;
+	}
+};
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB