diff --git a/pom.xml b/pom.xml
index df7d18a8..9e013040 100644
--- a/pom.xml
+++ b/pom.xml
@@ -21,7 +21,7 @@
 
         <dist.key>DATACOUCH</dist.key>
 
-        <couchbase>2.2.0-dp2</couchbase>
+        <couchbase>2.2.0</couchbase>
         <couchbase.osgi>2.2.0</couchbase.osgi>
         <jackson>2.6.0</jackson>
         <springdata.commons>1.11.0.BUILD-SNAPSHOT</springdata.commons>
@@ -127,14 +127,6 @@
             <id>spring-libs-snapshot</id>
             <url>https://repo.spring.io/libs-snapshot</url>
         </repository>
-        <repository>
-            <id>couchbase</id>
-            <name>couchbase repo</name>
-            <url>http://files.couchbase.com/maven2</url>
-            <snapshots>
-                <enabled>false</enabled>
-            </snapshots>
-        </repository>
     </repositories>
 
     <pluginRepositories>
diff --git a/src/integration/java/org/springframework/data/couchbase/core/CouchbaseTemplateTests.java b/src/integration/java/org/springframework/data/couchbase/core/CouchbaseTemplateTests.java
index 81c5829c..f97f59f7 100644
--- a/src/integration/java/org/springframework/data/couchbase/core/CouchbaseTemplateTests.java
+++ b/src/integration/java/org/springframework/data/couchbase/core/CouchbaseTemplateTests.java
@@ -36,8 +36,8 @@ import java.util.Random;
 import com.couchbase.client.java.Bucket;
 import com.couchbase.client.java.document.RawJsonDocument;
 import com.couchbase.client.java.error.DocumentDoesNotExistException;
-import com.couchbase.client.java.query.Query;
-import com.couchbase.client.java.query.QueryResult;
+import com.couchbase.client.java.query.N1qlQuery;
+import com.couchbase.client.java.query.N1qlQueryResult;
 import com.couchbase.client.java.query.dsl.Expression;
 import com.couchbase.client.java.view.Stale;
 import com.couchbase.client.java.view.ViewQuery;
@@ -226,10 +226,10 @@ public class CouchbaseTemplateTests {
 
 	@Test
 	public void shouldQueryRaw() {
-		Query query = Query.simple(select("name").from(i(client.name()))
+		N1qlQuery query = N1qlQuery.simple(select("name").from(i(client.name()))
 				.where(x("name").isNotMissing()));
 
-		QueryResult queryResult = template.queryN1QL(query);
+		N1qlQueryResult queryResult = template.queryN1QL(query);
 		assertNotNull(queryResult);
 		assertTrue(queryResult.errors().toString(), queryResult.finalSuccess());
 		assertFalse(queryResult.allRows().isEmpty());
@@ -241,7 +241,7 @@ public class CouchbaseTemplateTests {
 		FullFragment ff2 = new FullFragment("fullFragment2", 2, "fullFragment", "test2");
 		template.save(Arrays.asList(ff1, ff2));
 
-		Query query = Query.simple(select(i("value")) //"value" is a n1ql keyword apparently
+		N1qlQuery query = N1qlQuery.simple(select(i("value")) //"value" is a n1ql keyword apparently
 				.from(i(client.name()))
 				.where(x("type").eq(s("fullFragment"))
 				.and(x("criteria").gt(1))));
diff --git a/src/integration/java/org/springframework/data/couchbase/repository/feature/FeatureDetectionRepositoryTests.java b/src/integration/java/org/springframework/data/couchbase/repository/feature/FeatureDetectionRepositoryTests.java
index 1f57cf13..f0bec185 100644
--- a/src/integration/java/org/springframework/data/couchbase/repository/feature/FeatureDetectionRepositoryTests.java
+++ b/src/integration/java/org/springframework/data/couchbase/repository/feature/FeatureDetectionRepositoryTests.java
@@ -21,7 +21,7 @@ import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.fail;
 
 import com.couchbase.client.java.cluster.ClusterInfo;
-import com.couchbase.client.java.query.Query;
+import com.couchbase.client.java.query.N1qlQuery;
 import com.couchbase.client.java.util.features.CouchbaseFeature;
 import com.couchbase.client.java.util.features.Version;
 import org.junit.Assume;
@@ -79,7 +79,7 @@ public class FeatureDetectionRepositoryTests {
 
   @Test
   public void testN1qlIncompatibleClusterTemplateFails() {
-    Query query = Query.simple("SELECT * FROM `" + template.getCouchbaseBucket().name() + "`");
+    N1qlQuery query = N1qlQuery.simple("SELECT * FROM `" + template.getCouchbaseBucket().name() + "`");
     try {
       template.findByN1QL(query, User.class);
       fail("expected findByN1QL to fail with UnsupportedCouchbaseFeatureException");
diff --git a/src/main/java/org/springframework/data/couchbase/config/AbstractCouchbaseConfiguration.java b/src/main/java/org/springframework/data/couchbase/config/AbstractCouchbaseConfiguration.java
index 7faf66c3..b2e53fe9 100644
--- a/src/main/java/org/springframework/data/couchbase/config/AbstractCouchbaseConfiguration.java
+++ b/src/main/java/org/springframework/data/couchbase/config/AbstractCouchbaseConfiguration.java
@@ -27,7 +27,7 @@ import com.couchbase.client.java.CouchbaseCluster;
 import com.couchbase.client.java.cluster.ClusterInfo;
 import com.couchbase.client.java.env.CouchbaseEnvironment;
 import com.couchbase.client.java.env.DefaultCouchbaseEnvironment;
-import com.couchbase.client.java.query.Query;
+import com.couchbase.client.java.query.N1qlQuery;
 import com.couchbase.client.java.view.ViewQuery;
 
 import org.springframework.beans.factory.config.BeanDefinition;
@@ -268,7 +268,7 @@ public abstract class AbstractCouchbaseConfiguration {
 
   /**
    * Configures the default consistency for generated {@link ViewQuery view queries}
-   * and {@link Query N1QL queries} in repositories.
+   * and {@link N1qlQuery N1QL queries} in repositories.
    *
    * @return the {@link Consistency consistency} to apply by default on generated queries.
    */
diff --git a/src/main/java/org/springframework/data/couchbase/config/CouchbaseEnvironmentNoShutdownProxy.java b/src/main/java/org/springframework/data/couchbase/config/CouchbaseEnvironmentNoShutdownProxy.java
index 8597cb0b..93821210 100644
--- a/src/main/java/org/springframework/data/couchbase/config/CouchbaseEnvironmentNoShutdownProxy.java
+++ b/src/main/java/org/springframework/data/couchbase/config/CouchbaseEnvironmentNoShutdownProxy.java
@@ -250,8 +250,8 @@ public class CouchbaseEnvironmentNoShutdownProxy implements CouchbaseEnvironment
   }
 
   @Override
-  public MetricsCollector systemMetricsCollector() {
-    return delegate.systemMetricsCollector();
+  public MetricsCollector runtimeMetricsCollector() {
+    return delegate.runtimeMetricsCollector();
   }
 
   @Override
diff --git a/src/main/java/org/springframework/data/couchbase/core/CouchbaseOperations.java b/src/main/java/org/springframework/data/couchbase/core/CouchbaseOperations.java
index 342b625d..70893c59 100644
--- a/src/main/java/org/springframework/data/couchbase/core/CouchbaseOperations.java
+++ b/src/main/java/org/springframework/data/couchbase/core/CouchbaseOperations.java
@@ -24,9 +24,9 @@ import com.couchbase.client.java.Bucket;
 import com.couchbase.client.java.PersistTo;
 import com.couchbase.client.java.ReplicateTo;
 import com.couchbase.client.java.cluster.ClusterInfo;
-import com.couchbase.client.java.query.Query;
-import com.couchbase.client.java.query.QueryParams;
-import com.couchbase.client.java.query.QueryResult;
+import com.couchbase.client.java.query.N1qlQuery;
+import com.couchbase.client.java.query.N1qlQueryResult;
+import com.couchbase.client.java.query.N1qlParams;
 import com.couchbase.client.java.query.Statement;
 import com.couchbase.client.java.view.ViewQuery;
 import com.couchbase.client.java.view.ViewResult;
@@ -219,11 +219,11 @@ public interface CouchbaseOperations {
    * {@value #SELECT_CAS} (document id and cas, obtained through N1QL's
    * "{@code META(bucket).id AS} {@value #SELECT_ID}" and
    * "{@code META(bucket).cas AS} {@value #SELECT_CAS}").
-   * <p>This is done via a {@link Query} that contains a {@link Statement} and possibly
-   * additional query parameters ({@link QueryParams}) and placeholder values if the
+   * <p>This is done via a {@link N1qlQuery} that contains a {@link Statement} and possibly
+   * additional query parameters ({@link N1qlParams}) and placeholder values if the
    * statement contains placeholders.
    * <br/>
-   * Use {@link Query}'s factory methods to construct such a Query.</p>
+   * Use {@link N1qlQuery}'s factory methods to construct such a Query.</p>
    *
    * @param n1ql the N1QL query.
    * @param entityClass the target class for the returned entities.
@@ -231,38 +231,38 @@ public interface CouchbaseOperations {
    * @return the list of entities matching this query.
    * @throws CouchbaseQueryExecutionException if the id and cas are not selected.
    */
-  <T> List<T> findByN1QL(Query n1ql, Class<T> entityClass);
+  <T> List<T> findByN1QL(N1qlQuery n1ql, Class<T> entityClass);
 
   /**
    * Query the N1QL Service for partial JSON data of type T. The selected field will be
    * used in a {@link TranslationService#decodeFragment(String, Class) straightforward decoding}
    * (no document, metadata like id nor cas) to map to a "fragment class".
-   * <p>This is done via a {@link Query} that contains a {@link Statement} and possibly
-   * additional query parameters ({@link QueryParams}) and placeholder values if the
+   * <p>This is done via a {@link N1qlQuery} that contains a {@link Statement} and possibly
+   * additional query parameters ({@link N1qlParams}) and placeholder values if the
    * statement contains placeholders.
    * <br/>
-   * Use {@link Query}'s factory methods to construct such a Query.</p>
+   * Use {@link N1qlQuery}'s factory methods to construct such a Query.</p>
    *
    * @param n1ql the N1QL query.
    * @param fragmentClass the target class for the returned fragments.
    * @param <T> the fragment class
    * @return the list of entities matching this query.
    */
-  <T> List<T> findByN1QLProjection(Query n1ql, Class<T> fragmentClass);
+  <T> List<T> findByN1QLProjection(N1qlQuery n1ql, Class<T> fragmentClass);
 
   /**
-   * Query the N1QL Service with direct access to the {@link QueryResult}.
+   * Query the N1QL Service with direct access to the {@link N1qlQueryResult}.
    * <p>
-   * This is done via a {@link Query} that can
-   * contain a {@link Statement}, additional query parameters ({@link QueryParams})
+   * This is done via a {@link N1qlQuery} that can
+   * contain a {@link Statement}, additional query parameters ({@link N1qlParams})
    * and placeholder values if the statement contains placeholders.</p>
    * <p>
-   * Use {@link Query}'s factory methods to construct this.</p>
+   * Use {@link N1qlQuery}'s factory methods to construct this.</p>
    *
    * @param n1ql the N1QL query.
-   * @return {@link QueryResult} containing the results of the n1ql query.
+   * @return {@link N1qlQueryResult} containing the results of the n1ql query.
    */
-  QueryResult queryN1QL(Query n1ql);
+  N1qlQueryResult queryN1QL(N1qlQuery n1ql);
 
   /**
    * Checks if the given document exists.
diff --git a/src/main/java/org/springframework/data/couchbase/core/CouchbaseTemplate.java b/src/main/java/org/springframework/data/couchbase/core/CouchbaseTemplate.java
index 9f5c0612..01432214 100644
--- a/src/main/java/org/springframework/data/couchbase/core/CouchbaseTemplate.java
+++ b/src/main/java/org/springframework/data/couchbase/core/CouchbaseTemplate.java
@@ -35,10 +35,10 @@ import com.couchbase.client.java.document.RawJsonDocument;
 import com.couchbase.client.java.document.json.JsonObject;
 import com.couchbase.client.java.error.CASMismatchException;
 import com.couchbase.client.java.error.TranscodingException;
-import com.couchbase.client.java.query.Query;
-import com.couchbase.client.java.query.QueryParams;
-import com.couchbase.client.java.query.QueryResult;
-import com.couchbase.client.java.query.QueryRow;
+import com.couchbase.client.java.query.N1qlQuery;
+import com.couchbase.client.java.query.N1qlQueryResult;
+import com.couchbase.client.java.query.N1qlQueryRow;
+import com.couchbase.client.java.query.N1qlParams;
 import com.couchbase.client.java.query.consistency.ScanConsistency;
 import com.couchbase.client.java.util.features.CouchbaseFeature;
 import com.couchbase.client.java.view.ViewQuery;
@@ -327,15 +327,15 @@ public class CouchbaseTemplate implements CouchbaseOperations, ApplicationEventP
   }
 
   @Override
-  public <T> List<T> findByN1QL(Query n1ql, Class<T> entityClass) {
+  public <T> List<T> findByN1QL(N1qlQuery n1ql, Class<T> entityClass) {
     checkN1ql();
     try {
-      QueryResult queryResult = queryN1QL(n1ql);
+      N1qlQueryResult queryResult = queryN1QL(n1ql);
 
       if (queryResult.finalSuccess()) {
-        List<QueryRow> allRows = queryResult.allRows();
+        List<N1qlQueryRow> allRows = queryResult.allRows();
         List<T> result = new ArrayList<T>(allRows.size());
-        for (QueryRow row : allRows) {
+        for (N1qlQueryRow row : allRows) {
           JsonObject json = row.value();
           String id = json.getString(SELECT_ID);
           Long cas = json.getLong(SELECT_CAS);
@@ -364,15 +364,15 @@ public class CouchbaseTemplate implements CouchbaseOperations, ApplicationEventP
   }
 
   @Override
-  public <T> List<T> findByN1QLProjection(Query n1ql, Class<T> entityClass) {
+  public <T> List<T> findByN1QLProjection(N1qlQuery n1ql, Class<T> entityClass) {
     checkN1ql();
     try {
-      QueryResult queryResult = queryN1QL(n1ql);
+      N1qlQueryResult queryResult = queryN1QL(n1ql);
 
       if (queryResult.finalSuccess()) {
-        List<QueryRow> allRows = queryResult.allRows();
+        List<N1qlQueryRow> allRows = queryResult.allRows();
         List<T> result = new ArrayList<T>(allRows.size());
-        for (QueryRow row : allRows) {
+        for (N1qlQueryRow row : allRows) {
           JsonObject json = row.value();
           T decoded = translationService.decodeFragment(json.toString(), entityClass);
           result.add(decoded);
@@ -393,11 +393,11 @@ public class CouchbaseTemplate implements CouchbaseOperations, ApplicationEventP
   }
 
   @Override
-  public QueryResult queryN1QL(final Query query) {
+  public N1qlQueryResult queryN1QL(final N1qlQuery query) {
     checkN1ql();
-    return execute(new BucketCallback<QueryResult>() {
+    return execute(new BucketCallback<N1qlQueryResult>() {
       @Override
-      public QueryResult doInBucket() throws TimeoutException, ExecutionException, InterruptedException {
+      public N1qlQueryResult doInBucket() throws TimeoutException, ExecutionException, InterruptedException {
         return client.query(query);
       }
     });
diff --git a/src/main/java/org/springframework/data/couchbase/core/convert/translation/TranslationService.java b/src/main/java/org/springframework/data/couchbase/core/convert/translation/TranslationService.java
index 4e9cde91..2f5cd453 100644
--- a/src/main/java/org/springframework/data/couchbase/core/convert/translation/TranslationService.java
+++ b/src/main/java/org/springframework/data/couchbase/core/convert/translation/TranslationService.java
@@ -16,7 +16,7 @@
 
 package org.springframework.data.couchbase.core.convert.translation;
 
-import com.couchbase.client.java.query.QueryRow;
+import com.couchbase.client.java.query.N1qlQueryRow;
 
 import org.springframework.data.couchbase.core.mapping.CouchbaseDocument;
 import org.springframework.data.couchbase.core.mapping.CouchbaseStorable;
@@ -48,7 +48,7 @@ public interface TranslationService {
   /**
    * Decodes an ad-hoc JSON object into a corresponding "case" class.
    *
-   * @param source the JSON for the ad-hoc JSON object (from a N1QL {@link QueryRow} for instance).
+   * @param source the JSON for the ad-hoc JSON object (from a N1QL {@link N1qlQueryRow} for instance).
    * @param target the target class information.
    * @param <T> the target class.
    * @return an ad-hoc instance of the decoded JSON into the corresponding "case" class.
diff --git a/src/main/java/org/springframework/data/couchbase/repository/query/AbstractN1qlBasedQuery.java b/src/main/java/org/springframework/data/couchbase/repository/query/AbstractN1qlBasedQuery.java
index 4628bba5..c40966f1 100644
--- a/src/main/java/org/springframework/data/couchbase/repository/query/AbstractN1qlBasedQuery.java
+++ b/src/main/java/org/springframework/data/couchbase/repository/query/AbstractN1qlBasedQuery.java
@@ -19,9 +19,9 @@ package org.springframework.data.couchbase.repository.query;
 import java.util.List;
 
 import com.couchbase.client.java.document.json.JsonArray;
-import com.couchbase.client.java.query.Query;
-import com.couchbase.client.java.query.QueryParams;
-import com.couchbase.client.java.query.QueryResult;
+import com.couchbase.client.java.query.N1qlQuery;
+import com.couchbase.client.java.query.N1qlQueryResult;
+import com.couchbase.client.java.query.N1qlParams;
 import com.couchbase.client.java.query.Statement;
 import com.couchbase.client.java.query.consistency.ScanConsistency;
 import org.slf4j.Logger;
@@ -41,7 +41,7 @@ import org.springframework.util.Assert;
 
 /**
  * Abstract base for all Couchbase {@link RepositoryQuery}. It is in charge of inspecting the parameters
- * and choosing the correct {@link Query} implementation to use.
+ * and choosing the correct {@link N1qlQuery} implementation to use.
  */
 public abstract class AbstractN1qlBasedQuery implements RepositoryQuery {
 
@@ -68,32 +68,32 @@ public abstract class AbstractN1qlBasedQuery implements RepositoryQuery {
     JsonArray queryPlaceholderValues = getPlaceholderValues(accessor);
 
     //prepare the final query
-    Query query = buildQuery(statement, queryPlaceholderValues,
+    N1qlQuery query = buildQuery(statement, queryPlaceholderValues,
         getCouchbaseOperations().getDefaultConsistency().n1qlConsistency());
 
     //prepare a count query
     //TODO only do that when necessary (isPageQuery or isSliceQuery)
     Statement countStatement = getCount(accessor);
-    Query countQuery = buildQuery(countStatement, queryPlaceholderValues,
+    N1qlQuery countQuery = buildQuery(countStatement, queryPlaceholderValues,
         getCouchbaseOperations().getDefaultConsistency().n1qlConsistency());
 
     return executeDependingOnType(query, countQuery, queryMethod, accessor.getPageable(),
         queryMethod.isPageQuery(), queryMethod.isSliceQuery(), queryMethod.isModifyingQuery());
   }
 
-  protected static Query buildQuery(Statement statement, JsonArray queryPlaceholderValues, ScanConsistency scanConsistency) {
-    QueryParams queryParams = QueryParams.build().consistency(scanConsistency);
-    Query query;
+  protected static N1qlQuery buildQuery(Statement statement, JsonArray queryPlaceholderValues, ScanConsistency scanConsistency) {
+    N1qlParams n1qlParams = N1qlParams.build().consistency(scanConsistency);
+    N1qlQuery query;
     if (!queryPlaceholderValues.isEmpty()) {
-      query = Query.parameterized(statement, queryPlaceholderValues, queryParams);
+      query = N1qlQuery.parameterized(statement, queryPlaceholderValues, n1qlParams);
     }
     else {
-      query = Query.simple(statement, queryParams);
+      query = N1qlQuery.simple(statement, n1qlParams);
     }
     return query;
   }
 
-  protected Object executeDependingOnType(Query query, Query countQuery, QueryMethod queryMethod, Pageable pageable,
+  protected Object executeDependingOnType(N1qlQuery query, N1qlQuery countQuery, QueryMethod queryMethod, Pageable pageable,
                                           boolean isPage, boolean isSlice, boolean isModifying) {
     if (isModifying) {
       throw new UnsupportedOperationException("Modifying queries not yet supported");
@@ -112,30 +112,30 @@ public abstract class AbstractN1qlBasedQuery implements RepositoryQuery {
     }
   }
 
-  private void logIfNecessary(Query query) {
+  private void logIfNecessary(N1qlQuery query) {
     if (LOG.isDebugEnabled()) {
       LOG.debug("Executing N1QL query: " + query.n1ql());
     }
   }
 
-  protected List<?> executeCollection(Query query) {
+  protected List<?> executeCollection(N1qlQuery query) {
     logIfNecessary(query);
     List<?> result = couchbaseOperations.findByN1QL(query, queryMethod.getEntityInformation().getJavaType());
     return result;
   }
 
-  protected Object executeEntity(Query query) {
+  protected Object executeEntity(N1qlQuery query) {
     logIfNecessary(query);
     List<?> result = executeCollection(query);
     return result.isEmpty() ? null : result.get(0);
   }
 
-  protected Object executeStream(Query query) {
+  protected Object executeStream(N1qlQuery query) {
     logIfNecessary(query);
     return StreamUtils.createStreamFromIterator(executeCollection(query).iterator());
   }
 
-  protected Object executePaged(Query query, Query countQuery, Pageable pageable) {
+  protected Object executePaged(N1qlQuery query, N1qlQuery countQuery, Pageable pageable) {
     Assert.notNull(pageable);
     long total = 0L;
     logIfNecessary(countQuery);
@@ -149,7 +149,7 @@ public abstract class AbstractN1qlBasedQuery implements RepositoryQuery {
     return new PageImpl(result, pageable, total);
   }
 
-  protected Object executeSliced(Query query, Query countQuery, Pageable pageable) {
+  protected Object executeSliced(N1qlQuery query, N1qlQuery countQuery, Pageable pageable) {
     Assert.notNull(pageable);
     logIfNecessary(query);
     List<?> result = couchbaseOperations.findByN1QL(query, queryMethod.getEntityInformation().getJavaType());
diff --git a/src/main/java/org/springframework/data/couchbase/repository/query/StringN1qlBasedQuery.java b/src/main/java/org/springframework/data/couchbase/repository/query/StringN1qlBasedQuery.java
index 5dfdc55a..3960e4c1 100644
--- a/src/main/java/org/springframework/data/couchbase/repository/query/StringN1qlBasedQuery.java
+++ b/src/main/java/org/springframework/data/couchbase/repository/query/StringN1qlBasedQuery.java
@@ -17,7 +17,7 @@
 package org.springframework.data.couchbase.repository.query;
 
 import com.couchbase.client.java.document.json.JsonArray;
-import com.couchbase.client.java.query.Query;
+import com.couchbase.client.java.query.N1qlQuery;
 import com.couchbase.client.java.query.Statement;
 
 import org.springframework.data.couchbase.core.CouchbaseOperations;
@@ -99,7 +99,7 @@ public class StringN1qlBasedQuery extends AbstractN1qlBasedQuery {
       result = result.replaceFirst("\\$FILTER_TYPE\\$", typeSelection);
     }
 
-    return Query.simple(result).statement();
+    return N1qlQuery.simple(result).statement();
   }
 
   @Override
diff --git a/src/main/java/org/springframework/data/couchbase/repository/support/N1qlCouchbaseRepository.java b/src/main/java/org/springframework/data/couchbase/repository/support/N1qlCouchbaseRepository.java
index bbb5a55f..141e71a4 100644
--- a/src/main/java/org/springframework/data/couchbase/repository/support/N1qlCouchbaseRepository.java
+++ b/src/main/java/org/springframework/data/couchbase/repository/support/N1qlCouchbaseRepository.java
@@ -19,7 +19,7 @@ package org.springframework.data.couchbase.repository.support;
 import java.io.Serializable;
 import java.util.List;
 
-import com.couchbase.client.java.query.Query;
+import com.couchbase.client.java.query.N1qlQuery;
 import com.couchbase.client.java.query.Statement;
 import com.couchbase.client.java.query.dsl.Expression;
 import com.couchbase.client.java.query.dsl.path.WherePath;
@@ -68,7 +68,7 @@ public class N1qlCouchbaseRepository<T, ID extends Serializable>
     Statement st = selectFrom.where(whereCriteria).orderBy(orderings);
 
     //fire the query
-    Query query = Query.simple(st);
+    N1qlQuery query = N1qlQuery.simple(st);
     return getCouchbaseOperations().findByN1QL(query, getEntityInformation().getJavaType());
   }
 
@@ -82,7 +82,7 @@ public class N1qlCouchbaseRepository<T, ID extends Serializable>
 
     //TODO how to avoid to do that more than once?
     //fire the count query and get total count
-    List<CountFragment> countResult = getCouchbaseOperations().findByN1QLProjection(Query.simple(countStatement), CountFragment.class);
+    List<CountFragment> countResult = getCouchbaseOperations().findByN1QLProjection(N1qlQuery.simple(countStatement), CountFragment.class);
     long totalCount = countResult == null || countResult.isEmpty() ? 0 : countResult.get(0).count;
 
     //prepare elements of the data query
@@ -94,7 +94,7 @@ public class N1qlCouchbaseRepository<T, ID extends Serializable>
     Statement pageStatement = selectFrom.where(whereCriteria).limit(pageable.getPageSize()).offset(pageable.getOffset());
 
     //fire the query
-    Query query = Query.simple(pageStatement);
+    N1qlQuery query = N1qlQuery.simple(pageStatement);
     List<T> pageContent = getCouchbaseOperations().findByN1QL(query, getEntityInformation().getJavaType());
 
     //return the list as a Page
diff --git a/src/test/java/org/springframework/data/couchbase/repository/query/AbstractN1qlBasedQueryTest.java b/src/test/java/org/springframework/data/couchbase/repository/query/AbstractN1qlBasedQueryTest.java
index ab3b5238..b776631e 100644
--- a/src/test/java/org/springframework/data/couchbase/repository/query/AbstractN1qlBasedQueryTest.java
+++ b/src/test/java/org/springframework/data/couchbase/repository/query/AbstractN1qlBasedQueryTest.java
@@ -9,10 +9,10 @@ import java.util.List;
 
 import com.couchbase.client.java.document.json.JsonArray;
 import com.couchbase.client.java.document.json.JsonObject;
-import com.couchbase.client.java.query.ParameterizedQuery;
-import com.couchbase.client.java.query.Query;
-import com.couchbase.client.java.query.QueryParams;
-import com.couchbase.client.java.query.SimpleQuery;
+import com.couchbase.client.java.query.ParameterizedN1qlQuery;
+import com.couchbase.client.java.query.N1qlQuery;
+import com.couchbase.client.java.query.N1qlParams;
+import com.couchbase.client.java.query.SimpleN1qlQuery;
 import com.couchbase.client.java.query.Statement;
 import com.couchbase.client.java.query.consistency.ScanConsistency;
 import org.junit.Test;
@@ -24,14 +24,14 @@ import org.springframework.data.repository.query.QueryMethod;
 public class AbstractN1qlBasedQueryTest {
 
   @Test
-  public void testEmptyArgumentsShouldProduceSimpleQuery() throws Exception {
+  public void testEmptyArgumentsShouldProduceSimpleN1qlQuery() throws Exception {
     Statement st = select("*");
-    Query query = AbstractN1qlBasedQuery.buildQuery(st, JsonArray.empty(), ScanConsistency.NOT_BOUNDED);
+    N1qlQuery query = AbstractN1qlBasedQuery.buildQuery(st, JsonArray.empty(), ScanConsistency.NOT_BOUNDED);
     JsonObject queryObject = query.n1ql();
 
-    assertTrue(query instanceof SimpleQuery);
+    assertTrue(query instanceof SimpleN1qlQuery);
     assertEquals(st.toString(), query.statement().toString());
-    assertEquals(QueryParams.build().consistency(ScanConsistency.NOT_BOUNDED), query.params());
+    assertEquals(N1qlParams.build().consistency(ScanConsistency.NOT_BOUNDED), query.params());
     assertFalse(queryObject.containsKey("args"));
   }
 
@@ -41,12 +41,12 @@ public class AbstractN1qlBasedQueryTest {
     List<Object> params = new ArrayList<Object>(2);
     params.add("test");
     JsonArray placeholderValues = JsonArray.from(params);
-    Query query = AbstractN1qlBasedQuery.buildQuery(st, placeholderValues, ScanConsistency.NOT_BOUNDED);
+    N1qlQuery query = AbstractN1qlBasedQuery.buildQuery(st, placeholderValues, ScanConsistency.NOT_BOUNDED);
     JsonObject queryObject = query.n1ql();
 
-    assertTrue(query instanceof ParameterizedQuery);
+    assertTrue(query instanceof ParameterizedN1qlQuery);
     assertEquals(st.toString(), query.statement().toString());
-    assertEquals(QueryParams.build().consistency(ScanConsistency.NOT_BOUNDED), query.params());
+    assertEquals(N1qlParams.build().consistency(ScanConsistency.NOT_BOUNDED), query.params());
     assertTrue(queryObject.containsKey("args"));
     JsonArray args = queryObject.getArray("args");
     assertEquals(1, args.size());
@@ -60,12 +60,12 @@ public class AbstractN1qlBasedQueryTest {
     params.add(123L);
     params.add("test");
     JsonArray placeholderValues = JsonArray.from(params);
-    Query query = AbstractN1qlBasedQuery.buildQuery(st, placeholderValues, ScanConsistency.NOT_BOUNDED);
+    N1qlQuery query = AbstractN1qlBasedQuery.buildQuery(st, placeholderValues, ScanConsistency.NOT_BOUNDED);
     JsonObject queryObject = query.n1ql();
 
-    assertTrue(query instanceof ParameterizedQuery);
+    assertTrue(query instanceof ParameterizedN1qlQuery);
     assertEquals(st.toString(), query.statement().toString());
-    assertEquals(QueryParams.build().consistency(ScanConsistency.NOT_BOUNDED), query.params());
+    assertEquals(N1qlParams.build().consistency(ScanConsistency.NOT_BOUNDED), query.params());
     assertTrue(queryObject.containsKey("args"));
     JsonArray args = queryObject.getArray("args");
     assertEquals(2, args.size());
@@ -76,112 +76,112 @@ public class AbstractN1qlBasedQueryTest {
   @Test
   public void shouldChooseCollectionExecutionWhenCollectionType() {
     CouchbaseQueryMethod queryMethod = Mockito.mock(CouchbaseQueryMethod.class);
-    Query query = Mockito.mock(Query.class);
+    N1qlQuery query = Mockito.mock(N1qlQuery.class);
     Pageable pageable = Mockito.mock(Pageable.class);
     AbstractN1qlBasedQuery mock = mock(AbstractN1qlBasedQuery.class);
-    when(mock.executeDependingOnType(any(Query.class), any(Query.class), any(QueryMethod.class), any(Pageable.class),
+    when(mock.executeDependingOnType(any(N1qlQuery.class), any(N1qlQuery.class), any(QueryMethod.class), any(Pageable.class),
         anyBoolean(), anyBoolean(), anyBoolean()))
         .thenCallRealMethod();
     when(queryMethod.isCollectionQuery()).thenReturn(true);
 
     mock.executeDependingOnType(query, query, queryMethod, pageable, false, false, false);
-    verify(mock).executeCollection(any(Query.class));
-    verify(mock, never()).executeEntity(any(Query.class));
-    verify(mock, never()).executeStream(any(Query.class));
-    verify(mock, never()).executePaged(any(Query.class), any(Query.class), any(Pageable.class));
-    verify(mock, never()).executeSliced(any(Query.class), any(Query.class), any(Pageable.class));
+    verify(mock).executeCollection(any(N1qlQuery.class));
+    verify(mock, never()).executeEntity(any(N1qlQuery.class));
+    verify(mock, never()).executeStream(any(N1qlQuery.class));
+    verify(mock, never()).executePaged(any(N1qlQuery.class), any(N1qlQuery.class), any(Pageable.class));
+    verify(mock, never()).executeSliced(any(N1qlQuery.class), any(N1qlQuery.class), any(Pageable.class));
   }
 
   @Test
   public void shouldChooseEntityExecutionWhenEntityType() {
     CouchbaseQueryMethod queryMethod = Mockito.mock(CouchbaseQueryMethod.class);
-    Query query = Mockito.mock(Query.class);
+    N1qlQuery query = Mockito.mock(N1qlQuery.class);
     Pageable pageable = Mockito.mock(Pageable.class);
     AbstractN1qlBasedQuery mock = mock(AbstractN1qlBasedQuery.class);
-    when(mock.executeDependingOnType(any(Query.class), any(Query.class), any(QueryMethod.class), any(Pageable.class),
+    when(mock.executeDependingOnType(any(N1qlQuery.class), any(N1qlQuery.class), any(QueryMethod.class), any(Pageable.class),
         anyBoolean(), anyBoolean(), anyBoolean()))
         .thenCallRealMethod();
     when(queryMethod.isQueryForEntity()).thenReturn(true);
 
     mock.executeDependingOnType(query, query, queryMethod, pageable, false, false, false);
-    verify(mock, never()).executeCollection(any(Query.class));
-    verify(mock).executeEntity(any(Query.class));
-    verify(mock, never()).executeStream(any(Query.class));
-    verify(mock, never()).executePaged(any(Query.class), any(Query.class), any(Pageable.class));
-    verify(mock, never()).executeSliced(any(Query.class), any(Query.class), any(Pageable.class));
+    verify(mock, never()).executeCollection(any(N1qlQuery.class));
+    verify(mock).executeEntity(any(N1qlQuery.class));
+    verify(mock, never()).executeStream(any(N1qlQuery.class));
+    verify(mock, never()).executePaged(any(N1qlQuery.class), any(N1qlQuery.class), any(Pageable.class));
+    verify(mock, never()).executeSliced(any(N1qlQuery.class), any(N1qlQuery.class), any(Pageable.class));
   }
 
   @Test
   public void shouldChooseStreamExecutionWhenStreamType() {
     CouchbaseQueryMethod queryMethod = Mockito.mock(CouchbaseQueryMethod.class);
-    Query query = Mockito.mock(Query.class);
+    N1qlQuery query = Mockito.mock(N1qlQuery.class);
     Pageable pageable = Mockito.mock(Pageable.class);
     AbstractN1qlBasedQuery mock = mock(AbstractN1qlBasedQuery.class);
-    when(mock.executeDependingOnType(any(Query.class), any(Query.class), any(QueryMethod.class), any(Pageable.class),
+    when(mock.executeDependingOnType(any(N1qlQuery.class), any(N1qlQuery.class), any(QueryMethod.class), any(Pageable.class),
         anyBoolean(), anyBoolean(), anyBoolean()))
         .thenCallRealMethod();
     when(queryMethod.isStreamQuery()).thenReturn(true);
 
     mock.executeDependingOnType(query, query, queryMethod, pageable, false, false, false);
-    verify(mock, never()).executeCollection(any(Query.class));
-    verify(mock, never()).executeEntity(any(Query.class));
-    verify(mock).executeStream(any(Query.class));
-    verify(mock, never()).executePaged(any(Query.class), any(Query.class), any(Pageable.class));
-    verify(mock, never()).executeSliced(any(Query.class), any(Query.class), any(Pageable.class));
+    verify(mock, never()).executeCollection(any(N1qlQuery.class));
+    verify(mock, never()).executeEntity(any(N1qlQuery.class));
+    verify(mock).executeStream(any(N1qlQuery.class));
+    verify(mock, never()).executePaged(any(N1qlQuery.class), any(N1qlQuery.class), any(Pageable.class));
+    verify(mock, never()).executeSliced(any(N1qlQuery.class), any(N1qlQuery.class), any(Pageable.class));
   }
 
   @Test
   public void shouldChoosePagedExecutionWhenPageType() {
     CouchbaseQueryMethod queryMethod = Mockito.mock(CouchbaseQueryMethod.class);
-    Query query = Mockito.mock(Query.class);
+    N1qlQuery query = Mockito.mock(N1qlQuery.class);
     Pageable pageable = Mockito.mock(Pageable.class);
     AbstractN1qlBasedQuery mock = mock(AbstractN1qlBasedQuery.class);
-    when(mock.executeDependingOnType(any(Query.class), any(Query.class), any(QueryMethod.class), any(Pageable.class),
+    when(mock.executeDependingOnType(any(N1qlQuery.class), any(N1qlQuery.class), any(QueryMethod.class), any(Pageable.class),
         anyBoolean(), anyBoolean(), anyBoolean()))
         .thenCallRealMethod();
 
     mock.executeDependingOnType(query, query, queryMethod, pageable, true, false, false);
-    verify(mock, never()).executeCollection(any(Query.class));
-    verify(mock, never()).executeEntity(any(Query.class));
-    verify(mock, never()).executeStream(any(Query.class));
-    verify(mock).executePaged(any(Query.class), any(Query.class), any(Pageable.class));
-    verify(mock, never()).executeSliced(any(Query.class), any(Query.class), any(Pageable.class));
+    verify(mock, never()).executeCollection(any(N1qlQuery.class));
+    verify(mock, never()).executeEntity(any(N1qlQuery.class));
+    verify(mock, never()).executeStream(any(N1qlQuery.class));
+    verify(mock).executePaged(any(N1qlQuery.class), any(N1qlQuery.class), any(Pageable.class));
+    verify(mock, never()).executeSliced(any(N1qlQuery.class), any(N1qlQuery.class), any(Pageable.class));
   }
 
   @Test
   public void shouldChooseSlicedExecutionWhenSliceType() {
     CouchbaseQueryMethod queryMethod = Mockito.mock(CouchbaseQueryMethod.class);
-    Query query = Mockito.mock(Query.class);
+    N1qlQuery query = Mockito.mock(N1qlQuery.class);
     Pageable pageable = Mockito.mock(Pageable.class);
     AbstractN1qlBasedQuery mock = mock(AbstractN1qlBasedQuery.class);
-    when(mock.executeDependingOnType(any(Query.class), any(Query.class), any(QueryMethod.class), any(Pageable.class),
+    when(mock.executeDependingOnType(any(N1qlQuery.class), any(N1qlQuery.class), any(QueryMethod.class), any(Pageable.class),
         anyBoolean(), anyBoolean(), anyBoolean()))
         .thenCallRealMethod();
     when(queryMethod.isSliceQuery()).thenReturn(true);
 
     mock.executeDependingOnType(query, query, queryMethod, pageable, false, true, false);
-    verify(mock, never()).executeCollection(any(Query.class));
-    verify(mock, never()).executeEntity(any(Query.class));
-    verify(mock, never()).executeStream(any(Query.class));
-    verify(mock, never()).executePaged(any(Query.class), any(Query.class), any(Pageable.class));
-    verify(mock).executeSliced(any(Query.class), any(Query.class), any(Pageable.class));
+    verify(mock, never()).executeCollection(any(N1qlQuery.class));
+    verify(mock, never()).executeEntity(any(N1qlQuery.class));
+    verify(mock, never()).executeStream(any(N1qlQuery.class));
+    verify(mock, never()).executePaged(any(N1qlQuery.class), any(N1qlQuery.class), any(Pageable.class));
+    verify(mock).executeSliced(any(N1qlQuery.class), any(N1qlQuery.class), any(Pageable.class));
   }
 
   @Test
   public void shouldThrowWhenUnsupportedType() throws NoSuchMethodException {
     CouchbaseQueryMethod queryMethod = Mockito.mock(CouchbaseQueryMethod.class);
-    Query query = Mockito.mock(Query.class);
+    N1qlQuery query = Mockito.mock(N1qlQuery.class);
     Pageable pageable = Mockito.mock(Pageable.class);
     AbstractN1qlBasedQuery mock = mock(AbstractN1qlBasedQuery.class);
-    when(mock.executeDependingOnType(any(Query.class), any(Query.class), any(QueryMethod.class), any(Pageable.class),
+    when(mock.executeDependingOnType(any(N1qlQuery.class), any(N1qlQuery.class), any(QueryMethod.class), any(Pageable.class),
         anyBoolean(), anyBoolean(), anyBoolean()))
         .thenCallRealMethod();
 
     try { mock.executeDependingOnType(query, query, queryMethod, pageable, false, false, true); fail(); } catch (UnsupportedOperationException e) { }
-    verify(mock, never()).executeCollection(any(Query.class));
-    verify(mock, never()).executeEntity(any(Query.class));
-    verify(mock, never()).executeStream(any(Query.class));
-    verify(mock, never()).executePaged(any(Query.class), any(Query.class), any(Pageable.class));
-    verify(mock, never()).executeSliced(any(Query.class), any(Query.class), any(Pageable.class));
+    verify(mock, never()).executeCollection(any(N1qlQuery.class));
+    verify(mock, never()).executeEntity(any(N1qlQuery.class));
+    verify(mock, never()).executeStream(any(N1qlQuery.class));
+    verify(mock, never()).executePaged(any(N1qlQuery.class), any(N1qlQuery.class), any(Pageable.class));
+    verify(mock, never()).executeSliced(any(N1qlQuery.class), any(N1qlQuery.class), any(Pageable.class));
   }
 }