duckdb 0.3.2-dev838.0 → 0.3.2-dev856.0

package/src/duckdb.cpp

@@ -21139,12 +21139,14 @@ public:
 
 	int64_t GetFileSize(FileHandle &handle) override;
 
+	void Reset(FileHandle &handle) override;
 	bool OnDiskFile(FileHandle &handle) override {
 		return false;
 	};
 	bool CanSeek() override {
 		return false;
 	}
+	void FileSync(FileHandle &handle) override;
 
 	std::string GetName() const override {
 		return "PipeFileSystem";
@@ -21181,6 +21183,10 @@ int64_t PipeFile::WriteChunk(void *buffer, int64_t nr_bytes) {
 	return child_handle->Write(buffer, nr_bytes);
 }
 
+void PipeFileSystem::Reset(FileHandle &handle) {
+	throw InternalException("Cannot reset pipe file system");
+}
+
 int64_t PipeFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes) {
 	auto &pipe = (PipeFile &)handle;
 	return pipe.ReadChunk(buffer, nr_bytes);
@@ -21195,6 +21201,9 @@ int64_t PipeFileSystem::GetFileSize(FileHandle &handle) {
 	return 0;
 }
 
+void PipeFileSystem::FileSync(FileHandle &handle) {
+}
+
 unique_ptr<FileHandle> PipeFileSystem::OpenPipe(unique_ptr<FileHandle> handle) {
 	auto path = handle->path;
 	return make_unique<PipeFile>(move(handle), path);
@@ -56617,6 +56626,125 @@ string PhysicalTopN::ParamsToString() const {
 
 namespace duckdb {
 
+struct CSVFileHandle {
+public:
+	explicit CSVFileHandle(unique_ptr<FileHandle> file_handle_p) : file_handle(move(file_handle_p)) {
+		can_seek = file_handle->CanSeek();
+		plain_file_source = file_handle->OnDiskFile() && can_seek;
+		file_size = file_handle->GetFileSize();
+	}
+
+	bool CanSeek() {
+		return can_seek;
+	}
+	void Seek(idx_t position) {
+		if (!can_seek) {
+			throw InternalException("Cannot seek in this file");
+		}
+		file_handle->Seek(position);
+	}
+	idx_t SeekPosition() {
+		if (!can_seek) {
+			throw InternalException("Cannot seek in this file");
+		}
+		return file_handle->SeekPosition();
+	}
+	void Reset() {
+		if (plain_file_source) {
+			file_handle->Reset();
+		} else {
+			if (!reset_enabled) {
+				throw InternalException("Reset called but reset is not enabled for this CSV Handle");
+			}
+			read_position = 0;
+		}
+	}
+	bool PlainFileSource() {
+		return plain_file_source;
+	}
+
+	idx_t FileSize() {
+		return file_size;
+	}
+
+	idx_t Read(void *buffer, idx_t nr_bytes) {
+		if (!plain_file_source) {
+			// not a plain file source: we need to do some bookkeeping around the reset functionality
+			idx_t result_offset = 0;
+			if (read_position < buffer_size) {
+				// we need to read from our cached buffer
+				auto buffer_read_count = MinValue<idx_t>(nr_bytes, buffer_size - read_position);
+				memcpy(buffer, cached_buffer.get() + read_position, buffer_read_count);
+				result_offset += buffer_read_count;
+				read_position += buffer_read_count;
+				if (result_offset == nr_bytes) {
+					return nr_bytes;
+				}
+			} else if (!reset_enabled && cached_buffer) {
+				// reset is disabled but we still have cached data
+				// we can remove any cached data
+				cached_buffer.reset();
+				buffer_size = 0;
+				buffer_capacity = 0;
+				read_position = 0;
+			}
+			// we have data left to read from the file
+			// read directly into the buffer
+			auto bytes_read = file_handle->Read((char *)buffer + result_offset, nr_bytes - result_offset);
+			read_position += bytes_read;
+			if (reset_enabled) {
+				// if reset caching is enabled, we need to cache the bytes that we have read
+				if (buffer_size + bytes_read >= buffer_capacity) {
+					// no space; first enlarge the buffer
+					buffer_capacity = MaxValue<idx_t>(NextPowerOfTwo(buffer_size + bytes_read), buffer_capacity * 2);
+
+					auto new_buffer = unique_ptr<data_t[]>(new data_t[buffer_capacity]);
+					if (buffer_size > 0) {
+						memcpy(new_buffer.get(), cached_buffer.get(), buffer_size);
+					}
+					cached_buffer = move(new_buffer);
+				}
+				memcpy(cached_buffer.get() + buffer_size, (char *)buffer + result_offset, bytes_read);
+				buffer_size += bytes_read;
+			}
+
+			return result_offset + bytes_read;
+		} else {
+			return file_handle->Read(buffer, nr_bytes);
+		}
+	}
+
+	string ReadLine() {
+		string result;
+		char buffer[1];
+		while (true) {
+			idx_t tuples_read = Read(buffer, 1);
+			if (tuples_read == 0 || buffer[0] == '\n') {
+				return result;
+			}
+			if (buffer[0] != '\r') {
+				result += buffer[0];
+			}
+		}
+	}
+
+	void DisableReset() {
+		this->reset_enabled = false;
+	}
+
+private:
+	unique_ptr<FileHandle> file_handle;
+	bool reset_enabled = true;
+	bool can_seek = false;
+	bool plain_file_source = false;
+	idx_t file_size = 0;
+	// reset support
+	unique_ptr<data_t[]> cached_buffer;
+	idx_t read_position = 0;
+	idx_t buffer_size = 0;
+	idx_t buffer_capacity = 0;
+};
+
 void BufferedCSVReaderOptions::SetDelimiter(const string &input) {
 	this->delimiter = StringUtil::Replace(input, "\\t", "\t");
 	this->has_delimiter = true;
@@ -56749,6 +56877,13 @@ BufferedCSVReader::BufferedCSVReader(ClientContext &context, BufferedCSVReaderOp
                         requested_types) {
 }
 
+BufferedCSVReader::~BufferedCSVReader() {
+}
+
+idx_t BufferedCSVReader::GetFileSize() {
+	return file_handle ? file_handle->FileSize() : 0;
+}
+
 void BufferedCSVReader::Initialize(const vector<LogicalType> &requested_types) {
 	PrepareComplexParser();
 	if (options.auto_detect) {
@@ -56765,6 +56900,9 @@ void BufferedCSVReader::Initialize(const vector<LogicalType> &requested_types) {
 		SkipRowsAndReadHeader(options.skip_rows, options.header);
 	}
 	InitParseChunk(sql_types.size());
+	// we only need reset support during the automatic CSV type detection
+	// since reset support might require caching (in the case of streams), we disable it for the remainder
+	file_handle->DisableReset();
 }
 
 void BufferedCSVReader::PrepareComplexParser() {
@@ -56773,12 +56911,10 @@ void BufferedCSVReader::PrepareComplexParser() {
 	quote_search = TextSearchShiftArray(options.quote);
 }
 
-unique_ptr<FileHandle> BufferedCSVReader::OpenCSV(const BufferedCSVReaderOptions &options) {
-	auto result = fs.OpenFile(options.file_path.c_str(), FileFlags::FILE_FLAGS_READ, FileLockType::NO_LOCK,
-	                          options.compression, this->opener);
-	plain_file_source = result->OnDiskFile() && result->CanSeek();
-	file_size = result->GetFileSize();
-	return result;
+unique_ptr<CSVFileHandle> BufferedCSVReader::OpenCSV(const BufferedCSVReaderOptions &options) {
+	auto file_handle = fs.OpenFile(options.file_path.c_str(), FileFlags::FILE_FLAGS_READ, FileLockType::NO_LOCK,
+	                               options.compression, this->opener);
+	return make_unique<CSVFileHandle>(move(file_handle));
 }
 
 // Helper function to generate column names
@@ -56944,7 +57080,7 @@ bool BufferedCSVReader::JumpToNextSample() {
 	// assess if it makes sense to jump, based on size of the first chunk relative to size of the entire file
 	if (sample_chunk_idx == 0) {
 		idx_t bytes_first_chunk = bytes_in_chunk;
-		double chunks_fit = (file_size / (double)bytes_first_chunk);
+		double chunks_fit = (file_handle->FileSize() / (double)bytes_first_chunk);
 		jumping_samples = chunks_fit >= options.sample_chunks;
 
 		// jump back to the beginning
@@ -56959,7 +57095,7 @@ bool BufferedCSVReader::JumpToNextSample() {
 
 	// if we deal with any other sources than plaintext files, jumping_samples can be tricky. In that case
 	// we just read x continuous chunks from the stream TODO: make jumps possible for zipfiles.
-	if (!plain_file_source || !jumping_samples) {
+	if (!file_handle->PlainFileSource() || !jumping_samples) {
 		sample_chunk_idx++;
 		return true;
 	}
@@ -56969,13 +57105,13 @@ bool BufferedCSVReader::JumpToNextSample() {
 	bytes_per_line_avg = ((bytes_per_line_avg * (sample_chunk_idx)) + bytes_per_line) / (sample_chunk_idx + 1);
 
 	// if none of the previous conditions were met, we can jump
-	idx_t partition_size = (idx_t)round(file_size / (double)options.sample_chunks);
+	idx_t partition_size = (idx_t)round(file_handle->FileSize() / (double)options.sample_chunks);
 
 	// calculate offset to end of the current partition
 	int64_t offset = partition_size - bytes_in_chunk - remaining_bytes_in_buffer;
 	auto current_pos = file_handle->SeekPosition();
 
-	if (current_pos + offset < file_size) {
+	if (current_pos + offset < file_handle->FileSize()) {
 		// set position in stream and clear failure bits
 		file_handle->Seek(current_pos + offset);
 
@@ -56986,10 +57122,10 @@ bool BufferedCSVReader::JumpToNextSample() {
 		// seek backwards from the end in last chunk and hope to catch the end of the file
 		// TODO: actually it would be good to make sure that the end of file is being reached, because
 		// messy end-lines are quite common. For this case, however, we first need a skip_end detection anyways.
-		file_handle->Seek(file_size - bytes_in_chunk);
+		file_handle->Seek(file_handle->FileSize() - bytes_in_chunk);
 
 		// estimate linenr
-		linenr = (idx_t)round((file_size - bytes_in_chunk) / bytes_per_line_avg);
+		linenr = (idx_t)round((file_handle->FileSize() - bytes_in_chunk) / bytes_per_line_avg);
 		linenr_estimated = true;
 	}
 
@@ -57143,6 +57279,7 @@ void BufferedCSVReader::DetectDialect(const vector<LogicalType> &requested_types
 
 					JumpToBeginning(original_options.skip_rows);
 					sniffed_column_counts.clear();
+
 					if (!TryParseCSV(ParserMode::SNIFFING_DIALECT)) {
 						continue;
 					}
@@ -72253,7 +72390,7 @@ namespace duckdb {
 struct VariableReturnBindData : public FunctionData {
 	LogicalType stype;
 
-	explicit VariableReturnBindData(LogicalType stype) : stype(stype) {
+	explicit VariableReturnBindData(const LogicalType &stype_p) : stype(stype_p) {
 	}
 
 	unique_ptr<FunctionData> Copy() override {
@@ -73604,9 +73741,13 @@ static int64_t TargetTypeCost(const LogicalType &type) {
 	case LogicalTypeId::TIMESTAMP:
 		return 120;
 	case LogicalTypeId::VARCHAR:
-		return 199;
+		return 149;
 	case LogicalTypeId::DECIMAL:
 		return 104;
+	case LogicalTypeId::STRUCT:
+	case LogicalTypeId::MAP:
+	case LogicalTypeId::LIST:
+		return 160;
 	default:
 		return 110;
 	}
@@ -75503,6 +75644,10 @@ void DateDiffFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+
+
+
+
 namespace duckdb {
 
 bool TryGetDatePartSpecifier(const string &specifier_p, DatePartSpecifier &result) {
@@ -75569,6 +75714,73 @@ DatePartSpecifier GetDatePartSpecifier(const string &specifier) {
 	return result;
 }
 
+DatePartSpecifier GetDateTypePartSpecifier(const string &specifier, LogicalType &type) {
+	const auto part = GetDatePartSpecifier(specifier);
+	switch (type.id()) {
+	case LogicalType::TIMESTAMP:
+	case LogicalType::TIMESTAMP_TZ:
+		return part;
+	case LogicalType::DATE:
+		switch (part) {
+		case DatePartSpecifier::YEAR:
+		case DatePartSpecifier::MONTH:
+		case DatePartSpecifier::DAY:
+		case DatePartSpecifier::DECADE:
+		case DatePartSpecifier::CENTURY:
+		case DatePartSpecifier::MILLENNIUM:
+		case DatePartSpecifier::DOW:
+		case DatePartSpecifier::ISODOW:
+		case DatePartSpecifier::WEEK:
+		case DatePartSpecifier::QUARTER:
+		case DatePartSpecifier::DOY:
+		case DatePartSpecifier::YEARWEEK:
+		case DatePartSpecifier::ERA:
+			return part;
+		default:
+			break;
+		}
+		break;
+	case LogicalType::TIME:
+		switch (part) {
+		case DatePartSpecifier::MICROSECONDS:
+		case DatePartSpecifier::MILLISECONDS:
+		case DatePartSpecifier::SECOND:
+		case DatePartSpecifier::MINUTE:
+		case DatePartSpecifier::HOUR:
+		case DatePartSpecifier::EPOCH:
+		case DatePartSpecifier::OFFSET:
+			return part;
+		default:
+			break;
+		}
+		break;
+	case LogicalType::INTERVAL:
+		switch (part) {
+		case DatePartSpecifier::YEAR:
+		case DatePartSpecifier::MONTH:
+		case DatePartSpecifier::DAY:
+		case DatePartSpecifier::DECADE:
+		case DatePartSpecifier::CENTURY:
+		case DatePartSpecifier::QUARTER:
+		case DatePartSpecifier::MILLENNIUM:
+		case DatePartSpecifier::MICROSECONDS:
+		case DatePartSpecifier::MILLISECONDS:
+		case DatePartSpecifier::SECOND:
+		case DatePartSpecifier::MINUTE:
+		case DatePartSpecifier::HOUR:
+		case DatePartSpecifier::EPOCH:
+			return part;
+		default:
+			break;
+		}
+		break;
+	default:
+		break;
+	}
+
+	throw NotImplementedException("\"%s\" units \"%s\" not recognized", LogicalTypeIdToString(type.id()), specifier);
+}
+
 template <class T>
 static void LastYearFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	int32_t last_year = 0;
@@ -75902,6 +76114,137 @@ struct DatePart {
 			return PropagateSimpleDatePartStatistics<0, 0>(child_stats);
 		}
 	};
+
+	struct StructOperator {
+		using part_codes_t = vector<DatePartSpecifier>;
+		using part_mask_t = uint64_t;
+
+		enum MaskBits : uint8_t {
+			YMD = 1 << 0,
+			DOW = 1 << 1,
+			DOY = 1 << 2,
+			EPOCH = 1 << 3,
+			TIME = 1 << 4,
+			ZONE = 1 << 5
+		};
+
+		static part_mask_t GetMask(const part_codes_t &part_codes) {
+			part_mask_t mask = 0;
+			for (const auto &part_code : part_codes) {
+				switch (part_code) {
+				case DatePartSpecifier::YEAR:
+				case DatePartSpecifier::MONTH:
+				case DatePartSpecifier::DAY:
+				case DatePartSpecifier::DECADE:
+				case DatePartSpecifier::CENTURY:
+				case DatePartSpecifier::MILLENNIUM:
+				case DatePartSpecifier::QUARTER:
+				case DatePartSpecifier::ERA:
+					mask |= YMD;
+					break;
+				case DatePartSpecifier::YEARWEEK:
+					mask |= YMD;
+					mask |= DOW;
+					break;
+				case DatePartSpecifier::DOW:
+				case DatePartSpecifier::ISODOW:
+				case DatePartSpecifier::WEEK:
+					mask |= DOW;
+					break;
+				case DatePartSpecifier::DOY:
+					mask |= DOY;
+					break;
+				case DatePartSpecifier::EPOCH:
+					mask |= EPOCH;
+					break;
+				case DatePartSpecifier::MICROSECONDS:
+				case DatePartSpecifier::MILLISECONDS:
+				case DatePartSpecifier::SECOND:
+				case DatePartSpecifier::MINUTE:
+				case DatePartSpecifier::HOUR:
+					mask |= TIME;
+					break;
+				case DatePartSpecifier::OFFSET:
+					mask |= ZONE;
+					break;
+				}
+			}
+			return mask;
+		}
+
+		template <typename P>
+		static inline P HasPartValue(P *part_values, DatePartSpecifier part) {
+			return part_values[int(part)];
+		}
+
+		template <class TA, class TR>
+		static inline void Operation(TR **part_values, const TA &input, const idx_t idx, const part_mask_t mask) {
+			TR *part_data;
+			// YMD calculations
+			int32_t yyyy = 1970;
+			int32_t mm = 0;
+			int32_t dd = 1;
+			if (mask & YMD) {
+				Date::Convert(input, yyyy, mm, dd);
+				if ((part_data = HasPartValue(part_values, DatePartSpecifier::YEAR))) {
+					part_data[idx] = yyyy;
+				}
+				if ((part_data = HasPartValue(part_values, DatePartSpecifier::MONTH))) {
+					part_data[idx] = mm;
+				}
+				if ((part_data = HasPartValue(part_values, DatePartSpecifier::DAY))) {
+					part_data[idx] = dd;
+				}
+				if ((part_data = HasPartValue(part_values, DatePartSpecifier::DECADE))) {
+					part_data[idx] = yyyy / 10;
+				}
+				if ((part_data = HasPartValue(part_values, DatePartSpecifier::CENTURY))) {
+					part_data[idx] = (yyyy - 1) / 100 + 1;
+				}
+				if ((part_data = HasPartValue(part_values, DatePartSpecifier::MILLENNIUM))) {
+					part_data[idx] = (yyyy - 1) / 1000 + 1;
+				}
+				if ((part_data = HasPartValue(part_values, DatePartSpecifier::QUARTER))) {
+					part_data[idx] = (mm - 1) / Interval::MONTHS_PER_QUARTER + 1;
+				}
+				if ((part_data = HasPartValue(part_values, DatePartSpecifier::ERA))) {
+					part_data[idx] = yyyy > 0 ? 1 : 0;
+				}
+			}
+
+			// Week calculations
+			int32_t isodow = 0;
+			int32_t ww = 0;
+			if (mask & DOW) {
+				isodow = Date::ExtractISODayOfTheWeek(input);
+				ww = Date::ExtractISOWeekNumber(input);
+				int32_t dow = isodow % 7;
+				if ((part_data = HasPartValue(part_values, DatePartSpecifier::DOW))) {
+					part_data[idx] = dow;
+				}
+				if ((part_data = HasPartValue(part_values, DatePartSpecifier::ISODOW))) {
+					part_data[idx] = isodow;
+				}
+				if ((part_data = HasPartValue(part_values, DatePartSpecifier::WEEK))) {
+					part_data[idx] = ww;
+				}
+				if ((part_data = HasPartValue(part_values, DatePartSpecifier::YEARWEEK))) {
+					part_data[idx] = yyyy * 100 + ww;
+				}
+			}
+
+			if (mask & EPOCH) {
+				if ((part_data = HasPartValue(part_values, DatePartSpecifier::EPOCH))) {
+					part_data[idx] = Date::Epoch(input);
+				}
+			}
+			if (mask & DOY) {
+				if ((part_data = HasPartValue(part_values, DatePartSpecifier::DOY))) {
+					part_data[idx] = Date::ExtractDayOfTheYear(input);
+				}
+			}
+		}
+	};
 };
 
 template <>
@@ -76198,7 +76541,7 @@ int64_t DatePart::OffsetOperator::Operation(timestamp_t input) {
 
 template <>
 int64_t DatePart::OffsetOperator::Operation(interval_t input) {
-	return 0;
+	throw NotImplementedException("\"interval\" units \"offset\" not recognized");
 }
 
 template <>
@@ -76206,7 +76549,110 @@ int64_t DatePart::OffsetOperator::Operation(dtime_t input) {
 	return 0;
 }
 
-template <class T>
+template <>
+void DatePart::StructOperator::Operation(int64_t **part_values, const dtime_t &input, const idx_t idx,
+                                         const part_mask_t mask) {
+	int64_t *part_data;
+	if (mask & TIME) {
+		const auto micros = MicrosecondsOperator::Operation<dtime_t, int64_t>(input);
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MICROSECONDS))) {
+			part_data[idx] = micros;
+		}
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MILLISECONDS))) {
+			part_data[idx] = micros / Interval::MICROS_PER_MSEC;
+		}
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::SECOND))) {
+			part_data[idx] = micros / Interval::MICROS_PER_SEC;
+		}
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MINUTE))) {
+			part_data[idx] = MinutesOperator::Operation<dtime_t, int64_t>(input);
+		}
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::HOUR))) {
+			part_data[idx] = HoursOperator::Operation<dtime_t, int64_t>(input);
+		}
+	}
+
+	if (mask & EPOCH) {
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::EPOCH))) {
+			part_data[idx] = EpochOperator::Operation<dtime_t, int64_t>(input);
+			;
+		}
+	}
+
+	if (mask & ZONE) {
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::OFFSET))) {
+			part_data[idx] = 0;
+		}
+	}
+}
+
+template <>
+void DatePart::StructOperator::Operation(int64_t **part_values, const timestamp_t &input, const idx_t idx,
+                                         const part_mask_t mask) {
+	date_t d;
+	dtime_t t;
+	Timestamp::Convert(input, d, t);
+	// Time first because they both define epoch.
+	Operation(part_values, t, idx, mask);
+	Operation(part_values, d, idx, mask);
+}
+
+template <>
+void DatePart::StructOperator::Operation(int64_t **part_values, const interval_t &input, const idx_t idx,
+                                         const part_mask_t mask) {
+	int64_t *part_data;
+	if (mask & YMD) {
+		const auto mm = input.months % Interval::MONTHS_PER_YEAR;
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::YEAR))) {
+			part_data[idx] = input.months / Interval::MONTHS_PER_YEAR;
+		}
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MONTH))) {
+			part_data[idx] = mm;
+		}
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::DAY))) {
+			part_data[idx] = input.days;
+		}
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::DECADE))) {
+			part_data[idx] = input.months / Interval::MONTHS_PER_DECADE;
+		}
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::CENTURY))) {
+			part_data[idx] = input.months / Interval::MONTHS_PER_CENTURY;
+		}
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MILLENNIUM))) {
+			part_data[idx] = input.months / Interval::MONTHS_PER_MILLENIUM;
+		}
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::QUARTER))) {
+			part_data[idx] = mm / Interval::MONTHS_PER_QUARTER + 1;
+		}
+	}
+
+	if (mask & TIME) {
+		const auto micros = MicrosecondsOperator::Operation<interval_t, int64_t>(input);
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MICROSECONDS))) {
+			part_data[idx] = micros;
+		}
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MILLISECONDS))) {
+			part_data[idx] = micros / Interval::MICROS_PER_MSEC;
+		}
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::SECOND))) {
+			part_data[idx] = micros / Interval::MICROS_PER_SEC;
+		}
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::MINUTE))) {
+			part_data[idx] = MinutesOperator::Operation<interval_t, int64_t>(input);
+		}
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::HOUR))) {
+			part_data[idx] = HoursOperator::Operation<interval_t, int64_t>(input);
+		}
+	}
+
+	if (mask & EPOCH) {
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::EPOCH))) {
+			part_data[idx] = EpochOperator::Operation<interval_t, int64_t>(input);
+		}
+	}
+}
+
+template <typename T>
 static int64_t ExtractElement(DatePartSpecifier type, T element) {
 	switch (type) {
 	case DatePartSpecifier::YEAR:
@@ -76346,6 +76792,164 @@ struct DayNameOperator {
 	}
 };
 
+struct StructDatePart {
+	using part_codes_t = vector<DatePartSpecifier>;
+
+	struct BindData : public VariableReturnBindData {
+		part_codes_t part_codes;
+
+		explicit BindData(const LogicalType &stype, const part_codes_t &part_codes_p)
+		    : VariableReturnBindData(stype), part_codes(part_codes_p) {
+		}
+
+		unique_ptr<FunctionData> Copy() override {
+			return make_unique<BindData>(stype, part_codes);
+		}
+	};
+
+	static unique_ptr<FunctionData> Bind(ClientContext &context, ScalarFunction &bound_function,
+	                                     vector<unique_ptr<Expression>> &arguments) {
+		// collect names and deconflict, construct return type
+		if (!arguments[0]->IsFoldable()) {
+			throw BinderException("%s can only take constant lists of part names", bound_function.name);
+		}
+
+		case_insensitive_set_t name_collision_set;
+		child_list_t<LogicalType> struct_children;
+		part_codes_t part_codes;
+
+		Value parts_list = ExpressionExecutor::EvaluateScalar(*arguments[0]);
+		if (parts_list.type().id() == LogicalTypeId::LIST) {
+			if (parts_list.list_value.empty()) {
+				throw BinderException("%s requires non-empty lists of part names", bound_function.name);
+			}
+			for (const auto &part_value : parts_list.list_value) {
+				if (part_value.is_null) {
+					throw BinderException("NULL struct entry name in %s", bound_function.name);
+				}
+				const auto part_name = part_value.ToString();
+				const auto part_code = GetDateTypePartSpecifier(part_name, arguments[1]->return_type);
+				if (name_collision_set.find(part_name) != name_collision_set.end()) {
+					throw BinderException("Duplicate struct entry name \"%s\" in %s", part_name, bound_function.name);
+				}
+				name_collision_set.insert(part_name);
+				part_codes.emplace_back(part_code);
+				struct_children.emplace_back(make_pair(part_name, LogicalType::BIGINT));
+			}
+		} else {
+			throw BinderException("%s can only take constant lists of part names", bound_function.name);
+		}
+
+		arguments.erase(arguments.begin());
+		bound_function.arguments.erase(bound_function.arguments.begin());
+		bound_function.return_type = LogicalType::STRUCT(move(struct_children));
+		return make_unique<BindData>(bound_function.return_type, part_codes);
+	}
+
+	template <typename INPUT_TYPE>
+	static void Function(DataChunk &args, ExpressionState &state, Vector &result) {
+		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &info = (BindData &)*func_expr.bind_info;
+		D_ASSERT(args.ColumnCount() == 1);
+
+		const auto count = args.size();
+		Vector &input = args.data[0];
+		vector<int64_t *> part_values(int(DatePartSpecifier::OFFSET) + 1, nullptr);
+		const auto part_mask = DatePart::StructOperator::GetMask(info.part_codes);
+
+		auto &child_entries = StructVector::GetEntries(result);
+
+		// The first computer of a part "owns" it
+		// and other requestors just reference the owner
+		vector<size_t> owners(int(DatePartSpecifier::OFFSET) + 1, child_entries.size());
+		for (size_t col = 0; col < child_entries.size(); ++col) {
+			const auto part_index = size_t(info.part_codes[col]);
+			if (owners[part_index] == child_entries.size()) {
+				owners[part_index] = col;
+			}
+		}
+
+		if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
+			result.SetVectorType(VectorType::CONSTANT_VECTOR);
+
+			if (ConstantVector::IsNull(input)) {
+				ConstantVector::SetNull(result, true);
+			} else {
+				ConstantVector::SetNull(result, false);
+				for (size_t col = 0; col < child_entries.size(); ++col) {
+					auto &child_entry = child_entries[col];
+					ConstantVector::SetNull(*child_entry, false);
+					const auto part_index = size_t(info.part_codes[col]);
+					if (owners[part_index] == col) {
+						part_values[part_index] = ConstantVector::GetData<int64_t>(*child_entry);
+					}
+				}
+				auto tdata = ConstantVector::GetData<INPUT_TYPE>(input);
+				DatePart::StructOperator::Operation(part_values.data(), tdata[0], 0, part_mask);
+			}
+		} else {
+			VectorData rdata;
+			input.Orrify(count, rdata);
+
+			const auto &arg_valid = rdata.validity;
+			auto tdata = (const INPUT_TYPE *)rdata.data;
+
+			// Start with a valid flat vector
+			result.SetVectorType(VectorType::FLAT_VECTOR);
+			auto &res_valid = FlatVector::Validity(result);
+			if (res_valid.GetData()) {
+				res_valid.SetAllValid(count);
+			}
+
+			// Start with valid children
+			for (size_t col = 0; col < child_entries.size(); ++col) {
+				auto &child_entry = child_entries[col];
+				child_entry->SetVectorType(VectorType::FLAT_VECTOR);
+				auto &child_validity = FlatVector::Validity(*child_entry);
+				if (child_validity.GetData()) {
+					child_validity.SetAllValid(count);
+				}
+
+				// Pre-multiplex
+				const auto part_index = size_t(info.part_codes[col]);
+				if (owners[part_index] == col) {
+					part_values[part_index] = FlatVector::GetData<int64_t>(*child_entry);
+				}
+			}
+
+			for (idx_t i = 0; i < count; ++i) {
+				const auto idx = rdata.sel->get_index(i);
+				if (arg_valid.RowIsValid(idx)) {
+					DatePart::StructOperator::Operation(part_values.data(), tdata[idx], idx, part_mask);
+				} else {
+					res_valid.SetInvalid(idx);
+					for (auto &child_entry : child_entries) {
+						FlatVector::Validity(*child_entry).SetInvalid(idx);
+					}
+				}
+			}
+		}
+
+		// Reference any duplicate parts
+		for (size_t col = 0; col < child_entries.size(); ++col) {
+			const auto part_index = size_t(info.part_codes[col]);
+			const auto owner = owners[part_index];
+			if (owner != col) {
+				child_entries[col]->Reference(*child_entries[owner]);
+			}
+		}
+
+		result.Verify(count);
+	}
+
+	template <typename INPUT_TYPE>
+	static ScalarFunction GetFunction(const LogicalType &temporal_type) {
+		auto part_type = LogicalType::LIST(LogicalType::VARCHAR);
+		auto result_type = LogicalType::STRUCT({});
+		return ScalarFunction({part_type, temporal_type}, result_type, Function<INPUT_TYPE>, false, Bind);
+	}
+};
+
 void DatePartFun::RegisterFunction(BuiltinFunctions &set) {
 	// register the individual operators
 	AddGenericDatePartOperator(set, "year", LastYearFunction<date_t>, LastYearFunction<timestamp_t>,
@@ -76412,6 +77016,13 @@ void DatePartFun::RegisterFunction(BuiltinFunctions &set) {
 	    ScalarFunction({LogicalType::VARCHAR, LogicalType::TIME}, LogicalType::BIGINT, DatePartFunction<dtime_t>));
 	date_part.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::INTERVAL}, LogicalType::BIGINT,
 	                                     DatePartFunction<interval_t>));
+
+	// struct variants
+	date_part.AddFunction(StructDatePart::GetFunction<date_t>(LogicalType::DATE));
+	date_part.AddFunction(StructDatePart::GetFunction<timestamp_t>(LogicalType::TIMESTAMP));
+	date_part.AddFunction(StructDatePart::GetFunction<dtime_t>(LogicalType::TIME));
+	date_part.AddFunction(StructDatePart::GetFunction<interval_t>(LogicalType::INTERVAL));
+
 	set.AddFunction(date_part);
 	date_part.name = "datepart";
 	set.AddFunction(date_part);
@@ -91542,7 +92153,7 @@ static unique_ptr<FunctionOperatorData> ReadCSVInit(ClientContext &context, cons
 		result->csv_reader = make_unique<BufferedCSVReader>(context, bind_data.options, bind_data.sql_types);
 	}
 	bind_data.bytes_read = 0;
-	bind_data.file_size = result->csv_reader->file_size;
+	bind_data.file_size = result->csv_reader->GetFileSize();
 	result->file_index = 1;
 	return move(result);
 }