duckdb 0.4.1-dev815.0 → 0.4.1-dev829.0

package/package.json

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

package/src/duckdb.cpp

@@ -162662,6 +162662,31 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName *type_n
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enum_class_hash.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+#include <cstddef>
+
+namespace duckdb {
+/* For compatibility with older C++ STL, an explicit hash class
+   is required for enums with C++ sets and maps */
+struct EnumClassHash {
+	template <typename T>
+	std::size_t operator()(T t) const {
+		return static_cast<std::size_t>(t);
+	}
+};
+} // namespace duckdb
+
+
+
 namespace duckdb {
 
 unique_ptr<AlterStatement> Transformer::TransformAlterSequence(duckdb_libpgquery::PGNode *node) {
@@ -162677,12 +162702,18 @@ unique_ptr<AlterStatement> Transformer::TransformAlterSequence(duckdb_libpgquery
 		throw InternalException("Expected an argument for ALTER SEQUENCE.");
 	}
 
+	unordered_set<SequenceInfo, EnumClassHash> used;
 	duckdb_libpgquery::PGListCell *cell = nullptr;
 	for_each_cell(cell, stmt->options->head) {
 		auto *def_elem = reinterpret_cast<duckdb_libpgquery::PGDefElem *>(cell->data.ptr_value);
 		string opt_name = string(def_elem->defname);
 
 		if (opt_name == "owned_by") {
+			if (used.find(SequenceInfo::SEQ_OWN) != used.end()) {
+				throw ParserException("Owned by value should be passed as most once");
+			}
+			used.insert(SequenceInfo::SEQ_OWN);
+
 			auto val = (duckdb_libpgquery::PGValue *)def_elem->arg;
 			if (!val) {
 				throw InternalException("Expected an argument for option %s", opt_name);
@@ -162733,8 +162764,11 @@ unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode
 	D_ASSERT(stmt);
 	D_ASSERT(stmt->relation);
 
-	auto result = make_unique<AlterStatement>();
+	if (stmt->cmds->length != 1) {
+		throw ParserException("Only one ALTER command per statement is supported");
+	}
 
+	auto result = make_unique<AlterStatement>();
 	auto qname = TransformQualifiedName(stmt->relation);
 
 	// first we check the type of ALTER
@@ -162744,6 +162778,10 @@ unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode
 		switch (command->subtype) {
 		case duckdb_libpgquery::PG_AT_AddColumn: {
 			auto cdef = (duckdb_libpgquery::PGColumnDef *)command->def;
+
+			if (stmt->relkind != duckdb_libpgquery::PG_OBJECT_TABLE) {
+				throw ParserException("Adding columns is only supported for tables");
+			}
 			if (cdef->category == duckdb_libpgquery::COL_GENERATED) {
 				throw ParserException("Adding generated columns after table creation is not supported yet");
 			}
@@ -162763,20 +162801,31 @@ unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode
 		}
 		case duckdb_libpgquery::PG_AT_DropColumn: {
 			bool cascade = command->behavior == duckdb_libpgquery::PG_DROP_CASCADE;
+
+			if (stmt->relkind != duckdb_libpgquery::PG_OBJECT_TABLE) {
+				throw ParserException("Dropping columns is only supported for tables");
+			}
 			result->info =
 			    make_unique<RemoveColumnInfo>(qname.schema, qname.name, command->name, command->missing_ok, cascade);
 			break;
 		}
 		case duckdb_libpgquery::PG_AT_ColumnDefault: {
 			auto expr = TransformExpression(command->def);
+
+			if (stmt->relkind != duckdb_libpgquery::PG_OBJECT_TABLE) {
+				throw ParserException("Alter column's default is only supported for tables");
+			}
 			result->info = make_unique<SetDefaultInfo>(qname.schema, qname.name, command->name, move(expr));
 			break;
 		}
 		case duckdb_libpgquery::PG_AT_AlterColumnType: {
 			auto cdef = (duckdb_libpgquery::PGColumnDef *)command->def;
 			auto column_definition = TransformColumnDefinition(cdef);
-
 			unique_ptr<ParsedExpression> expr;
+
+			if (stmt->relkind != duckdb_libpgquery::PG_OBJECT_TABLE) {
+				throw ParserException("Alter column's type is only supported for tables");
+			}
 			if (cdef->raw_default) {
 				expr = TransformExpression(cdef->raw_default);
 			} else {
@@ -163128,6 +163177,8 @@ unique_ptr<CreateStatement> Transformer::TransformCreateSchema(duckdb_libpgquery
 
 
 
+
+
 namespace duckdb {
 
 unique_ptr<CreateStatement> Transformer::TransformCreateSequence(duckdb_libpgquery::PGNode *node) {
@@ -163141,27 +163192,35 @@ unique_ptr<CreateStatement> Transformer::TransformCreateSequence(duckdb_libpgque
 	info->name = qname.name;
 
 	if (stmt->options) {
+		unordered_set<SequenceInfo, EnumClassHash> used;
 		duckdb_libpgquery::PGListCell *cell = nullptr;
 		for_each_cell(cell, stmt->options->head) {
 			auto *def_elem = reinterpret_cast<duckdb_libpgquery::PGDefElem *>(cell->data.ptr_value);
 			string opt_name = string(def_elem->defname);
-
 			auto val = (duckdb_libpgquery::PGValue *)def_elem->arg;
-			if (def_elem->defaction == duckdb_libpgquery::PG_DEFELEM_UNSPEC && !val) { // e.g. NO MINVALUE
-				continue;
-			}
-			D_ASSERT(val);
-			int64_t opt_value;
-			if (val->type == duckdb_libpgquery::T_PGInteger) {
-				opt_value = val->val.ival;
-			} else if (val->type == duckdb_libpgquery::T_PGFloat) {
-				if (!TryCast::Operation<string_t, int64_t>(string_t(val->val.str), opt_value, true)) {
+			bool nodef = def_elem->defaction == duckdb_libpgquery::PG_DEFELEM_UNSPEC && !val; // e.g. NO MINVALUE
+			int64_t opt_value = 0;
+
+			if (val) {
+				if (val->type == duckdb_libpgquery::T_PGInteger) {
+					opt_value = val->val.ival;
+				} else if (val->type == duckdb_libpgquery::T_PGFloat) {
+					if (!TryCast::Operation<string_t, int64_t>(string_t(val->val.str), opt_value, true)) {
+						throw ParserException("Expected an integer argument for option %s", opt_name);
+					}
+				} else {
 					throw ParserException("Expected an integer argument for option %s", opt_name);
 				}
-			} else {
-				throw ParserException("Expected an integer argument for option %s", opt_name);
 			}
 			if (opt_name == "increment") {
+				if (used.find(SequenceInfo::SEQ_INC) != used.end()) {
+					throw ParserException("Increment value should be passed as most once");
+				}
+				used.insert(SequenceInfo::SEQ_INC);
+				if (nodef) {
+					continue;
+				}
+
 				info->increment = opt_value;
 				if (info->increment == 0) {
 					throw ParserException("Increment must not be zero");
@@ -163174,18 +163233,50 @@ unique_ptr<CreateStatement> Transformer::TransformCreateSequence(duckdb_libpgque
 					info->max_value = NumericLimits<int64_t>::Maximum();
 				}
 			} else if (opt_name == "minvalue") {
+				if (used.find(SequenceInfo::SEQ_MIN) != used.end()) {
+					throw ParserException("Minvalue should be passed as most once");
+				}
+				used.insert(SequenceInfo::SEQ_MIN);
+				if (nodef) {
+					continue;
+				}
+
 				info->min_value = opt_value;
 				if (info->increment > 0) {
 					info->start_value = info->min_value;
 				}
 			} else if (opt_name == "maxvalue") {
+				if (used.find(SequenceInfo::SEQ_MAX) != used.end()) {
+					throw ParserException("Maxvalue should be passed as most once");
+				}
+				used.insert(SequenceInfo::SEQ_MAX);
+				if (nodef) {
+					continue;
+				}
+
 				info->max_value = opt_value;
 				if (info->increment < 0) {
 					info->start_value = info->max_value;
 				}
 			} else if (opt_name == "start") {
+				if (used.find(SequenceInfo::SEQ_START) != used.end()) {
+					throw ParserException("Start value should be passed as most once");
+				}
+				used.insert(SequenceInfo::SEQ_START);
+				if (nodef) {
+					continue;
+				}
+
 				info->start_value = opt_value;
 			} else if (opt_name == "cycle") {
+				if (used.find(SequenceInfo::SEQ_CYCLE) != used.end()) {
+					throw ParserException("Cycle value should be passed as most once");
+				}
+				used.insert(SequenceInfo::SEQ_CYCLE);
+				if (nodef) {
+					continue;
+				}
+
 				info->cycle = opt_value > 0;
 			} else {
 				throw ParserException("Unrecognized option \"%s\" for CREATE SEQUENCE", opt_name);
@@ -163966,6 +164057,7 @@ unique_ptr<AlterStatement> Transformer::TransformRename(duckdb_libpgquery::PGNod
 		throw NotImplementedException("Schema element not supported yet!");
 	}
 	D_ASSERT(info);
+	info->if_exists = stmt->missing_ok;
 
 	auto result = make_unique<AlterStatement>();
 	result->info = move(info);
@@ -164537,6 +164629,9 @@ unique_ptr<TableRef> Transformer::TransformRangeSubselect(duckdb_libpgquery::PGR
 	if (!subquery) {
 		return nullptr;
 	}
+	if (root->lateral) {
+		throw NotImplementedException("LATERAL not implemented");
+	}
 	auto result = make_unique<SubqueryRef>(move(subquery));
 	result->alias = TransformAlias(root->alias, result->column_name_alias);
 	if (root->sample) {

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 "4650df619"
-#define DUCKDB_VERSION "v0.4.1-dev815"
+#define DUCKDB_SOURCE_ID "195b7b47b"
+#define DUCKDB_VERSION "v0.4.1-dev829"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -12208,6 +12208,21 @@ public:
 
 namespace duckdb {
 
+enum class SequenceInfo : uint8_t {
+	// Sequence start
+	SEQ_START,
+	// Sequence increment
+	SEQ_INC,
+	// Sequence minimum value
+	SEQ_MIN,
+	// Sequence maximum value
+	SEQ_MAX,
+	// Sequence cycle option
+	SEQ_CYCLE,
+	// Sequence owner table
+	SEQ_OWN
+};
+
 struct CreateSequenceInfo : public CreateInfo {
 	CreateSequenceInfo()
 	    : CreateInfo(CatalogType::SEQUENCE_ENTRY, INVALID_SCHEMA), name(string()), usage_count(0), increment(1),