duckdb 0.7.2-dev1901.0 → 0.7.2-dev2144.0

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

@@ -20,6 +20,11 @@ static inline int MemcmpFixed(const void *str1, const void *str2) {
 	return memcmp(str1, str2, SIZE);
 }
 
+template <size_t SIZE>
+static inline void MemsetFixed(void *ptr, int value) {
+	memset(ptr, value, SIZE);
+}
+
 namespace duckdb {
 
 //! This templated memcpy is significantly faster than std::memcpy,
@@ -690,4 +695,527 @@ static inline int FastMemcmp(const void *str1, const void *str2, const size_t si
 	// LCOV_EXCL_STOP
 }
 
+static inline void FastMemset(void *ptr, int value, size_t size) {
+	// LCOV_EXCL_START
+	switch (size) {
+	case 0:
+		return;
+	case 1:
+		return MemsetFixed<1>(ptr, value);
+	case 2:
+		return MemsetFixed<2>(ptr, value);
+	case 3:
+		return MemsetFixed<3>(ptr, value);
+	case 4:
+		return MemsetFixed<4>(ptr, value);
+	case 5:
+		return MemsetFixed<5>(ptr, value);
+	case 6:
+		return MemsetFixed<6>(ptr, value);
+	case 7:
+		return MemsetFixed<7>(ptr, value);
+	case 8:
+		return MemsetFixed<8>(ptr, value);
+	case 9:
+		return MemsetFixed<9>(ptr, value);
+	case 10:
+		return MemsetFixed<10>(ptr, value);
+	case 11:
+		return MemsetFixed<11>(ptr, value);
+	case 12:
+		return MemsetFixed<12>(ptr, value);
+	case 13:
+		return MemsetFixed<13>(ptr, value);
+	case 14:
+		return MemsetFixed<14>(ptr, value);
+	case 15:
+		return MemsetFixed<15>(ptr, value);
+	case 16:
+		return MemsetFixed<16>(ptr, value);
+	case 17:
+		return MemsetFixed<17>(ptr, value);
+	case 18:
+		return MemsetFixed<18>(ptr, value);
+	case 19:
+		return MemsetFixed<19>(ptr, value);
+	case 20:
+		return MemsetFixed<20>(ptr, value);
+	case 21:
+		return MemsetFixed<21>(ptr, value);
+	case 22:
+		return MemsetFixed<22>(ptr, value);
+	case 23:
+		return MemsetFixed<23>(ptr, value);
+	case 24:
+		return MemsetFixed<24>(ptr, value);
+	case 25:
+		return MemsetFixed<25>(ptr, value);
+	case 26:
+		return MemsetFixed<26>(ptr, value);
+	case 27:
+		return MemsetFixed<27>(ptr, value);
+	case 28:
+		return MemsetFixed<28>(ptr, value);
+	case 29:
+		return MemsetFixed<29>(ptr, value);
+	case 30:
+		return MemsetFixed<30>(ptr, value);
+	case 31:
+		return MemsetFixed<31>(ptr, value);
+	case 32:
+		return MemsetFixed<32>(ptr, value);
+	case 33:
+		return MemsetFixed<33>(ptr, value);
+	case 34:
+		return MemsetFixed<34>(ptr, value);
+	case 35:
+		return MemsetFixed<35>(ptr, value);
+	case 36:
+		return MemsetFixed<36>(ptr, value);
+	case 37:
+		return MemsetFixed<37>(ptr, value);
+	case 38:
+		return MemsetFixed<38>(ptr, value);
+	case 39:
+		return MemsetFixed<39>(ptr, value);
+	case 40:
+		return MemsetFixed<40>(ptr, value);
+	case 41:
+		return MemsetFixed<41>(ptr, value);
+	case 42:
+		return MemsetFixed<42>(ptr, value);
+	case 43:
+		return MemsetFixed<43>(ptr, value);
+	case 44:
+		return MemsetFixed<44>(ptr, value);
+	case 45:
+		return MemsetFixed<45>(ptr, value);
+	case 46:
+		return MemsetFixed<46>(ptr, value);
+	case 47:
+		return MemsetFixed<47>(ptr, value);
+	case 48:
+		return MemsetFixed<48>(ptr, value);
+	case 49:
+		return MemsetFixed<49>(ptr, value);
+	case 50:
+		return MemsetFixed<50>(ptr, value);
+	case 51:
+		return MemsetFixed<51>(ptr, value);
+	case 52:
+		return MemsetFixed<52>(ptr, value);
+	case 53:
+		return MemsetFixed<53>(ptr, value);
+	case 54:
+		return MemsetFixed<54>(ptr, value);
+	case 55:
+		return MemsetFixed<55>(ptr, value);
+	case 56:
+		return MemsetFixed<56>(ptr, value);
+	case 57:
+		return MemsetFixed<57>(ptr, value);
+	case 58:
+		return MemsetFixed<58>(ptr, value);
+	case 59:
+		return MemsetFixed<59>(ptr, value);
+	case 60:
+		return MemsetFixed<60>(ptr, value);
+	case 61:
+		return MemsetFixed<61>(ptr, value);
+	case 62:
+		return MemsetFixed<62>(ptr, value);
+	case 63:
+		return MemsetFixed<63>(ptr, value);
+	case 64:
+		return MemsetFixed<64>(ptr, value);
+	case 65:
+		return MemsetFixed<65>(ptr, value);
+	case 66:
+		return MemsetFixed<66>(ptr, value);
+	case 67:
+		return MemsetFixed<67>(ptr, value);
+	case 68:
+		return MemsetFixed<68>(ptr, value);
+	case 69:
+		return MemsetFixed<69>(ptr, value);
+	case 70:
+		return MemsetFixed<70>(ptr, value);
+	case 71:
+		return MemsetFixed<71>(ptr, value);
+	case 72:
+		return MemsetFixed<72>(ptr, value);
+	case 73:
+		return MemsetFixed<73>(ptr, value);
+	case 74:
+		return MemsetFixed<74>(ptr, value);
+	case 75:
+		return MemsetFixed<75>(ptr, value);
+	case 76:
+		return MemsetFixed<76>(ptr, value);
+	case 77:
+		return MemsetFixed<77>(ptr, value);
+	case 78:
+		return MemsetFixed<78>(ptr, value);
+	case 79:
+		return MemsetFixed<79>(ptr, value);
+	case 80:
+		return MemsetFixed<80>(ptr, value);
+	case 81:
+		return MemsetFixed<81>(ptr, value);
+	case 82:
+		return MemsetFixed<82>(ptr, value);
+	case 83:
+		return MemsetFixed<83>(ptr, value);
+	case 84:
+		return MemsetFixed<84>(ptr, value);
+	case 85:
+		return MemsetFixed<85>(ptr, value);
+	case 86:
+		return MemsetFixed<86>(ptr, value);
+	case 87:
+		return MemsetFixed<87>(ptr, value);
+	case 88:
+		return MemsetFixed<88>(ptr, value);
+	case 89:
+		return MemsetFixed<89>(ptr, value);
+	case 90:
+		return MemsetFixed<90>(ptr, value);
+	case 91:
+		return MemsetFixed<91>(ptr, value);
+	case 92:
+		return MemsetFixed<92>(ptr, value);
+	case 93:
+		return MemsetFixed<93>(ptr, value);
+	case 94:
+		return MemsetFixed<94>(ptr, value);
+	case 95:
+		return MemsetFixed<95>(ptr, value);
+	case 96:
+		return MemsetFixed<96>(ptr, value);
+	case 97:
+		return MemsetFixed<97>(ptr, value);
+	case 98:
+		return MemsetFixed<98>(ptr, value);
+	case 99:
+		return MemsetFixed<99>(ptr, value);
+	case 100:
+		return MemsetFixed<100>(ptr, value);
+	case 101:
+		return MemsetFixed<101>(ptr, value);
+	case 102:
+		return MemsetFixed<102>(ptr, value);
+	case 103:
+		return MemsetFixed<103>(ptr, value);
+	case 104:
+		return MemsetFixed<104>(ptr, value);
+	case 105:
+		return MemsetFixed<105>(ptr, value);
+	case 106:
+		return MemsetFixed<106>(ptr, value);
+	case 107:
+		return MemsetFixed<107>(ptr, value);
+	case 108:
+		return MemsetFixed<108>(ptr, value);
+	case 109:
+		return MemsetFixed<109>(ptr, value);
+	case 110:
+		return MemsetFixed<110>(ptr, value);
+	case 111:
+		return MemsetFixed<111>(ptr, value);
+	case 112:
+		return MemsetFixed<112>(ptr, value);
+	case 113:
+		return MemsetFixed<113>(ptr, value);
+	case 114:
+		return MemsetFixed<114>(ptr, value);
+	case 115:
+		return MemsetFixed<115>(ptr, value);
+	case 116:
+		return MemsetFixed<116>(ptr, value);
+	case 117:
+		return MemsetFixed<117>(ptr, value);
+	case 118:
+		return MemsetFixed<118>(ptr, value);
+	case 119:
+		return MemsetFixed<119>(ptr, value);
+	case 120:
+		return MemsetFixed<120>(ptr, value);
+	case 121:
+		return MemsetFixed<121>(ptr, value);
+	case 122:
+		return MemsetFixed<122>(ptr, value);
+	case 123:
+		return MemsetFixed<123>(ptr, value);
+	case 124:
+		return MemsetFixed<124>(ptr, value);
+	case 125:
+		return MemsetFixed<125>(ptr, value);
+	case 126:
+		return MemsetFixed<126>(ptr, value);
+	case 127:
+		return MemsetFixed<127>(ptr, value);
+	case 128:
+		return MemsetFixed<128>(ptr, value);
+	case 129:
+		return MemsetFixed<129>(ptr, value);
+	case 130:
+		return MemsetFixed<130>(ptr, value);
+	case 131:
+		return MemsetFixed<131>(ptr, value);
+	case 132:
+		return MemsetFixed<132>(ptr, value);
+	case 133:
+		return MemsetFixed<133>(ptr, value);
+	case 134:
+		return MemsetFixed<134>(ptr, value);
+	case 135:
+		return MemsetFixed<135>(ptr, value);
+	case 136:
+		return MemsetFixed<136>(ptr, value);
+	case 137:
+		return MemsetFixed<137>(ptr, value);
+	case 138:
+		return MemsetFixed<138>(ptr, value);
+	case 139:
+		return MemsetFixed<139>(ptr, value);
+	case 140:
+		return MemsetFixed<140>(ptr, value);
+	case 141:
+		return MemsetFixed<141>(ptr, value);
+	case 142:
+		return MemsetFixed<142>(ptr, value);
+	case 143:
+		return MemsetFixed<143>(ptr, value);
+	case 144:
+		return MemsetFixed<144>(ptr, value);
+	case 145:
+		return MemsetFixed<145>(ptr, value);
+	case 146:
+		return MemsetFixed<146>(ptr, value);
+	case 147:
+		return MemsetFixed<147>(ptr, value);
+	case 148:
+		return MemsetFixed<148>(ptr, value);
+	case 149:
+		return MemsetFixed<149>(ptr, value);
+	case 150:
+		return MemsetFixed<150>(ptr, value);
+	case 151:
+		return MemsetFixed<151>(ptr, value);
+	case 152:
+		return MemsetFixed<152>(ptr, value);
+	case 153:
+		return MemsetFixed<153>(ptr, value);
+	case 154:
+		return MemsetFixed<154>(ptr, value);
+	case 155:
+		return MemsetFixed<155>(ptr, value);
+	case 156:
+		return MemsetFixed<156>(ptr, value);
+	case 157:
+		return MemsetFixed<157>(ptr, value);
+	case 158:
+		return MemsetFixed<158>(ptr, value);
+	case 159:
+		return MemsetFixed<159>(ptr, value);
+	case 160:
+		return MemsetFixed<160>(ptr, value);
+	case 161:
+		return MemsetFixed<161>(ptr, value);
+	case 162:
+		return MemsetFixed<162>(ptr, value);
+	case 163:
+		return MemsetFixed<163>(ptr, value);
+	case 164:
+		return MemsetFixed<164>(ptr, value);
+	case 165:
+		return MemsetFixed<165>(ptr, value);
+	case 166:
+		return MemsetFixed<166>(ptr, value);
+	case 167:
+		return MemsetFixed<167>(ptr, value);
+	case 168:
+		return MemsetFixed<168>(ptr, value);
+	case 169:
+		return MemsetFixed<169>(ptr, value);
+	case 170:
+		return MemsetFixed<170>(ptr, value);
+	case 171:
+		return MemsetFixed<171>(ptr, value);
+	case 172:
+		return MemsetFixed<172>(ptr, value);
+	case 173:
+		return MemsetFixed<173>(ptr, value);
+	case 174:
+		return MemsetFixed<174>(ptr, value);
+	case 175:
+		return MemsetFixed<175>(ptr, value);
+	case 176:
+		return MemsetFixed<176>(ptr, value);
+	case 177:
+		return MemsetFixed<177>(ptr, value);
+	case 178:
+		return MemsetFixed<178>(ptr, value);
+	case 179:
+		return MemsetFixed<179>(ptr, value);
+	case 180:
+		return MemsetFixed<180>(ptr, value);
+	case 181:
+		return MemsetFixed<181>(ptr, value);
+	case 182:
+		return MemsetFixed<182>(ptr, value);
+	case 183:
+		return MemsetFixed<183>(ptr, value);
+	case 184:
+		return MemsetFixed<184>(ptr, value);
+	case 185:
+		return MemsetFixed<185>(ptr, value);
+	case 186:
+		return MemsetFixed<186>(ptr, value);
+	case 187:
+		return MemsetFixed<187>(ptr, value);
+	case 188:
+		return MemsetFixed<188>(ptr, value);
+	case 189:
+		return MemsetFixed<189>(ptr, value);
+	case 190:
+		return MemsetFixed<190>(ptr, value);
+	case 191:
+		return MemsetFixed<191>(ptr, value);
+	case 192:
+		return MemsetFixed<192>(ptr, value);
+	case 193:
+		return MemsetFixed<193>(ptr, value);
+	case 194:
+		return MemsetFixed<194>(ptr, value);
+	case 195:
+		return MemsetFixed<195>(ptr, value);
+	case 196:
+		return MemsetFixed<196>(ptr, value);
+	case 197:
+		return MemsetFixed<197>(ptr, value);
+	case 198:
+		return MemsetFixed<198>(ptr, value);
+	case 199:
+		return MemsetFixed<199>(ptr, value);
+	case 200:
+		return MemsetFixed<200>(ptr, value);
+	case 201:
+		return MemsetFixed<201>(ptr, value);
+	case 202:
+		return MemsetFixed<202>(ptr, value);
+	case 203:
+		return MemsetFixed<203>(ptr, value);
+	case 204:
+		return MemsetFixed<204>(ptr, value);
+	case 205:
+		return MemsetFixed<205>(ptr, value);
+	case 206:
+		return MemsetFixed<206>(ptr, value);
+	case 207:
+		return MemsetFixed<207>(ptr, value);
+	case 208:
+		return MemsetFixed<208>(ptr, value);
+	case 209:
+		return MemsetFixed<209>(ptr, value);
+	case 210:
+		return MemsetFixed<210>(ptr, value);
+	case 211:
+		return MemsetFixed<211>(ptr, value);
+	case 212:
+		return MemsetFixed<212>(ptr, value);
+	case 213:
+		return MemsetFixed<213>(ptr, value);
+	case 214:
+		return MemsetFixed<214>(ptr, value);
+	case 215:
+		return MemsetFixed<215>(ptr, value);
+	case 216:
+		return MemsetFixed<216>(ptr, value);
+	case 217:
+		return MemsetFixed<217>(ptr, value);
+	case 218:
+		return MemsetFixed<218>(ptr, value);
+	case 219:
+		return MemsetFixed<219>(ptr, value);
+	case 220:
+		return MemsetFixed<220>(ptr, value);
+	case 221:
+		return MemsetFixed<221>(ptr, value);
+	case 222:
+		return MemsetFixed<222>(ptr, value);
+	case 223:
+		return MemsetFixed<223>(ptr, value);
+	case 224:
+		return MemsetFixed<224>(ptr, value);
+	case 225:
+		return MemsetFixed<225>(ptr, value);
+	case 226:
+		return MemsetFixed<226>(ptr, value);
+	case 227:
+		return MemsetFixed<227>(ptr, value);
+	case 228:
+		return MemsetFixed<228>(ptr, value);
+	case 229:
+		return MemsetFixed<229>(ptr, value);
+	case 230:
+		return MemsetFixed<230>(ptr, value);
+	case 231:
+		return MemsetFixed<231>(ptr, value);
+	case 232:
+		return MemsetFixed<232>(ptr, value);
+	case 233:
+		return MemsetFixed<233>(ptr, value);
+	case 234:
+		return MemsetFixed<234>(ptr, value);
+	case 235:
+		return MemsetFixed<235>(ptr, value);
+	case 236:
+		return MemsetFixed<236>(ptr, value);
+	case 237:
+		return MemsetFixed<237>(ptr, value);
+	case 238:
+		return MemsetFixed<238>(ptr, value);
+	case 239:
+		return MemsetFixed<239>(ptr, value);
+	case 240:
+		return MemsetFixed<240>(ptr, value);
+	case 241:
+		return MemsetFixed<241>(ptr, value);
+	case 242:
+		return MemsetFixed<242>(ptr, value);
+	case 243:
+		return MemsetFixed<243>(ptr, value);
+	case 244:
+		return MemsetFixed<244>(ptr, value);
+	case 245:
+		return MemsetFixed<245>(ptr, value);
+	case 246:
+		return MemsetFixed<246>(ptr, value);
+	case 247:
+		return MemsetFixed<247>(ptr, value);
+	case 248:
+		return MemsetFixed<248>(ptr, value);
+	case 249:
+		return MemsetFixed<249>(ptr, value);
+	case 250:
+		return MemsetFixed<250>(ptr, value);
+	case 251:
+		return MemsetFixed<251>(ptr, value);
+	case 252:
+		return MemsetFixed<252>(ptr, value);
+	case 253:
+		return MemsetFixed<253>(ptr, value);
+	case 254:
+		return MemsetFixed<254>(ptr, value);
+	case 255:
+		return MemsetFixed<255>(ptr, value);
+	case 256:
+		return MemsetFixed<256>(ptr, value);
+	default:
+		memset(ptr, value, size);
+	}
+	// LCOV_EXCL_STOP
+}
+
 } // namespace duckdb

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

@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/filename_pattern.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/file_system.hpp"
+#include "duckdb/common/types/uuid.hpp"
+
+namespace duckdb {
+
+class FilenamePattern {
+
+public:
+	FilenamePattern() : _base("data_"), _pos(_base.length()), _uuid(false) {
+	}
+	~FilenamePattern() {
+	}
+
+public:
+	void SetFilenamePattern(const string &pattern);
+	string CreateFilename(const FileSystem &fs, const string &path, const string &extension, idx_t offset) const;
+
+private:
+	string _base;
+	idx_t _pos;
+	bool _uuid;
+};
+
+} // namespace duckdb

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

@@ -82,6 +82,13 @@ unique_ptr<S> make_uniq_base(Args &&... args) {
 	return unique_ptr<S>(new T(std::forward<Args>(args)...));
 }
 
+#ifdef DUCKDB_ENABLE_DEPRECATED_API
+template <typename S, typename T, typename... Args>
+unique_ptr<S> make_unique_base(Args &&... args) {
+	return unique_ptr<S>(new T(std::forward<Args>(args)...));
+}
+#endif // DUCKDB_ENABLE_DEPRECATED_API
+
 template <typename T, typename S>
 unique_ptr<S> unique_ptr_cast(unique_ptr<T> src) {
 	return unique_ptr<S>(static_cast<S *>(src.release()));
@@ -111,7 +118,10 @@ typename std::remove_reference<T>::type&& move(T&& t) noexcept {
 
 template <class T, class... _Args>
 static duckdb::unique_ptr<T> make_unique(_Args&&... __args) {
+#ifndef DUCKDB_ENABLE_DEPRECATED_API
 	static_assert(sizeof(T) == 0, "Use make_uniq instead of make_unique!");
+#endif // DUCKDB_ENABLE_DEPRECATED_API
+	return unique_ptr<T>(new T(std::forward<_Args>(__args)...));
 }
 
 template <typename T>

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

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "duckdb/common/types/partitioned_column_data.hpp"
+#include "duckdb/common/types/column/partitioned_column_data.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/optimizer/filter_combiner.hpp"
 #include "duckdb/optimizer/statistics_propagator.hpp"
@@ -16,8 +16,8 @@
 #include "duckdb/planner/table_filter.hpp"
 #include "re2/re2.h"
 
-#include <sstream>
 #include <iostream>
+#include <sstream>
 
 namespace duckdb {
 
@@ -83,7 +83,9 @@ public:
 	HivePartitionedColumnData(ClientContext &context, vector<LogicalType> types, vector<idx_t> partition_by_cols,
 	                          shared_ptr<GlobalHivePartitionState> global_state = nullptr)
 	    : PartitionedColumnData(PartitionedColumnDataType::HIVE, context, std::move(types)),
-	      global_state(std::move(global_state)), group_by_columns(partition_by_cols) {
+	      global_state(std::move(global_state)), group_by_columns(std::move(partition_by_cols)),
+	      hashes_v(LogicalType::HASH) {
+		InitializeKeys();
 	}
 	HivePartitionedColumnData(const HivePartitionedColumnData &other);
 	void ComputePartitionIndices(PartitionedColumnDataAppendState &state, DataChunk &input) override;
@@ -103,12 +105,20 @@ protected:
 	//! Copy the newly added entries in the global_state.map to the local_partition_map (requires lock!)
 	void SynchronizeLocalMap();
 
+private:
+	void InitializeKeys();
+
+protected:
 	//! Shared HivePartitionedColumnData should always have a global state to allow parallel key discovery
 	shared_ptr<GlobalHivePartitionState> global_state;
 	//! Thread-local copy of the partition map
 	hive_partition_map_t local_partition_map;
 	//! The columns that make up the key
 	vector<idx_t> group_by_columns;
+	//! Thread-local pre-allocated vector for hashes
+	Vector hashes_v;
+	//! Thread-local pre-allocated HivePartitionKeys
+	vector<HivePartitionKey> keys;
 };
 
 } // namespace duckdb

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

@@ -61,6 +61,14 @@ public:
 		return ptr;
 	}
 
+	bool operator==(const optional_ptr<T> &rhs) const {
+		return ptr == rhs.ptr;
+	}
+
+	bool operator!=(const optional_ptr<T> &rhs) const {
+		return ptr != rhs.ptr;
+	}
+
 private:
 	T *ptr;
 };

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

@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/string_map_set.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/types.hpp"
+#include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/unordered_set.hpp"
+
+namespace duckdb {
+
+struct PerfectHash {
+	inline std::size_t operator()(const idx_t &h) const {
+		return h;
+	}
+};
+
+struct PerfectEquality {
+	inline bool operator()(const idx_t &a, const idx_t &b) const {
+		return a == b;
+	}
+};
+
+template <typename T>
+using perfect_map_t = unordered_map<idx_t, T, PerfectHash, PerfectEquality>;
+
+using perfect_set_t = unordered_set<idx_t, PerfectHash, PerfectEquality>;
+
+} // namespace duckdb