duckdb 0.3.2-dev941.0 → 0.3.2-dev957.0

package/package.json

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

package/src/duckdb.cpp

@@ -19364,14 +19364,14 @@ static bool IntegerCastLoop(const char *buf, idx_t len, T &result, bool strict)
 					if (pos >= len) {
 						return false;
 					}
-					int64_t exponent = 0;
+					int32_t exponent = 0;
 					int negative = buf[pos] == '-';
 					if (negative) {
-						if (!IntegerCastLoop<int64_t, true, false>(buf + pos, len - pos, exponent, strict)) {
+						if (!IntegerCastLoop<int32_t, true, false>(buf + pos, len - pos, exponent, strict)) {
 							return false;
 						}
 					} else {
-						if (!IntegerCastLoop<int64_t, false, false>(buf + pos, len - pos, exponent, strict)) {
+						if (!IntegerCastLoop<int32_t, false, false>(buf + pos, len - pos, exponent, strict)) {
 							return false;
 						}
 					}
@@ -91590,6 +91590,10 @@ struct DuckDBFunctionsFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct DuckDBKeywordsFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct DuckDBIndexesFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
@@ -93771,6 +93775,90 @@ void DuckDBIndexesFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+namespace duckdb {
+
+struct DuckDBKeywordsData : public FunctionOperatorData {
+	DuckDBKeywordsData() : offset(0) {
+	}
+
+	vector<ParserKeyword> entries;
+	idx_t offset;
+};
+
+static unique_ptr<FunctionData> DuckDBKeywordsBind(ClientContext &context, vector<Value> &inputs,
+                                                   unordered_map<string, Value> &named_parameters,
+                                                   vector<LogicalType> &input_table_types,
+                                                   vector<string> &input_table_names, vector<LogicalType> &return_types,
+                                                   vector<string> &names) {
+	names.emplace_back("keyword_name");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
+	names.emplace_back("keyword_category");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
+	return nullptr;
+}
+
+unique_ptr<FunctionOperatorData> DuckDBKeywordsInit(ClientContext &context, const FunctionData *bind_data,
+                                                    const vector<column_t> &column_ids,
+                                                    TableFilterCollection *filters) {
+	auto result = make_unique<DuckDBKeywordsData>();
+	result->entries = Parser::KeywordList();
+	return move(result);
+}
+
+void DuckDBKeywordsFunction(ClientContext &context, const FunctionData *bind_data, FunctionOperatorData *operator_state,
+                            DataChunk *input, DataChunk &output) {
+	auto &data = (DuckDBKeywordsData &)*operator_state;
+	if (data.offset >= data.entries.size()) {
+		// finished returning values
+		return;
+	}
+	// start returning values
+	// either fill up the chunk or return all the remaining columns
+	idx_t count = 0;
+	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
+		auto &entry = data.entries[data.offset++];
+
+		// keyword_name, VARCHAR
+		output.SetValue(0, count, Value(entry.name));
+		// keyword_category, VARCHAR
+		string category_name;
+		switch (entry.category) {
+		case KeywordCategory::KEYWORD_RESERVED:
+			category_name = "reserved";
+			break;
+		case KeywordCategory::KEYWORD_UNRESERVED:
+			category_name = "unreserved";
+			break;
+		case KeywordCategory::KEYWORD_TYPE_FUNC:
+			category_name = "type_function";
+			break;
+		case KeywordCategory::KEYWORD_COL_NAME:
+			category_name = "column_name";
+			break;
+		default:
+			throw InternalException("Unrecognized keyword category");
+		}
+		output.SetValue(1, count, Value(move(category_name)));
+
+		count++;
+	}
+	output.SetCardinality(count);
+}
+
+void DuckDBKeywordsFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(
+	    TableFunction("duckdb_keywords", {}, DuckDBKeywordsFunction, DuckDBKeywordsBind, DuckDBKeywordsInit));
+}
+
+} // namespace duckdb
+
+
+
+
+
+
 
 namespace duckdb {
 
@@ -95461,6 +95549,7 @@ void BuiltinFunctions::RegisterSQLiteFunctions() {
 	DuckDBColumnsFun::RegisterFunction(*this);
 	DuckDBConstraintsFun::RegisterFunction(*this);
 	DuckDBFunctionsFun::RegisterFunction(*this);
+	DuckDBKeywordsFun::RegisterFunction(*this);
 	DuckDBIndexesFun::RegisterFunction(*this);
 	DuckDBSchemasFun::RegisterFunction(*this);
 	DuckDBDependenciesFun::RegisterFunction(*this);
@@ -134906,6 +134995,7 @@ private:
 
 
 #include <cstdint>
+#include <string>
 
 namespace duckdb_libpgquery {
 
@@ -134923,6 +135013,18 @@ struct PGSimplifiedToken {
 	int32_t start;
 };
 
+enum class PGKeywordCategory : uint8_t {
+	PG_KEYWORD_RESERVED,
+	PG_KEYWORD_UNRESERVED,
+	PG_KEYWORD_TYPE_FUNC,
+	PG_KEYWORD_COL_NAME
+};
+
+struct PGKeyword {
+	std::string text;
+	PGKeywordCategory category;
+};
+
 }
 
 
@@ -134944,6 +135046,7 @@ public:
 	static std::vector<duckdb_libpgquery::PGSimplifiedToken> Tokenize(const std::string &query);
 
 	static bool IsKeyword(const std::string &text);
+	static std::vector<duckdb_libpgquery::PGKeyword> KeywordList();
 };
 }
 
@@ -134990,6 +135093,7 @@ typedef enum PGBackslashQuoteType {
 PGList *raw_parser(const char *str);
 
 bool is_keyword(const char *str);
+std::vector<PGKeyword> keyword_list();
 
 std::vector<PGSimplifiedToken> tokenize(const char *str);
 
@@ -135065,6 +135169,8 @@ vector<SimplifiedToken> Parser::Tokenize(const string &query) {
 		case duckdb_libpgquery::PGSimplifiedTokenType::PG_SIMPLIFIED_TOKEN_COMMENT: // LCOV_EXCL_START
 			token.type = SimplifiedTokenType::SIMPLIFIED_TOKEN_COMMENT;
 			break;
+		default:
+			throw InternalException("Unrecognized token category");
 		} // LCOV_EXCL_STOP
 		token.start = pg_token.start;
 		result.push_back(token);
@@ -135076,6 +135182,33 @@ bool Parser::IsKeyword(const string &text) {
 	return PostgresParser::IsKeyword(text);
 }
 
+vector<ParserKeyword> Parser::KeywordList() {
+	auto keywords = PostgresParser::KeywordList();
+	vector<ParserKeyword> result;
+	for (auto &kw : keywords) {
+		ParserKeyword res;
+		res.name = kw.text;
+		switch (kw.category) {
+		case duckdb_libpgquery::PGKeywordCategory::PG_KEYWORD_RESERVED:
+			res.category = KeywordCategory::KEYWORD_RESERVED;
+			break;
+		case duckdb_libpgquery::PGKeywordCategory::PG_KEYWORD_UNRESERVED:
+			res.category = KeywordCategory::KEYWORD_UNRESERVED;
+			break;
+		case duckdb_libpgquery::PGKeywordCategory::PG_KEYWORD_TYPE_FUNC:
+			res.category = KeywordCategory::KEYWORD_TYPE_FUNC;
+			break;
+		case duckdb_libpgquery::PGKeywordCategory::PG_KEYWORD_COL_NAME:
+			res.category = KeywordCategory::KEYWORD_COL_NAME;
+			break;
+		default:
+			throw InternalException("Unrecognized keyword category");
+		}
+		result.push_back(res);
+	}
+	return result;
+}
+
 vector<unique_ptr<ParsedExpression>> Parser::ParseExpressionList(const string &select_list) {
 	// construct a mock query prefixed with SELECT
 	string mock_query = "SELECT " + select_list;
@@ -135765,7 +135898,17 @@ unique_ptr<ResultModifier> OrderModifier::Copy() {
 
 string OrderByNode::ToString() const {
 	auto str = expression->ToString();
-	str += (type == OrderType::ASCENDING) ? " ASC" : " DESC";
+	switch (type) {
+	case OrderType::ASCENDING:
+		str += " ASC";
+		break;
+	case OrderType::DESCENDING:
+		str += " DESC";
+		break;
+	default:
+		break;
+	}
+
 	switch (null_order) {
 	case OrderByNullType::NULLS_FIRST:
 		str += " NULLS FIRST";
@@ -139151,6 +139294,7 @@ void Transformer::AddGroupByExpression(unique_ptr<ParsedExpression> expression,
 
 static void AddCubeSets(const GroupingSet &current_set, vector<GroupingSet> &result_set,
                         vector<GroupingSet> &result_sets, idx_t start_idx = 0) {
+	CheckGroupingSetMax(result_sets.size());
 	result_sets.push_back(current_set);
 	for (idx_t k = start_idx; k < result_set.size(); k++) {
 		auto child_set = current_set;
@@ -139373,6 +139517,8 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName *type_n
 	if (type_name->type != duckdb_libpgquery::T_PGTypeName) {
 		throw ParserException("Expected a type");
 	}
+	auto stack_checker = StackCheck();
+
 	auto name = (reinterpret_cast<duckdb_libpgquery::PGValue *>(type_name->names->tail->data.ptr_value)->val.str);
 	// transform it to the SQL type
 	LogicalTypeId base_type = TransformStringToLogicalType(name);
@@ -139501,8 +139647,10 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName *type_n
 	}
 	if (type_name->arrayBounds) {
 		// array bounds: turn the type into a list
+		idx_t extra_stack = 0;
 		for (auto cell = type_name->arrayBounds->head; cell != nullptr; cell = cell->next) {
 			result_type = LogicalType::LIST(move(result_type));
+			StackCheck(extra_stack++);
 		}
 	}
 	return result_type;
@@ -139738,8 +139886,14 @@ unique_ptr<CopyStatement> Transformer::TransformCopy(duckdb_libpgquery::PGNode *
 	auto &info = *result->info;
 
 	// get file_path and is_from
-	info.file_path = stmt->filename;
 	info.is_from = stmt->is_from;
+	if (!stmt->filename) {
+		// stdin/stdout
+		info.file_path = info.is_from ? "/dev/stdin" : "/dev/stdout";
+	} else {
+		// copy to a file
+		info.file_path = stmt->filename;
+	}
 	if (StringUtil::EndsWith(info.file_path, ".parquet")) {
 		info.format = "parquet";
 	} else {
@@ -222079,6 +222233,10 @@ bool PostgresParser::IsKeyword(const std::string &text) {
 	return duckdb_libpgquery::is_keyword(text.c_str());
 }
 
+vector<duckdb_libpgquery::PGKeyword> PostgresParser::KeywordList() {
+	return duckdb_libpgquery::keyword_list();
+}
+
 }
 
 
@@ -250861,6 +251019,30 @@ bool is_keyword(const char *text) {
 	return ScanKeywordLookup(text, ScanKeywords, NumScanKeywords) != NULL;
 }
 
+std::vector<PGKeyword> keyword_list() {
+    std::vector<PGKeyword> result;
+	for(size_t i = 0; i < NumScanKeywords; i++) {
+		PGKeyword keyword;
+		keyword.text = ScanKeywords[i].name;
+		switch(ScanKeywords[i].category) {
+		case UNRESERVED_KEYWORD:
+			keyword.category = PGKeywordCategory::PG_KEYWORD_UNRESERVED;
+			break;
+		case RESERVED_KEYWORD:
+			keyword.category = PGKeywordCategory::PG_KEYWORD_RESERVED;
+			break;
+		case TYPE_FUNC_NAME_KEYWORD:
+			keyword.category = PGKeywordCategory::PG_KEYWORD_TYPE_FUNC;
+			break;
+		case COL_NAME_KEYWORD:
+			keyword.category = PGKeywordCategory::PG_KEYWORD_COL_NAME;
+			break;
+		}
+		result.push_back(keyword);
+	}
+	return result;
+}
+
 std::vector<PGSimplifiedToken> tokenize(const char *str) {
 	core_yyscan_t yyscanner;
 	base_yy_extra_type yyextra;

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 "b701ecd1d"
-#define DUCKDB_VERSION "0.3.2-dev941"
+#define DUCKDB_SOURCE_ID "b33df7694"
+#define DUCKDB_VERSION "0.3.2-dev957"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -19831,6 +19831,13 @@ struct SimplifiedToken {
 	idx_t start;
 };
 
+enum class KeywordCategory : uint8_t { KEYWORD_RESERVED, KEYWORD_UNRESERVED, KEYWORD_TYPE_FUNC, KEYWORD_COL_NAME };
+
+struct ParserKeyword {
+	string name;
+	KeywordCategory category;
+};
+
 } // namespace duckdb
 
 
@@ -19848,6 +19855,10 @@ class Parser {
 public:
 	Parser();
 
+	//! The parsed SQL statements from an invocation to ParseQuery.
+	vector<unique_ptr<SQLStatement>> statements;
+
+public:
 	//! Attempts to parse a query into a series of SQL statements. Returns
 	//! whether or not the parsing was successful. If the parsing was
 	//! successful, the parsed statements will be stored in the statements
@@ -19859,6 +19870,8 @@ public:
 
 	//! Returns true if the given text matches a keyword of the parser
 	static bool IsKeyword(const string &text);
+	//! Returns a list of all keywords in the parser
+	static vector<ParserKeyword> KeywordList();
 
 	//! Parses a list of expressions (i.e. the list found in a SELECT clause)
 	static vector<unique_ptr<ParsedExpression>> ParseExpressionList(const string &select_list);
@@ -19871,15 +19884,6 @@ public:
 	static vector<vector<unique_ptr<ParsedExpression>>> ParseValuesList(const string &value_list);
 	//! Parses a column list (i.e. as found in a CREATE TABLE statement)
 	static vector<ColumnDefinition> ParseColumnList(const string &column_list);
-
-	//! The parsed SQL statements from an invocation to ParseQuery.
-	vector<unique_ptr<SQLStatement>> statements;
-
-private:
-	//! Transform a Postgres parse tree into a set of SQL Statements
-	bool TransformList(duckdb_libpgquery::PGList *tree);
-	//! Transform a single Postgres parse node into a SQL Statement.
-	unique_ptr<SQLStatement> TransformNode(duckdb_libpgquery::PGNode *stmt);
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//