IntervalExpression.java

/*-
 * #%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 net.sf.jsqlparser.parser.ASTNodeAccessImpl;

import java.io.Serializable;
import java.util.Objects;

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() {
        this(true);
    }

    public IntervalExpression(boolean intervalKeyword) {
        this.intervalKeyword = intervalKeyword;
    }

    public IntervalExpression(int value, String type) {
        this.parameter = null;
        this.intervalKeyword = true;
        this.expression = new LongValue(value);
        this.intervalType = type;
    }

    public boolean isUsingIntervalKeyword() {
        return intervalKeyword;
    }

    public String getParameter() {
        return parameter;
    }

    public void setParameter(String parameter) {
        this.parameter = parameter;
    }

    public String getIntervalType() {
        return intervalType;
    }

    public void setIntervalType(String intervalType) {
        this.intervalType = intervalType;
    }

    public IntervalQualifier getIntervalQualifier() {
        return intervalQualifier;
    }

    public void setIntervalQualifier(IntervalQualifier intervalQualifier) {
        this.intervalQualifier = intervalQualifier;
    }

    public Expression getExpression() {
        return expression;
    }

    public void setExpression(Expression expression) {
        this.expression = expression;
    }

    @Override
    public String toString() {
        return (intervalKeyword ? "INTERVAL " : "")
                + Objects.toString(expression, parameter)
                + (intervalQualifier != null
                        ? " " + intervalQualifier.toString()
                        : (intervalType != null ? " " + intervalType : ""));
    }

    @Override
    public <T, S> T accept(ExpressionVisitor<T> expressionVisitor, S context) {
        return expressionVisitor.visit(this, context);
    }

    public IntervalExpression withParameter(String parameter) {
        this.setParameter(parameter);
        return this;
    }

    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;
    }

    public <E extends Expression> E getExpression(Class<E> type) {
        return type.cast(getExpression());
    }

    /**
     * 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 static 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();
        }
    }
}