diff --git a/gcloud-java-bigquery/src/main/java/com/google/gcloud/bigquery/QueryRequest.java b/gcloud-java-bigquery/src/main/java/com/google/gcloud/bigquery/QueryRequest.java
new file mode 100644
index 000000000000..717fe78e6fc2
--- /dev/null
+++ b/gcloud-java-bigquery/src/main/java/com/google/gcloud/bigquery/QueryRequest.java
@@ -0,0 +1,272 @@
+/*
+ * Copyright 2015 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.gcloud.bigquery;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.MoreObjects;
+
+import java.io.Serializable;
+import java.util.Objects;
+
+/**
+ * Google Cloud BigQuery Query Request. This class can be used to run a BigQuery SQL query and
+ * return results if the query completes within a specified timeout. The query results are saved to
+ * a temporary table that is deleted approximately 24 hours after the query is run. Query is run
+ * through a BigQuery Job whose identity can be accessed via {@link QueryResponse#job()}.
+ *
+ * @see <a href="https://cloud.google.com/bigquery/docs/reference/v2/jobs/query">Query</a>
+ */
+public class QueryRequest implements Serializable {
+
+  private static final long serialVersionUID = -8727328332415880852L;
+
+  private final String query;
+  private final Long maxResults;
+  private final DatasetId defaultDataset;
+  private final Long maxWaitTime;
+  private final Boolean dryRun;
+  private final Boolean useQueryCache;
+
+  public static final class Builder {
+
+    private String query;
+    private Long maxResults;
+    private DatasetId defaultDataset;
+    private Long maxWaitTime;
+    private Boolean dryRun;
+    private Boolean useQueryCache;
+
+    private Builder() {}
+
+    /**
+     * Sets the BigQuery query to be executed.
+     */
+    public Builder query(String query) {
+      this.query = query;
+      return this;
+    }
+
+    /**
+     * Sets the maximum number of rows of data to return per page of results. Setting this flag to a
+     * small value such as 1000 and then paging through results might improve reliability when the
+     * query result set is large. In addition to this limit, responses are also limited to 10 MB.
+     * By default, there is no maximum row count, and only the byte limit applies.
+     */
+    public Builder maxResults(Long maxResults) {
+      this.maxResults = maxResults;
+      return this;
+    }
+
+    /**
+     * Sets the default dataset to assume for any unqualified table names in the query.
+     */
+    public Builder defaultDataset(DatasetId defaultDataset) {
+      this.defaultDataset = defaultDataset;
+      return this;
+    }
+
+    /**
+     * Sets how long to wait for the query to complete, in milliseconds, before the request times
+     * out and returns. Note that this is only a timeout for the request, not the query. If the
+     * query takes longer to run than the timeout value, the call returns without any results and
+     * with the {@link QueryResponse#jobComplete()} set to {@code false}. You can call
+     * {@link BigQuery#getQueryResults(JobId, BigQuery.QueryResultsOption...)} to wait for the query
+     * to complete and read the results. The default value is 10000 milliseconds (10 seconds).
+     */
+    public Builder maxWaitTime(Long maxWaitTime) {
+      this.maxWaitTime = maxWaitTime;
+      return this;
+    }
+
+    /**
+     * Sets whether the query has to be dry run or not. If set, the query is not executed: if the
+     * query is valid statistics are returned on how many bytes would be processed, if the query is
+     * invalid an error is returned.
+     */
+    public Builder dryRun(Boolean dryRun) {
+      this.dryRun = dryRun;
+      return this;
+    }
+
+    /**
+     * Sets whether to look for the result in the query cache. The query cache is a best-effort
+     * cache that will be flushed whenever tables in the query are modified.
+     *
+     * @see <a href="https://cloud.google.com/bigquery/querying-data#querycaching">Query Caching</a>
+     */
+    public Builder useQueryCache(Boolean useQueryCache) {
+      this.useQueryCache = useQueryCache;
+      return this;
+    }
+
+    public QueryRequest build() {
+      return new QueryRequest(this);
+    }
+  }
+
+  private QueryRequest(Builder builder) {
+    query = checkNotNull(builder.query);
+    maxResults = builder.maxResults;
+    defaultDataset = builder.defaultDataset;
+    maxWaitTime = builder.maxWaitTime;
+    dryRun = builder.dryRun;
+    useQueryCache = builder.useQueryCache;
+  }
+
+  /**
+   * Sets the BigQuery query to be executed.
+   */
+  public String query() {
+    return query;
+  }
+
+  /**
+   * Returns the maximum number of rows of data to return per page of results.
+   */
+  public Long maxResults() {
+    return maxResults;
+  }
+
+  /**
+   * Returns the default dataset to assume for any unqualified table names in the query.
+   */
+  public DatasetId defaultDataset() {
+    return defaultDataset;
+  }
+
+  /**
+   * Returns how long to wait for the query to complete, in milliseconds, before the request times
+   * out and returns. Note that this is only a timeout for the request, not the query. If the
+   * query takes longer to run than the timeout value, the call returns without any results and
+   * with the {@link QueryResponse#jobComplete()} set to {@code false}. You can call
+   * {@link BigQuery#getQueryResults(JobId, BigQuery.QueryResultsOption...)} to wait for the query
+   * to complete and read the results. The default value is 10000 milliseconds (10 seconds).
+   */
+  public Long maxWaitTime() {
+    return maxWaitTime;
+  }
+
+  /**
+   * Returns whether the query has to be dry run or not. If set, the query is not executed: if the
+   * query is valid statistics are returned on how many bytes would be processed, if the query is
+   * invalid an error is returned.
+   */
+  public Boolean dryRun() {
+    return dryRun;
+  }
+
+  /**
+   * Returns whether to look for the result in the query cache. The query cache is a best-effort
+   * cache that will be flushed whenever tables in the query are modified.
+   *
+   * @see <a href="https://cloud.google.com/bigquery/querying-data#querycaching">Query Caching</a>
+   */
+  public Boolean useQueryCache() {
+    return useQueryCache;
+  }
+
+  /**
+   * Returns a builder for the {@code QueryRequest} object.
+   */
+  public Builder toBuilder() {
+    return new Builder()
+        .query(query)
+        .maxResults(maxResults)
+        .defaultDataset(defaultDataset)
+        .maxWaitTime(maxWaitTime)
+        .dryRun(dryRun)
+        .useQueryCache(useQueryCache);
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("query", query)
+        .add("maxResults", maxResults)
+        .add("defaultDataset", defaultDataset)
+        .add("maxWaitTime", maxWaitTime)
+        .add("dryRun", dryRun)
+        .add("useQueryCache", useQueryCache)
+        .toString();
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(query, maxResults, defaultDataset, maxWaitTime, dryRun, useQueryCache);
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    return obj instanceof QueryRequest && Objects.equals(toPb(), ((QueryRequest) obj).toPb());
+  }
+
+  com.google.api.services.bigquery.model.QueryRequest toPb() {
+    com.google.api.services.bigquery.model.QueryRequest queryRequestPb =
+        new com.google.api.services.bigquery.model.QueryRequest().setQuery(query);
+    if (maxResults != null) {
+      queryRequestPb.setMaxResults(maxResults);
+    }
+    if (defaultDataset != null) {
+      queryRequestPb.setDefaultDataset(defaultDataset.toPb());
+    }
+    if (maxWaitTime != null) {
+      queryRequestPb.setTimeoutMs(maxWaitTime);
+    }
+    if (dryRun != null) {
+      queryRequestPb.setDryRun(dryRun);
+    }
+    if (useQueryCache != null) {
+      queryRequestPb.setUseQueryCache(useQueryCache);
+    }
+    return queryRequestPb;
+  }
+
+  /**
+   * Creates a builder for a {@code QueryRequest} given the BigQuery SQL query to be executed.
+   */
+  public static Builder builder(String query) {
+    return new Builder().query(query);
+  }
+
+  /**
+   * Creates a {@code QueryRequest} object given the BigQuery SQL query to be executed.
+   */
+  public static QueryRequest of(String query) {
+    return new Builder().query(query).build();
+  }
+
+  static QueryRequest fromPb(com.google.api.services.bigquery.model.QueryRequest queryRequestPb) {
+    Builder builder = builder(queryRequestPb.getQuery());
+    if (queryRequestPb.getMaxResults() != null) {
+      builder.maxResults(queryRequestPb.getMaxResults());
+    }
+    if (queryRequestPb.getDefaultDataset() != null) {
+      builder.defaultDataset(DatasetId.fromPb(queryRequestPb.getDefaultDataset()));
+    }
+    if (queryRequestPb.getTimeoutMs() != null) {
+      builder.maxWaitTime(queryRequestPb.getTimeoutMs());
+    }
+    if (queryRequestPb.getDryRun() != null) {
+      builder.dryRun(queryRequestPb.getDryRun());
+    }
+    if (queryRequestPb.getUseQueryCache() != null) {
+      builder.useQueryCache(queryRequestPb.getUseQueryCache());
+    }
+    return builder.build();
+  }
+}
diff --git a/gcloud-java-bigquery/src/main/java/com/google/gcloud/bigquery/QueryResponse.java b/gcloud-java-bigquery/src/main/java/com/google/gcloud/bigquery/QueryResponse.java
new file mode 100644
index 000000000000..add54583f033
--- /dev/null
+++ b/gcloud-java-bigquery/src/main/java/com/google/gcloud/bigquery/QueryResponse.java
@@ -0,0 +1,233 @@
+/*
+ * Copyright 2015 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.gcloud.bigquery;
+
+import com.google.common.base.MoreObjects;
+import com.google.gcloud.Page;
+
+import java.io.Serializable;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * Google Cloud BigQuery Query Response. This class contains the results of a Query Job or of a
+ * Query Request.
+ */
+public class QueryResponse implements Serializable {
+
+  private static final long serialVersionUID = 3549226764825005655L;
+
+  private final String etag;
+  private final Schema schema;
+  private final JobId job;
+  private final Long totalRows;
+  private final Page<List<FieldValue>> rows;
+  private final Long totalBytesProcessed;
+  private final Boolean jobComplete;
+  private final List<BigQueryError> errors;
+  private final Boolean cacheHit;
+
+  static final class Builder {
+
+    private String etag;
+    private Schema schema;
+    private JobId job;
+    private Long totalRows;
+    private Page<List<FieldValue>> rows;
+    private Long totalBytesProcessed;
+    private Boolean jobComplete;
+    private List<BigQueryError> errors;
+    private Boolean cacheHit;
+
+    private Builder() {}
+
+    Builder etag(String etag) {
+      this.etag = etag;
+      return this;
+    }
+
+    Builder schema(Schema schema) {
+      this.schema = schema;
+      return this;
+    }
+
+    Builder job(JobId job) {
+      this.job = job;
+      return this;
+    }
+
+    Builder totalRows(Long totalRows) {
+      this.totalRows = totalRows;
+      return this;
+    }
+
+    Builder rows(Page<List<FieldValue>> rows) {
+      this.rows = rows;
+      return this;
+    }
+
+    Builder totalBytesProcessed(Long totalBytesProcessed) {
+      this.totalBytesProcessed = totalBytesProcessed;
+      return this;
+    }
+
+    Builder jobComplete(Boolean jobComplete) {
+      this.jobComplete = jobComplete;
+      return this;
+    }
+
+    Builder errors(List<BigQueryError> errors) {
+      this.errors = errors;
+      return this;
+    }
+
+    Builder cacheHit(Boolean cacheHit) {
+      this.cacheHit = cacheHit;
+      return this;
+    }
+
+    QueryResponse build() {
+      return new QueryResponse(this);
+    }
+  }
+
+  private QueryResponse(Builder builder) {
+    this.etag = builder.etag;
+    this.schema = builder.schema;
+    this.job = builder.job;
+    this.totalRows = builder.totalRows;
+    this.rows = builder.rows;
+    this.totalBytesProcessed = builder.totalBytesProcessed;
+    this.jobComplete = builder.jobComplete;
+    this.errors = builder.errors;
+    this.cacheHit = builder.cacheHit;
+  }
+
+  /**
+   * Returns the hash of the {@code QueryResponse} resource or {@code null} if not set.
+   */
+  public String etag() {
+    return etag;
+  }
+
+  /**
+   * Returns the schema of the results when the query completed successfully. Returns {@code null}
+   * otherwise.
+   */
+  public Schema schema() {
+    return schema;
+  }
+
+  /**
+   * Returns the identity of the BigQuery Job that was created to run the query. This field will be
+   * present even if the original request timed out.
+   */
+  public JobId job() {
+    return job;
+  }
+
+  /**
+   * Returns the total number of rows in the complete query result set, which can be more than the
+   * number of rows in the first page of results returned by {@link #rows()}. Returns {@code null}
+   * if the query did not complete successfully.
+   */
+  public Long totalRows() {
+    return totalRows;
+  }
+
+  /**
+   * Returns the query result as a paginated list of rows, if the query completed successfully.
+   * Returns {@code null} otherwise.
+   */
+  public Page<List<FieldValue>> rows() {
+    return rows;
+  }
+
+  /**
+   * Returns the total number of bytes processed for the query.
+   */
+  public Long totalBytesProcessed() {
+    return totalBytesProcessed;
+  }
+
+  /**
+   * Returns whether the job running the query has completed or not. If {@link #rows()} and
+   * {@link #totalRows()} are present, this method will always return {@code true}. If this method
+   * returns {@code false}, {@link #totalRows()} will not be available.
+   */
+  public Boolean jobComplete() {
+    return jobComplete;
+  }
+
+  /**
+   * Returns errors and warnings encountered during the running of the job, if any. Errors here do
+   * not necessarily mean that the job has completed or was unsuccessful.
+   */
+  public List<BigQueryError> errors() {
+    return errors;
+  }
+
+  /**
+   * Returns whether the query result was fetched from the query cache.
+   *
+   * @see <a href="https://cloud.google.com/bigquery/querying-data#querycaching">Query Caching</a>
+   */
+  public Boolean cacheHit() {
+    return cacheHit;
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("job", job)
+        .add("jobComplete", jobComplete)
+        .add("totalRows", totalRows)
+        .add("schema", schema)
+        .add("totalBytesProcessed", totalBytesProcessed)
+        .add("errors", errors)
+        .add("cacheHit", cacheHit)
+        .toString();
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(job);
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (this == obj) {
+      return true;
+    }
+    if (obj == null || getClass() != obj.getClass()) {
+      return false;
+    }
+    QueryResponse response = (QueryResponse) obj;
+    return Objects.equals(schema, response.schema)
+        && Objects.equals(job, response.job)
+        && Objects.equals(totalRows, response.totalRows)
+        && Objects.equals(rows, response.rows)
+        && Objects.equals(totalBytesProcessed, response.totalBytesProcessed)
+        && Objects.equals(jobComplete, response.jobComplete)
+        && Objects.equals(errors, response.errors)
+        && Objects.equals(cacheHit, response.cacheHit);
+  }
+
+  static Builder builder() {
+    return new Builder();
+  }
+}
\ No newline at end of file
diff --git a/gcloud-java-bigquery/src/test/java/com/google/gcloud/bigquery/QueryRequestTest.java b/gcloud-java-bigquery/src/test/java/com/google/gcloud/bigquery/QueryRequestTest.java
new file mode 100644
index 000000000000..f2ff83cc6009
--- /dev/null
+++ b/gcloud-java-bigquery/src/test/java/com/google/gcloud/bigquery/QueryRequestTest.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2015 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.gcloud.bigquery;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import org.junit.Test;
+
+public class QueryRequestTest {
+
+  private static final String QUERY = "BigQuery SQL";
+  private static final DatasetId DATASET_ID = DatasetId.of("project", "dataset");
+  private static final Boolean USE_QUERY_CACHE = true;
+  private static final Boolean DRY_RUN = false;
+  private static final Long MAX_RESULTS = 42L;
+  private static final Long MAX_WAIT_TIME = 42000L;
+  private static final QueryRequest QUERY_REQUEST = QueryRequest.builder(QUERY)
+      .useQueryCache(USE_QUERY_CACHE)
+      .defaultDataset(DATASET_ID)
+      .dryRun(DRY_RUN)
+      .maxResults(MAX_RESULTS)
+      .maxWaitTime(MAX_WAIT_TIME)
+      .build();
+
+  @Test
+  public void testToBuilder() {
+    compareQueryRequest(QUERY_REQUEST, QUERY_REQUEST.toBuilder().build());
+    QueryRequest queryRequest = QUERY_REQUEST.toBuilder()
+        .query("New BigQuery SQL")
+        .build();
+    assertEquals("New BigQuery SQL", queryRequest.query());
+    queryRequest = queryRequest.toBuilder().query(QUERY).build();
+    compareQueryRequest(QUERY_REQUEST, queryRequest);
+  }
+
+  @Test
+  public void testToBuilderIncomplete() {
+    QueryRequest queryRequest = QueryRequest.of(QUERY);
+    compareQueryRequest(queryRequest, queryRequest.toBuilder().build());
+  }
+
+  @Test
+  public void testBuilder() {
+    assertEquals(QUERY, QUERY_REQUEST.query());
+    assertEquals(USE_QUERY_CACHE, QUERY_REQUEST.useQueryCache());
+    assertEquals(DATASET_ID, QUERY_REQUEST.defaultDataset());
+    assertEquals(DRY_RUN, QUERY_REQUEST.dryRun());
+    assertEquals(MAX_RESULTS, QUERY_REQUEST.maxResults());
+    assertEquals(MAX_WAIT_TIME, QUERY_REQUEST.maxWaitTime());
+  }
+
+  @Test
+  public void testOf() {
+    QueryRequest request = QueryRequest.of(QUERY);
+    assertEquals(QUERY, request.query());
+    assertNull(request.useQueryCache());
+    assertNull(request.defaultDataset());
+    assertNull(request.dryRun());
+    assertNull(request.maxResults());
+    assertNull(request.maxWaitTime());
+  }
+
+  @Test
+  public void testToPbAndFromPb() {
+    compareQueryRequest(QUERY_REQUEST, QueryRequest.fromPb(QUERY_REQUEST.toPb()));
+    QueryRequest queryRequest = QueryRequest.of(QUERY);
+    compareQueryRequest(queryRequest, QueryRequest.fromPb(queryRequest.toPb()));
+  }
+
+  private void compareQueryRequest(QueryRequest expected, QueryRequest value) {
+    assertEquals(expected, value);
+    assertEquals(expected.query(), value.query());
+    assertEquals(expected.useQueryCache(), value.useQueryCache());
+    assertEquals(expected.defaultDataset(), value.defaultDataset());
+    assertEquals(expected.dryRun(), value.dryRun());
+    assertEquals(expected.maxResults(), value.maxResults());
+    assertEquals(expected.maxWaitTime(), value.maxWaitTime());
+  }
+}
diff --git a/gcloud-java-bigquery/src/test/java/com/google/gcloud/bigquery/QueryResponseTest.java b/gcloud-java-bigquery/src/test/java/com/google/gcloud/bigquery/QueryResponseTest.java
new file mode 100644
index 000000000000..f6f29e7b1312
--- /dev/null
+++ b/gcloud-java-bigquery/src/test/java/com/google/gcloud/bigquery/QueryResponseTest.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2015 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.gcloud.bigquery;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import com.google.common.collect.ImmutableList;
+import com.google.gcloud.Page;
+import com.google.gcloud.PageImpl;
+
+import org.junit.Test;
+
+import java.util.List;
+
+public class QueryResponseTest {
+
+  private static final String ETAG = "etag";
+  private static final Field FIELD_SCHEMA1 =
+      Field.builder("StringField", Field.Type.string())
+          .mode(Field.Mode.NULLABLE)
+          .description("FieldDescription1")
+          .build();
+  private static final Schema SCHEMA = Schema.of(FIELD_SCHEMA1);
+  private static final JobId JOB_ID = JobId.of("project", "job");
+  private static final Long TOTAL_ROWS = 42L;
+  private static final PageImpl.NextPageFetcher<List<FieldValue>> FETCHER =
+      new PageImpl.NextPageFetcher<List<FieldValue>>() {
+        @Override
+        public Page<List<FieldValue>> nextPage() {
+          return null;
+        }
+      };
+  private static final Page<List<FieldValue>> ROWS =
+      new PageImpl<List<FieldValue>>(FETCHER, "cursor", ImmutableList.<List<FieldValue>>of());
+  private static final Long TOTAL_BYTES_PROCESSED = 4200L;
+  private static final Boolean JOB_COMPLETE = true;
+  private static final List<BigQueryError> ERRORS = ImmutableList.of(
+      new BigQueryError("reason1", "location1", "message1", "debugInfo1"),
+      new BigQueryError("reason2", "location2", "message2", "debugInfo2")
+  );
+  private static final Boolean CACHE_HIT = false;
+  private static final QueryResponse QUERY_RESPONSE = QueryResponse.builder()
+      .etag(ETAG)
+      .schema(SCHEMA)
+      .job(JOB_ID)
+      .totalRows(TOTAL_ROWS)
+      .rows(ROWS)
+      .totalBytesProcessed(TOTAL_BYTES_PROCESSED)
+      .jobComplete(JOB_COMPLETE)
+      .errors(ERRORS)
+      .cacheHit(CACHE_HIT)
+      .build();
+
+  @Test
+  public void testBuilder() {
+    assertEquals(ETAG, QUERY_RESPONSE.etag());
+    assertEquals(SCHEMA, QUERY_RESPONSE.schema());
+    assertEquals(JOB_ID, QUERY_RESPONSE.job());
+    assertEquals(TOTAL_ROWS, QUERY_RESPONSE.totalRows());
+    assertEquals(ROWS, QUERY_RESPONSE.rows());
+    assertEquals(TOTAL_BYTES_PROCESSED, QUERY_RESPONSE.totalBytesProcessed());
+    assertEquals(JOB_COMPLETE, QUERY_RESPONSE.jobComplete());
+    assertEquals(ERRORS, QUERY_RESPONSE.errors());
+    assertEquals(CACHE_HIT, QUERY_RESPONSE.cacheHit());
+  }
+
+  @Test
+  public void testBuilderIncomplete() {
+    QueryResponse queryResponse = QueryResponse.builder().jobComplete(false).build();
+    assertNull(queryResponse.etag());
+    assertNull(queryResponse.schema());
+    assertNull(queryResponse.job());
+    assertNull(queryResponse.totalRows());
+    assertNull(queryResponse.rows());
+    assertNull(queryResponse.totalBytesProcessed());
+    assertEquals(false, queryResponse.jobComplete());
+    assertNull(queryResponse.errors());
+    assertNull(queryResponse.cacheHit());
+  }
+
+  @Test
+  public void testEquals() {
+    compareQueryResponse(QUERY_RESPONSE, QUERY_RESPONSE);
+  }
+
+  private void compareQueryResponse(QueryResponse expected, QueryResponse value) {
+    assertEquals(expected, value);
+    assertEquals(expected.etag(), value.etag());
+    assertEquals(expected.schema(), value.schema());
+    assertEquals(expected.job(), value.job());
+    assertEquals(expected.totalRows(), value.totalRows());
+    assertEquals(expected.rows(), value.rows());
+    assertEquals(expected.totalBytesProcessed(), value.totalBytesProcessed());
+    assertEquals(expected.jobComplete(), value.jobComplete());
+    assertEquals(expected.errors(), value.errors());
+    assertEquals(expected.cacheHit(), value.cacheHit());
+  }
+}