duckdb 0.7.2-dev717.0 → 0.7.2-dev865.0

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/duckdb/ub_src_storage_statistics.cpp

@@ -8,6 +8,8 @@
 
 #include "src/storage/statistics/numeric_stats.cpp"
 
+#include "src/storage/statistics/numeric_stats_union.cpp"
+
 #include "src/storage/statistics/segment_statistics.cpp"
 
 #include "src/storage/statistics/string_stats.cpp"

package/src/duckdb/ub_src_storage_table.cpp

@@ -14,8 +14,6 @@
 
 #include "src/storage/table/persistent_table_data.cpp"
 
-#include "src/storage/table/segment_tree.cpp"
-
 #include "src/storage/table/row_group.cpp"
 
 #include "src/storage/table/row_group_collection.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);
         });
     }
 });

package/src/duckdb/src/storage/table/segment_tree.cpp

@@ -1,179 +0,0 @@
-#include "duckdb/storage/table/segment_tree.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/string_util.hpp"
-
-namespace duckdb {
-
-SegmentLock SegmentTree::Lock() {
-	return SegmentLock(node_lock);
-}
-
-bool SegmentTree::IsEmpty(SegmentLock &) {
-	return nodes.empty();
-}
-
-SegmentBase *SegmentTree::GetRootSegment(SegmentLock &l) {
-	return nodes.empty() ? nullptr : nodes[0].node.get();
-}
-
-vector<SegmentNode> SegmentTree::MoveSegments(SegmentLock &) {
-	return std::move(nodes);
-}
-
-SegmentBase *SegmentTree::GetRootSegment() {
-	auto l = Lock();
-	return GetRootSegment(l);
-}
-
-SegmentBase *SegmentTree::GetSegmentByIndex(SegmentLock &, int64_t index) {
-	if (index < 0) {
-		index = nodes.size() + index;
-		if (index < 0) {
-			return nullptr;
-		}
-		return nodes[index].node.get();
-	} else {
-		if (idx_t(index) >= nodes.size()) {
-			return nullptr;
-		}
-		return nodes[index].node.get();
-	}
-}
-SegmentBase *SegmentTree::GetSegmentByIndex(int64_t index) {
-	auto l = Lock();
-	return GetSegmentByIndex(l, index);
-}
-
-SegmentBase *SegmentTree::GetLastSegment(SegmentLock &l) {
-	if (nodes.empty()) {
-		return nullptr;
-	}
-	return nodes.back().node.get();
-}
-
-SegmentBase *SegmentTree::GetLastSegment() {
-	auto l = Lock();
-	return GetLastSegment(l);
-}
-
-SegmentBase *SegmentTree::GetSegment(SegmentLock &l, idx_t row_number) {
-	return nodes[GetSegmentIndex(l, row_number)].node.get();
-}
-
-SegmentBase *SegmentTree::GetSegment(idx_t row_number) {
-	auto l = Lock();
-	return GetSegment(l, row_number);
-}
-
-bool SegmentTree::TryGetSegmentIndex(SegmentLock &, idx_t row_number, idx_t &result) {
-	if (nodes.empty()) {
-		return false;
-	}
-	D_ASSERT(!nodes.empty());
-	D_ASSERT(row_number >= nodes[0].row_start);
-	D_ASSERT(row_number < nodes.back().row_start + nodes.back().node->count);
-	idx_t lower = 0;
-	idx_t upper = nodes.size() - 1;
-	// binary search to find the node
-	while (lower <= upper) {
-		idx_t index = (lower + upper) / 2;
-		D_ASSERT(index < nodes.size());
-		auto &entry = nodes[index];
-		D_ASSERT(entry.row_start == entry.node->start);
-		if (row_number < entry.row_start) {
-			upper = index - 1;
-		} else if (row_number >= entry.row_start + entry.node->count) {
-			lower = index + 1;
-		} else {
-			result = index;
-			return true;
-		}
-	}
-	return false;
-}
-
-idx_t SegmentTree::GetSegmentIndex(SegmentLock &l, idx_t row_number) {
-	idx_t segment_index;
-	if (TryGetSegmentIndex(l, row_number, segment_index)) {
-		return segment_index;
-	}
-	string error;
-	error = StringUtil::Format("Attempting to find row number \"%lld\" in %lld nodes\n", row_number, nodes.size());
-	for (idx_t i = 0; i < nodes.size(); i++) {
-		error +=
-		    StringUtil::Format("Node %lld: Start %lld, Count %lld", i, nodes[i].row_start, nodes[i].node->count.load());
-	}
-	throw InternalException("Could not find node in column segment tree!\n%s%s", error, Exception::GetStackTrace());
-}
-
-idx_t SegmentTree::GetSegmentIndex(idx_t row_number) {
-	auto l = Lock();
-	return GetSegmentIndex(l, row_number);
-}
-
-bool SegmentTree::HasSegment(SegmentLock &, SegmentBase *segment) {
-	for (auto &node : nodes) {
-		if (node.node.get() == segment) {
-			return true;
-		}
-	}
-	return false;
-}
-
-bool SegmentTree::HasSegment(SegmentBase *segment) {
-	auto l = Lock();
-	return HasSegment(l, segment);
-}
-
-void SegmentTree::AppendSegment(SegmentLock &, unique_ptr<SegmentBase> segment) {
-	D_ASSERT(segment);
-	// add the node to the list of nodes
-	if (!nodes.empty()) {
-		nodes.back().node->next = segment.get();
-	}
-	SegmentNode node;
-	node.row_start = segment->start;
-	node.node = std::move(segment);
-	nodes.push_back(std::move(node));
-}
-
-void SegmentTree::AppendSegment(unique_ptr<SegmentBase> segment) {
-	auto l = Lock();
-	AppendSegment(l, std::move(segment));
-}
-
-void SegmentTree::EraseSegments(SegmentLock &, idx_t segment_start) {
-	if (segment_start >= nodes.size() - 1) {
-		return;
-	}
-	nodes.erase(nodes.begin() + segment_start + 1, nodes.end());
-}
-
-void SegmentTree::Replace(SegmentLock &, SegmentTree &other) {
-	nodes = std::move(other.nodes);
-}
-
-void SegmentTree::Replace(SegmentTree &other) {
-	auto l = Lock();
-	Replace(l, other);
-}
-
-void SegmentTree::Verify(SegmentLock &) {
-#ifdef DEBUG
-	idx_t base_start = nodes.empty() ? 0 : nodes[0].node->start;
-	for (idx_t i = 0; i < nodes.size(); i++) {
-		D_ASSERT(nodes[i].row_start == nodes[i].node->start);
-		D_ASSERT(nodes[i].node->start == base_start);
-		base_start += nodes[i].node->count;
-	}
-#endif
-}
-
-void SegmentTree::Verify() {
-#ifdef DEBUG
-	auto l = Lock();
-	Verify(l);
-#endif
-}
-
-} // namespace duckdb