duckdb 0.3.2-dev1259.0 → 0.3.2-dev1288.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.2-dev1259.0",
+  "version": "0.3.2-dev1288.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -100463,13 +100463,15 @@ class SelectStatement;
 
 class QueryRelation : public Relation {
 public:
-	QueryRelation(ClientContext &context, string query, string alias = "query_relation");
+	QueryRelation(ClientContext &context, unique_ptr<SelectStatement> select_stmt, string alias);
+	~QueryRelation();
 
-	string query;
+	unique_ptr<SelectStatement> select_stmt;
 	string alias;
 	vector<ColumnDefinition> columns;
 
 public:
+	static unique_ptr<SelectStatement> ParseStatement(ClientContext &context, const string &query, const string &error);
 	unique_ptr<QueryNode> GetQueryNode() override;
 	unique_ptr<TableRef> GetTableRef() override;
 
@@ -100915,8 +100917,12 @@ unordered_set<string> Connection::GetTableNames(const string &query) {
 	return context->GetTableNames(query);
 }
 
-shared_ptr<Relation> Connection::RelationFromQuery(const string &query, const string &alias) {
-	return make_shared<QueryRelation>(*context, query, alias);
+shared_ptr<Relation> Connection::RelationFromQuery(const string &query, string alias, const string &error) {
+	return RelationFromQuery(QueryRelation::ParseStatement(*context, query, error), move(alias));
+}
+
+shared_ptr<Relation> Connection::RelationFromQuery(unique_ptr<SelectStatement> select_stmt, string alias) {
+	return make_shared<QueryRelation>(*context, move(select_stmt), move(alias));
 }
 
 void Connection::BeginTransaction() {
@@ -111513,23 +111519,31 @@ string ProjectionRelation::ToString(idx_t depth) {
 
 namespace duckdb {
 
-QueryRelation::QueryRelation(ClientContext &context, string query, string alias)
-    : Relation(context, RelationType::QUERY_RELATION), query(move(query)), alias(move(alias)) {
+QueryRelation::QueryRelation(ClientContext &context, unique_ptr<SelectStatement> select_stmt_p, string alias_p)
+    : Relation(context, RelationType::QUERY_RELATION), select_stmt(move(select_stmt_p)), alias(move(alias_p)) {
 	context.TryBindRelation(*this, this->columns);
 }
 
-unique_ptr<SelectStatement> QueryRelation::GetSelectStatement() {
+QueryRelation::~QueryRelation() {
+}
+
+unique_ptr<SelectStatement> QueryRelation::ParseStatement(ClientContext &context, const string &query,
+                                                          const string &error) {
 	Parser parser(context.GetParserOptions());
 	parser.ParseQuery(query);
 	if (parser.statements.size() != 1) {
-		throw ParserException("Expected a single SELECT statement");
+		throw ParserException(error);
 	}
 	if (parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
-		throw ParserException("Expected a single SELECT statement");
+		throw ParserException(error);
 	}
 	return unique_ptr_cast<SQLStatement, SelectStatement>(move(parser.statements[0]));
 }
 
+unique_ptr<SelectStatement> QueryRelation::GetSelectStatement() {
+	return unique_ptr_cast<SQLStatement, SelectStatement>(select_stmt->Copy());
+}
+
 unique_ptr<QueryNode> QueryRelation::GetQueryNode() {
 	auto select = GetSelectStatement();
 	return move(select->node);
@@ -111549,7 +111563,7 @@ const vector<ColumnDefinition> &QueryRelation::Columns() {
 }
 
 string QueryRelation::ToString(idx_t depth) {
-	return RenderWhitespace(depth) + "Subquery [" + query + "]";
+	return RenderWhitespace(depth) + "Subquery";
 }
 
 } // namespace duckdb
@@ -167135,8 +167149,8 @@ void UpdateSegment::CleanupUpdate(UpdateInfo *info) {
 //===--------------------------------------------------------------------===//
 // Check for conflicts in update
 //===--------------------------------------------------------------------===//
-static void CheckForConflicts(UpdateInfo *info, Transaction &transaction, row_t *ids, idx_t count, row_t offset,
-                              UpdateInfo *&node) {
+static void CheckForConflicts(UpdateInfo *info, Transaction &transaction, row_t *ids, const SelectionVector &sel,
+                              idx_t count, row_t offset, UpdateInfo *&node) {
 	if (!info) {
 		return;
 	}
@@ -167148,7 +167162,7 @@ static void CheckForConflicts(UpdateInfo *info, Transaction &transaction, row_t
 		// as both ids and info->tuples are sorted, this is similar to a merge join
 		idx_t i = 0, j = 0;
 		while (true) {
-			auto id = ids[i] - offset;
+			auto id = ids[sel.get_index(i)] - offset;
 			if (id == info->tuples[j]) {
 				throw TransactionException("Conflict on update!");
 			} else if (id < info->tuples[j]) {
@@ -167166,7 +167180,7 @@ static void CheckForConflicts(UpdateInfo *info, Transaction &transaction, row_t
 			}
 		}
 	}
-	CheckForConflicts(info->next, transaction, ids, count, offset, node);
+	CheckForConflicts(info->next, transaction, ids, sel, count, offset, node);
 }
 
 //===--------------------------------------------------------------------===//
@@ -167699,7 +167713,7 @@ void UpdateSegment::Update(Transaction &transaction, idx_t column_index, Vector
 		// there is already a version here, check if there are any conflicts and search for the node that belongs to
 		// this transaction in the version chain
 		auto base_info = root->info[vector_index]->info.get();
-		CheckForConflicts(base_info->next, transaction, ids, count, vector_offset, node);
+		CheckForConflicts(base_info->next, transaction, ids, sel, count, vector_offset, node);
 
 		// there are no conflicts
 		// first, check if this thread has already done any updates

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "c8fc68400"
-#define DUCKDB_VERSION "v0.3.2-dev1259"
+#define DUCKDB_SOURCE_ID "0d3fee81b"
+#define DUCKDB_VERSION "v0.3.2-dev1288"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -10905,6 +10905,7 @@ class ClientContext;
 class DatabaseInstance;
 class DuckDB;
 class LogicalOperator;
+class SelectStatement;
 
 typedef void (*warning_callback)(std::string);
 
@@ -11004,7 +11005,10 @@ public:
 	DUCKDB_API shared_ptr<Relation> ReadCSV(const string &csv_file);
 	DUCKDB_API shared_ptr<Relation> ReadCSV(const string &csv_file, const vector<string> &columns);
 	//! Returns a relation from a query
-	DUCKDB_API shared_ptr<Relation> RelationFromQuery(const string &query, const string &alias = "queryrelation");
+	DUCKDB_API shared_ptr<Relation> RelationFromQuery(const string &query, string alias = "queryrelation",
+	                                                  const string &error = "Expected a single SELECT statement");
+	DUCKDB_API shared_ptr<Relation> RelationFromQuery(unique_ptr<SelectStatement> select_stmt,
+	                                                  string alias = "queryrelation");
 
 	DUCKDB_API void BeginTransaction();
 	DUCKDB_API void Commit();