duckdb 0.8.2-dev4711.0 → 0.8.2-dev5002.0

package/src/duckdb/src/function/cast/time_casts.cpp

@@ -134,6 +134,10 @@ BoundCastInfo DefaultCasts::TimestampMsCastSwitch(BindCastInput &input, const Lo
 		// timestamp (ms) to timestamp (us)
 		return BoundCastInfo(
 		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampMsToUs>);
+	case LogicalTypeId::TIMESTAMP_NS:
+		// timestamp (ms) to timestamp (ns)
+		return BoundCastInfo(
+		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampMsToNs>);
 	default:
 		return TryVectorNullCast;
 	}
@@ -146,10 +150,18 @@ BoundCastInfo DefaultCasts::TimestampSecCastSwitch(BindCastInput &input, const L
 	case LogicalTypeId::VARCHAR:
 		// timestamp (sec) to varchar
 		return BoundCastInfo(&VectorCastHelpers::StringCast<timestamp_t, duckdb::CastFromTimestampSec>);
+	case LogicalTypeId::TIMESTAMP_MS:
+		// timestamp (s) to timestamp (ms)
+		return BoundCastInfo(
+		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampSecToMs>);
 	case LogicalTypeId::TIMESTAMP:
 		// timestamp (s) to timestamp (us)
 		return BoundCastInfo(
 		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampSecToUs>);
+	case LogicalTypeId::TIMESTAMP_NS:
+		// timestamp (s) to timestamp (ns)
+		return BoundCastInfo(
+		    &VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::CastTimestampSecToNs>);
 	default:
 		return TryVectorNullCast;
 	}

package/src/duckdb/src/function/cast/vector_cast_helpers.cpp

@@ -20,10 +20,16 @@ inline static void SkipWhitespace(const char *buf, idx_t &pos, idx_t len) {
 static bool SkipToCloseQuotes(idx_t &pos, const char *buf, idx_t &len) {
 	char quote = buf[pos];
 	pos++;
+	bool escaped = false;
 
 	while (pos < len) {
-		if (buf[pos] == quote) {
-			return true;
+		if (buf[pos] == '\\') {
+			escaped = !escaped;
+		} else {
+			if (buf[pos] == quote && !escaped) {
+				return true;
+			}
+			escaped = false;
 		}
 		pos++;
 	}

package/src/duckdb/src/function/function_binder.cpp

@@ -1,16 +1,16 @@
 #include "duckdb/function/function_binder.hpp"
-#include "duckdb/common/limits.hpp"
 
-#include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/catalog/catalog.hpp"
 #include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
-
-#include "duckdb/planner/expression_binder.hpp"
+#include "duckdb/common/limits.hpp"
+#include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/function/aggregate_function.hpp"
 #include "duckdb/function/cast_rules.hpp"
-#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/planner/expression_binder.hpp"
 
 namespace duckdb {
 
@@ -268,7 +268,8 @@ unique_ptr<Expression> FunctionBinder::BindScalarFunction(ScalarFunctionCatalogE
 
 	if (bound_function.null_handling == FunctionNullHandling::DEFAULT_NULL_HANDLING) {
 		for (auto &child : children) {
-			if (child->return_type == LogicalTypeId::SQLNULL) {
+			if (child->return_type == LogicalTypeId::SQLNULL ||
+			    (child->IsFoldable() && ExpressionExecutor::EvaluateScalar(context, *child).IsNull())) {
 				return make_uniq<BoundConstantExpression>(Value(LogicalType::SQLNULL));
 			}
 		}

package/src/duckdb/src/function/pragma/pragma_queries.cpp

@@ -124,12 +124,15 @@ string PragmaShow(ClientContext &context, const FunctionParameters &parameters)
 	ON cols.column_name = pragma_table_info.name 
 	AND cols.table_name='%table_name%'
 	AND cols.schema_name='%table_schema%'
+	AND cols.database_name = '%table_database%'
 	ORDER BY column_index;)";
 	// clang-format on
 
 	sql = StringUtil::Replace(sql, "%func_param_table%", parameters.values[0].ToString());
 	sql = StringUtil::Replace(sql, "%table_name%", table.name);
 	sql = StringUtil::Replace(sql, "%table_schema%", table.schema.empty() ? DEFAULT_SCHEMA : table.schema);
+	sql = StringUtil::Replace(sql, "%table_database%",
+	                          table.catalog.empty() ? DatabaseManager::GetDefaultDatabase(context) : table.catalog);
 	return sql;
 }
 

package/src/duckdb/src/function/scalar/string/like.cpp

@@ -196,9 +196,6 @@ static unique_ptr<FunctionData> LikeBindFunction(ClientContext &context, ScalarF
 	D_ASSERT(arguments.size() == 2 || arguments.size() == 3);
 	if (arguments[1]->IsFoldable()) {
 		Value pattern_str = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
-		if (pattern_str.IsNull()) {
-			return nullptr;
-		}
 		return LikeMatcher::CreateLikeMatcher(pattern_str.ToString());
 	}
 	return nullptr;

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev4711"
+#define DUCKDB_VERSION "0.8.2-dev5002"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "474a0bd683"
+#define DUCKDB_SOURCE_ID "239f51293c"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/common/enums/date_part_specifier.hpp

@@ -25,7 +25,6 @@ enum class DatePartSpecifier : uint8_t {
 	SECOND,
 	MINUTE,
 	HOUR,
-	EPOCH,
 	DOW,
 	ISODOW,
 	WEEK,
@@ -39,11 +38,20 @@ enum class DatePartSpecifier : uint8_t {
 	TIMEZONE_MINUTE,
 
 	//	DOUBLE values
-	JULIAN_DAY
+	EPOCH,
+	JULIAN_DAY,
+
+	//	Invalid
+	INVALID,
+
+	//	Type ranges
+	BEGIN_BIGINT = YEAR,
+	BEGIN_DOUBLE = EPOCH,
+	BEGIN_INVALID = INVALID,
 };
 
 inline bool IsBigintDatepart(DatePartSpecifier part_code) {
-	return size_t(part_code) < size_t(DatePartSpecifier::JULIAN_DAY);
+	return size_t(part_code) < size_t(DatePartSpecifier::BEGIN_DOUBLE);
 }
 
 DUCKDB_API bool TryGetDatePartSpecifier(const string &specifier, DatePartSpecifier &result);

package/src/duckdb/src/include/duckdb/common/multi_file_reader.hpp

@@ -182,6 +182,11 @@ struct MultiFileReader {
 			}
 		}
 		for (idx_t r = 0; r < data.union_readers.size(); r++) {
+			if (!data.union_readers[r]) {
+				data.union_readers.erase(data.union_readers.begin() + r);
+				r--;
+				continue;
+			}
 			// check if the union reader should still be read or not
 			auto entry = file_set.find(data.union_readers[r]->GetFileName());
 			if (entry == file_set.end()) {

package/src/duckdb/src/include/duckdb/common/operator/cast_operators.hpp

@@ -632,6 +632,13 @@ struct CastTimestampMsToUs {
 	}
 };
 
+struct CastTimestampMsToNs {
+	template <class SRC, class DST>
+	static inline DST Operation(SRC input) {
+		throw duckdb::NotImplementedException("Cast to TIMESTAMP_NS could not be performed!");
+	}
+};
+
 struct CastTimestampNsToUs {
 	template <class SRC, class DST>
 	static inline DST Operation(SRC input) {
@@ -639,6 +646,13 @@ struct CastTimestampNsToUs {
 	}
 };
 
+struct CastTimestampSecToMs {
+	template <class SRC, class DST>
+	static inline DST Operation(SRC input) {
+		throw duckdb::NotImplementedException("Cast to TIMESTAMP_MS could not be performed!");
+	}
+};
+
 struct CastTimestampSecToUs {
 	template <class SRC, class DST>
 	static inline DST Operation(SRC input) {
@@ -646,6 +660,13 @@ struct CastTimestampSecToUs {
 	}
 };
 
+struct CastTimestampSecToNs {
+	template <class SRC, class DST>
+	static inline DST Operation(SRC input) {
+		throw duckdb::NotImplementedException("Cast to TIMESTAMP_NS could not be performed!");
+	}
+};
+
 template <>
 duckdb::timestamp_t CastTimestampUsToMs::Operation(duckdb::timestamp_t input);
 template <>
@@ -655,9 +676,15 @@ duckdb::timestamp_t CastTimestampUsToSec::Operation(duckdb::timestamp_t input);
 template <>
 duckdb::timestamp_t CastTimestampMsToUs::Operation(duckdb::timestamp_t input);
 template <>
+duckdb::timestamp_t CastTimestampMsToNs::Operation(duckdb::timestamp_t input);
+template <>
 duckdb::timestamp_t CastTimestampNsToUs::Operation(duckdb::timestamp_t input);
 template <>
+duckdb::timestamp_t CastTimestampSecToMs::Operation(duckdb::timestamp_t input);
+template <>
 duckdb::timestamp_t CastTimestampSecToUs::Operation(duckdb::timestamp_t input);
+template <>
+duckdb::timestamp_t CastTimestampSecToNs::Operation(duckdb::timestamp_t input);
 
 template <>
 duckdb::string_t CastFromTimestampNS::Operation(duckdb::timestamp_t input, Vector &result);

package/src/duckdb/src/include/duckdb/common/operator/comparison_operators.hpp

@@ -8,11 +8,11 @@
 
 #pragma once
 
-#include "duckdb/common/types/string_type.hpp"
+#include "duckdb/common/helper.hpp"
 #include "duckdb/common/types.hpp"
 #include "duckdb/common/types/hugeint.hpp"
 #include "duckdb/common/types/interval.hpp"
-#include "duckdb/common/helper.hpp"
+#include "duckdb/common/types/string_type.hpp"
 
 #include <cstring>
 
@@ -142,6 +142,42 @@ struct DistinctLessThanEquals {
 	}
 };
 
+//===--------------------------------------------------------------------===//
+// Comparison Operator Wrappers (so (Not)DistinctFrom have the same API)
+//===--------------------------------------------------------------------===//
+template <class OP>
+struct ComparisonOperationWrapper {
+	static constexpr const bool COMPARE_NULL = false;
+
+	template <class T>
+	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
+		if (right_null || left_null) {
+			return false;
+		}
+		return OP::template Operation<T>(left, right);
+	}
+};
+
+template <>
+struct ComparisonOperationWrapper<DistinctFrom> {
+	static constexpr const bool COMPARE_NULL = true;
+
+	template <class T>
+	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
+		return DistinctFrom::template Operation<T>(left, right, left_null, right_null);
+	}
+};
+
+template <>
+struct ComparisonOperationWrapper<NotDistinctFrom> {
+	static constexpr const bool COMPARE_NULL = true;
+
+	template <class T>
+	static inline bool Operation(const T &left, const T &right, bool left_null, bool right_null) {
+		return NotDistinctFrom::template Operation<T>(left, right, left_null, right_null);
+	}
+};
+
 //===--------------------------------------------------------------------===//
 // Specialized Boolean Comparison Operators
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/common/row_operations/row_matcher.hpp

@@ -0,0 +1,63 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/row_operations/row_matcher.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/enums/expression_type.hpp"
+#include "duckdb/common/types.hpp"
+
+namespace duckdb {
+
+class Vector;
+class DataChunk;
+class TupleDataLayout;
+struct TupleDataVectorFormat;
+struct SelectionVector;
+struct MatchFunction;
+
+typedef idx_t (*match_function_t)(Vector &lhs_vector, const TupleDataVectorFormat &lhs_format, SelectionVector &sel,
+                                  const idx_t count, const TupleDataLayout &rhs_layout, Vector &rhs_row_locations,
+                                  const idx_t col_idx, const vector<MatchFunction> &child_functions,
+                                  SelectionVector *no_match_sel, idx_t &no_match_count);
+
+struct MatchFunction {
+	match_function_t function;
+	vector<MatchFunction> child_functions;
+};
+
+struct RowMatcher {
+public:
+	using Predicates = vector<ExpressionType>;
+
+	//! Initializes the RowMatcher, filling match_functions using layout and predicates
+	void Initialize(const bool no_match_sel, const TupleDataLayout &layout, const Predicates &predicates);
+	//! Given a DataChunk on the LHS, on which we've called TupleDataCollection::ToUnifiedFormat,
+	//! we match it with rows on the RHS, according to the given layout and locations.
+	//! Initially, 'sel' has 'count' entries which point to what needs to be compared.
+	//! After matching is done, this returns how many matching entries there are, which 'sel' is modified to point to
+	idx_t Match(DataChunk &lhs, const vector<TupleDataVectorFormat> &lhs_formats, SelectionVector &sel, idx_t count,
+	            const TupleDataLayout &rhs_layout, Vector &rhs_row_locations, SelectionVector *no_match_sel,
+	            idx_t &no_match_count);
+
+private:
+	//! Gets the templated match function for a given column
+	MatchFunction GetMatchFunction(const bool no_match_sel, const LogicalType &type, const ExpressionType predicate);
+	template <bool NO_MATCH_SEL>
+	MatchFunction GetMatchFunction(const LogicalType &type, const ExpressionType predicate);
+	template <bool NO_MATCH_SEL, class T>
+	MatchFunction GetMatchFunction(const ExpressionType predicate);
+	template <bool NO_MATCH_SEL>
+	MatchFunction GetStructMatchFunction(const LogicalType &type, const ExpressionType predicate);
+	template <bool NO_MATCH_SEL>
+	MatchFunction GetListMatchFunction(const ExpressionType predicate);
+
+private:
+	vector<MatchFunction> match_functions;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/row/tuple_data_collection.hpp

@@ -21,7 +21,7 @@ struct RowOperationsState;
 
 typedef void (*tuple_data_scatter_function_t)(const Vector &source, const TupleDataVectorFormat &source_format,
                                               const SelectionVector &append_sel, const idx_t append_count,
-                                              const TupleDataLayout &layout, Vector &row_locations,
+                                              const TupleDataLayout &layout, const Vector &row_locations,
                                               Vector &heap_locations, const idx_t col_idx,
                                               const UnifiedVectorFormat &list_format,
                                               const vector<TupleDataScatterFunction> &child_functions);
@@ -84,7 +84,11 @@ public:
 	                      TupleDataPinProperties = TupleDataPinProperties::UNPIN_AFTER_DONE);
 	//! Initializes the Chunk state of an Append state
 	//! - Useful for optimizing many appends made to the same tuple data collection
-	void InitializeAppend(TupleDataChunkState &chunk_state, vector<column_t> column_ids = {});
+	void InitializeChunkState(TupleDataChunkState &chunk_state, vector<column_t> column_ids = {});
+	//! Initializes the Chunk state of an Append state
+	//! - Useful for optimizing many appends made to the same tuple data collection
+	static void InitializeChunkState(TupleDataChunkState &chunk_state, const vector<LogicalType> &types,
+	                                 vector<column_t> column_ids = {});
 	//! Append a DataChunk directly to this TupleDataCollection - calls InitializeAppend and Append internally
 	void Append(DataChunk &new_chunk, const SelectionVector &append_sel = *FlatVector::IncrementalSelectionVector(),
 	            idx_t append_count = DConstants::INVALID_INDEX);

package/src/duckdb/src/include/duckdb/common/types/row/tuple_data_states.hpp

@@ -42,8 +42,8 @@ struct TupleDataVectorFormat {
 	const SelectionVector *original_sel;
 	SelectionVector original_owned_sel;
 
-	UnifiedVectorFormat data;
-	vector<TupleDataVectorFormat> child_formats;
+	UnifiedVectorFormat unified;
+	vector<TupleDataVectorFormat> children;
 	unique_ptr<CombinedListData> combined_list_data;
 };
 

package/src/duckdb/src/include/duckdb/common/types/validity_mask.hpp

@@ -148,6 +148,9 @@ public:
 		if (!validity_mask) {
 			return ValidityBuffer::MAX_ENTRY;
 		}
+		return GetValidityEntryUnsafe(entry_idx);
+	}
+	inline V &GetValidityEntryUnsafe(idx_t entry_idx) const {
 		return validity_mask[entry_idx];
 	}
 	static inline bool AllValid(V entry) {
@@ -156,7 +159,7 @@ public:
 	static inline bool NoneValid(V entry) {
 		return entry == 0;
 	}
-	static inline bool RowIsValid(V entry, idx_t idx_in_entry) {
+	static inline bool RowIsValid(const V &entry, const idx_t &idx_in_entry) {
 		return entry & (V(1) << V(idx_in_entry));
 	}
 	static inline void GetEntryIndex(idx_t row_idx, idx_t &entry_idx, idx_t &idx_in_entry) {

package/src/duckdb/src/include/duckdb/core_functions/scalar/bit_functions.hpp

@@ -18,7 +18,7 @@ namespace duckdb {
 struct GetBitFun {
 	static constexpr const char *Name = "get_bit";
 	static constexpr const char *Parameters = "bitstring,index";
-	static constexpr const char *Description = "Extracts the nth bit from bitstring; the first (leftmost) bit is indexed 0.";
+	static constexpr const char *Description = "Extracts the nth bit from bitstring; the first (leftmost) bit is indexed 0";
 	static constexpr const char *Example = "get_bit('0110010'::BIT, 2)";
 
 	static ScalarFunction GetFunction();
@@ -27,7 +27,7 @@ struct GetBitFun {
 struct SetBitFun {
 	static constexpr const char *Name = "set_bit";
 	static constexpr const char *Parameters = "bitstring,index,new_value";
-	static constexpr const char *Description = "Sets the nth bit in bitstring to newvalue; the first (leftmost) bit is indexed 0. Returns a new bitstring.";
+	static constexpr const char *Description = "Sets the nth bit in bitstring to newvalue; the first (leftmost) bit is indexed 0. Returns a new bitstring";
 	static constexpr const char *Example = "set_bit('0110010'::BIT, 2, 0)";
 
 	static ScalarFunction GetFunction();
@@ -36,7 +36,7 @@ struct SetBitFun {
 struct BitPositionFun {
 	static constexpr const char *Name = "bit_position";
 	static constexpr const char *Parameters = "substring,bitstring";
-	static constexpr const char *Description = "Returns first starting index of the specified substring within bits, or zero if it’s not present. The first (leftmost) bit is indexed 1";
+	static constexpr const char *Description = "Returns first starting index of the specified substring within bits, or zero if it is not present. The first (leftmost) bit is indexed 1";
 	static constexpr const char *Example = "bit_position('010'::BIT, '1110101'::BIT)";
 
 	static ScalarFunction GetFunction();
@@ -45,7 +45,7 @@ struct BitPositionFun {
 struct BitStringFun {
 	static constexpr const char *Name = "bitstring";
 	static constexpr const char *Parameters = "bitstring,length";
-	static constexpr const char *Description = "Pads the bitstring until the specified length.";
+	static constexpr const char *Description = "Pads the bitstring until the specified length";
 	static constexpr const char *Example = "bitstring('1010'::BIT, 7)";
 
 	static ScalarFunction GetFunction();

package/src/duckdb/src/include/duckdb/core_functions/scalar/blob_functions.hpp

@@ -18,7 +18,7 @@ namespace duckdb {
 struct DecodeFun {
 	static constexpr const char *Name = "decode";
 	static constexpr const char *Parameters = "blob";
-	static constexpr const char *Description = "Convert blob to varchar. Fails if blob is not valid utf-8.";
+	static constexpr const char *Description = "Convert blob to varchar. Fails if blob is not valid utf-8";
 	static constexpr const char *Example = "decode('\\xC3\\xBC'::BLOB)";
 
 	static ScalarFunction GetFunction();
@@ -27,7 +27,7 @@ struct DecodeFun {
 struct EncodeFun {
 	static constexpr const char *Name = "encode";
 	static constexpr const char *Parameters = "string";
-	static constexpr const char *Description = "Convert varchar to blob. Converts utf-8 characters into literal encoding.";
+	static constexpr const char *Description = "Convert varchar to blob. Converts utf-8 characters into literal encoding";
 	static constexpr const char *Example = "encode('my_string_with_ü')";
 
 	static ScalarFunction GetFunction();
@@ -36,7 +36,7 @@ struct EncodeFun {
 struct FromBase64Fun {
 	static constexpr const char *Name = "from_base64";
 	static constexpr const char *Parameters = "string";
-	static constexpr const char *Description = "Convert a base64 encoded string to a character string.";
+	static constexpr const char *Description = "Convert a base64 encoded string to a character string";
 	static constexpr const char *Example = "from_base64('QQ==')";
 
 	static ScalarFunction GetFunction();
@@ -45,7 +45,7 @@ struct FromBase64Fun {
 struct ToBase64Fun {
 	static constexpr const char *Name = "to_base64";
 	static constexpr const char *Parameters = "blob";
-	static constexpr const char *Description = "Convert a blob to a base64 encoded string.";
+	static constexpr const char *Description = "Convert a blob to a base64 encoded string";
 	static constexpr const char *Example = "base64('A'::blob)";
 
 	static ScalarFunction GetFunction();

package/src/duckdb/src/include/duckdb/core_functions/scalar/date_functions.hpp

@@ -120,7 +120,7 @@ struct DayFun {
 struct DayNameFun {
 	static constexpr const char *Name = "dayname";
 	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "The (English) name of the weekday.";
+	static constexpr const char *Description = "The (English) name of the weekday";
 	static constexpr const char *Example = "dayname(TIMESTAMP '1992-03-22')";
 
 	static ScalarFunctionSet GetFunctions();
@@ -357,7 +357,7 @@ struct MonthFun {
 struct MonthNameFun {
 	static constexpr const char *Name = "monthname";
 	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "The (English) name of the month.";
+	static constexpr const char *Description = "The (English) name of the month";
 	static constexpr const char *Example = "monthname(TIMESTAMP '1992-09-20')";
 
 	static ScalarFunctionSet GetFunctions();
@@ -393,7 +393,7 @@ struct StrfTimeFun {
 struct StrpTimeFun {
 	static constexpr const char *Name = "strptime";
 	static constexpr const char *Parameters = "text,format";
-	static constexpr const char *Description = "Converts string to timestamp with time zone according to the format string if %Z is specified.";
+	static constexpr const char *Description = "Converts string to timestamp with time zone according to the format string if %Z is specified";
 	static constexpr const char *Example = "strptime('Wed, 1 January 1992 - 08:38:40 PST', '%a, %-d %B %Y - %H:%M:%S %Z')";
 
 	static ScalarFunctionSet GetFunctions();
@@ -402,7 +402,7 @@ struct StrpTimeFun {
 struct TimeBucketFun {
 	static constexpr const char *Name = "time_bucket";
 	static constexpr const char *Parameters = "bucket_width,timestamp,origin";
-	static constexpr const char *Description = "Truncate timestamptz by the specified interval bucket_width. Buckets are aligned relative to origin timestamptz. origin defaults to 2000-01-03 00:00:00+00 for buckets that don’t include a month or year interval, and to 2000-01-01 00:00:00+00 for month and year buckets.";
+	static constexpr const char *Description = "Truncate TIMESTAMPTZ by the specified interval bucket_width. Buckets are aligned relative to origin TIMESTAMPTZ. The origin defaults to 2000-01-03 00:00:00+00 for buckets that do not include a month or year interval, and to 2000-01-01 00:00:00+00 for month and year buckets";
 	static constexpr const char *Example = "time_bucket(INTERVAL '2 weeks', TIMESTAMP '1992-04-20 15:26:00-07', TIMESTAMP '1992-04-01 00:00:00-07')";
 
 	static ScalarFunctionSet GetFunctions();
@@ -519,7 +519,7 @@ struct ToYearsFun {
 struct TryStrpTimeFun {
 	static constexpr const char *Name = "try_strptime";
 	static constexpr const char *Parameters = "text,format";
-	static constexpr const char *Description = "Converts string to timestamp using the format string (timestamp with time zone if %Z is specified). Returns NULL on failure.";
+	static constexpr const char *Description = "Converts string to timestamp using the format string (timestamp with time zone if %Z is specified). Returns NULL on failure";
 	static constexpr const char *Example = "try_strptime('Wed, 1 January 1992 - 08:38:40 PM', '%a, %-d %B %Y - %I:%M:%S %p')";
 
 	static ScalarFunctionSet GetFunctions();

package/src/duckdb/src/include/duckdb/core_functions/scalar/enum_functions.hpp

@@ -18,8 +18,8 @@ namespace duckdb {
 struct EnumFirstFun {
 	static constexpr const char *Name = "enum_first";
 	static constexpr const char *Parameters = "enum";
-	static constexpr const char *Description = "Returns the first value of the input enum type.";
-	static constexpr const char *Example = "enum_first(null::mood)";
+	static constexpr const char *Description = "Returns the first value of the input enum type";
+	static constexpr const char *Example = "enum_first(NULL::mood)";
 
 	static ScalarFunction GetFunction();
 };
@@ -27,8 +27,8 @@ struct EnumFirstFun {
 struct EnumLastFun {
 	static constexpr const char *Name = "enum_last";
 	static constexpr const char *Parameters = "enum";
-	static constexpr const char *Description = "Returns the last value of the input enum type.";
-	static constexpr const char *Example = "enum_last(null::mood)";
+	static constexpr const char *Description = "Returns the last value of the input enum type";
+	static constexpr const char *Example = "enum_last(NULL::mood)";
 
 	static ScalarFunction GetFunction();
 };
@@ -45,8 +45,8 @@ struct EnumCodeFun {
 struct EnumRangeFun {
 	static constexpr const char *Name = "enum_range";
 	static constexpr const char *Parameters = "enum";
-	static constexpr const char *Description = "Returns all values of the input enum type as an array.";
-	static constexpr const char *Example = "enum_range(null::mood)";
+	static constexpr const char *Description = "Returns all values of the input enum type as an array";
+	static constexpr const char *Example = "enum_range(NULL::mood)";
 
 	static ScalarFunction GetFunction();
 };
@@ -54,7 +54,7 @@ struct EnumRangeFun {
 struct EnumRangeBoundaryFun {
 	static constexpr const char *Name = "enum_range_boundary";
 	static constexpr const char *Parameters = "start,end";
-	static constexpr const char *Description = "Returns the range between the two given enum values as an array. The values must be of the same enum type. When the first parameter is NULL, the result starts with the first value of the enum type. When the second parameter is NULL, the result ends with the last value of the enum type.";
+	static constexpr const char *Description = "Returns the range between the two given enum values as an array. The values must be of the same enum type. When the first parameter is NULL, the result starts with the first value of the enum type. When the second parameter is NULL, the result ends with the last value of the enum type";
 	static constexpr const char *Example = "enum_range_boundary(NULL, 'happy'::mood)";
 
 	static ScalarFunction GetFunction();