duckdb 0.3.2-dev955.0 → 0.3.2-dev957.0

package/package.json

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

package/src/duckdb.cpp

@@ -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;
@@ -222100,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();
+}
+
 }
 
 
@@ -250882,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 "0fead7880"
-#define DUCKDB_VERSION "0.3.2-dev955"
+#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
 //===----------------------------------------------------------------------===//