duckdb 0.5.2-dev1579.0 → 0.5.2-dev1610.0

package/src/duckdb.cpp

@@ -9200,7 +9200,7 @@ void BoxRenderer::Render(ClientContext &context, const vector<string> &names, co
 
 	// for each column, figure out the width
 	// start off by figuring out the name of the header by looking at the column name and column type
-	idx_t min_width = has_hidden_rows ? minimum_row_length : 0;
+	idx_t min_width = has_hidden_rows || row_count == 0 ? minimum_row_length : 0;
 	vector<idx_t> column_map;
 	idx_t total_length;
 	auto widths = ComputeRenderWidths(names, result, collections, min_width, max_width, column_map, total_length);
@@ -52186,6 +52186,15 @@ idx_t ListVector::GetListSize(const Vector &vec) {
 	return ((VectorListBuffer &)*vec.auxiliary).size;
 }
 
+idx_t ListVector::GetListCapacity(const Vector &vec) {
+	if (vec.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
+		auto &child = DictionaryVector::Child(vec);
+		return ListVector::GetListSize(child);
+	}
+	D_ASSERT(vec.auxiliary);
+	return ((VectorListBuffer &)*vec.auxiliary).capacity;
+}
+
 void ListVector::ReferenceEntry(Vector &vector, Vector &other) {
 	D_ASSERT(vector.GetType().id() == LogicalTypeId::LIST);
 	D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR ||
@@ -98646,6 +98655,7 @@ struct HandleVectorCastError {
 
 
 
+
 namespace duckdb {
 
 template <class OP>
@@ -98829,9 +98839,20 @@ struct VectorCastHelpers {
 	}
 };
 
-struct VectorStringifiedListParser {
+struct VectorStringToList {
 	static idx_t CountParts(const string_t &input);
 	static bool SplitStringifiedList(const string_t &input, string_t *child_data, idx_t &child_start, Vector &child);
+	static bool StringToNestedTypeCastLoop(string_t *source_data, ValidityMask &source_mask, Vector &result,
+	                                       ValidityMask &result_mask, idx_t count, CastParameters &parameters,
+	                                       const SelectionVector *sel);
+};
+
+struct VectorStringToStruct {
+	static bool SplitStruct(string_t &input, std::vector<std::unique_ptr<Vector>> &varchar_vectors, idx_t &row_idx,
+	                        string_map_t<idx_t> &child_names, std::vector<ValidityMask *> &child_masks);
+	static bool StringToNestedTypeCastLoop(string_t *source_data, ValidityMask &source_mask, Vector &result,
+	                                       ValidityMask &result_mask, idx_t count, CastParameters &parameters,
+	                                       const SelectionVector *sel);
 };
 
 } // namespace duckdb
@@ -99956,6 +99977,8 @@ BoundCastInfo DefaultCasts::PointerCastSwitch(BindCastInput &input, const Logica
 
 
 
+
+
 namespace duckdb {
 
 template <class T>
@@ -100067,8 +100090,9 @@ static BoundCastInfo VectorStringCastNumericSwitch(BindCastInput &input, const L
 	}
 }
 
-bool StringListCastLoop(string_t *source_data, ValidityMask &source_mask, Vector &result, ValidityMask &result_mask,
-                        idx_t count, CastParameters &parameters, const SelectionVector *sel) {
+bool VectorStringToList::StringToNestedTypeCastLoop(string_t *source_data, ValidityMask &source_mask, Vector &result,
+                                                    ValidityMask &result_mask, idx_t count, CastParameters &parameters,
+                                                    const SelectionVector *sel) {
 
 	idx_t total_list_size = 0;
 	for (idx_t i = 0; i < count; i++) {
@@ -100079,7 +100103,7 @@ bool StringListCastLoop(string_t *source_data, ValidityMask &source_mask, Vector
 		if (!source_mask.RowIsValid(idx)) {
 			continue;
 		}
-		total_list_size += VectorStringifiedListParser::CountParts(source_data[idx]);
+		total_list_size += VectorStringToList::CountParts(source_data[idx]);
 	}
 
 	Vector varchar_vector(LogicalType::VARCHAR, total_list_size);
@@ -100103,9 +100127,7 @@ bool StringListCastLoop(string_t *source_data, ValidityMask &source_mask, Vector
 		}
 
 		list_data[i].offset = total;
-		auto valid =
-		    VectorStringifiedListParser::SplitStringifiedList(source_data[idx], child_data, total, varchar_vector);
-		if (!valid) {
+		if (!VectorStringToList::SplitStringifiedList(source_data[idx], child_data, total, varchar_vector)) {
 			string text = "Type VARCHAR with value '" + source_data[idx].GetString() +
 			              "' can't be cast to the destination type LIST";
 			HandleVectorCastError::Operation<string_t>(text, result_mask, idx, parameters.error_message, all_converted);
@@ -100121,23 +100143,85 @@ bool StringListCastLoop(string_t *source_data, ValidityMask &source_mask, Vector
 	       all_converted;
 }
 
-bool StringListCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
+static LogicalType InitVarcharStructType(const LogicalType &target) {
+	child_list_t<LogicalType> child_types;
+	for (auto &child : StructType::GetChildTypes(target)) {
+		child_types.push_back(make_pair(child.first, LogicalType::VARCHAR));
+	}
+
+	return LogicalType::STRUCT(child_types);
+}
+
+bool VectorStringToStruct::StringToNestedTypeCastLoop(string_t *source_data, ValidityMask &source_mask, Vector &result,
+                                                      ValidityMask &result_mask, idx_t count,
+                                                      CastParameters &parameters, const SelectionVector *sel) {
+
+	auto varchar_struct_type = InitVarcharStructType(result.GetType());
+	Vector varchar_vector(varchar_struct_type, count);
+	auto &child_vectors = StructVector::GetEntries(varchar_vector);
+	auto &result_children = StructVector::GetEntries(result);
+
+	string_map_t<idx_t> child_names;
+	vector<ValidityMask *> child_masks;
+	for (idx_t child_idx = 0; child_idx < result_children.size(); child_idx++) {
+		child_names.insert({StructType::GetChildName(result.GetType(), child_idx), child_idx});
+		child_masks.emplace_back(&FlatVector::Validity(*child_vectors[child_idx]));
+		child_masks[child_idx]->SetAllInvalid(count);
+	}
+
+	bool all_converted = true;
+	for (idx_t i = 0; i < count; i++) {
+		idx_t idx = i;
+		if (sel) {
+			idx = sel->get_index(i);
+		}
+		if (!source_mask.RowIsValid(idx)) {
+			result_mask.SetInvalid(i);
+			continue;
+		}
+		if (!VectorStringToStruct::SplitStruct(source_data[idx], child_vectors, i, child_names, child_masks)) {
+			string text = "Type VARCHAR with value '" + source_data[idx].GetString() +
+			              "' can't be cast to the destination type STRUCT";
+			for (auto &child_mask : child_masks) {
+				child_mask->SetInvalid(idx); // some values may have already been found and set valid
+			}
+			HandleVectorCastError::Operation<string_t>(text, result_mask, idx, parameters.error_message, all_converted);
+		}
+	}
+
+	auto &cast_data = (StructBoundCastData &)*parameters.cast_data;
+	D_ASSERT(cast_data.child_cast_info.size() == result_children.size());
+
+	for (idx_t child_idx = 0; child_idx < result_children.size(); child_idx++) {
+		auto &varchar_vector = *child_vectors[child_idx];
+		auto &result_child_vector = *result_children[child_idx];
+		auto &child_cast_info = cast_data.child_cast_info[child_idx];
+		// get the correct casting function (VARCHAR -> result_child_type) from cast_data
+		// casting functions are determined by BindStructtoStructCast
+		CastParameters child_parameters(parameters, child_cast_info.cast_data.get());
+		if (!child_cast_info.function(varchar_vector, result_child_vector, count, child_parameters)) {
+			all_converted = false;
+		}
+	}
+	return all_converted;
+}
+
+template <class T>
+bool StringToNestedTypeCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	D_ASSERT(source.GetType().id() == LogicalTypeId::VARCHAR);
-	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
 
 	switch (source.GetVectorType()) {
 	case VectorType::CONSTANT_VECTOR: {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-
 		auto source_data = ConstantVector::GetData<string_t>(source);
 		auto &source_mask = ConstantVector::Validity(source);
-		auto &result_mask = ConstantVector::Validity(result);
+		auto &result_mask = FlatVector::Validity(result);
 
-		return StringListCastLoop(source_data, source_mask, result, result_mask, 1, parameters, nullptr);
+		auto ret = T::StringToNestedTypeCastLoop(source_data, source_mask, result, result_mask, 1, parameters, nullptr);
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+		return ret;
 	}
 	default: {
 		UnifiedVectorFormat unified_source;
-		result.SetVectorType(VectorType::FLAT_VECTOR);
 
 		source.ToUnifiedFormat(count, unified_source);
 		auto source_sel = unified_source.sel;
@@ -100145,17 +100229,12 @@ bool StringListCast(Vector &source, Vector &result, idx_t count, CastParameters
 		auto &source_mask = unified_source.validity;
 		auto &result_mask = FlatVector::Validity(result);
 
-		return StringListCastLoop(source_data, source_mask, result, result_mask, count, parameters, source_sel);
+		return T::StringToNestedTypeCastLoop(source_data, source_mask, result, result_mask, count, parameters,
+		                                     source_sel);
 	}
 	}
 }
 
-BoundCastInfo StringToListCast(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
-	// second argument allows for a secondary casting function to be passed in the CastParameters
-	return BoundCastInfo(&StringListCast,
-	                     ListBoundCastData::BindListToListCast(input, LogicalType::LIST(LogicalType::VARCHAR), target));
-}
-
 BoundCastInfo DefaultCasts::StringCastSwitch(BindCastInput &input, const LogicalType &source,
                                              const LogicalType &target) {
 	switch (target.id()) {
@@ -100186,7 +100265,13 @@ BoundCastInfo DefaultCasts::StringCastSwitch(BindCastInput &input, const Logical
 	case LogicalTypeId::JSON:
 		return &DefaultCasts::ReinterpretCast;
 	case LogicalTypeId::LIST:
-		return StringToListCast(input, source, target);
+		// the second argument allows for a secondary casting function to be passed in the CastParameters
+		return BoundCastInfo(
+		    &StringToNestedTypeCast<VectorStringToList>,
+		    ListBoundCastData::BindListToListCast(input, LogicalType::LIST(LogicalType::VARCHAR), target));
+	case LogicalTypeId::STRUCT:
+		return BoundCastInfo(&StringToNestedTypeCast<VectorStringToStruct>,
+		                     StructBoundCastData::BindStructToStructCast(input, InitVarcharStructType(target), target));
 	default:
 		return VectorStringCastNumericSwitch(input, source, target);
 	}
@@ -100198,26 +100283,8 @@ BoundCastInfo DefaultCasts::StringCastSwitch(BindCastInput &input, const Logical
 
 namespace duckdb {
 
-struct StructBoundCastData : public BoundCastData {
-	StructBoundCastData(vector<BoundCastInfo> child_casts, LogicalType target_p)
-	    : child_cast_info(move(child_casts)), target(move(target_p)) {
-	}
-
-	vector<BoundCastInfo> child_cast_info;
-	LogicalType target;
-
-public:
-	unique_ptr<BoundCastData> Copy() const override {
-		vector<BoundCastInfo> copy_info;
-		for (auto &info : child_cast_info) {
-			copy_info.push_back(info.Copy());
-		}
-		return make_unique<StructBoundCastData>(move(copy_info), target);
-	}
-};
-
-unique_ptr<BoundCastData> BindStructToStructCast(BindCastInput &input, const LogicalType &source,
-                                                 const LogicalType &target) {
+unique_ptr<BoundCastData> StructBoundCastData::BindStructToStructCast(BindCastInput &input, const LogicalType &source,
+                                                                      const LogicalType &target) {
 	vector<BoundCastInfo> child_cast_info;
 	auto &source_child_types = StructType::GetChildTypes(source);
 	auto &result_child_types = StructType::GetChildTypes(target);
@@ -100238,13 +100305,14 @@ static bool StructToStructCast(Vector &source, Vector &result, idx_t count, Cast
 	D_ASSERT(source_children.size() == StructType::GetChildTypes(result.GetType()).size());
 
 	auto &result_children = StructVector::GetEntries(result);
+	bool all_converted = true;
 	for (idx_t c_idx = 0; c_idx < source_child_types.size(); c_idx++) {
 		auto &result_child_vector = *result_children[c_idx];
 		auto &source_child_vector = *source_children[c_idx];
 		CastParameters child_parameters(parameters, cast_data.child_cast_info[c_idx].cast_data.get());
 		if (!cast_data.child_cast_info[c_idx].function(source_child_vector, result_child_vector, count,
 		                                               child_parameters)) {
-			return false;
+			all_converted = false;
 		}
 	}
 	if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) {
@@ -100254,7 +100322,7 @@ static bool StructToStructCast(Vector &source, Vector &result, idx_t count, Cast
 		source.Flatten(count);
 		FlatVector::Validity(result) = FlatVector::Validity(source);
 	}
-	return true;
+	return all_converted;
 }
 
 static bool StructToVarcharCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
@@ -100333,7 +100401,7 @@ BoundCastInfo DefaultCasts::StructCastSwitch(BindCastInput &input, const Logical
                                              const LogicalType &target) {
 	switch (target.id()) {
 	case LogicalTypeId::STRUCT:
-		return BoundCastInfo(StructToStructCast, BindStructToStructCast(input, source, target));
+		return BoundCastInfo(StructToStructCast, StructBoundCastData::BindStructToStructCast(input, source, target));
 	case LogicalTypeId::JSON:
 	case LogicalTypeId::VARCHAR: {
 		// bind a cast in which we convert all child entries to VARCHAR entries
@@ -100343,7 +100411,8 @@ BoundCastInfo DefaultCasts::StructCastSwitch(BindCastInput &input, const Logical
 			varchar_children.push_back(make_pair(child_entry.first, LogicalType::VARCHAR));
 		}
 		auto varchar_type = LogicalType::STRUCT(move(varchar_children));
-		return BoundCastInfo(StructToVarcharCast, BindStructToStructCast(input, source, varchar_type));
+		return BoundCastInfo(StructToVarcharCast,
+		                     StructBoundCastData::BindStructToStructCast(input, source, varchar_type));
 	}
 	default:
 		return TryVectorNullCast;
@@ -100898,6 +100967,33 @@ BoundCastInfo DefaultCasts::UUIDCastSwitch(BindCastInput &input, const LogicalTy
 
 namespace duckdb {
 
+static bool IsNull(const char *buf, idx_t start_pos, Vector &child, idx_t row_idx) {
+	if (buf[start_pos] == 'N' && buf[start_pos + 1] == 'U' && buf[start_pos + 2] == 'L' && buf[start_pos + 3] == 'L') {
+		FlatVector::SetNull(child, row_idx, true);
+		return true;
+	}
+	return false;
+}
+
+inline static void SkipWhitespace(const char *buf, idx_t &pos, idx_t len) {
+	while (pos < len && StringUtil::CharacterIsSpace(buf[pos])) {
+		pos++;
+	}
+}
+
+static idx_t StringTrim(const char *buf, idx_t &start_pos, idx_t pos) {
+	idx_t trailing_whitespace = 0;
+	while (StringUtil::CharacterIsSpace(buf[pos - trailing_whitespace - 1])) {
+		trailing_whitespace++;
+	}
+	if ((buf[start_pos] == '"' && buf[pos - trailing_whitespace - 1] == '"') ||
+	    (buf[start_pos] == '\'' && buf[pos - trailing_whitespace - 1] == '\'')) {
+		start_pos++;
+		trailing_whitespace++;
+	}
+	return (pos - trailing_whitespace);
+}
+
 struct CountPartOperation {
 	idx_t count = 0;
 
@@ -100916,10 +101012,7 @@ struct SplitStringOperation {
 	Vector &child;
 
 	void HandleValue(const char *buf, idx_t start_pos, idx_t pos) {
-
-		if ((pos - start_pos) >= 4 && buf[start_pos] == 'N' && buf[start_pos + 1] == 'U' && buf[start_pos + 2] == 'L' &&
-		    buf[start_pos + 3] == 'L') {
-			FlatVector::SetNull(child, child_start, true);
+		if ((pos - start_pos) == 4 && IsNull(buf, start_pos, child, child_start)) {
 			child_start++;
 			return;
 		}
@@ -100941,20 +101034,27 @@ static bool SkipToCloseQuotes(idx_t &pos, const char *buf, idx_t &len) {
 	return false;
 }
 
-static bool SkipToClose(idx_t &idx, const char *buf, idx_t &len, idx_t &lvl) {
+static bool SkipToClose(idx_t &idx, const char *buf, idx_t &len, idx_t &lvl, char close_bracket) {
+	idx++;
+
 	while (idx < len) {
-		if (buf[idx] == '[') {
-			if (!SkipToClose(++idx, buf, len, lvl)) {
+		if (buf[idx] == '"' || buf[idx] == '\'') {
+			if (!SkipToCloseQuotes(idx, buf, len)) {
+				return false;
+			}
+		} else if (buf[idx] == '{') {
+			if (!SkipToClose(idx, buf, len, lvl, '}')) {
+				return false;
+			}
+		} else if (buf[idx] == '[') {
+			if (!SkipToClose(idx, buf, len, lvl, ']')) {
 				return false;
 			}
 			lvl++;
-			idx++;
-		}
-		if (buf[idx] == '"' || buf[idx] == '\'') {
-			SkipToCloseQuotes(idx, buf, len);
-		}
-		if (buf[idx] == ']') {
-			lvl--;
+		} else if (buf[idx] == close_bracket) {
+			if (close_bracket == ']') {
+				lvl--;
+			}
 			return true;
 		}
 		idx++;
@@ -100969,68 +101069,133 @@ static bool SplitStringifiedListInternal(const string_t &input, OP &state) {
 	idx_t lvl = 1;
 	idx_t pos = 0;
 
-	while (pos < len && StringUtil::CharacterIsSpace(buf[pos])) {
-		pos++;
-	}
+	SkipWhitespace(buf, pos, len);
 	if (pos == len || buf[pos] != '[') {
 		return false;
 	}
-	pos++;
-	while (pos < len && StringUtil::CharacterIsSpace(buf[pos])) {
-		pos++;
-	}
 
+	SkipWhitespace(buf, ++pos, len);
 	idx_t start_pos = pos;
 	while (pos < len) {
 		if (buf[pos] == '[') {
-			if (!SkipToClose(++pos, buf, len, ++lvl)) {
+			if (!SkipToClose(pos, buf, len, ++lvl, ']')) {
 				return false;
 			}
 		} else if (buf[pos] == '"' || buf[pos] == '\'') {
 			SkipToCloseQuotes(pos, buf, len);
+		} else if (buf[pos] == '{') {
+			idx_t struct_lvl = 0;
+			SkipToClose(pos, buf, len, struct_lvl, '}');
 		} else if (buf[pos] == ',' || buf[pos] == ']') {
 			idx_t trailing_whitespace = 0;
 			while (StringUtil::CharacterIsSpace(buf[pos - trailing_whitespace - 1])) {
 				trailing_whitespace++;
 			}
-			if (!(buf[pos] == ']' && start_pos == (pos))) {
+			if (!(buf[pos] == ']' && start_pos == pos)) {
 				state.HandleValue(buf, start_pos, pos - trailing_whitespace);
 			} // else the list is empty
 			if (buf[pos] == ']') {
 				lvl--;
 				break;
 			}
-			while (pos + 1 < len && StringUtil::CharacterIsSpace(buf[pos + 1])) {
-				pos++;
-			}
-			start_pos = pos + 1;
-		}
-		pos++;
-	}
-	pos++;
-	while (pos < len) {
-		if (!StringUtil::CharacterIsSpace(buf[pos])) {
-			return false;
+			SkipWhitespace(buf, ++pos, len);
+			start_pos = pos;
+			continue;
 		}
 		pos++;
 	}
-	if (lvl != 0) {
-		return false;
-	}
-	return true;
+	SkipWhitespace(buf, ++pos, len);
+	return (pos == len && lvl == 0);
 }
 
-bool VectorStringifiedListParser::SplitStringifiedList(const string_t &input, string_t *child_data, idx_t &child_start,
-                                                       Vector &child) {
+bool VectorStringToList::SplitStringifiedList(const string_t &input, string_t *child_data, idx_t &child_start,
+                                              Vector &child) {
 	SplitStringOperation state(child_data, child_start, child);
 	return SplitStringifiedListInternal<SplitStringOperation>(input, state);
 }
 
-idx_t VectorStringifiedListParser::CountParts(const string_t &input) {
+idx_t VectorStringToList::CountParts(const string_t &input) {
 	CountPartOperation state;
 	SplitStringifiedListInternal<CountPartOperation>(input, state);
 	return state.count;
 }
+
+static bool FindKey(const char *buf, idx_t len, idx_t &pos) {
+	while (pos < len) {
+		if (buf[pos] == ':') {
+			return true;
+		}
+		pos++;
+	}
+	return false;
+}
+
+static bool FindValue(const char *buf, idx_t len, idx_t &pos, Vector &varchar_child, idx_t &row_idx,
+                      ValidityMask *child_mask) {
+	auto start_pos = pos;
+	idx_t lvl = 0;
+	while (pos < len) {
+		if (buf[pos] == '"' || buf[pos] == '\'') {
+			SkipToCloseQuotes(pos, buf, len);
+		} else if (buf[pos] == '{') {
+			SkipToClose(pos, buf, len, lvl, '}');
+		} else if (buf[pos] == '[') {
+			SkipToClose(pos, buf, len, lvl, ']');
+		} else if (buf[pos] == ',' || buf[pos] == '}') {
+			idx_t end_pos = StringTrim(buf, start_pos, pos);
+			if ((end_pos - start_pos) == 4 && IsNull(buf, start_pos, varchar_child, row_idx)) {
+				return true;
+			}
+			FlatVector::GetData<string_t>(varchar_child)[row_idx] =
+			    StringVector::AddString(varchar_child, buf + start_pos, end_pos - start_pos);
+			child_mask->SetValid(row_idx); // any child not set to valid will remain invalid
+			return true;
+		}
+		pos++;
+	}
+	return false;
+}
+
+bool VectorStringToStruct::SplitStruct(string_t &input, std::vector<std::unique_ptr<Vector>> &varchar_vectors,
+                                       idx_t &row_idx, string_map_t<idx_t> &child_names,
+                                       std::vector<ValidityMask *> &child_masks) {
+	const char *buf = input.GetDataUnsafe();
+	idx_t len = input.GetSize();
+	idx_t pos = 0;
+	idx_t child_idx;
+
+	SkipWhitespace(buf, pos, len);
+	if (pos == len || buf[pos] != '{') {
+		return false;
+	}
+	SkipWhitespace(buf, ++pos, len);
+	if (buf[pos] == '}') {
+		pos++;
+	} else {
+		while (pos < len) {
+			auto key_start = pos;
+			if (!FindKey(buf, len, pos)) {
+				return false;
+			}
+			auto key_end = StringTrim(buf, key_start, pos);
+			string_t found_key(buf + key_start, key_end - key_start);
+
+			auto it = child_names.find(found_key);
+			if (it == child_names.end()) {
+				return false; // false key
+			}
+			child_idx = it->second;
+			SkipWhitespace(buf, ++pos, len);
+			if (!FindValue(buf, len, pos, *varchar_vectors[child_idx], row_idx, child_masks[child_idx])) {
+				return false;
+			}
+			SkipWhitespace(buf, ++pos, len);
+		}
+	}
+	SkipWhitespace(buf, pos, len);
+	return (pos == len);
+}
+
 } // namespace duckdb
 
 
@@ -118794,6 +118959,20 @@ struct RegexpExtractBindData : public RegexpBaseBindData {
 	bool Equals(const FunctionData &other_p) const override;
 };
 
+struct RegexLocalState : public FunctionLocalState {
+	explicit RegexLocalState(RegexpBaseBindData &info)
+	    : constant_pattern(duckdb_re2::StringPiece(info.constant_string.c_str(), info.constant_string.size()),
+	                       info.options) {
+		D_ASSERT(info.constant_pattern);
+	}
+
+	RE2 constant_pattern;
+};
+
+unique_ptr<FunctionLocalState> RegexInitLocalState(const BoundFunctionExpression &expr, FunctionData *bind_data);
+unique_ptr<FunctionData> RegexpMatchesBind(ClientContext &context, ScalarFunction &bound_function,
+                                           vector<unique_ptr<Expression>> &arguments);
+
 } // namespace duckdb
 
 
@@ -118833,18 +119012,7 @@ static inline duckdb_re2::StringPiece CreateStringPiece(string_t &input) {
 	return duckdb_re2::StringPiece(input.GetDataUnsafe(), input.GetSize());
 }
 
-struct RegexLocalState : public FunctionLocalState {
-	explicit RegexLocalState(RegexpBaseBindData &info)
-	    : constant_pattern(duckdb_re2::StringPiece(info.constant_string.c_str(), info.constant_string.size()),
-	                       info.options) {
-		D_ASSERT(info.constant_pattern);
-	}
-
-	RE2 constant_pattern;
-};
-
-static unique_ptr<FunctionLocalState> RegexInitLocalState(const BoundFunctionExpression &expr,
-                                                          FunctionData *bind_data) {
+unique_ptr<FunctionLocalState> RegexInitLocalState(const BoundFunctionExpression &expr, FunctionData *bind_data) {
 	auto &info = (RegexpBaseBindData &)*bind_data;
 	if (info.constant_pattern) {
 		return make_unique<RegexLocalState>(info);
@@ -118951,8 +119119,8 @@ unique_ptr<FunctionData> RegexpMatchesBindData::Copy() const {
 	                                          range_success);
 }
 
-static unique_ptr<FunctionData> RegexpMatchesBind(ClientContext &context, ScalarFunction &bound_function,
-                                                  vector<unique_ptr<Expression>> &arguments) {
+unique_ptr<FunctionData> RegexpMatchesBind(ClientContext &context, ScalarFunction &bound_function,
+                                           vector<unique_ptr<Expression>> &arguments) {
 	// pattern is the second argument. If its constant, we can already prepare the pattern and store it for later.
 	D_ASSERT(arguments.size() == 2 || arguments.size() == 3);
 	RE2::Options options;
@@ -119398,188 +119566,106 @@ void ReverseFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
-
-
-
 namespace duckdb {
 
-struct StringSplitIterator {
-public:
-	explicit StringSplitIterator(idx_t size) : size(size) {
-	}
-	virtual ~StringSplitIterator() {
+struct StringSplitInput {
+	StringSplitInput(Vector &result_list, Vector &result_child, idx_t offset)
+	    : result_list(result_list), result_child(result_child), offset(offset) {
 	}
 
-	idx_t size;
+	Vector &result_list;
+	Vector &result_child;
+	idx_t offset;
 
-public:
-	virtual idx_t Next(const char *input) = 0;
-	bool HasNext() {
-		return offset < size;
-	}
-	idx_t Start() {
-		return start;
+	void AddSplit(const char *split_data, idx_t split_size, idx_t list_idx) {
+		auto list_entry = offset + list_idx;
+		if (list_entry >= ListVector::GetListCapacity(result_list)) {
+			ListVector::SetListSize(result_list, offset + list_idx);
+			ListVector::Reserve(result_list, ListVector::GetListCapacity(result_list) * 2);
+		}
+		FlatVector::GetData<string_t>(result_child)[list_entry] =
+		    StringVector::AddString(result_child, split_data, split_size);
 	}
-
-protected:
-	idx_t start = 0;  // end of last place a delim match was found
-	idx_t offset = 0; // current position
 };
 
-struct AsciiStringSplitIterator : virtual public StringSplitIterator {
-public:
-	AsciiStringSplitIterator(size_t size, const char *delim, const size_t delim_size)
-	    : StringSplitIterator(size), delim(delim), delim_size(delim_size) {
-	}
-	idx_t Next(const char *input) override {
-		// special case: separate by empty delimiter
+struct RegularStringSplit {
+	static idx_t Find(const char *input_data, idx_t input_size, const char *delim_data, idx_t delim_size,
+	                  idx_t &match_size, void *data) {
+		match_size = delim_size;
 		if (delim_size == 0) {
-			offset++;
-			start = offset;
-			return offset;
-		}
-		for (offset = start; HasNext(); offset++) {
-			// potential delimiter match
-			if (input[offset] == delim[0] && offset + delim_size <= size) {
-				idx_t i;
-				for (i = 1; i < delim_size; i++) {
-					if (input[offset + i] != delim[i]) {
-						break;
-					}
-				}
-				// delimiter found: skip start over delimiter
-				if (i == delim_size) {
-					start = offset + delim_size;
-					return offset;
-				}
-			}
+			return 0;
 		}
-		return offset;
+		return ContainsFun::Find((const unsigned char *)input_data, input_size, (const unsigned char *)delim_data,
+		                         delim_size);
 	}
+};
 
-protected:
-	const char *delim;
-	size_t delim_size;
+struct ConstantRegexpStringSplit {
+	static idx_t Find(const char *input_data, idx_t input_size, const char *delim_data, idx_t delim_size,
+	                  idx_t &match_size, void *data) {
+		D_ASSERT(data);
+		auto regex = (duckdb_re2::RE2 *)data;
+		duckdb_re2::StringPiece match;
+		if (!regex->Match(duckdb_re2::StringPiece(input_data, input_size), 0, input_size, RE2::UNANCHORED, &match, 1)) {
+			return DConstants::INVALID_INDEX;
+		}
+		match_size = match.size();
+		return match.data() - input_data;
+	}
 };
 
-struct UnicodeStringSplitIterator : virtual public StringSplitIterator {
-public:
-	UnicodeStringSplitIterator(size_t input_size, const char *delim, const size_t delim_size)
-	    : StringSplitIterator(input_size), delim_size(delim_size) {
-		int cp_sz;
-		for (idx_t i = 0; i < delim_size; i += cp_sz) {
-			delim_cps.push_back(utf8proc_codepoint(delim, cp_sz));
+struct RegexpStringSplit {
+	static idx_t Find(const char *input_data, idx_t input_size, const char *delim_data, idx_t delim_size,
+	                  idx_t &match_size, void *data) {
+		duckdb_re2::RE2 regex(duckdb_re2::StringPiece(delim_data, delim_size));
+		if (!regex.ok()) {
+			throw InvalidInputException(regex.error());
 		}
+		return ConstantRegexpStringSplit::Find(input_data, input_size, delim_data, delim_size, match_size, &regex);
 	}
-	idx_t Next(const char *input) override {
-		// special case: separate by empty delimiter
-		if (delim_size == 0) {
-			offset = utf8proc_next_grapheme(input, size, offset);
-			start = offset;
-			return offset;
-		}
-		int cp_sz;
-		for (offset = start; HasNext(); offset = utf8proc_next_grapheme(input, size, offset)) {
-			// potential delimiter match
-			if (utf8proc_codepoint(&input[offset], cp_sz) == delim_cps[0] && offset + delim_size <= size) {
-				idx_t delim_offset = cp_sz;
-				for (idx_t i = 1; i < delim_cps.size(); i++) {
-					if (utf8proc_codepoint(&input[offset + delim_offset], cp_sz) != delim_cps[i]) {
+};
+
+struct StringSplitter {
+	template <class OP>
+	static idx_t Split(string_t input, string_t delim, StringSplitInput &state, void *data) {
+		auto input_data = input.GetDataUnsafe();
+		auto input_size = input.GetSize();
+		auto delim_data = delim.GetDataUnsafe();
+		auto delim_size = delim.GetSize();
+		idx_t list_idx = 0;
+		while (input_size > 0) {
+			idx_t match_size;
+			auto pos = OP::Find(input_data, input_size, delim_data, delim_size, match_size, data);
+			if (pos > input_size) {
+				break;
+			}
+			if (match_size == 0 && pos == 0) {
+				// special case: 0 length match and pos is 0
+				// move to the next character
+				for (pos++; pos < input_size; pos++) {
+					if (LengthFun::IsCharacter(input_data[pos])) {
 						break;
 					}
-					delim_offset += cp_sz;
 				}
-				// delimiter found: skip start over delimiter
-				if (delim_offset == delim_size) {
-					start = offset + delim_size;
-					return offset;
+				if (pos == input_size) {
+					break;
 				}
 			}
-		}
-		return offset;
-	}
-
-protected:
-	vector<utf8proc_int32_t> delim_cps;
-	size_t delim_size;
-};
+			D_ASSERT(input_size >= pos + match_size);
+			state.AddSplit(input_data, pos, list_idx);
 
-struct RegexStringSplitIterator : virtual public StringSplitIterator {
-public:
-	RegexStringSplitIterator(size_t input_size, unique_ptr<RE2> re, const bool ascii_only)
-	    : StringSplitIterator(input_size), re(move(re)), ascii_only(ascii_only) {
-	}
-	idx_t Next(const char *input) override {
-		duckdb_re2::StringPiece input_sp(input, size);
-		duckdb_re2::StringPiece match;
-		if (re->Match(input_sp, start, size, RE2::UNANCHORED, &match, 1)) {
-			offset = match.data() - input;
-			// special case: 0 length match
-			if (match.empty() && start < size) {
-				if (ascii_only) {
-					offset++;
-				} else {
-					offset = utf8proc_next_grapheme(input, size, offset);
-				}
-				start = offset;
-			} else {
-				start = offset + match.size();
-			}
-		} else {
-			offset = size;
+			list_idx++;
+			input_data += (pos + match_size);
+			input_size -= (pos + match_size);
 		}
-		return offset;
+		state.AddSplit(input_data, input_size, list_idx);
+		list_idx++;
+		return list_idx;
 	}
-
-protected:
-	unique_ptr<RE2> re;
-	bool ascii_only;
 };
 
-void BaseStringSplitFunction(const char *input, StringSplitIterator &iter, Vector &result) {
-	// special case: empty string
-	if (iter.size == 0) {
-		Value val = StringVector::AddString(ListVector::GetEntry(result), &input[0], 0);
-		ListVector::PushBack(result, val);
-		return;
-	}
-	while (iter.HasNext()) {
-		idx_t start = iter.Start();
-		idx_t end = iter.Next(input);
-		size_t length = end - start;
-		Value to_insert(StringVector::AddString(ListVector::GetEntry(result), &input[start], length));
-		ListVector::PushBack(result, to_insert);
-	}
-}
-
-unique_ptr<Vector> BaseStringSplitFunction(string_t input, string_t delim, const bool regex) {
-	const char *input_data = input.GetDataUnsafe();
-	size_t input_size = input.GetSize();
-	const char *delim_data = delim.GetDataUnsafe();
-	size_t delim_size = delim.GetSize();
-
-	bool ascii_only = Utf8Proc::Analyze(input_data, input_size) == UnicodeType::ASCII;
-
-	auto list_type = LogicalType::LIST(LogicalType::VARCHAR);
-	auto output = make_unique<Vector>(list_type);
-	unique_ptr<StringSplitIterator> iter;
-	if (regex) {
-		auto re = make_unique<RE2>(duckdb_re2::StringPiece(delim_data, delim_size));
-		if (!re->ok()) {
-			throw Exception(re->error());
-		}
-		iter = make_unique_base<StringSplitIterator, RegexStringSplitIterator>(input_size, move(re), ascii_only);
-	} else if (ascii_only) {
-		iter = make_unique_base<StringSplitIterator, AsciiStringSplitIterator>(input_size, delim_data, delim_size);
-	} else {
-		iter = make_unique_base<StringSplitIterator, UnicodeStringSplitIterator>(input_size, delim_data, delim_size);
-	}
-	BaseStringSplitFunction(input_data, *iter, *output);
-
-	return output;
-}
-
-static void StringSplitExecutor(DataChunk &args, ExpressionState &state, Vector &result, const bool regex) {
+template <class OP>
+static void StringSplitExecutor(DataChunk &args, ExpressionState &state, Vector &result, void *data = nullptr) {
 	UnifiedVectorFormat input_data;
 	args.data[0].ToUnifiedFormat(args.size(), input_data);
 	auto inputs = (string_t *)input_data.data;
@@ -119594,10 +119680,11 @@ static void StringSplitExecutor(DataChunk &args, ExpressionState &state, Vector
 	ListVector::SetListSize(result, 0);
 
 	auto list_struct_data = FlatVector::GetData<list_entry_t>(result);
-	auto list_vector_type = LogicalType::LIST(LogicalType::VARCHAR);
 
-	idx_t total_len = 0;
+	// count all the splits and set up the list entries
+	auto &child_entry = ListVector::GetEntry(result);
 	auto &result_mask = FlatVector::Validity(result);
+	idx_t total_splits = 0;
 	for (idx_t i = 0; i < args.size(); i++) {
 		auto input_idx = input_data.sel->get_index(i);
 		auto delim_idx = delim_data.sel->get_index(i);
@@ -119605,36 +119692,43 @@ static void StringSplitExecutor(DataChunk &args, ExpressionState &state, Vector
 			result_mask.SetInvalid(i);
 			continue;
 		}
-		string_t input = inputs[input_idx];
-
-		unique_ptr<Vector> split_input;
+		StringSplitInput split_input(result, child_entry, total_splits);
 		if (!delim_data.validity.RowIsValid(delim_idx)) {
-			// special case: delimiter is NULL
-			split_input = make_unique<Vector>(list_vector_type);
-			Value val(input);
-			ListVector::PushBack(*split_input, val);
-		} else {
-			string_t delim = delims[delim_idx];
-			split_input = BaseStringSplitFunction(input, delim, regex);
+			// delim is NULL: copy the complete entry
+			split_input.AddSplit(inputs[input_idx].GetDataUnsafe(), inputs[input_idx].GetSize(), 0);
+			list_struct_data[i].length = 1;
+			list_struct_data[i].offset = total_splits;
+			total_splits++;
+			continue;
 		}
-		list_struct_data[i].length = ListVector::GetListSize(*split_input);
-		list_struct_data[i].offset = total_len;
-		total_len += ListVector::GetListSize(*split_input);
-		ListVector::Append(result, ListVector::GetEntry(*split_input), ListVector::GetListSize(*split_input));
+		auto list_length = StringSplitter::Split<OP>(inputs[input_idx], delims[delim_idx], split_input, data);
+		list_struct_data[i].length = list_length;
+		list_struct_data[i].offset = total_splits;
+		total_splits += list_length;
 	}
+	ListVector::SetListSize(result, total_splits);
+	D_ASSERT(ListVector::GetListSize(result) == total_splits);
 
-	D_ASSERT(ListVector::GetListSize(result) == total_len);
 	if (args.AllConstant()) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
 	}
 }
 
 static void StringSplitFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	StringSplitExecutor(args, state, result, false);
+	StringSplitExecutor<RegularStringSplit>(args, state, result, nullptr);
 }
 
 static void StringSplitRegexFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	StringSplitExecutor(args, state, result, true);
+	auto &func_expr = (BoundFunctionExpression &)state.expr;
+	auto &info = (RegexpMatchesBindData &)*func_expr.bind_info;
+	if (info.constant_pattern) {
+		// fast path: pre-compiled regex
+		auto &lstate = (RegexLocalState &)*ExecuteFunctionState::GetFunctionState(state);
+		StringSplitExecutor<ConstantRegexpStringSplit>(args, state, result, &lstate.constant_pattern);
+	} else {
+		// slow path: have to re-compile regex for every row
+		StringSplitExecutor<RegexpStringSplit>(args, state, result);
+	}
 }
 
 void StringSplitFun::RegisterFunction(BuiltinFunctions &set) {
@@ -119645,10 +119739,18 @@ void StringSplitFun::RegisterFunction(BuiltinFunctions &set) {
 	regular_fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	set.AddFunction({"string_split", "str_split", "string_to_array", "split"}, regular_fun);
 
-	auto regex_fun =
-	    ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, varchar_list_type, StringSplitRegexFunction);
-	regex_fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction({"string_split_regex", "str_split_regex", "regexp_split_to_array"}, regex_fun);
+	ScalarFunctionSet regexp_split("string_split_regex");
+	ScalarFunction regex_fun({LogicalType::VARCHAR, LogicalType::VARCHAR}, varchar_list_type, StringSplitRegexFunction,
+	                         RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID,
+	                         FunctionSideEffects::NO_SIDE_EFFECTS, FunctionNullHandling::SPECIAL_HANDLING);
+	regexp_split.AddFunction(regex_fun);
+	// regexp options
+	regex_fun.arguments.emplace_back(LogicalType::VARCHAR);
+	regexp_split.AddFunction(regex_fun);
+	for (auto &name : {"string_split_regex", "str_split_regex", "regexp_split_to_array"}) {
+		regexp_split.name = name;
+		set.AddFunction(regexp_split);
+	}
 }
 
 } // namespace duckdb