com.querydsl.sql.WindowFunction Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of querydsl-sql Show documentation
SQL support for Querydsl
There is a newer version: 6.9
/*
 * Copyright 2015, The Querydsl Team (http://www.querydsl.com/team)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.querydsl.sql;

import com.querydsl.core.types.*;
import com.querydsl.core.types.dsl.BooleanExpression;
import com.querydsl.core.types.dsl.ComparableExpressionBase;
import com.querydsl.core.types.dsl.Expressions;
import com.querydsl.core.types.dsl.SimpleExpression;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.jetbrains.annotations.Nullable;

/**
 * {@code WindowFunction} is a builder for window function expressions
 *
 * @param  expression type
 * @author tiwe
 */
public class WindowFunction extends MutableExpressionBase {

  private static final String ORDER_BY = "order by ";

  private static final String PARTITION_BY = "partition by ";

  private static final long serialVersionUID = -4130672293308756779L;

  private final List> orderBy = new ArrayList>();

  private final List> partitionBy = new ArrayList>();

  private final Expression target;

  @Nullable private transient volatile SimpleExpression value;

  private String rowsOrRange;

  private List> rowsOrRangeArgs;

  public WindowFunction(Expression expr) {
    super(expr.getType());
    this.target = expr;
  }

  public SimpleExpression getValue() {
    if (value == null) {
      int size = 0;
      List> args = new ArrayList<>();
      StringBuilder builder = new StringBuilder();
      builder.append("{0} over (");
      args.add(target);
      size++;
      if (!partitionBy.isEmpty()) {
        builder.append(PARTITION_BY);
        boolean first = true;
        for (Expression expr : partitionBy) {
          if (!first) {
            builder.append(", ");
          }
          builder.append("{").append(size).append("}");
          args.add(expr);
          size++;
          first = false;
        }
      }
      if (!orderBy.isEmpty()) {
        if (!partitionBy.isEmpty()) {
          builder.append(" ");
        }
        builder.append(ORDER_BY);
        builder.append("{").append(size).append("}");
        args.add(ExpressionUtils.orderBy(orderBy));
        size++;
      }
      if (rowsOrRange != null) {
        builder.append(rowsOrRange);
        args.addAll(rowsOrRangeArgs);
        size += rowsOrRangeArgs.size();
      }
      builder.append(")");
      value =
          Expressions.template(
              target.getType(), builder.toString(), Collections.unmodifiableList(args));
    }
    return value;
  }

  @SuppressWarnings("unchecked")
  public SimpleExpression as(Expression alias) {
    return Expressions.operation(getType(), Ops.ALIAS, this, alias);
  }

  public SimpleExpression as(String alias) {
    return Expressions.operation(
        getType(), Ops.ALIAS, this, ExpressionUtils.path(getType(), alias));
  }

  @Override
  public  R accept(Visitor v, C context) {
    return getValue().accept(v, context);
  }

  @Override
  public boolean equals(Object o) {
    if (o == this) {
      return true;
    } else if (o instanceof WindowFunction) {
      WindowFunction so = (WindowFunction) o;
      return so.target.equals(target)
          && so.partitionBy.equals(partitionBy)
          && so.orderBy.equals(orderBy);
    } else {
      return false;
    }
  }

  public BooleanExpression eq(Expression expr) {
    return getValue().eq(expr);
  }

  public BooleanExpression eq(A arg) {
    return getValue().eq(arg);
  }

  public BooleanExpression ne(Expression expr) {
    return getValue().ne(expr);
  }

  public BooleanExpression ne(A arg) {
    return getValue().ne(arg);
  }

  public WindowFunction orderBy(ComparableExpressionBase orderBy) {
    value = null;
    this.orderBy.add(orderBy.asc());
    return this;
  }

  public WindowFunction orderBy(ComparableExpressionBase... orderBy) {
    value = null;
    for (ComparableExpressionBase e : orderBy) {
      this.orderBy.add(e.asc());
    }
    return this;
  }

  public WindowFunction orderBy(OrderSpecifier orderBy) {
    value = null;
    this.orderBy.add(orderBy);
    return this;
  }

  public WindowFunction orderBy(OrderSpecifier... orderBy) {
    value = null;
    Collections.addAll(this.orderBy, orderBy);
    return this;
  }

  public WindowFunction partitionBy(Expression partitionBy) {
    value = null;
    this.partitionBy.add(partitionBy);
    return this;
  }

  public WindowFunction partitionBy(Expression... partitionBy) {
    value = null;
    Collections.addAll(this.partitionBy, partitionBy);
    return this;
  }

  WindowFunction withRowsOrRange(String s, List> args) {
    rowsOrRange = s;
    rowsOrRangeArgs = args;
    return this;
  }

  public WindowRows rows() {
    value = null;
    int offset = orderBy.size() + partitionBy.size() + 1;
    return new WindowRows(this, " rows", offset);
  }

  public WindowRows range() {
    value = null;
    int offset = orderBy.size() + partitionBy.size() + 1;
    return new WindowRows(this, " range", offset);
  }
}