Refine search
@PostConstruct private void postConstruct() { // Need to post-process travel data to add _class attribute List<Airline> airlinesWithoutClassAttribute = couchbaseOperations.findByN1QL(N1qlQuery.simple( // "SELECT META(`travel-sample`).id AS _ID, META(`travel-sample`).cas AS _CAS, `travel-sample`.* " + // "FROM `travel-sample` " + // "WHERE type = \"airline\" AND _class IS MISSING;"), Airline.class); airlinesWithoutClassAttribute.forEach(couchbaseOperations::save); } }
final List<HashMap<String, ByteIterator>> data = new ArrayList<HashMap<String, ByteIterator>>(recordcount); bucket.async() .query(N1qlQuery.parameterized( scanAllQuery, JsonArray.from(formatId(table, startkey), recordcount), N1qlParams.build().adhoc(adhoc).maxParallelism(maxParallelism) )) .doOnNext(new Action1<AsyncN1qlQueryResult>() { @Override public void call(AsyncN1qlQueryResult result) {
@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); }
private Observable<Boolean> drop(final boolean ignoreIfNotExist, Statement dropIndex, final String errorPrefix) { return queryExecutor.execute(N1qlQuery.simple(dropIndex), env, env.managementTimeout(), TimeUnit.MILLISECONDS) .flatMap(new Func1<AsyncN1qlQueryResult, Observable<Boolean>>() { @Override public Observable<Boolean> call(final AsyncN1qlQueryResult aqr) {
@Override public Observable<Boolean> createN1qlPrimaryIndex(final boolean ignoreIfExist, boolean defer) { Statement createIndex; UsingWithPath usingWithPath = Index.createPrimaryIndex().on(bucket); if (defer) { createIndex = usingWithPath.withDefer(); } else { createIndex = usingWithPath; } return queryExecutor.execute(N1qlQuery.simple(createIndex), env, env.managementTimeout(), TimeUnit.MILLISECONDS) .compose(checkIndexCreation(ignoreIfExist, "Error creating primary index")); }
return Observable.error(new UnsupportedOperationException("Cluster level querying is only available " + "when at least 1 bucket is opened")); "CLUSTER_N1QL credentials are required in the Authenticator for cluster level querying"); } else { query.params().withCredentials(creds); LOGGER.trace("Added {} credentials to a cluster-level N1qlQuery", creds.size());
protected static N1qlQuery buildQuery(Statement statement, JsonValue queryPlaceholderValues, ScanConsistency scanConsistency) { N1qlParams n1qlParams = N1qlParams.build().consistency(scanConsistency); N1qlQuery query; if (queryPlaceholderValues instanceof JsonObject && !((JsonObject) queryPlaceholderValues).isEmpty()) { query = N1qlQuery.parameterized(statement, (JsonObject) queryPlaceholderValues, n1qlParams); } else if (queryPlaceholderValues instanceof JsonArray && !((JsonArray) queryPlaceholderValues).isEmpty()) { query = N1qlQuery.parameterized(statement, (JsonArray) queryPlaceholderValues, n1qlParams); } else { query = N1qlQuery.simple(statement, n1qlParams); } return query; }
String scanSpecQuery = "SELECT " + joinFields(fields) + " FROM `" + bucketName + "` WHERE meta().id >= '$1' LIMIT $2"; N1qlQueryResult queryResult = bucket.query(N1qlQuery.parameterized( scanSpecQuery, JsonArray.from(formatId(table, startkey), recordcount),
private void logIfNecessary(N1qlQuery query) { if (LOG.isDebugEnabled()) { LOG.debug("Executing N1QL query: " + query.n1ql()); } }
/** * Creates the core query request and performs centralized string substitution. */ private GenericQueryRequest createN1qlRequest(final N1qlQuery query, String bucket, String username, String password, InetAddress targetNode) { String rawQuery = query.n1ql().toString(); rawQuery = rawQuery.replaceAll( CouchbaseAsyncBucket.CURRENT_BUCKET_IDENTIFIER, "`" + bucket + "`" ); if (targetNode != null) { return GenericQueryRequest.jsonQuery(rawQuery, bucket, username, password, targetNode, query.params().clientContextId()); } else { return GenericQueryRequest.jsonQuery(rawQuery, bucket, username, password, query.params().clientContextId()); } }
@Override public Observable<AsyncN1qlQueryResult> query(N1qlQuery query, long timeout, TimeUnit timeUnit) { if (!query.params().hasServerSideTimeout()) { query.params().serverSideTimeout(timeout, timeUnit); } if (query.params().clientContextId() == null || query.params().clientContextId().isEmpty()) { query.params().withContextId(UUID.randomUUID().toString()); } return n1qlQueryExecutor.execute(query, environment, timeout, timeUnit); }
@Override public Observable<Boolean> createN1qlPrimaryIndex(final String customName, final boolean ignoreIfExist, boolean defer) { Statement createIndex; UsingWithPath usingWithPath = Index.createNamedPrimaryIndex(customName).on(bucket); if (defer) { createIndex = usingWithPath.withDefer(); } else { createIndex = usingWithPath; } return queryExecutor.execute(N1qlQuery.simple(createIndex), env, env.managementTimeout(), TimeUnit.MILLISECONDS) .compose(checkIndexCreation(ignoreIfExist, "Error creating custom primary index " + customName)); }
protected static N1qlQuery buildQuery(Statement statement, JsonValue queryPlaceholderValues, ScanConsistency scanConsistency) { N1qlParams n1qlParams = N1qlParams.build().consistency(scanConsistency); N1qlQuery query; if (queryPlaceholderValues instanceof JsonObject && !((JsonObject) queryPlaceholderValues).isEmpty()) { query = N1qlQuery.parameterized(statement, (JsonObject) queryPlaceholderValues, n1qlParams); } else if (queryPlaceholderValues instanceof JsonArray && !((JsonArray) queryPlaceholderValues).isEmpty()) { query = N1qlQuery.parameterized(statement, (JsonArray) queryPlaceholderValues, n1qlParams); } else { query = N1qlQuery.simple(statement, n1qlParams); } return query; }
throws Exception { String readQuery = "SELECT " + joinFields(fields) + " FROM `" + bucketName + "` USE KEYS [$1]"; N1qlQueryResult queryResult = bucket.query(N1qlQuery.parameterized( readQuery, JsonArray.from(docId),
private void logIfNecessary(N1qlQuery query) { if (LOG.isDebugEnabled()) { LOG.debug("Executing N1QL query: " + query.n1ql()); } }
public Observable<AsyncN1qlQueryResult> execute(final N1qlQuery query, CouchbaseEnvironment env, long timeout, TimeUnit timeUnit) { if (query.params().isAdhoc()) { return executeQuery(query, env, timeout, timeUnit); } else { return dispatchPrepared(query, env, timeout, timeUnit); } }
@Override public Observable<Boolean> createN1qlIndex(final String indexName, List<Object> fields, Expression whereClause, final boolean ignoreIfExist, boolean defer) { if (fields == null || fields.isEmpty()) { throw new IllegalArgumentException("At least one field is required for secondary index"); } int i = -1; Expression firstExpression = expressionOrIdentifier(fields.get(0)); Expression[] otherExpressions = new Expression[fields.size() - 1]; for (Object field : fields) { if (i > -1) { otherExpressions[i] = expressionOrIdentifier(field); } //otherwise skip first expression, already processed i++; } Statement createIndex; UsingWithPath usingWithPath; if (whereClause != null) { usingWithPath = Index.createIndex(indexName).on(bucket, firstExpression, otherExpressions).where(whereClause); } else { usingWithPath = Index.createIndex(indexName).on(bucket, firstExpression, otherExpressions); } if (defer) { createIndex = usingWithPath.withDefer(); } else { createIndex = usingWithPath; } return queryExecutor.execute(N1qlQuery.simple(createIndex), env, env.managementTimeout(), TimeUnit.MILLISECONDS) .compose(checkIndexCreation(ignoreIfExist, "Error creating secondary index " + indexName)); }
/** * Run a {@link N1qlQuery#simple(Statement)} query. * * @param statement Statement. * @param <T> Entity type. * @return A list of results. * @see N1Q#from(Class) */ default <T> Observable<List<T>> query(final Statement statement) { return query(N1qlQuery.simple(statement)); }
/** * Creates N1QLQuery object from the statement, query placeholder values and scan consistency * * @param statement * @param queryPlaceholderValues * @param scanConsistency * @return */ public static N1qlQuery buildQuery(Statement statement, JsonValue queryPlaceholderValues, ScanConsistency scanConsistency) { N1qlParams n1qlParams = N1qlParams.build().consistency(scanConsistency); N1qlQuery query; if (queryPlaceholderValues instanceof JsonObject && !((JsonObject) queryPlaceholderValues).isEmpty()) { query = N1qlQuery.parameterized(statement, (JsonObject) queryPlaceholderValues, n1qlParams); } else if (queryPlaceholderValues instanceof JsonArray && !((JsonArray) queryPlaceholderValues).isEmpty()) { query = N1qlQuery.parameterized(statement, (JsonArray) queryPlaceholderValues, n1qlParams); } else { query = N1qlQuery.simple(statement, n1qlParams); } return query; }