duckdb 0.10.1 → 0.10.2-dev3.0

package/src/duckdb/third_party/re2/re2/unicode_groups.h

@@ -62,6 +62,6 @@ extern const int num_posix_groups;
 extern const UGroup perl_groups[];
 extern const int num_perl_groups;
 
-}  // namespace duckdb_re2
+}  // namespace re2
 
 #endif  // RE2_UNICODE_GROUPS_H_

package/src/duckdb/third_party/re2/re2/walker-inl.h

@@ -25,10 +25,7 @@ template<typename T> struct WalkState;
 template<typename T> class Regexp::Walker {
  public:
   Walker();
-  virtual ~Walker() {
-    Reset();
-	delete stack_;
-  }
+  virtual ~Walker();
 
   // Virtual method called before visiting re's children.
   // PreVisit passes ownership of its return value to its caller.
@@ -92,7 +89,7 @@ template<typename T> class Regexp::Walker {
 
  private:
   // Walk state for the entire traversal.
-  std::stack<WalkState<T> >* stack_;
+  std::stack<WalkState<T>> stack_;
   bool stopped_early_;
   int max_visits_;
 
@@ -122,7 +119,7 @@ template<typename T> T Regexp::Walker<T>::Copy(T arg) {
 
 // State about a single level in the traversal.
 template<typename T> struct WalkState {
-  WalkState<T>(Regexp* re, T parent)
+  WalkState(Regexp* re, T parent)
     : re(re),
       n(-1),
       parent_arg(parent),
@@ -137,19 +134,23 @@ template<typename T> struct WalkState {
 };
 
 template<typename T> Regexp::Walker<T>::Walker() {
-  stack_ = new std::stack<WalkState<T> >;
   stopped_early_ = false;
 }
 
+template<typename T> Regexp::Walker<T>::~Walker() {
+  Reset();
+}
+
 // Clears the stack.  Should never be necessary, since
 // Walk always enters and exits with an empty stack.
 // Logs DFATAL if stack is not already clear.
 template<typename T> void Regexp::Walker<T>::Reset() {
-  if (stack_ && stack_->size() > 0) {
+  if (!stack_.empty()) {
     LOG(DFATAL) << "Stack not empty.";
-    while (stack_->size() > 0) {
-      delete stack_->top().child_args;
-      stack_->pop();
+    while (!stack_.empty()) {
+      if (stack_.top().re->nsub_ > 1)
+        delete[] stack_.top().child_args;
+      stack_.pop();
     }
   }
 }
@@ -163,13 +164,13 @@ template<typename T> T Regexp::Walker<T>::WalkInternal(Regexp* re, T top_arg,
     return top_arg;
   }
 
-  stack_->push(WalkState<T>(re, top_arg));
+  stack_.push(WalkState<T>(re, top_arg));
 
   WalkState<T>* s;
   for (;;) {
     T t;
-    s = &stack_->top();
-    Regexp* re = s->re;
+    s = &stack_.top();
+    re = s->re;
     switch (s->n) {
       case -1: {
         if (--max_visits_ < 0) {
@@ -199,7 +200,7 @@ template<typename T> T Regexp::Walker<T>::WalkInternal(Regexp* re, T top_arg,
               s->child_args[s->n] = Copy(s->child_args[s->n - 1]);
               s->n++;
             } else {
-              stack_->push(WalkState<T>(sub[s->n], s->pre_arg));
+              stack_.push(WalkState<T>(sub[s->n], s->pre_arg));
             }
             continue;
           }
@@ -212,12 +213,12 @@ template<typename T> T Regexp::Walker<T>::WalkInternal(Regexp* re, T top_arg,
       }
     }
 
-    // We've finished stack_->top().
+    // We've finished stack_.top().
     // Update next guy down.
-    stack_->pop();
-    if (stack_->size() == 0)
+    stack_.pop();
+    if (stack_.empty())
       return t;
-    s = &stack_->top();
+    s = &stack_.top();
     if (s->child_args != NULL)
       s->child_args[s->n] = t;
     else
@@ -241,6 +242,6 @@ template<typename T> T Regexp::Walker<T>::WalkExponential(Regexp* re, T top_arg,
   return WalkInternal(re, top_arg, false);
 }
 
-}  // namespace duckdb_re2
+}  // namespace re2
 
 #endif  // RE2_WALKER_INL_H_

package/src/duckdb/third_party/re2/util/logging.h

@@ -12,6 +12,7 @@
 #include <stdlib.h>
 #include <ostream>
 #include <sstream>
+#include <stdexcept>
 
 #include "util/util.h"
 
@@ -54,23 +55,18 @@
 
 #define VLOG(x) if((x)>0){}else LOG_INFO.stream()
 
-namespace duckdb_re2 {
-
-
 class LogMessage {
  public:
   LogMessage(const char* file, int line)
       : flushed_(false) {
-    stream() << file << ":" << line << ": ";
+//    stream() << file << ":" << line << ": ";
   }
   void Flush() {
-    stream() << "\n";
-	/*// R does not allow us to have a reference to stderr even if we are not using it
-    std::string s = str_.str();
-    size_t n = s.size();
-    if (fwrite(s.data(), 1, n, stderr) < n) {}  // shut up gcc
-    */
-    flushed_ = true;
+//    stream() << "\n";
+//    std::string s = str_.str();
+//    size_t n = s.size();
+//    if (fwrite(s.data(), 1, n, stderr) < n) {}  // shut up gcc
+//    flushed_ = true;
   }
   ~LogMessage() {
     if (!flushed_) {
@@ -90,26 +86,26 @@ class LogMessage {
 // Silence "destructor never returns" warning for ~LogMessageFatal().
 // Since this is a header file, push and then pop to limit the scope.
 #ifdef _MSC_VER
-//#pragma warning(push)
-//#pragma warning(disable: 4722)
+#pragma warning(push)
+#pragma warning(disable: 4722)
 #endif
 
 class LogMessageFatal : public LogMessage {
  public:
   LogMessageFatal(const char* file, int line)
-      : LogMessage(file, line) {}
-  ATTRIBUTE_NORETURN ~LogMessageFatal() {
+      : LogMessage(file, line) {
+	  throw std::runtime_error("RE2 Fatal Error");
+  }
+  ~LogMessageFatal() {
     Flush();
-    abort();
   }
  private:
   LogMessageFatal(const LogMessageFatal&) = delete;
   LogMessageFatal& operator=(const LogMessageFatal&) = delete;
 };
-} // namespace
 
 #ifdef _MSC_VER
-//#pragma warning(pop)
+#pragma warning(pop)
 #endif
 
 #endif  // UTIL_LOGGING_H_

package/src/duckdb/third_party/re2/util/mix.h

@@ -13,8 +13,8 @@ namespace duckdb_re2 {
 // Silence "truncation of constant value" warning for kMul in 32-bit mode.
 // Since this is a header file, push and then pop to limit the scope.
 #ifdef _MSC_VER
-//#pragma warning(push)
-//#pragma warning(disable: 4309)
+#pragma warning(push)
+#pragma warning(disable: 4309)
 #endif
 
 class HashMix {
@@ -33,9 +33,9 @@ class HashMix {
 };
 
 #ifdef _MSC_VER
-//#pragma warning(pop)
+#pragma warning(pop)
 #endif
 
-}  // namespace duckdb_re2
+}  // namespace re2
 
 #endif  // UTIL_MIX_H_

package/src/duckdb/third_party/re2/util/mutex.h

@@ -10,24 +10,39 @@
  * You should assume the locks are *not* re-entrant.
  */
 
-#if !defined(_WIN32)
+#ifdef RE2_NO_THREADS
+#include <assert.h>
+#define MUTEX_IS_LOCK_COUNTER
+#else
+#ifdef _WIN32
+// Requires Windows Vista or Windows Server 2008 at minimum.
+#include <windows.h>
+#if defined(WINVER) && WINVER >= 0x0600
+#define MUTEX_IS_WIN32_SRWLOCK
+#endif
+#else
 #ifndef _POSIX_C_SOURCE
 #define _POSIX_C_SOURCE 200809L
 #endif
 #include <unistd.h>
-//#if defined(_POSIX_READER_WRITER_LOCKS) && _POSIX_READER_WRITER_LOCKS > 0
-//#define MUTEX_IS_PTHREAD_RWLOCK
-//#endif
+#if defined(_POSIX_READER_WRITER_LOCKS) && _POSIX_READER_WRITER_LOCKS > 0
+#define MUTEX_IS_PTHREAD_RWLOCK
+#endif
+#endif
 #endif
 
-#if defined(MUTEX_IS_PTHREAD_RWLOCK)
-#error We really dont want to include pthread
+#if defined(MUTEX_IS_LOCK_COUNTER)
+typedef int MutexType;
+#elif defined(MUTEX_IS_WIN32_SRWLOCK)
+typedef SRWLOCK MutexType;
+#elif defined(MUTEX_IS_PTHREAD_RWLOCK)
+#include <stdexcept>
 #include <pthread.h>
 #include <stdlib.h>
 typedef pthread_rwlock_t MutexType;
 #else
-#include <mutex>
-typedef std::mutex MutexType;
+#include <shared_mutex>
+typedef std::shared_mutex MutexType;
 #endif
 
 namespace duckdb_re2 {
@@ -57,15 +72,33 @@ class Mutex {
   Mutex& operator=(const Mutex&) = delete;
 };
 
-#if defined(MUTEX_IS_PTHREAD_RWLOCK)
+#if defined(MUTEX_IS_LOCK_COUNTER)
+
+Mutex::Mutex()             : mutex_(0) { }
+Mutex::~Mutex()            { assert(mutex_ == 0); }
+void Mutex::Lock()         { assert(--mutex_ == -1); }
+void Mutex::Unlock()       { assert(mutex_++ == -1); }
+void Mutex::ReaderLock()   { assert(++mutex_ > 0); }
+void Mutex::ReaderUnlock() { assert(mutex_-- > 0); }
+
+#elif defined(MUTEX_IS_WIN32_SRWLOCK)
+
+Mutex::Mutex()             : mutex_(SRWLOCK_INIT) { }
+Mutex::~Mutex()            { }
+void Mutex::Lock()         { AcquireSRWLockExclusive(&mutex_); }
+void Mutex::Unlock()       { ReleaseSRWLockExclusive(&mutex_); }
+void Mutex::ReaderLock()   { AcquireSRWLockShared(&mutex_); }
+void Mutex::ReaderUnlock() { ReleaseSRWLockShared(&mutex_); }
+
+#elif defined(MUTEX_IS_PTHREAD_RWLOCK)
 
 #define SAFE_PTHREAD(fncall)    \
   do {                          \
-    if ((fncall) != 0) abort(); \
-  } while (0)
+    if ((fncall) != 0) throw std::runtime_error("RE2 pthread failure"); \
+  } while (0);
 
 Mutex::Mutex()             { SAFE_PTHREAD(pthread_rwlock_init(&mutex_, NULL)); }
-Mutex::~Mutex()            { SAFE_PTHREAD(pthread_rwlock_destroy(&mutex_)); }
+Mutex::~Mutex()            { pthread_rwlock_destroy(&mutex_); }
 void Mutex::Lock()         { SAFE_PTHREAD(pthread_rwlock_wrlock(&mutex_)); }
 void Mutex::Unlock()       { SAFE_PTHREAD(pthread_rwlock_unlock(&mutex_)); }
 void Mutex::ReaderLock()   { SAFE_PTHREAD(pthread_rwlock_rdlock(&mutex_)); }
@@ -79,8 +112,8 @@ Mutex::Mutex()             { }
 Mutex::~Mutex()            { }
 void Mutex::Lock()         { mutex_.lock(); }
 void Mutex::Unlock()       { mutex_.unlock(); }
-void Mutex::ReaderLock()   { Lock(); }  // C++11 doesn't have std::shared_mutex.
-void Mutex::ReaderUnlock() { Unlock(); }
+void Mutex::ReaderLock()   { mutex_.lock_shared(); }
+void Mutex::ReaderUnlock() { mutex_.unlock_shared(); }
 
 #endif
 
@@ -127,6 +160,6 @@ class WriterMutexLock {
 #define ReaderMutexLock(x) static_assert(false, "ReaderMutexLock declaration missing variable name")
 #define WriterMutexLock(x) static_assert(false, "WriterMutexLock declaration missing variable name")
 
-}  // namespace duckdb_re2
+}  // namespace re2
 
 #endif  // UTIL_MUTEX_H_

package/src/duckdb/third_party/re2/util/rune.cc

@@ -51,7 +51,7 @@ int
 chartorune(Rune *rune, const char *str)
 {
 	int c, c1, c2, c3;
-	long l;
+	Rune l;
 
 	/*
 	 * one character sequence
@@ -127,7 +127,7 @@ int
 runetochar(char *str, const Rune *rune)
 {
 	/* Runes are signed, so convert to unsigned for range check. */
-	unsigned long c;
+	unsigned int c;
 
 	/*
 	 * one character sequence
@@ -212,7 +212,7 @@ int
 utflen(const char *s)
 {
 	int c;
-	long n;
+	int n;
 	Rune rune;
 
 	n = 0;
@@ -232,7 +232,7 @@ utflen(const char *s)
 char*
 utfrune(const char *s, Rune c)
 {
-	long c1;
+	int c1;
 	Rune r;
 	int n;
 
@@ -257,4 +257,4 @@ utfrune(const char *s, Rune c)
 	return 0;
 }
 
-}  // namespace duckdb_re2
+}  // namespace re2

package/src/duckdb/third_party/re2/util/strutil.cc

@@ -146,19 +146,4 @@ std::string StringPrintf(const char* format, ...) {
   return result;
 }
 
-void SStringPrintf(std::string* dst, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  dst->clear();
-  StringAppendV(dst, format, ap);
-  va_end(ap);
-}
-
-void StringAppendF(std::string* dst, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  StringAppendV(dst, format, ap);
-  va_end(ap);
-}
-
-}  // namespace duckdb_re2
+}  // namespace re2

package/src/duckdb/third_party/re2/util/strutil.h

@@ -15,9 +15,7 @@ namespace duckdb_re2 {
 std::string CEscape(const StringPiece& src);
 void PrefixSuccessor(std::string* prefix);
 std::string StringPrintf(const char* format, ...);
-void SStringPrintf(std::string* dst, const char* format, ...);
-void StringAppendF(std::string* dst, const char* format, ...);
 
-}  // namespace duckdb_re2
+}  // namespace re2
 
 #endif  // UTIL_STRUTIL_H_

package/src/duckdb/third_party/re2/util/utf.h

@@ -39,6 +39,6 @@ int fullrune(const char* s, int n);
 int utflen(const char* s);
 char* utfrune(const char*, Rune);
 
-}  // namespace duckdb_re2
+}  // namespace re2
 
 #endif  // UTIL_UTF_H_

package/src/duckdb/third_party/re2/util/util.h

@@ -5,7 +5,7 @@
 #ifndef UTIL_UTIL_H_
 #define UTIL_UTIL_H_
 
-#define arraysize(array) (int)(sizeof(array)/sizeof((array)[0]))
+#define arraysize(array) (sizeof(array)/sizeof((array)[0]))
 
 #ifndef ATTRIBUTE_NORETURN
 #if defined(__GNUC__)
@@ -17,6 +17,14 @@
 #endif
 #endif
 
+#ifndef ATTRIBUTE_UNUSED
+#if defined(__GNUC__)
+#define ATTRIBUTE_UNUSED __attribute__((unused))
+#else
+#define ATTRIBUTE_UNUSED
+#endif
+#endif
+
 #ifndef FALLTHROUGH_INTENDED
 #if defined(__clang__)
 #define FALLTHROUGH_INTENDED [[clang::fallthrough]]

package/src/duckdb/third_party/utf8proc/include/utf8proc_wrapper.hpp

@@ -26,6 +26,8 @@ public:
 	static char* Normalize(const char* s, size_t len);
 	//! Returns whether or not the UTF8 string is valid
 	static bool IsValid(const char *s, size_t len);
+	//! Makes Invalid Unicode valid by replacing invalid parts with a given character
+	static void MakeValid(char *s, size_t len, char special_flag = '?');
 	//! Returns the position (in bytes) of the next grapheme cluster
 	static size_t NextGraphemeCluster(const char *s, size_t len, size_t pos);
 	//! Returns the position (in bytes) of the previous grapheme cluster

package/src/duckdb/third_party/utf8proc/utf8proc_wrapper.cpp

@@ -1,6 +1,6 @@
 #include "utf8proc_wrapper.hpp"
 #include "utf8proc.hpp"
-
+#include "duckdb/common/assert.hpp"
 using namespace std;
 
 namespace duckdb {
@@ -102,6 +102,41 @@ UnicodeType Utf8Proc::Analyze(const char *s, size_t len, UnicodeInvalidReason *i
 	return type;
 }
 
+void Utf8Proc::MakeValid(char *s, size_t len, char special_flag){
+	D_ASSERT(special_flag <=127);
+	UnicodeType type = UnicodeType::ASCII;
+	for (size_t i = 0; i < len; i++) {
+		int c = (int) s[i];
+		if ((c & 0x80) == 0) {
+			continue;
+		}
+		int first_pos_seq = i;
+		if ((c & 0xE0) == 0xC0) {
+			/* 2 byte sequence */
+			int utf8char = c & 0x1F;
+			type = UTF8ExtraByteLoop<1, 0x000780>(first_pos_seq, utf8char, i, s, len, nullptr, nullptr);
+		} else if ((c & 0xF0) == 0xE0) {
+			/* 3 byte sequence */
+			int utf8char = c & 0x0F;
+			type = UTF8ExtraByteLoop<2, 0x00F800>(first_pos_seq, utf8char, i, s, len, nullptr, nullptr);
+		} else if ((c & 0xF8) == 0xF0) {
+			/* 4 byte sequence */
+			int utf8char = c & 0x07;
+			type = UTF8ExtraByteLoop<3, 0x1F0000>(first_pos_seq, utf8char, i, s, len, nullptr, nullptr);
+		} else {
+			/* invalid UTF-8 start byte */
+			s[i] = special_flag; // Rewrite invalid byte
+		}
+		if (type == UnicodeType::INVALID) {
+			for (size_t j = first_pos_seq; j <= i; j++) {
+                s[j] = special_flag; // Rewrite each byte of the invalid sequence
+            }
+			type = UnicodeType::ASCII;
+		}
+	}
+	D_ASSERT(Utf8Proc::IsValid(s,len));
+}
+
 char* Utf8Proc::Normalize(const char *s, size_t len) {
 	assert(s);
 	assert(Utf8Proc::Analyze(s, len) != UnicodeType::INVALID);

package/src/duckdb/ub_src_common.cpp

@@ -12,8 +12,6 @@
 
 #include "src/common/checksum.cpp"
 
-#include "src/common/cycle_counter.cpp"
-
 #include "src/common/exception.cpp"
 
 #include "src/common/exception_format_value.cpp"

package/src/duckdb/ub_src_execution_physical_plan.cpp

@@ -76,6 +76,8 @@
 
 #include "src/execution/physical_plan/plan_window.cpp"
 
+#include "src/execution/physical_plan/plan_vacuum.cpp"
+
 #include "src/execution/physical_plan/plan_unnest.cpp"
 
 #include "src/execution/physical_plan/plan_expression_get.cpp"

package/src/duckdb/ub_src_planner_expression.cpp

@@ -16,6 +16,8 @@
 
 #include "src/planner/expression/bound_constant_expression.cpp"
 
+#include "src/planner/expression/bound_expanded_expression.cpp"
+
 #include "src/planner/expression/bound_function_expression.cpp"
 
 #include "src/planner/expression/bound_lambda_expression.cpp"

package/src/duckdb/ub_src_planner_expression_binder.cpp

@@ -30,6 +30,8 @@
 
 #include "src/planner/expression_binder/select_binder.cpp"
 
+#include "src/planner/expression_binder/select_bind_state.cpp"
+
 #include "src/planner/expression_binder/table_function_binder.cpp"
 
 #include "src/planner/expression_binder/update_binder.cpp"

package/src/duckdb/ub_src_planner_operator.cpp

@@ -80,5 +80,7 @@
 
 #include "src/planner/operator/logical_update.cpp"
 
+#include "src/planner/operator/logical_vacuum.cpp"
+
 #include "src/planner/operator/logical_window.cpp"