duckdb 0.10.3-dev3.0 → 0.10.3-dev8.0

package/src/duckdb/third_party/mbedtls/library/constant_time.cpp

@@ -61,7 +61,7 @@ int mbedtls_ct_memcmp( const void *a,
          * This avoids IAR compiler warning:
          * 'the order of volatile accesses is undefined ..' */
         unsigned char x = A[i], y = B[i];
-        diff |= x ^ y;
+        diff = (diff | (x ^ y));
     }
 
     return( (int)diff );

package/src/duckdb/third_party/parquet/parquet_types.cpp

@@ -113,6 +113,9 @@ std::ostream &operator<<(std::ostream &out, const ConvertedType::type &val) {
 	case ConvertedType::INTERVAL:
 		out << "INTERVAL";
 		return out;
+	case ConvertedType::NULL_TYPE:
+		out << "NULL";
+		return out;
 		//  no default for compiler error on missing enum
 	}
 	out << static_cast<int>(val);

package/src/duckdb/third_party/parquet/parquet_types.h

@@ -61,7 +61,8 @@ struct ConvertedType {
     INT_64 = 18,
     JSON = 19,
     BSON = 20,
-    INTERVAL = 21
+    INTERVAL = 21,
+    NULL_TYPE = 24
   };
 };
 

package/src/duckdb/third_party/re2/re2/compile.cc

@@ -487,8 +487,8 @@ int Compiler::CachedRuneByteSuffix(uint8_t lo, uint8_t hi, bool foldcase,
 }
 
 bool Compiler::IsCachedRuneByteSuffix(int id) {
-  uint8_t lo = inst_[id].lo_;
-  uint8_t hi = inst_[id].hi_;
+  uint8_t lo = inst_[id].byte_range.lo_;
+  uint8_t hi = inst_[id].byte_range.hi_;
   bool foldcase = inst_[id].foldcase() != 0;
   int next = inst_[id].out();
 

package/src/duckdb/third_party/re2/re2/dfa.cc

@@ -116,13 +116,8 @@ class DFA {
                         // into this state, along with kFlagMatch if this
                         // is a matching state.
 
-// Work around the bug affecting flexible array members in GCC 6.x (for x >= 1).
-// (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=70932)
-#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ == 6 && __GNUC_MINOR__ >= 1
-    std::atomic<State*> next_[0];   // Outgoing arrows from State,
-#else
-    std::atomic<State*> next_[];    // Outgoing arrows from State,
-#endif
+	// fixes from https://github.com/girishji/re2/commit/80b212f289c4ef75408b1510b9fc85e6cb9a447c
+    std::atomic<State*> *next_;    // Outgoing arrows from State,
 
                         // one per input byte class
   };
@@ -751,7 +746,7 @@ DFA::State* DFA::CachedState(int* inst, int ninst, uint32_t flag) {
   // Allocate new state along with room for next_ and inst_.
   char* space = std::allocator<char>().allocate(mem);
   State* s = new (space) State;
-  (void) new (s->next_) std::atomic<State*>[nnext];
+  s->next_ =  new (space + sizeof(State)) std::atomic<State*>[nnext];
   // Work around a unfortunate bug in older versions of libstdc++.
   // (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64658)
   for (int i = 0; i < nnext; i++)

package/src/duckdb/third_party/re2/re2/onepass.cc

@@ -143,7 +143,7 @@ namespace duckdb_re2 {
 // the memory footprint.)
 struct OneState {
   uint32_t matchcond;   // conditions to match right now.
-  uint32_t action[];
+  uint32_t action[256];
 };
 
 // The uint32_t conditions in the action are a combination of
@@ -243,7 +243,8 @@ bool Prog::SearchOnePass(const StringPiece& text,
     kind = kFullMatch;
 
   uint8_t* nodes = onepass_nodes_.data();
-  int statesize = sizeof(OneState) + bytemap_range()*sizeof(uint32_t);
+  int statesize = sizeof(uint32_t) + bytemap_range()*sizeof(uint32_t);
+
   // start() is always mapped to the zeroth OneState.
   OneState* state = IndexToNode(nodes, statesize, 0);
   uint8_t* bytemap = bytemap_;
@@ -392,7 +393,7 @@ bool Prog::IsOnePass() {
   // Limit max node count to 65000 as a conservative estimate to
   // avoid overflowing 16-bit node index in encoding.
   int maxnodes = 2 + inst_count(kInstByteRange);
-  int statesize = sizeof(OneState) + bytemap_range()*sizeof(uint32_t);
+  int statesize = sizeof(uint32_t) + bytemap_range()*sizeof(uint32_t);
   if (maxnodes >= 65000 || dfa_mem_ / 4 / statesize < maxnodes)
     return false;
 

package/src/duckdb/third_party/re2/re2/prog.cc

@@ -38,9 +38,9 @@ void Prog::Inst::InitAlt(uint32_t out, uint32_t out1) {
 void Prog::Inst::InitByteRange(int lo, int hi, int foldcase, uint32_t out) {
   DCHECK_EQ(out_opcode_, 0);
   set_out_opcode(out, kInstByteRange);
-  lo_ = lo & 0xFF;
-  hi_ = hi & 0xFF;
-  hint_foldcase_ = foldcase&1;
+  byte_range.lo_ = lo & 0xFF;
+  byte_range.hi_ = hi & 0xFF;
+  byte_range.hint_foldcase_ = foldcase&1;
 }
 
 void Prog::Inst::InitCapture(int cap, uint32_t out) {
@@ -85,7 +85,7 @@ std::string Prog::Inst::Dump() {
     case kInstByteRange:
       return StringPrintf("byte%s [%02x-%02x] %d -> %d",
                           foldcase() ? "/i" : "",
-                          lo_, hi_, hint(), out());
+		                    byte_range.lo_, byte_range.hi_, hint(), out());
 
     case kInstCapture:
       return StringPrintf("capture %d -> %d", cap_, out());
@@ -921,7 +921,7 @@ void Prog::ComputeHints(std::vector<Inst>* flat, int begin, int end) {
 
     if (first != end) {
       uint16_t hint = static_cast<uint16_t>(std::min(first - id, 32767));
-      ip->hint_foldcase_ |= hint<<1;
+      ip->byte_range.hint_foldcase_ |= hint<<1;
     }
   }
 }
@@ -1022,11 +1022,11 @@ void Prog::ConfigurePrefixAccel(const std::string& prefix,
     prefix_dfa_ = BuildShiftDFA(prefix.substr(0, prefix_size_));
   } else if (prefix_size_ != 1) {
     // Use PrefixAccel_FrontAndBack().
-    prefix_front_ = prefix.front();
-    prefix_back_ = prefix.back();
+    prefix_front_back.prefix_front_ = prefix.front();
+	prefix_front_back.prefix_back_ = prefix.back();
   } else {
     // Use memchr(3).
-    prefix_front_ = prefix.front();
+	prefix_front_back.prefix_front_ = prefix.front();
   }
 }
 
@@ -1166,8 +1166,8 @@ const void* Prog::PrefixAccel_FrontAndBack(const void* data, size_t size) {
   const char* p0 = reinterpret_cast<const char*>(data);
   for (const char* p = p0;; p++) {
     DCHECK_GE(size, static_cast<size_t>(p-p0));
-    p = reinterpret_cast<const char*>(memchr(p, prefix_front_, size - (p-p0)));
-    if (p == NULL || p[prefix_size_-1] == prefix_back_)
+    p = reinterpret_cast<const char*>(memchr(p, prefix_front_back.prefix_front_, size - (p-p0)));
+    if (p == NULL || p[prefix_size_-1] == prefix_front_back.prefix_back_)
       return p;
   }
 }

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

@@ -84,10 +84,10 @@ class Prog {
     int out()       { return out_opcode_>>4; }
     int out1()      { DCHECK(opcode() == kInstAlt || opcode() == kInstAltMatch); return out1_; }
     int cap()       { DCHECK_EQ(opcode(), kInstCapture); return cap_; }
-    int lo()        { DCHECK_EQ(opcode(), kInstByteRange); return lo_; }
-    int hi()        { DCHECK_EQ(opcode(), kInstByteRange); return hi_; }
-    int foldcase()  { DCHECK_EQ(opcode(), kInstByteRange); return hint_foldcase_&1; }
-    int hint()      { DCHECK_EQ(opcode(), kInstByteRange); return hint_foldcase_>>1; }
+    int lo()        { DCHECK_EQ(opcode(), kInstByteRange); return byte_range.lo_; }
+    int hi()        { DCHECK_EQ(opcode(), kInstByteRange); return byte_range.hi_; }
+    int foldcase()  { DCHECK_EQ(opcode(), kInstByteRange); return byte_range.hint_foldcase_&1; }
+    int hint()      { DCHECK_EQ(opcode(), kInstByteRange); return byte_range.hint_foldcase_>>1; }
     int match_id()  { DCHECK_EQ(opcode(), kInstMatch); return match_id_; }
     EmptyOp empty() { DCHECK_EQ(opcode(), kInstEmptyWidth); return empty_; }
 
@@ -103,7 +103,7 @@ class Prog {
       DCHECK_EQ(opcode(), kInstByteRange);
       if (foldcase() && 'A' <= c && c <= 'Z')
         c += 'a' - 'A';
-      return lo_ <= c && c <= hi_;
+      return byte_range.lo_ <= c && c <= byte_range.hi_;
     }
 
     // Returns string representation for debugging.
@@ -155,7 +155,7 @@ class Prog {
                            //   means there are no remaining possibilities,
                            //   which is most likely for character classes.
                            //   foldcase: A-Z -> a-z before checking range.
-      };
+      } byte_range;
 
       EmptyOp empty_;       // opcode == kInstEmptyWidth
                             //   empty_ is bitwise OR of kEmpty* flags above.
@@ -227,7 +227,7 @@ class Prog {
     } else if (prefix_size_ != 1) {
       return PrefixAccel_FrontAndBack(data, size);
     } else {
-      return memchr(data, prefix_front_, size);
+      return memchr(data, prefix_front_back.prefix_front_, size);
     }
   }
 
@@ -426,7 +426,7 @@ class Prog {
     struct {
       int prefix_front_;    // first byte of prefix
       int prefix_back_;     // last byte of prefix
-    };
+    } prefix_front_back;
   };
 
   int list_count_;                  // count of lists (see above)

package/src/duckdb/third_party/tdigest/t_digest.hpp

@@ -219,7 +219,7 @@ public:
 				pq.push((*iter));
 			}
 			std::vector<const TDigest *> batch;
-			batch.reserve(size);
+			batch.reserve(size_t(size));
 
 			size_t totalSize = 0;
 			while (!pq.empty()) {
@@ -324,7 +324,7 @@ public:
 			CentroidComparator cc;
 			auto iter = std::upper_bound(processed_.cbegin(), processed_.cend(), Centroid(x, 0), cc);
 
-			auto i = std::distance(processed_.cbegin(), iter);
+			auto i = size_t(std::distance(processed_.cbegin(), iter));
 			auto z1 = x - (iter - 1)->mean();
 			auto z2 = (iter)->mean() - x;
 			return weightedAverage(cumulative_[i - 1], z2, cumulative_[i], z1) / processedWeight_;
@@ -369,7 +369,7 @@ public:
 		auto iter = std::lower_bound(cumulative_.cbegin(), cumulative_.cend(), index);
 
 		if (iter + 1 != cumulative_.cend()) {
-			auto i = std::distance(cumulative_.cbegin(), iter);
+			auto i = size_t(std::distance(cumulative_.cbegin(), iter));
 			auto z1 = index - *(iter - 1);
 			auto z2 = *(iter)-index;
 			// LOG(INFO) << "z2 " << z2 << " index " << index << " z1 " << z1;
@@ -406,9 +406,9 @@ public:
 
 	inline void add(std::vector<Centroid>::const_iterator iter, std::vector<Centroid>::const_iterator end) {
 		while (iter != end) {
-			const size_t diff = std::distance(iter, end);
+			const size_t diff = size_t(std::distance(iter, end));
 			const size_t room = maxUnprocessed_ - unprocessed_.size();
-			auto mid = iter + std::min(diff, room);
+			auto mid = iter + int64_t(std::min(diff, room));
 			while (iter != mid) {
 				unprocessed_.push_back(*(iter++));
 			}
@@ -538,7 +538,7 @@ private:
 		std::sort(unprocessed_.begin(), unprocessed_.end(), cc);
 		auto count = unprocessed_.size();
 		unprocessed_.insert(unprocessed_.end(), processed_.cbegin(), processed_.cend());
-		std::inplace_merge(unprocessed_.begin(), unprocessed_.begin() + count, unprocessed_.end(), cc);
+		std::inplace_merge(unprocessed_.begin(), unprocessed_.begin() + int64_t(count), unprocessed_.end(), cc);
 
 		processedWeight_ += unprocessedWeight_;
 		unprocessedWeight_ = 0;

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

@@ -637,7 +637,7 @@ void utf8proc_grapheme_callback(const char *s, size_t len, T &&fun) {
 	size_t start = 0;
 	size_t cpos = 0;
 	while(true) {
-		cpos += sz;
+		cpos += static_cast<size_t>(sz);
 		if (cpos >= len) {
 			fun(start, cpos);
 			return;