duckdb 0.3.2-dev145.0 → 0.3.2-dev173.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.2-dev145.0",
+  "version": "0.3.2-dev173.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -29764,6 +29764,700 @@ void Comparators::SwizzleSingleValue(data_ptr_t data_ptr, const data_ptr_t &heap
 }
 
 } // namespace duckdb
+//                         DuckDB
+//
+// duckdb/common/fast_mem.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+template <size_t SIZE>
+static inline void MemcpyFixed(void *dest, const void *src) {
+	memcpy(dest, src, SIZE);
+}
+
+template <size_t SIZE>
+static inline int MemcmpFixed(const void *str1, const void *str2) {
+	return memcmp(str1, str2, SIZE);
+}
+
+namespace duckdb {
+
+//! This templated memcpy is significantly faster than std::memcpy,
+//! but only when you are calling memcpy with a const size in a loop.
+//! For instance `while (<cond>) { memcpy(<dest>, <src>, const_size); ... }`
+static inline void FastMemcpy(void *dest, const void *src, const size_t size) {
+	// LCOV_EXCL_START
+	switch (size) {
+	case 0:
+		return;
+	case 1:
+		return MemcpyFixed<1>(dest, src);
+	case 2:
+		return MemcpyFixed<2>(dest, src);
+	case 3:
+		return MemcpyFixed<3>(dest, src);
+	case 4:
+		return MemcpyFixed<4>(dest, src);
+	case 5:
+		return MemcpyFixed<5>(dest, src);
+	case 6:
+		return MemcpyFixed<6>(dest, src);
+	case 7:
+		return MemcpyFixed<7>(dest, src);
+	case 8:
+		return MemcpyFixed<8>(dest, src);
+	case 9:
+		return MemcpyFixed<9>(dest, src);
+	case 10:
+		return MemcpyFixed<10>(dest, src);
+	case 11:
+		return MemcpyFixed<11>(dest, src);
+	case 12:
+		return MemcpyFixed<12>(dest, src);
+	case 13:
+		return MemcpyFixed<13>(dest, src);
+	case 14:
+		return MemcpyFixed<14>(dest, src);
+	case 15:
+		return MemcpyFixed<15>(dest, src);
+	case 16:
+		return MemcpyFixed<16>(dest, src);
+	case 17:
+		return MemcpyFixed<17>(dest, src);
+	case 18:
+		return MemcpyFixed<18>(dest, src);
+	case 19:
+		return MemcpyFixed<19>(dest, src);
+	case 20:
+		return MemcpyFixed<20>(dest, src);
+	case 21:
+		return MemcpyFixed<21>(dest, src);
+	case 22:
+		return MemcpyFixed<22>(dest, src);
+	case 23:
+		return MemcpyFixed<23>(dest, src);
+	case 24:
+		return MemcpyFixed<24>(dest, src);
+	case 25:
+		return MemcpyFixed<25>(dest, src);
+	case 26:
+		return MemcpyFixed<26>(dest, src);
+	case 27:
+		return MemcpyFixed<27>(dest, src);
+	case 28:
+		return MemcpyFixed<28>(dest, src);
+	case 29:
+		return MemcpyFixed<29>(dest, src);
+	case 30:
+		return MemcpyFixed<30>(dest, src);
+	case 31:
+		return MemcpyFixed<31>(dest, src);
+	case 32:
+		return MemcpyFixed<32>(dest, src);
+	case 33:
+		return MemcpyFixed<33>(dest, src);
+	case 34:
+		return MemcpyFixed<34>(dest, src);
+	case 35:
+		return MemcpyFixed<35>(dest, src);
+	case 36:
+		return MemcpyFixed<36>(dest, src);
+	case 37:
+		return MemcpyFixed<37>(dest, src);
+	case 38:
+		return MemcpyFixed<38>(dest, src);
+	case 39:
+		return MemcpyFixed<39>(dest, src);
+	case 40:
+		return MemcpyFixed<40>(dest, src);
+	case 41:
+		return MemcpyFixed<41>(dest, src);
+	case 42:
+		return MemcpyFixed<42>(dest, src);
+	case 43:
+		return MemcpyFixed<43>(dest, src);
+	case 44:
+		return MemcpyFixed<44>(dest, src);
+	case 45:
+		return MemcpyFixed<45>(dest, src);
+	case 46:
+		return MemcpyFixed<46>(dest, src);
+	case 47:
+		return MemcpyFixed<47>(dest, src);
+	case 48:
+		return MemcpyFixed<48>(dest, src);
+	case 49:
+		return MemcpyFixed<49>(dest, src);
+	case 50:
+		return MemcpyFixed<50>(dest, src);
+	case 51:
+		return MemcpyFixed<51>(dest, src);
+	case 52:
+		return MemcpyFixed<52>(dest, src);
+	case 53:
+		return MemcpyFixed<53>(dest, src);
+	case 54:
+		return MemcpyFixed<54>(dest, src);
+	case 55:
+		return MemcpyFixed<55>(dest, src);
+	case 56:
+		return MemcpyFixed<56>(dest, src);
+	case 57:
+		return MemcpyFixed<57>(dest, src);
+	case 58:
+		return MemcpyFixed<58>(dest, src);
+	case 59:
+		return MemcpyFixed<59>(dest, src);
+	case 60:
+		return MemcpyFixed<60>(dest, src);
+	case 61:
+		return MemcpyFixed<61>(dest, src);
+	case 62:
+		return MemcpyFixed<62>(dest, src);
+	case 63:
+		return MemcpyFixed<63>(dest, src);
+	case 64:
+		return MemcpyFixed<64>(dest, src);
+	case 65:
+		return MemcpyFixed<65>(dest, src);
+	case 66:
+		return MemcpyFixed<66>(dest, src);
+	case 67:
+		return MemcpyFixed<67>(dest, src);
+	case 68:
+		return MemcpyFixed<68>(dest, src);
+	case 69:
+		return MemcpyFixed<69>(dest, src);
+	case 70:
+		return MemcpyFixed<70>(dest, src);
+	case 71:
+		return MemcpyFixed<71>(dest, src);
+	case 72:
+		return MemcpyFixed<72>(dest, src);
+	case 73:
+		return MemcpyFixed<73>(dest, src);
+	case 74:
+		return MemcpyFixed<74>(dest, src);
+	case 75:
+		return MemcpyFixed<75>(dest, src);
+	case 76:
+		return MemcpyFixed<76>(dest, src);
+	case 77:
+		return MemcpyFixed<77>(dest, src);
+	case 78:
+		return MemcpyFixed<78>(dest, src);
+	case 79:
+		return MemcpyFixed<79>(dest, src);
+	case 80:
+		return MemcpyFixed<80>(dest, src);
+	case 81:
+		return MemcpyFixed<81>(dest, src);
+	case 82:
+		return MemcpyFixed<82>(dest, src);
+	case 83:
+		return MemcpyFixed<83>(dest, src);
+	case 84:
+		return MemcpyFixed<84>(dest, src);
+	case 85:
+		return MemcpyFixed<85>(dest, src);
+	case 86:
+		return MemcpyFixed<86>(dest, src);
+	case 87:
+		return MemcpyFixed<87>(dest, src);
+	case 88:
+		return MemcpyFixed<88>(dest, src);
+	case 89:
+		return MemcpyFixed<89>(dest, src);
+	case 90:
+		return MemcpyFixed<90>(dest, src);
+	case 91:
+		return MemcpyFixed<91>(dest, src);
+	case 92:
+		return MemcpyFixed<92>(dest, src);
+	case 93:
+		return MemcpyFixed<93>(dest, src);
+	case 94:
+		return MemcpyFixed<94>(dest, src);
+	case 95:
+		return MemcpyFixed<95>(dest, src);
+	case 96:
+		return MemcpyFixed<96>(dest, src);
+	case 97:
+		return MemcpyFixed<97>(dest, src);
+	case 98:
+		return MemcpyFixed<98>(dest, src);
+	case 99:
+		return MemcpyFixed<99>(dest, src);
+	case 100:
+		return MemcpyFixed<100>(dest, src);
+	case 101:
+		return MemcpyFixed<101>(dest, src);
+	case 102:
+		return MemcpyFixed<102>(dest, src);
+	case 103:
+		return MemcpyFixed<103>(dest, src);
+	case 104:
+		return MemcpyFixed<104>(dest, src);
+	case 105:
+		return MemcpyFixed<105>(dest, src);
+	case 106:
+		return MemcpyFixed<106>(dest, src);
+	case 107:
+		return MemcpyFixed<107>(dest, src);
+	case 108:
+		return MemcpyFixed<108>(dest, src);
+	case 109:
+		return MemcpyFixed<109>(dest, src);
+	case 110:
+		return MemcpyFixed<110>(dest, src);
+	case 111:
+		return MemcpyFixed<111>(dest, src);
+	case 112:
+		return MemcpyFixed<112>(dest, src);
+	case 113:
+		return MemcpyFixed<113>(dest, src);
+	case 114:
+		return MemcpyFixed<114>(dest, src);
+	case 115:
+		return MemcpyFixed<115>(dest, src);
+	case 116:
+		return MemcpyFixed<116>(dest, src);
+	case 117:
+		return MemcpyFixed<117>(dest, src);
+	case 118:
+		return MemcpyFixed<118>(dest, src);
+	case 119:
+		return MemcpyFixed<119>(dest, src);
+	case 120:
+		return MemcpyFixed<120>(dest, src);
+	case 121:
+		return MemcpyFixed<121>(dest, src);
+	case 122:
+		return MemcpyFixed<122>(dest, src);
+	case 123:
+		return MemcpyFixed<123>(dest, src);
+	case 124:
+		return MemcpyFixed<124>(dest, src);
+	case 125:
+		return MemcpyFixed<125>(dest, src);
+	case 126:
+		return MemcpyFixed<126>(dest, src);
+	case 127:
+		return MemcpyFixed<127>(dest, src);
+	case 128:
+		return MemcpyFixed<128>(dest, src);
+	case 129:
+		return MemcpyFixed<129>(dest, src);
+	case 130:
+		return MemcpyFixed<130>(dest, src);
+	case 131:
+		return MemcpyFixed<131>(dest, src);
+	case 132:
+		return MemcpyFixed<132>(dest, src);
+	case 133:
+		return MemcpyFixed<133>(dest, src);
+	case 134:
+		return MemcpyFixed<134>(dest, src);
+	case 135:
+		return MemcpyFixed<135>(dest, src);
+	case 136:
+		return MemcpyFixed<136>(dest, src);
+	case 137:
+		return MemcpyFixed<137>(dest, src);
+	case 138:
+		return MemcpyFixed<138>(dest, src);
+	case 139:
+		return MemcpyFixed<139>(dest, src);
+	case 140:
+		return MemcpyFixed<140>(dest, src);
+	case 141:
+		return MemcpyFixed<141>(dest, src);
+	case 142:
+		return MemcpyFixed<142>(dest, src);
+	case 143:
+		return MemcpyFixed<143>(dest, src);
+	case 144:
+		return MemcpyFixed<144>(dest, src);
+	case 145:
+		return MemcpyFixed<145>(dest, src);
+	case 146:
+		return MemcpyFixed<146>(dest, src);
+	case 147:
+		return MemcpyFixed<147>(dest, src);
+	case 148:
+		return MemcpyFixed<148>(dest, src);
+	case 149:
+		return MemcpyFixed<149>(dest, src);
+	case 150:
+		return MemcpyFixed<150>(dest, src);
+	case 151:
+		return MemcpyFixed<151>(dest, src);
+	case 152:
+		return MemcpyFixed<152>(dest, src);
+	case 153:
+		return MemcpyFixed<153>(dest, src);
+	case 154:
+		return MemcpyFixed<154>(dest, src);
+	case 155:
+		return MemcpyFixed<155>(dest, src);
+	case 156:
+		return MemcpyFixed<156>(dest, src);
+	case 157:
+		return MemcpyFixed<157>(dest, src);
+	case 158:
+		return MemcpyFixed<158>(dest, src);
+	case 159:
+		return MemcpyFixed<159>(dest, src);
+	case 160:
+		return MemcpyFixed<160>(dest, src);
+	case 161:
+		return MemcpyFixed<161>(dest, src);
+	case 162:
+		return MemcpyFixed<162>(dest, src);
+	case 163:
+		return MemcpyFixed<163>(dest, src);
+	case 164:
+		return MemcpyFixed<164>(dest, src);
+	case 165:
+		return MemcpyFixed<165>(dest, src);
+	case 166:
+		return MemcpyFixed<166>(dest, src);
+	case 167:
+		return MemcpyFixed<167>(dest, src);
+	case 168:
+		return MemcpyFixed<168>(dest, src);
+	case 169:
+		return MemcpyFixed<169>(dest, src);
+	case 170:
+		return MemcpyFixed<170>(dest, src);
+	case 171:
+		return MemcpyFixed<171>(dest, src);
+	case 172:
+		return MemcpyFixed<172>(dest, src);
+	case 173:
+		return MemcpyFixed<173>(dest, src);
+	case 174:
+		return MemcpyFixed<174>(dest, src);
+	case 175:
+		return MemcpyFixed<175>(dest, src);
+	case 176:
+		return MemcpyFixed<176>(dest, src);
+	case 177:
+		return MemcpyFixed<177>(dest, src);
+	case 178:
+		return MemcpyFixed<178>(dest, src);
+	case 179:
+		return MemcpyFixed<179>(dest, src);
+	case 180:
+		return MemcpyFixed<180>(dest, src);
+	case 181:
+		return MemcpyFixed<181>(dest, src);
+	case 182:
+		return MemcpyFixed<182>(dest, src);
+	case 183:
+		return MemcpyFixed<183>(dest, src);
+	case 184:
+		return MemcpyFixed<184>(dest, src);
+	case 185:
+		return MemcpyFixed<185>(dest, src);
+	case 186:
+		return MemcpyFixed<186>(dest, src);
+	case 187:
+		return MemcpyFixed<187>(dest, src);
+	case 188:
+		return MemcpyFixed<188>(dest, src);
+	case 189:
+		return MemcpyFixed<189>(dest, src);
+	case 190:
+		return MemcpyFixed<190>(dest, src);
+	case 191:
+		return MemcpyFixed<191>(dest, src);
+	case 192:
+		return MemcpyFixed<192>(dest, src);
+	case 193:
+		return MemcpyFixed<193>(dest, src);
+	case 194:
+		return MemcpyFixed<194>(dest, src);
+	case 195:
+		return MemcpyFixed<195>(dest, src);
+	case 196:
+		return MemcpyFixed<196>(dest, src);
+	case 197:
+		return MemcpyFixed<197>(dest, src);
+	case 198:
+		return MemcpyFixed<198>(dest, src);
+	case 199:
+		return MemcpyFixed<199>(dest, src);
+	case 200:
+		return MemcpyFixed<200>(dest, src);
+	case 201:
+		return MemcpyFixed<201>(dest, src);
+	case 202:
+		return MemcpyFixed<202>(dest, src);
+	case 203:
+		return MemcpyFixed<203>(dest, src);
+	case 204:
+		return MemcpyFixed<204>(dest, src);
+	case 205:
+		return MemcpyFixed<205>(dest, src);
+	case 206:
+		return MemcpyFixed<206>(dest, src);
+	case 207:
+		return MemcpyFixed<207>(dest, src);
+	case 208:
+		return MemcpyFixed<208>(dest, src);
+	case 209:
+		return MemcpyFixed<209>(dest, src);
+	case 210:
+		return MemcpyFixed<210>(dest, src);
+	case 211:
+		return MemcpyFixed<211>(dest, src);
+	case 212:
+		return MemcpyFixed<212>(dest, src);
+	case 213:
+		return MemcpyFixed<213>(dest, src);
+	case 214:
+		return MemcpyFixed<214>(dest, src);
+	case 215:
+		return MemcpyFixed<215>(dest, src);
+	case 216:
+		return MemcpyFixed<216>(dest, src);
+	case 217:
+		return MemcpyFixed<217>(dest, src);
+	case 218:
+		return MemcpyFixed<218>(dest, src);
+	case 219:
+		return MemcpyFixed<219>(dest, src);
+	case 220:
+		return MemcpyFixed<220>(dest, src);
+	case 221:
+		return MemcpyFixed<221>(dest, src);
+	case 222:
+		return MemcpyFixed<222>(dest, src);
+	case 223:
+		return MemcpyFixed<223>(dest, src);
+	case 224:
+		return MemcpyFixed<224>(dest, src);
+	case 225:
+		return MemcpyFixed<225>(dest, src);
+	case 226:
+		return MemcpyFixed<226>(dest, src);
+	case 227:
+		return MemcpyFixed<227>(dest, src);
+	case 228:
+		return MemcpyFixed<228>(dest, src);
+	case 229:
+		return MemcpyFixed<229>(dest, src);
+	case 230:
+		return MemcpyFixed<230>(dest, src);
+	case 231:
+		return MemcpyFixed<231>(dest, src);
+	case 232:
+		return MemcpyFixed<232>(dest, src);
+	case 233:
+		return MemcpyFixed<233>(dest, src);
+	case 234:
+		return MemcpyFixed<234>(dest, src);
+	case 235:
+		return MemcpyFixed<235>(dest, src);
+	case 236:
+		return MemcpyFixed<236>(dest, src);
+	case 237:
+		return MemcpyFixed<237>(dest, src);
+	case 238:
+		return MemcpyFixed<238>(dest, src);
+	case 239:
+		return MemcpyFixed<239>(dest, src);
+	case 240:
+		return MemcpyFixed<240>(dest, src);
+	case 241:
+		return MemcpyFixed<241>(dest, src);
+	case 242:
+		return MemcpyFixed<242>(dest, src);
+	case 243:
+		return MemcpyFixed<243>(dest, src);
+	case 244:
+		return MemcpyFixed<244>(dest, src);
+	case 245:
+		return MemcpyFixed<245>(dest, src);
+	case 246:
+		return MemcpyFixed<246>(dest, src);
+	case 247:
+		return MemcpyFixed<247>(dest, src);
+	case 248:
+		return MemcpyFixed<248>(dest, src);
+	case 249:
+		return MemcpyFixed<249>(dest, src);
+	case 250:
+		return MemcpyFixed<250>(dest, src);
+	case 251:
+		return MemcpyFixed<251>(dest, src);
+	case 252:
+		return MemcpyFixed<252>(dest, src);
+	case 253:
+		return MemcpyFixed<253>(dest, src);
+	case 254:
+		return MemcpyFixed<254>(dest, src);
+	case 255:
+		return MemcpyFixed<255>(dest, src);
+	case 256:
+		return MemcpyFixed<256>(dest, src);
+	default:
+		memcpy(dest, src, size);
+	}
+	// LCOV_EXCL_STOP
+}
+
+//! This templated memcmp is significantly faster than std::memcmp,
+//! but only when you are calling memcmp with a const size in a loop.
+//! For instance `while (<cond>) { memcmp(<str1>, <str2>, const_size); ... }`
+static inline int FastMemcmp(const void *str1, const void *str2, const size_t size) {
+	// LCOV_EXCL_START
+	switch (size) {
+	case 0:
+		return 0;
+	case 1:
+		return MemcmpFixed<1>(str1, str2);
+	case 2:
+		return MemcmpFixed<2>(str1, str2);
+	case 3:
+		return MemcmpFixed<3>(str1, str2);
+	case 4:
+		return MemcmpFixed<4>(str1, str2);
+	case 5:
+		return MemcmpFixed<5>(str1, str2);
+	case 6:
+		return MemcmpFixed<6>(str1, str2);
+	case 7:
+		return MemcmpFixed<7>(str1, str2);
+	case 8:
+		return MemcmpFixed<8>(str1, str2);
+	case 9:
+		return MemcmpFixed<9>(str1, str2);
+	case 10:
+		return MemcmpFixed<10>(str1, str2);
+	case 11:
+		return MemcmpFixed<11>(str1, str2);
+	case 12:
+		return MemcmpFixed<12>(str1, str2);
+	case 13:
+		return MemcmpFixed<13>(str1, str2);
+	case 14:
+		return MemcmpFixed<14>(str1, str2);
+	case 15:
+		return MemcmpFixed<15>(str1, str2);
+	case 16:
+		return MemcmpFixed<16>(str1, str2);
+	case 17:
+		return MemcmpFixed<17>(str1, str2);
+	case 18:
+		return MemcmpFixed<18>(str1, str2);
+	case 19:
+		return MemcmpFixed<19>(str1, str2);
+	case 20:
+		return MemcmpFixed<20>(str1, str2);
+	case 21:
+		return MemcmpFixed<21>(str1, str2);
+	case 22:
+		return MemcmpFixed<22>(str1, str2);
+	case 23:
+		return MemcmpFixed<23>(str1, str2);
+	case 24:
+		return MemcmpFixed<24>(str1, str2);
+	case 25:
+		return MemcmpFixed<25>(str1, str2);
+	case 26:
+		return MemcmpFixed<26>(str1, str2);
+	case 27:
+		return MemcmpFixed<27>(str1, str2);
+	case 28:
+		return MemcmpFixed<28>(str1, str2);
+	case 29:
+		return MemcmpFixed<29>(str1, str2);
+	case 30:
+		return MemcmpFixed<30>(str1, str2);
+	case 31:
+		return MemcmpFixed<31>(str1, str2);
+	case 32:
+		return MemcmpFixed<32>(str1, str2);
+	case 33:
+		return MemcmpFixed<33>(str1, str2);
+	case 34:
+		return MemcmpFixed<34>(str1, str2);
+	case 35:
+		return MemcmpFixed<35>(str1, str2);
+	case 36:
+		return MemcmpFixed<36>(str1, str2);
+	case 37:
+		return MemcmpFixed<37>(str1, str2);
+	case 38:
+		return MemcmpFixed<38>(str1, str2);
+	case 39:
+		return MemcmpFixed<39>(str1, str2);
+	case 40:
+		return MemcmpFixed<40>(str1, str2);
+	case 41:
+		return MemcmpFixed<41>(str1, str2);
+	case 42:
+		return MemcmpFixed<42>(str1, str2);
+	case 43:
+		return MemcmpFixed<43>(str1, str2);
+	case 44:
+		return MemcmpFixed<44>(str1, str2);
+	case 45:
+		return MemcmpFixed<45>(str1, str2);
+	case 46:
+		return MemcmpFixed<46>(str1, str2);
+	case 47:
+		return MemcmpFixed<47>(str1, str2);
+	case 48:
+		return MemcmpFixed<48>(str1, str2);
+	case 49:
+		return MemcmpFixed<49>(str1, str2);
+	case 50:
+		return MemcmpFixed<50>(str1, str2);
+	case 51:
+		return MemcmpFixed<51>(str1, str2);
+	case 52:
+		return MemcmpFixed<52>(str1, str2);
+	case 53:
+		return MemcmpFixed<53>(str1, str2);
+	case 54:
+		return MemcmpFixed<54>(str1, str2);
+	case 55:
+		return MemcmpFixed<55>(str1, str2);
+	case 56:
+		return MemcmpFixed<56>(str1, str2);
+	case 57:
+		return MemcmpFixed<57>(str1, str2);
+	case 58:
+		return MemcmpFixed<58>(str1, str2);
+	case 59:
+		return MemcmpFixed<59>(str1, str2);
+	case 60:
+		return MemcmpFixed<60>(str1, str2);
+	case 61:
+		return MemcmpFixed<61>(str1, str2);
+	case 62:
+		return MemcmpFixed<62>(str1, str2);
+	case 63:
+		return MemcmpFixed<63>(str1, str2);
+	case 64:
+		return MemcmpFixed<64>(str1, str2);
+	default:
+		return memcmp(str1, str2, size);
+	}
+	// LCOV_EXCL_STOP
+}
+
+} // namespace duckdb
+
 
 
 
@@ -29920,7 +30614,7 @@ int MergeSorter::CompareUsingGlobalIndex(SortedBlock &l, SortedBlock &r, const i
 
 	int comp_res;
 	if (sort_layout.all_constant) {
-		comp_res = memcmp(l_ptr, r_ptr, sort_layout.comparison_size);
+		comp_res = FastMemcmp(l_ptr, r_ptr, sort_layout.comparison_size);
 	} else {
 		l.blob_sorting_data->block_idx = l_block_idx;
 		l.blob_sorting_data->entry_idx = l_entry_idx;
@@ -30064,7 +30758,7 @@ void MergeSorter::ComputeMerge(const idx_t &count, bool left_smaller[]) {
 		if (sort_layout.all_constant) {
 			// All sorting columns are constant size
 			for (; compared < count && l_entry_idx < l_count && r_entry_idx < r_count; compared++) {
-				left_smaller[compared] = memcmp(l_radix_ptr, r_radix_ptr, sort_layout.comparison_size) < 0;
+				left_smaller[compared] = FastMemcmp(l_radix_ptr, r_radix_ptr, sort_layout.comparison_size) < 0;
 				const bool &l_smaller = left_smaller[compared];
 				const bool r_smaller = !l_smaller;
 				// Use comparison bool (0 or 1) to increment entries and pointers
@@ -30312,8 +31006,8 @@ void MergeSorter::MergeData(SortedData &result_data, SortedData &l_data, SortedD
 					const bool &l_smaller = left_smaller[copied + i];
 					const bool r_smaller = !l_smaller;
 					const auto &entry_size = next_entry_sizes[copied + i];
-					memcpy(result_heap_ptr, l_heap_ptr, l_smaller * entry_size);
-					memcpy(result_heap_ptr, r_heap_ptr, r_smaller * entry_size);
+					memcpy(result_heap_ptr, (data_ptr_t)(l_smaller * (idx_t)l_heap_ptr + r_smaller * (idx_t)r_heap_ptr),
+					       entry_size);
 					D_ASSERT(Load<uint32_t>(result_heap_ptr) == entry_size);
 					result_heap_ptr += entry_size;
 					l_heap_ptr += l_smaller * entry_size;
@@ -30349,8 +31043,7 @@ void MergeSorter::MergeRows(data_ptr_t &l_ptr, idx_t &l_entry_idx, const idx_t &
 		const bool &l_smaller = left_smaller[copied + i];
 		const bool r_smaller = !l_smaller;
 		// Use comparison bool (0 or 1) to copy an entry from either side
-		memcpy(target_ptr, l_ptr, l_smaller * entry_size);
-		memcpy(target_ptr, r_ptr, r_smaller * entry_size);
+		FastMemcpy(target_ptr, (data_ptr_t)(l_smaller * (idx_t)l_ptr + r_smaller * (idx_t)r_ptr), entry_size);
 		target_ptr += entry_size;
 		// Use the comparison bool to increment entries and pointers
 		l_entry_idx += l_smaller;
@@ -30431,6 +31124,7 @@ void MergeSorter::FlushBlobs(const RowLayout &layout, const idx_t &source_count,
 
 
 
+
 namespace duckdb {
 
 //! Calls std::sort on strings that are tied by their prefix after the radix sort
@@ -30470,7 +31164,7 @@ static void SortTiedBlobs(BufferManager &buffer_manager, const data_ptr_t datapt
 	    buffer_manager.Allocate(MaxValue((end - start) * sort_layout.entry_size, (idx_t)Storage::BLOCK_SIZE));
 	data_ptr_t temp_ptr = temp_block->Ptr();
 	for (idx_t i = 0; i < end - start; i++) {
-		memcpy(temp_ptr, entry_ptrs[i], sort_layout.entry_size);
+		FastMemcpy(temp_ptr, entry_ptrs[i], sort_layout.entry_size);
 		temp_ptr += sort_layout.entry_size;
 	}
 	memcpy(dataptr + start * sort_layout.entry_size, temp_block->Ptr(), (end - start) * sort_layout.entry_size);
@@ -30530,7 +31224,7 @@ static void ComputeTies(data_ptr_t dataptr, const idx_t &count, const idx_t &col
 	// Align dataptr
 	dataptr += col_offset;
 	for (idx_t i = 0; i < count - 1; i++) {
-		ties[i] = ties[i] && memcmp(dataptr, dataptr + sort_layout.entry_size, tie_size) == 0;
+		ties[i] = ties[i] && FastMemcmp(dataptr, dataptr + sort_layout.entry_size, tie_size) == 0;
 		dataptr += sort_layout.entry_size;
 	}
 }
@@ -30568,7 +31262,7 @@ void RadixSortLSD(BufferManager &buffer_manager, const data_ptr_t &dataptr, cons
 		data_ptr_t row_ptr = source_ptr + (count - 1) * row_width;
 		for (idx_t i = 0; i < count; i++) {
 			idx_t &radix_offset = --counts[*(row_ptr + offset)];
-			memcpy(target_ptr + radix_offset * row_width, row_ptr, row_width);
+			FastMemcpy(target_ptr + radix_offset * row_width, row_ptr, row_width);
 			row_ptr -= row_width;
 		}
 		swap = !swap;
@@ -30591,14 +31285,14 @@ inline void InsertionSort(const data_ptr_t orig_ptr, const data_ptr_t temp_ptr,
 		const data_ptr_t val = temp_val.get();
 		const auto comp_width = total_comp_width - offset;
 		for (idx_t i = 1; i < count; i++) {
-			memcpy(val, source_ptr + i * row_width, row_width);
+			FastMemcpy(val, source_ptr + i * row_width, row_width);
 			idx_t j = i;
 			while (j > 0 &&
-			       memcmp(source_ptr + (j - 1) * row_width + total_offset, val + total_offset, comp_width) > 0) {
-				memcpy(source_ptr + j * row_width, source_ptr + (j - 1) * row_width, row_width);
+			       FastMemcmp(source_ptr + (j - 1) * row_width + total_offset, val + total_offset, comp_width) > 0) {
+				FastMemcpy(source_ptr + j * row_width, source_ptr + (j - 1) * row_width, row_width);
 				j--;
 			}
-			memcpy(source_ptr + j * row_width, val, row_width);
+			FastMemcpy(source_ptr + j * row_width, val, row_width);
 		}
 	}
 	if (swap) {
@@ -30632,7 +31326,7 @@ void RadixSortMSD(const data_ptr_t orig_ptr, const data_ptr_t temp_ptr, const id
 		data_ptr_t row_ptr = source_ptr;
 		for (idx_t i = 0; i < count; i++) {
 			const idx_t &radix_offset = locations[*(row_ptr + total_offset)]++;
-			memcpy(target_ptr + radix_offset * row_width, row_ptr, row_width);
+			FastMemcpy(target_ptr + radix_offset * row_width, row_ptr, row_width);
 			row_ptr += row_width;
 		}
 		swap = !swap;
@@ -43103,6 +43797,7 @@ struct EnumTypeInfo : public ExtraTypeInfo {
 	TypeCatalogEntry *catalog_entry = nullptr;
 
 public:
+	// Equalities are only used in enums with different catalog entries
 	bool Equals(ExtraTypeInfo *other_p) override {
 		if (!other_p) {
 			return false;
@@ -43111,9 +43806,12 @@ public:
 			return false;
 		}
 		auto &other = (EnumTypeInfo &)*other_p;
-		return other.enum_name == enum_name && other.values_insert_order == values_insert_order;
+		// We must check if all elements are equal
+		if (other.values_insert_order == values_insert_order) {
+			return true;
+		}
+		return false;
 	}
-
 	void Serialize(Serializer &serializer) const override {
 		serializer.Write<uint32_t>(values_insert_order.size());
 		serializer.WriteString(enum_name);
@@ -54559,6 +55257,8 @@ private:
 	Vector statep;
 	//! The frame boundaries, used for the window functions
 	FrameBounds frame;
+	//! The active data in the inputs. Used for the window functions
+	FrameBounds active;
 	//! Reused result state container for the window functions
 	Vector statev;
 
@@ -70814,8 +71514,8 @@ WindowSegmentTree::WindowSegmentTree(AggregateFunction &aggregate, FunctionData
                                      const LogicalType &result_type_p, ChunkCollection *input,
                                      WindowAggregationMode mode_p)
     : aggregate(aggregate), bind_info(bind_info), result_type(result_type_p), state(aggregate.state_size()),
-      statep(Value::POINTER((idx_t)state.data())), frame(0, 0), statev(Value::POINTER((idx_t)state.data())),
-      internal_nodes(0), input_ref(input), mode(mode_p) {
+      statep(Value::POINTER((idx_t)state.data())), frame(0, 0), active(0, 1),
+      statev(Value::POINTER((idx_t)state.data())), internal_nodes(0), input_ref(input), mode(mode_p) {
 #if STANDARD_VECTOR_SIZE < 512
 	throw NotImplementedException("Window functions are not supported for vector sizes < 512");
 #endif
@@ -70827,6 +71527,7 @@ WindowSegmentTree::WindowSegmentTree(AggregateFunction &aggregate, FunctionData
 		// if we have a frame-by-frame method, share the single state
 		if (aggregate.window && UseWindowAPI()) {
 			AggregateInit();
+			inputs.Reference(input_ref->GetChunk(0));
 		} else if (aggregate.combine && UseCombineAPI()) {
 			ConstructTree();
 		}
@@ -70993,9 +71694,38 @@ void WindowSegmentTree::Compute(Vector &result, idx_t rid, idx_t begin, idx_t en
 		frame = FrameBounds(begin, end);
 
 		// Extract the range
-		ExtractFrame(MinValue(frame.first, prev.first), MaxValue(frame.second, prev.second));
+		auto &coll = *input_ref;
+		const auto prev_active = active;
+		const FrameBounds combined(MinValue(frame.first, prev.first), MaxValue(frame.second, prev.second));
+
+		// The chunk bounds are the range that includes the begin and end - 1
+		const FrameBounds prev_chunks(coll.LocateChunk(prev_active.first), coll.LocateChunk(prev_active.second - 1));
+		const FrameBounds active_chunks(coll.LocateChunk(combined.first), coll.LocateChunk(combined.second - 1));
+
+		// Extract the range
+		if (active_chunks.first == active_chunks.second) {
+			// If all the data is in a single chunk, then just reference it
+			if (prev_chunks != active_chunks || (!prev.first && !prev.second)) {
+				inputs.Reference(coll.GetChunk(active_chunks.first));
+			}
+		} else if (active_chunks.first == prev_chunks.first && prev_chunks.first != prev_chunks.second) {
+			// If the start chunk did not change, and we are not just a reference, then extend if necessary
+			for (auto chunk_idx = prev_chunks.second + 1; chunk_idx <= active_chunks.second; ++chunk_idx) {
+				inputs.Append(coll.GetChunk(chunk_idx), true);
+			}
+		} else {
+			// If the first chunk changed, start over
+			inputs.Reset();
+			for (auto chunk_idx = active_chunks.first; chunk_idx <= active_chunks.second; ++chunk_idx) {
+				inputs.Append(coll.GetChunk(chunk_idx), true);
+			}
+		}
+
+		active = FrameBounds(active_chunks.first * STANDARD_VECTOR_SIZE,
+		                     MinValue((active_chunks.second + 1) * STANDARD_VECTOR_SIZE, coll.Count()));
 
-		aggregate.window(inputs.data.data(), bind_info, inputs.ColumnCount(), state.data(), frame, prev, result, rid);
+		aggregate.window(inputs.data.data(), bind_info, inputs.ColumnCount(), state.data(), frame, prev, result, rid,
+		                 active.first);
 		return;
 	}
 
@@ -75394,11 +76124,10 @@ struct ModeFunction {
 
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
 	static void Window(const INPUT_TYPE *data, const ValidityMask &dmask, FunctionData *bind_data_p, STATE *state,
-	                   const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t rid) {
+	                   const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t rid, idx_t bias) {
 		auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
 		auto &rmask = FlatVector::Validity(result);
 
-		const auto bias = MinValue(frame.first, prev.first);
 		if (!state->frequency_map) {
 			state->frequency_map = new unordered_map<KEY_TYPE, size_t>();
 		}
@@ -76045,11 +76774,11 @@ struct QuantileScalarOperation : public QuantileOperation {
 
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
 	static void Window(const INPUT_TYPE *data, const ValidityMask &dmask, FunctionData *bind_data_p, STATE *state,
-	                   const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t ridx) {
+	                   const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t ridx, idx_t bias) {
 		auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
 		auto &rmask = FlatVector::Validity(result);
 
-		QuantileNotNull not_null(dmask, MinValue(frame.first, prev.first));
+		QuantileNotNull not_null(dmask, bias);
 
 		//  Lazily initialise frame state
 		auto prev_pos = state->pos;
@@ -76194,11 +76923,11 @@ struct QuantileListOperation : public QuantileOperation {
 
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
 	static void Window(const INPUT_TYPE *data, const ValidityMask &dmask, FunctionData *bind_data_p, STATE *state,
-	                   const FrameBounds &frame, const FrameBounds &prev, Vector &list, idx_t lidx) {
+	                   const FrameBounds &frame, const FrameBounds &prev, Vector &list, idx_t lidx, idx_t bias) {
 		D_ASSERT(bind_data_p);
 		auto bind_data = (QuantileBindData *)bind_data_p;
 
-		QuantileNotNull not_null(dmask, MinValue(frame.first, prev.first));
+		QuantileNotNull not_null(dmask, bias);
 
 		// Result is a constant LIST<RESULT_TYPE> with a fixed length
 		auto ldata = FlatVector::GetData<RESULT_TYPE>(list);
@@ -76547,11 +77276,11 @@ struct MedianAbsoluteDeviationOperation : public QuantileOperation {
 
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
 	static void Window(const INPUT_TYPE *data, const ValidityMask &dmask, FunctionData *bind_data_p, STATE *state,
-	                   const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t ridx) {
+	                   const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t ridx, idx_t bias) {
 		auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
 		auto &rmask = FlatVector::Validity(result);
 
-		QuantileNotNull not_null(dmask, MinValue(frame.first, prev.first));
+		QuantileNotNull not_null(dmask, bias);
 
 		//  Lazily initialise frame state
 		auto prev_pos = state->pos;
@@ -139032,6 +139761,11 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 		case ResultModifierType::DISTINCT_MODIFIER: {
 			auto &distinct = (DistinctModifier &)*mod;
 			auto bound_distinct = make_unique<BoundDistinctModifier>();
+			if (distinct.distinct_on_targets.empty()) {
+				for (idx_t i = 0; i < result.names.size(); i++) {
+					distinct.distinct_on_targets.push_back(make_unique<ConstantExpression>(Value::INTEGER(1 + i)));
+				}
+			}
 			for (auto &distinct_on_target : distinct.distinct_on_targets) {
 				auto expr = BindOrderExpression(order_binder, move(distinct_on_target));
 				if (!expr) {

package/src/duckdb.hpp

@@ -10,8 +10,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 #pragma once
 #define DUCKDB_AMALGAMATION 1
-#define DUCKDB_SOURCE_ID "1f9b8f4d6"
-#define DUCKDB_VERSION "0.3.2-dev145"
+#define DUCKDB_SOURCE_ID "a73d33c14"
+#define DUCKDB_VERSION "0.3.2-dev173"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -6961,12 +6961,12 @@ public:
 
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
 	static void UnaryWindow(Vector &input, FunctionData *bind_data, data_ptr_t state, const FrameBounds &frame,
-	                        const FrameBounds &prev, Vector &result, idx_t rid) {
+	                        const FrameBounds &prev, Vector &result, idx_t rid, idx_t bias) {
 
-		auto idata = FlatVector::GetData<const INPUT_TYPE>(input) - MinValue(frame.first, prev.first);
+		auto idata = FlatVector::GetData<const INPUT_TYPE>(input) - bias;
 		const auto &ivalid = FlatVector::Validity(input);
 		OP::template Window<STATE, INPUT_TYPE, RESULT_TYPE>(idata, ivalid, bind_data, (STATE *)state, frame, prev,
-		                                                    result, rid);
+		                                                    result, rid, bias);
 	}
 
 	template <class STATE_TYPE, class OP>
@@ -8133,7 +8133,8 @@ typedef void (*aggregate_simple_update_t)(Vector inputs[], FunctionData *bind_da
 //! The type used for updating complex windowed aggregate functions (optional)
 typedef std::pair<idx_t, idx_t> FrameBounds;
 typedef void (*aggregate_window_t)(Vector inputs[], FunctionData *bind_data, idx_t input_count, data_ptr_t state,
-                                   const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t offset);
+                                   const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t rid,
+                                   idx_t bias);
 
 class AggregateFunction : public BaseScalarFunction {
 public:
@@ -8275,10 +8276,10 @@ public:
 
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE, class OP>
 	static void UnaryWindow(Vector inputs[], FunctionData *bind_data, idx_t input_count, data_ptr_t state,
-	                        const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t rid) {
+	                        const FrameBounds &frame, const FrameBounds &prev, Vector &result, idx_t rid, idx_t bias) {
 		D_ASSERT(input_count == 1);
 		AggregateExecutor::UnaryWindow<STATE, INPUT_TYPE, RESULT_TYPE, OP>(inputs[0], bind_data, state, frame, prev,
-		                                                                   result, rid);
+		                                                                   result, rid, bias);
 	}
 
 	template <class STATE, class A_TYPE, class B_TYPE, class OP>