exp = x(colName).lt(x(val)); break; case "<=": exp = x(colName).lte(x(val)); break; case ">": exp = x(colName).gt(x(val)); break; case ">=": exp = x(colName).gte(x(val)); break; case "=": exp = x(colName).eq(x(val)); break; default: return asPath.where(exp.and(x(CouchbaseConstants.KUNDERA_ENTITY).eq(x("'" + tableName) + "'")));
/** * Creates a new {@link N1qlQuery} for the given class, this method build a query like: * * <pre> * select b.* from bucket b where b._class = 'model.Beer' * </pre> * * @param bucket Bucket name. * @param entityClass Entity class. * @return A query. */ public static GroupByPath from(final String bucket, final Class<?> entityClass) { String alias = String.valueOf(entityClass.getSimpleName().charAt(0)); return Select.select(alias + ".*") .from(i(bucket) + " " + alias) .where(path(alias, CLASS).eq(s(entityClass.getName()))); }
Expression left = ignoreCase ? StringFunctions.lower(x(fieldNamePath)) : x(fieldNamePath); Expression exp; switch (partType) { case BETWEEN: exp = left.between(x(getPlaceHolder(position, ignoreCase)).and(x(getPlaceHolder(position, ignoreCase)))); placeHolderValues.add(getValue(parameterValues)); placeHolderValues.add(getValue(parameterValues)); break; case IS_NOT_NULL: exp = left.isNotNull(); break; case IS_NULL: exp = left.isNull(); break; case NEGATING_SIMPLE_PROPERTY: exp = left.ne(getPlaceHolder(position, ignoreCase)); placeHolderValues.add(getValue(parameterValues)); break; case SIMPLE_PROPERTY: exp = left.eq(getPlaceHolder(position, ignoreCase)); placeHolderValues.add(getValue(parameterValues)); break; case BEFORE: case LESS_THAN: exp = left.lt(getPlaceHolder(position, ignoreCase)); placeHolderValues.add(getValue(parameterValues)); break; case LESS_THAN_EQUAL: exp = left.lte(getPlaceHolder(position, ignoreCase));
/** * Produces an {@link Expression} that can serve as a WHERE clause criteria to only select documents in a bucket * that matches a particular Spring Data entity (as given by the {@link EntityMetadata} parameter). * * @param baseWhereCriteria the other criteria of the WHERE clause, or null if none. * @param converter the {@link CouchbaseConverter} giving the attribute storing the type information can be extracted. * @param entityInformation the expected type information. * @return an {@link Expression} to be used as a WHERE clause, that additionally restricts on the given type. */ public static Expression createWhereFilterForEntity(Expression baseWhereCriteria, CouchbaseConverter converter, EntityMetadata<?> entityInformation) { //add part that filters on type key String typeKey = converter.getTypeKey(); String typeValue = entityInformation.getJavaType().getName(); Expression typeSelector = i(typeKey).eq(s(typeValue)); if (baseWhereCriteria == null) { baseWhereCriteria = typeSelector; } else { baseWhereCriteria = x("(" + baseWhereCriteria.toString() + ")").and(typeSelector); } return baseWhereCriteria; }
return x(document.getName()).eq(x(PARAM_PREFIX + document.getName())); case LESSER_THAN: return x(document.getName()).lt(x(PARAM_PREFIX + document.getName())); case LESSER_EQUALS_THAN: return x(document.getName()).lte(x(PARAM_PREFIX + document.getName())); case GREATER_THAN: return x(document.getName()).gt(x(PARAM_PREFIX + document.getName())); case GREATER_EQUALS_THAN: return x(document.getName()).gte(x(PARAM_PREFIX + document.getName())); case LIKE: return x(document.getName()).like(x(PARAM_PREFIX + document.getName())); case IN: return x(document.getName()).in(x(PARAM_PREFIX + document.getName())); case BETWEEN: return x(document.getName()).between(x(PARAM_PREFIX + document.getName())); case AND: return document.get(new TypeReference<List<DocumentCondition>>() { case NOT: DocumentCondition dc = document.get(DocumentCondition.class); return getCondition(dc, params, keys, documentCollection).not(); default: throw new IllegalStateException("This condition is not supported at coubhbase: " + condition.getCondition());
@Override public Observable<IndexInfo> listN1qlIndexes() { Expression whereClause = x("keyspace_id").eq(s(bucket)) .and(i("using").eq(s("gsi"))); Statement listIndexes = select("idx.*").from(x("system:indexes").as("idx")).where(whereClause) .orderBy(Sort.desc("is_primary"), Sort.asc("name")); final Func1<List<JsonObject>, Observable<AsyncN1qlQueryRow>> errorHandler = errorsToThrowable( "Error while listing indexes: "); return queryExecutor.execute( N1qlQuery.simple(listIndexes, N1qlParams.build().consistency(ScanConsistency.REQUEST_PLUS)), env, env.managementTimeout(), TimeUnit.MILLISECONDS) .flatMap(new Func1<AsyncN1qlQueryResult, Observable<AsyncN1qlQueryRow>>() { @Override public Observable<AsyncN1qlQueryRow> call(final AsyncN1qlQueryResult aqr) { return aqr.finalSuccess() .flatMap(new Func1<Boolean, Observable<AsyncN1qlQueryRow>>() { @Override public Observable<AsyncN1qlQueryRow> call(Boolean success) { if (success) { return aqr.rows(); } else { return aqr.errors().toList().flatMap(errorHandler); } } }); } }).map(ROW_VALUE_TO_INDEXINFO); }
/** * Escape the given bucketName and produce an {@link Expression}. */ public static Expression escapedBucket(String bucketName) { return i(bucketName); }
@Override protected Statement getCount(ParameterAccessor accessor, Object[] runtimeParameters) { Expression bucket = i(getCouchbaseOperations().getCouchbaseBucket().name()); WherePath countFrom = select(count("*").as(CountFragment.COUNT_ALIAS)).from(bucket); N1qlCountQueryCreator queryCountCreator = new N1qlCountQueryCreator(partTree, accessor, countFrom, getCouchbaseOperations().getConverter(), getQueryMethod()); Statement statement = queryCountCreator.createQuery(); this.placeHolderValues = queryCountCreator.getPlaceHolderValues(); return statement; }
public static N1qlSpelValues createN1qlSpelValues(String bucketName, String typeField, Class<?> typeValue, boolean isCount) { String b = "`" + bucketName + "`"; String entity = "META(" + b + ").id AS " + SELECT_ID + ", META(" + b + ").cas AS " + SELECT_CAS; String count = "COUNT(*) AS " + CountFragment.COUNT_ALIAS; String selectEntity; if (isCount) { selectEntity = "SELECT " + count + " FROM " + b; } else { selectEntity = "SELECT " + entity + ", " + b + ".* FROM " + b; } String typeSelection = "`" + typeField + "` = \"" + typeValue.getName() + "\""; String delete = deleteFrom(i(bucketName)).toString(); String returning = " returning " + N1qlUtils.createReturningExpressionForDelete(bucketName).toString(); return new N1qlSpelValues(selectEntity, entity, b, typeSelection, delete, returning); }
@Override public InsertValuesPath values(String id, Expression value) { element(new InsertValueElement(POS, s(id), value)); return new DefaultInsertValuesPath(this); }
@Override protected Expression and(Part part, Expression base, Iterator<Object> iterator) { if (base == null) { return create(part, iterator); } return base.and(create(part, iterator)); }