Merge branch 'master' into manticore

Author: manticore-projects

src/main/java/net/sf/jsqlparser/expression/ExpressionVisitor.java

@@ -659,6 +659,14 @@ default void visit(JsonTableFunction jsonTableFunction) {
         this.visit(jsonTableFunction, null);
     }
 
+    default <S> T visit(XmlTableFunction xmlTableFunction, S context) {
+        return visit((Function) xmlTableFunction, context);
+    }
+
+    default void visit(XmlTableFunction xmlTableFunction) {
+        this.visit(xmlTableFunction, null);
+    }
+
     <S> T visit(ConnectByRootOperator connectByRootOperator, S context);
 
     default void visit(ConnectByRootOperator connectByRootOperator) {

src/main/java/net/sf/jsqlparser/expression/ExpressionVisitorAdapter.java

@@ -758,6 +758,11 @@ public <S> T visit(JsonTableFunction jsonTableFunction, S context) {
         return visitExpressions(jsonTableFunction, context, jsonTableFunction.getAllExpressions());
     }
 
+    @Override
+    public <S> T visit(XmlTableFunction xmlTableFunction, S context) {
+        return visitExpressions(xmlTableFunction, context, xmlTableFunction.getAllExpressions());
+    }
+
     @Override
     public <S> T visit(ConnectByRootOperator connectByRootOperator, S context) {
         return connectByRootOperator.getColumn().accept(this, context);

src/main/java/net/sf/jsqlparser/expression/IntervalExpression.java

@@ -18,6 +18,7 @@ public class IntervalExpression extends ASTNodeAccessImpl implements Expression
     private final boolean intervalKeyword;
     private String parameter = null;
     private String intervalType = null;
+    private IntervalQualifier intervalQualifier = null;
     private Expression expression = null;
 
     public IntervalExpression() {
@@ -47,12 +48,42 @@ public void setParameter(String parameter) {
         this.parameter = parameter;
     }
 
+    /**
+     * Returns the non-standard single-identifier interval type (e.g. MySQL {@code INTERVAL 1 foo}),
+     * or {@code null} when a structured {@link IntervalQualifier} is present.
+     *
+     * @deprecated the structured {@link #getIntervalQualifier()} is the canonical representation.
+     *             This legacy field is kept only for the non-standard single-identifier form.
+     * @return the legacy interval type, or {@code null} if a qualifier is set
+     */
+    @Deprecated
     public String getIntervalType() {
         return intervalType;
     }
 
+    /**
+     * Sets the non-standard single-identifier interval type (e.g. MySQL {@code INTERVAL 1 foo}) and
+     * clears any structured qualifier.
+     *
+     * @deprecated use {@link #setIntervalQualifier(IntervalQualifier)} for the standard form.
+     * @param intervalType the legacy interval type
+     */
+    @Deprecated
     public void setIntervalType(String intervalType) {
         this.intervalType = intervalType;
+        this.intervalQualifier = null;
+    }
+
+    public IntervalQualifier getIntervalQualifier() {
+        return intervalQualifier;
+    }
+
+    /**
+     * Sets the structured interval qualifier and clears the legacy interval type.
+     */
+    public void setIntervalQualifier(IntervalQualifier intervalQualifier) {
+        this.intervalQualifier = intervalQualifier;
+        this.intervalType = null;
     }
 
     public Expression getExpression() {
@@ -67,7 +98,9 @@ public void setExpression(Expression expression) {
     public String toString() {
         return (intervalKeyword ? "INTERVAL " : "")
                 + Objects.toString(expression, parameter)
-                + (intervalType != null ? " " + intervalType : "");
+                + (intervalQualifier != null
+                        ? " " + intervalQualifier.toString()
+                        : (intervalType != null ? " " + intervalType : ""));
     }
 
     @Override
@@ -80,11 +113,22 @@ public IntervalExpression withParameter(String parameter) {
         return this;
     }
 
+    /**
+     * @deprecated use {@link #withIntervalQualifier(IntervalQualifier)} for the standard form.
+     * @param intervalType the legacy interval type
+     * @return this instance
+     */
+    @Deprecated
     public IntervalExpression withIntervalType(String intervalType) {
         this.setIntervalType(intervalType);
         return this;
     }
 
+    public IntervalExpression withIntervalQualifier(IntervalQualifier intervalQualifier) {
+        this.setIntervalQualifier(intervalQualifier);
+        return this;
+    }
+
     public IntervalExpression withExpression(Expression expression) {
         this.setExpression(expression);
         return this;

src/main/java/net/sf/jsqlparser/expression/IntervalQualifier.java

@@ -0,0 +1,123 @@
+/*-
+ * #%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.expression;
+
+import java.io.Serializable;
+import java.util.Objects;
+
+/**
+ * Models an SQL interval qualifier as defined by the SQL standard (see
+ * <a href="https://www.postgresql.org/docs/current/datatype-datetime.html">PostgreSQL: Interval
+ * Input</a>), e.g. {@code YEAR}, {@code DAY TO SECOND}, {@code DAY(9) TO SECOND} or
+ * {@code SECOND(2, 4)}.
+ * <p>
+ * It is shared by {@link IntervalExpression} (the {@code INTERVAL ...} expression literal, used in
+ * DML) and by {@code net.sf.jsqlparser.statement.create.table.ColDataType} (the {@code INTERVAL}
+ * column / cast target type, used in DDL), so the qualifier is represented once and round-trips
+ * consistently across all contexts.
+ */
+public final class IntervalQualifier implements Serializable {
+
+    private final String leadingField;
+    private final Integer leadingFieldPrecision;
+    private final String trailingField;
+    private final Integer fractionalSecondsPrecision;
+
+    public IntervalQualifier(
+            String leadingField, Integer leadingFieldPrecision, String trailingField,
+            Integer fractionalSecondsPrecision) {
+        this.leadingField = leadingField;
+        this.leadingFieldPrecision = leadingFieldPrecision;
+        this.trailingField = trailingField;
+        this.fractionalSecondsPrecision = fractionalSecondsPrecision;
+    }
+
+    public String getLeadingField() {
+        return leadingField;
+    }
+
+    public Integer getLeadingFieldPrecision() {
+        return leadingFieldPrecision;
+    }
+
+    public String getTrailingField() {
+        return trailingField;
+    }
+
+    public Integer getFractionalSecondsPrecision() {
+        return fractionalSecondsPrecision;
+    }
+
+    public IntervalQualifier withLeadingField(String leadingField) {
+        return new IntervalQualifier(
+                leadingField, leadingFieldPrecision, trailingField, fractionalSecondsPrecision);
+    }
+
+    public IntervalQualifier withLeadingFieldPrecision(Integer leadingFieldPrecision) {
+        return new IntervalQualifier(
+                leadingField, leadingFieldPrecision, trailingField, fractionalSecondsPrecision);
+    }
+
+    public IntervalQualifier withTrailingField(String trailingField) {
+        return new IntervalQualifier(
+                leadingField, leadingFieldPrecision, trailingField, fractionalSecondsPrecision);
+    }
+
+    public IntervalQualifier withFractionalSecondsPrecision(Integer fractionalSecondsPrecision) {
+        return new IntervalQualifier(
+                leadingField, leadingFieldPrecision, trailingField, fractionalSecondsPrecision);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof IntervalQualifier)) {
+            return false;
+        }
+        IntervalQualifier that = (IntervalQualifier) o;
+        return Objects.equals(leadingField, that.leadingField)
+                && Objects.equals(leadingFieldPrecision, that.leadingFieldPrecision)
+                && Objects.equals(trailingField, that.trailingField)
+                && Objects.equals(fractionalSecondsPrecision, that.fractionalSecondsPrecision);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(
+                leadingField, leadingFieldPrecision, trailingField, fractionalSecondsPrecision);
+    }
+
+    /**
+     * Renders the qualifier back to SQL, e.g. {@code DAY}, {@code DAY TO SECOND},
+     * {@code DAY(9) TO SECOND} or {@code SECOND(2, 4)}.
+     */
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder(Objects.toString(leadingField, ""));
+        if (leadingFieldPrecision != null) {
+            sb.append("(").append(leadingFieldPrecision);
+            // For a single-field qualifier such as SECOND(2, 4), the fractional seconds
+            // precision is rendered together with the leading precision.
+            if (trailingField == null && fractionalSecondsPrecision != null) {
+                sb.append(", ").append(fractionalSecondsPrecision);
+            }
+            sb.append(")");
+        }
+        if (trailingField != null) {
+            sb.append(" TO ").append(trailingField);
+            if (fractionalSecondsPrecision != null) {
+                sb.append("(").append(fractionalSecondsPrecision).append(")");
+            }
+        }
+        return sb.toString();
+    }
+}

src/main/java/net/sf/jsqlparser/expression/WindowElement.java

@@ -17,6 +17,7 @@ public class WindowElement implements Serializable {
     private Type type;
     private WindowOffset offset;
     private WindowRange range;
+    private Exclusion exclusion;
 
     public Type getType() {
         return type;
@@ -42,6 +43,14 @@ public void setRange(WindowRange range) {
         this.range = range;
     }
 
+    public Exclusion getExclusion() {
+        return exclusion;
+    }
+
+    public void setExclusion(Exclusion exclusion) {
+        this.exclusion = exclusion;
+    }
+
     @Override
     public String toString() {
         StringBuilder buffer = new StringBuilder(type.toString());
@@ -52,6 +61,10 @@ public String toString() {
             buffer.append(range.toString());
         }
 
+        if (exclusion != null) {
+            buffer.append(" EXCLUDE ").append(exclusion);
+        }
+
         return buffer.toString();
     }
 
@@ -70,12 +83,32 @@ public WindowElement withRange(WindowRange range) {
         return this;
     }
 
+    public WindowElement withExclusion(Exclusion exclusion) {
+        this.setExclusion(exclusion);
+        return this;
+    }
+
     public enum Type {
-        ROWS, RANGE;
+        ROWS, RANGE, GROUPS;
 
         public static Type from(String type) {
             return Enum.valueOf(Type.class, type.toUpperCase(Locale.ROOT));
         }
     }
 
+    public enum Exclusion {
+        CURRENT_ROW("CURRENT ROW"), GROUP("GROUP"), TIES("TIES"), NO_OTHERS("NO OTHERS");
+
+        private final String keyword;
+
+        Exclusion(String keyword) {
+            this.keyword = keyword;
+        }
+
+        @Override
+        public String toString() {
+            return keyword;
+        }
+    }
+
 }