duckdb 0.7.2-dev654.0 → 0.7.2-dev832.0

package/src/duckdb/src/parser/tableref/table_function.cpp

@@ -1,6 +1,8 @@
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/common/vector.hpp"
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -25,6 +27,21 @@ void TableFunctionRef::Serialize(FieldWriter &writer) const {
 	writer.WriteList<string>(column_name_alias);
 }
 
+void TableFunctionRef::FormatSerialize(FormatSerializer &serializer) const {
+	TableRef::FormatSerialize(serializer);
+	serializer.WriteProperty("function", function);
+	serializer.WriteProperty("alias", alias);
+	serializer.WriteProperty("column_name_alias", column_name_alias);
+}
+
+unique_ptr<TableRef> TableFunctionRef::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = make_unique<TableFunctionRef>();
+	deserializer.ReadProperty("function", result->function);
+	deserializer.ReadProperty("alias", result->alias);
+	deserializer.ReadProperty("column_name_alias", result->column_name_alias);
+	return std::move(result);
+}
+
 unique_ptr<TableRef> TableFunctionRef::Deserialize(FieldReader &reader) {
 	auto result = make_unique<TableFunctionRef>();
 	result->function = reader.ReadRequiredSerializable<ParsedExpression>();

package/src/duckdb/src/parser/tableref.cpp

@@ -3,6 +3,8 @@
 #include "duckdb/common/printer.hpp"
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/tableref/list.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 #include "duckdb/common/to_string.hpp"
 
 namespace duckdb {
@@ -52,6 +54,50 @@ void TableRef::Serialize(Serializer &serializer) const {
 	writer.Finalize();
 }
 
+void TableRef::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("type", type);
+	serializer.WriteProperty("alias", alias);
+	serializer.WriteOptionalProperty("sample", sample);
+}
+
+unique_ptr<TableRef> TableRef::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto type = deserializer.ReadProperty<TableReferenceType>("type");
+	auto alias = deserializer.ReadProperty<string>("alias");
+	auto sample = deserializer.ReadOptionalProperty<unique_ptr<SampleOptions>>("sample");
+
+	unique_ptr<TableRef> result;
+
+	switch (type) {
+	case TableReferenceType::BASE_TABLE:
+		result = BaseTableRef::FormatDeserialize(deserializer);
+		break;
+	case TableReferenceType::JOIN:
+		result = JoinRef::FormatDeserialize(deserializer);
+		break;
+	case TableReferenceType::SUBQUERY:
+		result = SubqueryRef::FormatDeserialize(deserializer);
+		break;
+	case TableReferenceType::TABLE_FUNCTION:
+		result = TableFunctionRef::FormatDeserialize(deserializer);
+		break;
+	case TableReferenceType::EMPTY:
+		result = EmptyTableRef::FormatDeserialize(deserializer);
+		break;
+	case TableReferenceType::EXPRESSION_LIST:
+		result = ExpressionListRef::FormatDeserialize(deserializer);
+		break;
+	case TableReferenceType::PIVOT:
+		result = PivotRef::FormatDeserialize(deserializer);
+		break;
+	case TableReferenceType::CTE:
+	case TableReferenceType::INVALID:
+		throw InternalException("Unsupported type for TableRef::FormatDeserialize");
+	}
+	result->alias = alias;
+	result->sample = std::move(sample);
+	return result;
+}
+
 unique_ptr<TableRef> TableRef::Deserialize(Deserializer &source) {
 	FieldReader reader(source);
 

package/src/duckdb/src/parser/transform/expression/transform_bool_expr.cpp

@@ -37,7 +37,7 @@ unique_ptr<ParsedExpression> Transformer::TransformBoolExpr(duckdb_libpgquery::P
 			           next->type <= ExpressionType::COMPARE_GREATERTHANOREQUALTO) {
 				// NOT on a comparison: we can negate the comparison
 				// e.g. NOT(x > y) is equivalent to x <= y
-				next->type = NegateComparisionExpression(next->type);
+				next->type = NegateComparisonExpression(next->type);
 				result = std::move(next);
 			} else {
 				result = make_unique<OperatorExpression>(ExpressionType::OPERATOR_NOT, std::move(next));

package/src/duckdb/src/parser/transform/expression/transform_function.cpp

@@ -134,7 +134,7 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 		schema = INVALID_SCHEMA;
 		function_name = reinterpret_cast<duckdb_libpgquery::PGValue *>(name->head->data.ptr_value)->val.str;
 	} else {
-		throw InternalException("TransformFuncCall - Expected 1, 2 or 3 qualifications");
+		throw ParserException("TransformFuncCall - Expected 1, 2 or 3 qualifications");
 	}
 
 	//  transform children

package/src/duckdb/src/parser/transform/expression/transform_operator.cpp

@@ -84,7 +84,7 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 			// ALL sublink is equivalent to NOT(ANY) with inverted comparison
 			// e.g. [= ALL()] is equivalent to [NOT(<> ANY())]
 			// first invert the comparison type
-			subquery_expr->comparison_type = NegateComparisionExpression(subquery_expr->comparison_type);
+			subquery_expr->comparison_type = NegateComparisonExpression(subquery_expr->comparison_type);
 			return make_unique<OperatorExpression>(ExpressionType::OPERATOR_NOT, std::move(subquery_expr));
 		}
 		return std::move(subquery_expr);

package/src/duckdb/src/parser/transform/expression/transform_subquery.cpp

@@ -44,7 +44,7 @@ unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::P
 			// ALL sublink is equivalent to NOT(ANY) with inverted comparison
 			// e.g. [= ALL()] is equivalent to [NOT(<> ANY())]
 			// first invert the comparison type
-			subquery_expr->comparison_type = NegateComparisionExpression(subquery_expr->comparison_type);
+			subquery_expr->comparison_type = NegateComparisonExpression(subquery_expr->comparison_type);
 			return make_unique<OperatorExpression>(ExpressionType::OPERATOR_NOT, std::move(subquery_expr));
 		}
 		break;

package/src/duckdb/src/planner/binder/expression/bind_subquery_expression.cpp

@@ -32,6 +32,10 @@ public:
 	void Serialize(FieldWriter &writer) const override {
 		throw InternalException("Cannot serialize bound subquery node");
 	}
+
+	void FormatSerialize(FormatSerializer &serializer) const override {
+		throw InternalException("Cannot serialize bound subquery node");
+	}
 };
 
 BindResult ExpressionBinder::BindExpression(SubqueryExpression &expr, idx_t depth) {

package/src/duckdb/src/planner/binder/statement/bind_copy.cpp

@@ -158,7 +158,9 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 	result.types = {LogicalType::BIGINT};
 	result.names = {"Count"};
 
-	D_ASSERT(!stmt.info->table.empty());
+	if (stmt.info->table.empty()) {
+		throw ParserException("COPY FROM requires a table name to be specified");
+	}
 	// COPY FROM a file
 	// generate an insert statement for the the to-be-inserted table
 	InsertStatement insert;

package/src/duckdb/src/planner/binder/tableref/plan_joinref.cpp

@@ -33,7 +33,7 @@ static bool CreateJoinCondition(Expression &expr, const unordered_set<idx_t> &le
 		if (left_side == JoinSide::RIGHT) {
 			// left = right, right = left, flip the comparison symbol and reverse sides
 			swap(left, right);
-			condition.comparison = FlipComparisionExpression(expr.type);
+			condition.comparison = FlipComparisonExpression(expr.type);
 		}
 		condition.left = std::move(left);
 		condition.right = std::move(right);

package/src/duckdb/src/planner/expression/bound_expression.cpp

@@ -28,4 +28,8 @@ void BoundExpression::Serialize(FieldWriter &writer) const {
 	throw SerializationException("Cannot copy or serialize bound expression");
 }
 
+void BoundExpression::FormatSerialize(FormatSerializer &serializer) const {
+	throw SerializationException("Cannot copy or serialize bound expression");
+}
+
 } // namespace duckdb

package/src/duckdb/src/storage/data_table.cpp

@@ -819,9 +819,10 @@ void DataTable::RevertAppend(idx_t start_row, idx_t count) {
 //===--------------------------------------------------------------------===//
 // Indexes
 //===--------------------------------------------------------------------===//
-bool DataTable::AppendToIndexes(TableIndexList &indexes, DataChunk &chunk, row_t row_start) {
+PreservedError DataTable::AppendToIndexes(TableIndexList &indexes, DataChunk &chunk, row_t row_start) {
+	PreservedError error;
 	if (indexes.Empty()) {
-		return true;
+		return error;
 	}
 	// first generate the vector of row identifiers
 	Vector row_identifiers(LogicalType::ROW_TYPE);
@@ -832,11 +833,13 @@ bool DataTable::AppendToIndexes(TableIndexList &indexes, DataChunk &chunk, row_t
 	// now append the entries to the indices
 	indexes.Scan([&](Index &index) {
 		try {
-			if (!index.Append(chunk, row_identifiers)) {
-				append_failed = true;
-				return true;
-			}
-		} catch (...) {
+			error = index.Append(chunk, row_identifiers);
+		} catch (Exception &ex) {
+			error = PreservedError(ex);
+		} catch (std::exception &ex) {
+			error = PreservedError(ex);
+		}
+		if (error) {
 			append_failed = true;
 			return true;
 		}
@@ -850,12 +853,11 @@ bool DataTable::AppendToIndexes(TableIndexList &indexes, DataChunk &chunk, row_t
 		for (auto *index : already_appended) {
 			index->Delete(chunk, row_identifiers);
 		}
-		return false;
 	}
-	return true;
+	return error;
 }
 
-bool DataTable::AppendToIndexes(DataChunk &chunk, row_t row_start) {
+PreservedError DataTable::AppendToIndexes(DataChunk &chunk, row_t row_start) {
 	D_ASSERT(is_root);
 	return AppendToIndexes(info->indexes, chunk, row_start);
 }
@@ -1204,9 +1206,9 @@ void DataTable::WALAddIndex(ClientContext &context, unique_ptr<Index> index,
 			index->ExecuteExpressions(intermediate, result);
 
 			// insert into the index
-			if (!index->Insert(lock, result, intermediate.data[intermediate.ColumnCount() - 1])) {
-				throw InternalException("Error during WAL replay. Can't create unique index, table contains "
-				                        "duplicate data on indexed column(s).");
+			auto error = index->Insert(lock, result, intermediate.data[intermediate.ColumnCount() - 1]);
+			if (error) {
+				throw InternalException("Error during WAL replay: %s", error.Message());
 			}
 		}
 	}

package/src/duckdb/src/storage/index.cpp

@@ -36,7 +36,7 @@ void Index::InitializeLock(IndexLock &state) {
 	state.index_lock = unique_lock<mutex>(lock);
 }
 
-bool Index::Append(DataChunk &entries, Vector &row_identifiers) {
+PreservedError Index::Append(DataChunk &entries, Vector &row_identifiers) {
 	IndexLock state;
 	InitializeLock(state);
 	return Append(state, entries, row_identifiers);
@@ -90,4 +90,15 @@ BlockPointer Index::Serialize(MetaBlockWriter &writer) {
 	throw NotImplementedException("The implementation of this index serialization does not exist.");
 }
 
+string Index::AppendRowError(DataChunk &input, idx_t index) {
+	string error;
+	for (idx_t c = 0; c < input.ColumnCount(); c++) {
+		if (c > 0) {
+			error += ", ";
+		}
+		error += input.GetValue(c, index).ToString();
+	}
+	return error;
+}
+
 } // namespace duckdb

package/src/duckdb/src/storage/local_storage.cpp

@@ -197,16 +197,16 @@ void LocalTableStorage::FlushToDisk() {
 	optimistic_writer.FinalFlush();
 }
 
-bool LocalTableStorage::AppendToIndexes(DuckTransaction &transaction, RowGroupCollection &source,
-                                        TableIndexList &index_list, const vector<LogicalType> &table_types,
-                                        row_t &start_row) {
+PreservedError LocalTableStorage::AppendToIndexes(DuckTransaction &transaction, RowGroupCollection &source,
+                                                  TableIndexList &index_list, const vector<LogicalType> &table_types,
+                                                  row_t &start_row) {
 	// only need to scan for index append
 	// figure out which columns we need to scan for the set of indexes
 	auto columns = index_list.GetRequiredColumns();
 	// create an empty mock chunk that contains all the correct types for the table
 	DataChunk mock_chunk;
 	mock_chunk.InitializeEmpty(table_types);
-	bool success = true;
+	PreservedError error;
 	source.Scan(transaction, columns, [&](DataChunk &chunk) -> bool {
 		// construct the mock chunk by referencing the required columns
 		for (idx_t i = 0; i < columns.size(); i++) {
@@ -214,28 +214,28 @@ bool LocalTableStorage::AppendToIndexes(DuckTransaction &transaction, RowGroupCo
 		}
 		mock_chunk.SetCardinality(chunk);
 		// append this chunk to the indexes of the table
-		if (!DataTable::AppendToIndexes(index_list, mock_chunk, start_row)) {
-			success = false;
+		error = DataTable::AppendToIndexes(index_list, mock_chunk, start_row);
+		if (error) {
 			return false;
 		}
 		start_row += chunk.size();
 		return true;
 	});
-	return success;
+	return error;
 }
 
 void LocalTableStorage::AppendToIndexes(DuckTransaction &transaction, TableAppendState &append_state,
                                         idx_t append_count, bool append_to_table) {
-	bool constraint_violated = false;
 	if (append_to_table) {
 		table->InitializeAppend(transaction, append_state, append_count);
 	}
+	PreservedError error;
 	if (append_to_table) {
 		// appending: need to scan entire
 		row_groups->Scan(transaction, [&](DataChunk &chunk) -> bool {
 			// append this chunk to the indexes of the table
-			if (!table->AppendToIndexes(chunk, append_state.current_row)) {
-				constraint_violated = true;
+			error = table->AppendToIndexes(chunk, append_state.current_row);
+			if (error) {
 				return false;
 			}
 			// append to base table
@@ -243,11 +243,10 @@ void LocalTableStorage::AppendToIndexes(DuckTransaction &transaction, TableAppen
 			return true;
 		});
 	} else {
-		constraint_violated = !AppendToIndexes(transaction, *row_groups, table->info->indexes, table->GetTypes(),
-		                                       append_state.current_row);
+		error = AppendToIndexes(transaction, *row_groups, table->info->indexes, table->GetTypes(),
+		                        append_state.current_row);
 	}
-	if (constraint_violated) {
-		PreservedError error;
+	if (error) {
 		// need to revert the append
 		row_t current_row = append_state.row_start;
 		// remove the data from the indexes, if there are any indexes
@@ -273,10 +272,7 @@ void LocalTableStorage::AppendToIndexes(DuckTransaction &transaction, TableAppen
 		if (append_to_table) {
 			table->RevertAppendInternal(append_state.row_start, append_count);
 		}
-		if (error) {
-			error.Throw();
-		}
-		throw ConstraintException("PRIMARY KEY or UNIQUE constraint violated: duplicated key");
+		error.Throw();
 	}
 }
 
@@ -412,8 +408,9 @@ void LocalStorage::Append(LocalAppendState &state, DataChunk &chunk) {
 	// append to unique indices (if any)
 	auto storage = state.storage;
 	idx_t base_id = MAX_ROW_ID + storage->row_groups->GetTotalRows() + state.append_state.total_append_count;
-	if (!DataTable::AppendToIndexes(storage->indexes, chunk, base_id)) {
-		throw ConstraintException("PRIMARY KEY or UNIQUE constraint violated: duplicated key");
+	auto error = DataTable::AppendToIndexes(storage->indexes, chunk, base_id);
+	if (error) {
+		error.Throw();
 	}
 
 	//! Append the chunk to the local storage
@@ -434,9 +431,9 @@ void LocalStorage::LocalMerge(DataTable *table, RowGroupCollection &collection)
 	if (!storage->indexes.Empty()) {
 		// append data to indexes if required
 		row_t base_id = MAX_ROW_ID + storage->row_groups->GetTotalRows();
-		bool success = storage->AppendToIndexes(transaction, collection, storage->indexes, table->GetTypes(), base_id);
-		if (!success) {
-			throw ConstraintException("PRIMARY KEY or UNIQUE constraint violated: duplicated key");
+		auto error = storage->AppendToIndexes(transaction, collection, storage->indexes, table->GetTypes(), base_id);
+		if (error) {
+			error.Throw();
 		}
 	}
 	storage->row_groups->MergeStorage(collection);

package/src/duckdb/src/verification/deserialized_statement_verifier.cpp

@@ -1,5 +1,4 @@
 #include "duckdb/verification/deserialized_statement_verifier.hpp"
-
 #include "duckdb/common/serializer/buffered_deserializer.hpp"
 
 namespace duckdb {

package/src/duckdb/third_party/re2/re2/re2.cc

@@ -566,6 +566,15 @@ static int ascii_strcasecmp(const char* a, const char* b, size_t len) {
   return 0;
 }
 
+RE2::Anchor RE2::Anchored() const {
+  if (prog_->anchor_start()) {
+    if (prog_->anchor_end()) {
+      return Anchor::ANCHOR_BOTH;
+    }
+    return Anchor::ANCHOR_START;
+  }
+  return Anchor::UNANCHORED;
+}
 
 /***** Actual matching and rewriting code *****/
 

package/src/duckdb/third_party/re2/re2/re2.h

@@ -475,6 +475,8 @@ class RE2 {
     ANCHOR_BOTH         // Anchor at start and end
   };
 
+  Anchor Anchored() const;
+
   // Return the number of capturing subpatterns, or -1 if the
   // regexp wasn't valid on construction.  The overall match ($0)
   // does not count: if the regexp is "(a)(b)", returns 2.

package/src/duckdb/ub_extension_json_json_functions.cpp

@@ -20,6 +20,8 @@
 
 #include "extension/json/json_functions/json_valid.cpp"
 
+#include "extension/json/json_functions/json_serialize_sql.cpp"
+
 #include "extension/json/json_functions/read_json.cpp"
 
 #include "extension/json/json_functions/read_json_objects.cpp"

package/src/duckdb/ub_src_common_serializer.cpp

@@ -6,3 +6,5 @@
 
 #include "src/common/serializer/buffered_serializer.cpp"
 
+#include "src/common/serializer/enum_serializer.cpp"
+

package/src/duckdb/ub_src_function_scalar_string_regexp.cpp

@@ -0,0 +1,4 @@
+#include "src/function/scalar/string/regexp/regexp_util.cpp"
+
+#include "src/function/scalar/string/regexp/regexp_extract_all.cpp"
+

package/src/duckdb/ub_src_parser.cpp

@@ -6,6 +6,8 @@
 
 #include "src/parser/constraint.cpp"
 
+#include "src/parser/common_table_expression_info.cpp"
+
 #include "src/parser/expression_util.cpp"
 
 #include "src/parser/keyword_helper.cpp"

package/src/utils.cpp

@@ -18,6 +18,18 @@ static void SetString(Napi::Object &obj, const std::string &key, const std::stri
 
 Napi::Object Utils::CreateError(Napi::Env env, duckdb::PreservedError &error) {
 	auto obj = Utils::CreateError(env, error.Message());
+	if (error.Type() == duckdb::ExceptionType::HTTP) {
+		const auto &e = error.GetError()->AsHTTPException();
+		obj.Set(Napi::String::New(env, "statusCode"), Napi::Number::New(env, e.GetStatusCode()));
+		SetString(obj, "response", e.GetResponseBody());
+		SetString(obj, "reason", e.GetReason());
+
+		auto headers = Napi::Object::New(env);
+		for (const auto &item : e.GetHeaders()) {
+			SetString(headers, item.first, item.second);
+		}
+		obj.Set(Napi::String::New(env, "headers"), headers);
+	}
 
 	SetString(obj, "errorType", duckdb::Exception::ExceptionTypeToString(error.Type()));
 

package/test/extension.test.ts

@@ -1,9 +1,8 @@
 import * as duckdb from '..';
-import {Database, TableData} from '..';
+import {Database, DuckDbError, HttpError, TableData} from '..';
 import * as fs from 'fs';
 import * as assert from 'assert';
 import * as path from 'path';
-import {Done} from "mocha";
 
 const extension_base_path = "../../../build/release/extension";
 
@@ -21,46 +20,63 @@ if (fs.existsSync(extension_full_path)) {
     }).filter(a => a) as string[];
 }
 
+function isHTTPException(err: DuckDbError): err is HttpError {
+    return err.errorType === 'HTTP';
+}
+
 // Note: test will pass on http request failing due to connection issues.
-const test_httpfs = async function (db: duckdb.Database, done: Done) {
-    db.all("SELECT id, first_name, last_name FROM PARQUET_SCAN('https://raw.githubusercontent.com/cwida/duckdb/master/data/parquet-testing/userdata1.parquet') LIMIT 3;", function(err: null | Error, rows: TableData) {
+const test_httpfs = async function (db: duckdb.Database) {
+    await new Promise<void>((resolve, reject) => db.all("SELECT id, first_name, last_name FROM PARQUET_SCAN('https://raw.githubusercontent.com/cwida/duckdb/master/data/parquet-testing/userdata1.parquet') LIMIT 3;", function (err: null | Error, rows: TableData) {
         if (err) {
             if (err.message.startsWith("Unable to connect to URL")) {
                 console.warn("Warning: HTTP request failed in extension.test.js");
-                done();
+                resolve();
             } else {
-                throw err;
+                reject(err);
             }
         } else {
             assert.deepEqual(rows, [
-                { id: 1, first_name: 'Amanda', last_name: 'Jordan'},
-                { id: 2, first_name: 'Albert', last_name: 'Freeman'},
-                { id: 3, first_name: 'Evelyn', last_name: 'Morgan'},
+                {id: 1, first_name: 'Amanda', last_name: 'Jordan'},
+                {id: 2, first_name: 'Albert', last_name: 'Freeman'},
+                {id: 3, first_name: 'Evelyn', last_name: 'Morgan'},
             ]);
-            done();
+            resolve();
         }
-    });
+    }));
+
+    await new Promise<void>((resolve) => {
+        db.exec("select * from read_csv_auto('https://example.com/hello.csv')", (err: DuckDbError | null) => {
+            assert.ok(err);
+            assert.ok(isHTTPException(err));
+            if (isHTTPException(err)) {
+                assert.equal(err.statusCode, 404);
+                assert.equal(err.reason, 'Not Found');
+                assert.equal(err.response, '');
+                assert.ok('Content-Length' in err.headers, JSON.stringify(err.headers));
+            }
+            resolve();
+        });
+    })
 };
 
-const test_tpch = async function (db: Database, done:Done) {
-    db.all("CALL DBGEN(sf=0.01);", function(err: null | Error) {
+const test_tpch = async function (db: Database) {
+    await new Promise<void>((resolve, reject) => db.all("CALL DBGEN(sf=0.01);", function (err: null | Error) {
         if (err) {
-            throw err;
+            reject(err);
         }
-        done();
-    });
+        resolve();
+    }));
 };
 
-const test_extension = function(extension_name: string, db: duckdb.Database, done: Done) {
-    switch(extension_name) {
+const test_extension = async function (extension_name: string, db: duckdb.Database) {
+    switch (extension_name) {
         case 'httpfs.duckdb_extension':
-            test_httpfs(db, done);
+            await test_httpfs(db);
             break;
         case 'tpch.duckdb_extension':
-            test_tpch(db, done);
+            await test_tpch(db);
             break;
         default:
-            done();
             break;
     }
 };
@@ -79,13 +95,15 @@ describe('Extension loading', function() {
             continue;
         }
 
-        it(extension_name, function(done) {
-            db.run(`LOAD '${extension_path}';`, function(err: null | Error) {
+        it(extension_name, async function () {
+            await new Promise<void>((resolve, reject) => db.run(`LOAD '${extension_path}';`, function (err: null | Error) {
                 if (err) {
-                    throw err;
+                    reject(err);
                 }
-                test_extension(extension_name, db, done);
-            });
+                resolve()
+            }));
+
+            await test_extension(extension_name, db);
         });
     }
 });