duckdb 0.7.2-dev14.0 → 0.7.2-dev225.0

package/binding.gyp

@@ -57,6 +57,7 @@
                 "src/duckdb/ub_src_function.cpp", 
                 "src/duckdb/ub_src_function_cast.cpp", 
                 "src/duckdb/ub_src_function_pragma.cpp", 
+                "src/duckdb/ub_src_function_scalar_bit.cpp", 
                 "src/duckdb/ub_src_function_scalar_blob.cpp", 
                 "src/duckdb/ub_src_function_scalar_date.cpp", 
                 "src/duckdb/ub_src_function_scalar.cpp", 
@@ -223,6 +224,7 @@
                 "src/duckdb/third_party/zstd/compress/zstd_ldm.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_opt.cpp", 
                 "src/duckdb/extension/icu/./icu-dateadd.cpp", 
+                "src/duckdb/extension/icu/./icu-table-range.cpp", 
                 "src/duckdb/extension/icu/./icu-datetrunc.cpp", 
                 "src/duckdb/extension/icu/./icu-strptime.cpp", 
                 "src/duckdb/extension/icu/./icu-datefunc.cpp", 

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.7.2-dev14.0",
+  "version": "0.7.2-dev225.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/icu/icu-extension.cpp

@@ -13,6 +13,7 @@
 #include "include/icu-datesub.hpp"
 #include "include/icu-datetrunc.hpp"
 #include "include/icu-makedate.hpp"
+#include "include/icu-table-range.hpp"
 #include "include/icu-strptime.hpp"
 #include "include/icu-timebucket.hpp"
 #include "include/icu-timezone.hpp"
@@ -266,6 +267,7 @@ void ICUExtension::Load(DuckDB &db) {
 	RegisterICUDateSubFunctions(*con.context);
 	RegisterICUDateTruncFunctions(*con.context);
 	RegisterICUMakeDateFunctions(*con.context);
+	RegisterICUTableRangeFunctions(*con.context);
 	RegisterICUStrptimeFunctions(*con.context);
 	RegisterICUTimeBucketFunctions(*con.context);
 	RegisterICUTimeZoneFunctions(*con.context);

package/src/duckdb/extension/icu/icu-table-range.cpp

@@ -0,0 +1,194 @@
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/types/interval.hpp"
+#include "duckdb/common/types/timestamp.hpp"
+#include "duckdb/function/function_set.hpp"
+#include "duckdb/function/table_function.hpp"
+#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
+#include "include/icu-datefunc.hpp"
+#include "unicode/calendar.h"
+
+namespace duckdb {
+
+struct ICUTableRange {
+	using CalendarPtr = unique_ptr<icu::Calendar>;
+
+	struct BindData : public TableFunctionData {
+		explicit BindData(const BindData &other)
+		    : tz_setting(other.tz_setting), cal_setting(other.cal_setting), calendar(other.calendar->clone()),
+		      start(other.start), end(other.end), increment(other.increment), inclusive_bound(other.inclusive_bound),
+		      greater_than_check(other.greater_than_check) {
+		}
+
+		BindData(ClientContext &context) {
+			Value tz_value;
+			if (context.TryGetCurrentSetting("TimeZone", tz_value)) {
+				tz_setting = tz_value.ToString();
+			}
+			auto tz = icu::TimeZone::createTimeZone(icu::UnicodeString::fromUTF8(icu::StringPiece(tz_setting)));
+
+			string cal_id("@calendar=");
+			Value cal_value;
+			if (context.TryGetCurrentSetting("Calendar", cal_value)) {
+				cal_setting = cal_value.ToString();
+				cal_id += cal_setting;
+			} else {
+				cal_id += "gregorian";
+			}
+
+			icu::Locale locale(cal_id.c_str());
+
+			UErrorCode success = U_ZERO_ERROR;
+			calendar.reset(icu::Calendar::createInstance(tz, locale, success));
+			if (U_FAILURE(success)) {
+				throw Exception("Unable to create ICU calendar.");
+			}
+		}
+
+		string tz_setting;
+		string cal_setting;
+		CalendarPtr calendar;
+
+		timestamp_t start;
+		timestamp_t end;
+		interval_t increment;
+		bool inclusive_bound;
+		bool greater_than_check;
+
+		bool Equals(const FunctionData &other_p) const {
+			auto &other = (const BindData &)other_p;
+			return other.start == start && other.end == end && other.increment == increment &&
+			       other.inclusive_bound == inclusive_bound && other.greater_than_check == greater_than_check &&
+			       *calendar == *other.calendar;
+		}
+
+		unique_ptr<FunctionData> Copy() const {
+			return make_unique<BindData>(*this);
+		}
+
+		bool Finished(timestamp_t current_value) {
+			if (greater_than_check) {
+				if (inclusive_bound) {
+					return current_value > end;
+				} else {
+					return current_value >= end;
+				}
+			} else {
+				if (inclusive_bound) {
+					return current_value < end;
+				} else {
+					return current_value <= end;
+				}
+			}
+		}
+	};
+
+	template <bool GENERATE_SERIES>
+	static unique_ptr<FunctionData> Bind(ClientContext &context, TableFunctionBindInput &input,
+	                                     vector<LogicalType> &return_types, vector<string> &names) {
+		auto result = make_unique<BindData>(context);
+
+		auto &inputs = input.inputs;
+		D_ASSERT(inputs.size() == 3);
+		result->start = inputs[0].GetValue<timestamp_t>();
+		result->end = inputs[1].GetValue<timestamp_t>();
+		result->increment = inputs[2].GetValue<interval_t>();
+
+		// Infinities either cause errors or infinite loops, so just ban them
+		if (!Timestamp::IsFinite(result->start) || !Timestamp::IsFinite(result->end)) {
+			throw BinderException("RANGE with infinite bounds is not supported");
+		}
+
+		if (result->increment.months == 0 && result->increment.days == 0 && result->increment.micros == 0) {
+			throw BinderException("interval cannot be 0!");
+		}
+		// all elements should point in the same direction
+		if (result->increment.months > 0 || result->increment.days > 0 || result->increment.micros > 0) {
+			if (result->increment.months < 0 || result->increment.days < 0 || result->increment.micros < 0) {
+				throw BinderException("RANGE with composite interval that has mixed signs is not supported");
+			}
+			result->greater_than_check = true;
+			if (result->start > result->end) {
+				throw BinderException(
+				    "start is bigger than end, but increment is positive: cannot generate infinite series");
+			}
+		} else {
+			result->greater_than_check = false;
+			if (result->start < result->end) {
+				throw BinderException(
+				    "start is smaller than end, but increment is negative: cannot generate infinite series");
+			}
+		}
+		return_types.push_back(inputs[0].type());
+		if (GENERATE_SERIES) {
+			// generate_series has inclusive bounds on the RHS
+			result->inclusive_bound = true;
+			names.emplace_back("generate_series");
+		} else {
+			result->inclusive_bound = false;
+			names.emplace_back("range");
+		}
+		return std::move(result);
+	}
+
+	struct State : public GlobalTableFunctionState {
+		explicit State(timestamp_t start_p) : current_state(start_p) {
+		}
+
+		timestamp_t current_state;
+		bool finished = false;
+	};
+
+	static unique_ptr<GlobalTableFunctionState> Init(ClientContext &context, TableFunctionInitInput &input) {
+		auto &bind_data = (BindData &)*input.bind_data;
+		return make_unique<State>(bind_data.start);
+	}
+
+	static void ICUTableRangeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+		auto &bind_data = (BindData &)*data_p.bind_data;
+		CalendarPtr calendar_ptr(bind_data.calendar->clone());
+		auto calendar = calendar_ptr.get();
+		auto &state = (State &)*data_p.global_state;
+		if (state.finished) {
+			return;
+		}
+
+		idx_t size = 0;
+		auto data = FlatVector::GetData<timestamp_t>(output.data[0]);
+		while (true) {
+			data[size++] = state.current_state;
+			state.current_state = ICUDateFunc::Add(calendar, state.current_state, bind_data.increment);
+			if (bind_data.Finished(state.current_state)) {
+				state.finished = true;
+				break;
+			}
+			if (size >= STANDARD_VECTOR_SIZE) {
+				break;
+			}
+		}
+		output.SetCardinality(size);
+	}
+
+	static void AddICUTableRangeFunction(ClientContext &context) {
+		auto &catalog = Catalog::GetSystemCatalog(context);
+
+		TableFunctionSet range("range");
+		range.AddFunction(TableFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
+		                                ICUTableRangeFunction, Bind<false>, Init));
+		CreateTableFunctionInfo range_func_info(range);
+		catalog.AddFunction(context, &range_func_info);
+
+		// generate_series: similar to range, but inclusive instead of exclusive bounds on the RHS
+		TableFunctionSet generate_series("generate_series");
+		generate_series.AddFunction(
+		    TableFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
+		                  ICUTableRangeFunction, Bind<true>, Init));
+		CreateTableFunctionInfo generate_series_func_info(generate_series);
+		catalog.AddFunction(context, &generate_series_func_info);
+	}
+};
+
+void RegisterICUTableRangeFunctions(ClientContext &context) {
+	ICUTableRange::AddICUTableRangeFunction(context);
+}
+
+} // namespace duckdb

package/src/duckdb/extension/icu/include/icu-table-range.hpp

@@ -0,0 +1,17 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// icu-table-range.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb.hpp"
+
+namespace duckdb {
+
+void RegisterICUTableRangeFunctions(ClientContext &context);
+
+} // namespace duckdb

package/src/duckdb/extension/parquet/column_writer.cpp

@@ -1994,7 +1994,6 @@ unique_ptr<ColumnWriter> ColumnWriter::CreateWriterRecursive(vector<duckdb_parqu
 			                                             max_define, can_have_nulls);
 		}
 	case LogicalTypeId::BLOB:
-	case LogicalTypeId::BIT:
 	case LogicalTypeId::VARCHAR:
 		return make_unique<StringColumnWriter>(writer, schema_idx, std::move(schema_path), max_repeat, max_define,
 		                                       can_have_nulls);

package/src/duckdb/extension/parquet/parquet-extension.cpp

@@ -368,7 +368,10 @@ public:
 		if (!config.options.enable_external_access) {
 			throw PermissionException("Scanning Parquet files is disabled through configuration");
 		}
-		auto file_name = input.inputs[0].GetValue<string>();
+		if (input.inputs[0].IsNull()) {
+			throw ParserException("Parquet reader cannot take NULL list as parameter");
+		}
+		auto file_name = StringValue::Get(input.inputs[0]);
 		ParquetOptions parquet_options(context);
 		for (auto &kv : input.named_parameters) {
 			auto loption = StringUtil::Lower(kv.first);
@@ -395,10 +398,16 @@ public:
 		if (!config.options.enable_external_access) {
 			throw PermissionException("Scanning Parquet files is disabled through configuration");
 		}
+		if (input.inputs[0].IsNull()) {
+			throw ParserException("Parquet reader cannot take NULL list as parameter");
+		}
 		FileSystem &fs = FileSystem::GetFileSystem(context);
 		vector<string> files;
 		for (auto &val : ListValue::GetChildren(input.inputs[0])) {
-			auto glob_files = ParquetGlob(fs, val.ToString(), context);
+			if (val.IsNull()) {
+				throw ParserException("Parquet reader cannot take NULL input as parameter");
+			}
+			auto glob_files = ParquetGlob(fs, StringValue::Get(val), context);
 			files.insert(files.end(), glob_files.begin(), glob_files.end());
 		}
 		if (files.empty()) {

package/src/duckdb/src/catalog/catalog_entry/duck_schema_entry.cpp

@@ -145,6 +145,10 @@ CatalogEntry *DuckSchemaEntry::CreateFunction(CatalogTransaction transaction, Cr
 		function = make_unique_base<StandardEntry, ScalarFunctionCatalogEntry>(catalog, this,
 		                                                                       (CreateScalarFunctionInfo *)info);
 		break;
+	case CatalogType::TABLE_FUNCTION_ENTRY:
+		function =
+		    make_unique_base<StandardEntry, TableFunctionCatalogEntry>(catalog, this, (CreateTableFunctionInfo *)info);
+		break;
 	case CatalogType::MACRO_ENTRY:
 		// create a macro function
 		function = make_unique_base<StandardEntry, ScalarMacroCatalogEntry>(catalog, this, (CreateMacroInfo *)info);

package/src/duckdb/src/catalog/catalog_entry/scalar_function_catalog_entry.cpp

@@ -1,5 +1,5 @@
 #include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
-#include "duckdb/parser/parsed_data/alter_function_info.hpp"
+#include "duckdb/parser/parsed_data/alter_scalar_function_info.hpp"
 
 namespace duckdb {
 
@@ -9,14 +9,15 @@ ScalarFunctionCatalogEntry::ScalarFunctionCatalogEntry(Catalog *catalog, SchemaC
 }
 
 unique_ptr<CatalogEntry> ScalarFunctionCatalogEntry::AlterEntry(ClientContext &context, AlterInfo *info) {
-	if (info->type != AlterType::ALTER_FUNCTION) {
+	if (info->type != AlterType::ALTER_SCALAR_FUNCTION) {
 		throw InternalException("Attempting to alter ScalarFunctionCatalogEntry with unsupported alter type");
 	}
-	auto &function_info = (AlterFunctionInfo &)*info;
-	if (function_info.alter_function_type != AlterFunctionType::ADD_FUNCTION_OVERLOADS) {
-		throw InternalException("Attempting to alter ScalarFunctionCatalogEntry with unsupported alter function type");
+	auto &function_info = (AlterScalarFunctionInfo &)*info;
+	if (function_info.alter_scalar_function_type != AlterScalarFunctionType::ADD_FUNCTION_OVERLOADS) {
+		throw InternalException(
+		    "Attempting to alter ScalarFunctionCatalogEntry with unsupported alter scalar function type");
 	}
-	auto &add_overloads = (AddFunctionOverloadInfo &)function_info;
+	auto &add_overloads = (AddScalarFunctionOverloadInfo &)function_info;
 
 	ScalarFunctionSet new_set = functions;
 	if (!new_set.MergeFunctionSet(add_overloads.new_overloads)) {

package/src/duckdb/src/catalog/catalog_entry/table_function_catalog_entry.cpp

@@ -1,5 +1,5 @@
 #include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
-#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
+#include "duckdb/parser/parsed_data/alter_table_function_info.hpp"
 
 namespace duckdb {
 
@@ -10,4 +10,23 @@ TableFunctionCatalogEntry::TableFunctionCatalogEntry(Catalog *catalog, SchemaCat
 	D_ASSERT(this->functions.Size() > 0);
 }
 
+unique_ptr<CatalogEntry> TableFunctionCatalogEntry::AlterEntry(ClientContext &context, AlterInfo *info) {
+	if (info->type != AlterType::ALTER_TABLE_FUNCTION) {
+		throw InternalException("Attempting to alter TableFunctionCatalogEntry with unsupported alter type");
+	}
+	auto &function_info = (AlterTableFunctionInfo &)*info;
+	if (function_info.alter_table_function_type != AlterTableFunctionType::ADD_FUNCTION_OVERLOADS) {
+		throw InternalException(
+		    "Attempting to alter TableFunctionCatalogEntry with unsupported alter table function type");
+	}
+	auto &add_overloads = (AddTableFunctionOverloadInfo &)function_info;
+
+	TableFunctionSet new_set = functions;
+	if (!new_set.MergeFunctionSet(add_overloads.new_overloads)) {
+		throw BinderException("Failed to add new function overloads to function \"%s\": function already exists", name);
+	}
+	CreateTableFunctionInfo new_info(std::move(new_set));
+	return make_unique<TableFunctionCatalogEntry>(catalog, schema, &new_info);
+}
+
 } // namespace duckdb

package/src/duckdb/src/common/enums/statement_type.cpp

@@ -59,6 +59,8 @@ string StatementTypeToString(StatementType type) {
 		return "ATTACH";
 	case StatementType::DETACH_STATEMENT:
 		return "DETACH";
+	case StatementType::MULTI_STATEMENT:
+		return "MULTI";
 	case StatementType::INVALID_STATEMENT:
 		break;
 	}

package/src/duckdb/src/common/types/bit.cpp

@@ -4,66 +4,35 @@
 
 namespace duckdb {
 
-void Bit::SetEmptyBitString(string_t &target, string_t &input) {
-	char *res_buf = target.GetDataWriteable();
-	const char *buf = input.GetDataUnsafe();
-	memset(res_buf, 0, input.GetSize());
-	res_buf[0] = buf[0];
+// **** helper functions ****
+static char ComputePadding(idx_t len) {
+	return (8 - (len % 8)) % 8;
 }
 
-idx_t Bit::BitLength(string_t bits) {
-	return ((bits.GetSize() - 1) * 8) - GetPadding(bits);
+idx_t Bit::ComputeBitstringLen(idx_t len) {
+	len = len % 8 ? (len / 8) + 1 : len / 8;
+	return ++len; // additional first byte to store info on zero padding
 }
 
-idx_t Bit::OctetLength(string_t bits) {
-	return bits.GetSize() - 1;
+inline idx_t Bit::GetPadding(const string_t &bit_string) {
+	auto data = (const_data_ptr_t)bit_string.GetDataUnsafe();
+	return data[0];
 }
 
-idx_t Bit::BitCount(string_t bits) {
-	idx_t count = 0;
-	const char *buf = bits.GetDataUnsafe();
-	for (idx_t byte_idx = 1; byte_idx < OctetLength(bits) + 1; byte_idx++) {
-		for (idx_t bit_idx = 0; bit_idx < 8; bit_idx++) {
-			count += (buf[byte_idx] & (1 << bit_idx)) ? 1 : 0;
-		}
-	}
-	return count;
+void Bit::SetEmptyBitString(string_t &target, string_t &input) {
+	char *res_buf = target.GetDataWriteable();
+	const char *buf = input.GetDataUnsafe();
+	memset(res_buf, 0, input.GetSize());
+	res_buf[0] = buf[0];
 }
 
-idx_t Bit::BitPosition(string_t substring, string_t bits) {
-	const char *buf = bits.GetDataUnsafe();
-	auto len = bits.GetSize();
-	auto substr_len = BitLength(substring);
-	idx_t substr_idx = 0;
-
-	for (idx_t bit_idx = GetPadding(bits); bit_idx < 8; bit_idx++) {
-		idx_t bit = buf[1] & (1 << (7 - bit_idx)) ? 1 : 0;
-		if (bit == GetBit(substring, substr_idx)) {
-			substr_idx++;
-			if (substr_idx == substr_len) {
-				return (bit_idx - GetPadding(bits)) - substr_len + 2;
-			}
-		} else {
-			substr_idx = 0;
-		}
-	}
-
-	for (idx_t byte_idx = 2; byte_idx < len; byte_idx++) {
-		for (idx_t bit_idx = 0; bit_idx < 8; bit_idx++) {
-			idx_t bit = buf[byte_idx] & (1 << (7 - bit_idx)) ? 1 : 0;
-			if (bit == GetBit(substring, substr_idx)) {
-				substr_idx++;
-				if (substr_idx == substr_len) {
-					return (((byte_idx - 1) * 8) + bit_idx - GetPadding(bits)) - substr_len + 2;
-				}
-			} else {
-				substr_idx = 0;
-			}
-		}
-	}
-	return 0;
+void Bit::SetEmptyBitString(string_t &target, idx_t len) {
+	char *res_buf = target.GetDataWriteable();
+	memset(res_buf, 0, target.GetSize());
+	res_buf[0] = ComputePadding(len);
 }
 
+// **** casting functions ****
 void Bit::ToString(string_t bits, char *output) {
 	auto data = (const_data_ptr_t)bits.GetDataUnsafe();
 	auto len = bits.GetSize();
@@ -101,8 +70,12 @@ bool Bit::TryGetBitStringSize(string_t str, idx_t &str_len, string *error_messag
 			return false;
 		}
 	}
-	str_len = str_len % 8 ? (str_len / 8) + 1 : str_len / 8;
-	str_len++; // additional first byte to store info on zero padding
+	if (str_len == 0) {
+		string error = "Cannot cast empty string to BIT";
+		HandleCastError::AssignError(error, error_message);
+		return false;
+	}
+	str_len = ComputeBitstringLen(str_len);
 	return true;
 }
 
@@ -151,6 +124,75 @@ string Bit::ToBit(string_t str) {
 	return string(buffer.get(), bit_len);
 }
 
+// **** scalar functions ****
+void Bit::BitString(const string_t &input, const idx_t &len, string_t &result) {
+	char *res_buf = result.GetDataWriteable();
+	const char *buf = input.GetDataUnsafe();
+
+	res_buf[0] = ComputePadding(len);
+	for (idx_t i = 0; i < Bit::BitLength(result); i++) {
+		if (i < len - input.GetSize()) {
+			Bit::SetBit(result, i, 0);
+		} else {
+			idx_t bit = buf[i - (len - input.GetSize())] == '1' ? 1 : 0;
+			Bit::SetBit(result, i, bit);
+		}
+	}
+}
+
+idx_t Bit::BitLength(string_t bits) {
+	return ((bits.GetSize() - 1) * 8) - GetPadding(bits);
+}
+
+idx_t Bit::OctetLength(string_t bits) {
+	return bits.GetSize() - 1;
+}
+
+idx_t Bit::BitCount(string_t bits) {
+	idx_t count = 0;
+	const char *buf = bits.GetDataUnsafe();
+	for (idx_t byte_idx = 1; byte_idx < OctetLength(bits) + 1; byte_idx++) {
+		for (idx_t bit_idx = 0; bit_idx < 8; bit_idx++) {
+			count += (buf[byte_idx] & (1 << bit_idx)) ? 1 : 0;
+		}
+	}
+	return count;
+}
+
+idx_t Bit::BitPosition(string_t substring, string_t bits) {
+	const char *buf = bits.GetDataUnsafe();
+	auto len = bits.GetSize();
+	auto substr_len = BitLength(substring);
+	idx_t substr_idx = 0;
+
+	for (idx_t bit_idx = GetPadding(bits); bit_idx < 8; bit_idx++) {
+		idx_t bit = buf[1] & (1 << (7 - bit_idx)) ? 1 : 0;
+		if (bit == GetBit(substring, substr_idx)) {
+			substr_idx++;
+			if (substr_idx == substr_len) {
+				return (bit_idx - GetPadding(bits)) - substr_len + 2;
+			}
+		} else {
+			substr_idx = 0;
+		}
+	}
+
+	for (idx_t byte_idx = 2; byte_idx < len; byte_idx++) {
+		for (idx_t bit_idx = 0; bit_idx < 8; bit_idx++) {
+			idx_t bit = buf[byte_idx] & (1 << (7 - bit_idx)) ? 1 : 0;
+			if (bit == GetBit(substring, substr_idx)) {
+				substr_idx++;
+				if (substr_idx == substr_len) {
+					return (((byte_idx - 1) * 8) + bit_idx - GetPadding(bits)) - substr_len + 2;
+				}
+			} else {
+				substr_idx = 0;
+			}
+		}
+	}
+	return 0;
+}
+
 idx_t Bit::GetBit(string_t bit_string, idx_t n) {
 	const char *buf = bit_string.GetDataUnsafe();
 	n += GetPadding(bit_string);
@@ -187,12 +229,7 @@ void Bit::SetBit(string_t &bit_string, idx_t n, idx_t new_value) {
 	}
 }
 
-inline idx_t Bit::GetPadding(const string_t &bit_string) {
-	auto data = (const_data_ptr_t)bit_string.GetDataUnsafe();
-	return data[0];
-}
-
-// **** BITWISE OPERATORS ****
+// **** BITWISE operators ****
 void Bit::RightShift(const string_t &bit_string, const idx_t &shift, string_t &result) {
 	char *res_buf = result.GetDataWriteable();
 	const char *buf = bit_string.GetDataUnsafe();