duckdb 0.8.2-dev2399.0 → 0.8.2-dev2669.0

package/binding.gyp

@@ -87,6 +87,7 @@
                 "src/duckdb/ub_src_function_scalar_string_regexp.cpp", 
                 "src/duckdb/ub_src_function_scalar_struct.cpp", 
                 "src/duckdb/ub_src_function_scalar_system.cpp", 
+                "src/duckdb/ub_src_function_table_arrow.cpp", 
                 "src/duckdb/ub_src_function_table.cpp", 
                 "src/duckdb/ub_src_function_table_system.cpp", 
                 "src/duckdb/ub_src_function_table_version.cpp", 

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.8.2-dev2399.0",
+  "version": "0.8.2-dev2669.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/icu/icu-datepart.cpp

@@ -54,13 +54,13 @@ struct ICUDatePart : public ICUDateFunc {
 	}
 
 	static int64_t ExtractDayOfWeek(icu::Calendar *calendar, const uint64_t micros) {
-		calendar->setFirstDayOfWeek(UCAL_SUNDAY);
+		// [Sun(0), Sat(6)]
 		return ExtractField(calendar, UCAL_DAY_OF_WEEK) - UCAL_SUNDAY;
 	}
 
 	static int64_t ExtractISODayOfWeek(icu::Calendar *calendar, const uint64_t micros) {
-		calendar->setFirstDayOfWeek(UCAL_MONDAY);
-		return ExtractField(calendar, UCAL_DAY_OF_WEEK);
+		// [Mon(1), Sun(7)]
+		return 1 + (ExtractField(calendar, UCAL_DAY_OF_WEEK) + 7 - UCAL_MONDAY) % 7;
 	}
 
 	static int64_t ExtractWeek(icu::Calendar *calendar, const uint64_t micros) {

package/src/duckdb/src/catalog/catalog_entry/duck_table_entry.cpp

@@ -43,7 +43,7 @@ void AddDataTableIndex(DataTable &storage, const ColumnList &columns, const vect
 	// create an adaptive radix tree around the expressions
 	if (index_block) {
 		art = make_uniq<ART>(column_ids, TableIOManager::Get(storage), std::move(unbound_expressions), constraint_type,
-		                     storage.db, index_block->block_id, index_block->offset);
+		                     storage.db, nullptr, index_block->block_id, index_block->offset);
 	} else {
 		art = make_uniq<ART>(column_ids, TableIOManager::Get(storage), std::move(unbound_expressions), constraint_type,
 		                     storage.db);

package/src/duckdb/src/catalog/default/default_functions.cpp

@@ -98,6 +98,11 @@ static DefaultMacro internal_macros[] = {
 	{DEFAULT_SCHEMA, "fmod", {"x", "y", nullptr}, "(x-y*floor(x/y))"},
 	{DEFAULT_SCHEMA, "count_if", {"l", nullptr}, "sum(if(l, 1, 0))"},
 	{DEFAULT_SCHEMA, "split_part", {"string", "delimiter", "position", nullptr}, "coalesce(string_split(string, delimiter)[position],'')"},
+	{DEFAULT_SCHEMA, "geomean", {"x", nullptr}, "exp(avg(ln(x)))"},
+	{DEFAULT_SCHEMA, "geometric_mean", {"x", nullptr}, "geomean(x)"},
+
+    {DEFAULT_SCHEMA, "list_reverse", {"l", nullptr}, "l[:-:-1]"},
+    {DEFAULT_SCHEMA, "array_reverse", {"l", nullptr}, "list_reverse(l)"},
 
     // FIXME implement as actual function if we encounter a lot of performance issues. Complexity now: n * m, with hashing possibly n + m
     {DEFAULT_SCHEMA, "list_intersect", {"l1", "l2", nullptr}, "list_filter(l1, (x) -> list_contains(l2, x))"},

package/src/duckdb/src/common/enum_util.cpp

@@ -71,7 +71,7 @@
 #include "duckdb/function/macro_function.hpp"
 #include "duckdb/function/scalar/compressed_materialization_functions.hpp"
 #include "duckdb/function/scalar/strftime_format.hpp"
-#include "duckdb/function/table/arrow.hpp"
+#include "duckdb/function/table/arrow/arrow_duck_schema.hpp"
 #include "duckdb/main/appender.hpp"
 #include "duckdb/main/capi/capi_internal.hpp"
 #include "duckdb/main/config.hpp"
@@ -81,6 +81,7 @@
 #include "duckdb/parallel/interrupt.hpp"
 #include "duckdb/parallel/task.hpp"
 #include "duckdb/parser/constraint.hpp"
+#include "duckdb/parser/expression/parameter_expression.hpp"
 #include "duckdb/parser/expression/window_expression.hpp"
 #include "duckdb/parser/parsed_data/alter_info.hpp"
 #include "duckdb/parser/parsed_data/alter_scalar_function_info.hpp"
@@ -4404,6 +4405,39 @@ PragmaType EnumUtil::FromString<PragmaType>(const char *value) {
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 
+template<>
+const char* EnumUtil::ToChars<PreparedParamType>(PreparedParamType value) {
+	switch(value) {
+	case PreparedParamType::AUTO_INCREMENT:
+		return "AUTO_INCREMENT";
+	case PreparedParamType::POSITIONAL:
+		return "POSITIONAL";
+	case PreparedParamType::NAMED:
+		return "NAMED";
+	case PreparedParamType::INVALID:
+		return "INVALID";
+	default:
+		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
+	}
+}
+
+template<>
+PreparedParamType EnumUtil::FromString<PreparedParamType>(const char *value) {
+	if (StringUtil::Equals(value, "AUTO_INCREMENT")) {
+		return PreparedParamType::AUTO_INCREMENT;
+	}
+	if (StringUtil::Equals(value, "POSITIONAL")) {
+		return PreparedParamType::POSITIONAL;
+	}
+	if (StringUtil::Equals(value, "NAMED")) {
+		return PreparedParamType::NAMED;
+	}
+	if (StringUtil::Equals(value, "INVALID")) {
+		return PreparedParamType::INVALID;
+	}
+	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
+}
+
 template<>
 const char* EnumUtil::ToChars<ProfilerPrintFormat>(ProfilerPrintFormat value) {
 	switch(value) {

package/src/duckdb/src/common/http_state.cpp

@@ -0,0 +1,78 @@
+#include "duckdb/common/http_state.hpp"
+
+namespace duckdb {
+
+CachedFileHandle::CachedFileHandle(shared_ptr<CachedFile> &file_p) {
+	// If the file was not yet initialized, we need to grab a lock.
+	if (!file_p->initialized) {
+		lock = make_uniq<lock_guard<mutex>>(file_p->lock);
+	}
+	file = file_p;
+}
+
+void CachedFileHandle::SetInitialized() {
+	if (file->initialized) {
+		throw InternalException("Cannot set initialized on cached file that was already initialized");
+	}
+	if (!lock) {
+		throw InternalException("Cannot set initialized on cached file without lock");
+	}
+	file->initialized = true;
+	lock = nullptr;
+}
+
+void CachedFileHandle::AllocateBuffer(idx_t size) {
+	if (file->initialized) {
+		throw InternalException("Cannot allocate a buffer for a cached file that was already initialized");
+	}
+	file->data = std::shared_ptr<char>(new char[size], std::default_delete<char[]>());
+	file->capacity = size;
+}
+
+void CachedFileHandle::GrowBuffer(idx_t new_capacity, idx_t bytes_to_copy) {
+	// copy shared ptr to old data
+	auto old_data = file->data;
+	// allocate new buffer that can hold the new capacity
+	AllocateBuffer(new_capacity);
+	// copy the old data
+	Write(old_data.get(), bytes_to_copy);
+}
+
+void CachedFileHandle::Write(const char *buffer, idx_t length, idx_t offset) {
+	//! Only write to non-initialized files with a lock;
+	D_ASSERT(!file->initialized && lock);
+	memcpy(file->data.get() + offset, buffer, length);
+}
+
+void HTTPState::Reset() {
+	// Reset Counters
+	head_count = 0;
+	get_count = 0;
+	put_count = 0;
+	post_count = 0;
+	total_bytes_received = 0;
+	total_bytes_sent = 0;
+
+	// Reset cached files
+	cached_files.clear();
+}
+
+shared_ptr<HTTPState> HTTPState::TryGetState(FileOpener *opener) {
+	auto client_context = FileOpener::TryGetClientContext(opener);
+	if (client_context) {
+		return client_context->client_data->http_state;
+	}
+	return nullptr;
+}
+
+//! Get cache entry, create if not exists
+shared_ptr<CachedFile> &HTTPState::GetCachedFile(const string &path) {
+	lock_guard<mutex> lock(cached_files_mutex);
+	auto &cache_entry_ref = cached_files[path];
+	if (!cache_entry_ref) {
+		cache_entry_ref = make_shared<CachedFile>();
+	}
+	return cache_entry_ref;
+}
+
+} // namespace duckdb

package/src/duckdb/src/core_functions/function_list.cpp

@@ -73,7 +73,7 @@ static StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayDistinctFun),
 	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayFilterFun),
 	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ArrayReverseSortFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(ArraySliceFun),
+	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ArraySliceFun),
 	DUCKDB_SCALAR_FUNCTION_SET_ALIAS(ArraySortFun),
 	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayTransformFun),
 	DUCKDB_SCALAR_FUNCTION_ALIAS(ArrayUniqueFun),
@@ -200,7 +200,7 @@ static StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_SCALAR_FUNCTION(ListFilterFun),
 	DUCKDB_SCALAR_FUNCTION_ALIAS(ListPackFun),
 	DUCKDB_SCALAR_FUNCTION_SET(ListReverseSortFun),
-	DUCKDB_SCALAR_FUNCTION(ListSliceFun),
+	DUCKDB_SCALAR_FUNCTION_SET(ListSliceFun),
 	DUCKDB_SCALAR_FUNCTION_SET(ListSortFun),
 	DUCKDB_SCALAR_FUNCTION(ListTransformFun),
 	DUCKDB_SCALAR_FUNCTION(ListUniqueFun),