diff --git a/gcloud-java-bigquery/src/main/java/com/google/gcloud/bigquery/FieldValue.java b/gcloud-java-bigquery/src/main/java/com/google/gcloud/bigquery/FieldValue.java
new file mode 100644
index 000000000000..19d68bfb2678
--- /dev/null
+++ b/gcloud-java-bigquery/src/main/java/com/google/gcloud/bigquery/FieldValue.java
@@ -0,0 +1,232 @@
+/*
+ * 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.checkState;
+
+import com.google.api.client.util.Data;
+import com.google.api.client.util.Lists;
+import com.google.common.base.MoreObjects;
+
+import java.io.Serializable;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Google BigQuery Table Field Value class. Objects of this class represent values of a BigQuery
+ * Table Field. A list of values forms a {@link TableRow}. Tables rows can be gotten as the result
+ * of a query or when listing table data.
+ */
+public class FieldValue implements Serializable {
+
+  private static final int MICROSECONDS = 1000000;
+  private static final long serialVersionUID = 469098630191710061L;
+
+  private final Kind kind;
+  private final Object value;
+
+  /**
+   * The field value's kind, giving information on the field's content type.
+   */
+  public enum Kind {
+    /**
+     * A primitive field value. A {@code FieldValue} has type {@link #PRIMITIVE} when the
+     * corresponding field has type {@link Field.Type#bool()}, {@link Field.Type#string()}
+     * {@link Field.Type#floatingPoint()}, {@link Field.Type#integer()},
+     * {@link Field.Type#timestamp()} or the value is set to {@code null}.
+     */
+    PRIMITIVE,
+
+    /**
+     * A {@code FieldValue} for a field with {@link Field.Mode#REPEATED} mode.
+     */
+    REPEATED,
+
+    /**
+     * A {@code FieldValue} for a field of type {@link Field.Type#record(Field...)}.
+     */
+    RECORD
+  }
+
+  FieldValue(Kind kind, Object value) {
+    this.kind = kind;
+    this.value = value;
+  }
+
+  /**
+   * Returns the kind of this Field Value.
+   *
+   * @return {@link Kind#PRIMITIVE} if the value is of primitive type ({@link Field.Type#bool()},
+   *     {@link Field.Type#string()}, {@link Field.Type#floatingPoint()},
+   *     {@link Field.Type#integer()}, {@link Field.Type#timestamp()}) or is {@code null}. Returns
+   *     {@link Kind#REPEATED} if the corresponding field has ({@link Field.Mode#REPEATED}) mode.
+   *     Returns {@link Kind#RECORD} if the corresponding field has
+   *     {@link Field.Type#record(Field...)} type.
+   */
+  public Kind kind() {
+    return kind;
+  }
+
+  /**
+   * Return this field's value as an {@link Object}.
+   */
+  public Object value() {
+    return value;
+  }
+
+  /**
+   * Return this field's value as a {@link String}. This method should only be used if the
+   * corresponding field has primitive type ({@link Field.Type#bool()}, {@link Field.Type#string()},
+   * {@link Field.Type#floatingPoint()}, {@link Field.Type#integer()},
+   * {@link Field.Type#timestamp()}).
+   *
+   * @throws ClassCastException if the field has not primitive type
+   */
+  @SuppressWarnings("unchecked")
+  public String stringValue() {
+    return (String) value;
+  }
+
+  /**
+   * Returns this field's value as a {@link Long}. This method should only be used if the
+   * corresponding field has {@link Field.Type#integer()} type.
+   *
+   * @throws NumberFormatException if the field's value could not be converted to {@link Integer}
+   */
+  @SuppressWarnings("unchecked")
+  public long longValue() {
+    return Long.valueOf(stringValue());
+  }
+
+  /**
+   * Returns this field's value as a {@link Double}. This method should only be used if the
+   * corresponding field has {@link Field.Type#floatingPoint()} type.
+   *
+   * @throws NumberFormatException if the field's value could not be converted to {@link Double}
+   */
+  @SuppressWarnings("unchecked")
+  public double doubleValue() {
+    return Double.valueOf(stringValue());
+  }
+
+  /**
+   * Returns this field's value as a {@link Boolean}. This method should only be used if the
+   * corresponding field has {@link Field.Type#bool()} type.
+   *
+   * @throws IllegalStateException if the field's value could not be converted to {@link Boolean}
+   */
+  @SuppressWarnings("unchecked")
+  public boolean booleanValue() {
+    String stringValue = stringValue();
+    checkState(stringValue.equalsIgnoreCase("true") || stringValue.equalsIgnoreCase("false"),
+        "Field value is not of boolean type");
+    return Boolean.parseBoolean(stringValue);
+  }
+
+  /**
+   * Returns this field's value as a {@link Long}, representing a timestamp in microseconds. This
+   * method should only be used if the corresponding field has {@link Field.Type#timestamp()} type.
+   *
+   * @throws NumberFormatException if the field's value could not be converted to {@link Long}
+   */
+  @SuppressWarnings("unchecked")
+  public long timestampValue() {
+    return new Double(((Double.valueOf(stringValue())) * MICROSECONDS)).longValue();
+  }
+
+  /**
+   * Returns this field's value as a list of {@link FieldValue}. This method should only be used if
+   * the corresponding field has {@link Field.Mode#REPEATED} mode (i.e. {@link #kind()} is
+   * {@link Kind#REPEATED}).
+   *
+   * @throws ClassCastException if the field has not {@link Field.Mode#REPEATED} mode
+   */
+  @SuppressWarnings("unchecked")
+  public List<FieldValue> repeatedValue() {
+    return (List<FieldValue>) value;
+  }
+
+  /**
+   * Returns this field's value as a list of {@link FieldValue}. This method should only be used if
+   * the corresponding field has {@link Field.Type#record(Field...)} type (i.e. {@link #kind()} is
+   * {@link Kind#RECORD}).
+   *
+   * @throws ClassCastException if the field has not {@link Field.Type#record(Field...)} type
+   */
+  @SuppressWarnings("unchecked")
+  public List<FieldValue> recordValue() {
+    return (List<FieldValue>) value;
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("kind", kind)
+        .add("value", value)
+        .toString();
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(kind, value);
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (!(obj instanceof FieldValue)) {
+      return false;
+    }
+    FieldValue other = (FieldValue) obj;
+    return kind == other.kind && Objects.equals(value, other.value);
+  }
+
+  @SuppressWarnings("unchecked")
+  static FieldValue fromPb(Object cellPb) {
+    if (Data.isNull(cellPb)) {
+      return new FieldValue(Kind.PRIMITIVE, null);
+    }
+    if (cellPb instanceof String) {
+      return new FieldValue(Kind.PRIMITIVE, cellPb);
+    }
+    if (cellPb instanceof List) {
+      List<Object> cellsListPb = (List<Object>) cellPb;
+      List<FieldValue> repeatedCells = Lists.newArrayListWithCapacity(cellsListPb.size());
+      for (Object repeatedCellPb : cellsListPb) {
+        repeatedCells.add(FieldValue.fromPb(repeatedCellPb));
+      }
+      return new FieldValue(Kind.REPEATED, repeatedCells);
+    }
+    if (cellPb instanceof Map) {
+      Map<String, Object> cellMapPb = (Map<String, Object>) cellPb;
+      if (cellMapPb.containsKey("f")) {
+        List<Object> cellsListPb = (List<Object>) cellMapPb.get("f");
+        List<FieldValue> recordCells = Lists.newArrayListWithCapacity(cellsListPb.size());
+        for (Object repeatedCellPb : cellsListPb) {
+          recordCells.add(FieldValue.fromPb(repeatedCellPb));
+        }
+        return new FieldValue(Kind.RECORD, recordCells);
+      }
+      // This should never be the case when we are processing a first level table field (i.e. a
+      // row's field, not a record sub-field)
+      if (cellMapPb.containsKey("v")) {
+        return FieldValue.fromPb(cellMapPb.get("v"));
+      }
+    }
+    throw new AssertionError("Unexpected table cell format");
+  }
+}
diff --git a/gcloud-java-bigquery/src/main/java/com/google/gcloud/bigquery/InsertAllRequest.java b/gcloud-java-bigquery/src/main/java/com/google/gcloud/bigquery/InsertAllRequest.java
new file mode 100644
index 000000000000..bcc9e5691c20
--- /dev/null
+++ b/gcloud-java-bigquery/src/main/java/com/google/gcloud/bigquery/InsertAllRequest.java
@@ -0,0 +1,399 @@
+/*
+ * 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 com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+
+import java.io.Serializable;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Google Cloud BigQuery insert all request. This class can be used to stream data into BigQuery one
+ * record at a time without needing to run a load job. This approach enables querying data without
+ * the delay of running a load job. There are several important trade-offs to consider before
+ * choosing an approach.
+ *
+ * @see <a href="https://cloud.google.com/bigquery/streaming-data-into-bigquery">Streaming Data into
+ *     BigQuery</a>
+ */
+public class InsertAllRequest implements Serializable {
+
+  private static final long serialVersionUID = 211200307773853078L;
+
+  private final TableId table;
+  private final List<RowToInsert> rows;
+  private final Boolean skipInvalidRows;
+  private final Boolean ignoreUnknownValues;
+
+  /**
+   * A Google Big Query row to be inserted into a table. Each {@code RowToInsert} has an associated
+   * id used by BigQuery to detect duplicate insertion requests on a best-effort basis.
+   *
+   * <p>
+   * Example usage of creating a row to insert:
+   * <pre>    {@code
+   *   List<Long> repeatedFieldValue = Arrays.asList(1L, 2L);
+   *   Map<String, Object> recordContent = new HashMap<String, Object>();
+   *   recordContent.put("subfieldName1", "value");
+   *   recordContent.put("subfieldName2", repeatedFieldValue);
+   *   Map<String, Object> rowContent = new HashMap<String, Object>();
+   *   rowContent.put("fieldName1", true);
+   *   rowContent.put("fieldName2", recordContent);
+   *   RowToInsert row = new RowToInsert("rowId", rowContent);
+   * }</pre>
+   *
+   * @see <a href ="https://cloud.google.com/bigquery/streaming-data-into-bigquery#dataconsistency">
+   *     Data Consistency</a>
+   */
+  public static class RowToInsert implements Serializable {
+
+    private static final long serialVersionUID = 8563060538219179157L;
+
+    private final String id;
+    private final Map<String, Object> content;
+
+    RowToInsert(String id, Map<String, Object> content) {
+      this.id = id;
+      this.content = content;
+    }
+
+    /**
+     * Returns the id associated with the row. Returns {@code null} if not set.
+     */
+    public String id() {
+      return id;
+    }
+
+    /**
+     * Returns the actual content of the row, as a map.
+     */
+    public Map<String, Object> content() {
+      return content;
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("id", id)
+          .add("content", content)
+          .toString();
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(id, content);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+      if (!(obj instanceof RowToInsert)) {
+        return false;
+      }
+      RowToInsert other = (RowToInsert) obj;
+      return Objects.equals(id, other.id)
+          && Objects.equals(content, other.content);
+    }
+
+    /**
+     * Creates a row to be inserted.
+     *
+     * @param id id of the row, used to identify duplicates
+     * @param content the actual content of the row
+     */
+    public static RowToInsert of(String id, Map<String, Object> content) {
+      return new RowToInsert(checkNotNull(id), checkNotNull(content));
+    }
+  }
+
+  public static final class Builder {
+
+    private TableId table;
+    private List<RowToInsert> rows;
+    private Boolean skipInvalidRows;
+    private Boolean ignoreUnknownValues;
+
+    private Builder() {}
+
+    /**
+     * Sets the destination table for rows insert request.
+     */
+    public Builder table(TableId table) {
+      this.table = checkNotNull(table);
+      return this;
+    }
+
+    /**
+     * Sets the rows to insert as a list of {@link RowToInsert} objects.
+     */
+    public Builder rows(Iterable<RowToInsert> rows) {
+      this.rows = Lists.newLinkedList(checkNotNull(rows));
+      return this;
+    }
+
+    /**
+     * Adds a row to be inserted.
+     */
+    public Builder addRow(RowToInsert rowToInsert) {
+      checkNotNull(rowToInsert);
+      if (rows == null) {
+        rows = Lists.newArrayList();
+      }
+      rows.add(rowToInsert);
+      return this;
+    }
+
+    /**
+     * Adds a row to be inserted with associated id.
+     *
+     * <p>
+     * Example usage of adding a row with associated id:
+     * <pre>    {@code
+     *   InsertAllRequest.Buider builder = InsertAllRequest.builder(tableId);
+     *   List<Long> repeatedFieldValue = Arrays.asList(1L, 2L);
+     *   Map<String, Object> recordContent = new HashMap<String, Object>();
+     *   recordContent.put("subfieldName1", "value");
+     *   recordContent.put("subfieldName2", repeatedFieldValue);
+     *   Map<String, Object> rowContent = new HashMap<String, Object>();
+     *   rowContent.put("fieldName1", true);
+     *   rowContent.put("fieldName2", recordContent);
+     *   builder.addRow("rowId", rowContent);
+     * }</pre>
+     */
+    public Builder addRow(String id, Map<String, Object> content) {
+      addRow(new RowToInsert(id, content));
+      return this;
+    }
+
+    /**
+     * Adds a row to be inserted without an associated id.
+     *
+     * <p>
+     * Example usage of adding a row without an associated id:
+     * <pre>    {@code
+     *   InsertAllRequest.Buider builder = InsertAllRequest.builder(tableId);
+     *   List<Long> repeatedFieldValue = Arrays.asList(1L, 2L);
+     *   Map<String, Object> recordContent = new HashMap<String, Object>();
+     *   recordContent.put("subfieldName1", "value");
+     *   recordContent.put("subfieldName2", repeatedFieldValue);
+     *   Map<String, Object> rowContent = new HashMap<String, Object>();
+     *   rowContent.put("fieldName1", true);
+     *   rowContent.put("fieldName2", recordContent);
+     *   builder.addRow(rowContent);
+     * }</pre>
+     */
+    public Builder addRow(Map<String, Object> content) {
+      addRow(new RowToInsert(null, content));
+      return this;
+    }
+
+    /**
+     * Sets whether to insert all valid rows of a request, even if invalid rows exist. If not set
+     * the entire insert request will fail if it contains an invalid row.
+     */
+    public Builder skipInvalidRows(boolean skipInvalidRows) {
+      this.skipInvalidRows = skipInvalidRows;
+      return this;
+    }
+
+    /**
+     * Sets whether to accept rows that contain values that do not match the schema. The unknown
+     * values are ignored. If not set, rows with unknown values are considered to be invalid.
+     */
+    public Builder ignoreUnknownValues(boolean ignoreUnknownValues) {
+      this.ignoreUnknownValues = ignoreUnknownValues;
+      return this;
+    }
+
+    public InsertAllRequest build() {
+      return new InsertAllRequest(this);
+    }
+  }
+
+  private InsertAllRequest(Builder builder) {
+    this.table = checkNotNull(builder.table);
+    this.rows = ImmutableList.copyOf(checkNotNull(builder.rows));
+    this.ignoreUnknownValues = builder.ignoreUnknownValues;
+    this.skipInvalidRows = builder.skipInvalidRows;
+  }
+
+  /**
+   * Returns the destination table for rows insert request.
+   */
+  public TableId table() {
+    return table;
+  }
+
+  /**
+   * Returns the rows to be inserted.
+   */
+  public List<RowToInsert> rows() {
+    return rows;
+  }
+
+  /**
+   * Returns whether to accept rows that contain values that do not match the schema. The unknown
+   * values are ignored. If not set, rows with unknown values are considered to be invalid.
+   */
+  public Boolean ignoreUnknownValues() {
+    return ignoreUnknownValues;
+  }
+
+  /**
+   * Returns whether to insert all valid rows of a request, even if invalid rows exist. If not set
+   * the entire insert request will fail if it contains an invalid row.
+   */
+  public Boolean skipInvalidRows() {
+    return skipInvalidRows;
+  }
+
+  /**
+   * Returns a builder for an {@code InsertAllRequest} object given the destination table.
+   */
+  public static Builder builder(TableId table) {
+    return new Builder().table(table);
+  }
+
+  /**
+   * Returns a builder for an {@code InsertAllRequest} object given the destination table and the
+   * rows to insert.
+   */
+  public static Builder builder(TableId table, Iterable<RowToInsert> rows) {
+    return builder(table).rows(rows);
+  }
+
+  /**
+   * Returns a builder for an {@code InsertAllRequest} object given the destination table and the
+   * rows to insert.
+   */
+  public static Builder builder(TableId table, RowToInsert... rows) {
+    return builder(table, ImmutableList.copyOf(rows));
+  }
+
+  /**
+   * Returns a builder for an {@code InsertAllRequest} object given the destination table.
+   */
+  public static Builder builder(String datasetId, String tableId) {
+    return new Builder().table(TableId.of(datasetId, tableId));
+  }
+
+  /**
+   * Returns a builder for an {@code InsertAllRequest} object given the destination table and the
+   * rows to insert.
+   */
+  public static Builder builder(String datasetId, String tableId, Iterable<RowToInsert> rows) {
+    return builder(TableId.of(datasetId, tableId), rows);
+  }
+
+  /**
+   * Returns a builder for an {@code InsertAllRequest} object given the destination table and the
+   * rows to insert.
+   */
+  public static Builder builder(String datasetId, String tableId, RowToInsert... rows) {
+    return builder(TableId.of(datasetId, tableId), rows);
+  }
+
+  /**
+   * Returns a builder for an {@code InsertAllRequest} object given the destination table and the
+   * rows to insert.
+   */
+  public static Builder builder(BaseTableInfo tableInfo, Iterable<RowToInsert> rows) {
+    return builder(tableInfo.tableId(), rows);
+  }
+
+  /**
+   * Returns a builder for an {@code InsertAllRequest} object given the destination table and the
+   * rows to insert.
+   */
+  public static Builder builder(BaseTableInfo tableInfo, RowToInsert... rows) {
+    return builder(tableInfo.tableId(), rows);
+  }
+
+  /**
+   * Returns a {@code InsertAllRequest} object given the destination table and the rows to insert.
+   */
+  public static InsertAllRequest of(TableId tableId, Iterable<RowToInsert> rows) {
+    return builder(tableId, rows).build();
+  }
+
+  /**
+   * Returns a {@code InsertAllRequest} object given the destination table and the rows to insert.
+   */
+  public static InsertAllRequest of(TableId tableId, RowToInsert... rows) {
+    return builder(tableId, rows).build();
+  }
+
+  /**
+   * Returns a {@code InsertAllRequest} object given the destination table and the rows to insert.
+   */
+  public static InsertAllRequest of(String datasetId, String tableId, Iterable<RowToInsert> rows) {
+    return builder(datasetId, tableId, rows).build();
+  }
+
+  /**
+   * Returns a {@code InsertAllRequest} object given the destination table and the rows to insert.
+   */
+  public static InsertAllRequest of(String datasetId, String tableId, RowToInsert... rows) {
+    return builder(datasetId, tableId, rows).build();
+  }
+
+  /**
+   * Returns a {@code InsertAllRequest} object given the destination table and the rows to insert.
+   */
+  public static InsertAllRequest of(BaseTableInfo tableInfo, Iterable<RowToInsert> rows) {
+    return builder(tableInfo.tableId(), rows).build();
+  }
+
+  /**
+   * Returns a {@code InsertAllRequest} object given the destination table and the rows to insert.
+   */
+  public static InsertAllRequest of(BaseTableInfo tableInfo, RowToInsert... rows) {
+    return builder(tableInfo.tableId(), rows).build();
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("table", table)
+        .add("rows", rows)
+        .add("ignoreUnknownValues", ignoreUnknownValues)
+        .add("skipInvalidRows", skipInvalidRows)
+        .toString();
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(table, rows, ignoreUnknownValues, skipInvalidRows);
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (!(obj instanceof InsertAllRequest)) {
+      return false;
+    }
+    InsertAllRequest other = (InsertAllRequest) obj;
+    return Objects.equals(table, other.table)
+        && Objects.equals(rows, other.rows)
+        && Objects.equals(ignoreUnknownValues, other.ignoreUnknownValues)
+        && Objects.equals(skipInvalidRows, other.skipInvalidRows);
+  }
+}
diff --git a/gcloud-java-bigquery/src/main/java/com/google/gcloud/bigquery/InsertAllResponse.java b/gcloud-java-bigquery/src/main/java/com/google/gcloud/bigquery/InsertAllResponse.java
new file mode 100644
index 000000000000..2534f4f23f67
--- /dev/null
+++ b/gcloud-java-bigquery/src/main/java/com/google/gcloud/bigquery/InsertAllResponse.java
@@ -0,0 +1,119 @@
+/*
+ * 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.api.services.bigquery.model.ErrorProto;
+import com.google.api.services.bigquery.model.TableDataInsertAllResponse;
+import com.google.api.services.bigquery.model.TableDataInsertAllResponse.InsertErrors;
+import com.google.common.base.Function;
+import com.google.common.base.MoreObjects;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+
+import java.io.Serializable;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Google Cloud BigQuery insert all response. Objects of this class possibly contain errors for an
+ * {@link InsertAllRequest}. If a row failed to be inserted, the non-empty list of errors associated
+ * to that row's index can be obtained with {@link InsertAllResponse#errorsFor(Long)}.
+ * {@link InsertAllResponse#insertErrors()} can be used to return all errors caused by a
+ * {@link InsertAllRequest} as a map.
+ */
+public class InsertAllResponse implements Serializable {
+
+  private final Map<Long, List<BigQueryError>> insertErrors;
+
+  InsertAllResponse(Map<Long, List<BigQueryError>> insertErrors) {
+    this.insertErrors = insertErrors != null ? ImmutableMap.copyOf(insertErrors)
+        : ImmutableMap.<Long, List<BigQueryError>>of();
+  }
+
+  /**
+   * Returns all insertion errors as a map whose keys are indexes of rows that failed to insert.
+   * Each failed row index is associated with a non-empty list of {@link BigQueryError}.
+   */
+  public Map<Long, List<BigQueryError>> insertErrors() {
+    return insertErrors;
+  }
+
+  /**
+   * Returns errors for the provided row index. If no error exists returns {@code null}.
+   */
+  public List<BigQueryError> errorsFor(Long index) {
+    return insertErrors.get(index);
+  }
+
+  /**
+   * Returns {@code true} if no row insertion failed, {@code false} otherwise. If {@code false}
+   * {@link #insertErrors()} returns an empty map.
+   */
+  public boolean hasErrors() {
+    return !insertErrors.isEmpty();
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(insertErrors);
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    return obj instanceof InsertAllResponse
+        && Objects.equals(insertErrors, ((InsertAllResponse) obj).insertErrors);
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this).add("insertErrors", insertErrors).toString();
+  }
+
+  TableDataInsertAllResponse toPb() {
+    TableDataInsertAllResponse responsePb = new TableDataInsertAllResponse();
+    if (insertErrors.size() > 0) {
+      responsePb.setInsertErrors(ImmutableList.copyOf(Iterables.transform(insertErrors.entrySet(),
+          new Function<Map.Entry<Long, List<BigQueryError>>, InsertErrors>() {
+            @Override
+            public InsertErrors apply(Map.Entry<Long, List<BigQueryError>> entry) {
+              return new InsertErrors()
+                  .setIndex(entry.getKey())
+                  .setErrors(Lists.transform(entry.getValue(), BigQueryError.TO_PB_FUNCTION));
+            }
+          })));
+    }
+    return responsePb;
+  }
+
+  static InsertAllResponse fromPb(TableDataInsertAllResponse responsePb) {
+    Map<Long, List<BigQueryError>> insertErrors = null;
+    if (responsePb.getInsertErrors() != null) {
+      List<InsertErrors> errorsPb = responsePb.getInsertErrors();
+      insertErrors = Maps.newHashMapWithExpectedSize(errorsPb.size());
+      for (InsertErrors errorPb : errorsPb) {
+        insertErrors.put(errorPb.getIndex(), Lists.transform(
+            errorPb.getErrors() != null ? errorPb.getErrors() : ImmutableList.<ErrorProto>of(),
+            BigQueryError.FROM_PB_FUNCTION));
+      }
+    }
+    return new InsertAllResponse(insertErrors);
+  }
+}
diff --git a/gcloud-java-bigquery/src/main/java/com/google/gcloud/bigquery/TableRow.java b/gcloud-java-bigquery/src/main/java/com/google/gcloud/bigquery/TableRow.java
new file mode 100644
index 000000000000..7dde02280701
--- /dev/null
+++ b/gcloud-java-bigquery/src/main/java/com/google/gcloud/bigquery/TableRow.java
@@ -0,0 +1,104 @@
+/*
+ * 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.api.client.util.Lists;
+import com.google.common.base.Function;
+import com.google.common.collect.ImmutableList;
+
+import java.io.Serializable;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * Google BigQuery Table Row class. Objects of this class contain a list of {@link FieldValue}, one
+ * for each field in the table.
+ */
+public class TableRow implements Serializable {
+
+  static final Function<com.google.api.services.bigquery.model.TableRow, TableRow>
+      FROM_PB_FUNCTION = new Function<com.google.api.services.bigquery.model.TableRow, TableRow>() {
+        @Override
+        public TableRow apply(com.google.api.services.bigquery.model.TableRow pb) {
+          return TableRow.fromPb(pb);
+        }
+      };
+  private static final long serialVersionUID = 1770751621297868029L;
+
+  private final List<FieldValue> values;
+
+  static final class Builder {
+
+    private List<FieldValue> values;
+
+    Builder() {}
+
+    Builder values(List<FieldValue> values) {
+      this.values = Lists.newArrayList(checkNotNull(values));
+      return this;
+    }
+
+    Builder addValue(FieldValue fieldValue) {
+      checkNotNull(fieldValue);
+      if (values == null) {
+        values = Lists.newArrayList();
+      }
+      values.add(fieldValue);
+      return this;
+    }
+
+    TableRow build() {
+      return new TableRow(this);
+    }
+  }
+
+  TableRow(Builder builder) {
+    this.values = ImmutableList.copyOf(builder.values);
+  }
+
+  /**
+   * Returns table row data as a list of {@link FieldValue}.
+   */
+  public List<FieldValue> values() {
+    return values;
+  }
+
+  @Override
+  public String toString() {
+    return values.toString();
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(values);
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    return obj instanceof TableRow && Objects.equals(values, ((TableRow) obj).values);
+  }
+
+  static TableRow fromPb(com.google.api.services.bigquery.model.TableRow rowPb) {
+    Builder builder = new Builder();
+    for (com.google.api.services.bigquery.model.TableCell cellPb : rowPb.getF()) {
+      builder.addValue(FieldValue.fromPb(cellPb.getV()));
+    }
+    return builder.build();
+  }
+}
diff --git a/gcloud-java-bigquery/src/test/java/com/google/gcloud/bigquery/FieldValueTest.java b/gcloud-java-bigquery/src/test/java/com/google/gcloud/bigquery/FieldValueTest.java
new file mode 100644
index 000000000000..6fd3cf4472c9
--- /dev/null
+++ b/gcloud-java-bigquery/src/test/java/com/google/gcloud/bigquery/FieldValueTest.java
@@ -0,0 +1,111 @@
+/*
+ * 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.assertFalse;
+import static org.junit.Assert.assertNull;
+
+import com.google.api.client.util.Data;
+import com.google.api.services.bigquery.model.TableCell;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+
+import org.junit.Test;
+
+import java.util.Map;
+
+public class FieldValueTest {
+
+  private static final TableCell BOOLEAN_FIELD = new TableCell().setV("false");
+  private static final Map<String, String> INTEGER_FIELD = ImmutableMap.of("v", "1");
+  private static final Map<String, String> FLOAT_FIELD = ImmutableMap.of("v", "1.5");
+  private static final Map<String, String> STRING_FIELD = ImmutableMap.of("v", "string");
+  private static final Map<String, String> TIMESTAMP_FIELD = ImmutableMap.of("v", "42");
+  private static final Map<String, Object> NULL_FIELD =
+      ImmutableMap.of("v", Data.nullOf(String.class));
+  private static final Map<String, Object> REPEATED_FIELD =
+      ImmutableMap.<String, Object>of("v", ImmutableList.<Object>of(INTEGER_FIELD, INTEGER_FIELD));
+  private static final Map<String, Object> RECORD_FIELD =
+      ImmutableMap.<String, Object>of("f", ImmutableList.<Object>of(FLOAT_FIELD, TIMESTAMP_FIELD));
+
+  @Test
+  public void testFromPb() {
+    FieldValue value = FieldValue.fromPb(BOOLEAN_FIELD);
+    assertEquals(FieldValue.Kind.PRIMITIVE, value.kind());
+    assertFalse(value.booleanValue());
+    value = FieldValue.fromPb(INTEGER_FIELD);
+    assertEquals(FieldValue.Kind.PRIMITIVE, value.kind());
+    assertEquals(1, value.longValue());
+    value = FieldValue.fromPb(FLOAT_FIELD);
+    assertEquals(FieldValue.Kind.PRIMITIVE, value.kind());
+    assertEquals(1.5, value.doubleValue(), 0);
+    value = FieldValue.fromPb(STRING_FIELD);
+    assertEquals(FieldValue.Kind.PRIMITIVE, value.kind());
+    assertEquals("string", value.stringValue());
+    value = FieldValue.fromPb(TIMESTAMP_FIELD);
+    assertEquals(FieldValue.Kind.PRIMITIVE, value.kind());
+    assertEquals(42000000, value.timestampValue());
+    value = FieldValue.fromPb(NULL_FIELD);
+    assertNull(value.value());
+    value = FieldValue.fromPb(REPEATED_FIELD);
+    assertEquals(FieldValue.Kind.REPEATED, value.kind());
+    assertEquals(FieldValue.fromPb(INTEGER_FIELD), value.repeatedValue().get(0));
+    assertEquals(FieldValue.fromPb(INTEGER_FIELD), value.repeatedValue().get(1));
+    value = FieldValue.fromPb(RECORD_FIELD);
+    assertEquals(FieldValue.Kind.RECORD, value.kind());
+    assertEquals(FieldValue.fromPb(FLOAT_FIELD), value.repeatedValue().get(0));
+    assertEquals(FieldValue.fromPb(TIMESTAMP_FIELD), value.repeatedValue().get(1));
+  }
+
+  @Test
+  public void testEquals() {
+    FieldValue booleanValue = new FieldValue(FieldValue.Kind.PRIMITIVE, "false");
+    assertEquals(booleanValue, FieldValue.fromPb(BOOLEAN_FIELD));
+    assertEquals(booleanValue.hashCode(), FieldValue.fromPb(BOOLEAN_FIELD).hashCode());
+
+    FieldValue integerValue = new FieldValue(FieldValue.Kind.PRIMITIVE, "1");
+    assertEquals(integerValue, FieldValue.fromPb(INTEGER_FIELD));
+    assertEquals(integerValue.hashCode(), FieldValue.fromPb(INTEGER_FIELD).hashCode());
+
+    FieldValue floatValue = new FieldValue(FieldValue.Kind.PRIMITIVE, "1.5");
+    assertEquals(floatValue, FieldValue.fromPb(FLOAT_FIELD));
+    assertEquals(floatValue.hashCode(), FieldValue.fromPb(FLOAT_FIELD).hashCode());
+
+    FieldValue stringValue = new FieldValue(FieldValue.Kind.PRIMITIVE, "string");
+    assertEquals(stringValue, FieldValue.fromPb(STRING_FIELD));
+    assertEquals(stringValue.hashCode(), FieldValue.fromPb(STRING_FIELD).hashCode());
+
+    FieldValue timestampValue = new FieldValue(FieldValue.Kind.PRIMITIVE, "42");
+    assertEquals(timestampValue, FieldValue.fromPb(TIMESTAMP_FIELD));
+    assertEquals(timestampValue.hashCode(), FieldValue.fromPb(TIMESTAMP_FIELD).hashCode());
+
+    FieldValue nullValue = new FieldValue(FieldValue.Kind.PRIMITIVE, null);
+    assertEquals(nullValue, FieldValue.fromPb(NULL_FIELD));
+    assertEquals(nullValue.hashCode(), FieldValue.fromPb(NULL_FIELD).hashCode());
+
+    FieldValue repeatedValue = new FieldValue(FieldValue.Kind.REPEATED,
+        ImmutableList.of(integerValue, integerValue));
+    assertEquals(repeatedValue, FieldValue.fromPb(REPEATED_FIELD));
+    assertEquals(repeatedValue.hashCode(), FieldValue.fromPb(REPEATED_FIELD).hashCode());
+
+    FieldValue recordValue = new FieldValue(FieldValue.Kind.RECORD,
+        ImmutableList.of(floatValue, timestampValue));
+    assertEquals(recordValue, FieldValue.fromPb(RECORD_FIELD));
+    assertEquals(recordValue.hashCode(), FieldValue.fromPb(RECORD_FIELD).hashCode());
+  }
+}
diff --git a/gcloud-java-bigquery/src/test/java/com/google/gcloud/bigquery/InsertAllRequestTest.java b/gcloud-java-bigquery/src/test/java/com/google/gcloud/bigquery/InsertAllRequestTest.java
new file mode 100644
index 000000000000..8a153c8c4da1
--- /dev/null
+++ b/gcloud-java-bigquery/src/test/java/com/google/gcloud/bigquery/InsertAllRequestTest.java
@@ -0,0 +1,197 @@
+/*
+ * 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.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+
+import org.junit.Test;
+
+import java.util.List;
+import java.util.Map;
+
+public class InsertAllRequestTest {
+
+  private static final Map<String, Object> CONTENT1 =
+      ImmutableMap.<String, Object>of("key", "val1");
+  private static final Map<String, Object> CONTENT2 =
+      ImmutableMap.<String, Object>of("key", "val2");
+  private static final List<InsertAllRequest.RowToInsert> ROWS =
+      ImmutableList.of(new InsertAllRequest.RowToInsert(null, CONTENT1),
+          new InsertAllRequest.RowToInsert(null, CONTENT2));
+  private static final List<InsertAllRequest.RowToInsert> ROWS_WITH_ID =
+      ImmutableList.of(new InsertAllRequest.RowToInsert("id1", CONTENT1),
+          new InsertAllRequest.RowToInsert("id2", CONTENT2));
+  private static final TableId TABLE_ID = TableId.of("dataset", "table");
+  private static final Schema TABLE_SCHEMA = Schema.of();
+  private static final BaseTableInfo TABLE_INFO = TableInfo.of(TABLE_ID, TABLE_SCHEMA);
+  private static final boolean SKIP_INVALID_ROWS = true;
+  private static final boolean IGNORE_UNKNOWN_VALUES = false;
+  private static final InsertAllRequest INSERT_ALL_REQUEST1 = InsertAllRequest.builder(TABLE_ID)
+      .addRow(CONTENT1)
+      .addRow(CONTENT2)
+      .ignoreUnknownValues(IGNORE_UNKNOWN_VALUES)
+      .skipInvalidRows(SKIP_INVALID_ROWS)
+      .build();
+  private static final InsertAllRequest INSERT_ALL_REQUEST2 = InsertAllRequest.builder(TABLE_ID)
+      .rows(ROWS)
+      .ignoreUnknownValues(IGNORE_UNKNOWN_VALUES)
+      .skipInvalidRows(SKIP_INVALID_ROWS)
+      .build();
+  private static final InsertAllRequest INSERT_ALL_REQUEST3 =
+      InsertAllRequest.builder(TABLE_ID.dataset(), TABLE_ID.table())
+          .rows(ROWS_WITH_ID)
+          .ignoreUnknownValues(IGNORE_UNKNOWN_VALUES)
+          .skipInvalidRows(SKIP_INVALID_ROWS)
+          .build();
+  private static final InsertAllRequest INSERT_ALL_REQUEST4 =
+      InsertAllRequest.builder(TABLE_ID, ROWS)
+          .ignoreUnknownValues(IGNORE_UNKNOWN_VALUES)
+          .skipInvalidRows(SKIP_INVALID_ROWS)
+          .build();
+  private static final InsertAllRequest INSERT_ALL_REQUEST5 =
+      InsertAllRequest.builder(TABLE_ID.dataset(), TABLE_ID.table(), ROWS_WITH_ID)
+          .ignoreUnknownValues(IGNORE_UNKNOWN_VALUES)
+          .skipInvalidRows(SKIP_INVALID_ROWS)
+          .build();
+  private static final InsertAllRequest INSERT_ALL_REQUEST6 =
+      InsertAllRequest.builder(TABLE_ID, ROWS.get(0), ROWS.get(1))
+          .ignoreUnknownValues(IGNORE_UNKNOWN_VALUES)
+          .skipInvalidRows(SKIP_INVALID_ROWS)
+          .build();
+  private static final InsertAllRequest INSERT_ALL_REQUEST7 =
+      InsertAllRequest.builder(TABLE_ID.dataset(), TABLE_ID.table(), ROWS_WITH_ID.get(0),
+          ROWS_WITH_ID.get(1))
+          .ignoreUnknownValues(IGNORE_UNKNOWN_VALUES)
+          .skipInvalidRows(SKIP_INVALID_ROWS)
+          .build();
+  private static final InsertAllRequest INSERT_ALL_REQUEST8 =
+      InsertAllRequest.builder(TABLE_ID.dataset(), TABLE_ID.table())
+          .addRow("id1", CONTENT1)
+          .addRow("id2", CONTENT2)
+          .ignoreUnknownValues(IGNORE_UNKNOWN_VALUES)
+          .skipInvalidRows(SKIP_INVALID_ROWS)
+          .build();
+  private static final InsertAllRequest INSERT_ALL_REQUEST9 =
+      InsertAllRequest.builder(TABLE_INFO)
+          .addRow("id1", CONTENT1)
+          .addRow("id2", CONTENT2)
+          .ignoreUnknownValues(IGNORE_UNKNOWN_VALUES)
+          .skipInvalidRows(SKIP_INVALID_ROWS)
+          .build();
+  private static final InsertAllRequest INSERT_ALL_REQUEST10 =
+      InsertAllRequest.builder(TABLE_INFO)
+          .addRow("id1", CONTENT1)
+          .addRow("id2", CONTENT2)
+          .ignoreUnknownValues(true)
+          .skipInvalidRows(false)
+          .build();
+
+  @Test
+  public void testBuilder() {
+    assertEquals(TABLE_ID, INSERT_ALL_REQUEST1.table());
+    assertEquals(TABLE_ID, INSERT_ALL_REQUEST2.table());
+    assertEquals(TABLE_ID, INSERT_ALL_REQUEST3.table());
+    assertEquals(TABLE_ID, INSERT_ALL_REQUEST4.table());
+    assertEquals(TABLE_ID, INSERT_ALL_REQUEST5.table());
+    assertEquals(TABLE_ID, INSERT_ALL_REQUEST6.table());
+    assertEquals(TABLE_ID, INSERT_ALL_REQUEST7.table());
+    assertEquals(TABLE_ID, INSERT_ALL_REQUEST8.table());
+    assertEquals(TABLE_ID, INSERT_ALL_REQUEST9.table());
+    assertEquals(TABLE_ID, INSERT_ALL_REQUEST10.table());
+    assertEquals(ROWS, INSERT_ALL_REQUEST1.rows());
+    assertEquals(ROWS, INSERT_ALL_REQUEST2.rows());
+    assertEquals(ROWS, INSERT_ALL_REQUEST4.rows());
+    assertEquals(ROWS, INSERT_ALL_REQUEST6.rows());
+    assertEquals(ROWS_WITH_ID, INSERT_ALL_REQUEST3.rows());
+    assertEquals(ROWS_WITH_ID, INSERT_ALL_REQUEST5.rows());
+    assertEquals(ROWS_WITH_ID, INSERT_ALL_REQUEST7.rows());
+    assertEquals(ROWS_WITH_ID, INSERT_ALL_REQUEST8.rows());
+    assertEquals(ROWS_WITH_ID, INSERT_ALL_REQUEST9.rows());
+    assertEquals(ROWS_WITH_ID, INSERT_ALL_REQUEST10.rows());
+    assertEquals(SKIP_INVALID_ROWS, INSERT_ALL_REQUEST1.skipInvalidRows());
+    assertEquals(SKIP_INVALID_ROWS, INSERT_ALL_REQUEST2.skipInvalidRows());
+    assertEquals(SKIP_INVALID_ROWS, INSERT_ALL_REQUEST3.skipInvalidRows());
+    assertEquals(SKIP_INVALID_ROWS, INSERT_ALL_REQUEST4.skipInvalidRows());
+    assertEquals(SKIP_INVALID_ROWS, INSERT_ALL_REQUEST5.skipInvalidRows());
+    assertEquals(SKIP_INVALID_ROWS, INSERT_ALL_REQUEST6.skipInvalidRows());
+    assertEquals(SKIP_INVALID_ROWS, INSERT_ALL_REQUEST7.skipInvalidRows());
+    assertEquals(SKIP_INVALID_ROWS, INSERT_ALL_REQUEST8.skipInvalidRows());
+    assertEquals(SKIP_INVALID_ROWS, INSERT_ALL_REQUEST9.skipInvalidRows());
+    assertFalse(INSERT_ALL_REQUEST10.skipInvalidRows());
+    assertEquals(IGNORE_UNKNOWN_VALUES, INSERT_ALL_REQUEST1.ignoreUnknownValues());
+    assertEquals(IGNORE_UNKNOWN_VALUES, INSERT_ALL_REQUEST2.ignoreUnknownValues());
+    assertEquals(IGNORE_UNKNOWN_VALUES, INSERT_ALL_REQUEST3.ignoreUnknownValues());
+    assertEquals(IGNORE_UNKNOWN_VALUES, INSERT_ALL_REQUEST4.ignoreUnknownValues());
+    assertEquals(IGNORE_UNKNOWN_VALUES, INSERT_ALL_REQUEST5.ignoreUnknownValues());
+    assertEquals(IGNORE_UNKNOWN_VALUES, INSERT_ALL_REQUEST6.ignoreUnknownValues());
+    assertEquals(IGNORE_UNKNOWN_VALUES, INSERT_ALL_REQUEST7.ignoreUnknownValues());
+    assertEquals(IGNORE_UNKNOWN_VALUES, INSERT_ALL_REQUEST8.ignoreUnknownValues());
+    assertEquals(IGNORE_UNKNOWN_VALUES, INSERT_ALL_REQUEST9.ignoreUnknownValues());
+    assertTrue(INSERT_ALL_REQUEST10.ignoreUnknownValues());
+  }
+
+  @Test
+  public void testOf() {
+    InsertAllRequest request = InsertAllRequest.of(TABLE_ID, ROWS);
+    assertEquals(TABLE_ID, request.table());
+    assertEquals(ROWS, request.rows());
+    request = InsertAllRequest.of(TABLE_INFO, ROWS);
+    assertEquals(TABLE_ID, request.table());
+    assertEquals(ROWS, request.rows());
+    request = InsertAllRequest.of(TABLE_ID.dataset(), TABLE_ID.table(), ROWS);
+    assertEquals(TABLE_ID, request.table());
+    assertEquals(ROWS, request.rows());
+    request = InsertAllRequest.of(TABLE_ID.dataset(), TABLE_ID.table(), ROWS);
+    assertEquals(TABLE_ID, request.table());
+    assertEquals(ROWS, request.rows());
+    request = InsertAllRequest.of(TABLE_ID, ROWS.get(0), ROWS.get(1));
+    assertEquals(TABLE_ID, request.table());
+    assertEquals(ROWS, request.rows());
+    request = InsertAllRequest.of(TABLE_INFO, ROWS.get(0), ROWS.get(1));
+    assertEquals(TABLE_ID, request.table());
+    assertEquals(ROWS, request.rows());
+    request = InsertAllRequest.of(TABLE_ID.dataset(), TABLE_ID.table(), ROWS.get(0), ROWS.get(1));
+    assertEquals(TABLE_ID, request.table());
+    assertEquals(ROWS, request.rows());
+  }
+
+  @Test
+  public void testEquals() {
+    compareInsertAllRequest(INSERT_ALL_REQUEST1, INSERT_ALL_REQUEST2);
+    compareInsertAllRequest(INSERT_ALL_REQUEST2, INSERT_ALL_REQUEST4);
+    compareInsertAllRequest(INSERT_ALL_REQUEST3, INSERT_ALL_REQUEST5);
+    compareInsertAllRequest(INSERT_ALL_REQUEST4, INSERT_ALL_REQUEST6);
+    compareInsertAllRequest(INSERT_ALL_REQUEST5, INSERT_ALL_REQUEST7);
+    compareInsertAllRequest(INSERT_ALL_REQUEST7, INSERT_ALL_REQUEST8);
+    compareInsertAllRequest(INSERT_ALL_REQUEST8, INSERT_ALL_REQUEST9);
+  }
+
+  private void compareInsertAllRequest(InsertAllRequest expected, InsertAllRequest value) {
+    assertEquals(expected, value);
+    assertEquals(expected.toString(), value.toString());
+    assertEquals(expected.hashCode(), value.hashCode());
+    assertEquals(expected.table(), value.table());
+    assertEquals(expected.rows(), value.rows());
+    assertEquals(expected.ignoreUnknownValues(), value.ignoreUnknownValues());
+    assertEquals(expected.skipInvalidRows(), value.skipInvalidRows());
+  }
+}
diff --git a/gcloud-java-bigquery/src/test/java/com/google/gcloud/bigquery/InsertAllResponseTest.java b/gcloud-java-bigquery/src/test/java/com/google/gcloud/bigquery/InsertAllResponseTest.java
new file mode 100644
index 000000000000..b2eb0458f27f
--- /dev/null
+++ b/gcloud-java-bigquery/src/test/java/com/google/gcloud/bigquery/InsertAllResponseTest.java
@@ -0,0 +1,77 @@
+/*
+ * 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.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+
+import org.junit.Test;
+
+import java.util.List;
+import java.util.Map;
+
+public class InsertAllResponseTest {
+
+  private static final List<BigQueryError> ERRORS1 = ImmutableList.of(
+      new BigQueryError("reason1", "location1", "message1"),
+      new BigQueryError("reason2", "location2", "message2"));
+  private static final List<BigQueryError> ERRORS2 = ImmutableList.of(
+      new BigQueryError("reason3", "location3", "message3"),
+      new BigQueryError("reason4", "location4", "message4"));
+  private static final Map<Long, List<BigQueryError>> ERRORS_MAP = ImmutableMap.of(
+      0L, ERRORS1, 1L, ERRORS2);
+  private static final InsertAllResponse INSERT_ALL_RESPONSE = new InsertAllResponse(ERRORS_MAP);
+  private static final InsertAllResponse EMPTY_INSERT_ALL_RESPONSE = new InsertAllResponse(null);
+
+  @Test
+  public void testConstructor() {
+    assertEquals(INSERT_ALL_RESPONSE, INSERT_ALL_RESPONSE);
+  }
+
+  @Test
+  public void testErrorsFor() {
+    assertEquals(ERRORS1, INSERT_ALL_RESPONSE.errorsFor(0L));
+    assertEquals(ERRORS2, INSERT_ALL_RESPONSE.errorsFor(1L));
+    assertNull(INSERT_ALL_RESPONSE.errorsFor(2L));
+  }
+
+  @Test
+  public void testHasErrors() {
+    assertTrue(INSERT_ALL_RESPONSE.hasErrors());
+    assertFalse(EMPTY_INSERT_ALL_RESPONSE.hasErrors());
+  }
+
+  @Test
+  public void testToPbAndFromPb() {
+    compareInsertAllResponse(INSERT_ALL_RESPONSE,
+        InsertAllResponse.fromPb(INSERT_ALL_RESPONSE.toPb()));
+    compareInsertAllResponse(EMPTY_INSERT_ALL_RESPONSE,
+        InsertAllResponse.fromPb(EMPTY_INSERT_ALL_RESPONSE.toPb()));
+  }
+
+  private void compareInsertAllResponse(InsertAllResponse expected, InsertAllResponse value) {
+    assertEquals(expected, value);
+    assertEquals(expected.hashCode(), value.hashCode());
+    assertEquals(expected.toString(), value.toString());
+    assertEquals(expected.insertErrors(), value.insertErrors());
+  }
+}
diff --git a/gcloud-java-bigquery/src/test/java/com/google/gcloud/bigquery/SerializationTest.java b/gcloud-java-bigquery/src/test/java/com/google/gcloud/bigquery/SerializationTest.java
index 15a652719703..088820c298ec 100644
--- a/gcloud-java-bigquery/src/test/java/com/google/gcloud/bigquery/SerializationTest.java
+++ b/gcloud-java-bigquery/src/test/java/com/google/gcloud/bigquery/SerializationTest.java
@@ -20,6 +20,7 @@
 import static org.junit.Assert.assertNotSame;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 import com.google.gcloud.AuthCredentials;
 import com.google.gcloud.RetryParams;
 
@@ -33,6 +34,7 @@
 import java.io.Serializable;
 import java.nio.charset.StandardCharsets;
 import java.util.List;
+import java.util.Map;
 
 public class SerializationTest {
 
@@ -169,6 +171,23 @@ public class SerializationTest {
   private static final ExtractJobInfo EXTRACT_JOB = ExtractJobInfo.of(TABLE_ID, SOURCE_URIS);
   private static final LoadJobInfo LOAD_JOB = LoadJobInfo.of(TABLE_ID, SOURCE_URIS);
   private static final QueryJobInfo QUERY_JOB = QueryJobInfo.of("query");
+  private static final Map<String, Object> CONTENT1 =
+      ImmutableMap.<String, Object>of("key", "val1");
+  private static final Map<String, Object> CONTENT2 =
+      ImmutableMap.<String, Object>of("key", "val2");
+  private static final InsertAllRequest INSERT_ALL_REQUEST = InsertAllRequest.builder(TABLE_ID)
+      .addRow(CONTENT1)
+      .addRow(CONTENT2)
+      .ignoreUnknownValues(true)
+      .skipInvalidRows(false)
+      .build();
+  private static final Map<Long, List<BigQueryError>> ERRORS_MAP =
+      ImmutableMap.<Long, List<BigQueryError>>of(0L, ImmutableList.of(BIGQUERY_ERROR));
+  private static final InsertAllResponse INSERT_ALL_RESPONSE = new InsertAllResponse(ERRORS_MAP);
+  private static final FieldValue FIELD_VALUE = new FieldValue(FieldValue.Kind.PRIMITIVE, "value");
+  private static final TableRow TABLE_ROW = new TableRow.Builder()
+      .addValue(FIELD_VALUE)
+      .build();
 
   @Test
   public void testServiceOptions() throws Exception {
@@ -194,7 +213,8 @@ public void testModelAndRequests() throws Exception {
         DATASET_INFO, TABLE_ID, CSV_OPTIONS, STREAMING_BUFFER, EXTERNAL_DATA_CONFIGURATION,
         TABLE_SCHEMA, TABLE_INFO, VIEW_INFO, EXTERNAL_TABLE_INFO, INLINE_FUNCTION, URI_FUNCTION,
         JOB_STATISTICS, EXTRACT_STATISTICS, LOAD_STATISTICS, QUERY_STATISTICS, BIGQUERY_ERROR,
-        JOB_STATUS, JOB_ID, COPY_JOB, EXTRACT_JOB, LOAD_JOB, QUERY_JOB};
+        JOB_STATUS, JOB_ID, COPY_JOB, EXTRACT_JOB, LOAD_JOB, QUERY_JOB, INSERT_ALL_REQUEST,
+        INSERT_ALL_RESPONSE, FIELD_VALUE, TABLE_ROW};
     for (Serializable obj : objects) {
       Object copy = serializeAndDeserialize(obj);
       assertEquals(obj, obj);
diff --git a/gcloud-java-bigquery/src/test/java/com/google/gcloud/bigquery/TableRowTest.java b/gcloud-java-bigquery/src/test/java/com/google/gcloud/bigquery/TableRowTest.java
new file mode 100644
index 000000000000..f20105ea9cd5
--- /dev/null
+++ b/gcloud-java-bigquery/src/test/java/com/google/gcloud/bigquery/TableRowTest.java
@@ -0,0 +1,80 @@
+/*
+ * 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 com.google.api.client.util.Data;
+import com.google.api.services.bigquery.model.TableCell;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+
+import org.junit.Test;
+
+import java.util.List;
+import java.util.Map;
+
+public class TableRowTest {
+
+  private static final FieldValue BOOL_VALUE = new FieldValue(FieldValue.Kind.PRIMITIVE, "false");
+  private static final FieldValue INT_VALUE = new FieldValue(FieldValue.Kind.PRIMITIVE, "1");
+  private static final FieldValue FLOAT_VALUE = new FieldValue(FieldValue.Kind.PRIMITIVE, "1.5");
+  private static final FieldValue STRING_VALUE = new FieldValue(FieldValue.Kind.PRIMITIVE, "str");
+  private static final FieldValue TIME_VALUE = new FieldValue(FieldValue.Kind.PRIMITIVE, "42");
+  private static final List<FieldValue> ROW_VALUES =
+      ImmutableList.of(BOOL_VALUE, INT_VALUE, FLOAT_VALUE, STRING_VALUE, TIME_VALUE);
+  private static final TableRow TABLE_ROW1 = new TableRow.Builder()
+      .addValue(BOOL_VALUE)
+      .addValue(INT_VALUE)
+      .addValue(FLOAT_VALUE)
+      .addValue(STRING_VALUE)
+      .addValue(TIME_VALUE)
+      .build();
+  private static final TableRow TABLE_ROW2 = new TableRow.Builder().values(ROW_VALUES).build();
+
+  @Test
+  public void testBuilder() {
+    assertEquals(ROW_VALUES, TABLE_ROW1.values());
+    assertEquals(ROW_VALUES, TABLE_ROW2.values());
+  }
+
+  @Test
+  public void testEquals() {
+    compareTableRow(TABLE_ROW1, TABLE_ROW2);
+  }
+
+  @Test
+  public void testFromPb() {
+    TableCell booleanField = new TableCell().setV("false");
+    TableCell integerField = new TableCell().setV("1");
+    TableCell floatField = new TableCell().setV("1.5");
+    TableCell stringField = new TableCell().setV("str");
+    TableCell timestampField = new TableCell().setV("42");
+    com.google.api.services.bigquery.model.TableRow rowPb =
+        new com.google.api.services.bigquery.model.TableRow();
+    rowPb.setF(ImmutableList.of(booleanField, integerField, floatField, stringField,
+        timestampField));
+    compareTableRow(TABLE_ROW1, TableRow.fromPb(rowPb));
+  }
+
+  private void compareTableRow(TableRow expected, TableRow value) {
+    assertEquals(expected, value);
+    assertEquals(expected.hashCode(), value.hashCode());
+    assertEquals(expected.toString(), value.toString());
+    assertEquals(expected.values(), value.values());
+  }
+}