How to use io.yawp.repository.query

Best Java code snippets using io.yawp.repository.query (Showing top 20 results out of 315)

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 Connection c =DataSource dataSource;dataSource.getConnection()
String url;DriverManager.getConnection(url)
IdentityDatabaseUtil.getDBConnection()
Smart code suggestions by Tabnine
}

public Query(QueryBuilder<?> builder, boolean keysOnly) {
  this.builder = builder;
  this.keysOnly = keysOnly;
  this.r = builder.getRepository();
}

private void configureQuery(int batchSize, QueryBuilder<?> q) {
  if (cursor != null) {
    q.cursor(cursor);
  }
  q.limit(batchSize);
}

public List<T> list() {
  List<T> list = executeQueryList();
  sortList(list);
  return list;
}

private List<?> list(QueryBuilder<?> query) {
  List<?> objects;
  if (hasTransformer()) {
    objects = query.transform(getTransformerName()).list();
  } else {
    objects = query.list();
    applyGetFacade(objects);
  }
  return objects;
}

@Test
public void testBooleanCodition() {
  String q = "{where: {p: 'booleanValue', op: '=', v: true}}";
  QueryOptions options = QueryOptions.parse(q);
  assertSimpleCondition(options.getCondition(), "booleanValue", WhereOperator.EQUAL, true);
}

public IdRef<T> onlyId() throws NoResultException, MoreThanOneResultException {
  List<IdRef<T>> ids = ids();
  if (ids.size() == 0) {
    throw new NoResultException();
  }
  if (ids.size() > 1) {
    throw new MoreThanOneResultException();
  }
  return ids.get(0);
}

public QueryTransformer<F, T> where(String field, String operator, Object value) {
  query.where(field, operator, value);
  return this;
}

public QueryTransformer<F, T> cursor(String cursor) {
  query.cursor(cursor);
  return this;
}

public QueryBuilder<T> order(String property) {
  order(property, null);
  return this;
}

private T executeQueryOnly() throws MoreThanOneResultException {
  List<T> list = executeQuery();
  if (list.size() == 0) {
    throw new NoResultException();
  }
  if (list.size() == 1) {
    return list.get(0);
  }
  throw new MoreThanOneResultException();
}

@SuppressWarnings("unchecked")
private T getForcedResultFetch() {
  return (T) getForcedResult(QueryType.FETCH);
}

  @Override
  public int compare(Object o1, Object o2) {
    for (QueryOrder order : postOrders) {
      int compare = order.compare(o1, o2);
      if (compare == 0) {
        continue;
      }
      return compare;
    }
    return 0;
  }
});

public QueryTransformer<F, T> options(QueryOptions options) {
  query.options(options);
  return this;
}

public QueryBuilder<T> sort(String property) {
  sort(property, null);
  return this;
}

@Override
public <T> QueryBuilder<T> query(Class<T> clazz) {
  return QueryBuilder.q(clazz, this);
}

@Test
public void testWhereSimpleCondition() {
  String q = "{where: {p: 'longValue', op: '=', v: 1}}";
  QueryOptions options = QueryOptions.parse(q);
  assertSimpleCondition(options.getCondition(), "longValue", WhereOperator.EQUAL, 1l);
}

@Override
public void beforeQuery(QueryBuilder<HookedObject> q) {
  if (HookTest.LoggedUser.filter == null) {
    return;
  }
  q.where("stringValue", "=", HookTest.LoggedUser.filter);
}

@SuppressWarnings("unchecked")
private List<IdRef<T>> getForcedResultIds() {
  return (List<IdRef<T>>) getForcedResult(QueryType.IDS);
}

  @Override
  public int compare(Object o1, Object o2) {
    for (QueryOrder order : preOrders) {
      int compare = order.compare(o1, o2);
      if (compare == 0) {
        continue;
      }
      return compare;
    }
    return 0;
  }
});

@SuppressWarnings("unchecked")
private List<T> getForcedResultList() {
  return (List<T>) getForcedResult(QueryType.LIST);
}