Merge branch '71-generated-support' into 'main'
Resolve "Improve GENERATED support" Closes #71 See merge request eelke/pgLab!11
This commit is contained in:
Eelke Klein
commit
50c45426d9
13 changed files with 749 additions and 246 deletions
|
|
@ -12,6 +12,7 @@
|
|||
#include "ScopeGuard.h"
|
||||
#include "SqlFormattingUtils.h"
|
||||
#include <QBrush>
|
||||
#include <QStringBuilder>
|
||||
|
||||
namespace {
|
||||
|
||||
|
|
@ -142,18 +143,6 @@ int ColumnTableModel::columnCount(const QModelIndex &/*parent*/) const
|
|||
Oid ColumnTableModel::getType(int /*column*/) const
|
||||
{
|
||||
Oid oid = Pgsql::varchar_oid;
|
||||
// switch (column) {
|
||||
// case TypeCol:
|
||||
// case NameCol:
|
||||
// case NullCol:
|
||||
// case DefaultCol:
|
||||
// case CollationCol:
|
||||
// oid = VARCHAROID;
|
||||
// break;
|
||||
|
||||
// c = tr("Collation");
|
||||
// break;
|
||||
// }
|
||||
return oid;
|
||||
}
|
||||
|
||||
|
|
@ -191,7 +180,7 @@ QVariant ColumnTableModel::getData(const QModelIndex &index) const
|
|||
v = QString::fromStdU16String(t.notnull ? u"" : u"N");
|
||||
break;
|
||||
case DefaultCol:
|
||||
v = t.defaultValue;
|
||||
v = getDefaultString(t);
|
||||
break;
|
||||
case ForeignKeyCol:
|
||||
v = getFKey(t);
|
||||
|
|
@ -222,7 +211,36 @@ QString ColumnTableModel::getFKey(const PgAttribute &column) const
|
|||
result = getForeignKeyConstraintReferencesShort(*m_catalog, elem);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
return result;
|
||||
}
|
||||
|
||||
QString ColumnTableModel::getDefaultString(const PgAttribute &column) const
|
||||
{
|
||||
if (column.identity != '\0') {
|
||||
QString sql = "GENERATED ";
|
||||
switch (column.identity) {
|
||||
case 'a':
|
||||
sql += "ALWAYS";
|
||||
break;
|
||||
case 'd':
|
||||
sql += "BY DEFAULT";
|
||||
break;
|
||||
}
|
||||
sql += " AS IDENTITY";
|
||||
// TODO sequence options might be missing
|
||||
return sql;
|
||||
}
|
||||
|
||||
if (column.generated != '\0')
|
||||
{
|
||||
return "GENERATED ALWAYS AS " % column.defaultValue % " STORED";
|
||||
}
|
||||
|
||||
|
||||
if (column.hasdef)
|
||||
return column.defaultValue;
|
||||
|
||||
return {};
|
||||
}
|
||||
|
||||
void ColumnTableModel::refresh()
|
||||
|
|
|
|||
|
|
@ -55,8 +55,7 @@ protected:
|
|||
QMetaObject::Connection refreshConnection;
|
||||
|
||||
QString getFKey(const PgAttribute &column) const;
|
||||
|
||||
|
||||
QString getDefaultString(const PgAttribute &column) const;
|
||||
|
||||
private slots:
|
||||
/// Retrieves required data from catalog, called everytime it might have changed
|
||||
|
|
|
|||
|
|
@ -169,7 +169,7 @@ QVariant CrudModel::data(const QModelIndex &index, int role) const
|
|||
if (index.column() < PreColumnCount)
|
||||
{
|
||||
if (role == Qt::DisplayRole || role == CustomSortRole)
|
||||
return index.row();
|
||||
return index.row() + 1;
|
||||
else if (role == CustomDataTypeRole)
|
||||
return Pgsql::int4_oid;
|
||||
|
||||
|
|
@ -231,6 +231,7 @@ void CrudModel::loadIntoModel(std::shared_ptr<Pgsql::Result> data)
|
|||
beginResetModel();
|
||||
m_pendingRowList.clear();
|
||||
m_roData = data;
|
||||
initializeColumnList();
|
||||
lastRowKey = data->rows() - 1;
|
||||
initRowMapping();
|
||||
appendNewRow();
|
||||
|
|
@ -276,7 +277,7 @@ Qt::ItemFlags CrudModel::flags(const QModelIndex &index) const
|
|||
if (index.column() < PreColumnCount)
|
||||
return flags;
|
||||
|
||||
if (m_primaryKey)
|
||||
if (m_primaryKey && !columnIsReadOnly(index.column()))
|
||||
flags |= Qt::ItemIsEditable;
|
||||
|
||||
return flags;
|
||||
|
|
@ -419,21 +420,16 @@ std::tuple<QString, Pgsql::Params> CrudModel::createInsertQuery(const PendingRow
|
|||
QTextStream q(&buffer);
|
||||
q << "INSERT INTO " << table_name << "(";
|
||||
|
||||
auto columns = m_database->catalog()->attributes()->getColumnsForRelation(m_table->oid());
|
||||
bool first = true;
|
||||
for (const auto& e : data)
|
||||
{
|
||||
int num = e.first + 1;
|
||||
auto find_res = std::find_if(columns.begin(), columns.end(),
|
||||
[num] (const auto &elem) -> bool { return num == elem.num; });
|
||||
if (find_res != columns.end())
|
||||
{
|
||||
if (first)
|
||||
first = false;
|
||||
else
|
||||
q << ",";
|
||||
q << find_res->name;
|
||||
}
|
||||
int num = e.first;
|
||||
auto&& column = columnList[num];
|
||||
if (first)
|
||||
first = false;
|
||||
else
|
||||
q << ",";
|
||||
q << column.name;
|
||||
}
|
||||
q << ") VALUES ($1";
|
||||
for (size_t p = 2; p <= data.size(); ++p)
|
||||
|
|
@ -515,6 +511,30 @@ bool CrudModel::IsLastRow(RowMappingVector::iterator mapping_iter) const
|
|||
return mapping_iter == --m_rowMapping.end();
|
||||
}
|
||||
|
||||
bool CrudModel::columnIsReadOnly(int column_index) const
|
||||
{
|
||||
if (m_roData == nullptr)
|
||||
return true;
|
||||
|
||||
auto&& column = columnList[column_index - PreColumnCount];
|
||||
return column.getIdentity() == PgAttribute::Identity::Always
|
||||
|| column.getGenerated() != PgAttribute::Generated::None;
|
||||
}
|
||||
|
||||
void CrudModel::initializeColumnList()
|
||||
{
|
||||
columnList.clear();
|
||||
columnList.reserve(m_roData->cols());
|
||||
auto columns = m_database->catalog()->attributes()->getColumnsForRelation(m_table->oid());
|
||||
for (int col = 0; col < m_roData->cols(); ++col)
|
||||
{
|
||||
int attnum = m_roData->ftableCol(col);
|
||||
auto find_result = std::find_if(columns.begin(), columns.end(), [attnum](const PgAttribute &att) { return att.num == attnum; });
|
||||
assert(find_result != columns.end());
|
||||
columnList.push_back(*find_result);
|
||||
}
|
||||
}
|
||||
|
||||
bool CrudModel::submit()
|
||||
{
|
||||
return savePendingChanges();
|
||||
|
|
|
|||
|
|
@ -15,6 +15,7 @@
|
|||
#include <vector>
|
||||
#include <optional>
|
||||
|
||||
class PgAttribute;
|
||||
class PgConstraint;
|
||||
class OpenDatabase;
|
||||
|
||||
|
|
@ -210,6 +211,7 @@ private:
|
|||
bool callLoadData = false;
|
||||
|
||||
std::shared_ptr<Pgsql::Result> m_roData;
|
||||
std::vector<PgAttribute> columnList; // list of columnMeta 1 to 1 with columns in m_roData.
|
||||
|
||||
PendingRowList m_pendingRowList;
|
||||
|
||||
|
|
@ -256,6 +258,8 @@ private:
|
|||
void RemoveRangeOfRowsFromModel(IntegerRange<int> row_range);
|
||||
|
||||
bool IsLastRow(RowMappingVector::iterator mapping_iter) const;
|
||||
bool columnIsReadOnly(int column_index) const;
|
||||
void initializeColumnList();
|
||||
private slots:
|
||||
|
||||
void loadIntoModel(std::shared_ptr<Pgsql::Result> data);
|
||||
|
|
|
|||
|
|
@ -3,18 +3,43 @@
|
|||
#include "SqlFormattingUtils.h"
|
||||
#include "PgClass.h"
|
||||
#include "PgDatabaseCatalog.h"
|
||||
#include "PgSequenceContainer.h"
|
||||
#include "PgTypeContainer.h"
|
||||
#include "PgCollation.h"
|
||||
#include "PgCollationContainer.h"
|
||||
#include "Pgsql_oids.h"
|
||||
|
||||
|
||||
PgAttribute::Identity PgAttribute::getIdentity() const
|
||||
{
|
||||
switch (identity)
|
||||
{
|
||||
case '\0': return Identity::None;
|
||||
case 'a': return Identity::Always;
|
||||
case 'd': return Identity::ByDefault;
|
||||
}
|
||||
assert(false); // we shouldn't get here
|
||||
return {};
|
||||
}
|
||||
|
||||
PgAttribute::Generated PgAttribute::getGenerated() const
|
||||
{
|
||||
switch (generated)
|
||||
{
|
||||
case '\0': return Generated::None;
|
||||
case 's': return Generated::Stored;
|
||||
}
|
||||
assert(false); // we shouldn't get here
|
||||
return {};
|
||||
}
|
||||
|
||||
QString PgAttribute::columnDefinition(const PgDatabaseCatalog &cat) const
|
||||
{
|
||||
// create: column_name data_type [ COLLATE collation ] [ column_constraint [ ... ]
|
||||
// alter: column_name data_type [ COLLATE collation ] [ column_constraint [ ... ]
|
||||
// constraints NULL/NOT NULL, DEFAULT, GENERATED other constraints will be ignored here a
|
||||
QString type_str;
|
||||
if (isSerial()) {
|
||||
if (isSerial() && identity == '\0') {
|
||||
if (typid == Pgsql::int4_oid)
|
||||
type_str = "SERIAL";
|
||||
else if (typid == Pgsql::int8_oid)
|
||||
|
|
@ -35,16 +60,31 @@ QString PgAttribute::columnDefinition(const PgDatabaseCatalog &cat) const
|
|||
if (notnull)
|
||||
sql += " NOT NULL";
|
||||
|
||||
if (hasdef && !isSerial())
|
||||
sql += " DEFAULT " % defaultValue;
|
||||
|
||||
if (identity != '\0') {
|
||||
auto identity = getIdentity();
|
||||
auto generated = getGenerated();
|
||||
if (identity != Identity::None) {
|
||||
sql += " GENERATED ";
|
||||
if (identity == 'a') sql += "ALWAYS";
|
||||
else if (identity == 'd') sql += "BY DEFAULT";
|
||||
if (identity == Identity::Always)
|
||||
sql += "ALWAYS";
|
||||
else if (identity == Identity::ByDefault)
|
||||
sql += "BY DEFAULT";
|
||||
sql += " AS IDENTITY";
|
||||
|
||||
auto sequence = cat.sequences()->getByObjectNsAndName(serschema, sername);
|
||||
auto options_string = sequence->nonDefaultOptionsString();
|
||||
if (!options_string.isEmpty())
|
||||
sql += "(" % options_string % ")";
|
||||
}
|
||||
// TODO sequence options might be missing
|
||||
else if (generated != Generated::None)
|
||||
{
|
||||
if (generated == Generated::Stored)
|
||||
sql += " GENERATED ALWAYS AS " % defaultValue % " STORED";
|
||||
}
|
||||
else
|
||||
{
|
||||
if (hasdef && !isSerial())
|
||||
sql += " DEFAULT " % defaultValue;
|
||||
}
|
||||
|
||||
return sql;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,6 +11,16 @@ class PgDatabaseCatalog;
|
|||
|
||||
class PgAttribute {
|
||||
public:
|
||||
enum class Identity {
|
||||
None,
|
||||
Always,
|
||||
ByDefault
|
||||
};
|
||||
enum class Generated {
|
||||
None,
|
||||
Stored
|
||||
};
|
||||
|
||||
using Key = std::tuple<Oid, int16_t>;
|
||||
|
||||
Oid relid = InvalidOid;
|
||||
|
|
@ -23,12 +33,16 @@ public:
|
|||
bool notnull = false;
|
||||
bool hasdef = false;
|
||||
char identity = '\0';
|
||||
char generated = '\0';
|
||||
bool isdropped = false;
|
||||
bool islocal = true;
|
||||
Oid collation = InvalidOid;
|
||||
QString acl;
|
||||
QString options;
|
||||
|
||||
Identity getIdentity() const;
|
||||
Generated getGenerated() const;
|
||||
|
||||
QString defaultValue; ///< Comes from pg_attrdef table
|
||||
QString sername, serschema; // serial sequence name and schema
|
||||
QString description; ///< from pg_description
|
||||
|
|
|
|||
|
|
@ -16,7 +16,9 @@ SELECT attrelid, attname, atttypid, attstattarget,
|
|||
cs.relname AS sername, ns.nspname AS serschema, d.description)__";
|
||||
if (m_catalog.serverVersion() >= 100000)
|
||||
q += ", attidentity";
|
||||
q += R"__(
|
||||
if (m_catalog.serverVersion() >= 120000)
|
||||
q += ", attgenerated";
|
||||
q += R"__(
|
||||
FROM pg_catalog.pg_attribute AS att
|
||||
LEFT JOIN pg_attrdef AS def ON attrelid=adrelid AND attnum=adnum
|
||||
LEFT JOIN (pg_depend JOIN pg_class cs ON classid='pg_class'::regclass AND objid=cs.oid AND cs.relkind='S') ON refobjid=att.attrelid AND refobjsubid=att.attnum
|
||||
|
|
@ -36,6 +38,8 @@ PgAttribute PgAttributeContainer::loadElem(const Pgsql::Row &row)
|
|||
>> v.sername >> v.serschema >> v.description;
|
||||
if (m_catalog.serverVersion() >= 100000)
|
||||
col >> v.identity;
|
||||
if (m_catalog.serverVersion() >= 120000)
|
||||
col >> v.generated;
|
||||
|
||||
return v;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -78,6 +78,36 @@ public:
|
|||
return nullptr;
|
||||
}
|
||||
|
||||
const T* getByObjectName(const QString &name) const
|
||||
{
|
||||
auto find_res = std::find_if(m_container.begin(), m_container.end(),
|
||||
[&name](const T& item)
|
||||
{
|
||||
return item.objectName() == name;
|
||||
});
|
||||
|
||||
if (find_res != m_container.end())
|
||||
return &*find_res;
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
const T* getByObjectNsAndName(const QString &ns, const QString &name) const
|
||||
{
|
||||
auto find_res = std::find_if(m_container.begin(), m_container.end(),
|
||||
[&ns, &name](const T& item)
|
||||
{
|
||||
// check name first as it is less likely to pass
|
||||
return item.objectName() == name
|
||||
&& item.nsName() == ns;
|
||||
});
|
||||
|
||||
if (find_res != m_container.end())
|
||||
return &*find_res;
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
/// Retrieve element by index
|
||||
///
|
||||
/// This function throws when idx is out of range
|
||||
|
|
|
|||
|
|
@ -5,119 +5,11 @@ namespace {
|
|||
|
||||
using KeywordHT = std::unordered_set<Keyword>;
|
||||
|
||||
#define PG_KEYWORD(a,b,c) Keyword{a,c},
|
||||
#define PG_KEYWORD(a,b,c,d) Keyword{a,c},
|
||||
const KeywordHT _ScanKeywords = {
|
||||
//const Keyword _ScanKeywords[] = {
|
||||
#include <server/parser/kwlist.h>
|
||||
};
|
||||
#include "kwlist.h"
|
||||
|
||||
// The following keyword list are for plpgsql and are copied from the postgresql source.
|
||||
// src\pl\plpgsql\src\pl_scanner.c
|
||||
|
||||
static const KeywordHT plpgsql_reserved_keywords = {
|
||||
PG_KEYWORD("all", K_ALL, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("begin", K_BEGIN, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("by", K_BY, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("case", K_CASE, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("declare", K_DECLARE, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("else", K_ELSE, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("end", K_END, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("execute", K_EXECUTE, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("for", K_FOR, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("foreach", K_FOREACH, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("from", K_FROM, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("if", K_IF, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("in", K_IN, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("into", K_INTO, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("loop", K_LOOP, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("not", K_NOT, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("null", K_NULL, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("or", K_OR, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("strict", K_STRICT, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("then", K_THEN, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("to", K_TO, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("using", K_USING, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("when", K_WHEN, RESERVED_KEYWORD)
|
||||
PG_KEYWORD("while", K_WHILE, RESERVED_KEYWORD)
|
||||
};
|
||||
|
||||
static const KeywordHT plpgsql_unreserved_keywords = {
|
||||
PG_KEYWORD("absolute", K_ABSOLUTE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("alias", K_ALIAS, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("array", K_ARRAY, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("assert", K_ASSERT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("backward", K_BACKWARD, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("close", K_CLOSE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("collate", K_COLLATE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("column", K_COLUMN, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("column_name", K_COLUMN_NAME, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("constant", K_CONSTANT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("constraint", K_CONSTRAINT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("constraint_name", K_CONSTRAINT_NAME, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("continue", K_CONTINUE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("current", K_CURRENT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("cursor", K_CURSOR, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("datatype", K_DATATYPE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("debug", K_DEBUG, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("default", K_DEFAULT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("detail", K_DETAIL, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("diagnostics", K_DIAGNOSTICS, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("dump", K_DUMP, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("elseif", K_ELSIF, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("elsif", K_ELSIF, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("errcode", K_ERRCODE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("error", K_ERROR, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("exception", K_EXCEPTION, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("exit", K_EXIT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("fetch", K_FETCH, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("first", K_FIRST, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("forward", K_FORWARD, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("get", K_GET, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("hint", K_HINT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("import", K_IMPORT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("info", K_INFO, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("insert", K_INSERT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("is", K_IS, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("last", K_LAST, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("log", K_LOG, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("message", K_MESSAGE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("message_text", K_MESSAGE_TEXT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("move", K_MOVE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("next", K_NEXT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("no", K_NO, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("notice", K_NOTICE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("open", K_OPEN, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("option", K_OPTION, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("perform", K_PERFORM, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("pg_context", K_PG_CONTEXT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("pg_datatype_name", K_PG_DATATYPE_NAME, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("pg_exception_context", K_PG_EXCEPTION_CONTEXT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("pg_exception_detail", K_PG_EXCEPTION_DETAIL, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("pg_exception_hint", K_PG_EXCEPTION_HINT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("print_strict_params", K_PRINT_STRICT_PARAMS, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("prior", K_PRIOR, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("query", K_QUERY, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("raise", K_RAISE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("relative", K_RELATIVE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("result_oid", K_RESULT_OID, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("return", K_RETURN, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("returned_sqlstate", K_RETURNED_SQLSTATE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("reverse", K_REVERSE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("row_count", K_ROW_COUNT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("rowtype", K_ROWTYPE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("schema", K_SCHEMA, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("schema_name", K_SCHEMA_NAME, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("scroll", K_SCROLL, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("slice", K_SLICE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("sqlstate", K_SQLSTATE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("stacked", K_STACKED, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("table", K_TABLE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("table_name", K_TABLE_NAME, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("type", K_TYPE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("use_column", K_USE_COLUMN, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("use_variable", K_USE_VARIABLE, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("variable_conflict", K_VARIABLE_CONFLICT, UNRESERVED_KEYWORD)
|
||||
PG_KEYWORD("warning", K_WARNING, UNRESERVED_KEYWORD)
|
||||
};
|
||||
|
||||
}
|
||||
|
|
@ -131,96 +23,3 @@ const Keyword* getPgsqlKeyword(QString s)
|
|||
return result;
|
||||
}
|
||||
|
||||
|
||||
//t_SymbolSet g_Keywords = {
|
||||
// "a", "abort", "abs", "absent", "absolute", "access", "according", "action", "ada", "add",
|
||||
// "admin", "after", "aggregate", "all", "allocate", "also", "alter", "analyse", "analyze", "and",
|
||||
// "any", "are", "array", "array_agg", "array_max_cardinality", "as", "asc", "asensitive",
|
||||
// "assetion", "assignment", "asymmetric", "at", "atomic", "attribute", "attributes", "authorization", "avg",
|
||||
// "backward", "base64", "before", "begin", "begin_frame", "begin_partition", "bernoulli", "between", "bigint", "binary",
|
||||
// "bit", "bit_length", "blob", "blocked", "bom", "boolean", "both", "breadth", "buffer", "by",
|
||||
// "c", "cache", "call", "called", "cardinality", "cascade", "cascaded", "case", "cast",
|
||||
// "catalog", "catalog_name", "ceil", "ceiling", "chain", "char", "character", "characteristics",
|
||||
// "characters", "character_length", "character_set_catalog", "character_set_name", "character_set_schema",
|
||||
// "char_length", "check", "checkpoint", "class", "class_origin", "clob", "close", "cluster",
|
||||
// "coalesce", "cobol", "collate", "collation", "collation_catalog", "collation_name", "collation_schema",
|
||||
// "collect", "column", "columns", "column_name", "command_function", "command_function_code",
|
||||
// "comment", "comments", "commit", "committed", "concurrently", "condition", "condition_number",
|
||||
// "configuration", "conflict", "connect", "connection", "connection_name", "constraint", "constraints",
|
||||
// "constraint_catalog", "constraint_name", "constraint_schema", "constructor", "contains", "content",
|
||||
// "continue", "control", "conversion", "convert", "copy", "corr", "corresponding", "cost", "count",
|
||||
// "covar_pop", "covar_samp", "create", "cross", "csv", "cube", "cume_dist", "current", "current_catalog",
|
||||
// "current_date", "current_default_transform_group", "current_path", "current_role", "current_row",
|
||||
// "current_schema", "current_time", "current_timestamp", "current_transform_group_for_type",
|
||||
// "current_user", "cursor", "cursor_name", "cycle",
|
||||
// "data", "database", "datalink", "date", "datetime_interval_code", "datetime_interval_precision",
|
||||
// "day", "db", "deallocate", "dec", "decimal", "declare", "default", "defaults", "deferrable", "deferred",
|
||||
// "defined", "definer", "degree", "delete", "delimiter", "delimiters", "dense_rank", "depends", "depth",
|
||||
// "deref", "derived", "desc", "describe", "descriptor", "deterministic", "diagnostics", "dictionary",
|
||||
// "disable", "discard", "disconnect", "dispatch", "distinct", "dlnewcopy", "dlpreviouscopy", "dlurlcomplete",
|
||||
// "dlurlcompleteonly", "dlurlcompletewrite", "dlurlpatch", "dlurlpathonly", "dlurlpathwrite", "dlurlscheme",
|
||||
// "dlurlserver", "dlvalue", "do", "document", "domain", "double", "drop", "dynamic", "dynamic_function",
|
||||
// "dynamic_function_code",
|
||||
// "each", "element", "else", "empty", "enable", "encodign", "encrypted", "end", "end-exec", "end_frame",
|
||||
// "end_partition", "enforced", "enum", "equals", "escape", "event", "every", "except", "exception", "exclude",
|
||||
// "excluding", "exclusive", "exec", "execute", "exists", "exp", "explain", "expression", "extenstion",
|
||||
// "external", "extract", "false", "family", "fetch", "file", "filter", "final", "first", "first_value",
|
||||
// "flag", "float", "floor", "following", "for", "force", "foreign", "fortran", "forward", "found",
|
||||
// "frame_row", "free", "freeze", "from", "fs", "full", "function", "functions", "fusion",
|
||||
// "g", "general", "generated", "get", "global", "go" "goto", "grant", "granted", "greatest", "group",
|
||||
// "grouping", "groups", "handler", "having", "header", "hex", "hierarchy", "hold", "hour", "id", "identity",
|
||||
// "if", "ignore", "ilike", "immediate", "immediatly", "immutable", "implementation", "implicit", "import", "in",
|
||||
// "including", "increment", "indent", "index", "indexes", "indicator", "inherit", "inherits", "initially", "inline",
|
||||
// "inner", "inout", "input", "insensitive", "insert", "instance", "instantiable", "instead", "int", "integer",
|
||||
// "integrity", "intersect", "intersection", "interval", "into", "invoker", "is", "isnull", "isolation",
|
||||
// "join",
|
||||
// "k", "key", "key_member", "key_type",
|
||||
// "label", "lag", "language", "large", "last", "last_value", "lateral", "lead", "leading", "leakproof",
|
||||
// "least", "left", "length", "level", "library", "like", "like_regex", "limit", "link", "listen", "ln", "load", "local",
|
||||
// "localtime", "localtimestamp", "location", "locator", "lock", "locked", "logged", "lower",
|
||||
// "m", "map", "mapping", "match", "matched", "materialized", "max", "maxvalue", "max_cardinality", "member",
|
||||
// "merge", "message_length", "message_octet_length", "message_text", "method", "min", "minute", "minvalue",
|
||||
// "mod", "mode", "modifies", "module", "month", "more", "move", "multiset", "mumps",
|
||||
// "name", "namespace", "national", "natural", "nchar", "nclob", "nesting", "new", "next", "nfc", "nfd", "nfkc", "nkfd",
|
||||
// "nil", "no", "none", "normalize", "normalize", "not", "nothing", "notify", "notnull", "nowait", "nth_value", "ntile",
|
||||
// "null", "nullable", "nullif", "nulls", "number", "numeric",
|
||||
// "object", "occurrences_regex", "octets", "octet_length", "of", "off", "offset", "oids", "old", "on", "only", "open",
|
||||
// "operator", "option", "options", "or", "order", "ordering", "ordinality", "others", "out", "outer", "output", "over",
|
||||
// "overlaps", "overlay", "overriding", "owned", "owner",
|
||||
// "p", "pad", "parallel", "parameter", "parameter_mode", "parameter_name", "parameter_specific_catalog",
|
||||
// "parameter_specific_name", "parameter_specific_schema", "parser",
|
||||
// "partial", "partition", "pascal", "passing", "passthrough", "password", "path", "percent", "percentile_cont",
|
||||
// "percentile_disc", "percent_rank", "period", "permission", "placing", "plans", "pli", "policy", "portion",
|
||||
// "position", "position_regex", "power", "precedes", "preceding", "precision", "prepare", "prepared", "preserve",
|
||||
// "primary", "prior", "privileges", "procedural", "procedure", "program", "public",
|
||||
// "quote", "range", "rank", "read", "reads", "real", "reassign", "recheck", "recovery", "recursive", "ref",
|
||||
// "references", "referencing", "refresh", "regr_avgx", "regr_avgy", "regr_count", "regr_intercept", "regr_r2",
|
||||
// "regr_slope", "regr_sxx", "regr_sxy", "regr_syy", "reindex", "relative", "release", "rename", "repeatable",
|
||||
// "replace", "replica", "requiring", "reset", "respect", "restart", "restore", "restrict", "result", "return",
|
||||
// "returned_cardinality", "returned_length", "returned_octet_length", "returned_sqlstate", "returning", "returns",
|
||||
// "revoke", "right", "role", "rollback", "rollup", "routine", "routine_catalog", "routine_name", "routine_schema",
|
||||
// "row", "rows", "row_count", "row_number", "rule",
|
||||
// "savepoint", "scale", "schema", "schema_name", "scope", "scope_catalog", "scope_name", "scope_schema", "scroll",
|
||||
// "search", "second", "section", "security", "select", "selective", "self", "sensitive", "sequence", "sequences",
|
||||
// "serializable", "server", "server_name", "session", "session_user", "set", "setof", "sets", "share", "show",
|
||||
// "similar", "simple", "size", "skip", "smallint", "snapshot", "some", "source", "space", "specific", "specifictype",
|
||||
// "specific_name", "sql", "sqlcode", "sqlerror", "sqlexception", "sqlstate", "sqlwarning", "sqrt", "stable",
|
||||
// "standalone", "start", "state", "statement", "static", "statistics", "stddev_pop", "stddev_samp", "stdin", "stdout",
|
||||
// "storage", "strict", "strip", "structure", "style", "subclass_origin", "submultiset", "substring", "substring_regex",
|
||||
// "succeeds", "sum", "symmetric", "sysid", "system", "system_time", "system_user",
|
||||
// "t", "table", "tables", "tablesample", "tablespace", "table_name", "temp", "template", "temporary", "text", "then",
|
||||
// "ties", "time", "timestamp", "timezone_hour", "timezone_minute", "to", "token", "top_level_count", "trailing",
|
||||
// "transaction", "transaction_committed", "transaction_rolled_back", "transaction_active", "transform", "transforms",
|
||||
// "translate", "translate_regex", "translation", "treat", "trigger", "trigger_catalog", "trigger_name", "trigger_schema",
|
||||
// "trim", "trim_array", "true", "truncate", "trusted", "type", "types", "uescape", "unbounded", "uncommitted", "under",
|
||||
// "unencrypted", "union", "unique", "unknown", "unlink", "unlisten", "unlogged", "unnamed", "unnest", "until", "untyped",
|
||||
// "update", "upper", "uri", "usage", "user", "user_defined_type_catalog", "user_defined_type_code",
|
||||
// "user_defined_type_name", "user_defined_type_schema", "using",
|
||||
// "vacuum", "valid", "validate", "validator", "value", "values", "value_of", "varbinary", "varchar", "variadic",
|
||||
// "varying", "var_pop", "var_samp", "verbose", "version", "versioning", "view", "views", "volatile",
|
||||
// "when", "whenever", "where", "whitespace", "width_bucket", "window", "with", "within", "without", "work", "wrapper",
|
||||
// "write", "xml", "xmlagg", "xmlattributes", "xmlbinary", "xmlcast", "xmlcomment", "xmlconcat", "xmldeclaration",
|
||||
// "xmldocument", "xmlelement", "xmlexists", "xmlforest", "xmliterate", "xmlnamespaces", "xmlparse", "xmlpi",
|
||||
// "xmlquery", "xmlroot", "xmlschema", "xmlserialize", "xmltable", "xmltext", "xmlvalidate", "year", "yes", "zone"
|
||||
//};
|
||||
|
||||
|
|
|
|||
|
|
@ -19,5 +19,60 @@ QString PgSequence::createSql() const
|
|||
|
||||
// [ OWNED BY { table_name.column_name | NONE } ]
|
||||
sql += ";";
|
||||
return sql;
|
||||
return sql;
|
||||
}
|
||||
|
||||
int64_t PgSequence::defaultMin() const
|
||||
{
|
||||
if (direction() == Ascending)
|
||||
return 1;
|
||||
|
||||
if (typid == Pgsql::int8_oid)
|
||||
return std::numeric_limits<int64_t>::min();
|
||||
return std::numeric_limits<int32_t>::min();
|
||||
}
|
||||
|
||||
int64_t PgSequence::defaultMax() const
|
||||
{
|
||||
if (direction() == Descending)
|
||||
return -1;
|
||||
|
||||
if (typid == Pgsql::int8_oid)
|
||||
return std::numeric_limits<int64_t>::max();
|
||||
return std::numeric_limits<int32_t>::max();
|
||||
}
|
||||
|
||||
int64_t PgSequence::defaultStart() const
|
||||
{
|
||||
if (direction() == Descending)
|
||||
return max;
|
||||
return min;
|
||||
}
|
||||
|
||||
int64_t PgSequence::defaultIncrement() const
|
||||
{
|
||||
// Direction should not be considered here
|
||||
// a negative increment is what makes it a descending sequence
|
||||
return 1;
|
||||
}
|
||||
|
||||
int64_t PgSequence::defaultCache() const
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
QString PgSequence::nonDefaultOptionsString() const
|
||||
{
|
||||
QString options;
|
||||
if (increment != defaultIncrement())
|
||||
options += QString("INCREMENT %1 ").arg(increment);
|
||||
if (min != defaultMin())
|
||||
options += QString("MINVALUE %1 ").arg(min);
|
||||
if (max != defaultMax())
|
||||
options += QString("MAXVALUE %1 ").arg(max);
|
||||
if (start != defaultStart())
|
||||
options += QString("START %1 ").arg(start);
|
||||
if (cache != defaultCache())
|
||||
options += QString("CACHE %1 ").arg(cache);
|
||||
return options.trimmed();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,23 +5,44 @@
|
|||
|
||||
class PgSequence: public PgClass {
|
||||
public:
|
||||
enum Direction {
|
||||
Ascending,
|
||||
Descending
|
||||
};
|
||||
|
||||
// values that define the trigger
|
||||
// in recent versions from the catalog
|
||||
Oid typid = InvalidOid;
|
||||
int64_t last = 0;
|
||||
int64_t start = 0;
|
||||
int64_t increment = 0;
|
||||
int64_t max = 0;
|
||||
int64_t min = 0;
|
||||
int64_t cache = 0;
|
||||
int64_t log = 0;
|
||||
bool cycled = false;
|
||||
bool called = false;
|
||||
|
||||
bool priv_usage = false;
|
||||
bool priv_select = false;
|
||||
bool priv_update = false;
|
||||
|
||||
// Sequence state data, retrieved by SELECTing the sequence
|
||||
int64_t last = 0;
|
||||
int64_t log = 0; // shows how many fetches are left before new wal log
|
||||
bool called = false;
|
||||
|
||||
using PgClass::PgClass;
|
||||
QString createSql() const;
|
||||
|
||||
Direction direction() const
|
||||
{
|
||||
return increment < 0 ? Descending : Ascending;
|
||||
}
|
||||
int64_t defaultMin() const;
|
||||
int64_t defaultMax() const;
|
||||
int64_t defaultStart() const;
|
||||
int64_t defaultIncrement() const;
|
||||
int64_t defaultCache() const;
|
||||
// other option defaults are 1
|
||||
QString nonDefaultOptionsString() const;
|
||||
};
|
||||
|
||||
#endif // PGSEQUENCE_H
|
||||
|
|
|
|||
484
pglablib/catalog/kwlist.h
Normal file
484
pglablib/catalog/kwlist.h
Normal file
|
|
@ -0,0 +1,484 @@
|
|||
/*-------------------------------------------------------------------------
|
||||
*
|
||||
* kwlist.h
|
||||
*
|
||||
* The keyword lists are kept in their own source files for use by
|
||||
* automatic tools. The exact representation of a keyword is determined
|
||||
* by the PG_KEYWORD macro, which is not defined in this file; it can
|
||||
* be defined by the caller for special purposes.
|
||||
*
|
||||
* Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* src/include/parser/kwlist.h
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
/* there is deliberately not an #ifndef KWLIST_H here */
|
||||
|
||||
/*
|
||||
* List of keyword (name, token-value, category, bare-label-status) entries.
|
||||
*
|
||||
* Note: gen_keywordlist.pl requires the entries to appear in ASCII order.
|
||||
*/
|
||||
|
||||
/* name, value, category, is-bare-label */
|
||||
PG_KEYWORD("abort", ABORT_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("absolute", ABSOLUTE_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("access", ACCESS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("action", ACTION, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("add", ADD_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("admin", ADMIN, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("after", AFTER, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("aggregate", AGGREGATE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("all", ALL, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("also", ALSO, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("alter", ALTER, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("always", ALWAYS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("analyse", ANALYSE, RESERVED_KEYWORD, BARE_LABEL) /* British spelling */
|
||||
PG_KEYWORD("analyze", ANALYZE, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("and", AND, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("any", ANY, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("array", ARRAY, RESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("as", AS, RESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("asc", ASC, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("asensitive", ASENSITIVE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("assertion", ASSERTION, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("assignment", ASSIGNMENT, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("asymmetric", ASYMMETRIC, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("at", AT, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("atomic", ATOMIC, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("attach", ATTACH, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("attribute", ATTRIBUTE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("authorization", AUTHORIZATION, TYPE_FUNC_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("backward", BACKWARD, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("before", BEFORE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("begin", BEGIN_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("between", BETWEEN, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("bigint", BIGINT, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("binary", BINARY, TYPE_FUNC_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("bit", BIT, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("boolean", BOOLEAN_P, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("both", BOTH, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("breadth", BREADTH, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("by", BY, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("cache", CACHE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("call", CALL, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("called", CALLED, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("cascade", CASCADE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("cascaded", CASCADED, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("case", CASE, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("cast", CAST, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("catalog", CATALOG_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("chain", CHAIN, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("char", CHAR_P, COL_NAME_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("character", CHARACTER, COL_NAME_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("characteristics", CHARACTERISTICS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("check", CHECK, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("checkpoint", CHECKPOINT, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("class", CLASS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("close", CLOSE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("cluster", CLUSTER, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("coalesce", COALESCE, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("collate", COLLATE, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("collation", COLLATION, TYPE_FUNC_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("column", COLUMN, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("columns", COLUMNS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("comment", COMMENT, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("comments", COMMENTS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("commit", COMMIT, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("committed", COMMITTED, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("compression", COMPRESSION, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("concurrently", CONCURRENTLY, TYPE_FUNC_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("configuration", CONFIGURATION, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("conflict", CONFLICT, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("connection", CONNECTION, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("constraint", CONSTRAINT, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("constraints", CONSTRAINTS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("content", CONTENT_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("continue", CONTINUE_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("conversion", CONVERSION_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("copy", COPY, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("cost", COST, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("create", CREATE, RESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("cross", CROSS, TYPE_FUNC_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("csv", CSV, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("cube", CUBE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("current", CURRENT_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("current_catalog", CURRENT_CATALOG, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("current_date", CURRENT_DATE, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("current_role", CURRENT_ROLE, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("current_schema", CURRENT_SCHEMA, TYPE_FUNC_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("current_time", CURRENT_TIME, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("current_timestamp", CURRENT_TIMESTAMP, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("current_user", CURRENT_USER, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("cursor", CURSOR, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("cycle", CYCLE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("data", DATA_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("database", DATABASE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("day", DAY_P, UNRESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("deallocate", DEALLOCATE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("dec", DEC, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("decimal", DECIMAL_P, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("declare", DECLARE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("default", DEFAULT, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("defaults", DEFAULTS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("deferrable", DEFERRABLE, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("deferred", DEFERRED, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("definer", DEFINER, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("delete", DELETE_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("delimiter", DELIMITER, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("delimiters", DELIMITERS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("depends", DEPENDS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("depth", DEPTH, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("desc", DESC, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("detach", DETACH, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("dictionary", DICTIONARY, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("disable", DISABLE_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("discard", DISCARD, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("distinct", DISTINCT, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("do", DO, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("document", DOCUMENT_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("domain", DOMAIN_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("double", DOUBLE_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("drop", DROP, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("each", EACH, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("else", ELSE, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("enable", ENABLE_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("encoding", ENCODING, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("encrypted", ENCRYPTED, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("end", END_P, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("enum", ENUM_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("escape", ESCAPE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("event", EVENT, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("except", EXCEPT, RESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("exclude", EXCLUDE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("excluding", EXCLUDING, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("exclusive", EXCLUSIVE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("execute", EXECUTE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("exists", EXISTS, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("explain", EXPLAIN, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("expression", EXPRESSION, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("extension", EXTENSION, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("external", EXTERNAL, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("extract", EXTRACT, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("false", FALSE_P, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("family", FAMILY, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("fetch", FETCH, RESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("filter", FILTER, UNRESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("finalize", FINALIZE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("first", FIRST_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("float", FLOAT_P, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("following", FOLLOWING, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("for", FOR, RESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("force", FORCE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("foreign", FOREIGN, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("forward", FORWARD, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("freeze", FREEZE, TYPE_FUNC_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("from", FROM, RESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("full", FULL, TYPE_FUNC_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("function", FUNCTION, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("functions", FUNCTIONS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("generated", GENERATED, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("global", GLOBAL, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("grant", GRANT, RESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("granted", GRANTED, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("greatest", GREATEST, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("group", GROUP_P, RESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("grouping", GROUPING, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("groups", GROUPS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("handler", HANDLER, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("having", HAVING, RESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("header", HEADER_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("hold", HOLD, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("hour", HOUR_P, UNRESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("identity", IDENTITY_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("if", IF_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("ilike", ILIKE, TYPE_FUNC_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("immediate", IMMEDIATE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("immutable", IMMUTABLE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("implicit", IMPLICIT_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("import", IMPORT_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("in", IN_P, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("include", INCLUDE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("including", INCLUDING, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("increment", INCREMENT, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("index", INDEX, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("indexes", INDEXES, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("inherit", INHERIT, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("inherits", INHERITS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("initially", INITIALLY, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("inline", INLINE_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("inner", INNER_P, TYPE_FUNC_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("inout", INOUT, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("input", INPUT_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("insensitive", INSENSITIVE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("insert", INSERT, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("instead", INSTEAD, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("int", INT_P, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("integer", INTEGER, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("intersect", INTERSECT, RESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("interval", INTERVAL, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("into", INTO, RESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("invoker", INVOKER, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("is", IS, TYPE_FUNC_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("isnull", ISNULL, TYPE_FUNC_NAME_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("isolation", ISOLATION, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("join", JOIN, TYPE_FUNC_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("key", KEY, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("label", LABEL, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("language", LANGUAGE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("large", LARGE_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("last", LAST_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("lateral", LATERAL_P, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("leading", LEADING, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("leakproof", LEAKPROOF, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("least", LEAST, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("left", LEFT, TYPE_FUNC_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("level", LEVEL, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("like", LIKE, TYPE_FUNC_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("limit", LIMIT, RESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("listen", LISTEN, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("load", LOAD, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("local", LOCAL, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("localtime", LOCALTIME, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("localtimestamp", LOCALTIMESTAMP, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("location", LOCATION, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("lock", LOCK_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("locked", LOCKED, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("logged", LOGGED, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("mapping", MAPPING, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("match", MATCH, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("materialized", MATERIALIZED, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("maxvalue", MAXVALUE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("method", METHOD, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("minute", MINUTE_P, UNRESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("minvalue", MINVALUE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("mode", MODE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("month", MONTH_P, UNRESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("move", MOVE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("name", NAME_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("names", NAMES, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("national", NATIONAL, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("natural", NATURAL, TYPE_FUNC_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("nchar", NCHAR, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("new", NEW, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("next", NEXT, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("nfc", NFC, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("nfd", NFD, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("nfkc", NFKC, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("nfkd", NFKD, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("no", NO, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("none", NONE, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("normalize", NORMALIZE, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("normalized", NORMALIZED, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("not", NOT, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("nothing", NOTHING, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("notify", NOTIFY, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("notnull", NOTNULL, TYPE_FUNC_NAME_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("nowait", NOWAIT, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("null", NULL_P, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("nullif", NULLIF, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("nulls", NULLS_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("numeric", NUMERIC, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("object", OBJECT_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("of", OF, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("off", OFF, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("offset", OFFSET, RESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("oids", OIDS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("old", OLD, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("on", ON, RESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("only", ONLY, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("operator", OPERATOR, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("option", OPTION, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("options", OPTIONS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("or", OR, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("order", ORDER, RESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("ordinality", ORDINALITY, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("others", OTHERS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("out", OUT_P, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("outer", OUTER_P, TYPE_FUNC_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("over", OVER, UNRESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("overlaps", OVERLAPS, TYPE_FUNC_NAME_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("overlay", OVERLAY, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("overriding", OVERRIDING, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("owned", OWNED, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("owner", OWNER, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("parallel", PARALLEL, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("parser", PARSER, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("partial", PARTIAL, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("partition", PARTITION, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("passing", PASSING, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("password", PASSWORD, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("placing", PLACING, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("plans", PLANS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("policy", POLICY, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("position", POSITION, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("preceding", PRECEDING, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("precision", PRECISION, COL_NAME_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("prepare", PREPARE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("prepared", PREPARED, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("preserve", PRESERVE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("primary", PRIMARY, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("prior", PRIOR, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("privileges", PRIVILEGES, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("procedural", PROCEDURAL, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("procedure", PROCEDURE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("procedures", PROCEDURES, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("program", PROGRAM, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("publication", PUBLICATION, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("quote", QUOTE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("range", RANGE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("read", READ, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("real", REAL, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("reassign", REASSIGN, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("recheck", RECHECK, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("recursive", RECURSIVE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("ref", REF, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("references", REFERENCES, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("referencing", REFERENCING, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("refresh", REFRESH, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("reindex", REINDEX, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("relative", RELATIVE_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("release", RELEASE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("rename", RENAME, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("repeatable", REPEATABLE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("replace", REPLACE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("replica", REPLICA, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("reset", RESET, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("restart", RESTART, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("restrict", RESTRICT, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("return", RETURN, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("returning", RETURNING, RESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("returns", RETURNS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("revoke", REVOKE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("right", RIGHT, TYPE_FUNC_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("role", ROLE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("rollback", ROLLBACK, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("rollup", ROLLUP, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("routine", ROUTINE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("routines", ROUTINES, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("row", ROW, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("rows", ROWS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("rule", RULE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("savepoint", SAVEPOINT, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("schema", SCHEMA, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("schemas", SCHEMAS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("scroll", SCROLL, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("search", SEARCH, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("second", SECOND_P, UNRESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("security", SECURITY, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("select", SELECT, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("sequence", SEQUENCE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("sequences", SEQUENCES, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("serializable", SERIALIZABLE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("server", SERVER, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("session", SESSION, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("session_user", SESSION_USER, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("set", SET, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("setof", SETOF, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("sets", SETS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("share", SHARE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("show", SHOW, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("similar", SIMILAR, TYPE_FUNC_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("simple", SIMPLE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("skip", SKIP, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("smallint", SMALLINT, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("snapshot", SNAPSHOT, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("some", SOME, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("sql", SQL_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("stable", STABLE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("standalone", STANDALONE_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("start", START, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("statement", STATEMENT, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("statistics", STATISTICS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("stdin", STDIN, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("stdout", STDOUT, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("storage", STORAGE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("stored", STORED, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("strict", STRICT_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("strip", STRIP_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("subscription", SUBSCRIPTION, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("substring", SUBSTRING, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("support", SUPPORT, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("symmetric", SYMMETRIC, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("sysid", SYSID, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("system", SYSTEM_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("table", TABLE, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("tables", TABLES, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("tablesample", TABLESAMPLE, TYPE_FUNC_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("tablespace", TABLESPACE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("temp", TEMP, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("template", TEMPLATE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("temporary", TEMPORARY, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("text", TEXT_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("then", THEN, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("ties", TIES, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("time", TIME, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("timestamp", TIMESTAMP, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("to", TO, RESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("trailing", TRAILING, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("transaction", TRANSACTION, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("transform", TRANSFORM, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("treat", TREAT, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("trigger", TRIGGER, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("trim", TRIM, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("true", TRUE_P, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("truncate", TRUNCATE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("trusted", TRUSTED, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("type", TYPE_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("types", TYPES_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("uescape", UESCAPE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("unbounded", UNBOUNDED, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("uncommitted", UNCOMMITTED, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("unencrypted", UNENCRYPTED, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("union", UNION, RESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("unique", UNIQUE, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("unknown", UNKNOWN, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("unlisten", UNLISTEN, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("unlogged", UNLOGGED, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("until", UNTIL, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("update", UPDATE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("user", USER, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("using", USING, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("vacuum", VACUUM, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("valid", VALID, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("validate", VALIDATE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("validator", VALIDATOR, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("value", VALUE_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("values", VALUES, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("varchar", VARCHAR, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("variadic", VARIADIC, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("varying", VARYING, UNRESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("verbose", VERBOSE, TYPE_FUNC_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("version", VERSION_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("view", VIEW, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("views", VIEWS, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("volatile", VOLATILE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("when", WHEN, RESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("where", WHERE, RESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("whitespace", WHITESPACE_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("window", WINDOW, RESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("with", WITH, RESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("within", WITHIN, UNRESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("without", WITHOUT, UNRESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("work", WORK, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("wrapper", WRAPPER, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("write", WRITE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("xml", XML_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("xmlattributes", XMLATTRIBUTES, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("xmlconcat", XMLCONCAT, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("xmlelement", XMLELEMENT, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("xmlexists", XMLEXISTS, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("xmlforest", XMLFOREST, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("xmlnamespaces", XMLNAMESPACES, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("xmlparse", XMLPARSE, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("xmlpi", XMLPI, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("xmlroot", XMLROOT, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("xmlserialize", XMLSERIALIZE, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("xmltable", XMLTABLE, COL_NAME_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("year", YEAR_P, UNRESERVED_KEYWORD, AS_LABEL)
|
||||
PG_KEYWORD("yes", YES_P, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
PG_KEYWORD("zone", ZONE, UNRESERVED_KEYWORD, BARE_LABEL)
|
||||
15
releasenotes/notes/generated-support-1528dad543a7525f.yaml
Normal file
15
releasenotes/notes/generated-support-1528dad543a7525f.yaml
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
---
|
||||
features:
|
||||
- |
|
||||
Full support for identity and generated columns. This includes recognizing
|
||||
the new keywords, displaying column defaults as generated, showing the
|
||||
correct SQL to recreate the objects.
|
||||
The CRUD blocks editing of generated always columns.
|
||||
issues:
|
||||
- |
|
||||
From a CRUD tab it is currently not possible to override an ALWAYS AS IDENTITY
|
||||
column with OVERRRIDING SYSTEM VALUE.
|
||||
- |
|
||||
When all columns are GENERATED ALWAYS you cannot add a new row from a CRUD tab
|
||||
thought technically it is possible to INSERT a row by using DEFAULT.
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue