How to use

Slice

in

org.openrdf.query.algebra

@Override
public void meet(Slice node) throws RuntimeException {
  if(node.hasLimit())
    limit = node.getLimit();
  if(node.hasOffset())
    offset = node.getOffset();
}

public void visitAsk(Resource ask)
  throws OpenRDFException
{
  tupleNode = new SingletonSet();
  tupleRoot = new Slice(tupleNode, 0, 1);
  visitWhere(ask);
}

@Override
public void meet(Slice node)
  throws RuntimeException
{
  super.meet(node);
  if (node.getArg() instanceof SelectQuery) {
    SelectQuery query = (SelectQuery)node.getArg();
    if (node.getOffset() > 0) {
      query.setOffset(node.getOffset());
    }
    if (node.getLimit() >= 0) {
      query.setLimit(node.getLimit());
    }
    node.replaceWith(query);
  }
}

public Slice(TupleExpr arg, long offset2, long limit2) {
  super(arg);
  setOffset(offset2);
  setLimit(limit2);
}

@Override
public boolean equals(Object other) {
  if (other instanceof Slice && super.equals(other)) {
    Slice o = (Slice)other;
    return offset == o.getOffset() && limit == o.getLimit();
  }
  return false;
}

Slice aSlice = new Slice();
  aSlice.setLimit(mLimit);
  aSlice.setOffset(mOffset);

@Override
public void meet(Slice node) throws RuntimeException {
  TupleExpr child = node.getArg();
  if(!isSupported(child) && child instanceof UnaryTupleOperator) {
    UnaryTupleOperator replacement = (UnaryTupleOperator)child.clone();
    // switch positions of child and node
    node.replaceWith(replacement);
    node.setArg(((UnaryTupleOperator) child).getArg().clone());
    replacement.setArg(node.clone());
    // visit the newly inserted replacement node (i.e. the clone of child now containing the old "node" as
    // child, so "node" can be bubbled down further if needed)
    replacement.visit(this);
  }
}

  @Override
  public void meet(Slice node)
    throws RDFHandlerException
  {
    if (!isSubQuery) { // ignore root slice
      node.getArg().visit(this);
    }
    else {
      super.meet(node);
    }
  }
}

@Override
public void meet(Slice node) {
  handleType(SeRQO.SLICE);
  handleLiteral(SeRQO.LIMIT, node.getLimit());
  handleLiteral(SeRQO.OFFSET, node.getOffset());
  super.meet(node);
}

Slice slice = new Slice(tupleRoot);
if (offset > 0L) {
  slice.setOffset(offset);
  slice.setLimit(limit);

@Override
public void meet(Slice node) {
  if (predicate.equals(SeRQO.LIMIT)) {
    Literal lit = (Literal) object;
    node.setLimit(lit.intValue());
  } else if (predicate.equals(SeRQO.OFFSET)) {
    Literal lit = (Literal) object;
    node.setOffset(lit.intValue());
  } else {
    super.meet(node);
  }
}

/**
 * @inheritDoc
 */
@Override
public void meet(final Slice theSlice)
  throws Exception
{
  if (theSlice.hasOffset()) {
    mOffset = theSlice.getOffset();
  }
  if (theSlice.hasLimit()) {
    mLimit = theSlice.getLimit();
  }
  theSlice.visitChildren(this);
}

offset = slice.getOffset() < 0 ? null : slice.getOffset();
limit = slice.getLimit() < 0 ? null : slice.getLimit();
if (form == null && slice.getOffset() == 0 && slice.getLimit() == 1) {
  if (forceSelect) {
    form = Form.SELECT;

Long limit = modifiers.getLimit();
Long offset = modifiers.getOffset();
tuple = new Slice(
    tuple,
    offset != null ? offset.intValue() : 0,

public CloseableIteration<BindingSet, QueryEvaluationException> evaluate(Slice slice, BindingSet bindings)
  throws QueryEvaluationException
{
  CloseableIteration<BindingSet, QueryEvaluationException> result = evaluate(slice.getArg(), bindings);
  if (slice.hasOffset()) {
    result = new OffsetIteration<BindingSet, QueryEvaluationException>(result, slice.getOffset());
  }
  if (slice.hasLimit()) {
    result = new LimitIteration<BindingSet, QueryEvaluationException>(result, slice.getLimit());
  }
  return result;
}

offset = slice.getOffset() < 0 ? null : slice.getOffset();
limit = slice.getLimit() < 0 ? null : slice.getLimit();
if (form == null && slice.getOffset() == 0 && slice.getLimit() == 1) {
  if (forceSelect) {
    form = Form.SELECT;

Long limit = modifiers.getLimit();
Long offset = modifiers.getOffset();
tuple = new Slice(
    tuple,
    offset != null ? offset.intValue() : 0,

public CloseableIteration evaluate(Slice slice, BindingSet bindings)
    throws QueryEvaluationException {
  CloseableIteration result = evaluate(slice.getArg(), bindings);
  if (slice.hasOffset()) {
    result = new OffsetIteration(result, slice.getOffset());
  }
  if (slice.hasLimit()) {
    result = new LimitIteration(result, slice.getLimit());
  }
  return result;
}

Long limit = modifiers.getLimit();
Long offset = modifiers.getOffset();
tuple = new Slice(
    tuple,
    offset != null ? offset.intValue() : 0,

/**
 * Returns the limit of the current variable bindings before any further
 * projection.
 */
protected long getLimit(QueryModelNode node) {
  long offset = 0;
  if (node instanceof Slice) {
    Slice slice = (Slice)node;
    if (slice.hasOffset() && slice.hasLimit()) {
      return slice.getOffset() + slice.getLimit();
    }
    else if (slice.hasLimit()) {
      return slice.getLimit();
    }
    else if (slice.hasOffset()) {
      offset = slice.getOffset();
    }
  }
  QueryModelNode parent = node.getParentNode();
  if (parent instanceof Distinct || parent instanceof Reduced || parent instanceof Slice) {
    long limit = getLimit(parent);
    if (offset > 0L && limit < Long.MAX_VALUE) {
      return offset + limit;
    }
    else {
      return limit;
    }
  }
  return Long.MAX_VALUE;
}