diff --git a/README.md b/README.md index 6aab5f3ff..0e39243d7 100644 --- a/README.md +++ b/README.md @@ -170,6 +170,7 @@ and missing syntax gets added on demand — [open an issue](https://github.com/J | **PostgreSQL administration** | `CREATE`/`ALTER EVENT TRIGGER` · `REINDEX` · `SECURITY LABEL` | | **PostgreSQL types and rules** | `CREATE TYPE` (shell, composite, enum, range and base types) · `ALTER TYPE` · `CREATE RULE` · `ALTER RULE` | | **PostgreSQL casts, transforms and conversions** | `CREATE CAST` · `DROP CAST` · `CREATE [OR REPLACE] TRANSFORM` · `DROP TRANSFORM` · `CREATE [DEFAULT] CONVERSION` · `ALTER CONVERSION` | +| **PostgreSQL metadata objects** | `CREATE`/`ALTER [PROCEDURAL] LANGUAGE` · `ALTER LARGE OBJECT … OWNER TO` · `CREATE`/`ALTER TEXT SEARCH DICTIONARY` · `CREATE`/`ALTER TEXT SEARCH PARSER` · `CREATE`/`ALTER TEXT SEARCH TEMPLATE` | | **PostgreSQL operators and aggregates** | `CREATE`/`ALTER OPERATOR` · `CREATE`/`ALTER OPERATOR CLASS` · `CREATE`/`ALTER OPERATOR FAMILY` · `CREATE`/`ALTER AGGREGATE` | | **Informix constraints** | `ALTER TABLE … ADD CONSTRAINT` with trailing constraint names for primary, unique, foreign and check constraints; enable with `parser.withDialect(Dialect.INFORMIX)` | | **Salesforce SOQL** | `INCLUDES` · `EXCLUDES` | diff --git a/src/main/java/net/sf/jsqlparser/parser/feature/Feature.java b/src/main/java/net/sf/jsqlparser/parser/feature/Feature.java index 9fbe62bb8..60f8850dc 100644 --- a/src/main/java/net/sf/jsqlparser/parser/feature/Feature.java +++ b/src/main/java/net/sf/jsqlparser/parser/feature/Feature.java @@ -1102,6 +1102,60 @@ public enum Feature { * @see net.sf.jsqlparser.statement.alter.AlterConversion */ alterConversion, + /** + * PostgreSQL CREATE metadata statement is allowed. + * + * @see net.sf.jsqlparser.statement.create.language.CreateLanguage + */ + createLanguage, + /** + * PostgreSQL ALTER metadata statement is allowed. + * + * @see net.sf.jsqlparser.statement.alter.AlterLanguage + */ + alterLanguage, + /** + * PostgreSQL ALTER metadata statement is allowed. + * + * @see net.sf.jsqlparser.statement.alter.AlterLargeObject + */ + alterLargeObject, + /** + * PostgreSQL CREATE metadata statement is allowed. + * + * @see net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchDictionary + */ + createTextSearchDictionary, + /** + * PostgreSQL ALTER metadata statement is allowed. + * + * @see net.sf.jsqlparser.statement.alter.AlterTextSearchDictionary + */ + alterTextSearchDictionary, + /** + * PostgreSQL CREATE metadata statement is allowed. + * + * @see net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchParser + */ + createTextSearchParser, + /** + * PostgreSQL ALTER metadata statement is allowed. + * + * @see net.sf.jsqlparser.statement.alter.AlterTextSearchParser + */ + alterTextSearchParser, + /** + * PostgreSQL CREATE metadata statement is allowed. + * + * @see net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchTemplate + */ + createTextSearchTemplate, + /** + * PostgreSQL ALTER metadata statement is allowed. + * + * @see net.sf.jsqlparser.statement.alter.AlterTextSearchTemplate + */ + alterTextSearchTemplate, /** * PostgreSQL "CREATE OPERATOR" statement is allowed * diff --git a/src/main/java/net/sf/jsqlparser/statement/StatementFeatureVisitor.java b/src/main/java/net/sf/jsqlparser/statement/StatementFeatureVisitor.java index 46ac6476c..b5ac9c8d8 100644 --- a/src/main/java/net/sf/jsqlparser/statement/StatementFeatureVisitor.java +++ b/src/main/java/net/sf/jsqlparser/statement/StatementFeatureVisitor.java @@ -48,6 +48,15 @@ import net.sf.jsqlparser.statement.create.cast.CreateCast; import net.sf.jsqlparser.statement.create.transform.CreateTransform; import net.sf.jsqlparser.statement.create.conversion.CreateConversion; +import net.sf.jsqlparser.statement.create.language.CreateLanguage; +import net.sf.jsqlparser.statement.alter.AlterLanguage; +import net.sf.jsqlparser.statement.alter.AlterLargeObject; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchDictionary; +import net.sf.jsqlparser.statement.alter.AlterTextSearchDictionary; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchParser; +import net.sf.jsqlparser.statement.alter.AlterTextSearchParser; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchTemplate; +import net.sf.jsqlparser.statement.alter.AlterTextSearchTemplate; import net.sf.jsqlparser.statement.alter.AlterConversion; import net.sf.jsqlparser.statement.alter.AlterServer; import net.sf.jsqlparser.statement.alter.AlterSession; @@ -1735,4 +1744,49 @@ public Void visit(AlterOperatorFamily statement, S context) { public Void visit(AlterAggregate statement, S context) { return schemaOnly(); } + + @Override + public Void visit(CreateLanguage statement, S context) { + return schemaOnly(); + } + + @Override + public Void visit(AlterLanguage statement, S context) { + return schemaOnly(); + } + + @Override + public Void visit(AlterLargeObject statement, S context) { + return schemaOnly(); + } + + @Override + public Void visit(CreateTextSearchDictionary statement, S context) { + return schemaOnly(); + } + + @Override + public Void visit(AlterTextSearchDictionary statement, S context) { + return schemaOnly(); + } + + @Override + public Void visit(CreateTextSearchParser statement, S context) { + return schemaOnly(); + } + + @Override + public Void visit(AlterTextSearchParser statement, S context) { + return schemaOnly(); + } + + @Override + public Void visit(CreateTextSearchTemplate statement, S context) { + return schemaOnly(); + } + + @Override + public Void visit(AlterTextSearchTemplate statement, S context) { + return schemaOnly(); + } } diff --git a/src/main/java/net/sf/jsqlparser/statement/StatementVisitor.java b/src/main/java/net/sf/jsqlparser/statement/StatementVisitor.java index d7827dc21..fcd4f5920 100644 --- a/src/main/java/net/sf/jsqlparser/statement/StatementVisitor.java +++ b/src/main/java/net/sf/jsqlparser/statement/StatementVisitor.java @@ -36,6 +36,15 @@ import net.sf.jsqlparser.statement.create.cast.CreateCast; import net.sf.jsqlparser.statement.create.transform.CreateTransform; import net.sf.jsqlparser.statement.create.conversion.CreateConversion; +import net.sf.jsqlparser.statement.create.language.CreateLanguage; +import net.sf.jsqlparser.statement.alter.AlterLanguage; +import net.sf.jsqlparser.statement.alter.AlterLargeObject; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchDictionary; +import net.sf.jsqlparser.statement.alter.AlterTextSearchDictionary; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchParser; +import net.sf.jsqlparser.statement.alter.AlterTextSearchParser; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchTemplate; +import net.sf.jsqlparser.statement.alter.AlterTextSearchTemplate; import net.sf.jsqlparser.statement.alter.AlterConversion; import net.sf.jsqlparser.statement.alter.AlterRoutine; import net.sf.jsqlparser.statement.alter.AlterTrigger; @@ -1415,4 +1424,76 @@ default T visit(AlterAggregate statement, S context) { default void visit(AlterAggregate statement) { visit(statement, null); } + + default T visit(CreateLanguage statement, S context) { + return null; + } + + default void visit(CreateLanguage statement) { + visit(statement, null); + } + + default T visit(AlterLanguage statement, S context) { + return null; + } + + default void visit(AlterLanguage statement) { + visit(statement, null); + } + + default T visit(AlterLargeObject statement, S context) { + return null; + } + + default void visit(AlterLargeObject statement) { + visit(statement, null); + } + + default T visit(CreateTextSearchDictionary statement, S context) { + return null; + } + + default void visit(CreateTextSearchDictionary statement) { + visit(statement, null); + } + + default T visit(AlterTextSearchDictionary statement, S context) { + return null; + } + + default void visit(AlterTextSearchDictionary statement) { + visit(statement, null); + } + + default T visit(CreateTextSearchParser statement, S context) { + return null; + } + + default void visit(CreateTextSearchParser statement) { + visit(statement, null); + } + + default T visit(AlterTextSearchParser statement, S context) { + return null; + } + + default void visit(AlterTextSearchParser statement) { + visit(statement, null); + } + + default T visit(CreateTextSearchTemplate statement, S context) { + return null; + } + + default void visit(CreateTextSearchTemplate statement) { + visit(statement, null); + } + + default T visit(AlterTextSearchTemplate statement, S context) { + return null; + } + + default void visit(AlterTextSearchTemplate statement) { + visit(statement, null); + } } diff --git a/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java b/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java index fcd094a68..469f5908d 100644 --- a/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java +++ b/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java @@ -14,6 +14,15 @@ import net.sf.jsqlparser.statement.create.cast.CreateCast; import net.sf.jsqlparser.statement.create.transform.CreateTransform; import net.sf.jsqlparser.statement.create.conversion.CreateConversion; +import net.sf.jsqlparser.statement.create.language.CreateLanguage; +import net.sf.jsqlparser.statement.alter.AlterLanguage; +import net.sf.jsqlparser.statement.alter.AlterLargeObject; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchDictionary; +import net.sf.jsqlparser.statement.alter.AlterTextSearchDictionary; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchParser; +import net.sf.jsqlparser.statement.alter.AlterTextSearchParser; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchTemplate; +import net.sf.jsqlparser.statement.alter.AlterTextSearchTemplate; import net.sf.jsqlparser.statement.alter.AlterConversion; import net.sf.jsqlparser.statement.alter.AlterTablespace; import net.sf.jsqlparser.statement.alter.AlterPolicy; @@ -1354,4 +1363,50 @@ public T visit(CreateConversion statement, S context) { public T visit(AlterConversion statement, S context) { return null; } + + @Override + public T visit(CreateLanguage statement, S context) { + return null; + } + + @Override + public T visit(AlterLanguage statement, S context) { + return null; + } + + @Override + public T visit(AlterLargeObject statement, S context) { + statement.visitExpressions(expression -> expression.accept(expressionVisitor, context)); + return null; + } + + @Override + public T visit(CreateTextSearchDictionary statement, S context) { + return null; + } + + @Override + public T visit(AlterTextSearchDictionary statement, S context) { + return null; + } + + @Override + public T visit(CreateTextSearchParser statement, S context) { + return null; + } + + @Override + public T visit(AlterTextSearchParser statement, S context) { + return null; + } + + @Override + public T visit(CreateTextSearchTemplate statement, S context) { + return null; + } + + @Override + public T visit(AlterTextSearchTemplate statement, S context) { + return null; + } } diff --git a/src/main/java/net/sf/jsqlparser/statement/alter/AlterLanguage.java b/src/main/java/net/sf/jsqlparser/statement/alter/AlterLanguage.java new file mode 100644 index 000000000..9ad8380c9 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/alter/AlterLanguage.java @@ -0,0 +1,108 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2026 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.alter; + +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +/** PostgreSQL ALTER [PROCEDURAL] LANGUAGE with RENAME TO or OWNER TO. */ +public class AlterLanguage extends ASTNodeAccessImpl implements Statement { + public enum Action { + RENAME, OWNER + } + + private boolean procedural; + private String name; + private Action action; + private String newName; + private String owner; + + public boolean isProcedural() { + return procedural; + } + + public void setProcedural(boolean procedural) { + this.procedural = procedural; + } + + public AlterLanguage withProcedural(boolean procedural) { + setProcedural(procedural); + return this; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public AlterLanguage withName(String name) { + setName(name); + return this; + } + + public Action getAction() { + return action; + } + + public void setAction(Action action) { + this.action = action; + } + + public AlterLanguage withAction(Action action) { + setAction(action); + return this; + } + + public String getNewName() { + return newName; + } + + public void setNewName(String newName) { + this.newName = newName; + } + + public AlterLanguage withNewName(String newName) { + setNewName(newName); + return this; + } + + public String getOwner() { + return owner; + } + + public void setOwner(String owner) { + this.owner = owner; + } + + public AlterLanguage withOwner(String owner) { + setOwner(owner); + return this; + } + + public StringBuilder appendTo(StringBuilder sql) { + sql.append(procedural ? "ALTER PROCEDURAL LANGUAGE " : "ALTER LANGUAGE ").append(name); + return action == Action.RENAME ? sql.append(" RENAME TO ").append(newName) + : sql.append(" OWNER TO ").append(owner); + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + @Override + public T accept(StatementVisitor visitor, S context) { + return visitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/alter/AlterLargeObject.java b/src/main/java/net/sf/jsqlparser/statement/alter/AlterLargeObject.java new file mode 100644 index 000000000..d77dfd40b --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/alter/AlterLargeObject.java @@ -0,0 +1,76 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2026 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.alter; + +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +/** + * PostgreSQL ALTER LARGE OBJECT oid OWNER TO role. The numeric OID retains its sign and spelling. + */ +public class AlterLargeObject extends ASTNodeAccessImpl implements Statement { + private Expression largeObjectId; + private String owner; + + public Expression getLargeObjectId() { + return largeObjectId; + } + + public void setLargeObjectId(Expression largeObjectId) { + this.largeObjectId = largeObjectId; + } + + public AlterLargeObject withLargeObjectId(Expression largeObjectId) { + setLargeObjectId(largeObjectId); + return this; + } + + public String getOwner() { + return owner; + } + + public void setOwner(String owner) { + this.owner = owner; + } + + public AlterLargeObject withOwner(String owner) { + setOwner(owner); + return this; + } + + public void visitExpressions(Consumer visitor) { + if (largeObjectId != null) { + visitor.accept(largeObjectId); + } + } + + public StringBuilder appendTo(StringBuilder sql, Consumer expressionRenderer) { + sql.append("ALTER LARGE OBJECT "); + expressionRenderer.accept(largeObjectId); + return sql.append(" OWNER TO ").append(owner); + } + + public StringBuilder appendTo(StringBuilder sql) { + return appendTo(sql, expression -> sql.append(expression)); + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + @Override + public T accept(StatementVisitor visitor, S context) { + return visitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/alter/AlterTextSearchDictionary.java b/src/main/java/net/sf/jsqlparser/statement/alter/AlterTextSearchDictionary.java new file mode 100644 index 000000000..0dc2e7597 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/alter/AlterTextSearchDictionary.java @@ -0,0 +1,163 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2026 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.alter; + +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; +import net.sf.jsqlparser.statement.DefinitionElement; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +/** + * PostgreSQL ALTER TEXT SEARCH DICTIONARY. Options can be set or removed; ownership, rename and + * schema changes are supported. + */ +public class AlterTextSearchDictionary extends ASTNodeAccessImpl implements Statement { + public enum Action { + OPTIONS, RENAME, OWNER, SET_SCHEMA + } + + private String name; + private Action action; + private String newName; + private String schemaName; + private String owner; + private List options = new ArrayList<>(); + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public AlterTextSearchDictionary withName(String name) { + setName(name); + return this; + } + + public Action getAction() { + return action; + } + + public void setAction(Action action) { + this.action = action; + } + + public AlterTextSearchDictionary withAction(Action action) { + setAction(action); + return this; + } + + public String getNewName() { + return newName; + } + + public void setNewName(String newName) { + this.newName = newName; + } + + public AlterTextSearchDictionary withNewName(String newName) { + setNewName(newName); + return this; + } + + public String getSchemaName() { + return schemaName; + } + + public void setSchemaName(String schemaName) { + this.schemaName = schemaName; + } + + public AlterTextSearchDictionary withSchemaName(String schemaName) { + setSchemaName(schemaName); + return this; + } + + public String getOwner() { + return owner; + } + + public void setOwner(String owner) { + this.owner = owner; + } + + public AlterTextSearchDictionary withOwner(String owner) { + setOwner(owner); + return this; + } + + public List getOptions() { + return options; + } + + public void setOptions(List options) { + this.options = options; + } + + public AlterTextSearchDictionary withOptions(List options) { + setOptions(options); + return this; + } + + /** Returns the last matching option; a bare option has a null argument and removes it. */ + public DefinitionElement getOption(String name) { + return find(options, name); + } + + private static DefinitionElement find(List elements, String name) { + String requested = name.startsWith("\"") + ? name.substring(1, name.length() - 1).replace("\"\"", "\"") + : name.toLowerCase(Locale.ROOT); + for (int i = elements.size() - 1; i >= 0; i--) { + DefinitionElement element = elements.get(i); + String key = element.getName(); + if (key.startsWith("\"")) { + key = key.substring(1, key.length() - 1).replace("\"\"", "\""); + } else { + key = key.toLowerCase(Locale.ROOT); + } + if (requested.equals(key)) { + return element; + } + } + return null; + } + + public StringBuilder appendTo(StringBuilder sql) { + sql.append("ALTER TEXT SEARCH DICTIONARY ").append(name); + switch (action) { + case OPTIONS: + return sql.append(' ').append(DefinitionElement.toString(options)); + case OWNER: + return sql.append(" OWNER TO ").append(owner); + case RENAME: + return sql.append(" RENAME TO ").append(newName); + case SET_SCHEMA: + return sql.append(" SET SCHEMA ").append(schemaName); + default: + throw new IllegalStateException("Unknown text-search action: " + action); + } + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + @Override + public T accept(StatementVisitor visitor, S context) { + return visitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/alter/AlterTextSearchParser.java b/src/main/java/net/sf/jsqlparser/statement/alter/AlterTextSearchParser.java new file mode 100644 index 000000000..2a8f86de9 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/alter/AlterTextSearchParser.java @@ -0,0 +1,103 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2026 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.alter; + +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +/** + * PostgreSQL ALTER TEXT SEARCH PARSER. Only rename and schema changes are supported; there is no + * OWNER TO form. + */ +public class AlterTextSearchParser extends ASTNodeAccessImpl implements Statement { + public enum Action { + RENAME, SET_SCHEMA + } + + private String name; + private Action action; + private String newName; + private String schemaName; + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public AlterTextSearchParser withName(String name) { + setName(name); + return this; + } + + public Action getAction() { + return action; + } + + public void setAction(Action action) { + this.action = action; + } + + public AlterTextSearchParser withAction(Action action) { + setAction(action); + return this; + } + + public String getNewName() { + return newName; + } + + public void setNewName(String newName) { + this.newName = newName; + } + + public AlterTextSearchParser withNewName(String newName) { + setNewName(newName); + return this; + } + + public String getSchemaName() { + return schemaName; + } + + public void setSchemaName(String schemaName) { + this.schemaName = schemaName; + } + + public AlterTextSearchParser withSchemaName(String schemaName) { + setSchemaName(schemaName); + return this; + } + + public StringBuilder appendTo(StringBuilder sql) { + sql.append("ALTER TEXT SEARCH PARSER ").append(name); + switch (action) { + case RENAME: + return sql.append(" RENAME TO ").append(newName); + case SET_SCHEMA: + return sql.append(" SET SCHEMA ").append(schemaName); + default: + throw new IllegalStateException("Unknown text-search action: " + action); + } + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + @Override + public T accept(StatementVisitor visitor, S context) { + return visitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/alter/AlterTextSearchTemplate.java b/src/main/java/net/sf/jsqlparser/statement/alter/AlterTextSearchTemplate.java new file mode 100644 index 000000000..897edb17f --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/alter/AlterTextSearchTemplate.java @@ -0,0 +1,103 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2026 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.alter; + +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +/** + * PostgreSQL ALTER TEXT SEARCH TEMPLATE. Only rename and schema changes are supported; there is no + * OWNER TO form. + */ +public class AlterTextSearchTemplate extends ASTNodeAccessImpl implements Statement { + public enum Action { + RENAME, SET_SCHEMA + } + + private String name; + private Action action; + private String newName; + private String schemaName; + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public AlterTextSearchTemplate withName(String name) { + setName(name); + return this; + } + + public Action getAction() { + return action; + } + + public void setAction(Action action) { + this.action = action; + } + + public AlterTextSearchTemplate withAction(Action action) { + setAction(action); + return this; + } + + public String getNewName() { + return newName; + } + + public void setNewName(String newName) { + this.newName = newName; + } + + public AlterTextSearchTemplate withNewName(String newName) { + setNewName(newName); + return this; + } + + public String getSchemaName() { + return schemaName; + } + + public void setSchemaName(String schemaName) { + this.schemaName = schemaName; + } + + public AlterTextSearchTemplate withSchemaName(String schemaName) { + setSchemaName(schemaName); + return this; + } + + public StringBuilder appendTo(StringBuilder sql) { + sql.append("ALTER TEXT SEARCH TEMPLATE ").append(name); + switch (action) { + case RENAME: + return sql.append(" RENAME TO ").append(newName); + case SET_SCHEMA: + return sql.append(" SET SCHEMA ").append(schemaName); + default: + throw new IllegalStateException("Unknown text-search action: " + action); + } + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + @Override + public T accept(StatementVisitor visitor, S context) { + return visitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/language/CreateLanguage.java b/src/main/java/net/sf/jsqlparser/statement/create/language/CreateLanguage.java new file mode 100644 index 000000000..5e53d547e --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/language/CreateLanguage.java @@ -0,0 +1,181 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2026 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.create.language; + +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +/** + * PostgreSQL CREATE [OR REPLACE] [TRUSTED] [PROCEDURAL] LANGUAGE, including the handlerless form. + */ +public class CreateLanguage extends ASTNodeAccessImpl implements Statement { + private boolean orReplace; + private boolean trusted; + private boolean procedural; + private String name; + private String handler; + private String inlineHandler; + private String validator; + private boolean noValidator; + + public boolean isOrReplace() { + return orReplace; + } + + public void setOrReplace(boolean orReplace) { + this.orReplace = orReplace; + } + + public CreateLanguage withOrReplace(boolean orReplace) { + setOrReplace(orReplace); + return this; + } + + public boolean isTrusted() { + return trusted; + } + + public void setTrusted(boolean trusted) { + this.trusted = trusted; + } + + public CreateLanguage withTrusted(boolean trusted) { + setTrusted(trusted); + return this; + } + + public boolean isProcedural() { + return procedural; + } + + public void setProcedural(boolean procedural) { + this.procedural = procedural; + } + + public CreateLanguage withProcedural(boolean procedural) { + setProcedural(procedural); + return this; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public CreateLanguage withName(String name) { + setName(name); + return this; + } + + public String getHandler() { + return handler; + } + + /** Removing HANDLER also removes its optional INLINE and VALIDATOR clauses. */ + public void setHandler(String handler) { + this.handler = handler; + if (handler == null) { + inlineHandler = null; + validator = null; + noValidator = false; + } + } + + public CreateLanguage withHandler(String handler) { + setHandler(handler); + return this; + } + + public String getInlineHandler() { + return inlineHandler; + } + + public void setInlineHandler(String inlineHandler) { + this.inlineHandler = inlineHandler; + } + + public CreateLanguage withInlineHandler(String inlineHandler) { + setInlineHandler(inlineHandler); + return this; + } + + public String getValidator() { + return validator; + } + + public void setValidator(String validator) { + this.validator = validator; + if (validator != null) { + noValidator = false; + } + } + + public CreateLanguage withValidator(String validator) { + setValidator(validator); + return this; + } + + /** Whether an explicit NO VALIDATOR is written, rather than an omitted validator. */ + public boolean isNoValidator() { + return noValidator; + } + + public void setNoValidator(boolean noValidator) { + this.noValidator = noValidator; + if (noValidator) { + validator = null; + } + } + + public CreateLanguage withNoValidator(boolean noValidator) { + setNoValidator(noValidator); + return this; + } + + public StringBuilder appendTo(StringBuilder sql) { + sql.append("CREATE "); + if (orReplace) { + sql.append("OR REPLACE "); + } + if (trusted) { + sql.append("TRUSTED "); + } + if (procedural) { + sql.append("PROCEDURAL "); + } + sql.append("LANGUAGE ").append(name); + if (handler != null) { + sql.append(" HANDLER ").append(handler); + if (inlineHandler != null) { + sql.append(" INLINE ").append(inlineHandler); + } + if (noValidator) { + sql.append(" NO VALIDATOR"); + } else if (validator != null) { + sql.append(" VALIDATOR ").append(validator); + } + } + return sql; + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + @Override + public T accept(StatementVisitor visitor, S context) { + return visitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/textsearch/CreateTextSearchDictionary.java b/src/main/java/net/sf/jsqlparser/statement/create/textsearch/CreateTextSearchDictionary.java new file mode 100644 index 000000000..f3960fe56 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/textsearch/CreateTextSearchDictionary.java @@ -0,0 +1,99 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2026 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.create.textsearch; + +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; +import net.sf.jsqlparser.statement.DefinitionArgument; +import net.sf.jsqlparser.statement.DefinitionElement; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +/** + * PostgreSQL CREATE TEXT SEARCH DICTIONARY. Ordered options preserve names, typed values and + * quoting. + */ +public class CreateTextSearchDictionary extends ASTNodeAccessImpl implements Statement { + private String name; + private List options = new ArrayList<>(); + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public CreateTextSearchDictionary withName(String name) { + setName(name); + return this; + } + + public List getOptions() { + return options; + } + + public void setOptions(List options) { + this.options = options; + } + + public CreateTextSearchDictionary withOptions(List options) { + setOptions(options); + return this; + } + + /** Returns the last matching option, while the complete list retains source order. */ + public DefinitionElement getOption(String name) { + return find(options, name); + } + + /** The TEMPLATE value, represented as PostgreSQL's typed definition argument. */ + public DefinitionArgument getTemplate() { + DefinitionElement template = getOption("TEMPLATE"); + return template == null ? null : template.getArgument(); + } + + private static DefinitionElement find(List elements, String name) { + String requested = name.startsWith("\"") + ? name.substring(1, name.length() - 1).replace("\"\"", "\"") + : name.toLowerCase(Locale.ROOT); + for (int i = elements.size() - 1; i >= 0; i--) { + DefinitionElement element = elements.get(i); + String key = element.getName(); + if (key.startsWith("\"")) { + key = key.substring(1, key.length() - 1).replace("\"\"", "\""); + } else { + key = key.toLowerCase(Locale.ROOT); + } + if (requested.equals(key)) { + return element; + } + } + return null; + } + + public StringBuilder appendTo(StringBuilder sql) { + return sql.append("CREATE TEXT SEARCH DICTIONARY ").append(name).append(' ') + .append(DefinitionElement.toString(options)); + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + @Override + public T accept(StatementVisitor visitor, S context) { + return visitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/textsearch/CreateTextSearchParser.java b/src/main/java/net/sf/jsqlparser/statement/create/textsearch/CreateTextSearchParser.java new file mode 100644 index 000000000..63d5538df --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/textsearch/CreateTextSearchParser.java @@ -0,0 +1,113 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2026 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.create.textsearch; + +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; +import net.sf.jsqlparser.statement.DefinitionArgument; +import net.sf.jsqlparser.statement.DefinitionElement; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +/** PostgreSQL CREATE TEXT SEARCH PARSER. Functions may appear in any order. */ +public class CreateTextSearchParser extends ASTNodeAccessImpl implements Statement { + private String name; + private List functions = new ArrayList<>(); + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public CreateTextSearchParser withName(String name) { + setName(name); + return this; + } + + public List getFunctions() { + return functions; + } + + public void setFunctions(List functions) { + this.functions = functions; + } + + public CreateTextSearchParser withFunctions(List functions) { + setFunctions(functions); + return this; + } + + /** + * Returns the last matching function; the list retains all typed definitions in source order. + */ + public DefinitionArgument getFunction(String name) { + DefinitionElement function = find(functions, name); + return function == null ? null : function.getArgument(); + } + + public DefinitionArgument getStartFunction() { + return getFunction("START"); + } + + public DefinitionArgument getGetTokenFunction() { + return getFunction("GETTOKEN"); + } + + public DefinitionArgument getEndFunction() { + return getFunction("END"); + } + + public DefinitionArgument getLexTypesFunction() { + return getFunction("LEXTYPES"); + } + + public DefinitionArgument getHeadlineFunction() { + return getFunction("HEADLINE"); + } + + private static DefinitionElement find(List elements, String name) { + String requested = name.startsWith("\"") + ? name.substring(1, name.length() - 1).replace("\"\"", "\"") + : name.toLowerCase(Locale.ROOT); + for (int i = elements.size() - 1; i >= 0; i--) { + DefinitionElement element = elements.get(i); + String key = element.getName(); + if (key.startsWith("\"")) { + key = key.substring(1, key.length() - 1).replace("\"\"", "\""); + } else { + key = key.toLowerCase(Locale.ROOT); + } + if (requested.equals(key)) { + return element; + } + } + return null; + } + + public StringBuilder appendTo(StringBuilder sql) { + return sql.append("CREATE TEXT SEARCH PARSER ").append(name).append(' ') + .append(DefinitionElement.toString(functions)); + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + @Override + public T accept(StatementVisitor visitor, S context) { + return visitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/textsearch/CreateTextSearchTemplate.java b/src/main/java/net/sf/jsqlparser/statement/create/textsearch/CreateTextSearchTemplate.java new file mode 100644 index 000000000..ba5e52530 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/textsearch/CreateTextSearchTemplate.java @@ -0,0 +1,101 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2026 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.create.textsearch; + +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; +import net.sf.jsqlparser.statement.DefinitionArgument; +import net.sf.jsqlparser.statement.DefinitionElement; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +/** PostgreSQL CREATE TEXT SEARCH TEMPLATE. Functions may appear in any order. */ +public class CreateTextSearchTemplate extends ASTNodeAccessImpl implements Statement { + private String name; + private List functions = new ArrayList<>(); + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public CreateTextSearchTemplate withName(String name) { + setName(name); + return this; + } + + public List getFunctions() { + return functions; + } + + public void setFunctions(List functions) { + this.functions = functions; + } + + public CreateTextSearchTemplate withFunctions(List functions) { + setFunctions(functions); + return this; + } + + /** + * Returns the last matching function; the list retains all typed definitions in source order. + */ + public DefinitionArgument getFunction(String name) { + DefinitionElement function = find(functions, name); + return function == null ? null : function.getArgument(); + } + + public DefinitionArgument getInitFunction() { + return getFunction("INIT"); + } + + public DefinitionArgument getLexizeFunction() { + return getFunction("LEXIZE"); + } + + private static DefinitionElement find(List elements, String name) { + String requested = name.startsWith("\"") + ? name.substring(1, name.length() - 1).replace("\"\"", "\"") + : name.toLowerCase(Locale.ROOT); + for (int i = elements.size() - 1; i >= 0; i--) { + DefinitionElement element = elements.get(i); + String key = element.getName(); + if (key.startsWith("\"")) { + key = key.substring(1, key.length() - 1).replace("\"\"", "\""); + } else { + key = key.toLowerCase(Locale.ROOT); + } + if (requested.equals(key)) { + return element; + } + } + return null; + } + + public StringBuilder appendTo(StringBuilder sql) { + return sql.append("CREATE TEXT SEARCH TEMPLATE ").append(name).append(' ') + .append(DefinitionElement.toString(functions)); + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + @Override + public T accept(StatementVisitor visitor, S context) { + return visitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java b/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java index 63551dae7..b84ed3e0e 100644 --- a/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java +++ b/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java @@ -143,6 +143,15 @@ import net.sf.jsqlparser.statement.create.cast.CreateCast; import net.sf.jsqlparser.statement.create.transform.CreateTransform; import net.sf.jsqlparser.statement.create.conversion.CreateConversion; +import net.sf.jsqlparser.statement.create.language.CreateLanguage; +import net.sf.jsqlparser.statement.alter.AlterLanguage; +import net.sf.jsqlparser.statement.alter.AlterLargeObject; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchDictionary; +import net.sf.jsqlparser.statement.alter.AlterTextSearchDictionary; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchParser; +import net.sf.jsqlparser.statement.alter.AlterTextSearchParser; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchTemplate; +import net.sf.jsqlparser.statement.alter.AlterTextSearchTemplate; import net.sf.jsqlparser.statement.alter.AlterConversion; import net.sf.jsqlparser.statement.alter.AlterServer; import net.sf.jsqlparser.statement.alter.AlterSession; @@ -3723,4 +3732,49 @@ public Void visit(AlterOperatorFamily statement, S context) { public Void visit(AlterAggregate statement, S context) { return null; } + + @Override + public Void visit(CreateLanguage statement, S context) { + return null; + } + + @Override + public Void visit(AlterLanguage statement, S context) { + return null; + } + + @Override + public Void visit(AlterLargeObject statement, S context) { + return null; + } + + @Override + public Void visit(CreateTextSearchDictionary statement, S context) { + return null; + } + + @Override + public Void visit(AlterTextSearchDictionary statement, S context) { + return null; + } + + @Override + public Void visit(CreateTextSearchParser statement, S context) { + return null; + } + + @Override + public Void visit(AlterTextSearchParser statement, S context) { + return null; + } + + @Override + public Void visit(CreateTextSearchTemplate statement, S context) { + return null; + } + + @Override + public Void visit(AlterTextSearchTemplate statement, S context) { + return null; + } } diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/StatementDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/StatementDeParser.java index c158f2b65..6a3bacfcc 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/StatementDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/StatementDeParser.java @@ -44,6 +44,15 @@ import net.sf.jsqlparser.statement.create.cast.CreateCast; import net.sf.jsqlparser.statement.create.transform.CreateTransform; import net.sf.jsqlparser.statement.create.conversion.CreateConversion; +import net.sf.jsqlparser.statement.create.language.CreateLanguage; +import net.sf.jsqlparser.statement.alter.AlterLanguage; +import net.sf.jsqlparser.statement.alter.AlterLargeObject; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchDictionary; +import net.sf.jsqlparser.statement.alter.AlterTextSearchDictionary; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchParser; +import net.sf.jsqlparser.statement.alter.AlterTextSearchParser; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchTemplate; +import net.sf.jsqlparser.statement.alter.AlterTextSearchTemplate; import net.sf.jsqlparser.statement.alter.AlterConversion; import net.sf.jsqlparser.statement.alter.AlterTablespace; import net.sf.jsqlparser.statement.alter.AlterTablespaceMove; @@ -1319,4 +1328,50 @@ public StringBuilder visit(AlterOperatorFamily statement, S context) { public StringBuilder visit(AlterAggregate statement, S context) { return statement.appendTo(builder); } + + @Override + public StringBuilder visit(CreateLanguage statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(AlterLanguage statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(AlterLargeObject statement, S context) { + return statement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(CreateTextSearchDictionary statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(AlterTextSearchDictionary statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(CreateTextSearchParser statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(AlterTextSearchParser statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(CreateTextSearchTemplate statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(AlterTextSearchTemplate statement, S context) { + return statement.appendTo(builder); + } } diff --git a/src/main/java/net/sf/jsqlparser/util/validation/feature/FeaturesAllowed.java b/src/main/java/net/sf/jsqlparser/util/validation/feature/FeaturesAllowed.java index 338114efc..15b655a10 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/feature/FeaturesAllowed.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/feature/FeaturesAllowed.java @@ -102,6 +102,8 @@ public class FeaturesAllowed implements FeatureSetValidation, ModifyableFeatureS */ public static final FeaturesAllowed CREATE = new FeaturesAllowed("CREATE", Feature.createIndex, Feature.createTextSearchConfiguration, + Feature.createLanguage, Feature.createTextSearchDictionary, + Feature.createTextSearchParser, Feature.createTextSearchTemplate, Feature.createRule, Feature.createCollation, Feature.createCast, Feature.createTransform, Feature.createConversion, @@ -124,6 +126,9 @@ public class FeaturesAllowed implements FeatureSetValidation, ModifyableFeatureS public static final FeaturesAllowed ALTER = new FeaturesAllowed("ALTER", Feature.alterTable, Feature.alterSequence, Feature.alterTextSearchConfiguration, + Feature.alterLanguage, Feature.alterLargeObject, + Feature.alterTextSearchDictionary, Feature.alterTextSearchParser, + Feature.alterTextSearchTemplate, Feature.alterCollation, Feature.alterRule, Feature.alterConversion, Feature.alterOperator, Feature.alterOperatorClass, diff --git a/src/main/java/net/sf/jsqlparser/util/validation/feature/PostgresqlVersion.java b/src/main/java/net/sf/jsqlparser/util/validation/feature/PostgresqlVersion.java index f36c6cf7e..e788634e8 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/feature/PostgresqlVersion.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/feature/PostgresqlVersion.java @@ -130,6 +130,10 @@ public enum PostgresqlVersion implements Version { // https://www.postgresql.org/docs/current/sql-createconversion.html // https://www.postgresql.org/docs/current/sql-alterconversion.html Feature.createCast, Feature.createTransform, Feature.createConversion, + Feature.createLanguage, Feature.alterLanguage, Feature.alterLargeObject, + Feature.createTextSearchDictionary, Feature.alterTextSearchDictionary, + Feature.createTextSearchParser, Feature.alterTextSearchParser, + Feature.createTextSearchTemplate, Feature.alterTextSearchTemplate, Feature.alterConversion, // https://www.postgresql.org/docs/current/sql-createoperator.html // https://www.postgresql.org/docs/current/sql-createopclass.html // https://www.postgresql.org/docs/current/sql-createopfamily.html diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/StatementValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/StatementValidator.java index 82b0b9326..3adb41358 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/validator/StatementValidator.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/StatementValidator.java @@ -22,6 +22,15 @@ import net.sf.jsqlparser.statement.create.cast.CreateCast; import net.sf.jsqlparser.statement.create.transform.CreateTransform; import net.sf.jsqlparser.statement.create.conversion.CreateConversion; +import net.sf.jsqlparser.statement.create.language.CreateLanguage; +import net.sf.jsqlparser.statement.alter.AlterLanguage; +import net.sf.jsqlparser.statement.alter.AlterLargeObject; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchDictionary; +import net.sf.jsqlparser.statement.alter.AlterTextSearchDictionary; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchParser; +import net.sf.jsqlparser.statement.alter.AlterTextSearchParser; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchTemplate; +import net.sf.jsqlparser.statement.alter.AlterTextSearchTemplate; import net.sf.jsqlparser.statement.alter.AlterConversion; import net.sf.jsqlparser.statement.alter.AlterTablespace; import net.sf.jsqlparser.statement.alter.AlterTablespaceMove; @@ -1850,4 +1859,59 @@ public Void visit(AlterAggregate statement, S context) { validateFeature(Feature.alterAggregate); return null; } + + @Override + public Void visit(CreateLanguage statement, S context) { + validateFeature(Feature.createLanguage); + return null; + } + + @Override + public Void visit(AlterLanguage statement, S context) { + validateFeature(Feature.alterLanguage); + return null; + } + + @Override + public Void visit(AlterLargeObject statement, S context) { + validateFeature(Feature.alterLargeObject); + statement.visitExpressions(this::validateOptionalExpression); + return null; + } + + @Override + public Void visit(CreateTextSearchDictionary statement, S context) { + validateFeature(Feature.createTextSearchDictionary); + return null; + } + + @Override + public Void visit(AlterTextSearchDictionary statement, S context) { + validateFeature(Feature.alterTextSearchDictionary); + return null; + } + + @Override + public Void visit(CreateTextSearchParser statement, S context) { + validateFeature(Feature.createTextSearchParser); + return null; + } + + @Override + public Void visit(AlterTextSearchParser statement, S context) { + validateFeature(Feature.alterTextSearchParser); + return null; + } + + @Override + public Void visit(CreateTextSearchTemplate statement, S context) { + validateFeature(Feature.createTextSearchTemplate); + return null; + } + + @Override + public Void visit(AlterTextSearchTemplate statement, S context) { + validateFeature(Feature.alterTextSearchTemplate); + return null; + } } diff --git a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt index 80a3d42a7..237e31e06 100644 --- a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt +++ b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt @@ -55,6 +55,10 @@ import net.sf.jsqlparser.statement.create.server.CreateServer; import net.sf.jsqlparser.statement.create.accessmethod.CreateAccessMethod; import net.sf.jsqlparser.statement.create.usermapping.CreateUserMapping; import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchConfiguration; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchDictionary; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchParser; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchTemplate; +import net.sf.jsqlparser.statement.create.language.CreateLanguage; import net.sf.jsqlparser.statement.create.rule.CreateRule; import net.sf.jsqlparser.statement.notify.NotifyStatement; import net.sf.jsqlparser.statement.notify.ListenStatement; @@ -5127,6 +5131,66 @@ public class CCJSqlParser extends AbstractJSqlParser { || "SQL_BUFFER_RESULT".equalsIgnoreCase(token.image)); } + /** Recognizes PostgreSQL's language form without taking other products' opaque LANGUAGE DDL. */ + private boolean isCreateLanguageAhead() { + if (isPostgreSqlDialect() && isAnyWordAt(1, "TRUSTED", "PROCEDURAL", "LANGUAGE")) { + return true; + } + int offset = isWordAt(1, "TRUSTED") ? 2 : 1; + if (isWordAt(offset, "PROCEDURAL")) { + offset++; + } + if (!isWordAt(offset, "LANGUAGE")) { + return false; + } + int following = getToken(offset + 2).kind; + return following == EOF || following == ST_SEMICOLON || following == K_HANDLER; + } + + private boolean isAlterLanguageAhead() { + int offset = isWordAt(1, "PROCEDURAL") ? 2 : 1; + return isWordAt(offset, "LANGUAGE") && (isPostgreSqlDialect() + || getToken(offset + 2).kind == K_RENAME || isWordAt(offset + 2, "OWNER")); + } + + private boolean isTextSearchMetadataAhead() { + return getToken(1).kind == K_TEXT_LITERAL && getToken(2).kind == K_SEARCH + && (getToken(3).kind == K_PARSER || isAnyWordAt(3, "DICTIONARY", "TEMPLATE")); + } + + /** Quoted definition keys retain case in PostgreSQL; unquoted keys are folded to lower case. */ + private static String textSearchDefinitionKey(DefinitionElement element) { + String name = element.getName(); + return name.startsWith("\"") ? name.substring(1, name.length() - 1).replace("\"\"", "\"") + : name.toLowerCase(Locale.ROOT); + } + + private void requireTextSearchDictionary(List options) throws ParseException { + int templates = 0; + for (DefinitionElement option : options) { + requireDdlSyntax(option.getArgument() != null, "CREATE dictionary options require a value"); + if ("template".equals(textSearchDefinitionKey(option))) { + templates++; + } + } + requireDdlSyntax(templates > 0, "CREATE TEXT SEARCH DICTIONARY requires TEMPLATE"); + } + + private void requireTextSearchFunctions(List functions, boolean parser) + throws ParseException { + Set required = new HashSet(parser + ? Arrays.asList("start", "gettoken", "end", "lextypes") : Arrays.asList("lexize")); + Set seen = new HashSet(); + for (DefinitionElement function : functions) { + String name = textSearchDefinitionKey(function); + requireDdlSyntax(required.contains(name) || (parser ? "headline" : "init").equals(name), + "Unknown text-search function: " + function.getName()); + requireDdlSyntax(function.getArgument() != null, "Text-search functions require a value"); + seen.add(name); + } + requireDdlSyntax(seen.containsAll(required), "Missing required text-search functions"); + } + /** Whether the dialect is PostgreSQL: forms the server rejects are then not read. */ private boolean isPostgreSqlDialect() { return Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)); @@ -26984,6 +27048,12 @@ Statement Alter(): | LOOKAHEAD({ getToken(1).kind == K_USER && "MAPPING".equalsIgnoreCase(getToken(2).image) }) statement = AlterUserMapping() | + LOOKAHEAD({ isAlterLanguageAhead() }) statement = AlterLanguage() + | + LOOKAHEAD({ isWordSequenceAhead(1, "LARGE", "OBJECT") }) statement = AlterLargeObject() + | + LOOKAHEAD({ isTextSearchMetadataAhead() }) statement = AlterTextSearchMetadata() + | LOOKAHEAD({ getToken(1).kind == K_TEXT_LITERAL && getToken(2).kind == K_SEARCH && "CONFIGURATION".equalsIgnoreCase(getToken(3).image) }) statement = AlterTextSearchConfiguration() @@ -29096,6 +29166,12 @@ Statement Create(): | LOOKAHEAD({ getToken(1).kind == K_USER && "MAPPING".equalsIgnoreCase(getToken(2).image) }) { requireDdlSyntax(!isUsingOrReplace, "OR REPLACE is not supported for foreign-data objects"); } statement = CreateUserMapping() | + LOOKAHEAD({ isCreateLanguageAhead() }) statement = CreateLanguage(isUsingOrReplace) + | + LOOKAHEAD({ isTextSearchMetadataAhead() }) + { requireDdlSyntax(!isUsingOrReplace, "Text-search objects do not support OR REPLACE"); } + statement = CreateTextSearchMetadata() + | LOOKAHEAD({ getToken(1).kind == K_TEXT_LITERAL && getToken(2).kind == K_SEARCH && "CONFIGURATION".equalsIgnoreCase(getToken(3).image) }) { requireDdlSyntax(!isUsingOrReplace, "CREATE TEXT SEARCH CONFIGURATION does not support OR REPLACE"); } statement = CreateTextSearchConfiguration() @@ -31243,6 +31319,181 @@ CreateAccessMethod CreateAccessMethod(): { statement.setHandler(name); return statement; } } +/** PostgreSQL CREATE [OR REPLACE] [TRUSTED] [PROCEDURAL] LANGUAGE name [HANDLER ...]. */ +CreateLanguage CreateLanguage(boolean orReplace): +{ + CreateLanguage statement = new CreateLanguage(); String name; +} +{ + { statement.setOrReplace(orReplace); } + [ LOOKAHEAD({ isKeywordAhead("TRUSTED") }) ContextualKeyword("TRUSTED") { statement.setTrusted(true); } ] + [ LOOKAHEAD({ isKeywordAhead("PROCEDURAL") }) ContextualKeyword("PROCEDURAL") { statement.setProcedural(true); } ] + ContextualKeyword("LANGUAGE") name=RelObjectName() + { requireConversionName(name, false); statement.setName(name); } + [ LOOKAHEAD({ getToken(1).kind == K_HANDLER }) name=TypeDdlName() + { requireConversionName(name, false); statement.setHandler(name); } + [ LOOKAHEAD({ isKeywordAhead("INLINE") }) ContextualKeyword("INLINE") name=TypeDdlName() + { requireConversionName(name, false); statement.setInlineHandler(name); } ] + [ + LOOKAHEAD({ isKeywordAhead("VALIDATOR") }) ContextualKeyword("VALIDATOR") name=TypeDdlName() + { requireConversionName(name, false); statement.setValidator(name); } + | + ContextualKeyword("VALIDATOR") { statement.setNoValidator(true); } + ] + ] + { return statement; } +} + +AlterLanguage AlterLanguage(): +{ AlterLanguage statement = new AlterLanguage(); String name; } +{ + [ LOOKAHEAD({ isKeywordAhead("PROCEDURAL") }) ContextualKeyword("PROCEDURAL") { statement.setProcedural(true); } ] + ContextualKeyword("LANGUAGE") name=RelObjectName() + { requireConversionName(name, false); statement.setName(name); } + ( + name=RelObjectName() + { requireConversionName(name, false); statement.setAction(AlterLanguage.Action.RENAME); statement.setNewName(name); } + | + ContextualKeyword("OWNER") name=RelObjectName() + { requireConversionName(name, true); statement.setAction(AlterLanguage.Action.OWNER); statement.setOwner(name); } + ) + { return statement; } +} + +AlterLargeObject AlterLargeObject(): +{ + AlterLargeObject statement = new AlterLargeObject(); String owner; + Token first; Token sign = null; Token number; Expression objectId; +} +{ + ContextualKeyword("LARGE") ContextualKeyword("OBJECT") { first = getToken(1); } + [ sign="+" | sign="-" ] + ( + number= { objectId = linkToLastToken(new LongValue(number.image)); } + | + number= { objectId = linkToLastToken(new DoubleValue(number.image)); } + | + number= { + requireDdlSyntax(number.image.regionMatches(true, 0, "0x", 0, 2), + "A large-object OID must be numeric, not a bit string"); + objectId = linkToLastToken(new HexValue(number.image)); + } + ) + { + if (sign != null) { + objectId = linked(new SignedExpression(sign.image.charAt(0), objectId), first); + } + statement.setLargeObjectId(objectId); + } + ContextualKeyword("OWNER") owner=RelObjectName() + { requireConversionName(owner, true); statement.setOwner(owner); return statement; } +} + +Statement CreateTextSearchMetadata(): +{ Statement statement; } +{ + + ( + LOOKAHEAD({ isKeywordAhead("DICTIONARY") }) statement=CreateTextSearchDictionary() + | + LOOKAHEAD({ isKeywordAhead("PARSER") }) statement=CreateTextSearchParser() + | + statement=CreateTextSearchTemplate() + ) + { return statement; } +} + +CreateTextSearchDictionary CreateTextSearchDictionary(): +{ CreateTextSearchDictionary statement = new CreateTextSearchDictionary(); String name; List options; } +{ + ContextualKeyword("DICTIONARY") name=TypeDdlName() + { requireConversionName(name, false); statement.setName(name); } + options=PostgreSqlDefinition() + { requireTextSearchDictionary(options); statement.setOptions(options); return statement; } +} + +CreateTextSearchParser CreateTextSearchParser(): +{ CreateTextSearchParser statement = new CreateTextSearchParser(); String name; List functions; } +{ + name=TypeDdlName() + { requireConversionName(name, false); statement.setName(name); } + functions=PostgreSqlDefinition() + { requireTextSearchFunctions(functions, true); statement.setFunctions(functions); return statement; } +} + +CreateTextSearchTemplate CreateTextSearchTemplate(): +{ CreateTextSearchTemplate statement = new CreateTextSearchTemplate(); String name; List functions; } +{ + ContextualKeyword("TEMPLATE") name=TypeDdlName() + { requireConversionName(name, false); statement.setName(name); } + functions=PostgreSqlDefinition() + { requireTextSearchFunctions(functions, false); statement.setFunctions(functions); return statement; } +} + +Statement AlterTextSearchMetadata(): +{ Statement statement; } +{ + + ( + LOOKAHEAD({ isKeywordAhead("DICTIONARY") }) statement=AlterTextSearchDictionary() + | + LOOKAHEAD({ isKeywordAhead("PARSER") }) statement=AlterTextSearchParser() + | + statement=AlterTextSearchTemplate() + ) + { return statement; } +} + +AlterTextSearchDictionary AlterTextSearchDictionary(): +{ AlterTextSearchDictionary statement = new AlterTextSearchDictionary(); String name; List options; } +{ + ContextualKeyword("DICTIONARY") name=TypeDdlName() + { requireConversionName(name, false); statement.setName(name); } + ( + options=PostgreSqlDefinition() { statement.setAction(AlterTextSearchDictionary.Action.OPTIONS); statement.setOptions(options); } + | + name=RelObjectName() + { requireConversionName(name, false); statement.setAction(AlterTextSearchDictionary.Action.RENAME); statement.setNewName(name); } + | + ContextualKeyword("OWNER") name=RelObjectName() + { requireConversionName(name, true); statement.setAction(AlterTextSearchDictionary.Action.OWNER); statement.setOwner(name); } + | + name=RelObjectName() + { requireConversionName(name, false); statement.setAction(AlterTextSearchDictionary.Action.SET_SCHEMA); statement.setSchemaName(name); } + ) + { return statement; } +} + +AlterTextSearchParser AlterTextSearchParser(): +{ AlterTextSearchParser statement = new AlterTextSearchParser(); String name; } +{ + name=TypeDdlName() + { requireConversionName(name, false); statement.setName(name); } + ( + name=RelObjectName() + { requireConversionName(name, false); statement.setAction(AlterTextSearchParser.Action.RENAME); statement.setNewName(name); } + | + name=RelObjectName() + { requireConversionName(name, false); statement.setAction(AlterTextSearchParser.Action.SET_SCHEMA); statement.setSchemaName(name); } + ) + { return statement; } +} + +AlterTextSearchTemplate AlterTextSearchTemplate(): +{ AlterTextSearchTemplate statement = new AlterTextSearchTemplate(); String name; } +{ + ContextualKeyword("TEMPLATE") name=TypeDdlName() + { requireConversionName(name, false); statement.setName(name); } + ( + name=RelObjectName() + { requireConversionName(name, false); statement.setAction(AlterTextSearchTemplate.Action.RENAME); statement.setNewName(name); } + | + name=RelObjectName() + { requireConversionName(name, false); statement.setAction(AlterTextSearchTemplate.Action.SET_SCHEMA); statement.setSchemaName(name); } + ) + { return statement; } +} + CreateTextSearchConfiguration CreateTextSearchConfiguration(): { CreateTextSearchConfiguration statement = new CreateTextSearchConfiguration(); String name; } { diff --git a/src/test/java/net/sf/jsqlparser/statement/UnsupportedStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/UnsupportedStatementTest.java index f88eddc62..f86f1bd10 100644 --- a/src/test/java/net/sf/jsqlparser/statement/UnsupportedStatementTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/UnsupportedStatementTest.java @@ -206,8 +206,8 @@ void testInformixSetStatementIssue1945() throws JSQLParserException { @ParameterizedTest @ValueSource(strings = { - "CREATE LANGUAGE plperl", - "CREATE OR REPLACE TRUSTED PROCEDURAL LANGUAGE plsample HANDLER plsample_call_handler"}) + "CREATE SECRET sample (TYPE S3)", + "CREATE OR REPLACE SECRET sample (TYPE S3)"}) void unknownCreateFallsBackToUnsupportedStatement(String sql) throws JSQLParserException { for (Consumer dialect : Arrays.>asList(parser -> { }, parser -> parser.withDialect(Dialect.POSTGRESQL))) { @@ -222,7 +222,7 @@ void unknownCreateFallsBackToUnsupportedStatement(String sql) throws JSQLParserE @Test void unknownCreateDoesNotStopAScript() throws JSQLParserException { Statements statements = CCJSqlParserUtil.parseStatements( - "CREATE TABLE a (x int); CREATE LANGUAGE plperl; CREATE INDEX i ON a (x);", + "CREATE TABLE a (x int); CREATE SECRET sample (TYPE S3); CREATE INDEX i ON a (x);", parser -> parser.withDialect(Dialect.POSTGRESQL)); assertEquals(3, statements.size()); diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlMetadataDdlTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlMetadataDdlTest.java new file mode 100644 index 000000000..b3eb78c59 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlMetadataDdlTest.java @@ -0,0 +1,511 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2026 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.create; + +import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.ExpressionVisitorAdapter; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.parser.ASTNodeAccess; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.Node; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.statement.DefinitionArgument; +import net.sf.jsqlparser.statement.DefinitionElement; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.alter.AlterLanguage; +import net.sf.jsqlparser.statement.alter.AlterLargeObject; +import net.sf.jsqlparser.statement.alter.AlterTextSearchDictionary; +import net.sf.jsqlparser.statement.alter.AlterTextSearchParser; +import net.sf.jsqlparser.statement.alter.AlterTextSearchTemplate; +import net.sf.jsqlparser.statement.create.language.CreateLanguage; +import net.sf.jsqlparser.statement.create.table.ColDataType; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchDictionary; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchParser; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchTemplate; +import net.sf.jsqlparser.statement.select.SelectVisitorAdapter; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.ExpressionDeParser; +import net.sf.jsqlparser.util.deparser.SelectDeParser; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.ValidationContext; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import net.sf.jsqlparser.util.validation.validator.StatementValidator; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +/** PostgreSQL 18 language, large-object ownership and text-search metadata DDL. */ +class PostgreSqlMetadataDdlTest extends ValidationTestAsserts { + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + + private static Statement parse(String sql) throws Exception { + return CCJSqlParserUtil.parse(sql, POSTGRESQL); + } + + static Stream metadataStatements() { + return Stream.of( + Arguments.of( + "CREATE TRUSTED PROCEDURAL LANGUAGE plsample HANDLER plsample_call_handler INLINE plsample_inline_handler VALIDATOR plsample_validator", + "CreateLanguage"), + Arguments.of("ALTER PROCEDURAL LANGUAGE plsample RENAME TO plsample_new", + "AlterLanguage"), + Arguments.of("ALTER LANGUAGE plsample OWNER TO app_owner", "AlterLanguage"), + Arguments.of("ALTER LARGE OBJECT 12345 OWNER TO app_owner", "AlterLargeObject"), + Arguments.of( + "CREATE TEXT SEARCH DICTIONARY public.simple_dict (TEMPLATE = pg_catalog.simple)", + "CreateTextSearchDictionary"), + Arguments.of( + "ALTER TEXT SEARCH DICTIONARY public.simple_dict (STOPWORDS = english)", + "AlterTextSearchDictionary"), + Arguments.of( + "ALTER TEXT SEARCH DICTIONARY public.simple_dict RENAME TO simple_dict2", + "AlterTextSearchDictionary"), + Arguments.of( + "CREATE TEXT SEARCH PARSER public.sample_parser (START = prsd_start, GETTOKEN = prsd_nexttoken, END = prsd_end, LEXTYPES = prsd_lextype)", + "CreateTextSearchParser"), + Arguments.of( + "ALTER TEXT SEARCH PARSER public.sample_parser RENAME TO sample_parser2", + "AlterTextSearchParser"), + Arguments.of( + "CREATE TEXT SEARCH TEMPLATE public.sample_template (LEXIZE = dsimple_lexize)", + "CreateTextSearchTemplate"), + Arguments.of("ALTER TEXT SEARCH TEMPLATE public.sample_template SET SCHEMA app", + "AlterTextSearchTemplate")); + } + + @ParameterizedTest + @MethodSource("metadataStatements") + void parsesTypedMetadataStatements(String sql, String statementClass) throws Exception { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL); + assertThat(statement.getClass().getSimpleName()).isEqualTo(statementClass); + assertThat(assertSqlCanBeParsedAndDeparsed(sql)).isInstanceOf(statement.getClass()); + assertThat(new TablesNamesFinder().getTables(statement)).isEmpty(); + assertThat(statement.getFeatures().getCertain()).contains(StmtFeature.MODIFIES_SCHEMA) + .doesNotContain(StmtFeature.READS_DATA, StmtFeature.RETURNS_RESULT_SET); + validateNoErrors(sql, 1, PostgresqlVersion.V10, PostgresqlVersion.V14); + validateNoErrors(sql, 1, FeaturesAllowed.DDL); + Feature feature = Feature.valueOf(Character.toLowerCase(statementClass.charAt(0)) + + statementClass.substring(1)); + validateNotAllowed(sql, 1, 1, FeaturesAllowed.SELECT, feature); + validate(sql, 1, 1, MySqlVersion.V8_0); + Node node = ((ASTNodeAccess) statement).getASTNode(); + assertThat(node.jjtGetFirstToken().beginColumn).isEqualTo(1); + assertThat(node.jjtGetLastToken().endColumn).isEqualTo(sql.length()); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE LANGUAGE plsample", + "CREATE OR REPLACE LANGUAGE plsample", + "CREATE TRUSTED LANGUAGE \"Language 1\"", + "CREATE OR REPLACE TRUSTED PROCEDURAL LANGUAGE \"Language 1\" HANDLER s.\"Handler\" INLINE s.inline_fn VALIDATOR s.validator_fn", + "CREATE LANGUAGE plsample HANDLER h", + "CREATE LANGUAGE plsample HANDLER h INLINE i", + "CREATE LANGUAGE plsample HANDLER h VALIDATOR v", + "CREATE LANGUAGE plsample HANDLER h NO VALIDATOR", + "CREATE LANGUAGE plsample HANDLER h INLINE i NO VALIDATOR", + "ALTER LANGUAGE plsample RENAME TO \"New Language\"", + "ALTER LANGUAGE plsample OWNER TO CURRENT_USER", + "ALTER PROCEDURAL LANGUAGE \"Language 1\" OWNER TO CURRENT_ROLE", + "ALTER LANGUAGE plsample OWNER TO SESSION_USER", + "ALTER LARGE OBJECT 4294967295 OWNER TO \"Role 1\"", + "ALTER LARGE OBJECT +12345 OWNER TO CURRENT_ROLE", + "ALTER LARGE OBJECT 0x3039 OWNER TO CURRENT_USER", + "ALTER LARGE OBJECT +0x3039 OWNER TO CURRENT_USER", + "ALTER LARGE OBJECT -1 OWNER TO SESSION_USER", + "CREATE TEXT SEARCH DICTIONARY s.d (STOPWORDS = english, TEMPLATE = pg_catalog.simple, ACCEPT = FALSE)", + "CREATE TEXT SEARCH DICTIONARY s.d (TEMPLATE = s.custom_template, count = -2.5, label = E'value')", + "CREATE TEXT SEARCH DICTIONARY \"S\".\"D\" (\"template\" = pg_catalog.simple)", + "ALTER TEXT SEARCH DICTIONARY s.d (STOPWORDS)", + "ALTER TEXT SEARCH DICTIONARY s.d (language = dutch, STOPWORDS)", + "ALTER TEXT SEARCH DICTIONARY s.d OWNER TO CURRENT_USER", + "ALTER TEXT SEARCH DICTIONARY s.d OWNER TO CURRENT_ROLE", + "ALTER TEXT SEARCH DICTIONARY s.d OWNER TO SESSION_USER", + "ALTER TEXT SEARCH DICTIONARY s.d SET SCHEMA \"New Schema\"", + "CREATE TEXT SEARCH PARSER p (HEADLINE = s.h, LEXTYPES = s.l, END = s.e, GETTOKEN = s.g, START = s.s)", + "CREATE TEXT SEARCH PARSER \"S\".\"P\" (\"start\" = s.s, \"gettoken\" = s.g, \"end\" = s.e, \"lextypes\" = s.l)", + "ALTER TEXT SEARCH PARSER s.p SET SCHEMA \"New Schema\"", + "CREATE TEXT SEARCH TEMPLATE t (INIT = s.i, LEXIZE = s.l)", + "CREATE TEXT SEARCH TEMPLATE t (LEXIZE = pg_catalog.dsimple_lexize (1), INIT = s.i)", + "CREATE TEXT SEARCH TEMPLATE t (LEXIZE = 'dsimple_lexize')", + "CREATE TEXT SEARCH TEMPLATE t (\"lexize\" = s.l)", + "ALTER TEXT SEARCH TEMPLATE s.t RENAME TO \"New Template\""}) + void preservesSupportedVariants(String sql) throws Exception { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL); + assertThat(statement).isNotInstanceOf(UnsupportedStatement.class); + assertThat(assertSqlCanBeParsedAndDeparsed(sql)).isInstanceOf(statement.getClass()); + assertThat(new TablesNamesFinder().getTables(statement)).isEmpty(); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE LANGUAGE 'plsample' HANDLER h", + "CREATE LANGUAGE s.plsample HANDLER h", + "CREATE PROCEDURAL TRUSTED LANGUAGE plsample HANDLER h", + "CREATE LANGUAGE plsample INLINE i", + "CREATE LANGUAGE plsample NO VALIDATOR", + "CREATE LANGUAGE plsample HANDLER h() VALIDATOR v", + "CREATE LANGUAGE plsample HANDLER h VALIDATOR v INLINE i", + "CREATE LANGUAGE plsample HANDLER h NO VALIDATOR VALIDATOR v", + "CREATE LANGUAGE plsample HANDLER", + "ALTER LANGUAGE plsample SET SCHEMA s", + "ALTER LANGUAGE plsample OWNER TO s.r", + "ALTER LARGE OBJECT name OWNER TO r", + "ALTER LARGE OBJECT '12345' OWNER TO r", + "ALTER LARGE OBJECT X'3039' OWNER TO r", + "ALTER LARGE OBJECT 12345 RENAME TO oid2", + "CREATE OR REPLACE TEXT SEARCH DICTIONARY d (TEMPLATE = simple)", + "CREATE TEXT SEARCH DICTIONARY d ()", + "CREATE TEXT SEARCH DICTIONARY d (STOPWORDS = english)", + "CREATE TEXT SEARCH DICTIONARY d (TEMPLATE)", + "CREATE TEXT SEARCH DICTIONARY d (TEMPLATE = simple, STOPWORDS)", + "CREATE TEXT SEARCH PARSER p (START = f, GETTOKEN = f, END = f)", + "CREATE TEXT SEARCH PARSER p (START = f, GETTOKEN = f, END = f, LEXTYPES = f, UNKNOWN = f)", + "CREATE TEXT SEARCH PARSER p (START, GETTOKEN = f, END = f, LEXTYPES = f)", + "CREATE TEXT SEARCH TEMPLATE t (INIT = f)", + "CREATE TEXT SEARCH TEMPLATE t (LEXIZE)", + "CREATE OR REPLACE TEXT SEARCH TEMPLATE t (LEXIZE = f)", + "ALTER TEXT SEARCH PARSER p OWNER TO r", + "ALTER TEXT SEARCH TEMPLATE t OWNER TO r", + "ALTER TEXT SEARCH PARSER p (START = f)", + "ALTER TEXT SEARCH TEMPLATE t (LEXIZE = f)"}) + void rejectsInvalidMetadataForms(String sql) { + assertThatThrownBy(() -> parse(sql)).isInstanceOf(JSQLParserException.class); + } + + @Test + void readsLanguageFieldsAndMaintainsValidatorAlternatives() throws Exception { + CreateLanguage language = (CreateLanguage) parse( + "CREATE OR REPLACE TRUSTED PROCEDURAL LANGUAGE \"L\" HANDLER s.h INLINE s.i NO VALIDATOR"); + assertThat(language.isOrReplace()).isTrue(); + assertThat(language.isTrusted()).isTrue(); + assertThat(language.isProcedural()).isTrue(); + assertThat(language.getName()).isEqualTo("\"L\""); + assertThat(language.getHandler()).isEqualTo("s.h"); + assertThat(language.getInlineHandler()).isEqualTo("s.i"); + assertThat(language.isNoValidator()).isTrue(); + assertThat(language.getValidator()).isNull(); + language.setValidator("s.v"); + assertThat(language.isNoValidator()).isFalse(); + assertThat(language).hasToString( + "CREATE OR REPLACE TRUSTED PROCEDURAL LANGUAGE \"L\" HANDLER s.h INLINE s.i VALIDATOR s.v"); + language.setNoValidator(true); + assertThat(language.getValidator()).isNull(); + language.setHandler(null); + assertThat(language.getInlineHandler()).isNull(); + assertThat(language.getValidator()).isNull(); + assertThat(language.isNoValidator()).isFalse(); + assertThat(language).hasToString("CREATE OR REPLACE TRUSTED PROCEDURAL LANGUAGE \"L\""); + AlterLanguage alter = + (AlterLanguage) parse("ALTER PROCEDURAL LANGUAGE plsample OWNER TO CURRENT_ROLE"); + assertThat(alter.isProcedural()).isTrue(); + assertThat(alter.getAction()).isEqualTo(AlterLanguage.Action.OWNER); + assertThat(alter.getOwner()).isEqualTo("CURRENT_ROLE"); + } + + @Test + void exposesTypedOrderedDictionaryValuesAndResetOptions() throws Exception { + CreateTextSearchDictionary dictionary = (CreateTextSearchDictionary) parse( + "CREATE TEXT SEARCH DICTIONARY s.d (count = -2.5, TEMPLATE = s.custom_template, label = 'text')"); + assertThat(dictionary.getName()).isEqualTo("s.d"); + assertThat(dictionary.getOptions()).extracting(DefinitionElement::getName) + .containsExactly("count", "TEMPLATE", "label"); + assertThat(dictionary.getTemplate().getKind()).isEqualTo(DefinitionArgument.Kind.TYPE); + assertThat(dictionary.getTemplate().getDataType().getDataType()) + .isEqualTo("s.custom_template"); + assertThat(dictionary.getOption("count").getArgument().getNumber()).hasToString("-2.5"); + assertThat(dictionary.getOption("label").getArgument().getString().getValue()) + .isEqualTo("text"); + AlterTextSearchDictionary alter = (AlterTextSearchDictionary) parse( + "ALTER TEXT SEARCH DICTIONARY s.d (STOPWORDS, language = dutch)"); + assertThat(alter.getAction()).isEqualTo(AlterTextSearchDictionary.Action.OPTIONS); + assertThat(alter.getOption("STOPWORDS").getArgument()).isNull(); + assertThat(alter.getOption("language").getArgument().getDataType().getDataType()) + .isEqualTo("dutch"); + String unicode = "CREATE TEXT SEARCH DICTIONARY d (TEMPLATE = simple, label = U&'text')"; + assertThat(assertSqlCanBeParsedAndDeparsed(unicode, false, POSTGRESQL)) + .isInstanceOf(CreateTextSearchDictionary.class); + } + + @Test + void exposesParserAndTemplateFunctionDefinitionsWithoutTableLineage() throws Exception { + CreateTextSearchParser parser = (CreateTextSearchParser) parse( + "CREATE TEXT SEARCH PARSER p (LEXTYPES = s.l, END = s.e, GETTOKEN = s.g, START = s.s, HEADLINE = s.h)"); + assertThat(parser.getFunctions()).extracting(DefinitionElement::getName) + .containsExactly("LEXTYPES", "END", "GETTOKEN", "START", "HEADLINE"); + assertThat(parser.getStartFunction().getDataType().getDataType()).isEqualTo("s.s"); + assertThat(parser.getGetTokenFunction().getDataType().getDataType()).isEqualTo("s.g"); + assertThat(parser.getEndFunction().getDataType().getDataType()).isEqualTo("s.e"); + assertThat(parser.getLexTypesFunction().getDataType().getDataType()).isEqualTo("s.l"); + assertThat(parser.getHeadlineFunction().getDataType().getDataType()).isEqualTo("s.h"); + CreateTextSearchTemplate template = (CreateTextSearchTemplate) parse( + "CREATE TEXT SEARCH TEMPLATE t (\"lexize\" = pg_catalog.dsimple_lexize(1))"); + assertThat(template.getInitFunction()).isNull(); + assertThat(template.getLexizeFunction().getDataType().getDataType()) + .isEqualTo("pg_catalog.dsimple_lexize"); + assertThat(template.getLexizeFunction().getDataType().getArgumentsStringList()) + .containsExactly("1"); + template = (CreateTextSearchTemplate) parse( + "CREATE TEXT SEARCH TEMPLATE t (LEXIZE = 'dsimple_lexize')"); + assertThat(template.getLexizeFunction().getKind()) + .isEqualTo(DefinitionArgument.Kind.STRING); + assertThat(template.getLexizeFunction().getString().getValue()).isEqualTo("dsimple_lexize"); + assertThat(new TablesNamesFinder().getTables(parser)).isEmpty(); + assertThat(new TablesNamesFinder().getTables(template)).isEmpty(); + } + + @Test + void preservesDuplicateDefinitionsAndExposesTheLastValue() throws Exception { + String dictionarySql = + "CREATE TEXT SEARCH DICTIONARY d (TEMPLATE = simple, TEMPLATE = snowball, Language = english)"; + CreateTextSearchDictionary dictionary = + (CreateTextSearchDictionary) assertSqlCanBeParsedAndDeparsed(dictionarySql, false, + POSTGRESQL); + assertThat(dictionary.getOptions()).extracting(DefinitionElement::getName) + .containsExactly("TEMPLATE", "TEMPLATE", "Language"); + assertThat(dictionary.getTemplate().getDataType().getDataType()).isEqualTo("snowball"); + dictionary = (CreateTextSearchDictionary) parse( + "CREATE TEXT SEARCH DICTIONARY d (TEMPLATE = simple, \"Template\" = custom)"); + assertThat(dictionary.getTemplate().getDataType().getDataType()).isEqualTo("simple"); + assertThat(dictionary.getOption("\"Template\"").getArgument().getDataType().getDataType()) + .isEqualTo("custom"); + String templateSql = + "CREATE TEXT SEARCH TEMPLATE t (LEXIZE = dsimple_lexize, LEXIZE = dsynonym_lexize)"; + CreateTextSearchTemplate template = + (CreateTextSearchTemplate) assertSqlCanBeParsedAndDeparsed(templateSql, false, + POSTGRESQL); + assertThat(template.getFunctions()).hasSize(2); + assertThat(template.getLexizeFunction().getDataType().getDataType()) + .isEqualTo("dsynonym_lexize"); + String parserSql = + "CREATE TEXT SEARCH PARSER p (START = prsd_start, START = pg_catalog.prsd_start, GETTOKEN = prsd_nexttoken, END = prsd_end, LEXTYPES = prsd_lextype)"; + CreateTextSearchParser parser = + (CreateTextSearchParser) assertSqlCanBeParsedAndDeparsed(parserSql, false, + POSTGRESQL); + assertThat(parser.getFunctions()).hasSize(5); + assertThat(parser.getStartFunction().getDataType().getDataType()) + .isEqualTo("pg_catalog.prsd_start"); + AlterTextSearchDictionary alter = (AlterTextSearchDictionary) parse( + "ALTER TEXT SEARCH DICTIONARY d (STOPWORDS = english, STOPWORDS)"); + assertThat(alter.getOptions()).hasSize(2); + assertThat(alter.getOption("STOPWORDS").getArgument()).isNull(); + } + + @Test + void preservesStatementBoundariesAndContextualIdentifiers() throws Exception { + String sql = "CREATE LANGUAGE plsample HANDLER h; ALTER LANGUAGE plsample OWNER TO r; " + + "CREATE TEXT SEARCH TEMPLATE t (LEXIZE = f); ALTER TEXT SEARCH TEMPLATE t SET SCHEMA s; " + + "ALTER LARGE OBJECT 12345 OWNER TO r; SELECT language, trusted, procedural, dictionary, template, handler, validator, lexize FROM names"; + Statements statements = CCJSqlParserUtil.parseStatements(sql, POSTGRESQL); + assertThat(statements).hasSize(6); + assertThat(statements.get(0)).isInstanceOf(CreateLanguage.class); + assertThat(statements.get(1)).isInstanceOf(AlterLanguage.class); + assertThat(statements.get(2)).isInstanceOf(CreateTextSearchTemplate.class); + assertThat(statements.get(3)).isInstanceOf(AlterTextSearchTemplate.class); + assertThat(statements.get(4)).isInstanceOf(AlterLargeObject.class); + assertThat(statements.get(5).toString()).contains("language", "handler", "validator"); + assertThat(CCJSqlParserUtil.parse("CREATE LANGUAGE java EXTERNAL NAME 'jar'")) + .isInstanceOf(UnsupportedStatement.class); + assertThat(CCJSqlParserUtil.parse("ALTER LANGUAGE java COMPILE")) + .isInstanceOf(UnsupportedStatement.class); + } + + @Test + void numericOidReachesExpressionVisitorsDeparsersAndValidationWithItsRange() throws Exception { + AlterLargeObject statement = + (AlterLargeObject) parse("ALTER LARGE OBJECT 12345 OWNER TO r"); + LongValue oid = (LongValue) statement.getLargeObjectId(); + assertThat(oid.getASTNode().jjtGetFirstToken().image).isEqualTo("12345"); + assertThat(oid.getASTNode().jjtGetLastToken().image).isEqualTo("12345"); + List visited = new ArrayList<>(); + ExpressionVisitorAdapter expressions = new ExpressionVisitorAdapter() { + @Override + public Void visit(LongValue value, S context) { + assertThat(context).isEqualTo("context"); + visited.add(value); + return null; + } + }; + statement.accept(new StatementVisitorAdapter<>(new SelectVisitorAdapter<>(expressions)), + "context"); + assertThat(visited).containsExactly(oid); + StringBuilder output = new StringBuilder(); + ExpressionDeParser deparser = new ExpressionDeParser() { + @Override + public StringBuilder visit(LongValue value, S context) { + assertThat(context).isEqualTo("context"); + return getBuilder().append(value.getValue() + 1); + } + }; + statement.accept(new StatementDeParser(deparser, new SelectDeParser(), output), "context"); + assertThat(output).hasToString("ALTER LARGE OBJECT 12346 OWNER TO r"); + assertThat(statement).hasToString("ALTER LARGE OBJECT 12345 OWNER TO r"); + visited.clear(); + StatementValidator validator = new StatementValidator() { + @Override + protected void validateOptionalExpression(Expression value) { + visited.add(value); + super.validateOptionalExpression(value); + } + }; + validator.setContext( + new ValidationContext().setCapabilities(Arrays.asList(FeaturesAllowed.DDL))); + validator.validate(statement); + assertThat(visited).containsExactly(oid); + assertThat(validator.getValidationErrors()).isEmpty(); + } + + @ParameterizedTest + @MethodSource("metadataStatements") + void dispatchesTypedVisitorsWithContextAndLegacyOverloads(String sql, String statementClass) + throws Exception { + List visits = new ArrayList<>(); + StatementVisitorAdapter visitor = new StatementVisitorAdapter() { + private String record(Statement statement, S context) { + visits.add(statement.getClass().getSimpleName() + ":" + context); + return String.valueOf(context); + } + + @Override + public String visit(CreateLanguage statement, S context) { + return record(statement, context); + } + + @Override + public String visit(AlterLanguage statement, S context) { + return record(statement, context); + } + + @Override + public String visit(AlterLargeObject statement, S context) { + return record(statement, context); + } + + @Override + public String visit(CreateTextSearchDictionary statement, S context) { + return record(statement, context); + } + + @Override + public String visit(AlterTextSearchDictionary statement, S context) { + return record(statement, context); + } + + @Override + public String visit(CreateTextSearchParser statement, S context) { + return record(statement, context); + } + + @Override + public String visit(AlterTextSearchParser statement, S context) { + return record(statement, context); + } + + @Override + public String visit(CreateTextSearchTemplate statement, S context) { + return record(statement, context); + } + + @Override + public String visit(AlterTextSearchTemplate statement, S context) { + return record(statement, context); + } + + }; + Statement statement = parse(sql); + assertThat(statement.accept(visitor, "context")).isEqualTo("context"); + if (statement instanceof CreateLanguage) { + visitor.visit((CreateLanguage) statement); + } else if (statement instanceof AlterLanguage) { + visitor.visit((AlterLanguage) statement); + } else if (statement instanceof AlterLargeObject) { + visitor.visit((AlterLargeObject) statement); + } else if (statement instanceof CreateTextSearchDictionary) { + visitor.visit((CreateTextSearchDictionary) statement); + } else if (statement instanceof AlterTextSearchDictionary) { + visitor.visit((AlterTextSearchDictionary) statement); + } else if (statement instanceof CreateTextSearchParser) { + visitor.visit((CreateTextSearchParser) statement); + } else if (statement instanceof AlterTextSearchParser) { + visitor.visit((AlterTextSearchParser) statement); + } else if (statement instanceof CreateTextSearchTemplate) { + visitor.visit((CreateTextSearchTemplate) statement); + } else if (statement instanceof AlterTextSearchTemplate) { + visitor.visit((AlterTextSearchTemplate) statement); + } + assertThat(visits).containsExactly(statementClass + ":context", statementClass + ":null"); + } + + @Test + void buildersRenderTypedMetadataWithoutRawStatementParts() { + CreateLanguage language = new CreateLanguage().withName("l").withOrReplace(true) + .withTrusted(true).withProcedural(true).withHandler("s.h") + .withInlineHandler("s.i").withNoValidator(true); + assertThat(language).hasToString( + "CREATE OR REPLACE TRUSTED PROCEDURAL LANGUAGE l HANDLER s.h INLINE s.i NO VALIDATOR"); + assertThat(new AlterLanguage().withName("l").withProcedural(true) + .withAction(AlterLanguage.Action.RENAME).withNewName("m")) + .hasToString("ALTER PROCEDURAL LANGUAGE l RENAME TO m"); + assertThat(new AlterLargeObject().withLargeObjectId(new LongValue(12345)).withOwner("r")) + .hasToString("ALTER LARGE OBJECT 12345 OWNER TO r"); + DefinitionElement function = new DefinitionElement("LEXIZE", + DefinitionArgument.type(new ColDataType("s.f"))); + assertThat( + new CreateTextSearchTemplate().withName("t").withFunctions(Arrays.asList(function))) + .hasToString("CREATE TEXT SEARCH TEMPLATE t (LEXIZE = s.f)"); + assertThat(new CreateTextSearchDictionary().withName("d").withOptions(Arrays.asList( + new DefinitionElement("TEMPLATE", + DefinitionArgument.type(new ColDataType("simple")))))) + .hasToString("CREATE TEXT SEARCH DICTIONARY d (TEMPLATE = simple)"); + assertThat(new AlterTextSearchDictionary().withName("d") + .withAction(AlterTextSearchDictionary.Action.OPTIONS) + .withOptions(Arrays.asList(new DefinitionElement("STOPWORDS", null)))) + .hasToString("ALTER TEXT SEARCH DICTIONARY d (STOPWORDS)"); + assertThat(new AlterTextSearchParser().withName("p") + .withAction(AlterTextSearchParser.Action.RENAME).withNewName("q")) + .hasToString("ALTER TEXT SEARCH PARSER p RENAME TO q"); + assertThat(new AlterTextSearchTemplate().withName("t") + .withAction(AlterTextSearchTemplate.Action.SET_SCHEMA).withSchemaName("s")) + .hasToString("ALTER TEXT SEARCH TEMPLATE t SET SCHEMA s"); + } + + @ParameterizedTest + @ValueSource(strings = {"create language l handler h no validator", + "alter language l owner to r", "alter large object 12345 owner to r", + "create text search template t (lexize = f)"}) + void lowerCaseKeywordsNormalizeWithoutChangingNames(String sql) throws Exception { + Statement statement = parse(sql); + assertThat(statement).isNotInstanceOf(UnsupportedStatement.class); + assertThat(statement.toString()).isEqualToIgnoringCase(sql); + assertThat(parse(statement.toString())).hasToString(statement.toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/StatementValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/StatementValidatorTest.java index af8a06527..8d3f133ad 100644 --- a/src/test/java/net/sf/jsqlparser/util/validation/validator/StatementValidatorTest.java +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/StatementValidatorTest.java @@ -76,7 +76,7 @@ static Stream statementsOutsideSelect() { Arguments.of("ALTER EVENT e DISABLE", Feature.alterEvent), Arguments.of("CREATE TRIGGER trg BEFORE INSERT ON t FOR EACH ROW SELECT 1", Feature.createTrigger), - Arguments.of("CREATE LANGUAGE plperlu", Feature.allowUnsupportedStatements)); + Arguments.of("CREATE LANGUAGE plperlu", Feature.createLanguage)); } @ParameterizedTest