How to use

MutableQueryModifiers

in

it.unibz.inf.ontop.datalog

private boolean hasSelectDistinctStatement(DatalogProgram query) {
  boolean toReturn = false;
  if (query.getQueryModifiers().hasModifiers()) {
    toReturn = query.getQueryModifiers().isDistinct();
  }
  return toReturn;
}

@Override
public void copy(MutableQueryModifiers other) {
  isDistinct = other.isDistinct();
  limit = other.getLimit();
  offset = other.getOffset();
  orderConditions.addAll(other.getSortConditions());
  groupConditions.addAll(other.getGroupConditions());
}

private boolean hasOrderByClause(DatalogProgram query) {
  boolean toReturn = false;
  if (query.getQueryModifiers().hasModifiers()) {
    final List<OrderCondition> conditions = query.getQueryModifiers()
        .getSortConditions();
    toReturn = (!conditions.isEmpty());
  }
  return toReturn;
}

isDistinct = queryModifiers.hasModifiers() && queryModifiers.isDistinct();
isOrderBy = queryModifiers.hasModifiers() && !queryModifiers.getSortConditions().isEmpty();
if (queryModifiers.hasModifiers()) {
  long limit = queryModifiers.getLimit();
  long offset = queryModifiers.getOffset();
  List<OrderCondition> conditions = queryModifiers.getSortConditions();

if (queryProgram.getQueryModifiers().hasModifiers()) {
  final String outerViewName = "SUB_QVIEW";
  String subquery = generateQuery(signature, ruleIndex, predicatesInBottomUp, extensionalPredicates);
  List<OrderCondition> conditions = queryProgram.getQueryModifiers().getSortConditions();
  List<Variable> groupby = queryProgram.getQueryModifiers().getGroupConditions();
  long limit = queryProgram.getQueryModifiers().getLimit();
  long offset = queryProgram.getQueryModifiers().getOffset();

Slice slice = (Slice) node;
MutableQueryModifiers modifiers = program.getQueryModifiers();
modifiers.setOffset(slice.getOffset());
modifiers.setLimit(slice.getLimit());
return translate(slice.getArg());
program.getQueryModifiers().setDistinct();
return translate(distinct.getArg());
  int direction = c.isAscending() ? OrderCondition.ORDER_ASCENDING
      : OrderCondition.ORDER_DESCENDING;
  modifiers.addOrderCondition(var, direction);

  @Override
  public boolean hasModifiers() {
    return modifiers.hasModifiers();
  }
}

      long offset = n.getOffset();
      if (offset > 0)
        mutableQueryModifiers.setOffset(offset);
  });
mutableQueryModifiers.setDistinct();

private static void convertOrderComparator(OrderByNode.OrderComparator comparator,
                      MutableQueryModifiers queryModifiers) {
  NonGroundTerm term = comparator.getTerm();
  if (term instanceof Variable)
    queryModifiers.addOrderCondition((Variable) term,
        comparator.isAscending() ? OrderCondition.ORDER_ASCENDING : OrderCondition.ORDER_DESCENDING);
  else
    // TODO: throw a better exception
    throw new IllegalArgumentException("The Datalog representation only supports variable in order conditions");
}

public MutableQueryModifiersImpl(QueryModifiers modifiers) {
  isDistinct = modifiers.isDistinct();
  limit = modifiers.getLimit();
  offset = modifiers.getOffset();
  orderConditions = new ArrayList<>(modifiers.getSortConditions());
  if (modifiers instanceof MutableQueryModifiers) {
    groupConditions = new ArrayList<>(((MutableQueryModifiers) modifiers).getGroupConditions());
  }
  else {
    groupConditions = new ArrayList<>();
  }
}

isDistinct = queryModifiers.hasModifiers() && queryModifiers.isDistinct();
isOrderBy = queryModifiers.hasModifiers() && !queryModifiers.getSortConditions().isEmpty();
if (queryModifiers.hasModifiers()) {
  long limit = queryModifiers.getLimit();
  long offset = queryModifiers.getOffset();
  List<OrderCondition> conditions = queryModifiers.getSortConditions();

/**
 * TODO: explain
 */
private static Optional<ImmutableQueryModifiers> convertModifiers(MutableQueryModifiers queryModifiers) {
  if (queryModifiers.hasModifiers()) {
    ImmutableQueryModifiers immutableQueryModifiers = new ImmutableQueryModifiersImpl(queryModifiers);
    return Optional.of(immutableQueryModifiers);
  } else {
    return Optional.empty();
  }
}

  /**
   * TODO: explain
   */
  private static Optional<ImmutableQueryModifiers> convertModifiers(MutableQueryModifiers queryModifiers) {
    if (queryModifiers.hasModifiers()) {
      ImmutableQueryModifiers immutableQueryModifiers = new ImmutableQueryModifiersImpl(queryModifiers);
      return Optional.of(immutableQueryModifiers);
    } else {
      return Optional.empty();
    }
  }
}