MatchRecognizeClause.java

/*
 * *************************************************************************************
 *  Copyright (C) 2008 EsperTech, Inc. All rights reserved.                            *
 *  http://esper.codehaus.org                                                          *
 *  http://www.espertech.com                                                           *
 *  ---------------------------------------------------------------------------------- *
 *  The software in this package is published under the terms of the GPL license       *
 *  a copy of which has been included with this distribution in the license.txt file.  *
 * *************************************************************************************
 */

package com.espertech.esper.client.soda;

import java.io.Serializable;
import java.io.StringWriter;
import java.util.List;
import java.util.ArrayList;

/**
 * Match-recognize clause.
 */
public class MatchRecognizeClause implements Serializable {

    private static final long serialVersionUID = -344174798312697242L;
    
    private List<Expression> partitionExpressions = new ArrayList<Expression>();
    private List<SelectClauseExpression> measures = new ArrayList<SelectClauseExpression>();
    private boolean all;
    private MatchRecognizeSkipClause skipClause = MatchRecognizeSkipClause.PAST_LAST_ROW;
    private MatchRecognizeRegEx pattern;
    private MatchRecognizeIntervalClause intervalClause;
    private List<MatchRecognizeDefine> defines = new ArrayList<MatchRecognizeDefine>();

    /**
     * Ctor.
     */
    public MatchRecognizeClause() {
    }

    /**
     * Renders the clause in textual representation.
     * @param writer to output to
     */
    public void toEPL(StringWriter writer)
    {
        writer.write(" match_recognize (");

        if (partitionExpressions.size() > 0) {
            String delimiter = "";
            writer.write(" partition by ");
            for (Expression part : partitionExpressions) {
                writer.write(delimiter);
                part.toEPL(writer, ExpressionPrecedenceEnum.MINIMUM);
                delimiter = ", ";
            }
        }

        String delimiter = "";
        writer.write(" measures ");
        for (SelectClauseExpression part : measures) {
            writer.write(delimiter);
            part.toEPLElement(writer);
            delimiter = ", ";
        }

        if (all) {
            writer.write(" all matches");
        }

        if (skipClause != MatchRecognizeSkipClause.PAST_LAST_ROW) {
            writer.write(" after match skip " + skipClause.getText());
        }

        writer.write(" pattern (");
        pattern.writeEPL(writer);
        writer.write(")");

        if ((intervalClause != null) && (intervalClause.getExpression() != null)){
            writer.write(" interval ");
            intervalClause.getExpression().toEPL(writer, ExpressionPrecedenceEnum.MINIMUM);
        }

        delimiter = "";
        writer.write(" define ");
        for (MatchRecognizeDefine def : defines) {
            writer.write(delimiter);
            writer.write(def.getName());
            writer.write(" as ");
            def.getExpression().toEPL(writer, ExpressionPrecedenceEnum.MINIMUM);
            delimiter = ", ";
        }
        writer.write(")");
    }

    /**
     * Get partition expressions.
     * @return partition expressions
     */
    public List<Expression> getPartitionExpressions() {
        return partitionExpressions;
    }

    /**
     * Set partition expressions.
     * @param partitionExpressions partition expressions
     */
    public void setPartitionExpressions(List<Expression> partitionExpressions) {
        this.partitionExpressions = partitionExpressions;
    }

    /**
     * Returns measures.
     * @return measures
     */
    public List<SelectClauseExpression> getMeasures() {
        return measures;
    }

    /**
     * Sets measures.
     * @param measures to set
     */
    public void setMeasures(List<SelectClauseExpression> measures) {
        this.measures = measures;
    }

    /**
     * Indicator whether all matches.
     * @return all matches
     */
    public boolean isAll() {
        return all;
    }

    /**
     * Sets indicator whether all matches.
     * @param all all matches
     */
    public void setAll(boolean all) {
        this.all = all;
    }

    /**
     * Returns skip-clause.
     * @return skip-clause
     */
    public MatchRecognizeSkipClause getSkipClause() {
        return skipClause;
    }

    /**
     * Sets the skip-clause.
     * @param skipClause to set
     */
    public void setSkipClause(MatchRecognizeSkipClause skipClause) {
        this.skipClause = skipClause;
    }

    /**
     * Returns the defines-clause
     * @return defines-clause
     */
    public List<MatchRecognizeDefine> getDefines() {
        return defines;
    }

    /**
     * Sets the defines-clause
     * @param defines to set
     */
    public void setDefines(List<MatchRecognizeDefine> defines) {
        this.defines = defines;
    }

    /**
     * Returns the interval clause.
     * @return interval clause
     */
    public MatchRecognizeIntervalClause getIntervalClause() {
        return intervalClause;
    }

    /**
     * Sets the interval clause.
     * @param intervalClause interval clause
     */
    public void setIntervalClause(MatchRecognizeIntervalClause intervalClause) {
        this.intervalClause = intervalClause;
    }

    /**
     * Returns regex-pattern.
     * @return pattern
     */
    public MatchRecognizeRegEx getPattern() {
        return pattern;
    }

    /**
     * Sets regex-pattern.
     * @param pattern to set
     */
    public void setPattern(MatchRecognizeRegEx pattern) {
        this.pattern = pattern;
    }
}