diff --git a/src/main/java/module-info.java b/src/main/java/module-info.java index 361504653..6765fe187 100644 --- a/src/main/java/module-info.java +++ b/src/main/java/module-info.java @@ -36,7 +36,9 @@ exports net.sf.jsqlparser.statement.delete; exports net.sf.jsqlparser.statement.drop; exports net.sf.jsqlparser.statement.execute; + exports net.sf.jsqlparser.statement.export; exports net.sf.jsqlparser.statement.grant; + exports net.sf.jsqlparser.statement.imprt; exports net.sf.jsqlparser.statement.insert; exports net.sf.jsqlparser.statement.merge; exports net.sf.jsqlparser.statement.piped; diff --git a/src/main/java/net/sf/jsqlparser/parser/ParserKeywordsUtils.java b/src/main/java/net/sf/jsqlparser/parser/ParserKeywordsUtils.java index 19e89ff18..bfaa4a647 100644 --- a/src/main/java/net/sf/jsqlparser/parser/ParserKeywordsUtils.java +++ b/src/main/java/net/sf/jsqlparser/parser/ParserKeywordsUtils.java @@ -56,6 +56,7 @@ public class ParserKeywordsUtils { {"CHECK", RESTRICTED_SQL2016}, {"CONNECT", RESTRICTED_ALIAS}, {"CONNECT_BY_ROOT", RESTRICTED_JSQLPARSER}, + {"CSV", RESTRICTED_JSQLPARSER}, {"PRIOR", RESTRICTED_JSQLPARSER}, {"CONSTRAINT", RESTRICTED_SQL2016}, {"CREATE", RESTRICTED_ALIAS}, @@ -66,12 +67,15 @@ public class ParserKeywordsUtils { {"DISTINCTROW", RESTRICTED_SQL2016}, {"DOUBLE", RESTRICTED_ALIAS}, {"ELSE", RESTRICTED_JSQLPARSER}, + {"ERRORS", RESTRICTED_JSQLPARSER}, {"EXCEPT", RESTRICTED_SQL2016}, {"EXCLUDES", RESTRICTED_JSQLPARSER}, {"EXISTS", RESTRICTED_SQL2016}, {"EXTEND", RESTRICTED_JSQLPARSER}, {"FALSE", RESTRICTED_SQL2016}, + {"FBV", RESTRICTED_JSQLPARSER}, {"FETCH", RESTRICTED_SQL2016}, + {"FILE", RESTRICTED_JSQLPARSER}, {"FINAL", RESTRICTED_JSQLPARSER}, {"FOR", RESTRICTED_SQL2016}, {"FORCE", RESTRICTED_SQL2016}, @@ -87,6 +91,7 @@ public class ParserKeywordsUtils { {"IIF", RESTRICTED_ALIAS}, {"IGNORE", RESTRICTED_ALIAS}, {"ILIKE", RESTRICTED_SQL2016}, + {"IMPORT", RESTRICTED_JSQLPARSER}, {"IN", RESTRICTED_SQL2016}, {"INCLUDES", RESTRICTED_JSQLPARSER}, {"INNER", RESTRICTED_SQL2016}, @@ -122,12 +127,14 @@ public class ParserKeywordsUtils { {"RETURNING", RESTRICTED_JSQLPARSER}, {"RIGHT", RESTRICTED_SQL2016}, {"SAMPLE", RESTRICTED_ALIAS}, + {"SCRIPT", RESTRICTED_JSQLPARSER}, {"SEL", RESTRICTED_ALIAS}, {"SELECT", RESTRICTED_ALIAS}, {"SEMI", RESTRICTED_JSQLPARSER}, {"SET", RESTRICTED_JSQLPARSER}, {"SOME", RESTRICTED_JSQLPARSER}, {"START", RESTRICTED_JSQLPARSER}, + {"STATEMENT", RESTRICTED_JSQLPARSER}, {"TABLES", RESTRICTED_ALIAS}, {"TOP", RESTRICTED_SQL2016}, {"TRAILING", RESTRICTED_SQL2016}, @@ -147,6 +154,7 @@ public class ParserKeywordsUtils { {"VALUE", RESTRICTED_JSQLPARSER}, {"VALUES", RESTRICTED_SQL2016}, {"VARYING", RESTRICTED_JSQLPARSER}, + {"VERIFY", RESTRICTED_JSQLPARSER}, {"WHEN", RESTRICTED_SQL2016}, {"WHERE", RESTRICTED_SQL2016}, {"WINDOW", RESTRICTED_SQL2016}, 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 aed784cab..7f4cf2af0 100644 --- a/src/main/java/net/sf/jsqlparser/parser/feature/Feature.java +++ b/src/main/java/net/sf/jsqlparser/parser/feature/Feature.java @@ -798,7 +798,18 @@ public enum Feature { */ allowedNestingDepth(10), - dialect(null); + dialect(null), + + /** + * "IMPORT" + */ + imprt, + + /** + * "EXPORT" + */ + export, + ; private final Object value; private final boolean configurable; diff --git a/src/main/java/net/sf/jsqlparser/schema/Table.java b/src/main/java/net/sf/jsqlparser/schema/Table.java index a2011600d..fbf3fc63f 100644 --- a/src/main/java/net/sf/jsqlparser/schema/Table.java +++ b/src/main/java/net/sf/jsqlparser/schema/Table.java @@ -17,6 +17,7 @@ import net.sf.jsqlparser.expression.MySQLIndexHint; import net.sf.jsqlparser.expression.SQLServerHints; import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.ErrorDestination; import net.sf.jsqlparser.statement.select.FromItem; import net.sf.jsqlparser.statement.select.FromItemVisitor; import net.sf.jsqlparser.statement.select.IntoTableVisitor; @@ -27,7 +28,7 @@ /** * A table. It can have an alias and the schema name it belongs to. */ -public class Table extends ASTNodeAccessImpl implements FromItem, MultiPartName { +public class Table extends ASTNodeAccessImpl implements ErrorDestination, FromItem, MultiPartName { // private Database database; // private String schemaName; diff --git a/src/main/java/net/sf/jsqlparser/statement/CSVColumn.java b/src/main/java/net/sf/jsqlparser/statement/CSVColumn.java new file mode 100644 index 000000000..08c7f4d1d --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/CSVColumn.java @@ -0,0 +1,91 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2022 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement; + +import net.sf.jsqlparser.expression.StringValue; + +public class CSVColumn { + private Long startIndex; + private Long endIndex; + private StringValue format; + private String delimit; + + public CSVColumn(Long startIndex, Long endIndex) { + this.startIndex = startIndex; + this.endIndex = endIndex; + } + + public CSVColumn(Long index) { + this(index, null); + } + + public Long getStartIndex() { + return startIndex; + } + + public void setStartIndex(Long startIndex) { + this.startIndex = startIndex; + } + + public Long getIndex() { + return getStartIndex(); + } + + public void setIndex(Long index) { + setStartIndex(index); + } + + public Long getEndIndex() { + return endIndex; + } + + public void setEndIndex(Long endIndex) { + this.endIndex = endIndex; + } + + public StringValue getFormat() { + return format; + } + + public void setFormat(StringValue format) { + this.format = format; + } + + public String getDelimit() { + return delimit; + } + + public void setDelimit(String delimit) { + this.delimit = delimit; + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + + sql.append(startIndex); + if (endIndex != null) { + sql.append(" .. "); + sql.append(endIndex); + } else if (format != null || delimit != null) { + if (format != null) { + sql.append(" FORMAT = "); + sql.append(format); + } + + if (delimit != null) { + sql.append(" DELIMIT = "); + sql.append(delimit); + } + } + + return sql.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/CSVFileDestination.java b/src/main/java/net/sf/jsqlparser/statement/CSVFileDestination.java new file mode 100644 index 000000000..697368f83 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/CSVFileDestination.java @@ -0,0 +1,75 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2022 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement; + +import net.sf.jsqlparser.expression.StringValue; + +public class CSVFileDestination implements ErrorDestination { + private ConnectionDefinition connectionDefinition; + private boolean local; + private boolean secure; + private StringValue file; + + public ConnectionDefinition getConnectionDefinition() { + return connectionDefinition; + } + + public void setConnectionDefinition(ConnectionDefinition connectionDefinition) { + this.connectionDefinition = connectionDefinition; + } + + public boolean isLocal() { + return local; + } + + public void setLocal(boolean local) { + this.local = local; + } + + public boolean isSecure() { + return secure; + } + + public void setSecure(boolean secure) { + this.secure = secure; + } + + public StringValue getFile() { + return file; + } + + public void setFile(StringValue file) { + this.file = file; + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + + if (local) { + sql.append("LOCAL "); + if (secure) { + sql.append("SECURE "); + } + } + + sql.append("CSV"); + + if (connectionDefinition != null) { + sql.append(" "); + sql.append(connectionDefinition); + } + + sql.append(" FILE "); + sql.append(file); + + return sql.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/CertificateVerification.java b/src/main/java/net/sf/jsqlparser/statement/CertificateVerification.java new file mode 100644 index 000000000..7aabbb060 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/CertificateVerification.java @@ -0,0 +1,67 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2025 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement; + +import net.sf.jsqlparser.expression.StringValue; + +import java.io.Serializable; + +public class CertificateVerification implements Serializable { + private Boolean ignoreCertificate; + private StringValue publicKey; + + public StringValue getPublicKey() { + return publicKey; + } + + public void setPublicKey(StringValue publicKey) { + this.publicKey = publicKey; + } + + public Boolean getIgnoreCertificate() { + return ignoreCertificate; + } + + public void setIgnoreCertificate(Boolean ignoreCertificate) { + this.ignoreCertificate = ignoreCertificate; + } + + public Boolean getVerifyCertificate() { + return !ignoreCertificate; + } + + public void setVerifyCertificate(Boolean verifyCertificate) { + this.ignoreCertificate = !verifyCertificate; + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + + if (ignoreCertificate != null) { + if (ignoreCertificate) { + sql.append("IGNORE "); + } else { + sql.append("VERIFY "); + } + sql.append("CERTIFICATE"); + } + + if (publicKey != null) { + if (ignoreCertificate != null) { + sql.append(" "); + } + sql.append("PUBLIC KEY "); + sql.append(publicKey); + } + + return sql.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/CloudConnectionDefinition.java b/src/main/java/net/sf/jsqlparser/statement/CloudConnectionDefinition.java new file mode 100644 index 000000000..82b65fbd7 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/CloudConnectionDefinition.java @@ -0,0 +1,37 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2022 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement; + +public class CloudConnectionDefinition extends ConnectionDefinition { + private String storage; + + public String getStorage() { + return storage; + } + + public void setStorage(String storage) { + this.storage = storage; + } + + @Override + public void setCertificateVerification(CertificateVerification certificateVerification) {} + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + + sql.append("AT CLOUD "); + sql.append(storage); + sql.append(" "); + appendConnectionDefinition(sql); + + return sql.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/ConnectionDefinition.java b/src/main/java/net/sf/jsqlparser/statement/ConnectionDefinition.java new file mode 100644 index 000000000..f2887cf82 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/ConnectionDefinition.java @@ -0,0 +1,91 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2022 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement; + +import net.sf.jsqlparser.expression.StringValue; + +import java.io.Serializable; + +public class ConnectionDefinition implements Serializable { + private String connectionObjectName; + private StringValue connectionDefinition; + private UserIdentification userIdentification; + private CertificateVerification certificateVerification; + + public String getConnectionObjectName() { + return connectionObjectName; + } + + public void setConnectionObjectName(String connectionObjectName) { + this.connectionObjectName = connectionObjectName; + } + + public StringValue getConnectionDefinition() { + return connectionDefinition; + } + + public void setConnectionDefinition(StringValue connectionDefinition) { + this.connectionDefinition = connectionDefinition; + } + + public void setConnection(String connectionObjectName) { + this.connectionObjectName = connectionObjectName; + } + + public void setConnection(StringValue connectionDefinition) { + this.connectionDefinition = connectionDefinition; + } + + public UserIdentification getUserIdentification() { + return userIdentification; + } + + public void setUserIdentification(UserIdentification userIdentification) { + this.userIdentification = userIdentification; + } + + public CertificateVerification getCertificateVerification() { + return certificateVerification; + } + + public void setCertificateVerification(CertificateVerification certificateVerification) { + this.certificateVerification = certificateVerification; + } + + protected StringBuilder appendConnectionDefinition(StringBuilder sql) { + if (connectionObjectName != null) { + sql.append(connectionObjectName); + } else if (connectionDefinition != null) { + sql.append(connectionDefinition); + } + + if (userIdentification != null) { + sql.append(" "); + sql.append(userIdentification); + } + + if (certificateVerification != null) { + sql.append(" "); + sql.append(certificateVerification); + } + + return sql; + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + + sql.append("AT "); + appendConnectionDefinition(sql); + + return sql.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/ConnectionFileDefinition.java b/src/main/java/net/sf/jsqlparser/statement/ConnectionFileDefinition.java new file mode 100644 index 000000000..f0e0d0cf1 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/ConnectionFileDefinition.java @@ -0,0 +1,60 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2022 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement; + +import net.sf.jsqlparser.expression.StringValue; + +import java.util.List; + +public class ConnectionFileDefinition { + private ConnectionDefinition connectionDefinition; + private List filePaths; + + public ConnectionFileDefinition(List filePaths) { + this(null, filePaths); + } + + public ConnectionFileDefinition(ConnectionDefinition connectionDefinition, + List filePaths) { + this.connectionDefinition = connectionDefinition; + this.filePaths = filePaths; + } + + public ConnectionDefinition getConnectionDefinition() { + return connectionDefinition; + } + + public void setConnectionDefinition(ConnectionDefinition connectionDefinition) { + this.connectionDefinition = connectionDefinition; + } + + public List getFilePaths() { + return filePaths; + } + + public void setFilePaths(List filePaths) { + this.filePaths = filePaths; + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + + if (connectionDefinition != null) { + sql.append(connectionDefinition); + } + + for (StringValue filePath : filePaths) { + sql.append(" FILE ").append(filePath); + } + + return sql.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/DBMSType.java b/src/main/java/net/sf/jsqlparser/statement/DBMSType.java new file mode 100644 index 000000000..4b3d667da --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/DBMSType.java @@ -0,0 +1,52 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2019 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement; + +import net.sf.jsqlparser.expression.StringValue; + +public class DBMSType implements SourceDestinationType { + private final Kind dbmsType; + private StringValue jdbcDriverDefinition; + + public DBMSType(String dbmsType) { + this(dbmsType, null); + } + + public DBMSType(String dbmsType, String jdbcDriverDefinition) { + this.dbmsType = Kind.valueOf(dbmsType.toUpperCase()); + if (jdbcDriverDefinition != null) { + this.jdbcDriverDefinition = new StringValue(jdbcDriverDefinition); + } + } + + private enum Kind { + EXA, ORA, JDBC + } + + public StringValue getJDBCDriverDefinition() { + return jdbcDriverDefinition; + } + + public void setJDBCDriverDefinition(StringValue jdbcDriverDefinition) { + this.jdbcDriverDefinition = jdbcDriverDefinition; + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + + sql.append(dbmsType); + if (jdbcDriverDefinition != null) { + sql.append(" DRIVER = ").append(jdbcDriverDefinition); + } + + return sql.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/ErrorClause.java b/src/main/java/net/sf/jsqlparser/statement/ErrorClause.java new file mode 100644 index 000000000..92db1a3dc --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/ErrorClause.java @@ -0,0 +1,90 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2022 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement; + +import net.sf.jsqlparser.expression.Expression; + +import java.io.Serializable; + +public class ErrorClause implements Serializable { + private ErrorDestination errorDestination; + private Expression expression; + private RejectClause rejectClause; + private boolean replace; + private boolean truncate; + + public ErrorDestination getErrorDestination() { + return errorDestination; + } + + public void setErrorDestination(ErrorDestination errorDestination) { + this.errorDestination = errorDestination; + } + + public Expression getExpression() { + return expression; + } + + public void setExpression(Expression expression) { + this.expression = expression; + } + + public RejectClause getRejectClause() { + return rejectClause; + } + + public void setRejectClause(RejectClause rejectClause) { + this.rejectClause = rejectClause; + } + + public boolean isReplace() { + return replace; + } + + public void setReplace(boolean replace) { + this.replace = replace; + } + + public boolean isTruncate() { + return truncate; + } + + public void setTruncate(boolean truncate) { + this.truncate = truncate; + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + + if (errorDestination != null) { + sql.append("ERRORS INTO "); + sql.append(errorDestination); + if (expression != null) { + sql.append(" ("); + sql.append(expression); + sql.append(")"); + } + + if (replace) { + sql.append(" REPLACE"); + } else if (truncate) { + sql.append(" TRUNCATE"); + } + } + + if (rejectClause != null) { + sql.append(" "); + sql.append(rejectClause); + } + + return sql.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/ErrorDestination.java b/src/main/java/net/sf/jsqlparser/statement/ErrorDestination.java new file mode 100644 index 000000000..258a39ebb --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/ErrorDestination.java @@ -0,0 +1,13 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2022 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement; + +public interface ErrorDestination { +} diff --git a/src/main/java/net/sf/jsqlparser/statement/FBVColumn.java b/src/main/java/net/sf/jsqlparser/statement/FBVColumn.java new file mode 100644 index 000000000..a1846efd9 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/FBVColumn.java @@ -0,0 +1,98 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2022 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement; + +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.StringValue; + +public class FBVColumn { + private boolean precedesComma; + private String key; + private Expression value; + private String stringValue; + + private FBVColumn(String key, Expression value) { + this.key = key; + this.value = value; + this.stringValue = null; + } + + public FBVColumn(String key, String value) { + this.key = key; + this.value = null; + this.stringValue = value; + } + + public FBVColumn(String key, StringValue value) { + this(key, (Expression) value); + } + + public FBVColumn(String key, LongValue value) { + this(key, (Expression) value); + } + + public boolean precedesComma() { + return precedesComma; + } + + public void setPrecedesComma(boolean precedesComma) { + this.precedesComma = precedesComma; + } + + public String getKey() { + return key; + } + + public void setKey(String key) { + this.key = key; + } + + public Expression getValue() { + return value; + } + + public void setValue(String value) { + this.stringValue = value; + this.value = null; + } + + private void setValue(Expression value) { + this.value = value; + this.stringValue = null; + } + + public void setValue(StringValue value) { + setValue((Expression) value); + } + + public void setValue(LongValue value) { + setValue((Expression) value); + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + + if (precedesComma) { + sql.append(", "); + } + + sql.append(key); + sql.append(" = "); + if (stringValue != null) { + sql.append(stringValue); + } else { + sql.append(value); + } + + return sql.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/FileOption.java b/src/main/java/net/sf/jsqlparser/statement/FileOption.java new file mode 100644 index 000000000..ff91f571b --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/FileOption.java @@ -0,0 +1,85 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2022 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement; + +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.StringValue; + +public class FileOption { + private String key; + private Expression value; + private String stringValue; + + private FileOption(String key, Expression value) { + this.key = key; + this.value = value; + this.stringValue = null; + } + + public FileOption(String key, String value) { + this.key = key; + this.value = null; + this.stringValue = value; + } + + public FileOption(String key) { + this(key, (Expression) null); + } + + public FileOption(String key, StringValue value) { + this(key, (Expression) value); + } + + public FileOption(String key, LongValue value) { + this(key, (Expression) value); + } + + public String getKey() { + return key; + } + + public void setKey(String key) { + this.key = key; + } + + public Expression getValue() { + return value; + } + + public void setValue(StringValue value) { + this.value = value; + } + + public void setValue(LongValue value) { + this.value = value; + } + + public void setValue(String value) { + this.stringValue = value; + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + + sql.append(key); + if (value != null || stringValue != null) { + sql.append(" = "); + if (stringValue != null) { + sql.append(stringValue); + } else { + sql.append(value); + } + } + + return sql.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/FileSourceDestination.java b/src/main/java/net/sf/jsqlparser/statement/FileSourceDestination.java new file mode 100644 index 000000000..d5a79ed8f --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/FileSourceDestination.java @@ -0,0 +1,133 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2019 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement; + +import net.sf.jsqlparser.statement.select.PlainSelect; + +import java.io.Serializable; +import java.util.List; +import java.util.Objects; + +public abstract class FileSourceDestination implements Serializable { + private SourceDestinationType type; + private List connectionFileDefinitions; + private Boolean local; + private Boolean secure; + private List csvColumns; + private List fbvColumns; + private List fileOptions; + private CertificateVerification certificateVerification; + + protected SourceDestinationType getType() { + return type; + } + + protected void setType(SourceDestinationType type) { + this.type = type; + } + + public List getConnectionFileDefinitions() { + return connectionFileDefinitions; + } + + public void setConnectionFileDefinitions( + List connectionFileDefinitions) { + this.connectionFileDefinitions = connectionFileDefinitions; + } + + public Boolean isLocal() { + return local; + } + + public void setLocal(Boolean local) { + this.local = local; + } + + public Boolean isSecure() { + return secure; + } + + public void setSecure(Boolean secure) { + this.secure = secure; + } + + public List getCSVColumns() { + return csvColumns; + } + + public void setCSVColumns(List csvColumns) { + this.csvColumns = csvColumns; + } + + public List getFBVColumns() { + return fbvColumns; + } + + public void setFBVColumns(List fbvColumns) { + this.fbvColumns = fbvColumns; + } + + public List getFileOptions() { + return fileOptions; + } + + public void setFileOptions(List fileOptions) { + this.fileOptions = fileOptions; + } + + public CertificateVerification getCertificateVerification() { + return certificateVerification; + } + + public void setCertificateVerification(CertificateVerification certificateVerification) { + this.certificateVerification = certificateVerification; + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + + if (local != null) { + if (local) { + sql.append("LOCAL "); + } + + if (Objects.requireNonNullElse(secure, false)) { + sql.append("SECURE "); + } + } + + sql.append(type); + if (connectionFileDefinitions != null) { + sql.append(" "); + PlainSelect.appendStringListTo(sql, connectionFileDefinitions, false, false); + } + + if (csvColumns != null) { + sql.append(" "); + PlainSelect.appendStringListTo(sql, csvColumns, true, true); + } else if (fbvColumns != null) { + sql.append(" "); + PlainSelect.appendStringListTo(sql, fbvColumns, false, true); + } + + if (fileOptions != null) { + sql.append(" "); + PlainSelect.appendStringListTo(sql, fileOptions, false, false); + } + + if (certificateVerification != null) { + sql.append(" "); + sql.append(certificateVerification); + } + + return sql.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/FileType.java b/src/main/java/net/sf/jsqlparser/statement/FileType.java new file mode 100644 index 000000000..7ea1535f9 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/FileType.java @@ -0,0 +1,27 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2025 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement; + +public class FileType implements SourceDestinationType { + private final Kind fileType; + + public FileType(String fileType) { + this.fileType = Kind.valueOf(fileType.toUpperCase()); + } + + private enum Kind { + CSV, FBV + } + + @Override + public String toString() { + return fileType.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/LikeClause.java b/src/main/java/net/sf/jsqlparser/statement/LikeClause.java new file mode 100644 index 000000000..448b4de72 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/LikeClause.java @@ -0,0 +1,142 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2022 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement; + +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.imprt.ImportColumn; +import net.sf.jsqlparser.statement.select.PlainSelect; +import net.sf.jsqlparser.statement.select.SelectItem; + +import java.io.Serializable; +import java.util.List; + +/** + * Exasol Like Clause + * + * @see Like Clause in CREATE + * TABLE + * @see Like Clause in IMPORT + */ +public class LikeClause implements ImportColumn, Serializable { + private Table table; + private List> columnsList; + + private Boolean includingDefaults; + private Boolean includingIdentity; + private Boolean includingComments; + + public Table getTable() { + return table; + } + + public void setTable(Table table) { + this.table = table; + } + + public List> getColumnsList() { + return columnsList; + } + + public void setColumnsList(List> columnsList) { + this.columnsList = columnsList; + } + + public Boolean isIncludingDefaults() { + return includingDefaults; + } + + public void setIncludingDefaults(Boolean includingDefaults) { + this.includingDefaults = includingDefaults; + } + + public Boolean isExcludingDefaults() { + return includingDefaults == null ? null : !includingDefaults; + } + + public void setExcludingDefaults(Boolean excludingDefaults) { + this.includingDefaults = !excludingDefaults; + } + + public Boolean isIncludingIdentity() { + return includingIdentity; + } + + public void setIncludingIdentity(Boolean includingIdentity) { + this.includingIdentity = includingIdentity; + } + + public Boolean isExcludingIdentity() { + return includingIdentity == null ? null : !includingIdentity; + } + + public void setExcludingIdentity(Boolean excludingIdentity) { + this.includingIdentity = !excludingIdentity; + } + + public Boolean isIncludingComments() { + return includingComments; + } + + public void setIncludingComments(Boolean includingComments) { + this.includingComments = includingComments; + } + + public Boolean isExcludingComments() { + return includingComments == null ? null : !includingComments; + } + + public void setExcludingComments(Boolean excludingComments) { + this.includingComments = !excludingComments; + } + + public StringBuilder appendTo(StringBuilder builder) { + builder.append(" LIKE "); + builder.append(table); + if (columnsList != null) { + builder.append(" "); + PlainSelect.appendStringListTo(builder, columnsList, true, true); + } + + if (includingDefaults != null) { + if (includingDefaults) { + builder.append(" INCLUDING "); + } else { + builder.append(" EXCLUDING "); + } + builder.append(" DEFAULTS "); + } + + if (includingIdentity != null) { + if (includingIdentity) { + builder.append(" INCLUDING "); + } else { + builder.append(" EXCLUDING "); + } + builder.append(" IDENTITY "); + } + + if (includingComments != null) { + if (includingComments) { + builder.append(" INCLUDING "); + } else { + builder.append(" EXCLUDING "); + } + builder.append(" COMMENTS "); + } + + return builder; + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/RejectClause.java b/src/main/java/net/sf/jsqlparser/statement/RejectClause.java new file mode 100644 index 000000000..5ca9f9714 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/RejectClause.java @@ -0,0 +1,53 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2022 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement; + +import net.sf.jsqlparser.expression.LongValue; + +import java.io.Serializable; + +public class RejectClause implements Serializable { + private LongValue limit; + private boolean errors; + + public LongValue getLimit() { + return limit; + } + + public void setLimit(LongValue limit) { + this.limit = limit; + } + + public boolean isErrors() { + return errors; + } + + public void setErrors(boolean errors) { + this.errors = errors; + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + + sql.append("REJECT LIMIT "); + if (limit != null) { + sql.append(limit); + } else { + sql.append("UNLIMITED"); + } + + if (errors) { + sql.append(" ERRORS"); + } + + return sql.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/ScriptSourceDestination.java b/src/main/java/net/sf/jsqlparser/statement/ScriptSourceDestination.java new file mode 100644 index 000000000..c1193b037 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/ScriptSourceDestination.java @@ -0,0 +1,99 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2019 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement; + +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.export.ExportIntoItem; +import net.sf.jsqlparser.statement.imprt.ImportFromItem; + +import java.io.Serializable; +import java.util.List; + +public class ScriptSourceDestination implements ImportFromItem, ExportIntoItem, Serializable { + private Table script; + private ConnectionDefinition connectionDefinition; + private List properties; + private List values; + private ErrorClause errorClause; + + public Table getScript() { + return script; + } + + public void setScript(Table script) { + this.script = script; + } + + public ConnectionDefinition getConnectionDefinition() { + return connectionDefinition; + } + + public void setConnectionDefinition(ConnectionDefinition connectionDefinition) { + this.connectionDefinition = connectionDefinition; + } + + public List getProperties() { + return properties; + } + + public void setProperties(List properties) { + this.properties = properties; + } + + public List getValues() { + return values; + } + + public void setValues(List values) { + this.values = values; + } + + @Override + public ErrorClause getErrorClause() { + return errorClause; + } + + @Override + public void setErrorClause(ErrorClause errorClause) { + this.errorClause = errorClause; + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + + sql.append("SCRIPT "); + sql.append(script); + + if (connectionDefinition != null) { + sql.append(" "); + sql.append(connectionDefinition); + } + + if (properties != null && values != null) { + sql.append(" WITH"); + + int max = Math.min(properties.size(), values.size()); + for (int i = 0; i < max; i++) { + sql.append(" "); + sql.append(properties.get(i)); + sql.append(" = "); + sql.append(values.get(i)); + } + } + + if (errorClause != null) { + sql.append(errorClause); + } + + return sql.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/SourceDestinationType.java b/src/main/java/net/sf/jsqlparser/statement/SourceDestinationType.java new file mode 100644 index 000000000..743d21378 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/SourceDestinationType.java @@ -0,0 +1,13 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2019 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement; + +public interface SourceDestinationType { +} diff --git a/src/main/java/net/sf/jsqlparser/statement/StatementVisitor.java b/src/main/java/net/sf/jsqlparser/statement/StatementVisitor.java index dc35ea516..0068e0cf6 100644 --- a/src/main/java/net/sf/jsqlparser/statement/StatementVisitor.java +++ b/src/main/java/net/sf/jsqlparser/statement/StatementVisitor.java @@ -27,7 +27,9 @@ import net.sf.jsqlparser.statement.delete.ParenthesedDelete; import net.sf.jsqlparser.statement.drop.Drop; import net.sf.jsqlparser.statement.execute.Execute; +import net.sf.jsqlparser.statement.export.Export; import net.sf.jsqlparser.statement.grant.Grant; +import net.sf.jsqlparser.statement.imprt.Import; import net.sf.jsqlparser.statement.insert.Insert; import net.sf.jsqlparser.statement.insert.ParenthesedInsert; import net.sf.jsqlparser.statement.merge.Merge; @@ -329,4 +331,16 @@ default void visit(ParenthesedDelete parenthesedDelete) { default void visit(SessionStatement sessionStatement) { this.visit(sessionStatement, null); } + + T visit(Import imprt, S context); + + default void visit(Import imprt) { + this.visit(imprt, null); + } + + T visit(Export export, S context); + + default void visit(Export export) { + this.visit(export, null); + } } diff --git a/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java b/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java index 4880ed988..f7dbd477f 100644 --- a/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java +++ b/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java @@ -27,7 +27,9 @@ import net.sf.jsqlparser.statement.delete.ParenthesedDelete; import net.sf.jsqlparser.statement.drop.Drop; import net.sf.jsqlparser.statement.execute.Execute; +import net.sf.jsqlparser.statement.export.Export; import net.sf.jsqlparser.statement.grant.Grant; +import net.sf.jsqlparser.statement.imprt.Import; import net.sf.jsqlparser.statement.insert.Insert; import net.sf.jsqlparser.statement.insert.ParenthesedInsert; import net.sf.jsqlparser.statement.merge.Merge; @@ -313,4 +315,14 @@ public T visit(UnsupportedStatement unsupportedStatement, S context) { public T visit(RefreshMaterializedViewStatement materializedView, S context) { return null; } + + @Override + public T visit(Import imprt, S context) { + return null; + } + + @Override + public T visit(Export export, S context) { + return null; + } } diff --git a/src/main/java/net/sf/jsqlparser/statement/UserIdentification.java b/src/main/java/net/sf/jsqlparser/statement/UserIdentification.java new file mode 100644 index 000000000..d951931d9 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/UserIdentification.java @@ -0,0 +1,48 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2022 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement; + +import net.sf.jsqlparser.expression.StringValue; + +import java.io.Serializable; + +public class UserIdentification implements Serializable { + private StringValue user; + private StringValue password; + + public StringValue getUser() { + return user; + } + + public void setUser(StringValue user) { + this.user = user; + } + + public StringValue getPassword() { + return password; + } + + public void setPassword(StringValue password) { + this.password = password; + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + + sql.append("USER "); + sql.append(user); + + sql.append(" IDENTIFIED BY "); + sql.append(password); + + return sql.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/table/ColumnDefinition.java b/src/main/java/net/sf/jsqlparser/statement/create/table/ColumnDefinition.java index 90a0e0e40..a7f47104c 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/table/ColumnDefinition.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/table/ColumnDefinition.java @@ -9,6 +9,7 @@ */ package net.sf.jsqlparser.statement.create.table; +import net.sf.jsqlparser.statement.imprt.ImportColumn; import net.sf.jsqlparser.statement.select.PlainSelect; import java.io.Serializable; @@ -21,7 +22,7 @@ /** * Globally used definition class for columns. */ -public class ColumnDefinition implements Serializable { +public class ColumnDefinition implements ImportColumn, Serializable { private String columnName; private ColDataType colDataType; diff --git a/src/main/java/net/sf/jsqlparser/statement/export/DBMSDestination.java b/src/main/java/net/sf/jsqlparser/statement/export/DBMSDestination.java new file mode 100644 index 000000000..38774023a --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/export/DBMSDestination.java @@ -0,0 +1,118 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2019 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.export; + +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.ConnectionDefinition; +import net.sf.jsqlparser.statement.ErrorClause; +import net.sf.jsqlparser.statement.SourceDestinationType; +import net.sf.jsqlparser.statement.select.PlainSelect; + +import java.io.Serializable; +import java.util.List; + +public class DBMSDestination implements ExportIntoItem, Serializable { + private SourceDestinationType destinationType; + private ConnectionDefinition connectionDefinition; + private Table table; + private ExpressionList columns; + private List dbmsTableDestinationOptions; + private StringValue statement; + private ErrorClause errorClause; + + public SourceDestinationType getDestinationType() { + return destinationType; + } + + public void setDestinationType(SourceDestinationType destinationType) { + this.destinationType = destinationType; + } + + public ConnectionDefinition getConnectionDefinition() { + return connectionDefinition; + } + + public void setConnectionDefinition(ConnectionDefinition connectionDefinition) { + this.connectionDefinition = connectionDefinition; + } + + public Table getTable() { + return table; + } + + public void setTable(Table table) { + this.table = table; + } + + public ExpressionList getColumns() { + return columns; + } + + public void setColumns(ExpressionList columns) { + this.columns = columns; + } + + public List getDBMSTableDestinationOptions() { + return dbmsTableDestinationOptions; + } + + public void setDBMSTableDestinationOptions( + List dbmsTableDestinationOptions) { + this.dbmsTableDestinationOptions = dbmsTableDestinationOptions; + } + + public StringValue getStatement() { + return statement; + } + + public void setStatement(StringValue statement) { + this.statement = statement; + } + + @Override + public ErrorClause getErrorClause() { + return errorClause; + } + + @Override + public void setErrorClause(ErrorClause errorClause) { + this.errorClause = errorClause; + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + + sql.append(destinationType); + + sql.append(" "); + sql.append(connectionDefinition); + + if (table != null) { + sql.append(" TABLE ").append(table); + PlainSelect.appendStringListTo(sql, columns, true, true); + if (dbmsTableDestinationOptions != null) { + sql.append(" "); + PlainSelect.appendStringListTo(sql, dbmsTableDestinationOptions, false, false); + } + } else if (statement != null) { + sql.append(" STATEMENT ").append(statement); + } + + if (errorClause != null) { + sql.append(errorClause); + } + + return sql.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/export/DBMSTableDestinationOption.java b/src/main/java/net/sf/jsqlparser/statement/export/DBMSTableDestinationOption.java new file mode 100644 index 000000000..904acea95 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/export/DBMSTableDestinationOption.java @@ -0,0 +1,67 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2022 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.export; + +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.StringValue; + +import java.io.Serializable; + +public class DBMSTableDestinationOption implements Serializable { + private String key; + private Expression value; + + private DBMSTableDestinationOption(String key, Expression value) { + this.key = key; + this.value = value; + } + + public DBMSTableDestinationOption(String key) { + this(key, (Expression) null); + } + + public DBMSTableDestinationOption(String key, StringValue value) { + this(key, (Expression) value); + } + + public String getKey() { + return key; + } + + public void setKey(String key) { + this.key = key; + } + + public Expression getValue() { + return value; + } + + public void setValue(StringValue value) { + this.value = value; + } + + public void setValue(LongValue value) { + this.value = value; + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + + sql.append(key); + if (value != null) { + sql.append(" "); + sql.append(value); + } + + return sql.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/export/Export.java b/src/main/java/net/sf/jsqlparser/statement/export/Export.java new file mode 100644 index 000000000..dd6628a20 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/export/Export.java @@ -0,0 +1,81 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2019 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.export; + +import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; +import net.sf.jsqlparser.statement.select.*; + +public class Export implements Statement { + private Table table; + private ExpressionList columns; + private Select select; + private ExportIntoItem exportIntoItem; + + public Table getTable() { + return table; + } + + public void setTable(Table table) { + this.table = table; + } + + public ExpressionList getColumns() { + return columns; + } + + public void setColumns(ExpressionList columns) { + this.columns = columns; + } + + public Select getSelect() { + return select; + } + + public void setSelect(Select select) { + this.select = select; + } + + public ExportIntoItem getExportIntoItem() { + return exportIntoItem; + } + + public void setExportIntoItem(ExportIntoItem exportIntoItem) { + this.exportIntoItem = exportIntoItem; + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + sql.append("EXPORT "); + if (table != null || select != null) { + if (table != null) { + sql.append(table); + PlainSelect.appendStringListTo(sql, columns, true, true); + } else { + sql.append(select); + } + sql.append(" "); + } + + sql.append("INTO "); + sql.append(exportIntoItem); + + return sql.toString(); + } + + @Override + public T accept(StatementVisitor statementVisitor, S context) { + return statementVisitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/export/ExportIntoItem.java b/src/main/java/net/sf/jsqlparser/statement/export/ExportIntoItem.java new file mode 100644 index 000000000..4558b67e9 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/export/ExportIntoItem.java @@ -0,0 +1,18 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2019 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.export; + +import net.sf.jsqlparser.statement.ErrorClause; + +public interface ExportIntoItem { + ErrorClause getErrorClause(); + + void setErrorClause(ErrorClause errorClause); +} diff --git a/src/main/java/net/sf/jsqlparser/statement/export/FileDestination.java b/src/main/java/net/sf/jsqlparser/statement/export/FileDestination.java new file mode 100644 index 000000000..6ff364075 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/export/FileDestination.java @@ -0,0 +1,50 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2019 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.export; + +import net.sf.jsqlparser.statement.*; + +import java.io.Serializable; + +public class FileDestination extends FileSourceDestination implements ExportIntoItem, Serializable { + private ErrorClause errorClause; + + public SourceDestinationType getDestinationType() { + return getType(); + } + + public void setDestinationType(SourceDestinationType destinationType) { + setType(destinationType); + } + + @Override + public ErrorClause getErrorClause() { + return errorClause; + } + + @Override + public void setErrorClause(ErrorClause errorClause) { + this.errorClause = errorClause; + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + + sql.append(super.toString()); + + if (errorClause != null) { + sql.append(" "); + sql.append(errorClause); + } + + return sql.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/imprt/DBMSSource.java b/src/main/java/net/sf/jsqlparser/statement/imprt/DBMSSource.java new file mode 100644 index 000000000..0845af338 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/imprt/DBMSSource.java @@ -0,0 +1,106 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2019 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.imprt; + +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.ConnectionDefinition; +import net.sf.jsqlparser.statement.ErrorClause; +import net.sf.jsqlparser.statement.SourceDestinationType; +import net.sf.jsqlparser.statement.select.PlainSelect; + +import java.io.Serializable; +import java.util.List; + +public class DBMSSource implements ImportFromItem, Serializable { + private SourceDestinationType sourceType; + private ConnectionDefinition connectionDefinition; + private Table table; + private ExpressionList columns; + private List statements; + private ErrorClause errorClause; + + public SourceDestinationType getSourceType() { + return sourceType; + } + + public void setSourceType(SourceDestinationType sourceType) { + this.sourceType = sourceType; + } + + public ConnectionDefinition getConnectionDefinition() { + return connectionDefinition; + } + + public void setConnectionDefinition(ConnectionDefinition connectionDefinition) { + this.connectionDefinition = connectionDefinition; + } + + public Table getTable() { + return table; + } + + public void setTable(Table table) { + this.table = table; + } + + public ExpressionList getColumns() { + return columns; + } + + public void setColumns(ExpressionList columns) { + this.columns = columns; + } + + public List getStatements() { + return statements; + } + + public void setStatements(List statements) { + this.statements = statements; + } + + @Override + public ErrorClause getErrorClause() { + return errorClause; + } + + @Override + public void setErrorClause(ErrorClause errorClause) { + this.errorClause = errorClause; + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + + sql.append(sourceType); + + sql.append(" "); + sql.append(connectionDefinition); + + if (table != null) { + sql.append(" TABLE ").append(table); + PlainSelect.appendStringListTo(sql, columns, true, true); + } else if (statements != null) { + for (StringValue statement : statements) { + sql.append(" STATEMENT ").append(statement); + } + } + + if (errorClause != null) { + sql.append(errorClause); + } + + return sql.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/imprt/FileSource.java b/src/main/java/net/sf/jsqlparser/statement/imprt/FileSource.java new file mode 100644 index 000000000..0be5bbab6 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/imprt/FileSource.java @@ -0,0 +1,50 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2019 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.imprt; + +import net.sf.jsqlparser.statement.*; + +import java.io.Serializable; + +public class FileSource extends FileSourceDestination implements ImportFromItem, Serializable { + private ErrorClause errorClause; + + public SourceDestinationType getSourceType() { + return getType(); + } + + public void setSourceType(SourceDestinationType sourceType) { + setType(sourceType); + } + + @Override + public ErrorClause getErrorClause() { + return errorClause; + } + + @Override + public void setErrorClause(ErrorClause errorClause) { + this.errorClause = errorClause; + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + + sql.append(super.toString()); + + if (errorClause != null) { + sql.append(" "); + sql.append(errorClause); + } + + return sql.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/imprt/Import.java b/src/main/java/net/sf/jsqlparser/statement/imprt/Import.java new file mode 100644 index 000000000..e71799a3d --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/imprt/Import.java @@ -0,0 +1,128 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2019 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.imprt; + +import net.sf.jsqlparser.expression.Alias; +import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; +import net.sf.jsqlparser.statement.select.*; + +import java.util.List; + +public class Import extends ASTNodeAccessImpl implements FromItem, Statement { + private Table table; + private ExpressionList columns; + private List importColumns; + private ImportFromItem fromItem; + private Alias alias; + + public Table getTable() { + return table; + } + + public void setTable(Table table) { + this.table = table; + } + + public ExpressionList getColumns() { + return columns; + } + + public void setColumns(ExpressionList columns) { + this.columns = columns; + } + + public List getImportColumns() { + return importColumns; + } + + public void setImportColumns(List importColumns) { + this.importColumns = importColumns; + } + + public ImportFromItem getFromItem() { + return fromItem; + } + + public void setFromItem(ImportFromItem fromItem) { + this.fromItem = fromItem; + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + sql.append("IMPORT "); + if (table != null || importColumns != null) { + sql.append("INTO "); + if (table != null) { + sql.append(table); + PlainSelect.appendStringListTo(sql, columns, true, true); + } else { + PlainSelect.appendStringListTo(sql, importColumns, true, true); + } + sql.append(" "); + } + + sql.append("FROM "); + sql.append(fromItem); + + return sql.toString(); + } + + @Override + public T accept(StatementVisitor statementVisitor, S context) { + return statementVisitor.visit(this, context); + } + + @Override + public T accept(FromItemVisitor fromItemVisitor, S context) { + return fromItemVisitor.visit(this, context); + } + + @Override + public Alias getAlias() { + return alias; + } + + @Override + public void setAlias(Alias alias) { + this.alias = alias; + } + + @Override + public Pivot getPivot() { + return null; + } + + @Override + public void setPivot(Pivot pivot) {} + + @Override + public UnPivot getUnPivot() { + return null; + } + + @Override + public void setUnPivot(UnPivot unpivot) {} + + @Override + public SampleClause getSampleClause() { + return null; + } + + @Override + public FromItem setSampleClause(SampleClause sampleClause) { + return null; + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/imprt/ImportColumn.java b/src/main/java/net/sf/jsqlparser/statement/imprt/ImportColumn.java new file mode 100644 index 000000000..7d3f719dd --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/imprt/ImportColumn.java @@ -0,0 +1,13 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2019 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.imprt; + +public interface ImportColumn { +} diff --git a/src/main/java/net/sf/jsqlparser/statement/imprt/ImportFromItem.java b/src/main/java/net/sf/jsqlparser/statement/imprt/ImportFromItem.java new file mode 100644 index 000000000..86e736cca --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/imprt/ImportFromItem.java @@ -0,0 +1,18 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2019 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.imprt; + +import net.sf.jsqlparser.statement.ErrorClause; + +public interface ImportFromItem { + ErrorClause getErrorClause(); + + void setErrorClause(ErrorClause errorClause); +} diff --git a/src/main/java/net/sf/jsqlparser/statement/select/FromItemVisitor.java b/src/main/java/net/sf/jsqlparser/statement/select/FromItemVisitor.java index 0d97c4e4b..6949b1e73 100644 --- a/src/main/java/net/sf/jsqlparser/statement/select/FromItemVisitor.java +++ b/src/main/java/net/sf/jsqlparser/statement/select/FromItemVisitor.java @@ -10,6 +10,7 @@ package net.sf.jsqlparser.statement.select; import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.imprt.Import; import net.sf.jsqlparser.statement.piped.FromQuery; public interface FromItemVisitor { @@ -68,5 +69,11 @@ default void visit(TableStatement tableStatement) { this.visit(tableStatement, null); } + T visit(Import imprt, S context); + + default void visit(Import imprt) { + this.visit(imprt, null); + } + T visit(FromQuery fromQuery, S context); } diff --git a/src/main/java/net/sf/jsqlparser/statement/select/FromItemVisitorAdapter.java b/src/main/java/net/sf/jsqlparser/statement/select/FromItemVisitorAdapter.java index 9af6c9c82..35dc7b441 100644 --- a/src/main/java/net/sf/jsqlparser/statement/select/FromItemVisitorAdapter.java +++ b/src/main/java/net/sf/jsqlparser/statement/select/FromItemVisitorAdapter.java @@ -10,6 +10,7 @@ package net.sf.jsqlparser.statement.select; import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.imprt.Import; import net.sf.jsqlparser.statement.piped.FromQuery; import java.util.ArrayList; @@ -68,6 +69,11 @@ public T visit(TableStatement tableStatement, S context) { } @Override + public T visit(Import imprt, S context) { + + return null; + } + public T visit(FromQuery fromQuery, S context) { return fromQuery.getFromItem().accept(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 84c71b576..1c3b9bf9e 100644 --- a/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java +++ b/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java @@ -157,7 +157,9 @@ import net.sf.jsqlparser.statement.delete.ParenthesedDelete; import net.sf.jsqlparser.statement.drop.Drop; import net.sf.jsqlparser.statement.execute.Execute; +import net.sf.jsqlparser.statement.export.Export; import net.sf.jsqlparser.statement.grant.Grant; +import net.sf.jsqlparser.statement.imprt.Import; import net.sf.jsqlparser.statement.insert.Insert; import net.sf.jsqlparser.statement.insert.ParenthesedInsert; import net.sf.jsqlparser.statement.merge.Merge; @@ -1846,4 +1848,25 @@ public Void visit(GeometryDistance geometryDistance, S context) { return null; } + @Override + public Void visit(Import imprt, S context) { + throwUnsupported(imprt); + return null; + } + + @Override + public void visit(Import imprt) { + StatementVisitor.super.visit(imprt); + } + + @Override + public Void visit(Export export, S context) { + throwUnsupported(export); + return null; + } + + @Override + public void visit(Export export) { + StatementVisitor.super.visit(export); + } } diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/SelectDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/SelectDeParser.java index 77491e00c..0ae0cd122 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/SelectDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/SelectDeParser.java @@ -18,6 +18,7 @@ import net.sf.jsqlparser.expression.WindowDefinition; import net.sf.jsqlparser.schema.Column; import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.imprt.Import; import net.sf.jsqlparser.statement.piped.AggregatePipeOperator; import net.sf.jsqlparser.statement.piped.AsPipeOperator; import net.sf.jsqlparser.statement.piped.CallPipeOperator; @@ -798,6 +799,12 @@ public StringBuilder visit(Values values, S context) { return builder; } + @Override + public StringBuilder visit(Import imprt, S context) { + builder.append(imprt.toString()); + return builder; + } + @Override public void visit(Values values) { SelectVisitor.super.visit(values); @@ -893,6 +900,10 @@ public void visit(ParenthesedFromItem fromItem) { visit(fromItem, null); } + public void visit(Import imprt) { + visit(imprt, null); + } + private void deparseOptimizeFor(OptimizeFor optimizeFor) { builder.append(" OPTIMIZE FOR "); 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 9f3c81fc1..ccfc0a92b 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/StatementDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/StatementDeParser.java @@ -52,7 +52,9 @@ import net.sf.jsqlparser.statement.delete.ParenthesedDelete; import net.sf.jsqlparser.statement.drop.Drop; import net.sf.jsqlparser.statement.execute.Execute; +import net.sf.jsqlparser.statement.export.Export; import net.sf.jsqlparser.statement.grant.Grant; +import net.sf.jsqlparser.statement.imprt.Import; import net.sf.jsqlparser.statement.insert.Insert; import net.sf.jsqlparser.statement.insert.ParenthesedInsert; import net.sf.jsqlparser.statement.merge.Merge; @@ -499,4 +501,16 @@ public ExpressionDeParser getExpressionDeParser() { public SelectDeParser getSelectDeParser() { return selectDeParser; } + + @Override + public StringBuilder visit(Import imprt, S context) { + builder.append(imprt.toString()); + return builder; + } + + @Override + public StringBuilder visit(Export export, S context) { + builder.append(export.toString()); + return builder; + } } diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/SelectValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/SelectValidator.java index 49367ddf0..bacd4e1af 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/validator/SelectValidator.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/SelectValidator.java @@ -16,6 +16,7 @@ import net.sf.jsqlparser.expression.SQLServerHints; import net.sf.jsqlparser.parser.feature.Feature; import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.imprt.Import; import net.sf.jsqlparser.statement.piped.FromQuery; import net.sf.jsqlparser.statement.select.ExceptOp; import net.sf.jsqlparser.statement.select.Fetch; @@ -360,6 +361,12 @@ public Void visit(Values values, S context) { return null; } + @Override + public Void visit(Import imprt, S context) { + // TODO: not yet implemented + return null; + } + @Override public void validate(SelectItem statement) { statement.accept(this, null); @@ -426,4 +433,8 @@ public void visit(Values values) { visit(values, null); } + public void visit(Import imprt) { + visit(imprt, null); + } + } 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 06b44e14f..af4ec9256 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 @@ -50,7 +50,9 @@ import net.sf.jsqlparser.statement.delete.ParenthesedDelete; import net.sf.jsqlparser.statement.drop.Drop; import net.sf.jsqlparser.statement.execute.Execute; +import net.sf.jsqlparser.statement.export.Export; import net.sf.jsqlparser.statement.grant.Grant; +import net.sf.jsqlparser.statement.imprt.Import; import net.sf.jsqlparser.statement.insert.Insert; import net.sf.jsqlparser.statement.insert.ParenthesedInsert; import net.sf.jsqlparser.statement.merge.Merge; @@ -71,7 +73,6 @@ */ public class StatementValidator extends AbstractValidator implements StatementVisitor { - @Override public Void visit(CreateIndex createIndex, S context) { getValidator(CreateIndexValidator.class).validate(createIndex); @@ -386,6 +387,18 @@ public Void visit(UnsupportedStatement unsupportedStatement, S context) { return null; } + @Override + public Void visit(Import imprt, S context) { + // TODO: not yet implemented + return null; + } + + @Override + public Void visit(Export export, S context) { + // TODO: not yet implemented + return null; + } + public void visit(CreateIndex createIndex) { visit(createIndex, null); } @@ -562,4 +575,11 @@ public void visit(UnsupportedStatement unsupportedStatement) { visit(unsupportedStatement, null); } + public void visit(Import imprt) { + visit(imprt, null); + } + + public void visit(Export export) { + visit(export, null); + } } diff --git a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt index 83107c03e..a3f148379 100644 --- a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt +++ b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt @@ -68,6 +68,8 @@ import net.sf.jsqlparser.statement.update.*; import net.sf.jsqlparser.statement.upsert.*; import net.sf.jsqlparser.statement.merge.*; import net.sf.jsqlparser.statement.grant.*; +import net.sf.jsqlparser.statement.imprt.*; +import net.sf.jsqlparser.statement.export.*; import java.util.*; import java.util.AbstractMap.SimpleEntry; import net.sf.jsqlparser.statement.select.SetOperationList.SetOperationType; @@ -238,8 +240,10 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */ | | | +| | | +| | | | @@ -254,13 +258,16 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */ | | | +| | | | | | | +| | +| | | | @@ -273,6 +280,7 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */ | | /* H2 casewhen function */ | +| | | | @@ -280,6 +288,7 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */ | | | +| | | | @@ -287,6 +296,7 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */ | | | +| | | | @@ -297,7 +307,9 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */ | | | +| | +| | | | @@ -307,9 +319,12 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */ | | | +| | | | +| +| | | | @@ -322,6 +337,7 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */ | | | +| | | | @@ -329,16 +345,20 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */ | | | +| | | | | | +| | +| | | | | /* Salesforce SOQL */ +| | | | @@ -347,8 +367,11 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */ | | | +| +| | | +| | | | @@ -375,6 +398,8 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */ | | | +| +| | | | @@ -384,9 +409,11 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */ | | /* Salesforce SOQL */ | +| | | | +| | | | @@ -399,6 +426,7 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */ | | | +| | | | @@ -426,6 +454,7 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */ | | | +| | | | @@ -443,8 +472,10 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */ | | | +| | | +| | | | @@ -454,6 +485,7 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */ | | | +| | | | @@ -469,6 +501,7 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */ | | | +| | "> | | @@ -480,6 +513,7 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */ | | | +| | | | @@ -511,6 +545,7 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */ | | | +| | | | @@ -536,10 +571,12 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */ | | | +| | | | | +| | | | @@ -599,6 +636,7 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */ | | | +| | | | @@ -618,6 +656,7 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */ | | | +| | | | @@ -685,7 +724,7 @@ TOKEN : /* Data Types */ | <#TYPE_BIT: "BISTRING"> | <#TYPE_BLOB: "BLOB" | "BYTEA" | | "VARBINARY" | > - | <#TYPE_BOOLEAN: "BOOLEAN" | "BOOL" > + | <#TYPE_BOOLEAN: | "BOOL" > | <#TYPE_ENUM: "ENUM" > | <#TYPE_MAP: "MAP" > | <#TYPE_DECIMAL: "DECIMAL" | "NUMBER" | "NUMERIC" > @@ -974,6 +1013,8 @@ Statement SingleStatement() : stm = PurgeStatement() | stm = SessionStatement() + | + LOOKAHEAD({ Dialect.EXASOL.name().equals(getAsString(Feature.dialect)) }) ( stm = Import() | stm = Export() ) ) { return stm; } } @@ -1150,6 +1191,848 @@ List error_skipto(int kind) { return tokenImages; } +LikeClause LikeClause(): { + LikeClause likeClause = new LikeClause(); + Table table; + List> columnsList; +} { + + table = Table() { likeClause.setTable(table); } + [ "(" columnsList = ColumnSelectItemsList() ")" { likeClause.setColumnsList(columnsList); }] + + [ + LOOKAHEAD(2) + ( + { likeClause.setIncludingDefaults(true); } + | { likeClause.setExcludingDefaults(true); } + ) + + ] + + [ + LOOKAHEAD(2) + ( + { likeClause.setIncludingIdentity(true); } + | { likeClause.setExcludingIdentity(true); } + ) + + ] + + [ + LOOKAHEAD(2) + ( + { likeClause.setIncludingComments(true); } + | { likeClause.setExcludingComments(true); } + ) + + ] + + { + return likeClause; + } +} + +Export Export() #Export: { + Export export = new Export(); + Table table; + ParenthesedExpressionList columns; + ParenthesedSelect select; + ExportIntoItem exportIntoItem; +} { + + ( + table = Table() { export.setTable(table); } + [ columns = ParenthesedColumnList() { export.setColumns(columns); } ] + | select = ParenthesedSelect() { export.setSelect(select); } + ) + + + exportIntoItem = ExportIntoItem() { export.setExportIntoItem(exportIntoItem); } + + { + return export; + } +} + +Import Import() #Import: { + Import impt = new Import(); + Table table; + ParenthesedExpressionList columns; + List importColumns; + ImportFromItem fromItem; +} { + + [ + + ( + table = Table() { impt.setTable(table); } + [ columns = ParenthesedColumnList() { impt.setColumns(columns); } ] + | importColumns = ImportColumns() { impt.setImportColumns(importColumns); } + ) + ] + + + fromItem = ImportFromItem() { impt.setFromItem(fromItem); } + + { + return impt; + } +} + +Import SubImport() #SubImport: { + Import impt = new Import(); + List importColumns; + ImportFromItem fromItem; +} { + "(" + + [ importColumns = ImportColumns() { impt.setImportColumns(importColumns); } ] + + + fromItem = ImportFromItem() { impt.setFromItem(fromItem); } + ")" + + { + return impt; + } +} + +List ImportColumns(): { + ImportColumn importColumn; + List importColumns = new ArrayList(); +} { + "(" + ( + importColumn = ColumnDefinition() + | importColumn = LikeClause() + ) + { importColumns.add(importColumn); } + + ( + "," + ( + importColumn = ColumnDefinition() + | importColumn = LikeClause() + ) + { importColumns.add(importColumn); } + )* + ")" + + { + return importColumns; + } +} + +ExportIntoItem ExportIntoItem(): { + ExportIntoItem exportIntoItem; + ErrorClause errorClause; +} { + ( + exportIntoItem = DBMSDestination() + | exportIntoItem = FileDestination() + | exportIntoItem = ScriptSourceDestination() + ) + [ LOOKAHEAD(2) errorClause = ErrorClause() { exportIntoItem.setErrorClause(errorClause); } ] + + { + return exportIntoItem; + } +} + +ImportFromItem ImportFromItem(): { + ImportFromItem importFromItem; + ErrorClause errorClause; +} { + ( + importFromItem = DBMSSource() + | importFromItem = FileSource() + | importFromItem = ScriptSourceDestination() + ) + [ LOOKAHEAD(2) errorClause = ErrorClause() { importFromItem.setErrorClause(errorClause); } ] + + { + return importFromItem; + } +} + +DBMSDestination DBMSDestination() #DBMSDestination: { + DBMSDestination dbmsDestination = new DBMSDestination(); + DBMSType dbmsType; + ConnectionDefinition connectionDefinition; + Table table; + ExpressionList columns; + StringValue statement; + List dbmsTableDestinationOptions; +} { + dbmsType = DBMSType() { dbmsDestination.setDestinationType(dbmsType); } + + connectionDefinition = ConnectionDefinition() { dbmsDestination.setConnectionDefinition(connectionDefinition); } + + ( + LOOKAHEAD(3) + table = Table() { dbmsDestination.setTable(table); } + [ LOOKAHEAD(2) columns = ParenthesedColumnList() { dbmsDestination.setColumns(columns); } ] + [ LOOKAHEAD(2) dbmsTableDestinationOptions = DBMSTableDestinationOptionList() { dbmsDestination.setDBMSTableDestinationOptions(dbmsTableDestinationOptions); } ] + | statement = ImportExportStatement() { dbmsDestination.setStatement(statement); } + ) + + { + return dbmsDestination; + } +} + +DBMSTableDestinationOption DBMSTableDestinationOption(): { + DBMSTableDestinationOption dbmsTableDestinationOption; + + Token token; + Token token2; + Token token3; +} { + ( + ( + token = + | token = + ) { dbmsTableDestinationOption = new DBMSTableDestinationOption(token.image); } + | token = token2 = token3 = { dbmsTableDestinationOption = new DBMSTableDestinationOption(token.image + " " + token2.image, new StringValue(token3.image)); } + ) + + { + return dbmsTableDestinationOption; + } +} + +List DBMSTableDestinationOptionList(): { + List dbmsTableDestinationOptions = new ArrayList(); + DBMSTableDestinationOption dbmsTableDestinationOption; +} { + ( LOOKAHEAD(2) dbmsTableDestinationOption = DBMSTableDestinationOption() { dbmsTableDestinationOptions.add(dbmsTableDestinationOption); } )+ + { + return dbmsTableDestinationOptions; + } +} + +DBMSSource DBMSSource() #DBMSSource: { + DBMSSource dbmsSource = new DBMSSource(); + DBMSType dbmsType; + ConnectionDefinition connectionDefinition; + Table table; + ExpressionList columns; + List statements; +} { + dbmsType = DBMSType() { dbmsSource.setSourceType(dbmsType); } + + connectionDefinition = ConnectionDefinition() { dbmsSource.setConnectionDefinition(connectionDefinition); } + + ( + table = Table() { dbmsSource.setTable(table); } + [ LOOKAHEAD(2) columns = ParenthesedColumnList() { dbmsSource.setColumns(columns); } ] + | statements = ImportExportStatementsList() { dbmsSource.setStatements(statements); } + ) + { + return dbmsSource; + } +} + +DBMSType DBMSType(): { + DBMSType dbmsType; + Token tk1; + Token tk2 = null; +} { + ( + tk1= + | tk1= + | tk1= + [ "=" tk2=] + ) { dbmsType = new DBMSType(tk1.image, tk2 == null ? null : tk2.image); } + { + return dbmsType; + } +} + +FileType FileType(): { + FileType fileType; + Token tk; +} { + ( + tk= + | tk= + ) { fileType = new FileType(tk.image); } + { + return fileType; + } +} + +StringValue ImportExportStatement() #ImportExportStatement: { + StringValue statement; +} { + token = + { + statement = new StringValue(token.image); + linkAST(statement, jjtThis); + return statement; + } +} + +List ImportExportStatementsList(): { + List statements = new ArrayList(); + StringValue statement; +} { + ( statement = ImportExportStatement() { statements.add(statement); } )+ + + { + return statements; + } +} + +StringValue File() #File: { + Token token; +} { + token = + { + StringValue file = new StringValue(token.image); + linkAST(file, jjtThis); + return file; + } +} + +List FileList(): { + List files = new ArrayList(); + StringValue file; +} { + ( file = File() { files.add(file); } )+ + { + return files; + } +} + +ConnectionFileDefinition ConnectionFileDefinition(): { + ConnectionDefinition connectionDefinition = null; + List files; +} { + connectionDefinition = ConnectionOrCloudConnectionDefinition() + files = FileList() + { + return new ConnectionFileDefinition(connectionDefinition, files); + } +} + +List ConnectionFileDefinitionList(): { + List connectionFileDefinitions = new ArrayList(); + ConnectionFileDefinition connectionFileDefinition; +} { + ( LOOKAHEAD(2) connectionFileDefinition = ConnectionFileDefinition() { connectionFileDefinitions.add(connectionFileDefinition); } )+ + { + return connectionFileDefinitions; + } +} + +CSVColumn CSVDestinationColumn(): { + CSVColumn csvColumn; + + Token token; + Token token2; +} { + ( + LOOKAHEAD(2) + token= ".." token2= { csvColumn = new CSVColumn(Long.valueOf(token.image), Long.valueOf(token2.image)); } + | token= { csvColumn = new CSVColumn(Long.valueOf(token.image)); } + [ "=" token = { csvColumn.setFormat(new StringValue(token.image)); }] + [ + + "=" + ( + token= + | token= + | token= + ) + { csvColumn.setDelimit(token.image); } + ] + ) + { + return csvColumn; + } +} + +List CSVDestinationColumnList(): { + List csvColumns = new ArrayList(); + CSVColumn csvColumn; +} { + csvColumn = CSVDestinationColumn() { csvColumns.add(csvColumn); } + ( "," csvColumn = CSVDestinationColumn() { csvColumns.add(csvColumn); } )* + { + return csvColumns; + } +} + +CSVColumn CSVSourceColumn(): { + CSVColumn csvColumn; + + Token token; + Token token2; +} { + ( + LOOKAHEAD(2) + token= ".." token2= { csvColumn = new CSVColumn(Long.valueOf(token.image), Long.valueOf(token2.image)); } + | token= { csvColumn = new CSVColumn(Long.valueOf(token.image)); } + [ "=" token = { csvColumn.setFormat(new StringValue(token.image)); }] + ) + { + return csvColumn; + } +} + +List CSVSourceColumnList(): { + List csvColumns = new ArrayList(); + CSVColumn csvColumn; +} { + csvColumn = CSVSourceColumn() { csvColumns.add(csvColumn); } + ( "," csvColumn = CSVSourceColumn() { csvColumns.add(csvColumn); } )* + { + return csvColumns; + } +} + +FBVColumn FBVDestinationColumn(): { + FBVColumn fbvColumn; + + Token token; + Token token2; +} { + ( + token= "=" token2= { fbvColumn = new FBVColumn(token.image, new LongValue(token2.image)); } + | ( token= | token= ) "=" token2= { fbvColumn = new FBVColumn(token.image, new StringValue(token2.image)); } + | token= "=" ( token2= | token2= ) { fbvColumn = new FBVColumn(token.image, token2.image); } + ) + { + return fbvColumn; + } +} + +List FBVDestinationColumnList(): { + List fbvColumns = new ArrayList(); + FBVColumn fbvColumn; + boolean precedesComma; +} { + fbvColumn = FBVDestinationColumn() { fbvColumns.add(fbvColumn); } + ( + { precedesComma = false; } + ["," { precedesComma = true; }] + fbvColumn = FBVDestinationColumn() { fbvColumn.setPrecedesComma(precedesComma); fbvColumns.add(fbvColumn); } + )* + { + return fbvColumns; + } +} + +FBVColumn FBVSourceColumn(): { + FBVColumn fbvColumn; + + Token token; + Token token2; +} { + ( + ( token= | token= ) "=" token2= { fbvColumn = new FBVColumn(token.image, new LongValue(token2.image)); } + | ( token= | token= ) "=" token2= { fbvColumn = new FBVColumn(token.image, new StringValue(token2.image)); } + | token= "=" ( token2= | token2= ) { fbvColumn = new FBVColumn(token.image, token2.image); } + ) + { + return fbvColumn; + } +} + +List FBVSourceColumnList(): { + List fbvColumns = new ArrayList(); + FBVColumn fbvColumn; + boolean precedesComma; +} { + fbvColumn = FBVSourceColumn() { fbvColumns.add(fbvColumn); } + ( + { precedesComma = false; } + ["," { precedesComma = true; }] + fbvColumn = FBVSourceColumn() { fbvColumn.setPrecedesComma(precedesComma); fbvColumns.add(fbvColumn); } + )* + { + return fbvColumns; + } +} + +FileOption FileDestinationOption(): { + FileOption fileOption; + + Token token; + Token token2; + Token token3; +} { + ( + ( token= | token= ) { fileOption = new FileOption(token.image); } + | token= token2= token3= { fileOption = new FileOption(token.image + " " + token2.image + " " + token3.image); } + | ( token= | token= | token= ) "=" token2= { fileOption = new FileOption(token.image, new StringValue(token2.image)); } + | ( + token= token2= "=" token3= + | token= ( token2= | token2= ) "=" token3= + ) + { fileOption = new FileOption(token.image + " " + token2.image, new StringValue(token3.image)); } + | token= "=" ( token2= | token2= | token2= ) { fileOption = new FileOption(token.image, token2.image); } + ) + { + return fileOption; + } +} + +List FileDestinationOptionList(): { + List fileOptions = new ArrayList(); + FileOption fileOption; +} { + ( LOOKAHEAD(2) fileOption = FileDestinationOption() { fileOptions.add(fileOption); } )+ + { + return fileOptions; + } +} + +FileOption FileSourceOption(): { + FileOption fileOption; + + Token token; + Token token2; + Token token3; +} { + ( + ( token= | token= | token= ) { fileOption = new FileOption(token.image); } + | ( + ( token= | token= ) "=" token2= { fileOption = new FileOption(token.image, new StringValue(token2.image)); } + | token= "=" token2= { fileOption = new FileOption(token.image, new LongValue(token2.image)); } + ) + | LOOKAHEAD(2) + ( + token= token2= "=" token3= + | token= ( token2= | token2= ) "=" token3= + ) + { fileOption = new FileOption(token.image + " " + token2.image, new StringValue(token3.image)); } + | token= token2= "=" token3= + { fileOption = new FileOption(token.image + " " + token2.image, new LongValue(token3.image)); } + ) + { + return fileOption; + } +} + +List FileSourceOptionList(): { + List fileOptions = new ArrayList(); + FileOption fileOption; +} { + ( LOOKAHEAD(2) fileOption = FileSourceOption() { fileOptions.add(fileOption); } )+ + { + return fileOptions; + } +} + +FileDestination FileDestination() #FileDestination: { + FileDestination fileDestination = new FileDestination(); + FileType fileType; + List connectionFileDefinitions; + List files; + List csvColumns; + List fbvColumns; + List fileOptions; + CertificateVerification certificateVerification; +} { + ( + fileType = FileType() { fileDestination.setDestinationType(fileType); } + connectionFileDefinitions = ConnectionFileDefinitionList() { fileDestination.setConnectionFileDefinitions(connectionFileDefinitions); } + | { fileDestination.setLocal(true); } + [ { fileDestination.setSecure(true); }] + + fileType = FileType() { fileDestination.setDestinationType(fileType); } + files = FileList() + { + connectionFileDefinitions = new ArrayList(); + connectionFileDefinitions.add(new ConnectionFileDefinition(files)); + } + ) + { fileDestination.setConnectionFileDefinitions(connectionFileDefinitions); } + + [ + LOOKAHEAD(2) + "(" + ( + csvColumns = CSVDestinationColumnList() { fileDestination.setCSVColumns(csvColumns); } + | fbvColumns = FBVDestinationColumnList() { fileDestination.setFBVColumns(fbvColumns); } + ) + ")" + ] + + [ LOOKAHEAD(2) fileOptions = FileDestinationOptionList() { fileDestination.setFileOptions(fileOptions); } ] + + [ LOOKAHEAD(2) certificateVerification = CertificateVerification() { fileDestination.setCertificateVerification(certificateVerification); } ] + + { + return fileDestination; + } +} + +FileSource FileSource() #FileSource: { + FileSource fileSource = new FileSource(); + FileType fileType; + List connectionFileDefinitions; + List files; + List csvColumns; + List fbvColumns; + List fileOptions; + CertificateVerification certificateVerification; +} { + ( + fileType = FileType() { fileSource.setSourceType(fileType); } + connectionFileDefinitions = ConnectionFileDefinitionList() { fileSource.setConnectionFileDefinitions(connectionFileDefinitions); } + | { fileSource.setLocal(true); } + [ { fileSource.setSecure(true); }] + + fileType = FileType() { fileSource.setSourceType(fileType); } + files = FileList() + { + connectionFileDefinitions = new ArrayList(); + connectionFileDefinitions.add(new ConnectionFileDefinition(files)); + } + ) + { fileSource.setConnectionFileDefinitions(connectionFileDefinitions); } + + [ + LOOKAHEAD(2) + "(" + ( + csvColumns = CSVSourceColumnList() { fileSource.setCSVColumns(csvColumns); } + | fbvColumns = FBVSourceColumnList() { fileSource.setFBVColumns(fbvColumns); } + ) + ")" + ] + + [ LOOKAHEAD(2) fileOptions = FileSourceOptionList() { fileSource.setFileOptions(fileOptions); } ] + + [ LOOKAHEAD(2) certificateVerification = CertificateVerification() { fileSource.setCertificateVerification(certificateVerification); } ] + + { + return fileSource; + } +} + +CertificateVerification CertificateVerification(): { + CertificateVerification certificateVerification = new CertificateVerification(); + Token token; +} { + ( + ( + { certificateVerification.setIgnoreCertificate(true); } + | { certificateVerification.setVerifyCertificate(true); } + ) + + [ + LOOKAHEAD(2) + + token = { certificateVerification.setPublicKey(new StringValue(token.image)); } + ] + | + token = { certificateVerification.setPublicKey(new StringValue(token.image)); } + ) + { + return certificateVerification; + } +} + +ScriptSourceDestination ScriptSourceDestination(): { + ScriptSourceDestination scriptSourceDestination = new ScriptSourceDestination(); + ConnectionDefinition connectionDefinition; + Table script; + String property; + StringValue value; + + Token token; +} { + + script = Table() { scriptSourceDestination.setScript(script); } + + [ LOOKAHEAD(2) connectionDefinition = ConnectionDefinition() { scriptSourceDestination.setConnectionDefinition(connectionDefinition); } ] + + [ + LOOKAHEAD(2) + { + List properties = new ArrayList(); + List values = new ArrayList(); + scriptSourceDestination.setProperties(properties); + scriptSourceDestination.setValues(values); + } + + + ( + LOOKAHEAD(2) + property = RelObjectNameWithoutValue() "=" token = { value = new StringValue(token.image); } + { + properties.add(property); + values.add(value); + } + )+ + ] + + { + return scriptSourceDestination; + } +} + +UserIdentification UserIdentification(): { + UserIdentification userIdentification = new UserIdentification(); + Token token; +} { + + token= { userIdentification.setUser(new StringValue(token.image)); } + + token= { userIdentification.setPassword(new StringValue(token.image)); } + + { + return userIdentification; + } +} + +ConnectionDefinition ConnectionDefinition(): { + ConnectionDefinition connectionDefinition = new ConnectionDefinition(); + String connectionObjectName; + UserIdentification userIdentification; + CertificateVerification certificateVerification; + + Token token; +} { + + ( + connectionObjectName = RelObjectNameWithoutValue() { connectionDefinition.setConnectionObjectName(connectionObjectName); } + | token= { connectionDefinition.setConnectionDefinition(new StringValue(token.image)); } + ) + + [ LOOKAHEAD(2) userIdentification = UserIdentification() { connectionDefinition.setUserIdentification(userIdentification); } ] + + [ LOOKAHEAD(2) certificateVerification = CertificateVerification() { connectionDefinition.setCertificateVerification(certificateVerification); } ] + + { + return connectionDefinition; + } +} + +ConnectionDefinition CloudConnectionDefinition(): { + CloudConnectionDefinition connectionDefinition = new CloudConnectionDefinition(); + String connectionObjectName; + UserIdentification userIdentification; + + Token token; + Token token2; +} { + + ( + token = { connectionDefinition.setStorage(token.image); } + | token = token2 = { connectionDefinition.setStorage(token.image + " " + token2.image); } + ) + + ( + connectionObjectName = RelObjectNameWithoutValue() { connectionDefinition.setConnectionObjectName(connectionObjectName); } + | token = { connectionDefinition.setConnectionDefinition(new StringValue(token.image)); } + ) + + [ userIdentification = UserIdentification() { connectionDefinition.setUserIdentification(userIdentification); } ] + + { + return connectionDefinition; + } +} + +ConnectionDefinition ConnectionOrCloudConnectionDefinition(): { + ConnectionDefinition connectionDefinition; +} { + ( + LOOKAHEAD(2) connectionDefinition = CloudConnectionDefinition() + | connectionDefinition = ConnectionDefinition() + ) + { + return connectionDefinition; + } +} + +ErrorClause ErrorClause(): { + ErrorClause errorClause = new ErrorClause(); + ErrorDestination errorDestination; + Expression expression; + RejectClause rejectClause; + + Token token; +} { + ( + + errorDestination = ErrorDestination() { errorClause.setErrorDestination(errorDestination); } + [ + LOOKAHEAD(2) + "(" + expression = Expression() { errorClause.setExpression(expression); } + ")" + ] + [ + LOOKAHEAD(2) + ( + { errorClause.setReplace(true); } + | { errorClause.setTruncate(true); } + ) + ] + [ LOOKAHEAD(2) rejectClause = RejectClause() { errorClause.setRejectClause(rejectClause); } ] + | rejectClause = RejectClause() { errorClause.setRejectClause(rejectClause); } + ) + + { + return errorClause; + } +} + +RejectClause RejectClause(): { + RejectClause rejectClause = new RejectClause(); +} { + + ( + token= { rejectClause.setLimit(new LongValue(token.image)); } + | + ) + + [ LOOKAHEAD(2) { rejectClause.setErrors(true); } ] + + { + return rejectClause; + } +} + +ErrorDestination ErrorDestination(): { + ErrorDestination errorDestination; +} { + ( + LOOKAHEAD(2) errorDestination = CSVFileDestination() + | errorDestination = Table() + ) + + { + return errorDestination; + } +} + +CSVFileDestination CSVFileDestination(): { + CSVFileDestination csvFileDestination = new CSVFileDestination(); + ConnectionDefinition connectionDefinition; + StringValue file; +} { + ( + + connectionDefinition = ConnectionOrCloudConnectionDefinition() { csvFileDestination.setConnectionDefinition(connectionDefinition); } + | { csvFileDestination.setLocal(true); } + [ { csvFileDestination.setSecure(true); } ] + + ) + + file = File() { csvFileDestination.setFile(file); } + + { + return csvFileDestination; + } +} + DeclareStatement Declare(): { UserVariable userVariable; ColDataType colDataType; @@ -2278,7 +3161,7 @@ String RelObjectNameWithoutValue() : { Token tk = null; } { ( tk= | tk= | tk= | tk= | tk= | tk= | tk= | tk= | tk= - | tk= | tk= | tk="KILL" | tk="ACTION" | tk="ACTIVE" | tk="ADD" | tk="ADVANCE" | tk="ADVISE" | tk="AGAINST" | tk="AGGREGATE" | tk="ALGORITHM" | tk="ALTER" | tk="ANALYZE" | tk="APPLY" | tk="APPROXIMATE" | tk="ARCHIVE" | tk="ARRAY" | tk="ASC" | tk="AT" | tk="AUTHORIZATION" | tk="AUTO" | tk="AUTO_INCREMENT" | tk="BASE64" | tk="BEGIN" | tk="BERNOULLI" | tk="BINARY" | tk="BIT" | tk="BLOCK" | tk="BROWSE" | tk="BUFFERS" | tk="BY" | tk="BYTE" | tk="BYTES" | tk="CACHE" | tk="CALL" | tk="CASCADE" | tk="CASE" | tk="CAST" | tk="CHANGE" | tk="CHANGES" | tk="CHAR" | tk="CHARACTER" | tk="CHECKPOINT" | tk="CLOSE" | tk="COALESCE" | tk="COLLATE" | tk="COLUMN" | tk="COLUMNS" | tk="COMMENT" | tk="COMMIT" | tk="CONCURRENTLY" | tk="CONFLICT" | tk="CONSTRAINTS" | tk="CONVERT" | tk="CORRESPONDING" | tk="COSTS" | tk="COUNT" | tk="CS" | tk="CYCLE" | tk="DATA" | tk="DATABASE" | tk="DATETIME" | tk="DBA_RECYCLEBIN" | tk="DDL" | tk="DECLARE" | tk="DEFERRABLE" | tk="DELAYED" | tk="DELETE" | tk="DESC" | tk="DESCRIBE" | tk="DISABLE" | tk="DISCARD" | tk="DISCONNECT" | tk="DIV" | tk="DML" | tk="DO" | tk="DOMAIN" | tk="DROP" | tk="DUMP" | tk="DUPLICATE" | tk="ELEMENTS" | tk="EMIT" | tk="ENABLE" | tk="ENCRYPTION" | tk="END" | tk="ENFORCED" | tk="ENGINE" | tk="ERROR" | tk="ESCAPE" | tk="EXCHANGE" | tk="EXCLUDE" | tk="EXEC" | tk="EXECUTE" | tk="EXPLAIN" | tk="EXPLICIT" | tk="EXTENDED" | tk="EXTRACT" | tk="FILTER" | tk="FIRST" | tk="FLUSH" | tk="FN" | tk="FOLLOWING" | tk="FORMAT" | tk="FULLTEXT" | tk="FUNCTION" | tk="GRANT" | tk="GROUP_CONCAT" | tk="GUARD" | tk="HASH" | tk="HIGH" | tk="HIGH_PRIORITY" | tk="HISTORY" | tk="HOPPING" | tk="IMPORT" | tk="INCLUDE" | tk="INCLUDE_NULL_VALUES" | tk="INCREMENT" | tk="INDEX" | tk="INSERT" | tk="INTERLEAVE" | tk="INTERPRET" | tk="INVALIDATE" | tk="INVERSE" | tk="INVISIBLE" | tk="ISNULL" | tk="JSON" | tk="JSON_ARRAY" | tk="JSON_ARRAYAGG" | tk="JSON_OBJECT" | tk="JSON_OBJECTAGG" | tk="KEEP" | tk="KEY" | tk="KEYS" | tk="KEY_BLOCK_SIZE" | tk="LAST" | tk="LEADING" | tk="LESS" | tk="LINK" | tk="LOCAL" | tk="LOCK" | tk="LOCKED" | tk="LOG" | tk="LONGTEXT" | tk="LOOP" | tk="LOW" | tk="LOW_PRIORITY" | tk="MATCH" | tk="MATCHED" | tk="MATCH_ALL" | tk="MATCH_ANY" | tk="MATCH_PHRASE" | tk="MATCH_PHRASE_PREFIX" | tk="MATCH_REGEXP" | tk="MATERIALIZED" | tk="MAX" | tk="MAXVALUE" | tk="MEDIUMTEXT" | tk="MEMBER" | tk="MERGE" | tk="MIN" | tk="MINVALUE" | tk="MODIFY" | tk="MOVEMENT" | tk="NAME" | tk="NEXT" | tk="NO" | tk="NOCACHE" | tk="NOKEEP" | tk="NOLOCK" | tk="NOMAXVALUE" | tk="NOMINVALUE" | tk="NOORDER" | tk="NOTHING" | tk="NOTNULL" | tk="NOVALIDATE" | tk="NOWAIT" | tk="NULLS" | tk="OF" | tk="OFF" | tk="OPEN" | tk="ORDINALITY" | tk="OVER" | tk="OVERFLOW" | tk="OVERLAPS" | tk="OVERRIDING" | tk="OVERWRITE" | tk="PARALLEL" | tk="PARENT" | tk="PARSER" | tk="PARTITION" | tk="PARTITIONING" | tk="PATH" | tk="PERCENT" | tk="PLACING" | tk="PLAN" | tk="PLUS" | tk="PRECEDING" | tk="PRIMARY" | tk="PURGE" | tk="QUERY" | tk="QUICK" | tk="QUIESCE" | tk="RANGE" | tk="RAW" | tk="READ" | tk="REBUILD" | tk="RECURSIVE" | tk="RECYCLEBIN" | tk="REFERENCES" | tk="REFRESH" | tk="REGEXP" | tk="REGEXP_LIKE" | tk="REGISTER" | tk="REMOTE" | tk="REMOVE" | tk="RENAME" | tk="REORGANIZE" | tk="REPAIR" | tk="REPEATABLE" | tk="REPLACE" | tk="RESET" | tk="RESPECT" | tk="RESTART" | tk="RESTRICT" | tk="RESTRICTED" | tk="RESUMABLE" | tk="RESUME" | tk="RETURN" | tk="RLIKE" | tk="ROLLBACK" | tk="ROLLUP" | tk="ROOT" | tk="ROW" | tk="ROWS" | tk="RR" | tk="RS" | tk="SAFE_CAST" | tk="SAVEPOINT" | tk="SCHEMA" | tk="SECURE" | tk="SEED" | tk="SEPARATOR" | tk="SEQUENCE" | tk="SESSION" | tk="SETS" | tk="SHARE" | tk="SHOW" | tk="SHUTDOWN" | tk="SIBLINGS" | tk="SIGNED" | tk="SIMILAR" | tk="SIZE" | tk="SKIP" | tk="SPATIAL" | tk="STORED" | tk="STRICT" | tk="STRING" | tk="STRUCT" | tk="SUMMARIZE" | tk="SUSPEND" | tk="SWITCH" | tk="SYNONYM" | tk="SYSTEM" | tk="TABLE" | tk="TABLESPACE" | tk="TEMP" | tk="TEMPORARY" | tk="TEXT" | tk="THAN" | tk="THEN" | tk="TIMEOUT" | tk="TIMESTAMPTZ" | tk="TIMEZONE" | tk="TINYTEXT" | tk="TO" | tk="TRIGGER" | tk="TRUNCATE" | tk="TRY_CAST" | tk="TUMBLING" | tk="TYPE" | tk="UNLOGGED" | tk="UNQIESCE" | tk="UNSIGNED" | tk="UPDATE" | tk="UPSERT" | tk="UR" | tk="USER" | tk="VALIDATE" | tk="VALIDATION" | tk="VERBOSE" | tk="VIEW" | tk="VISIBLE" | tk="VOLATILE" | tk="WAIT" | tk="WITHIN" | tk="WITHOUT" | tk="WITHOUT_ARRAY_WRAPPER" | tk="WORK" | tk="XML" | tk="XMLAGG" | tk="XMLDATA" | tk="XMLSCHEMA" | tk="XMLTEXT" | tk="XSINIL" | tk="YAML" | tk="YES" | tk="ZONE" ) + | tk="ACTION" | tk="ACTIVE" | tk="ADD" | tk="ADVANCE" | tk="ADVISE" | tk="AGAINST" | tk="AGGREGATE" | tk="ALGORITHM" | tk="ALIGN" | tk="ALTER" | tk="ALWAYS" | tk="ANALYZE" | tk="APPLY" | tk="APPROXIMATE" | tk="ARCHIVE" | tk="ARRAY" | tk="ASC" | tk="ASYMMETRIC" | tk="AT" | tk="AUTHORIZATION" | tk="AUTO" | tk="AUTO_INCREMENT" | tk="AZURE" | tk="BASE64" | tk="BEGIN" | tk="BERNOULLI" | tk="BINARY" | tk="BIT" | tk="BLOBSTORAGE" | tk="BLOCK" | tk="BOOLEAN" | tk="BROWSE" | tk="BUFFERS" | tk="BY" | tk="BYTE" | tk="BYTES" | tk="CACHE" | tk="CALL" | tk="CASCADE" | tk="CASE" | tk="CAST" | tk="CERTIFICATE" | tk="CHANGE" | tk="CHANGES" | tk="CHAR" | tk="CHARACTER" | tk="CHECKPOINT" | tk="CLOSE" | tk="CLOUD" | tk="COALESCE" | tk="COLLATE" | tk="COLUMN" | tk="COLUMNS" | tk="COMMENT" | tk="COMMENTS" | tk="COMMIT" | tk="CONCURRENTLY" | tk="CONFLICT" | tk="CONSTRAINTS" | tk="CONVERT" | tk="CORRESPONDING" | tk="COSTS" | tk="COUNT" | tk="CREATED" | tk="CS" | tk="CYCLE" | tk="DATA" | tk="DATABASE" | tk="DATETIME" | tk="DBA_RECYCLEBIN" | tk="DDL" | tk="DECLARE" | tk="DEFAULTS" | tk="DEFERRABLE" | tk="DELAYED" | tk="DELETE" | tk="DELIMIT" | tk="DELIMITER" | tk="DESC" | tk="DESCRIBE" | tk="DISABLE" | tk="DISCARD" | tk="DISCONNECT" | tk="DIV" | tk="DML" | tk="DO" | tk="DOMAIN" | tk="DRIVER" | tk="DROP" | tk="DUMP" | tk="DUPLICATE" | tk="ELEMENTS" | tk="EMIT" | tk="ENABLE" | tk="ENCODING" | tk="ENCRYPTION" | tk="END" | tk="ENFORCED" | tk="ENGINE" | tk="ERROR" | tk="ESCAPE" | tk="EXA" | tk="EXCHANGE" | tk="EXCLUDE" | tk="EXCLUDING" | tk="EXEC" | tk="EXECUTE" | tk="EXPLAIN" | tk="EXPLICIT" | tk="EXPORT" | tk="EXTENDED" | tk="EXTRACT" | tk="FILTER" | tk="FIRST" | tk="FLUSH" | tk="FN" | tk="FOLLOWING" | tk="FORMAT" | tk="FULLTEXT" | tk="FUNCTION" | tk="GRANT" | tk="GROUP_CONCAT" | tk="GUARD" | tk="HASH" | tk="HIGH" | tk="HIGH_PRIORITY" | tk="HISTORY" | tk="HOPPING" | tk="IDENTIFIED" | tk="IDENTITY" | tk="INCLUDE" | tk="INCLUDE_NULL_VALUES" | tk="INCLUDING" | tk="INCREMENT" | tk="INDEX" | tk="INSERT" | tk="INTERLEAVE" | tk="INTERPRET" | tk="INVALIDATE" | tk="INVERSE" | tk="INVISIBLE" | tk="ISNULL" | tk="JDBC" | tk="JSON" | tk="JSON_ARRAY" | tk="JSON_ARRAYAGG" | tk="JSON_OBJECT" | tk="JSON_OBJECTAGG" | tk="KEEP" | tk="KEY" | tk="KEYS" | tk="KEY_BLOCK_SIZE" | tk="KILL" | tk="LAST" | tk="LEADING" | tk="LESS" | tk="LINK" | tk="LOCAL" | tk="LOCK" | tk="LOCKED" | tk="LOG" | tk="LONGTEXT" | tk="LOOP" | tk="LOW" | tk="LOW_PRIORITY" | tk="LTRIM" | tk="MATCH" | tk="MATCHED" | tk="MATCH_ALL" | tk="MATCH_ANY" | tk="MATCH_PHRASE" | tk="MATCH_PHRASE_PREFIX" | tk="MATCH_REGEXP" | tk="MATERIALIZED" | tk="MAX" | tk="MAXVALUE" | tk="MEDIUMTEXT" | tk="MEMBER" | tk="MERGE" | tk="MIN" | tk="MINVALUE" | tk="MODIFY" | tk="MOVEMENT" | tk="NAME" | tk="NAMES" | tk="NEVER" | tk="NEXT" | tk="NO" | tk="NOCACHE" | tk="NOKEEP" | tk="NOLOCK" | tk="NOMAXVALUE" | tk="NOMINVALUE" | tk="NONE" | tk="NOORDER" | tk="NOTHING" | tk="NOTNULL" | tk="NOVALIDATE" | tk="NOWAIT" | tk="NULLS" | tk="OF" | tk="OFF" | tk="OPEN" | tk="ORA" | tk="ORDINALITY" | tk="OVER" | tk="OVERFLOW" | tk="OVERLAPS" | tk="OVERRIDING" | tk="OVERWRITE" | tk="PADDING" | tk="PARALLEL" | tk="PARENT" | tk="PARSER" | tk="PARTITION" | tk="PARTITIONING" | tk="PATH" | tk="PERCENT" | tk="PLACING" | tk="PLAN" | tk="PLUS" | tk="PRECEDING" | tk="PRIMARY" | tk="PURGE" | tk="QUERY" | tk="QUICK" | tk="QUIESCE" | tk="RANGE" | tk="RAW" | tk="READ" | tk="REBUILD" | tk="RECURSIVE" | tk="RECYCLEBIN" | tk="REFERENCES" | tk="REFRESH" | tk="REGEXP" | tk="REGEXP_LIKE" | tk="REGISTER" | tk="REJECT" | tk="REMOTE" | tk="REMOVE" | tk="RENAME" | tk="REORGANIZE" | tk="REPAIR" | tk="REPEATABLE" | tk="REPLACE" | tk="RESET" | tk="RESPECT" | tk="RESTART" | tk="RESTRICT" | tk="RESTRICTED" | tk="RESUMABLE" | tk="RESUME" | tk="RETURN" | tk="RLIKE" | tk="ROLLBACK" | tk="ROLLUP" | tk="ROOT" | tk="ROW" | tk="ROWS" | tk="RR" | tk="RS" | tk="RTRIM" | tk="SAFE_CAST" | tk="SAVEPOINT" | tk="SCHEMA" | tk="SECURE" | tk="SEED" | tk="SEPARATOR" | tk="SEQUENCE" | tk="SESSION" | tk="SETS" | tk="SHARE" | tk="SHOW" | tk="SHUTDOWN" | tk="SIBLINGS" | tk="SIGNED" | tk="SIMILAR" | tk="SIZE" | tk="SKIP" | tk="SPATIAL" | tk="STORED" | tk="STRICT" | tk="STRING" | tk="STRUCT" | tk="SUMMARIZE" | tk="SUSPEND" | tk="SWITCH" | tk="SYMMETRIC" | tk="SYNONYM" | tk="SYSTEM" | tk="TABLE" | tk="TABLESPACE" | tk="TEMP" | tk="TEMPORARY" | tk="TEXT" | tk="THAN" | tk="THEN" | tk="TIMEOUT" | tk="TIMESTAMPTZ" | tk="TIMEZONE" | tk="TINYTEXT" | tk="TO" | tk="TRIGGER" | tk="TRUNCATE" | tk="TRY_CAST" | tk="TUMBLING" | tk="TYPE" | tk="UNLIMITED" | tk="UNLOGGED" | tk="UNQIESCE" | tk="UNSIGNED" | tk="UPDATE" | tk="UPSERT" | tk="UR" | tk="USER" | tk="VALIDATE" | tk="VALIDATION" | tk="VERBOSE" | tk="VIEW" | tk="VISIBLE" | tk="VOLATILE" | tk="WAIT" | tk="WITHIN" | tk="WITHOUT" | tk="WITHOUT_ARRAY_WRAPPER" | tk="WORK" | tk="XML" | tk="XMLAGG" | tk="XMLDATA" | tk="XMLSCHEMA" | tk="XMLTEXT" | tk="XSINIL" | tk="YAML" | tk="YES" | tk="ZONE" ) { return tk.image; } } @@ -3778,6 +4661,8 @@ FromItem FromItem() #FromItem: | fromItem=LateralSubSelect() | + LOOKAHEAD(2, { Dialect.EXASOL.name().equals(getAsString(Feature.dialect)) }) fromItem=SubImport() { fromItem = new ParenthesedFromItem(fromItem); } + | LOOKAHEAD({ getAsBoolean(Feature.allowUnparenthesizedSubSelects) }) fromItem=Select() ) @@ -7198,12 +8083,12 @@ ColDataType DataType(): | ( ( tk= | tk= | tk = | tk = | tk = - | tk= | tk= | tk= | tk= + | tk= | tk= | tk= | tk= | tk= | tk= | tk= | tk= ) { type = tk.image; } [ // MySQL seems to allow: INT UNSIGNED LOOKAHEAD(2) ( LOOKAHEAD(2) ( tk = | tk = | tk = - | tk= | tk= | tk= | tk= + | tk= | tk= | tk= | tk= | tk= | tk= | tk= | tk= ) { type += " " + tk.image; } )+ ] [ @@ -7464,7 +8349,7 @@ List CreateParameter(): | tk= | tk= | tk= | tk= | tk= | tk= | tk= | tk= | tk= | tk= | tk= | tk= | tk= | tk= | tk= | tk= | tk = | tk = - | tk= + | tk= | tk= | tk="=" ) { param.add(tk.image); } diff --git a/src/site/sphinx/keywords.rst b/src/site/sphinx/keywords.rst index 93842cc27..933cba664 100644 --- a/src/site/sphinx/keywords.rst +++ b/src/site/sphinx/keywords.rst @@ -29,6 +29,8 @@ The following Keywords are **restricted** in JSQLParser-|JSQLPARSER_VERSION| and +----------------------+-------------+-----------+ | CONNECT_BY_ROOT | Yes | Yes | +----------------------+-------------+-----------+ +| CSV | Yes | Yes | ++----------------------+-------------+-----------+ | PRIOR | Yes | Yes | +----------------------+-------------+-----------+ | CONSTRAINT | Yes | Yes | @@ -49,6 +51,8 @@ The following Keywords are **restricted** in JSQLParser-|JSQLPARSER_VERSION| and +----------------------+-------------+-----------+ | ELSE | Yes | Yes | +----------------------+-------------+-----------+ +| ERRORS | Yes | Yes | ++----------------------+-------------+-----------+ | EXCEPT | Yes | Yes | +----------------------+-------------+-----------+ | EXCLUDES | Yes | Yes | @@ -59,8 +63,12 @@ The following Keywords are **restricted** in JSQLParser-|JSQLPARSER_VERSION| and +----------------------+-------------+-----------+ | FALSE | Yes | Yes | +----------------------+-------------+-----------+ +| FBV | Yes | Yes | ++----------------------+-------------+-----------+ | FETCH | Yes | Yes | +----------------------+-------------+-----------+ +| FILE | Yes | Yes | ++----------------------+-------------+-----------+ | FINAL | Yes | Yes | +----------------------+-------------+-----------+ | FOR | Yes | Yes | @@ -91,6 +99,8 @@ The following Keywords are **restricted** in JSQLParser-|JSQLPARSER_VERSION| and +----------------------+-------------+-----------+ | ILIKE | Yes | Yes | +----------------------+-------------+-----------+ +| IMPORT | Yes | Yes | ++----------------------+-------------+-----------+ | IN | Yes | Yes | +----------------------+-------------+-----------+ | INCLUDES | Yes | Yes | @@ -161,6 +171,8 @@ The following Keywords are **restricted** in JSQLParser-|JSQLPARSER_VERSION| and +----------------------+-------------+-----------+ | SAMPLE | Yes | | +----------------------+-------------+-----------+ +| SCRIPT | Yes | Yes | ++----------------------+-------------+-----------+ | SEL | Yes | | +----------------------+-------------+-----------+ | SELECT | Yes | | @@ -173,6 +185,8 @@ The following Keywords are **restricted** in JSQLParser-|JSQLPARSER_VERSION| and +----------------------+-------------+-----------+ | START | Yes | Yes | +----------------------+-------------+-----------+ +| STATEMENT | Yes | Yes | ++----------------------+-------------+-----------+ | TABLES | Yes | | +----------------------+-------------+-----------+ | TOP | Yes | Yes | @@ -211,6 +225,8 @@ The following Keywords are **restricted** in JSQLParser-|JSQLPARSER_VERSION| and +----------------------+-------------+-----------+ | VARYING | Yes | Yes | +----------------------+-------------+-----------+ +| VERIFY | Yes | Yes | ++----------------------+-------------+-----------+ | WHEN | Yes | Yes | +----------------------+-------------+-----------+ | WHERE | Yes | Yes | diff --git a/src/test/java/net/sf/jsqlparser/expression/FunctionTest.java b/src/test/java/net/sf/jsqlparser/expression/FunctionTest.java index 0433222d3..8f3daf474 100644 --- a/src/test/java/net/sf/jsqlparser/expression/FunctionTest.java +++ b/src/test/java/net/sf/jsqlparser/expression/FunctionTest.java @@ -108,4 +108,15 @@ void testSimpleFunctionIssue2059() throws JSQLParserException { void testListAggOnOverflow(String sqlStr) throws Exception { TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); } + + @ParameterizedTest + @ValueSource(strings = { + "select RTRIM('string')", + "select LTRIM('string')", + "select RTRIM(field) from dual", + "select LTRIM(field) from dual" + }) + void testTrimFunctions(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); + } } diff --git a/src/test/java/net/sf/jsqlparser/statement/export/ExportTest.java b/src/test/java/net/sf/jsqlparser/statement/export/ExportTest.java new file mode 100644 index 000000000..1d158b975 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/export/ExportTest.java @@ -0,0 +1,272 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2019 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.export; + +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.test.TestUtils; +import org.junit.jupiter.api.parallel.Execution; +import org.junit.jupiter.api.parallel.ExecutionMode; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +@Execution(ExecutionMode.CONCURRENT) +public class ExportTest { + @ParameterizedTest + @ValueSource(strings = { + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv'", + "EXPORT schemaName.tableName ( columnName ) INTO LOCAL CSV FILE 'file.csv'", + "EXPORT schemaName.tableName ( columnName1, columnName2 ) INTO LOCAL CSV FILE 'file.csv'", + + "EXPORT ( select 1 ) INTO LOCAL CSV FILE 'file.csv'", + }) + public void testExport(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv'", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file1.csv' FILE 'file2.csv'", + + "EXPORT schemaName.tableName INTO LOCAL SECURE CSV FILE 'file.csv'", + "EXPORT schemaName.tableName INTO LOCAL SECURE CSV FILE 'file1.csv' FILE 'file2.csv'" + }) + public void testExportIntoFileCSV(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ( 1 )", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ( 1, 2 )", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ( 1 FORMAT = 'format' )", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ( 1 DELIMIT = ALWAYS )", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ( 1 DELIMIT = NEVER )", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ( 1 DELIMIT = AUTO )", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ( 1 FORMAT = 'format', 2 DELIMIT = NEVER )", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ( 1 FORMAT = 'format', 2 DELIMIT = NEVER, 3 FORMAT = 'format' DELIMIT = ALWAYS )", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ( 1 .. 2 )", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ( 1, 1 .. 2 )", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ( 1, 1 .. 2, 3 )" + }) + public void testExportIntoFileCSVCols(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "EXPORT schemaName.tableName INTO LOCAL FBV FILE 'file.fbv'", + "EXPORT schemaName.tableName INTO LOCAL FBV FILE 'file1.fbv' FILE 'file2.fbv'", + + "EXPORT schemaName.tableName INTO LOCAL SECURE FBV FILE 'file.fbv'", + "EXPORT schemaName.tableName INTO LOCAL SECURE FBV FILE 'file1.fbv' FILE 'file2.fbv'" + }) + public void testExportIntoFileFBV(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "EXPORT schemaName.tableName INTO LOCAL FBV FILE 'file.fbv' ( SIZE = 1 )", + "EXPORT schemaName.tableName INTO LOCAL FBV FILE 'file.fbv' ( FORMAT = 'format' )", + "EXPORT schemaName.tableName INTO LOCAL FBV FILE 'file.fbv' ( ALIGN = LEFT )", + "EXPORT schemaName.tableName INTO LOCAL FBV FILE 'file.fbv' ( ALIGN = RIGHT )", + "EXPORT schemaName.tableName INTO LOCAL FBV FILE 'file.fbv' ( PADDING = '0' )", + + "EXPORT schemaName.tableName INTO LOCAL FBV FILE 'file.fbv' ( SIZE = 1, PADDING = '0' )", + "EXPORT schemaName.tableName INTO LOCAL FBV FILE 'file.fbv' ( SIZE = 1 PADDING = '0' )", + "EXPORT schemaName.tableName INTO LOCAL FBV FILE 'file.fbv' ( SIZE = 1 PADDING = '0', FORMAT = 'format' )" + }) + public void testExportIntoFileFBVCols(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ENCODING = 'UTF-8'", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' REPLACE", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' TRUNCATE", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' NULL = 'null'", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' BOOLEAN = 'yes/no'", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ROW SEPARATOR = 'CRLF'", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' COLUMN SEPARATOR = ','", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' COLUMN DELIMITER = '\"'", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' DELIMIT = ALWAYS", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' DELIMIT = NEVER", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' DELIMIT = AUTO", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' WITH COLUMN NAMES", + + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ENCODING = 'UTF-8' REPLACE", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ENCODING = 'UTF-8' REPLACE WITH COLUMN NAMES" + }) + public void testExportIntoFileFileOpts(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' VERIFY CERTIFICATE", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' IGNORE CERTIFICATE", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' PUBLIC KEY 'publicKey'", + + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' VERIFY CERTIFICATE PUBLIC KEY 'publicKey'", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' IGNORE CERTIFICATE PUBLIC KEY 'publicKey'" + }) + public void testExportIntoFileCertVerification(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "EXPORT schemaName.tableName INTO CSV AT connectionName FILE 'file.csv'", + "EXPORT schemaName.tableName INTO CSV AT '127.0.0.1' FILE 'file.csv'", + + "EXPORT schemaName.tableName INTO CSV AT connectionName USER 'user' IDENTIFIED BY 'password' FILE 'file.csv'", + "EXPORT schemaName.tableName INTO CSV AT '127.0.0.1' USER 'user' IDENTIFIED BY 'password' FILE 'file.csv'", + + "EXPORT schemaName.tableName INTO CSV AT connectionName IGNORE CERTIFICATE FILE 'file.csv'", + "EXPORT schemaName.tableName INTO CSV AT connectionName VERIFY CERTIFICATE FILE 'file.csv'", + "EXPORT schemaName.tableName INTO CSV AT connectionName PUBLIC KEY 'publicKey' FILE 'file.csv'", + "EXPORT schemaName.tableName INTO CSV AT connectionName IGNORE CERTIFICATE PUBLIC KEY 'publicKey' FILE 'file.csv'", + "EXPORT schemaName.tableName INTO CSV AT connectionName VERIFY CERTIFICATE PUBLIC KEY 'publicKey' FILE 'file.csv'", + + "EXPORT schemaName.tableName INTO CSV AT connectionName USER 'user' IDENTIFIED BY 'password' IGNORE CERTIFICATE FILE 'file.csv'", + "EXPORT schemaName.tableName INTO CSV AT '127.0.0.1' USER 'user' IDENTIFIED BY 'password' IGNORE CERTIFICATE FILE 'file.csv'", + "EXPORT schemaName.tableName INTO CSV AT connectionName USER 'user' IDENTIFIED BY 'password' VERIFY CERTIFICATE FILE 'file.csv'", + "EXPORT schemaName.tableName INTO CSV AT '127.0.0.1' USER 'user' IDENTIFIED BY 'password' VERIFY CERTIFICATE FILE 'file.csv'", + "EXPORT schemaName.tableName INTO CSV AT connectionName USER 'user' IDENTIFIED BY 'password' PUBLIC KEY 'publicKey' FILE 'file.csv'", + "EXPORT schemaName.tableName INTO CSV AT '127.0.0.1' USER 'user' IDENTIFIED BY 'password' PUBLIC KEY 'publicKey' FILE 'file.csv'", + "EXPORT schemaName.tableName INTO CSV AT connectionName USER 'user' IDENTIFIED BY 'password' IGNORE CERTIFICATE PUBLIC KEY 'publicKey' FILE 'file.csv'", + "EXPORT schemaName.tableName INTO CSV AT '127.0.0.1' USER 'user' IDENTIFIED BY 'password' IGNORE CERTIFICATE PUBLIC KEY 'publicKey' FILE 'file.csv'", + "EXPORT schemaName.tableName INTO CSV AT connectionName USER 'user' IDENTIFIED BY 'password' VERIFY CERTIFICATE PUBLIC KEY 'publicKey' FILE 'file.csv'", + "EXPORT schemaName.tableName INTO CSV AT '127.0.0.1' USER 'user' IDENTIFIED BY 'password' VERIFY CERTIFICATE PUBLIC KEY 'publicKey' FILE 'file.csv'" + }) + public void testExportIntoConnectionDef(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "EXPORT schemaName.tableName INTO CSV AT CLOUD NONE connectionName FILE 'file.csv'", + "EXPORT schemaName.tableName INTO CSV AT CLOUD NONE '127.0.0.1' FILE 'file.csv'", + "EXPORT schemaName.tableName INTO CSV AT CLOUD NONE connectionName USER 'user' IDENTIFIED BY 'password' FILE 'file.csv'", + "EXPORT schemaName.tableName INTO CSV AT CLOUD NONE '127.0.0.1' USER 'user' IDENTIFIED BY 'password' FILE 'file.csv'", + "EXPORT schemaName.tableName INTO CSV AT CLOUD AZURE BLOBSTORAGE connectionName FILE 'file.csv'", + "EXPORT schemaName.tableName INTO CSV AT CLOUD AZURE BLOBSTORAGE '127.0.0.1' FILE 'file.csv'", + "EXPORT schemaName.tableName INTO CSV AT CLOUD AZURE BLOBSTORAGE connectionName USER 'user' IDENTIFIED BY 'password' FILE 'file.csv'", + "EXPORT schemaName.tableName INTO CSV AT CLOUD AZURE BLOBSTORAGE '127.0.0.1' USER 'user' IDENTIFIED BY 'password' FILE 'file.csv'" + }) + public void testExportIntoCloudConnectionDef(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "EXPORT schemaName.tableName INTO EXA AT connectionName TABLE schemaName.tableName", + "EXPORT schemaName.tableName INTO EXA AT connectionName TABLE schemaName.tableName ( columnName )", + "EXPORT schemaName.tableName INTO EXA AT connectionName TABLE schemaName.tableName ( columnName1, columnName2 )", + + "EXPORT schemaName.tableName INTO EXA AT connectionName TABLE schemaName.tableName REPLACE", + "EXPORT schemaName.tableName INTO EXA AT connectionName TABLE schemaName.tableName TRUNCATE", + "EXPORT schemaName.tableName INTO EXA AT connectionName TABLE schemaName.tableName CREATED BY 'CREATE OR REPLACE TABLE schemaName (columnName INTEGER)'", + + "EXPORT schemaName.tableName INTO EXA AT connectionName TABLE schemaName.tableName REPLACE TRUNCATE", + "EXPORT schemaName.tableName INTO EXA AT connectionName TABLE schemaName.tableName ( columnName ) REPLACE TRUNCATE", + "EXPORT schemaName.tableName INTO EXA AT connectionName TABLE schemaName.tableName ( columnName1, columnName2 ) REPLACE TRUNCATE", + + "EXPORT schemaName.tableName INTO EXA AT connectionName STATEMENT 'insert into schemaName.tableName ( columnName ) values ( ? )'" + }) + public void testExportIntoDBMSEXA(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "EXPORT schemaName.tableName INTO ORA AT connectionName TABLE schemaName.tableName", + "EXPORT schemaName.tableName INTO ORA AT connectionName TABLE schemaName.tableName ( columnName )", + "EXPORT schemaName.tableName INTO ORA AT connectionName TABLE schemaName.tableName ( columnName1, columnName2 )", + + "EXPORT schemaName.tableName INTO ORA AT connectionName STATEMENT 'insert into schemaName.tableName ( columnName ) values ( ? )'" + }) + public void testExportIntoDBMSORA(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "EXPORT schemaName.tableName INTO JDBC AT connectionName TABLE tableName", + "EXPORT schemaName.tableName INTO JDBC DRIVER = 'driverName' AT connectionName TABLE tableName" + }) + public void testExportIntoDBMSJDBC(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "EXPORT schemaName.tableName INTO SCRIPT scriptName", + "EXPORT schemaName.tableName INTO SCRIPT scriptName AT connectionName", + "EXPORT schemaName.tableName INTO SCRIPT scriptName WITH propertyName = 'value'", + "EXPORT schemaName.tableName INTO SCRIPT scriptName WITH propertyName = 'value' propertyName2 = 'value2'", + "EXPORT schemaName.tableName INTO SCRIPT scriptName AT connectionName WITH propertyName = 'value' propertyName2 = 'value2'" + }) + public void testExportIntoScript(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' REJECT LIMIT 1", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' REJECT LIMIT UNLIMITED", + + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' REJECT LIMIT 1 ERRORS", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' REJECT LIMIT UNLIMITED ERRORS", + + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ERRORS INTO CSV AT connectionName FILE 'file.csv'", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ERRORS INTO LOCAL CSV FILE 'file.csv'", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ERRORS INTO LOCAL SECURE CSV FILE 'file.csv'", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ERRORS INTO schemaName.tableName", + + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ERRORS INTO CSV AT connectionName FILE 'file.csv' REJECT LIMIT 1", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ERRORS INTO LOCAL CSV FILE 'file.csv' REJECT LIMIT 1", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ERRORS INTO LOCAL SECURE CSV FILE 'file.csv' REJECT LIMIT 1", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ERRORS INTO schemaName.tableName REJECT LIMIT 1", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ERRORS INTO CSV AT connectionName FILE 'file.csv' REJECT LIMIT 1 ERRORS", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ERRORS INTO LOCAL CSV FILE 'file.csv' REJECT LIMIT 1 ERRORS", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ERRORS INTO LOCAL SECURE CSV FILE 'file.csv' REJECT LIMIT 1 ERRORS", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ERRORS INTO schemaName.tableName REJECT LIMIT 1 ERRORS", + + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ERRORS INTO CSV AT connectionName FILE 'file.csv' REJECT LIMIT UNLIMITED", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ERRORS INTO LOCAL CSV FILE 'file.csv' REJECT LIMIT UNLIMITED", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ERRORS INTO LOCAL SECURE CSV FILE 'file.csv' REJECT LIMIT UNLIMITED", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ERRORS INTO schemaName.tableName REJECT LIMIT UNLIMITED", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ERRORS INTO CSV AT connectionName FILE 'file.csv' REJECT LIMIT UNLIMITED ERRORS", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ERRORS INTO LOCAL CSV FILE 'file.csv' REJECT LIMIT UNLIMITED ERRORS", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ERRORS INTO LOCAL SECURE CSV FILE 'file.csv' REJECT LIMIT UNLIMITED ERRORS", + "EXPORT schemaName.tableName INTO LOCAL CSV FILE 'file.csv' ERRORS INTO schemaName.tableName REJECT LIMIT UNLIMITED ERRORS" + }) + public void testImportErrorClause(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/imprt/ImportTest.java b/src/test/java/net/sf/jsqlparser/statement/imprt/ImportTest.java new file mode 100644 index 000000000..1539d4375 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/imprt/ImportTest.java @@ -0,0 +1,281 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2019 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.imprt; + +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.test.TestUtils; +import org.junit.jupiter.api.parallel.Execution; +import org.junit.jupiter.api.parallel.ExecutionMode; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +@Execution(ExecutionMode.CONCURRENT) +public class ImportTest { + @ParameterizedTest + @ValueSource(strings = { + "IMPORT INTO schemaName.tableName FROM LOCAL CSV FILE 'file.csv'", + "IMPORT INTO schemaName.tableName ( columnName ) FROM LOCAL CSV FILE 'file.csv'", + "IMPORT INTO schemaName.tableName ( columnName1, columnName2 ) FROM LOCAL CSV FILE 'file.csv'" + }) + public void testImportIntoTable(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "IMPORT INTO ( columnName integer ) FROM LOCAL CSV FILE 'file.csv'", + "IMPORT INTO ( columnName1 integer, columnName2 varchar(100) ) FROM LOCAL CSV FILE 'file.csv'", + + "IMPORT INTO ( LIKE schemaName.tableName ) FROM LOCAL CSV FILE 'file.csv'", + "IMPORT INTO ( LIKE schemaName.tableName ( columnName ) ) FROM LOCAL CSV FILE 'file.csv'", + "IMPORT INTO ( LIKE schemaName.tableName ( columnName1, columnName2 ) ) FROM LOCAL CSV FILE 'file.csv'", + "IMPORT INTO ( LIKE schemaName.tableName ( columnName AS aliasName ) ) FROM LOCAL CSV FILE 'file.csv'", + "IMPORT INTO ( LIKE schemaName.tableName ( columnName aliasName ) ) FROM LOCAL CSV FILE 'file.csv'", + "IMPORT INTO ( LIKE schemaName.tableName ( columnName1 AS aliasName2, columnName2 AS aliasName2 ) ) FROM LOCAL CSV FILE 'file.csv'" + }) + public void testImportIntoImportColumns(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "IMPORT FROM LOCAL CSV FILE 'file.csv'", + "IMPORT FROM LOCAL CSV FILE 'file1.csv' FILE 'file2.csv'", + + "IMPORT FROM LOCAL SECURE CSV FILE 'file.csv'", + "IMPORT FROM LOCAL SECURE CSV FILE 'file1.csv' FILE 'file2.csv'" + }) + public void testImportFromFileCSV(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "IMPORT FROM LOCAL CSV FILE 'file.csv' ( 1 )", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ( 1, 2 )", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ( 1 FORMAT = 'format' )", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ( 1 FORMAT = 'format', 2 FORMAT = 'format' )", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ( 1 .. 2 )", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ( 1, 1 .. 2 )", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ( 1, 1 .. 2, 3 )" + }) + public void testImportFromFileCSVCols(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "IMPORT FROM LOCAL FBV FILE 'file.fbv'", + "IMPORT FROM LOCAL FBV FILE 'file1.fbv' FILE 'file2.fbv'", + + "IMPORT FROM LOCAL SECURE FBV FILE 'file.fbv'", + "IMPORT FROM LOCAL SECURE FBV FILE 'file1.fbv' FILE 'file2.fbv'" + }) + public void testImportFromFileFBV(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "IMPORT FROM LOCAL FBV FILE 'file.fbv' ( SIZE = 1 )", + "IMPORT FROM LOCAL FBV FILE 'file.fbv' ( START = 1 )", + "IMPORT FROM LOCAL FBV FILE 'file.fbv' ( FORMAT = 'format' )", + "IMPORT FROM LOCAL FBV FILE 'file.fbv' ( ALIGN = LEFT )", + "IMPORT FROM LOCAL FBV FILE 'file.fbv' ( ALIGN = RIGHT )", + "IMPORT FROM LOCAL FBV FILE 'file.fbv' ( PADDING = 'padding' )", + + "IMPORT FROM LOCAL FBV FILE 'file.fbv' ( SIZE = 1, START = 1 )", + "IMPORT FROM LOCAL FBV FILE 'file.fbv' ( SIZE = 1 START = 1 )", + "IMPORT FROM LOCAL FBV FILE 'file.fbv' ( SIZE = 1 START = 1, FORMAT = 'format' )" + }) + public void testImportFromFileFBVCols(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "IMPORT FROM LOCAL CSV FILE 'file.csv' ENCODING = 'UTF-8'", + "IMPORT FROM LOCAL CSV FILE 'file.csv' SKIP = 1", + "IMPORT FROM LOCAL CSV FILE 'file.csv' TRIM", + "IMPORT FROM LOCAL CSV FILE 'file.csv' LTRIM", + "IMPORT FROM LOCAL CSV FILE 'file.csv' RTRIM", + "IMPORT FROM LOCAL CSV FILE 'file.csv' NULL = 'null'", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ROW SEPARATOR = 'CRLF'", + "IMPORT FROM LOCAL CSV FILE 'file.csv' COLUMN SEPARATOR = ','", + "IMPORT FROM LOCAL CSV FILE 'file.csv' COLUMN DELIMITER = '\"'", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ROW SIZE = 1", + + "IMPORT FROM LOCAL CSV FILE 'file.csv' ENCODING = 'UTF-8' SKIP = 1", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ENCODING = 'UTF-8' SKIP = 1 TRIM" + }) + public void testImportFromFileFileOpts(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "IMPORT FROM LOCAL CSV FILE 'file.csv' VERIFY CERTIFICATE", + "IMPORT FROM LOCAL CSV FILE 'file.csv' IGNORE CERTIFICATE", + "IMPORT FROM LOCAL CSV FILE 'file.csv' PUBLIC KEY 'publicKey'", + + "IMPORT FROM LOCAL CSV FILE 'file.csv' VERIFY CERTIFICATE PUBLIC KEY 'publicKey'", + "IMPORT FROM LOCAL CSV FILE 'file.csv' IGNORE CERTIFICATE PUBLIC KEY 'publicKey'" + }) + public void testImportFromFileCertVerification(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "IMPORT FROM CSV AT connectionName FILE 'file.csv'", + "IMPORT FROM CSV AT '127.0.0.1' FILE 'file.csv'", + + "IMPORT FROM CSV AT connectionName USER 'user' IDENTIFIED BY 'password' FILE 'file.csv'", + "IMPORT FROM CSV AT '127.0.0.1' USER 'user' IDENTIFIED BY 'password' FILE 'file.csv'", + + "IMPORT FROM CSV AT connectionName IGNORE CERTIFICATE FILE 'file.csv'", + "IMPORT FROM CSV AT connectionName VERIFY CERTIFICATE FILE 'file.csv'", + "IMPORT FROM CSV AT connectionName PUBLIC KEY 'publicKey' FILE 'file.csv'", + "IMPORT FROM CSV AT connectionName IGNORE CERTIFICATE PUBLIC KEY 'publicKey' FILE 'file.csv'", + "IMPORT FROM CSV AT connectionName VERIFY CERTIFICATE PUBLIC KEY 'publicKey' FILE 'file.csv'", + + "IMPORT FROM CSV AT connectionName USER 'user' IDENTIFIED BY 'password' IGNORE CERTIFICATE FILE 'file.csv'", + "IMPORT FROM CSV AT '127.0.0.1' USER 'user' IDENTIFIED BY 'password' IGNORE CERTIFICATE FILE 'file.csv'", + "IMPORT FROM CSV AT connectionName USER 'user' IDENTIFIED BY 'password' VERIFY CERTIFICATE FILE 'file.csv'", + "IMPORT FROM CSV AT '127.0.0.1' USER 'user' IDENTIFIED BY 'password' VERIFY CERTIFICATE FILE 'file.csv'", + "IMPORT FROM CSV AT connectionName USER 'user' IDENTIFIED BY 'password' PUBLIC KEY 'publicKey' FILE 'file.csv'", + "IMPORT FROM CSV AT '127.0.0.1' USER 'user' IDENTIFIED BY 'password' PUBLIC KEY 'publicKey' FILE 'file.csv'", + "IMPORT FROM CSV AT connectionName USER 'user' IDENTIFIED BY 'password' IGNORE CERTIFICATE PUBLIC KEY 'publicKey' FILE 'file.csv'", + "IMPORT FROM CSV AT '127.0.0.1' USER 'user' IDENTIFIED BY 'password' IGNORE CERTIFICATE PUBLIC KEY 'publicKey' FILE 'file.csv'", + "IMPORT FROM CSV AT connectionName USER 'user' IDENTIFIED BY 'password' VERIFY CERTIFICATE PUBLIC KEY 'publicKey' FILE 'file.csv'", + "IMPORT FROM CSV AT '127.0.0.1' USER 'user' IDENTIFIED BY 'password' VERIFY CERTIFICATE PUBLIC KEY 'publicKey' FILE 'file.csv'" + }) + public void testImportFromConnectionDef(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "IMPORT FROM CSV AT CLOUD NONE connectionName FILE 'file.csv'", + "IMPORT FROM CSV AT CLOUD NONE '127.0.0.1' FILE 'file.csv'", + "IMPORT FROM CSV AT CLOUD NONE connectionName USER 'user' IDENTIFIED BY 'password' FILE 'file.csv'", + "IMPORT FROM CSV AT CLOUD NONE '127.0.0.1' USER 'user' IDENTIFIED BY 'password' FILE 'file.csv'", + "IMPORT FROM CSV AT CLOUD AZURE BLOBSTORAGE connectionName FILE 'file.csv'", + "IMPORT FROM CSV AT CLOUD AZURE BLOBSTORAGE '127.0.0.1' FILE 'file.csv'", + "IMPORT FROM CSV AT CLOUD AZURE BLOBSTORAGE connectionName USER 'user' IDENTIFIED BY 'password' FILE 'file.csv'", + "IMPORT FROM CSV AT CLOUD AZURE BLOBSTORAGE '127.0.0.1' USER 'user' IDENTIFIED BY 'password' FILE 'file.csv'" + }) + public void testImportFromCloudConnectionDef(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "IMPORT FROM EXA AT connectionName TABLE schemaName.tableName", + "IMPORT FROM EXA AT connectionName TABLE schemaName.tableName ( columnName )", + "IMPORT FROM EXA AT connectionName TABLE schemaName.tableName ( columnName1, columnName2 )", + + "IMPORT FROM EXA AT connectionName STATEMENT 'select 1'", + "IMPORT FROM EXA AT connectionName STATEMENT 'select 1' STATEMENT 'select 2'" + }) + public void testImportFromDBMSEXA(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "IMPORT FROM ORA AT connectionName TABLE schemaName.tableName", + "IMPORT FROM ORA AT connectionName TABLE schemaName.tableName ( columnName )", + "IMPORT FROM ORA AT connectionName TABLE schemaName.tableName ( columnName1, columnName2 )", + + "IMPORT FROM ORA AT connectionName STATEMENT 'select 1'", + "IMPORT FROM ORA AT connectionName STATEMENT 'select 1' STATEMENT 'select 2'" + }) + public void testImportFromDBMSORA(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "IMPORT FROM JDBC AT connectionName TABLE tableName", + "IMPORT FROM JDBC DRIVER = 'driverName' AT connectionName TABLE tableName", + + "IMPORT FROM JDBC AT connectionName STATEMENT 'select 1'", + "IMPORT FROM JDBC AT connectionName STATEMENT 'select 1' STATEMENT 'select 2'", + "IMPORT FROM JDBC DRIVER = 'driverName' AT connectionName STATEMENT 'select 1'", + "IMPORT FROM JDBC DRIVER = 'driverName' AT connectionName STATEMENT 'select 1' STATEMENT 'select 2'" + }) + public void testImportFromDBMSJDBC(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "IMPORT FROM SCRIPT scriptName", + "IMPORT FROM SCRIPT scriptName AT connectionName", + "IMPORT FROM SCRIPT scriptName WITH propertyName = 'value'", + "IMPORT FROM SCRIPT scriptName WITH propertyName = 'value' propertyName2 = 'value2'", + "IMPORT FROM SCRIPT scriptName AT connectionName WITH propertyName = 'value' propertyName2 = 'value2'" + }) + public void testImportFromScript(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "IMPORT FROM LOCAL CSV FILE 'file.csv' REJECT LIMIT 1", + "IMPORT FROM LOCAL CSV FILE 'file.csv' REJECT LIMIT UNLIMITED", + + "IMPORT FROM LOCAL CSV FILE 'file.csv' REJECT LIMIT 1 ERRORS", + "IMPORT FROM LOCAL CSV FILE 'file.csv' REJECT LIMIT UNLIMITED ERRORS", + + "IMPORT FROM LOCAL CSV FILE 'file.csv' ERRORS INTO CSV AT connectionName FILE 'file.csv'", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ERRORS INTO LOCAL CSV FILE 'file.csv'", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ERRORS INTO LOCAL SECURE CSV FILE 'file.csv'", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ERRORS INTO schemaName.tableName", + + "IMPORT FROM LOCAL CSV FILE 'file.csv' ERRORS INTO CSV AT connectionName FILE 'file.csv' REJECT LIMIT 1", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ERRORS INTO LOCAL CSV FILE 'file.csv' REJECT LIMIT 1", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ERRORS INTO LOCAL SECURE CSV FILE 'file.csv' REJECT LIMIT 1", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ERRORS INTO schemaName.tableName REJECT LIMIT 1", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ERRORS INTO CSV AT connectionName FILE 'file.csv' REJECT LIMIT 1 ERRORS", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ERRORS INTO LOCAL CSV FILE 'file.csv' REJECT LIMIT 1 ERRORS", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ERRORS INTO LOCAL SECURE CSV FILE 'file.csv' REJECT LIMIT 1 ERRORS", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ERRORS INTO schemaName.tableName REJECT LIMIT 1 ERRORS", + + "IMPORT FROM LOCAL CSV FILE 'file.csv' ERRORS INTO CSV AT connectionName FILE 'file.csv' REJECT LIMIT UNLIMITED", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ERRORS INTO LOCAL CSV FILE 'file.csv' REJECT LIMIT UNLIMITED", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ERRORS INTO LOCAL SECURE CSV FILE 'file.csv' REJECT LIMIT UNLIMITED", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ERRORS INTO schemaName.tableName REJECT LIMIT UNLIMITED", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ERRORS INTO CSV AT connectionName FILE 'file.csv' REJECT LIMIT UNLIMITED ERRORS", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ERRORS INTO LOCAL CSV FILE 'file.csv' REJECT LIMIT UNLIMITED ERRORS", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ERRORS INTO LOCAL SECURE CSV FILE 'file.csv' REJECT LIMIT UNLIMITED ERRORS", + "IMPORT FROM LOCAL CSV FILE 'file.csv' ERRORS INTO schemaName.tableName REJECT LIMIT UNLIMITED ERRORS" + }) + public void testImportErrorClause(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/select/SelectTest.java b/src/test/java/net/sf/jsqlparser/statement/select/SelectTest.java index 8a1c6b694..1ba1bb4a7 100644 --- a/src/test/java/net/sf/jsqlparser/statement/select/SelectTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/select/SelectTest.java @@ -58,6 +58,7 @@ import net.sf.jsqlparser.expression.operators.relational.GreaterThan; import net.sf.jsqlparser.expression.operators.relational.InExpression; import net.sf.jsqlparser.expression.operators.relational.LikeExpression; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; import net.sf.jsqlparser.parser.CCJSqlParserManager; import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.schema.Column; @@ -6242,6 +6243,7 @@ void testIssue2242SubSelectLookAhead() throws JSQLParserException { + " ON CONFLICT (id) DO UPDATE\n" + " SET col4 = ?, col5 = ?, col6 = ?"; Statement statement = CCJSqlParserUtil.parse(sqlStr); + System.out.println(statement.toString()); Insert insert = (Insert) statement; Assertions.assertEquals("foo", insert.getTable().toString()); } @@ -6393,4 +6395,16 @@ void testQuotedStringValueIssue2258() throws JSQLParserException { .getExpression(StringValue.class) .getNotExcapedValue()); } + + @ParameterizedTest + @ValueSource(strings = { + "SELECT * FROM ( IMPORT FROM EXA AT connectionName STATEMENT 'select 1' )", + "SELECT * FROM ( IMPORT INTO ( LIKE schemaName.tableName ( a, b as c) ) FROM EXA AT connectionName STATEMENT 'select 1' )", + "SELECT * FROM schemaName.tableName JOIN ( IMPORT FROM EXA AT connectionName STATEMENT 'select 1' ) USING ( columnName )" + }) + public void testSelectWithSubImport(String sqlStr) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true, + parser -> parser.withDialect(Dialect.EXASOL)); + } + }