vendor: update all dependencies

vendor/cloud.google.com/go/bigquery/bigquery.go

@@ -152,5 +152,5 @@ func retryableError(err error) bool {
 	if len(e.Errors) > 0 {
 		reason = e.Errors[0].Reason
 	}
-	return reason == "backendError" || reason == "rateLimitExceeded"
+	return e.Code == http.StatusBadGateway || reason == "backendError" || reason == "rateLimitExceeded"
 }

vendor/cloud.google.com/go/bigquery/copy.go

@@ -37,6 +37,9 @@ type CopyConfig struct {
 
 	// The labels associated with this job.
 	Labels map[string]string
+
+	// Custom encryption configuration (e.g., Cloud KMS keys).
+	DestinationEncryptionConfig *EncryptionConfig
 }
 
 func (c *CopyConfig) toBQ() *bq.JobConfiguration {
@@ -47,10 +50,11 @@ func (c *CopyConfig) toBQ() *bq.JobConfiguration {
 	return &bq.JobConfiguration{
 		Labels: c.Labels,
 		Copy: &bq.JobConfigurationTableCopy{
-			CreateDisposition: string(c.CreateDisposition),
-			WriteDisposition:  string(c.WriteDisposition),
-			DestinationTable:  c.Dst.toBQ(),
-			SourceTables:      ts,
+			CreateDisposition:                  string(c.CreateDisposition),
+			WriteDisposition:                   string(c.WriteDisposition),
+			DestinationTable:                   c.Dst.toBQ(),
+			DestinationEncryptionConfiguration: c.DestinationEncryptionConfig.toBQ(),
+			SourceTables:                       ts,
 		},
 	}
 }
@@ -61,6 +65,7 @@ func bqToCopyConfig(q *bq.JobConfiguration, c *Client) *CopyConfig {
 		CreateDisposition: TableCreateDisposition(q.Copy.CreateDisposition),
 		WriteDisposition:  TableWriteDisposition(q.Copy.WriteDisposition),
 		Dst:               bqToTable(q.Copy.DestinationTable, c),
+		DestinationEncryptionConfig: bqToEncryptionConfig(q.Copy.DestinationEncryptionConfiguration),
 	}
 	for _, t := range q.Copy.SourceTables {
 		cc.Srcs = append(cc.Srcs, bqToTable(t, c))

vendor/cloud.google.com/go/bigquery/copy_test.go

@@ -84,15 +84,17 @@ func TestCopy(t *testing.T) {
 				},
 			},
 			config: CopyConfig{
-				CreateDisposition: CreateNever,
-				WriteDisposition:  WriteTruncate,
-				Labels:            map[string]string{"a": "b"},
+				CreateDisposition:           CreateNever,
+				WriteDisposition:            WriteTruncate,
+				DestinationEncryptionConfig: &EncryptionConfig{KMSKeyName: "keyName"},
+				Labels: map[string]string{"a": "b"},
 			},
 			want: func() *bq.Job {
 				j := defaultCopyJob()
 				j.Configuration.Labels = map[string]string{"a": "b"}
 				j.Configuration.Copy.CreateDisposition = "CREATE_NEVER"
 				j.Configuration.Copy.WriteDisposition = "WRITE_TRUNCATE"
+				j.Configuration.Copy.DestinationEncryptionConfiguration = &bq.EncryptionConfiguration{KmsKeyName: "keyName"}
 				return j
 			}(),
 		},

vendor/cloud.google.com/go/bigquery/datatransfer/apiv1/ListDataSources_smoke_test.go

@@ -0,0 +1,67 @@
+// Copyright 2018 Google LLC
+//
+// 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
+//
+//     https://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.
+
+// AUTO-GENERATED CODE. DO NOT EDIT.
+
+package datatransfer
+
+import (
+	datatransferpb "google.golang.org/genproto/googleapis/cloud/bigquery/datatransfer/v1"
+)
+
+import (
+	"fmt"
+	"strconv"
+	"testing"
+	"time"
+
+	"cloud.google.com/go/internal/testutil"
+	"golang.org/x/net/context"
+	"google.golang.org/api/iterator"
+	"google.golang.org/api/option"
+)
+
+var _ = fmt.Sprintf
+var _ = iterator.Done
+var _ = strconv.FormatUint
+var _ = time.Now
+
+func TestDataTransferServiceSmoke(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping smoke test in short mode")
+	}
+	ctx := context.Background()
+	ts := testutil.TokenSource(ctx, DefaultAuthScopes()...)
+	if ts == nil {
+		t.Skip("Integration tests skipped. See CONTRIBUTING.md for details")
+	}
+
+	projectId := testutil.ProjID()
+	_ = projectId
+
+	c, err := NewClient(ctx, option.WithTokenSource(ts))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", projectId, "us-central1")
+	var request = &datatransferpb.ListDataSourcesRequest{
+		Parent: formattedParent,
+	}
+
+	iter := c.ListDataSources(ctx, request)
+	if _, err := iter.Next(); err != nil && err != iterator.Done {
+		t.Error(err)
+	}
+}

vendor/cloud.google.com/go/bigquery/datatransfer/apiv1/data_transfer_client.go

@@ -1,10 +1,10 @@
-// Copyright 2017, Google LLC All rights reserved.
+// Copyright 2018 Google LLC
 //
 // 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
+//     https://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,
@@ -144,94 +144,6 @@ func (c *Client) setGoogleClientInfo(keyval ...string) {
 	c.xGoogMetadata = metadata.Pairs("x-goog-api-client", gax.XGoogHeader(kv...))
 }
 
-// ProjectPath returns the path for the project resource.
-func ProjectPath(project string) string {
-	return "" +
-		"projects/" +
-		project +
-		""
-}
-
-// LocationPath returns the path for the location resource.
-func LocationPath(project, location string) string {
-	return "" +
-		"projects/" +
-		project +
-		"/locations/" +
-		location +
-		""
-}
-
-// LocationDataSourcePath returns the path for the location data source resource.
-func LocationDataSourcePath(project, location, dataSource string) string {
-	return "" +
-		"projects/" +
-		project +
-		"/locations/" +
-		location +
-		"/dataSources/" +
-		dataSource +
-		""
-}
-
-// LocationTransferConfigPath returns the path for the location transfer config resource.
-func LocationTransferConfigPath(project, location, transferConfig string) string {
-	return "" +
-		"projects/" +
-		project +
-		"/locations/" +
-		location +
-		"/transferConfigs/" +
-		transferConfig +
-		""
-}
-
-// LocationRunPath returns the path for the location run resource.
-func LocationRunPath(project, location, transferConfig, run string) string {
-	return "" +
-		"projects/" +
-		project +
-		"/locations/" +
-		location +
-		"/transferConfigs/" +
-		transferConfig +
-		"/runs/" +
-		run +
-		""
-}
-
-// DataSourcePath returns the path for the data source resource.
-func DataSourcePath(project, dataSource string) string {
-	return "" +
-		"projects/" +
-		project +
-		"/dataSources/" +
-		dataSource +
-		""
-}
-
-// TransferConfigPath returns the path for the transfer config resource.
-func TransferConfigPath(project, transferConfig string) string {
-	return "" +
-		"projects/" +
-		project +
-		"/transferConfigs/" +
-		transferConfig +
-		""
-}
-
-// RunPath returns the path for the run resource.
-func RunPath(project, transferConfig, run string) string {
-	return "" +
-		"projects/" +
-		project +
-		"/transferConfigs/" +
-		transferConfig +
-		"/runs/" +
-		run +
-		""
-}
-
 // GetDataSource retrieves a supported data source and returns its settings,
 // which can be used for UI rendering.
 func (c *Client) GetDataSource(ctx context.Context, req *datatransferpb.GetDataSourceRequest, opts ...gax.CallOption) (*datatransferpb.DataSource, error) {

vendor/cloud.google.com/go/bigquery/datatransfer/apiv1/data_transfer_client_example_test.go

@@ -1,10 +1,10 @@
-// Copyright 2017, Google LLC All rights reserved.
+// Copyright 2018 Google LLC
 //
 // 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
+//     https://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,
@@ -41,7 +41,7 @@ func ExampleClient_GetDataSource() {
 	}
 
 	req := &datatransferpb.GetDataSourceRequest{
-	// TODO: Fill request struct fields.
+		// TODO: Fill request struct fields.
 	}
 	resp, err := c.GetDataSource(ctx, req)
 	if err != nil {
@@ -59,7 +59,7 @@ func ExampleClient_ListDataSources() {
 	}
 
 	req := &datatransferpb.ListDataSourcesRequest{
-	// TODO: Fill request struct fields.
+		// TODO: Fill request struct fields.
 	}
 	it := c.ListDataSources(ctx, req)
 	for {
@@ -83,7 +83,7 @@ func ExampleClient_CreateTransferConfig() {
 	}
 
 	req := &datatransferpb.CreateTransferConfigRequest{
-	// TODO: Fill request struct fields.
+		// TODO: Fill request struct fields.
 	}
 	resp, err := c.CreateTransferConfig(ctx, req)
 	if err != nil {
@@ -101,7 +101,7 @@ func ExampleClient_UpdateTransferConfig() {
 	}
 
 	req := &datatransferpb.UpdateTransferConfigRequest{
-	// TODO: Fill request struct fields.
+		// TODO: Fill request struct fields.
 	}
 	resp, err := c.UpdateTransferConfig(ctx, req)
 	if err != nil {
@@ -119,7 +119,7 @@ func ExampleClient_DeleteTransferConfig() {
 	}
 
 	req := &datatransferpb.DeleteTransferConfigRequest{
-	// TODO: Fill request struct fields.
+		// TODO: Fill request struct fields.
 	}
 	err = c.DeleteTransferConfig(ctx, req)
 	if err != nil {
@@ -135,7 +135,7 @@ func ExampleClient_GetTransferConfig() {
 	}
 
 	req := &datatransferpb.GetTransferConfigRequest{
-	// TODO: Fill request struct fields.
+		// TODO: Fill request struct fields.
 	}
 	resp, err := c.GetTransferConfig(ctx, req)
 	if err != nil {
@@ -153,7 +153,7 @@ func ExampleClient_ListTransferConfigs() {
 	}
 
 	req := &datatransferpb.ListTransferConfigsRequest{
-	// TODO: Fill request struct fields.
+		// TODO: Fill request struct fields.
 	}
 	it := c.ListTransferConfigs(ctx, req)
 	for {
@@ -177,7 +177,7 @@ func ExampleClient_ScheduleTransferRuns() {
 	}
 
 	req := &datatransferpb.ScheduleTransferRunsRequest{
-	// TODO: Fill request struct fields.
+		// TODO: Fill request struct fields.
 	}
 	resp, err := c.ScheduleTransferRuns(ctx, req)
 	if err != nil {
@@ -195,7 +195,7 @@ func ExampleClient_GetTransferRun() {
 	}
 
 	req := &datatransferpb.GetTransferRunRequest{
-	// TODO: Fill request struct fields.
+		// TODO: Fill request struct fields.
 	}
 	resp, err := c.GetTransferRun(ctx, req)
 	if err != nil {
@@ -213,7 +213,7 @@ func ExampleClient_DeleteTransferRun() {
 	}
 
 	req := &datatransferpb.DeleteTransferRunRequest{
-	// TODO: Fill request struct fields.
+		// TODO: Fill request struct fields.
 	}
 	err = c.DeleteTransferRun(ctx, req)
 	if err != nil {
@@ -229,7 +229,7 @@ func ExampleClient_ListTransferRuns() {
 	}
 
 	req := &datatransferpb.ListTransferRunsRequest{
-	// TODO: Fill request struct fields.
+		// TODO: Fill request struct fields.
 	}
 	it := c.ListTransferRuns(ctx, req)
 	for {
@@ -253,7 +253,7 @@ func ExampleClient_ListTransferLogs() {
 	}
 
 	req := &datatransferpb.ListTransferLogsRequest{
-	// TODO: Fill request struct fields.
+		// TODO: Fill request struct fields.
 	}
 	it := c.ListTransferLogs(ctx, req)
 	for {
@@ -277,7 +277,7 @@ func ExampleClient_CheckValidCreds() {
 	}
 
 	req := &datatransferpb.CheckValidCredsRequest{
-	// TODO: Fill request struct fields.
+		// TODO: Fill request struct fields.
 	}
 	resp, err := c.CheckValidCreds(ctx, req)
 	if err != nil {

vendor/cloud.google.com/go/bigquery/datatransfer/apiv1/doc.go

@@ -1,10 +1,10 @@
-// Copyright 2017, Google LLC All rights reserved.
+// Copyright 2018 Google LLC
 //
 // 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
+//     https://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,

vendor/cloud.google.com/go/bigquery/datatransfer/apiv1/mock_test.go

@@ -1,10 +1,10 @@
-// Copyright 2017, Google LLC All rights reserved.
+// Copyright 2018 Google LLC
 //
 // 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
+//     https://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,
@@ -259,7 +259,7 @@ func TestDataTransferServiceGetDataSource(t *testing.T) {
 	var defaultSchedule string = "defaultSchedule-800168235"
 	var supportsCustomSchedule bool = true
 	var helpUrl string = "helpUrl-789431439"
-	var defaultDataRefreshWindowDays int32 = -1804935157
+	var defaultDataRefreshWindowDays int32 = 1804935157
 	var manualRunsDisabled bool = true
 	var expectedResponse = &datatransferpb.DataSource{
 		Name:                      name2,
@@ -281,7 +281,7 @@ func TestDataTransferServiceGetDataSource(t *testing.T) {
 
 	mockDataTransfer.resps = append(mockDataTransfer.resps[:0], expectedResponse)
 
-	var formattedName string = LocationDataSourcePath("[PROJECT]", "[LOCATION]", "[DATA_SOURCE]")
+	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/dataSources/%s", "[PROJECT]", "[LOCATION]", "[DATA_SOURCE]")
 	var request = &datatransferpb.GetDataSourceRequest{
 		Name: formattedName,
 	}
@@ -310,7 +310,7 @@ func TestDataTransferServiceGetDataSourceError(t *testing.T) {
 	errCode := codes.PermissionDenied
 	mockDataTransfer.err = gstatus.Error(errCode, "test error")
 
-	var formattedName string = LocationDataSourcePath("[PROJECT]", "[LOCATION]", "[DATA_SOURCE]")
+	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/dataSources/%s", "[PROJECT]", "[LOCATION]", "[DATA_SOURCE]")
 	var request = &datatransferpb.GetDataSourceRequest{
 		Name: formattedName,
 	}
@@ -343,7 +343,7 @@ func TestDataTransferServiceListDataSources(t *testing.T) {
 
 	mockDataTransfer.resps = append(mockDataTransfer.resps[:0], expectedResponse)
 
-	var formattedParent string = LocationPath("[PROJECT]", "[LOCATION]")
+	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
 	var request = &datatransferpb.ListDataSourcesRequest{
 		Parent: formattedParent,
 	}
@@ -382,7 +382,7 @@ func TestDataTransferServiceListDataSourcesError(t *testing.T) {
 	errCode := codes.PermissionDenied
 	mockDataTransfer.err = gstatus.Error(errCode, "test error")
 
-	var formattedParent string = LocationPath("[PROJECT]", "[LOCATION]")
+	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
 	var request = &datatransferpb.ListDataSourcesRequest{
 		Parent: formattedParent,
 	}
@@ -409,7 +409,7 @@ func TestDataTransferServiceCreateTransferConfig(t *testing.T) {
 	var schedule string = "schedule-697920873"
 	var dataRefreshWindowDays int32 = 327632845
 	var disabled bool = true
-	var userId int64 = -147132913
+	var userId int64 = 147132913
 	var datasetRegion string = "datasetRegion959248539"
 	var expectedResponse = &datatransferpb.TransferConfig{
 		Name:                  name,
@@ -428,7 +428,7 @@ func TestDataTransferServiceCreateTransferConfig(t *testing.T) {
 
 	mockDataTransfer.resps = append(mockDataTransfer.resps[:0], expectedResponse)
 
-	var formattedParent string = LocationPath("[PROJECT]", "[LOCATION]")
+	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
 	var transferConfig *datatransferpb.TransferConfig = &datatransferpb.TransferConfig{}
 	var request = &datatransferpb.CreateTransferConfigRequest{
 		Parent:         formattedParent,
@@ -459,7 +459,7 @@ func TestDataTransferServiceCreateTransferConfigError(t *testing.T) {
 	errCode := codes.PermissionDenied
 	mockDataTransfer.err = gstatus.Error(errCode, "test error")
 
-	var formattedParent string = LocationPath("[PROJECT]", "[LOCATION]")
+	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
 	var transferConfig *datatransferpb.TransferConfig = &datatransferpb.TransferConfig{}
 	var request = &datatransferpb.CreateTransferConfigRequest{
 		Parent:         formattedParent,
@@ -488,7 +488,7 @@ func TestDataTransferServiceUpdateTransferConfig(t *testing.T) {
 	var schedule string = "schedule-697920873"
 	var dataRefreshWindowDays int32 = 327632845
 	var disabled bool = true
-	var userId int64 = -147132913
+	var userId int64 = 147132913
 	var datasetRegion string = "datasetRegion959248539"
 	var expectedResponse = &datatransferpb.TransferConfig{
 		Name:                  name,
@@ -567,7 +567,7 @@ func TestDataTransferServiceDeleteTransferConfig(t *testing.T) {
 
 	mockDataTransfer.resps = append(mockDataTransfer.resps[:0], expectedResponse)
 
-	var formattedName string = LocationTransferConfigPath("[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]")
+	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/transferConfigs/%s", "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]")
 	var request = &datatransferpb.DeleteTransferConfigRequest{
 		Name: formattedName,
 	}
@@ -593,7 +593,7 @@ func TestDataTransferServiceDeleteTransferConfigError(t *testing.T) {
 	errCode := codes.PermissionDenied
 	mockDataTransfer.err = gstatus.Error(errCode, "test error")
 
-	var formattedName string = LocationTransferConfigPath("[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]")
+	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/transferConfigs/%s", "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]")
 	var request = &datatransferpb.DeleteTransferConfigRequest{
 		Name: formattedName,
 	}
@@ -619,7 +619,7 @@ func TestDataTransferServiceGetTransferConfig(t *testing.T) {
 	var schedule string = "schedule-697920873"
 	var dataRefreshWindowDays int32 = 327632845
 	var disabled bool = true
-	var userId int64 = -147132913
+	var userId int64 = 147132913
 	var datasetRegion string = "datasetRegion959248539"
 	var expectedResponse = &datatransferpb.TransferConfig{
 		Name:                  name2,
@@ -638,7 +638,7 @@ func TestDataTransferServiceGetTransferConfig(t *testing.T) {
 
 	mockDataTransfer.resps = append(mockDataTransfer.resps[:0], expectedResponse)
 
-	var formattedName string = LocationTransferConfigPath("[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]")
+	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/transferConfigs/%s", "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]")
 	var request = &datatransferpb.GetTransferConfigRequest{
 		Name: formattedName,
 	}
@@ -667,7 +667,7 @@ func TestDataTransferServiceGetTransferConfigError(t *testing.T) {
 	errCode := codes.PermissionDenied
 	mockDataTransfer.err = gstatus.Error(errCode, "test error")
 
-	var formattedName string = LocationTransferConfigPath("[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]")
+	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/transferConfigs/%s", "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]")
 	var request = &datatransferpb.GetTransferConfigRequest{
 		Name: formattedName,
 	}
@@ -700,7 +700,7 @@ func TestDataTransferServiceListTransferConfigs(t *testing.T) {
 
 	mockDataTransfer.resps = append(mockDataTransfer.resps[:0], expectedResponse)
 
-	var formattedParent string = LocationPath("[PROJECT]", "[LOCATION]")
+	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
 	var request = &datatransferpb.ListTransferConfigsRequest{
 		Parent: formattedParent,
 	}
@@ -739,7 +739,7 @@ func TestDataTransferServiceListTransferConfigsError(t *testing.T) {
 	errCode := codes.PermissionDenied
 	mockDataTransfer.err = gstatus.Error(errCode, "test error")
 
-	var formattedParent string = LocationPath("[PROJECT]", "[LOCATION]")
+	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
 	var request = &datatransferpb.ListTransferConfigsRequest{
 		Parent: formattedParent,
 	}
@@ -766,7 +766,7 @@ func TestDataTransferServiceScheduleTransferRuns(t *testing.T) {
 
 	mockDataTransfer.resps = append(mockDataTransfer.resps[:0], expectedResponse)
 
-	var formattedParent string = LocationTransferConfigPath("[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]")
+	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/transferConfigs/%s", "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]")
 	var startTime *timestamppb.Timestamp = &timestamppb.Timestamp{}
 	var endTime *timestamppb.Timestamp = &timestamppb.Timestamp{}
 	var request = &datatransferpb.ScheduleTransferRunsRequest{
@@ -799,7 +799,7 @@ func TestDataTransferServiceScheduleTransferRunsError(t *testing.T) {
 	errCode := codes.PermissionDenied
 	mockDataTransfer.err = gstatus.Error(errCode, "test error")
 
-	var formattedParent string = LocationTransferConfigPath("[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]")
+	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/transferConfigs/%s", "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]")
 	var startTime *timestamppb.Timestamp = &timestamppb.Timestamp{}
 	var endTime *timestamppb.Timestamp = &timestamppb.Timestamp{}
 	var request = &datatransferpb.ScheduleTransferRunsRequest{
@@ -826,7 +826,7 @@ func TestDataTransferServiceGetTransferRun(t *testing.T) {
 	var name2 string = "name2-1052831874"
 	var destinationDatasetId string = "destinationDatasetId1541564179"
 	var dataSourceId string = "dataSourceId-1015796374"
-	var userId int64 = -147132913
+	var userId int64 = 147132913
 	var schedule string = "schedule-697920873"
 	var expectedResponse = &datatransferpb.TransferRun{
 		Name:                 name2,
@@ -841,7 +841,7 @@ func TestDataTransferServiceGetTransferRun(t *testing.T) {
 
 	mockDataTransfer.resps = append(mockDataTransfer.resps[:0], expectedResponse)
 
-	var formattedName string = LocationRunPath("[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]", "[RUN]")
+	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/transferConfigs/%s/runs/%s", "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]", "[RUN]")
 	var request = &datatransferpb.GetTransferRunRequest{
 		Name: formattedName,
 	}
@@ -870,7 +870,7 @@ func TestDataTransferServiceGetTransferRunError(t *testing.T) {
 	errCode := codes.PermissionDenied
 	mockDataTransfer.err = gstatus.Error(errCode, "test error")
 
-	var formattedName string = LocationRunPath("[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]", "[RUN]")
+	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/transferConfigs/%s/runs/%s", "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]", "[RUN]")
 	var request = &datatransferpb.GetTransferRunRequest{
 		Name: formattedName,
 	}
@@ -897,7 +897,7 @@ func TestDataTransferServiceDeleteTransferRun(t *testing.T) {
 
 	mockDataTransfer.resps = append(mockDataTransfer.resps[:0], expectedResponse)
 
-	var formattedName string = LocationRunPath("[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]", "[RUN]")
+	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/transferConfigs/%s/runs/%s", "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]", "[RUN]")
 	var request = &datatransferpb.DeleteTransferRunRequest{
 		Name: formattedName,
 	}
@@ -923,7 +923,7 @@ func TestDataTransferServiceDeleteTransferRunError(t *testing.T) {
 	errCode := codes.PermissionDenied
 	mockDataTransfer.err = gstatus.Error(errCode, "test error")
 
-	var formattedName string = LocationRunPath("[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]", "[RUN]")
+	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/transferConfigs/%s/runs/%s", "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]", "[RUN]")
 	var request = &datatransferpb.DeleteTransferRunRequest{
 		Name: formattedName,
 	}
@@ -955,7 +955,7 @@ func TestDataTransferServiceListTransferRuns(t *testing.T) {
 
 	mockDataTransfer.resps = append(mockDataTransfer.resps[:0], expectedResponse)
 
-	var formattedParent string = LocationTransferConfigPath("[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]")
+	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/transferConfigs/%s", "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]")
 	var request = &datatransferpb.ListTransferRunsRequest{
 		Parent: formattedParent,
 	}
@@ -994,7 +994,7 @@ func TestDataTransferServiceListTransferRunsError(t *testing.T) {
 	errCode := codes.PermissionDenied
 	mockDataTransfer.err = gstatus.Error(errCode, "test error")
 
-	var formattedParent string = LocationTransferConfigPath("[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]")
+	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/transferConfigs/%s", "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]")
 	var request = &datatransferpb.ListTransferRunsRequest{
 		Parent: formattedParent,
 	}
@@ -1027,7 +1027,7 @@ func TestDataTransferServiceListTransferLogs(t *testing.T) {
 
 	mockDataTransfer.resps = append(mockDataTransfer.resps[:0], expectedResponse)
 
-	var formattedParent string = LocationRunPath("[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]", "[RUN]")
+	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/transferConfigs/%s/runs/%s", "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]", "[RUN]")
 	var request = &datatransferpb.ListTransferLogsRequest{
 		Parent: formattedParent,
 	}
@@ -1066,7 +1066,7 @@ func TestDataTransferServiceListTransferLogsError(t *testing.T) {
 	errCode := codes.PermissionDenied
 	mockDataTransfer.err = gstatus.Error(errCode, "test error")
 
-	var formattedParent string = LocationRunPath("[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]", "[RUN]")
+	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s/transferConfigs/%s/runs/%s", "[PROJECT]", "[LOCATION]", "[TRANSFER_CONFIG]", "[RUN]")
 	var request = &datatransferpb.ListTransferLogsRequest{
 		Parent: formattedParent,
 	}
@@ -1096,7 +1096,7 @@ func TestDataTransferServiceCheckValidCreds(t *testing.T) {
 
 	mockDataTransfer.resps = append(mockDataTransfer.resps[:0], expectedResponse)
 
-	var formattedName string = LocationDataSourcePath("[PROJECT]", "[LOCATION]", "[DATA_SOURCE]")
+	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/dataSources/%s", "[PROJECT]", "[LOCATION]", "[DATA_SOURCE]")
 	var request = &datatransferpb.CheckValidCredsRequest{
 		Name: formattedName,
 	}
@@ -1125,7 +1125,7 @@ func TestDataTransferServiceCheckValidCredsError(t *testing.T) {
 	errCode := codes.PermissionDenied
 	mockDataTransfer.err = gstatus.Error(errCode, "test error")
 
-	var formattedName string = LocationDataSourcePath("[PROJECT]", "[LOCATION]", "[DATA_SOURCE]")
+	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/dataSources/%s", "[PROJECT]", "[LOCATION]", "[DATA_SOURCE]")
 	var request = &datatransferpb.CheckValidCredsRequest{
 		Name: formattedName,
 	}

vendor/cloud.google.com/go/bigquery/datatransfer/apiv1/path_funcs.go

@@ -0,0 +1,135 @@
+// Copyright 2018 Google LLC
+//
+// 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
+//
+//     https://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 datatransfer
+
+// ProjectPath returns the path for the project resource.
+//
+// Deprecated: Use
+//   fmt.Sprintf("projects/%s", project)
+// instead.
+func ProjectPath(project string) string {
+	return "" +
+		"projects/" +
+		project +
+		""
+}
+
+// LocationPath returns the path for the location resource.
+//
+// Deprecated: Use
+//   fmt.Sprintf("projects/%s/locations/%s", project, location)
+// instead.
+func LocationPath(project, location string) string {
+	return "" +
+		"projects/" +
+		project +
+		"/locations/" +
+		location +
+		""
+}
+
+// LocationDataSourcePath returns the path for the location data source resource.
+//
+// Deprecated: Use
+//   fmt.Sprintf("projects/%s/locations/%s/dataSources/%s", project, location, dataSource)
+// instead.
+func LocationDataSourcePath(project, location, dataSource string) string {
+	return "" +
+		"projects/" +
+		project +
+		"/locations/" +
+		location +
+		"/dataSources/" +
+		dataSource +
+		""
+}
+
+// LocationTransferConfigPath returns the path for the location transfer config resource.
+//
+// Deprecated: Use
+//   fmt.Sprintf("projects/%s/locations/%s/transferConfigs/%s", project, location, transferConfig)
+// instead.
+func LocationTransferConfigPath(project, location, transferConfig string) string {
+	return "" +
+		"projects/" +
+		project +
+		"/locations/" +
+		location +
+		"/transferConfigs/" +
+		transferConfig +
+		""
+}
+
+// LocationRunPath returns the path for the location run resource.
+//
+// Deprecated: Use
+//   fmt.Sprintf("projects/%s/locations/%s/transferConfigs/%s/runs/%s", project, location, transferConfig, run)
+// instead.
+func LocationRunPath(project, location, transferConfig, run string) string {
+	return "" +
+		"projects/" +
+		project +
+		"/locations/" +
+		location +
+		"/transferConfigs/" +
+		transferConfig +
+		"/runs/" +
+		run +
+		""
+}
+
+// DataSourcePath returns the path for the data source resource.
+//
+// Deprecated: Use
+//   fmt.Sprintf("projects/%s/dataSources/%s", project, dataSource)
+// instead.
+func DataSourcePath(project, dataSource string) string {
+	return "" +
+		"projects/" +
+		project +
+		"/dataSources/" +
+		dataSource +
+		""
+}
+
+// TransferConfigPath returns the path for the transfer config resource.
+//
+// Deprecated: Use
+//   fmt.Sprintf("projects/%s/transferConfigs/%s", project, transferConfig)
+// instead.
+func TransferConfigPath(project, transferConfig string) string {
+	return "" +
+		"projects/" +
+		project +
+		"/transferConfigs/" +
+		transferConfig +
+		""
+}
+
+// RunPath returns the path for the run resource.
+//
+// Deprecated: Use
+//   fmt.Sprintf("projects/%s/transferConfigs/%s/runs/%s", project, transferConfig, run)
+// instead.
+func RunPath(project, transferConfig, run string) string {
+	return "" +
+		"projects/" +
+		project +
+		"/transferConfigs/" +
+		transferConfig +
+		"/runs/" +
+		run +
+		""
+}

vendor/cloud.google.com/go/bigquery/doc.go

@@ -150,8 +150,9 @@ There are two ways to construct schemas with this package.
 You can build a schema by hand, like so:
 
     schema1 := bigquery.Schema{
-        &bigquery.FieldSchema{Name: "Name", Required: true, Type: bigquery.StringFieldType},
-        &bigquery.FieldSchema{Name: "Grades", Repeated: true, Type: bigquery.IntegerFieldType},
+        {Name: "Name", Required: true, Type: bigquery.StringFieldType},
+        {Name: "Grades", Repeated: true, Type: bigquery.IntegerFieldType},
+        {Name: "Optional", Required: false, Type: bigquery.IntegerFieldType},
     }
 
 Or you can infer the schema from a struct:
@@ -159,6 +160,7 @@ Or you can infer the schema from a struct:
     type student struct {
         Name   string
         Grades []int
+        Optional bigquery.NullInt64
     }
     schema2, err := bigquery.InferSchema(student{})
     if err != nil {
@@ -166,20 +168,24 @@ Or you can infer the schema from a struct:
     }
     // schema1 and schema2 are identical.
 
-Struct inference supports tags like those of the encoding/json package,
-so you can change names, ignore fields, or mark a field as nullable (non-required):
+Struct inference supports tags like those of the encoding/json package, so you can
+change names, ignore fields, or mark a field as nullable (non-required). Fields
+declared as on of the Null types (NullInt64, NullFloat64, NullString, NullBool,
+NullTimestamp, NullDate, NullTime and NullDateTime) are automatically inferred as
+nullable, so the "nullable" tag is only needed for []byte and pointer-to-struct
+fields.
 
     type student2 struct {
         Name     string `bigquery:"full_name"`
         Grades   []int
         Secret   string `bigquery:"-"`
-        Optional int    `bigquery:",nullable"
+        Optional []byte `bigquery:",nullable"
     }
     schema3, err := bigquery.InferSchema(student2{})
     if err != nil {
         // TODO: Handle error.
     }
-    // schema3 has required fields "full_name", "Grade" and nullable field "Optional".
+    // schema3 has required fields "full_name" and "Grade", and nullable BYTES field "Optional".
 
 Having constructed a schema, you can create a table with it like so:
 

vendor/cloud.google.com/go/bigquery/examples_test.go

@@ -131,6 +131,23 @@ func ExampleClient_Query_parameters() {
 	// TODO: Call Query.Run or Query.Read.
 }
 
+// This example demonstrates how to run a query job on a table
+// with a customer-managed encryption key. The same
+// applies to load and copy jobs as well.
+func ExampleClient_Query_encryptionKey() {
+	ctx := context.Background()
+	client, err := bigquery.NewClient(ctx, "project-id")
+	if err != nil {
+		// TODO: Handle error.
+	}
+	q := client.Query("select name, num from t1")
+	// TODO: Replace this key with a key you have created in Cloud KMS.
+	keyName := "projects/P/locations/L/keyRings/R/cryptoKeys/K"
+	q.DestinationEncryptionConfig = &bigquery.EncryptionConfig{KMSKeyName: keyName}
+	// TODO: set other options on the Query.
+	// TODO: Call Query.Run or Query.Read.
+}
+
 func ExampleQuery_Read() {
 	ctx := context.Background()
 	client, err := bigquery.NewClient(ctx, "project-id")
@@ -399,7 +416,8 @@ func ExampleInferSchema_tags() {
 		Size     float64
 		Count    int    `bigquery:"number"`
 		Secret   []byte `bigquery:"-"`
-		Optional bool   `bigquery:",nullable"`
+		Optional bigquery.NullBool
+		OptBytes []byte `bigquery:",nullable"`
 	}
 	schema, err := bigquery.InferSchema(Item{})
 	if err != nil {
@@ -414,6 +432,7 @@ func ExampleInferSchema_tags() {
 	// Size FLOAT true
 	// number INTEGER true
 	// Optional BOOLEAN false
+	// OptBytes BYTES false
 }
 
 func ExampleTable_Create() {
@@ -451,6 +470,33 @@ func ExampleTable_Create_initialize() {
 	}
 }
 
+// This example demonstrates how to create a table with
+// a customer-managed encryption key.
+func ExampleTable_Create_encryptionKey() {
+	ctx := context.Background()
+	// Infer table schema from a Go type.
+	schema, err := bigquery.InferSchema(Item{})
+	if err != nil {
+		// TODO: Handle error.
+	}
+	client, err := bigquery.NewClient(ctx, "project-id")
+	if err != nil {
+		// TODO: Handle error.
+	}
+	t := client.Dataset("my_dataset").Table("new-table")
+
+	// TODO: Replace this key with a key you have created in Cloud KMS.
+	keyName := "projects/P/locations/L/keyRings/R/cryptoKeys/K"
+	if err := t.Create(ctx,
+		&bigquery.TableMetadata{
+			Name:             "My New Table",
+			Schema:           schema,
+			EncryptionConfig: &bigquery.EncryptionConfig{KMSKeyName: keyName},
+		}); err != nil {
+		// TODO: Handle error.
+	}
+}
+
 func ExampleTable_Delete() {
 	ctx := context.Background()
 	client, err := bigquery.NewClient(ctx, "project-id")
@@ -757,3 +803,27 @@ func ExampleUploader_Put_struct() {
 		// TODO: Handle error.
 	}
 }
+
+func ExampleUploader_Put_valuesSaver() {
+	ctx := context.Background()
+	client, err := bigquery.NewClient(ctx, "project-id")
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	u := client.Dataset("my_dataset").Table("my_table").Uploader()
+
+	var vss []*bigquery.ValuesSaver
+	for i, name := range []string{"n1", "n2", "n3"} {
+		// Assume schema holds the table's schema.
+		vss = append(vss, &bigquery.ValuesSaver{
+			Schema:   schema,
+			InsertID: name,
+			Row:      []bigquery.Value{name, int64(i)},
+		})
+	}
+
+	if err := u.Put(ctx, vss); err != nil {
+		// TODO: Handle error.
+	}
+}

vendor/cloud.google.com/go/bigquery/integration_test.go

@@ -600,7 +600,7 @@ func TestIntegration_UploadAndRead(t *testing.T) {
 	}
 
 	// Test reading directly into a []Value.
-	valueLists, err := readAll(table.Read(ctx))
+	valueLists, schema, _, err := readAll(table.Read(ctx))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -610,6 +610,9 @@ func TestIntegration_UploadAndRead(t *testing.T) {
 		if err := it.Next(&got); err != nil {
 			t.Fatal(err)
 		}
+		if !testutil.Equal(it.Schema, schema) {
+			t.Fatalf("got schema %v, want %v", it.Schema, schema)
+		}
 		want := []Value(vl)
 		if !testutil.Equal(got, want) {
 			t.Errorf("%d: got %v, want %v", i, got, want)
@@ -671,6 +674,10 @@ type TestStruct struct {
 	RecordArray []SubTestStruct
 }
 
+// Round times to the microsecond for comparison purposes.
+var roundToMicros = cmp.Transformer("RoundToMicros",
+	func(t time.Time) time.Time { return t.Round(time.Microsecond) })
+
 func TestIntegration_UploadAndReadStructs(t *testing.T) {
 	if client == nil {
 		t.Skip("Integration tests skipped")
@@ -684,14 +691,14 @@ func TestIntegration_UploadAndReadStructs(t *testing.T) {
 	table := newTable(t, schema)
 	defer table.Delete(ctx)
 
-	d := civil.Date{2016, 3, 20}
-	tm := civil.Time{15, 4, 5, 6000}
+	d := civil.Date{Year: 2016, Month: 3, Day: 20}
+	tm := civil.Time{Hour: 15, Minute: 4, Second: 5, Nanosecond: 6000}
 	ts := time.Date(2016, 3, 20, 15, 4, 5, 6000, time.UTC)
-	dtm := civil.DateTime{d, tm}
-	d2 := civil.Date{1994, 5, 15}
-	tm2 := civil.Time{1, 2, 4, 0}
+	dtm := civil.DateTime{Date: d, Time: tm}
+	d2 := civil.Date{Year: 1994, Month: 5, Day: 15}
+	tm2 := civil.Time{Hour: 1, Minute: 2, Second: 4, Nanosecond: 0}
 	ts2 := time.Date(1994, 5, 15, 1, 2, 4, 0, time.UTC)
-	dtm2 := civil.DateTime{d2, tm2}
+	dtm2 := civil.DateTime{Date: d2, Time: tm2}
 
 	// Populate the table.
 	upl := table.Uploader()
@@ -770,9 +777,6 @@ func TestIntegration_UploadAndReadStructs(t *testing.T) {
 	}
 	sort.Sort(byName(got))
 
-	// Round times to the microsecond.
-	roundToMicros := cmp.Transformer("RoundToMicros",
-		func(t time.Time) time.Time { return t.Round(time.Microsecond) })
 	// BigQuery does not elide nils. It reports an error for nil fields.
 	for i, g := range got {
 		if i >= len(want) {
@@ -789,6 +793,69 @@ func (b byName) Len() int           { return len(b) }
 func (b byName) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
 func (b byName) Less(i, j int) bool { return b[i].Name < b[j].Name }
 
+func TestIntegration_UploadAndReadNullable(t *testing.T) {
+	if client == nil {
+		t.Skip("Integration tests skipped")
+	}
+	ctm := civil.Time{Hour: 15, Minute: 4, Second: 5, Nanosecond: 6000}
+	cdt := civil.DateTime{Date: testDate, Time: ctm}
+	testUploadAndReadNullable(t, testStructNullable{}, make([]Value, len(testStructNullableSchema)))
+	testUploadAndReadNullable(t, testStructNullable{
+		String:    NullString{"x", true},
+		Bytes:     []byte{1, 2, 3},
+		Integer:   NullInt64{1, true},
+		Float:     NullFloat64{2.3, true},
+		Boolean:   NullBool{true, true},
+		Timestamp: NullTimestamp{testTimestamp, true},
+		Date:      NullDate{testDate, true},
+		Time:      NullTime{ctm, true},
+		DateTime:  NullDateTime{cdt, true},
+		Record:    &subNullable{X: NullInt64{4, true}},
+	},
+		[]Value{"x", []byte{1, 2, 3}, int64(1), 2.3, true, testTimestamp, testDate, ctm, cdt, []Value{int64(4)}})
+}
+
+func testUploadAndReadNullable(t *testing.T, ts testStructNullable, wantRow []Value) {
+	ctx := context.Background()
+	table := newTable(t, testStructNullableSchema)
+	defer table.Delete(ctx)
+
+	// Populate the table.
+	upl := table.Uploader()
+	if err := upl.Put(ctx, []*StructSaver{{Schema: testStructNullableSchema, Struct: ts}}); err != nil {
+		t.Fatal(putError(err))
+	}
+	// Wait until the data has been uploaded. This can take a few seconds, according
+	// to https://cloud.google.com/bigquery/streaming-data-into-bigquery.
+	if err := waitForRow(ctx, table); err != nil {
+		t.Fatal(err)
+	}
+
+	// Read into a []Value.
+	iter := table.Read(ctx)
+	gotRows, _, _, err := readAll(iter)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(gotRows) != 1 {
+		t.Fatalf("got %d rows, want 1", len(gotRows))
+	}
+	if diff := testutil.Diff(gotRows[0], wantRow, roundToMicros); diff != "" {
+		t.Error(diff)
+	}
+
+	// Read into a struct.
+	want := ts
+	var sn testStructNullable
+	it := table.Read(ctx)
+	if err := it.Next(&sn); err != nil {
+		t.Fatal(err)
+	}
+	if diff := testutil.Diff(sn, want, roundToMicros); diff != "" {
+		t.Error(diff)
+	}
+}
+
 func TestIntegration_TableUpdate(t *testing.T) {
 	if client == nil {
 		t.Skip("Integration tests skipped")
@@ -954,7 +1021,7 @@ func TestIntegration_Load(t *testing.T) {
 	if err := wait(ctx, job); err != nil {
 		t.Fatal(err)
 	}
-	checkRead(t, "reader load", table.Read(ctx), wantRows)
+	checkReadAndTotalRows(t, "reader load", table.Read(ctx), wantRows)
 
 }
 
@@ -1018,9 +1085,9 @@ func TestIntegration_TimeTypes(t *testing.T) {
 	table := newTable(t, dtSchema)
 	defer table.Delete(ctx)
 
-	d := civil.Date{2016, 3, 20}
-	tm := civil.Time{12, 30, 0, 6000}
-	dtm := civil.DateTime{d, tm}
+	d := civil.Date{Year: 2016, Month: 3, Day: 20}
+	tm := civil.Time{Hour: 12, Minute: 30, Second: 0, Nanosecond: 6000}
+	dtm := civil.DateTime{Date: d, Time: tm}
 	ts := time.Date(2016, 3, 20, 15, 04, 05, 0, time.UTC)
 	wantRows := [][]Value{
 		[]Value{d, tm, dtm, ts},
@@ -1054,8 +1121,8 @@ func TestIntegration_StandardQuery(t *testing.T) {
 	}
 	ctx := context.Background()
 
-	d := civil.Date{2016, 3, 20}
-	tm := civil.Time{15, 04, 05, 0}
+	d := civil.Date{Year: 2016, Month: 3, Day: 20}
+	tm := civil.Time{Hour: 15, Minute: 04, Second: 05, Nanosecond: 0}
 	ts := time.Date(2016, 3, 20, 15, 04, 05, 0, time.UTC)
 	dtm := ts.Format("2006-01-02 15:04:05")
 
@@ -1080,7 +1147,7 @@ func TestIntegration_StandardQuery(t *testing.T) {
 		{fmt.Sprintf("SELECT TIMESTAMP '%s'", dtm), []Value{ts}},
 		{fmt.Sprintf("SELECT [TIMESTAMP '%s', TIMESTAMP '%s']", dtm, dtm), []Value{[]Value{ts, ts}}},
 		{fmt.Sprintf("SELECT ('hello', TIMESTAMP '%s')", dtm), []Value{[]Value{"hello", ts}}},
-		{fmt.Sprintf("SELECT DATETIME(TIMESTAMP '%s')", dtm), []Value{civil.DateTime{d, tm}}},
+		{fmt.Sprintf("SELECT DATETIME(TIMESTAMP '%s')", dtm), []Value{civil.DateTime{Date: d, Time: tm}}},
 		{fmt.Sprintf("SELECT DATE(TIMESTAMP '%s')", dtm), []Value{d}},
 		{fmt.Sprintf("SELECT TIME(TIMESTAMP '%s')", dtm), []Value{tm}},
 		{"SELECT (1, 2)", []Value{ints(1, 2)}},
@@ -1139,9 +1206,11 @@ func TestIntegration_QueryParameters(t *testing.T) {
 	}
 	ctx := context.Background()
 
-	d := civil.Date{2016, 3, 20}
-	tm := civil.Time{15, 04, 05, 0}
-	dtm := civil.DateTime{d, tm}
+	d := civil.Date{Year: 2016, Month: 3, Day: 20}
+	tm := civil.Time{Hour: 15, Minute: 04, Second: 05, Nanosecond: 3008}
+	rtm := tm
+	rtm.Nanosecond = 3000 // round to microseconds
+	dtm := civil.DateTime{Date: d, Time: tm}
 	ts := time.Date(2016, 3, 20, 15, 04, 05, 0, time.UTC)
 
 	type ss struct {
@@ -1159,20 +1228,93 @@ func TestIntegration_QueryParameters(t *testing.T) {
 		query      string
 		parameters []QueryParameter
 		wantRow    []Value
+		wantConfig interface{}
 	}{
-		{"SELECT @val", []QueryParameter{{"val", 1}}, []Value{int64(1)}},
-		{"SELECT @val", []QueryParameter{{"val", 1.3}}, []Value{1.3}},
-		{"SELECT @val", []QueryParameter{{"val", true}}, []Value{true}},
-		{"SELECT @val", []QueryParameter{{"val", "ABC"}}, []Value{"ABC"}},
-		{"SELECT @val", []QueryParameter{{"val", []byte("foo")}}, []Value{[]byte("foo")}},
-		{"SELECT @val", []QueryParameter{{"val", ts}}, []Value{ts}},
-		{"SELECT @val", []QueryParameter{{"val", []time.Time{ts, ts}}}, []Value{[]Value{ts, ts}}},
-		{"SELECT @val", []QueryParameter{{"val", dtm}}, []Value{dtm}},
-		{"SELECT @val", []QueryParameter{{"val", d}}, []Value{d}},
-		{"SELECT @val", []QueryParameter{{"val", tm}}, []Value{tm}},
-		{"SELECT @val", []QueryParameter{{"val", s{ts, []string{"a", "b"}, ss{"c"}, []ss{{"d"}, {"e"}}}}},
-			[]Value{[]Value{ts, []Value{"a", "b"}, []Value{"c"}, []Value{[]Value{"d"}, []Value{"e"}}}}},
-		{"SELECT @val.Timestamp, @val.SubStruct.String", []QueryParameter{{"val", s{Timestamp: ts, SubStruct: ss{"a"}}}}, []Value{ts, "a"}},
+		{
+			"SELECT @val",
+			[]QueryParameter{{"val", 1}},
+			[]Value{int64(1)},
+			int64(1),
+		},
+		{
+			"SELECT @val",
+			[]QueryParameter{{"val", 1.3}},
+			[]Value{1.3},
+			1.3,
+		},
+		{
+			"SELECT @val",
+			[]QueryParameter{{"val", true}},
+			[]Value{true},
+			true,
+		},
+		{
+			"SELECT @val",
+			[]QueryParameter{{"val", "ABC"}},
+			[]Value{"ABC"},
+			"ABC",
+		},
+		{
+			"SELECT @val",
+			[]QueryParameter{{"val", []byte("foo")}},
+			[]Value{[]byte("foo")},
+			[]byte("foo"),
+		},
+		{
+			"SELECT @val",
+			[]QueryParameter{{"val", ts}},
+			[]Value{ts},
+			ts,
+		},
+		{
+			"SELECT @val",
+			[]QueryParameter{{"val", []time.Time{ts, ts}}},
+			[]Value{[]Value{ts, ts}},
+			[]interface{}{ts, ts},
+		},
+		{
+			"SELECT @val",
+			[]QueryParameter{{"val", dtm}},
+			[]Value{civil.DateTime{Date: d, Time: rtm}},
+			civil.DateTime{Date: d, Time: rtm},
+		},
+		{
+			"SELECT @val",
+			[]QueryParameter{{"val", d}},
+			[]Value{d},
+			d,
+		},
+		{
+			"SELECT @val",
+			[]QueryParameter{{"val", tm}},
+			[]Value{rtm},
+			rtm,
+		},
+		{
+			"SELECT @val",
+			[]QueryParameter{{"val", s{ts, []string{"a", "b"}, ss{"c"}, []ss{{"d"}, {"e"}}}}},
+			[]Value{[]Value{ts, []Value{"a", "b"}, []Value{"c"}, []Value{[]Value{"d"}, []Value{"e"}}}},
+			map[string]interface{}{
+				"Timestamp":   ts,
+				"StringArray": []interface{}{"a", "b"},
+				"SubStruct":   map[string]interface{}{"String": "c"},
+				"SubStructArray": []interface{}{
+					map[string]interface{}{"String": "d"},
+					map[string]interface{}{"String": "e"},
+				},
+			},
+		},
+		{
+			"SELECT @val.Timestamp, @val.SubStruct.String",
+			[]QueryParameter{{"val", s{Timestamp: ts, SubStruct: ss{"a"}}}},
+			[]Value{ts, "a"},
+			map[string]interface{}{
+				"Timestamp":      ts,
+				"SubStruct":      map[string]interface{}{"String": "a"},
+				"StringArray":    nil,
+				"SubStructArray": nil,
+			},
+		},
 	}
 	for _, c := range testCases {
 		q := client.Query(c.query)
@@ -1189,6 +1331,15 @@ func TestIntegration_QueryParameters(t *testing.T) {
 			t.Fatal(err)
 		}
 		checkRead(t, "QueryParameters", it, [][]Value{c.wantRow})
+		config, err := job.Config()
+		if err != nil {
+			t.Fatal(err)
+		}
+		got := config.(*QueryConfig).Parameters[0].Value
+		if !testutil.Equal(got, c.wantConfig) {
+			t.Errorf("param %[1]v (%[1]T): config:\ngot %[2]v (%[2]T)\nwant %[3]v (%[3]T)",
+				c.parameters[0].Value, got, c.wantConfig)
+		}
 	}
 }
 
@@ -1284,7 +1435,7 @@ func TestIntegration_ExtractExternal(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	checkRead(t, "external query", iter, wantRows)
+	checkReadAndTotalRows(t, "external query", iter, wantRows)
 
 	// Make a table pointing to the file, and query it.
 	// BigQuery does not allow a Table.Read on an external table.
@@ -1302,7 +1453,7 @@ func TestIntegration_ExtractExternal(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	checkRead(t, "external table", iter, wantRows)
+	checkReadAndTotalRows(t, "external table", iter, wantRows)
 
 	// While we're here, check that the table metadata is correct.
 	md, err := table.Metadata(ctx)
@@ -1466,19 +1617,28 @@ func newTable(t *testing.T, s Schema) *Table {
 }
 
 func checkRead(t *testing.T, msg string, it *RowIterator, want [][]Value) {
-	if msg2, ok := compareRead(it, want); !ok {
+	if msg2, ok := compareRead(it, want, false); !ok {
 		t.Errorf("%s: %s", msg, msg2)
 	}
 }
 
-func compareRead(it *RowIterator, want [][]Value) (msg string, ok bool) {
-	got, err := readAll(it)
+func checkReadAndTotalRows(t *testing.T, msg string, it *RowIterator, want [][]Value) {
+	if msg2, ok := compareRead(it, want, true); !ok {
+		t.Errorf("%s: %s", msg, msg2)
+	}
+}
+
+func compareRead(it *RowIterator, want [][]Value, compareTotalRows bool) (msg string, ok bool) {
+	got, _, totalRows, err := readAll(it)
 	if err != nil {
 		return err.Error(), false
 	}
 	if len(got) != len(want) {
 		return fmt.Sprintf("got %d rows, want %d", len(got), len(want)), false
 	}
+	if compareTotalRows && len(got) != int(totalRows) {
+		return fmt.Sprintf("got %d rows, but totalRows = %d", len(got), totalRows), false
+	}
 	sort.Sort(byCol0(got))
 	for i, r := range got {
 		gotRow := []Value(r)
@@ -1490,18 +1650,24 @@ func compareRead(it *RowIterator, want [][]Value) (msg string, ok bool) {
 	return "", true
 }
 
-func readAll(it *RowIterator) ([][]Value, error) {
-	var rows [][]Value
+func readAll(it *RowIterator) ([][]Value, Schema, uint64, error) {
+	var (
+		rows      [][]Value
+		schema    Schema
+		totalRows uint64
+	)
 	for {
 		var vals []Value
 		err := it.Next(&vals)
 		if err == iterator.Done {
-			return rows, nil
+			return rows, schema, totalRows, nil
 		}
 		if err != nil {
-			return nil, err
+			return nil, nil, 0, err
 		}
 		rows = append(rows, vals)
+		schema = it.Schema
+		totalRows = it.TotalRows
 	}
 }
 

vendor/cloud.google.com/go/bigquery/iterator.go

@@ -48,9 +48,14 @@ type RowIterator struct {
 	// is also set, StartIndex is ignored.
 	StartIndex uint64
 
-	rows [][]Value
+	// The schema of the table. Available after the first call to Next.
+	Schema Schema
 
-	schema       Schema       // populated on first call to fetch
+	// The total number of rows in the result. Available after the first call to Next.
+	// May be zero just after rows were inserted.
+	TotalRows uint64
+
+	rows         [][]Value
 	structLoader structLoader // used to populate a pointer to a struct
 }
 
@@ -88,8 +93,11 @@ type RowIterator struct {
 // type (RECORD or nested schema) corresponds to a nested struct or struct pointer.
 // All calls to Next on the same iterator must use the same struct type.
 //
-// It is an error to attempt to read a BigQuery NULL value into a struct field.
-// If your table contains NULLs, use a *[]Value or *map[string]Value.
+// It is an error to attempt to read a BigQuery NULL value into a struct field,
+// unless the field is of type []byte or is one of the special Null types: NullInt64,
+// NullFloat64, NullBool, NullString, NullTimestamp, NullDate, NullTime or
+// NullDateTime. You can also use a *[]Value or *map[string]Value to read from a
+// table with NULLs.
 func (it *RowIterator) Next(dst interface{}) error {
 	var vl ValueLoader
 	switch dst := dst.(type) {
@@ -113,12 +121,12 @@ func (it *RowIterator) Next(dst interface{}) error {
 	if vl == nil {
 		// This can only happen if dst is a pointer to a struct. We couldn't
 		// set vl above because we need the schema.
-		if err := it.structLoader.set(dst, it.schema); err != nil {
+		if err := it.structLoader.set(dst, it.Schema); err != nil {
 			return err
 		}
 		vl = &it.structLoader
 	}
-	return vl.Load(row, it.schema)
+	return vl.Load(row, it.Schema)
 }
 
 func isStructPtr(x interface{}) bool {
@@ -130,12 +138,13 @@ func isStructPtr(x interface{}) bool {
 func (it *RowIterator) PageInfo() *iterator.PageInfo { return it.pageInfo }
 
 func (it *RowIterator) fetch(pageSize int, pageToken string) (string, error) {
-	res, err := it.pf(it.ctx, it.table, it.schema, it.StartIndex, int64(pageSize), pageToken)
+	res, err := it.pf(it.ctx, it.table, it.Schema, it.StartIndex, int64(pageSize), pageToken)
 	if err != nil {
 		return "", err
 	}
 	it.rows = append(it.rows, res.rows...)
-	it.schema = res.schema
+	it.Schema = res.schema
+	it.TotalRows = res.totalRows
 	return res.pageToken, nil
 }
 

vendor/cloud.google.com/go/bigquery/iterator_test.go

@@ -64,6 +64,7 @@ func TestIterator(t *testing.T) {
 		want           [][]Value
 		wantErr        error
 		wantSchema     Schema
+		wantTotalRows  uint64
 	}{
 		{
 			desc: "Iteration over single empty page",
@@ -87,11 +88,13 @@ func TestIterator(t *testing.T) {
 						pageToken: "",
 						rows:      [][]Value{{1, 2}, {11, 12}},
 						schema:    iiSchema,
+						totalRows: 4,
 					},
 				},
 			},
-			want:       [][]Value{{1, 2}, {11, 12}},
-			wantSchema: iiSchema,
+			want:          [][]Value{{1, 2}, {11, 12}},
+			wantSchema:    iiSchema,
+			wantTotalRows: 4,
 		},
 		{
 			desc: "Iteration over single page with different schema",
@@ -115,6 +118,7 @@ func TestIterator(t *testing.T) {
 						pageToken: "a",
 						rows:      [][]Value{{1, 2}, {11, 12}},
 						schema:    iiSchema,
+						totalRows: 4,
 					},
 				},
 				"a": {
@@ -122,11 +126,13 @@ func TestIterator(t *testing.T) {
 						pageToken: "",
 						rows:      [][]Value{{101, 102}, {111, 112}},
 						schema:    iiSchema,
+						totalRows: 4,
 					},
 				},
 			},
-			want:       [][]Value{{1, 2}, {11, 12}, {101, 102}, {111, 112}},
-			wantSchema: iiSchema,
+			want:          [][]Value{{1, 2}, {11, 12}, {101, 102}, {111, 112}},
+			wantSchema:    iiSchema,
+			wantTotalRows: 4,
 		},
 		{
 			desc: "Server response includes empty page",
@@ -240,7 +246,7 @@ func TestIterator(t *testing.T) {
 		}
 		it := newRowIterator(context.Background(), nil, pf.fetchPage)
 		it.PageInfo().Token = tc.pageToken
-		values, schema, err := consumeRowIterator(it)
+		values, schema, totalRows, err := consumeRowIterator(it)
 		if err != tc.wantErr {
 			t.Fatalf("%s: got %v, want %v", tc.desc, err, tc.wantErr)
 		}
@@ -250,35 +256,31 @@ func TestIterator(t *testing.T) {
 		if (len(schema) != 0 || len(tc.wantSchema) != 0) && !testutil.Equal(schema, tc.wantSchema) {
 			t.Errorf("%s: iterator.Schema:\ngot: %v\nwant: %v", tc.desc, schema, tc.wantSchema)
 		}
+		if totalRows != tc.wantTotalRows {
+			t.Errorf("%s: totalRows: got %d, want %d", tc.desc, totalRows, tc.wantTotalRows)
+		}
 	}
 }
 
-type valueListWithSchema struct {
-	vals   valueList
-	schema Schema
-}
-
-func (v *valueListWithSchema) Load(vs []Value, s Schema) error {
-	v.vals.Load(vs, s)
-	v.schema = s
-	return nil
-}
-
 // consumeRowIterator reads the schema and all values from a RowIterator and returns them.
-func consumeRowIterator(it *RowIterator) ([][]Value, Schema, error) {
-	var got [][]Value
-	var schema Schema
+func consumeRowIterator(it *RowIterator) ([][]Value, Schema, uint64, error) {
+	var (
+		got       [][]Value
+		schema    Schema
+		totalRows uint64
+	)
 	for {
-		var vls valueListWithSchema
+		var vls []Value
 		err := it.Next(&vls)
 		if err == iterator.Done {
-			return got, schema, nil
+			return got, schema, totalRows, nil
 		}
 		if err != nil {
-			return got, schema, err
+			return got, schema, totalRows, err
 		}
-		got = append(got, vls.vals)
-		schema = vls.schema
+		got = append(got, vls)
+		schema = it.Schema
+		totalRows = it.TotalRows
 	}
 }
 
@@ -333,7 +335,7 @@ func TestNextAfterFinished(t *testing.T) {
 		}
 		it := newRowIterator(context.Background(), nil, pf.fetchPage)
 
-		values, _, err := consumeRowIterator(it)
+		values, _, _, err := consumeRowIterator(it)
 		if err != nil {
 			t.Fatal(err)
 		}

vendor/cloud.google.com/go/bigquery/job.go

@@ -261,17 +261,20 @@ func (j *Job) read(ctx context.Context, waitForQuery func(context.Context, strin
 	}
 	destTable := j.config.Query.DestinationTable
 	// The destination table should only be nil if there was a query error.
-	if destTable == nil {
-		return nil, errors.New("bigquery: query job missing destination table")
+	projectID := j.projectID
+	if destTable != nil && projectID != destTable.ProjectId {
+		return nil, fmt.Errorf("bigquery: job project ID is %q, but destination table's is %q", projectID, destTable.ProjectId)
 	}
-	projectID := destTable.ProjectId
 	schema, err := waitForQuery(ctx, projectID)
 	if err != nil {
 		return nil, err
 	}
+	if destTable == nil {
+		return nil, errors.New("bigquery: query job missing destination table")
+	}
 	dt := bqToTable(destTable, j.c)
 	it := newRowIterator(ctx, dt, pf)
-	it.schema = schema
+	it.Schema = schema
 	return it, nil
 }
 

vendor/cloud.google.com/go/bigquery/load.go

@@ -42,16 +42,20 @@ type LoadConfig struct {
 
 	// If non-nil, the destination table is partitioned by time.
 	TimePartitioning *TimePartitioning
+
+	// Custom encryption configuration (e.g., Cloud KMS keys).
+	DestinationEncryptionConfig *EncryptionConfig
 }
 
 func (l *LoadConfig) toBQ() (*bq.JobConfiguration, io.Reader) {
 	config := &bq.JobConfiguration{
 		Labels: l.Labels,
 		Load: &bq.JobConfigurationLoad{
-			CreateDisposition: string(l.CreateDisposition),
-			WriteDisposition:  string(l.WriteDisposition),
-			DestinationTable:  l.Dst.toBQ(),
-			TimePartitioning:  l.TimePartitioning.toBQ(),
+			CreateDisposition:                  string(l.CreateDisposition),
+			WriteDisposition:                   string(l.WriteDisposition),
+			DestinationTable:                   l.Dst.toBQ(),
+			TimePartitioning:                   l.TimePartitioning.toBQ(),
+			DestinationEncryptionConfiguration: l.DestinationEncryptionConfig.toBQ(),
 		},
 	}
 	media := l.Src.populateLoadConfig(config.Load)
@@ -60,11 +64,12 @@ func (l *LoadConfig) toBQ() (*bq.JobConfiguration, io.Reader) {
 
 func bqToLoadConfig(q *bq.JobConfiguration, c *Client) *LoadConfig {
 	lc := &LoadConfig{
-		Labels:            q.Labels,
-		CreateDisposition: TableCreateDisposition(q.Load.CreateDisposition),
-		WriteDisposition:  TableWriteDisposition(q.Load.WriteDisposition),
-		Dst:               bqToTable(q.Load.DestinationTable, c),
-		TimePartitioning:  bqToTimePartitioning(q.Load.TimePartitioning),
+		Labels:                      q.Labels,
+		CreateDisposition:           TableCreateDisposition(q.Load.CreateDisposition),
+		WriteDisposition:            TableWriteDisposition(q.Load.WriteDisposition),
+		Dst:                         bqToTable(q.Load.DestinationTable, c),
+		TimePartitioning:            bqToTimePartitioning(q.Load.TimePartitioning),
+		DestinationEncryptionConfig: bqToEncryptionConfig(q.Load.DestinationEncryptionConfiguration),
 	}
 	var fc *FileConfig
 	if len(q.Load.SourceUris) == 0 {

vendor/cloud.google.com/go/bigquery/load_test.go

@@ -89,10 +89,11 @@ func TestLoad(t *testing.T) {
 			dst:   c.Dataset("dataset-id").Table("table-id"),
 			jobID: "ajob",
 			config: LoadConfig{
-				CreateDisposition: CreateNever,
-				WriteDisposition:  WriteTruncate,
-				Labels:            map[string]string{"a": "b"},
-				TimePartitioning:  &TimePartitioning{Expiration: 1234 * time.Millisecond},
+				CreateDisposition:           CreateNever,
+				WriteDisposition:            WriteTruncate,
+				Labels:                      map[string]string{"a": "b"},
+				TimePartitioning:            &TimePartitioning{Expiration: 1234 * time.Millisecond},
+				DestinationEncryptionConfig: &EncryptionConfig{KMSKeyName: "keyName"},
 			},
 			src: NewGCSReference("uri"),
 			want: func() *bq.Job {
@@ -104,6 +105,7 @@ func TestLoad(t *testing.T) {
 					Type:         "DAY",
 					ExpirationMs: 1234,
 				}
+				j.Configuration.Load.DestinationEncryptionConfiguration = &bq.EncryptionConfiguration{KmsKeyName: "keyName"}
 				j.JobReference = &bq.JobReference{
 					JobId:     "ajob",
 					ProjectId: "client-project-id",

vendor/cloud.google.com/go/bigquery/nulls.go

@@ -0,0 +1,299 @@
+// 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 bigquery
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strconv"
+	"time"
+
+	"cloud.google.com/go/civil"
+)
+
+// NullInt64 represents a BigQuery INT64 that may be NULL.
+type NullInt64 struct {
+	Int64 int64
+	Valid bool // Valid is true if Int64 is not NULL.
+}
+
+func (n NullInt64) String() string { return nullstr(n.Valid, n.Int64) }
+
+// NullString represents a BigQuery STRING that may be NULL.
+type NullString struct {
+	StringVal string
+	Valid     bool // Valid is true if StringVal is not NULL.
+}
+
+func (n NullString) String() string { return nullstr(n.Valid, n.StringVal) }
+
+// NullFloat64 represents a BigQuery FLOAT64 that may be NULL.
+type NullFloat64 struct {
+	Float64 float64
+	Valid   bool // Valid is true if Float64 is not NULL.
+}
+
+func (n NullFloat64) String() string { return nullstr(n.Valid, n.Float64) }
+
+// NullBool represents a BigQuery BOOL that may be NULL.
+type NullBool struct {
+	Bool  bool
+	Valid bool // Valid is true if Bool is not NULL.
+}
+
+func (n NullBool) String() string { return nullstr(n.Valid, n.Bool) }
+
+// NullTimestamp represents a BigQuery TIMESTAMP that may be null.
+type NullTimestamp struct {
+	Timestamp time.Time
+	Valid     bool // Valid is true if Time is not NULL.
+}
+
+func (n NullTimestamp) String() string { return nullstr(n.Valid, n.Timestamp) }
+
+// NullDate represents a BigQuery DATE that may be null.
+type NullDate struct {
+	Date  civil.Date
+	Valid bool // Valid is true if Date is not NULL.
+}
+
+func (n NullDate) String() string { return nullstr(n.Valid, n.Date) }
+
+// NullTime represents a BigQuery TIME that may be null.
+type NullTime struct {
+	Time  civil.Time
+	Valid bool // Valid is true if Time is not NULL.
+}
+
+func (n NullTime) String() string {
+	if !n.Valid {
+		return "<null>"
+	}
+	return CivilTimeString(n.Time)
+}
+
+// NullDateTime represents a BigQuery DATETIME that may be null.
+type NullDateTime struct {
+	DateTime civil.DateTime
+	Valid    bool // Valid is true if DateTime is not NULL.
+}
+
+func (n NullDateTime) String() string {
+	if !n.Valid {
+		return "<null>"
+	}
+	return CivilDateTimeString(n.DateTime)
+}
+
+func (n NullInt64) MarshalJSON() ([]byte, error)     { return nulljson(n.Valid, n.Int64) }
+func (n NullFloat64) MarshalJSON() ([]byte, error)   { return nulljson(n.Valid, n.Float64) }
+func (n NullBool) MarshalJSON() ([]byte, error)      { return nulljson(n.Valid, n.Bool) }
+func (n NullString) MarshalJSON() ([]byte, error)    { return nulljson(n.Valid, n.StringVal) }
+func (n NullTimestamp) MarshalJSON() ([]byte, error) { return nulljson(n.Valid, n.Timestamp) }
+func (n NullDate) MarshalJSON() ([]byte, error)      { return nulljson(n.Valid, n.Date) }
+
+func (n NullTime) MarshalJSON() ([]byte, error) {
+	if !n.Valid {
+		return jsonNull, nil
+	}
+	return []byte(`"` + CivilTimeString(n.Time) + `"`), nil
+}
+
+func (n NullDateTime) MarshalJSON() ([]byte, error) {
+	if !n.Valid {
+		return jsonNull, nil
+	}
+	return []byte(`"` + CivilDateTimeString(n.DateTime) + `"`), nil
+}
+
+func nullstr(valid bool, v interface{}) string {
+	if !valid {
+		return "NULL"
+	}
+	return fmt.Sprint(v)
+}
+
+var jsonNull = []byte("null")
+
+func nulljson(valid bool, v interface{}) ([]byte, error) {
+	if !valid {
+		return jsonNull, nil
+	}
+	return json.Marshal(v)
+}
+
+func (n *NullInt64) UnmarshalJSON(b []byte) error {
+	n.Valid = false
+	n.Int64 = 0
+	if bytes.Equal(b, jsonNull) {
+		return nil
+	}
+
+	if err := json.Unmarshal(b, &n.Int64); err != nil {
+		return err
+	}
+	n.Valid = true
+	return nil
+}
+
+func (n *NullFloat64) UnmarshalJSON(b []byte) error {
+	n.Valid = false
+	n.Float64 = 0
+	if bytes.Equal(b, jsonNull) {
+		return nil
+	}
+
+	if err := json.Unmarshal(b, &n.Float64); err != nil {
+		return err
+	}
+	n.Valid = true
+	return nil
+}
+
+func (n *NullBool) UnmarshalJSON(b []byte) error {
+	n.Valid = false
+	n.Bool = false
+	if bytes.Equal(b, jsonNull) {
+		return nil
+	}
+
+	if err := json.Unmarshal(b, &n.Bool); err != nil {
+		return err
+	}
+	n.Valid = true
+	return nil
+}
+
+func (n *NullString) UnmarshalJSON(b []byte) error {
+	n.Valid = false
+	n.StringVal = ""
+	if bytes.Equal(b, jsonNull) {
+		return nil
+	}
+
+	if err := json.Unmarshal(b, &n.StringVal); err != nil {
+		return err
+	}
+	n.Valid = true
+	return nil
+}
+
+func (n *NullTimestamp) UnmarshalJSON(b []byte) error {
+	n.Valid = false
+	n.Timestamp = time.Time{}
+	if bytes.Equal(b, jsonNull) {
+		return nil
+	}
+
+	if err := json.Unmarshal(b, &n.Timestamp); err != nil {
+		return err
+	}
+	n.Valid = true
+	return nil
+}
+
+func (n *NullDate) UnmarshalJSON(b []byte) error {
+	n.Valid = false
+	n.Date = civil.Date{}
+	if bytes.Equal(b, jsonNull) {
+		return nil
+	}
+
+	if err := json.Unmarshal(b, &n.Date); err != nil {
+		return err
+	}
+	n.Valid = true
+	return nil
+}
+
+func (n *NullTime) UnmarshalJSON(b []byte) error {
+	n.Valid = false
+	n.Time = civil.Time{}
+	if bytes.Equal(b, jsonNull) {
+		return nil
+	}
+
+	s, err := strconv.Unquote(string(b))
+	if err != nil {
+		return err
+	}
+
+	t, err := civil.ParseTime(s)
+	if err != nil {
+		return err
+	}
+	n.Time = t
+
+	n.Valid = true
+	return nil
+}
+
+func (n *NullDateTime) UnmarshalJSON(b []byte) error {
+	n.Valid = false
+	n.DateTime = civil.DateTime{}
+	if bytes.Equal(b, jsonNull) {
+		return nil
+	}
+
+	s, err := strconv.Unquote(string(b))
+	if err != nil {
+		return err
+	}
+
+	dt, err := parseCivilDateTime(s)
+	if err != nil {
+		return err
+	}
+	n.DateTime = dt
+
+	n.Valid = true
+	return nil
+}
+
+var (
+	typeOfNullInt64     = reflect.TypeOf(NullInt64{})
+	typeOfNullFloat64   = reflect.TypeOf(NullFloat64{})
+	typeOfNullBool      = reflect.TypeOf(NullBool{})
+	typeOfNullString    = reflect.TypeOf(NullString{})
+	typeOfNullTimestamp = reflect.TypeOf(NullTimestamp{})
+	typeOfNullDate      = reflect.TypeOf(NullDate{})
+	typeOfNullTime      = reflect.TypeOf(NullTime{})
+	typeOfNullDateTime  = reflect.TypeOf(NullDateTime{})
+)
+
+func nullableFieldType(t reflect.Type) FieldType {
+	switch t {
+	case typeOfNullInt64:
+		return IntegerFieldType
+	case typeOfNullFloat64:
+		return FloatFieldType
+	case typeOfNullBool:
+		return BooleanFieldType
+	case typeOfNullString:
+		return StringFieldType
+	case typeOfNullTimestamp:
+		return TimestampFieldType
+	case typeOfNullDate:
+		return DateFieldType
+	case typeOfNullTime:
+		return TimeFieldType
+	case typeOfNullDateTime:
+		return DateTimeFieldType
+	default:
+		return ""
+	}
+}

vendor/cloud.google.com/go/bigquery/nulls_test.go

@@ -0,0 +1,73 @@
+// 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 bigquery
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+
+	"cloud.google.com/go/civil"
+	"cloud.google.com/go/internal/testutil"
+)
+
+var (
+	nullsTestTime     = civil.Time{Hour: 7, Minute: 50, Second: 22, Nanosecond: 1000}
+	nullsTestDateTime = civil.DateTime{Date: civil.Date{Year: 2016, Month: 11, Day: 5}, Time: nullsTestTime}
+)
+
+func TestNullsJSON(t *testing.T) {
+	for _, test := range []struct {
+		in   interface{}
+		want string
+	}{
+		{&NullInt64{Valid: true, Int64: 3}, `3`},
+		{&NullFloat64{Valid: true, Float64: 3.14}, `3.14`},
+		{&NullBool{Valid: true, Bool: true}, `true`},
+		{&NullString{Valid: true, StringVal: "foo"}, `"foo"`},
+		{&NullTimestamp{Valid: true, Timestamp: testTimestamp}, `"2016-11-05T07:50:22.000000008Z"`},
+		{&NullDate{Valid: true, Date: testDate}, `"2016-11-05"`},
+		{&NullTime{Valid: true, Time: nullsTestTime}, `"07:50:22.000001"`},
+		{&NullDateTime{Valid: true, DateTime: nullsTestDateTime}, `"2016-11-05 07:50:22.000001"`},
+
+		{&NullInt64{}, `null`},
+		{&NullFloat64{}, `null`},
+		{&NullBool{}, `null`},
+		{&NullString{}, `null`},
+		{&NullTimestamp{}, `null`},
+		{&NullDate{}, `null`},
+		{&NullTime{}, `null`},
+		{&NullDateTime{}, `null`},
+	} {
+		bytes, err := json.Marshal(test.in)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got, want := string(bytes), test.want; got != want {
+			t.Errorf("%#v: got %s, want %s", test.in, got, want)
+		}
+
+		typ := reflect.Indirect(reflect.ValueOf(test.in)).Type()
+		value := reflect.New(typ).Interface()
+		err = json.Unmarshal(bytes, value)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if !testutil.Equal(value, test.in) {
+			t.Errorf("%#v: got %#v, want %#v", test.in, value, test.in)
+		}
+	}
+}

vendor/cloud.google.com/go/bigquery/params.go

@@ -20,7 +20,6 @@ import (
 	"fmt"
 	"reflect"
 	"regexp"
-	"strings"
 	"time"
 
 	"cloud.google.com/go/civil"
@@ -205,6 +204,8 @@ func paramValue(v reflect.Value) (bq.QueryParameterValue, error) {
 
 	case typeOfTime:
 		// civil.Time has nanosecond resolution, but BigQuery TIME only microsecond.
+		// (If we send nanoseconds, then when we try to read the result we get "query job
+		// missing destination table").
 		res.Value = CivilTimeString(v.Interface().(civil.Time))
 		return res, nil
 
@@ -306,11 +307,7 @@ func convertParamValue(qval *bq.QueryParameterValue, qtype *bq.QueryParameterTyp
 	case "TIMESTAMP":
 		return time.Parse(timestampFormat, qval.Value)
 	case "DATETIME":
-		parts := strings.Fields(qval.Value)
-		if len(parts) != 2 {
-			return nil, fmt.Errorf("bigquery: bad DATETIME value %q", qval.Value)
-		}
-		return civil.ParseDateTime(parts[0] + "T" + parts[1])
+		return parseCivilDateTime(qval.Value)
 	default:
 		return convertBasicType(qval.Value, paramTypeToFieldType[qtype.Type])
 	}

vendor/cloud.google.com/go/bigquery/params_test.go

@@ -45,9 +45,9 @@ var scalarTests = []struct {
 	{time.Date(2016, 3, 20, 4, 22, 9, 5000, time.FixedZone("neg1-2", -3720)),
 		"2016-03-20 04:22:09.000005-01:02",
 		timestampParamType},
-	{civil.Date{2016, 3, 20}, "2016-03-20", dateParamType},
-	{civil.Time{4, 5, 6, 789000000}, "04:05:06.789000", timeParamType},
-	{civil.DateTime{civil.Date{2016, 3, 20}, civil.Time{4, 5, 6, 789000000}},
+	{civil.Date{Year: 2016, Month: 3, Day: 20}, "2016-03-20", dateParamType},
+	{civil.Time{Hour: 4, Minute: 5, Second: 6, Nanosecond: 789000000}, "04:05:06.789000", timeParamType},
+	{civil.DateTime{Date: civil.Date{Year: 2016, Month: 3, Day: 20}, Time: civil.Time{Hour: 4, Minute: 5, Second: 6, Nanosecond: 789000000}},
 		"2016-03-20 04:05:06.789000",
 		dateTimeParamType},
 }

vendor/cloud.google.com/go/bigquery/query.go

@@ -100,6 +100,10 @@ type QueryConfig struct {
 	// It is illegal to mix positional and named syntax.
 	Parameters []QueryParameter
 
+	// TimePartitioning specifies time-based partitioning
+	// for the destination table.
+	TimePartitioning *TimePartitioning
+
 	// The labels associated with this job.
 	Labels map[string]string
 
@@ -111,16 +115,21 @@ type QueryConfig struct {
 	// call LastStatus on the returned job to get statistics. Calling Status on a
 	// dry-run job will fail.
 	DryRun bool
+
+	// Custom encryption configuration (e.g., Cloud KMS keys).
+	DestinationEncryptionConfig *EncryptionConfig
 }
 
 func (qc *QueryConfig) toBQ() (*bq.JobConfiguration, error) {
 	qconf := &bq.JobConfigurationQuery{
-		Query:              qc.Q,
-		CreateDisposition:  string(qc.CreateDisposition),
-		WriteDisposition:   string(qc.WriteDisposition),
-		AllowLargeResults:  qc.AllowLargeResults,
-		Priority:           string(qc.Priority),
-		MaximumBytesBilled: qc.MaxBytesBilled,
+		Query:                              qc.Q,
+		CreateDisposition:                  string(qc.CreateDisposition),
+		WriteDisposition:                   string(qc.WriteDisposition),
+		AllowLargeResults:                  qc.AllowLargeResults,
+		Priority:                           string(qc.Priority),
+		MaximumBytesBilled:                 qc.MaxBytesBilled,
+		TimePartitioning:                   qc.TimePartitioning.toBQ(),
+		DestinationEncryptionConfiguration: qc.DestinationEncryptionConfig.toBQ(),
 	}
 	if len(qc.TableDefinitions) > 0 {
 		qconf.TableDefinitions = make(map[string]bq.ExternalDataConfiguration)
@@ -188,6 +197,7 @@ func bqToQueryConfig(q *bq.JobConfiguration, c *Client) (*QueryConfig, error) {
 		MaxBytesBilled:    qq.MaximumBytesBilled,
 		UseLegacySQL:      qq.UseLegacySql,
 		UseStandardSQL:    !qq.UseLegacySql,
+		TimePartitioning:  bqToTimePartitioning(qq.TimePartitioning),
 	}
 	if len(qq.TableDefinitions) > 0 {
 		qc.TableDefinitions = make(map[string]ExternalData)

vendor/cloud.google.com/go/bigquery/query_test.go

@@ -16,6 +16,7 @@ package bigquery
 
 import (
 	"testing"
+	"time"
 
 	"github.com/google/go-cmp/cmp"
 
@@ -350,6 +351,8 @@ func TestConfiguringQuery(t *testing.T) {
 	query.JobID = "ajob"
 	query.DefaultProjectID = "def-project-id"
 	query.DefaultDatasetID = "def-dataset-id"
+	query.TimePartitioning = &TimePartitioning{Expiration: 1234 * time.Second, Field: "f"}
+	query.DestinationEncryptionConfig = &EncryptionConfig{KMSKeyName: "keyName"}
 	// Note: Other configuration fields are tested in other tests above.
 	// A lot of that can be consolidated once Client.Copy is gone.
 
@@ -361,8 +364,10 @@ func TestConfiguringQuery(t *testing.T) {
 					ProjectId: "def-project-id",
 					DatasetId: "def-dataset-id",
 				},
-				UseLegacySql:    false,
-				ForceSendFields: []string{"UseLegacySql"},
+				UseLegacySql:                       false,
+				TimePartitioning:                   &bq.TimePartitioning{ExpirationMs: 1234000, Field: "f", Type: "DAY"},
+				DestinationEncryptionConfiguration: &bq.EncryptionConfiguration{KmsKeyName: "keyName"},
+				ForceSendFields:                    []string{"UseLegacySql"},
 			},
 		},
 		JobReference: &bq.JobReference{

vendor/cloud.google.com/go/bigquery/schema.go

@@ -122,21 +122,66 @@ var (
 	errNoStruct             = errors.New("bigquery: can only infer schema from struct or pointer to struct")
 	errUnsupportedFieldType = errors.New("bigquery: unsupported type of field in struct")
 	errInvalidFieldName     = errors.New("bigquery: invalid name of field in struct")
+	errBadNullable          = errors.New(`bigquery: use "nullable" only for []byte and struct pointers; for all other types, use a NullXXX type`)
 )
 
 var typeOfByteSlice = reflect.TypeOf([]byte{})
 
 // InferSchema tries to derive a BigQuery schema from the supplied struct value.
-// NOTE: All fields in the returned Schema are configured to be required,
-// unless the corresponding field in the supplied struct is a slice or array.
+// Each exported struct field is mapped to a field in the schema.
 //
-// It is considered an error if the struct (including nested structs) contains
-// any exported fields that are pointers or one of the following types:
-// uint, uint64, uintptr, map, interface, complex64, complex128, func, chan.
-// In these cases, an error will be returned.
-// Future versions may handle these cases without error.
+// The following BigQuery types are inferred from the corresponding Go types.
+// (This is the same mapping as that used for RowIterator.Next.) Fields inferred
+// from these types are marked required (non-nullable).
+//
+//   STRING      string
+//   BOOL        bool
+//   INTEGER     int, int8, int16, int32, int64, uint8, uint16, uint32
+//   FLOAT       float32, float64
+//   BYTES       []byte
+//   TIMESTAMP   time.Time
+//   DATE        civil.Date
+//   TIME        civil.Time
+//   DATETIME    civil.DateTime
+//
+// A Go slice or array type is inferred to be a BigQuery repeated field of the
+// element type. The element type must be one of the above listed types.
+//
+// Nullable fields are inferred from the NullXXX types, declared in this package:
+//
+//   STRING      NullString
+//   BOOL        NullBool
+//   INTEGER     NullInt64
+//   FLOAT       NullFloat64
+//   TIMESTAMP   NullTimestamp
+//   DATE        NullDate
+//   TIME        NullTime
+//   DATETIME    NullDateTime
+
+// For a nullable BYTES field, use the type []byte and tag the field "nullable" (see below).
+//
+// A struct field that is of struct type is inferred to be a required field of type
+// RECORD with a schema inferred recursively. For backwards compatibility, a field of
+// type pointer to struct is also inferred to be required. To get a nullable RECORD
+// field, use the "nullable" tag (see below).
+//
+// InferSchema returns an error if any of the examined fields is of type uint,
+// uint64, uintptr, map, interface, complex64, complex128, func, or chan. Future
+// versions may handle these cases without error.
 //
 // Recursively defined structs are also disallowed.
+//
+// Struct fields may be tagged in a way similar to the encoding/json package.
+// A tag of the form
+//     bigquery:"name"
+// uses "name" instead of the struct field name as the BigQuery field name.
+// A tag of the form
+//     bigquery:"-"
+// omits the field from the inferred schema.
+// The "nullable" option marks the field as nullable (not required). It is only
+// needed for []byte and pointer-to-struct fields, and cannot appear on other
+// fields. In this example, the Go name of the field is retained:
+//     bigquery:",nullable"
 func InferSchema(st interface{}) (Schema, error) {
 	return inferSchemaReflectCached(reflect.TypeOf(st))
 }
@@ -186,20 +231,27 @@ func inferStruct(t reflect.Type) (Schema, error) {
 
 // inferFieldSchema infers the FieldSchema for a Go type
 func inferFieldSchema(rt reflect.Type, nullable bool) (*FieldSchema, error) {
+	// Only []byte and struct pointers can be tagged nullable.
+	if nullable && !(rt == typeOfByteSlice || rt.Kind() == reflect.Ptr && rt.Elem().Kind() == reflect.Struct) {
+		return nil, errBadNullable
+	}
 	switch rt {
 	case typeOfByteSlice:
 		return &FieldSchema{Required: !nullable, Type: BytesFieldType}, nil
 	case typeOfGoTime:
-		return &FieldSchema{Required: !nullable, Type: TimestampFieldType}, nil
+		return &FieldSchema{Required: true, Type: TimestampFieldType}, nil
 	case typeOfDate:
-		return &FieldSchema{Required: !nullable, Type: DateFieldType}, nil
+		return &FieldSchema{Required: true, Type: DateFieldType}, nil
 	case typeOfTime:
-		return &FieldSchema{Required: !nullable, Type: TimeFieldType}, nil
+		return &FieldSchema{Required: true, Type: TimeFieldType}, nil
 	case typeOfDateTime:
-		return &FieldSchema{Required: !nullable, Type: DateTimeFieldType}, nil
+		return &FieldSchema{Required: true, Type: DateTimeFieldType}, nil
 	}
-	if isSupportedIntType(rt) {
-		return &FieldSchema{Required: !nullable, Type: IntegerFieldType}, nil
+	if ft := nullableFieldType(rt); ft != "" {
+		return &FieldSchema{Required: false, Type: ft}, nil
+	}
+	if isSupportedIntType(rt) || isSupportedUintType(rt) {
+		return &FieldSchema{Required: true, Type: IntegerFieldType}, nil
 	}
 	switch rt.Kind() {
 	case reflect.Slice, reflect.Array:
@@ -208,7 +260,10 @@ func inferFieldSchema(rt reflect.Type, nullable bool) (*FieldSchema, error) {
 			// Multi dimensional slices/arrays are not supported by BigQuery
 			return nil, errUnsupportedFieldType
 		}
-
+		if nullableFieldType(et) != "" {
+			// Repeated nullable types are not supported by BigQuery.
+			return nil, errUnsupportedFieldType
+		}
 		f, err := inferFieldSchema(et, false)
 		if err != nil {
 			return nil, err
@@ -216,7 +271,12 @@ func inferFieldSchema(rt reflect.Type, nullable bool) (*FieldSchema, error) {
 		f.Repeated = true
 		f.Required = false
 		return f, nil
-	case reflect.Struct, reflect.Ptr:
+	case reflect.Ptr:
+		if rt.Elem().Kind() != reflect.Struct {
+			return nil, errUnsupportedFieldType
+		}
+		fallthrough
+	case reflect.Struct:
 		nested, err := inferStruct(rt)
 		if err != nil {
 			return nil, err
@@ -258,12 +318,22 @@ func inferFields(rt reflect.Type) (Schema, error) {
 	return s, nil
 }
 
-// isSupportedIntType reports whether t can be properly represented by the
-// BigQuery INTEGER/INT64 type.
+// isSupportedIntType reports whether t is an int type that can be properly
+// represented by the BigQuery INTEGER/INT64 type.
 func isSupportedIntType(t reflect.Type) bool {
 	switch t.Kind() {
-	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int,
-		reflect.Uint8, reflect.Uint16, reflect.Uint32:
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		return true
+	default:
+		return false
+	}
+}
+
+// isSupportedIntType reports whether t is a uint type that can be properly
+// represented by the BigQuery INTEGER/INT64 type.
+func isSupportedUintType(t reflect.Type) bool {
+	switch t.Kind() {
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32:
 		return true
 	default:
 		return false

vendor/cloud.google.com/go/bigquery/schema_test.go

@@ -248,6 +248,14 @@ func reqField(name, typ string) *FieldSchema {
 	}
 }
 
+func optField(name, typ string) *FieldSchema {
+	return &FieldSchema{
+		Name:     name,
+		Type:     FieldType(typ),
+		Required: false,
+	}
+}
+
 func TestSimpleInference(t *testing.T) {
 	testCases := []struct {
 		in   interface{}
@@ -491,6 +499,37 @@ func TestRepeatedInference(t *testing.T) {
 	}
 }
 
+type allNulls struct {
+	A NullInt64
+	B NullFloat64
+	C NullBool
+	D NullString
+	E NullTimestamp
+	F NullTime
+	G NullDate
+	H NullDateTime
+}
+
+func TestNullInference(t *testing.T) {
+	got, err := InferSchema(allNulls{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := Schema{
+		optField("A", "INTEGER"),
+		optField("B", "FLOAT"),
+		optField("C", "BOOLEAN"),
+		optField("D", "STRING"),
+		optField("E", "TIMESTAMP"),
+		optField("F", "TIME"),
+		optField("G", "DATE"),
+		optField("H", "DATETIME"),
+	}
+	if diff := testutil.Diff(got, want); diff != "" {
+		t.Error(diff)
+	}
+}
+
 type Embedded struct {
 	Embedded int
 }
@@ -532,11 +571,11 @@ func TestRecursiveInference(t *testing.T) {
 
 type withTags struct {
 	NoTag         int
-	ExcludeTag    int `bigquery:"-"`
-	SimpleTag     int `bigquery:"simple_tag"`
-	UnderscoreTag int `bigquery:"_id"`
-	MixedCase     int `bigquery:"MIXEDcase"`
-	Nullable      int `bigquery:",nullable"`
+	ExcludeTag    int    `bigquery:"-"`
+	SimpleTag     int    `bigquery:"simple_tag"`
+	UnderscoreTag int    `bigquery:"_id"`
+	MixedCase     int    `bigquery:"MIXEDcase"`
+	Nullable      []byte `bigquery:",nullable"`
 }
 
 type withTagsNested struct {
@@ -545,6 +584,8 @@ type withTagsNested struct {
 		ExcludeTag int `bigquery:"-"`
 		Inside     int `bigquery:"inside"`
 	} `bigquery:"anon"`
+	PNested         *struct{ X int } // not nullable, for backwards compatibility
+	PNestedNullable *struct{ X int } `bigquery:",nullable"`
 }
 
 type withTagsRepeated struct {
@@ -564,7 +605,7 @@ var withTagsSchema = Schema{
 	reqField("simple_tag", "INTEGER"),
 	reqField("_id", "INTEGER"),
 	reqField("MIXEDcase", "INTEGER"),
-	{Name: "Nullable", Type: FieldType("INTEGER"), Required: false},
+	optField("Nullable", "BYTES"),
 }
 
 func TestTagInference(t *testing.T) {
@@ -591,6 +632,18 @@ func TestTagInference(t *testing.T) {
 					Type:     "RECORD",
 					Schema:   Schema{reqField("inside", "INTEGER")},
 				},
+				&FieldSchema{
+					Name:     "PNested",
+					Required: true,
+					Type:     "RECORD",
+					Schema:   Schema{reqField("X", "INTEGER")},
+				},
+				&FieldSchema{
+					Name:     "PNestedNullable",
+					Required: false,
+					Type:     "RECORD",
+					Schema:   Schema{reqField("X", "INTEGER")},
+				},
 			},
 		},
 		{
@@ -724,7 +777,7 @@ func TestSchemaErrors(t *testing.T) {
 		},
 		{
 			in:  struct{ Ptr *int }{},
-			err: errNoStruct,
+			err: errUnsupportedFieldType,
 		},
 		{
 			in:  struct{ Interface interface{} }{},
@@ -738,6 +791,14 @@ func TestSchemaErrors(t *testing.T) {
 			in:  struct{ MultiDimensional [][][]byte }{},
 			err: errUnsupportedFieldType,
 		},
+		{
+			in:  struct{ SliceOfPointer []*int }{},
+			err: errUnsupportedFieldType,
+		},
+		{
+			in:  struct{ SliceOfNull []NullInt64 }{},
+			err: errUnsupportedFieldType,
+		},
 		{
 			in:  struct{ ChanSlice []chan bool }{},
 			err: errUnsupportedFieldType,
@@ -746,6 +807,42 @@ func TestSchemaErrors(t *testing.T) {
 			in:  struct{ NestedChan struct{ Chan []chan bool } }{},
 			err: errUnsupportedFieldType,
 		},
+		{
+			in: struct {
+				X int `bigquery:",nullable"`
+			}{},
+			err: errBadNullable,
+		},
+		{
+			in: struct {
+				X bool `bigquery:",nullable"`
+			}{},
+			err: errBadNullable,
+		},
+		{
+			in: struct {
+				X struct{ N int } `bigquery:",nullable"`
+			}{},
+			err: errBadNullable,
+		},
+		{
+			in: struct {
+				X []int `bigquery:",nullable"`
+			}{},
+			err: errBadNullable,
+		},
+		{
+			in:  struct{ X *[]byte }{},
+			err: errUnsupportedFieldType,
+		},
+		{
+			in:  struct{ X *[]int }{},
+			err: errUnsupportedFieldType,
+		},
+		{
+			in:  struct{ X *int }{},
+			err: errUnsupportedFieldType,
+		},
 	}
 	for _, tc := range testCases {
 		want := tc.err

vendor/cloud.google.com/go/bigquery/table.go

@@ -76,6 +76,9 @@ type TableMetadata struct {
 	// Information about a table stored outside of BigQuery.
 	ExternalDataConfig *ExternalDataConfig
 
+	// Custom encryption configuration (e.g., Cloud KMS keys).
+	EncryptionConfig *EncryptionConfig
+
 	// All the fields below are read-only.
 
 	FullID           string // An opaque ID uniquely identifying the table.
@@ -175,6 +178,32 @@ func bqToTimePartitioning(q *bq.TimePartitioning) *TimePartitioning {
 	}
 }
 
+// EncryptionConfig configures customer-managed encryption on tables.
+type EncryptionConfig struct {
+	// Describes the Cloud KMS encryption key that will be used to protect
+	// destination BigQuery table. The BigQuery Service Account associated with your
+	// project requires access to this encryption key.
+	KMSKeyName string
+}
+
+func (e *EncryptionConfig) toBQ() *bq.EncryptionConfiguration {
+	if e == nil {
+		return nil
+	}
+	return &bq.EncryptionConfiguration{
+		KmsKeyName: e.KMSKeyName,
+	}
+}
+
+func bqToEncryptionConfig(q *bq.EncryptionConfiguration) *EncryptionConfig {
+	if q == nil {
+		return nil
+	}
+	return &EncryptionConfig{
+		KMSKeyName: q.KmsKeyName,
+	}
+}
+
 // StreamingBuffer holds information about the streaming buffer.
 type StreamingBuffer struct {
 	// A lower-bound estimate of the number of bytes currently in the streaming
@@ -265,6 +294,7 @@ func (tm *TableMetadata) toBQ() (*bq.Table, error) {
 		edc := tm.ExternalDataConfig.toBQ()
 		t.ExternalDataConfiguration = &edc
 	}
+	t.EncryptionConfiguration = tm.EncryptionConfig.toBQ()
 	if tm.FullID != "" {
 		return nil, errors.New("cannot set FullID on create")
 	}
@@ -320,6 +350,7 @@ func bqToTableMetadata(t *bq.Table) (*TableMetadata, error) {
 		CreationTime:     unixMillisToTime(t.CreationTime),
 		LastModifiedTime: unixMillisToTime(int64(t.LastModifiedTime)),
 		ETag:             t.Etag,
+		EncryptionConfig: bqToEncryptionConfig(t.EncryptionConfiguration),
 	}
 	if t.Schema != nil {
 		md.Schema = bqToSchema(t.Schema)

vendor/cloud.google.com/go/bigquery/table_test.go

@@ -53,6 +53,7 @@ func TestBQToTableMetadata(t *testing.T) {
 					Type:         "DAY",
 					Field:        "pfield",
 				},
+				EncryptionConfiguration: &bq.EncryptionConfiguration{KmsKeyName: "keyName"},
 				Type:   "EXTERNAL",
 				View:   &bq.ViewDefinition{Query: "view-query"},
 				Labels: map[string]string{"a": "b"},
@@ -82,7 +83,8 @@ func TestBQToTableMetadata(t *testing.T) {
 					EstimatedRows:   3,
 					OldestEntryTime: aTime,
 				},
-				ETag: "etag",
+				EncryptionConfig: &EncryptionConfig{KMSKeyName: "keyName"},
+				ETag:             "etag",
 			},
 		},
 	} {
@@ -115,6 +117,7 @@ func TestTableMetadataToBQ(t *testing.T) {
 				ExpirationTime:     aTime,
 				Labels:             map[string]string{"a": "b"},
 				ExternalDataConfig: &ExternalDataConfig{SourceFormat: Bigtable},
+				EncryptionConfig:   &EncryptionConfig{KMSKeyName: "keyName"},
 			},
 			&bq.Table{
 				FriendlyName: "n",
@@ -127,6 +130,7 @@ func TestTableMetadataToBQ(t *testing.T) {
 				ExpirationTime: aTimeMillis,
 				Labels:         map[string]string{"a": "b"},
 				ExternalDataConfiguration: &bq.ExternalDataConfiguration{SourceFormat: "BIGTABLE"},
+				EncryptionConfiguration:   &bq.EncryptionConfiguration{KmsKeyName: "keyName"},
 			},
 		},
 		{

vendor/cloud.google.com/go/bigquery/uploader.go

@@ -54,6 +54,9 @@ type Uploader struct {
 
 // Uploader returns an Uploader that can be used to append rows to t.
 // The returned Uploader may optionally be further configured before its Put method is called.
+//
+// To stream rows into a date-partitioned table at a particular date, add the
+// $yyyymmdd suffix to the table name when constructing the Table.
 func (t *Table) Uploader() *Uploader {
 	return &Uploader{t: t}
 }

vendor/cloud.google.com/go/bigquery/value.go

@@ -18,8 +18,10 @@ import (
 	"encoding/base64"
 	"errors"
 	"fmt"
+	"math"
 	"reflect"
 	"strconv"
+	"strings"
 	"time"
 
 	"cloud.google.com/go/civil"
@@ -63,6 +65,8 @@ func loadMap(m map[string]Value, vals []Value, s Schema) {
 		val := vals[i]
 		var v interface{}
 		switch {
+		case val == nil:
+			v = val
 		case f.Schema == nil:
 			v = val
 		case !f.Repeated:
@@ -79,6 +83,7 @@ func loadMap(m map[string]Value, vals []Value, s Schema) {
 			}
 			v = vs
 		}
+
 		m[f.Name] = v
 	}
 }
@@ -125,6 +130,18 @@ func setInt(v reflect.Value, x interface{}) error {
 	return nil
 }
 
+func setUint(v reflect.Value, x interface{}) error {
+	if x == nil {
+		return errNoNulls
+	}
+	xx := x.(int64)
+	if xx < 0 || v.OverflowUint(uint64(xx)) {
+		return fmt.Errorf("bigquery: value %v overflows struct field of type %v", xx, v.Type())
+	}
+	v.SetUint(uint64(xx))
+	return nil
+}
+
 func setFloat(v reflect.Value, x interface{}) error {
 	if x == nil {
 		return errNoNulls
@@ -155,9 +172,20 @@ func setString(v reflect.Value, x interface{}) error {
 
 func setBytes(v reflect.Value, x interface{}) error {
 	if x == nil {
-		return errNoNulls
+		v.SetBytes(nil)
+	} else {
+		v.SetBytes(x.([]byte))
+	}
+	return nil
+}
+
+func setNull(v reflect.Value, x interface{}, build func() interface{}) error {
+	if x == nil {
+		v.Set(reflect.Zero(v.Type()))
+	} else {
+		n := build()
+		v.Set(reflect.ValueOf(n))
 	}
-	v.SetBytes(x.([]byte))
 	return nil
 }
 
@@ -228,7 +256,7 @@ func compileToOps(structType reflect.Type, schema Schema) ([]structLoaderOp, err
 				return nil, err
 			}
 			op.setFunc = func(v reflect.Value, val interface{}) error {
-				return setNested(nested, v, val.([]Value))
+				return setNested(nested, v, val)
 			}
 		} else {
 			op.setFunc = determineSetFunc(t, schemaField.Type)
@@ -253,6 +281,13 @@ func determineSetFunc(ftype reflect.Type, stype FieldType) setFunc {
 		if ftype.Kind() == reflect.String {
 			return setString
 		}
+		if ftype == typeOfNullString {
+			return func(v reflect.Value, x interface{}) error {
+				return setNull(v, x, func() interface{} {
+					return NullString{StringVal: x.(string), Valid: true}
+				})
+			}
+		}
 
 	case BytesFieldType:
 		if ftype == typeOfByteSlice {
@@ -260,40 +295,91 @@ func determineSetFunc(ftype reflect.Type, stype FieldType) setFunc {
 		}
 
 	case IntegerFieldType:
-		if isSupportedIntType(ftype) {
+		if isSupportedUintType(ftype) {
+			return setUint
+		} else if isSupportedIntType(ftype) {
 			return setInt
 		}
+		if ftype == typeOfNullInt64 {
+			return func(v reflect.Value, x interface{}) error {
+				return setNull(v, x, func() interface{} {
+					return NullInt64{Int64: x.(int64), Valid: true}
+				})
+			}
+		}
 
 	case FloatFieldType:
 		switch ftype.Kind() {
 		case reflect.Float32, reflect.Float64:
 			return setFloat
 		}
+		if ftype == typeOfNullFloat64 {
+			return func(v reflect.Value, x interface{}) error {
+				return setNull(v, x, func() interface{} {
+					return NullFloat64{Float64: x.(float64), Valid: true}
+				})
+			}
+		}
 
 	case BooleanFieldType:
 		if ftype.Kind() == reflect.Bool {
 			return setBool
 		}
+		if ftype == typeOfNullBool {
+			return func(v reflect.Value, x interface{}) error {
+				return setNull(v, x, func() interface{} {
+					return NullBool{Bool: x.(bool), Valid: true}
+				})
+			}
+		}
 
 	case TimestampFieldType:
 		if ftype == typeOfGoTime {
 			return setAny
 		}
+		if ftype == typeOfNullTimestamp {
+			return func(v reflect.Value, x interface{}) error {
+				return setNull(v, x, func() interface{} {
+					return NullTimestamp{Timestamp: x.(time.Time), Valid: true}
+				})
+			}
+		}
 
 	case DateFieldType:
 		if ftype == typeOfDate {
 			return setAny
 		}
+		if ftype == typeOfNullDate {
+			return func(v reflect.Value, x interface{}) error {
+				return setNull(v, x, func() interface{} {
+					return NullDate{Date: x.(civil.Date), Valid: true}
+				})
+			}
+		}
 
 	case TimeFieldType:
 		if ftype == typeOfTime {
 			return setAny
 		}
+		if ftype == typeOfNullTime {
+			return func(v reflect.Value, x interface{}) error {
+				return setNull(v, x, func() interface{} {
+					return NullTime{Time: x.(civil.Time), Valid: true}
+				})
+			}
+		}
 
 	case DateTimeFieldType:
 		if ftype == typeOfDateTime {
 			return setAny
 		}
+		if ftype == typeOfNullDateTime {
+			return func(v reflect.Value, x interface{}) error {
+				return setNull(v, x, func() interface{} {
+					return NullDateTime{DateTime: x.(civil.DateTime), Valid: true}
+				})
+			}
+		}
 	}
 	return nil
 }
@@ -323,16 +409,21 @@ func runOps(ops []structLoaderOp, vstruct reflect.Value, values []Value) error {
 	return nil
 }
 
-func setNested(ops []structLoaderOp, v reflect.Value, vals []Value) error {
+func setNested(ops []structLoaderOp, v reflect.Value, val interface{}) error {
 	// v is either a struct or a pointer to a struct.
 	if v.Kind() == reflect.Ptr {
+		// If the value is nil, set the pointer to nil.
+		if val == nil {
+			v.Set(reflect.Zero(v.Type()))
+			return nil
+		}
 		// If the pointer is nil, set it to a zero struct value.
 		if v.IsNil() {
 			v.Set(reflect.New(v.Type().Elem()))
 		}
 		v = v.Elem()
 	}
-	return runOps(ops, v, vals)
+	return runOps(ops, v, val.([]Value))
 }
 
 func setRepeated(field reflect.Value, vslice []Value, setElem setFunc) error {
@@ -404,6 +495,10 @@ func valuesToMap(vs []Value, schema Schema) (map[string]Value, error) {
 
 	m := make(map[string]Value)
 	for i, fieldSchema := range schema {
+		if vs[i] == nil {
+			m[fieldSchema.Name] = nil
+			continue
+		}
 		if fieldSchema.Type != RecordFieldType {
 			m[fieldSchema.Name] = toUploadValue(vs[i], fieldSchema)
 			continue
@@ -550,10 +645,16 @@ func toUploadValue(val interface{}, fs *FieldSchema) interface{} {
 func toUploadValueReflect(v reflect.Value, fs *FieldSchema) interface{} {
 	switch fs.Type {
 	case TimeFieldType:
+		if v.Type() == typeOfNullTime {
+			return v.Interface()
+		}
 		return civilToUploadValue(v, fs, func(v reflect.Value) string {
 			return CivilTimeString(v.Interface().(civil.Time))
 		})
 	case DateTimeFieldType:
+		if v.Type() == typeOfNullDateTime {
+			return v.Interface()
+		}
 		return civilToUploadValue(v, fs, func(v reflect.Value) string {
 			return CivilDateTimeString(v.Interface().(civil.DateTime))
 		})
@@ -607,6 +708,16 @@ func CivilDateTimeString(dt civil.DateTime) string {
 	return dt.Date.String() + " " + CivilTimeString(dt.Time)
 }
 
+// parseCivilDateTime parses a date-time represented in a BigQuery SQL
+// compatible format and returns a civil.DateTime.
+func parseCivilDateTime(s string) (civil.DateTime, error) {
+	parts := strings.Fields(s)
+	if len(parts) != 2 {
+		return civil.DateTime{}, fmt.Errorf("bigquery: bad DATETIME value %q", s)
+	}
+	return civil.ParseDateTime(parts[0] + "T" + parts[1])
+}
+
 // convertRows converts a series of TableRows into a series of Value slices.
 // schema is used to interpret the data from rows; its length must match the
 // length of each row.
@@ -705,7 +816,12 @@ func convertBasicType(val string, typ FieldType) (Value, error) {
 		return strconv.ParseBool(val)
 	case TimestampFieldType:
 		f, err := strconv.ParseFloat(val, 64)
-		return Value(time.Unix(0, int64(f*1e9)).UTC()), err
+		if err != nil {
+			return nil, err
+		}
+		secs := math.Trunc(f)
+		nanos := (f - secs) * 1e9
+		return Value(time.Unix(int64(secs), int64(nanos)).UTC()), nil
 	case DateFieldType:
 		return civil.ParseDate(val)
 	case TimeFieldType:

vendor/cloud.google.com/go/bigquery/value_test.go

@@ -24,7 +24,6 @@ import (
 	"github.com/google/go-cmp/cmp"
 
 	"cloud.google.com/go/civil"
-	"cloud.google.com/go/internal/pretty"
 	"cloud.google.com/go/internal/testutil"
 
 	bq "google.golang.org/api/bigquery/v2"
@@ -89,6 +88,20 @@ func TestConvertTime(t *testing.T) {
 	}
 }
 
+func TestConvertSmallTimes(t *testing.T) {
+	for _, year := range []int{1600, 1066, 1} {
+		want := time.Date(year, time.January, 1, 0, 0, 0, 0, time.UTC)
+		s := fmt.Sprintf("%.10f", float64(want.Unix()))
+		got, err := convertBasicType(s, TimestampFieldType)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !got.(time.Time).Equal(want) {
+			t.Errorf("got %v, want %v", got, want)
+		}
+	}
+}
+
 func TestConvertNullValues(t *testing.T) {
 	schema := []*FieldSchema{
 		{Type: StringFieldType},
@@ -393,7 +406,10 @@ func TestValuesSaverConvertsToMap(t *testing.T) {
 				},
 				InsertID: "iid",
 				Row: []Value{1, "a",
-					civil.DateTime{civil.Date{1, 2, 3}, civil.Time{4, 5, 6, 7000}}},
+					civil.DateTime{
+						Date: civil.Date{Year: 1, Month: 2, Day: 3},
+						Time: civil.Time{Hour: 4, Minute: 5, Second: 6, Nanosecond: 7000}},
+				},
 			},
 			wantInsertID: "iid",
 			wantRow: map[string]Value{"intField": 1, "strField": "a",
@@ -512,6 +528,7 @@ func TestStructSaver(t *testing.T) {
 		{Name: "rnested", Type: RecordFieldType, Repeated: true, Schema: Schema{
 			{Name: "b", Type: BooleanFieldType},
 		}},
+		{Name: "p", Type: IntegerFieldType, Required: false},
 	}
 
 	type (
@@ -523,6 +540,7 @@ func TestStructSaver(t *testing.T) {
 			TR      []civil.Time
 			Nested  *N
 			Rnested []*N
+			P       NullInt64
 		}
 	)
 
@@ -539,12 +557,13 @@ func TestStructSaver(t *testing.T) {
 		if wantIID := "iid"; gotIID != wantIID {
 			t.Errorf("%s: InsertID: got %q, want %q", msg, gotIID, wantIID)
 		}
-		if !testutil.Equal(got, want) {
-			t.Errorf("%s:\ngot\n%#v\nwant\n%#v", msg, got, want)
+		if diff := testutil.Diff(got, want); diff != "" {
+			t.Errorf("%s: %s", msg, diff)
 		}
 	}
-	ct1 := civil.Time{1, 2, 3, 4000}
-	ct2 := civil.Time{5, 6, 7, 8000}
+
+	ct1 := civil.Time{Hour: 1, Minute: 2, Second: 3, Nanosecond: 4000}
+	ct2 := civil.Time{Hour: 5, Minute: 6, Second: 7, Nanosecond: 8000}
 	in := T{
 		S:       "x",
 		R:       []int{1, 2},
@@ -552,6 +571,7 @@ func TestStructSaver(t *testing.T) {
 		TR:      []civil.Time{ct1, ct2},
 		Nested:  &N{B: true},
 		Rnested: []*N{{true}, {false}},
+		P:       NullInt64{Valid: true, Int64: 17},
 	}
 	want := map[string]Value{
 		"s":       "x",
@@ -560,10 +580,11 @@ func TestStructSaver(t *testing.T) {
 		"tr":      []string{"01:02:03.000004", "05:06:07.000008"},
 		"nested":  map[string]Value{"b": true},
 		"rnested": []Value{map[string]Value{"b": true}, map[string]Value{"b": false}},
+		"p":       NullInt64{Valid: true, Int64: 17},
 	}
 	check("all values", in, want)
 	check("all values, ptr", &in, want)
-	check("empty struct", T{}, map[string]Value{"s": "", "t": "00:00:00"})
+	check("empty struct", T{}, map[string]Value{"s": "", "t": "00:00:00", "p": NullInt64{}})
 
 	// Missing and extra fields ignored.
 	type T2 struct {
@@ -577,6 +598,7 @@ func TestStructSaver(t *testing.T) {
 		map[string]Value{
 			"s":       "",
 			"t":       "00:00:00",
+			"p":       NullInt64{},
 			"rnested": []Value{map[string]Value{"b": true}, map[string]Value(nil), map[string]Value{"b": false}},
 		})
 }
@@ -713,6 +735,22 @@ func TestValueMap(t *testing.T) {
 		t.Errorf("got\n%+v\nwant\n%+v", vm, want)
 	}
 
+	in = make([]Value, len(schema))
+	want = map[string]Value{
+		"s":  nil,
+		"i":  nil,
+		"f":  nil,
+		"b":  nil,
+		"n":  nil,
+		"rn": nil,
+	}
+	var vm2 valueMap
+	if err := vm2.Load(in, schema); err != nil {
+		t.Fatal(err)
+	}
+	if !testutil.Equal(vm2, valueMap(want)) {
+		t.Errorf("got\n%+v\nwant\n%+v", vm2, want)
+	}
 }
 
 var (
@@ -722,6 +760,7 @@ var (
 		{Name: "s2", Type: StringFieldType},
 		{Name: "by", Type: BytesFieldType},
 		{Name: "I", Type: IntegerFieldType},
+		{Name: "U", Type: IntegerFieldType},
 		{Name: "F", Type: FloatFieldType},
 		{Name: "B", Type: BooleanFieldType},
 		{Name: "TS", Type: TimestampFieldType},
@@ -736,11 +775,11 @@ var (
 	}
 
 	testTimestamp = time.Date(2016, 11, 5, 7, 50, 22, 8, time.UTC)
-	testDate      = civil.Date{2016, 11, 5}
-	testTime      = civil.Time{7, 50, 22, 8}
-	testDateTime  = civil.DateTime{testDate, testTime}
+	testDate      = civil.Date{Year: 2016, Month: 11, Day: 5}
+	testTime      = civil.Time{Hour: 7, Minute: 50, Second: 22, Nanosecond: 8}
+	testDateTime  = civil.DateTime{Date: testDate, Time: testTime}
 
-	testValues = []Value{"x", "y", []byte{1, 2, 3}, int64(7), 3.14, true,
+	testValues = []Value{"x", "y", []byte{1, 2, 3}, int64(7), int64(8), 3.14, true,
 		testTimestamp, testDate, testTime, testDateTime,
 		[]Value{"nested", int64(17)}, "z"}
 )
@@ -748,6 +787,7 @@ var (
 type testStruct1 struct {
 	B bool
 	I int
+	U uint16
 	times
 	S      string
 	S2     String
@@ -774,14 +814,13 @@ type times struct {
 
 func TestStructLoader(t *testing.T) {
 	var ts1 testStruct1
-	if err := load(&ts1, schema2, testValues); err != nil {
-		t.Fatal(err)
-	}
+	mustLoad(t, &ts1, schema2, testValues)
 	// Note: the schema field named "s" gets matched to the exported struct
 	// field "S", not the unexported "s".
 	want := &testStruct1{
 		B:      true,
 		I:      7,
+		U:      8,
 		F:      3.14,
 		times:  times{TS: testTimestamp, T: testTime, D: testDate, DT: testDateTime},
 		S:      "x",
@@ -790,33 +829,25 @@ func TestStructLoader(t *testing.T) {
 		Nested: nested{NestS: "nested", NestI: 17},
 		Tagged: "z",
 	}
-	if !testutil.Equal(&ts1, want, cmp.AllowUnexported(testStruct1{})) {
-		t.Errorf("got %+v, want %+v", pretty.Value(ts1), pretty.Value(*want))
-		d, _, err := pretty.Diff(*want, ts1)
-		if err == nil {
-			t.Logf("diff:\n%s", d)
-		}
+	if diff := testutil.Diff(&ts1, want, cmp.AllowUnexported(testStruct1{})); diff != "" {
+		t.Error(diff)
 	}
 
 	// Test pointers to nested structs.
 	type nestedPtr struct{ Nested *nested }
 	var np nestedPtr
-	if err := load(&np, schema2, testValues); err != nil {
-		t.Fatal(err)
-	}
+	mustLoad(t, &np, schema2, testValues)
 	want2 := &nestedPtr{Nested: &nested{NestS: "nested", NestI: 17}}
-	if !testutil.Equal(&np, want2) {
-		t.Errorf("got %+v, want %+v", pretty.Value(np), pretty.Value(*want2))
+	if diff := testutil.Diff(&np, want2); diff != "" {
+		t.Error(diff)
 	}
 
 	// Existing values should be reused.
 	nst := &nested{NestS: "x", NestI: -10}
 	np = nestedPtr{Nested: nst}
-	if err := load(&np, schema2, testValues); err != nil {
-		t.Fatal(err)
-	}
-	if !testutil.Equal(&np, want2) {
-		t.Errorf("got %+v, want %+v", pretty.Value(np), pretty.Value(*want2))
+	mustLoad(t, &np, schema2, testValues)
+	if diff := testutil.Diff(&np, want2); diff != "" {
+		t.Error(diff)
 	}
 	if np.Nested != nst {
 		t.Error("nested struct pointers not equal")
@@ -851,28 +882,23 @@ var (
 
 func TestStructLoaderRepeated(t *testing.T) {
 	var r1 repStruct
-	if err := load(&r1, repSchema, repValues); err != nil {
-		t.Fatal(err)
-	}
+	mustLoad(t, &r1, repSchema, repValues)
 	want := repStruct{
 		Nums:      []int{1, 2, 3},
 		ShortNums: [...]int{1, 2}, // extra values discarded
 		LongNums:  [...]int{1, 2, 3, 0, 0},
 		Nested:    []*nested{{"x", 1}, {"y", 2}},
 	}
-	if !testutil.Equal(r1, want) {
-		t.Errorf("got %+v, want %+v", pretty.Value(r1), pretty.Value(want))
+	if diff := testutil.Diff(r1, want); diff != "" {
+		t.Error(diff)
 	}
-
 	r2 := repStruct{
 		Nums:     []int{-1, -2, -3, -4, -5},    // truncated to zero and appended to
 		LongNums: [...]int{-1, -2, -3, -4, -5}, // unset elements are zeroed
 	}
-	if err := load(&r2, repSchema, repValues); err != nil {
-		t.Fatal(err)
-	}
-	if !testutil.Equal(r2, want) {
-		t.Errorf("got %+v, want %+v", pretty.Value(r2), pretty.Value(want))
+	mustLoad(t, &r2, repSchema, repValues)
+	if diff := testutil.Diff(r2, want); diff != "" {
+		t.Error(diff)
 	}
 	if got, want := cap(r2.Nums), 5; got != want {
 		t.Errorf("cap(r2.Nums) = %d, want %d", got, want)
@@ -880,33 +906,109 @@ func TestStructLoaderRepeated(t *testing.T) {
 
 	// Short slice case.
 	r3 := repStruct{Nums: []int{-1}}
-	if err := load(&r3, repSchema, repValues); err != nil {
-		t.Fatal(err)
-	}
-	if !testutil.Equal(r3, want) {
-		t.Errorf("got %+v, want %+v", pretty.Value(r3), pretty.Value(want))
+	mustLoad(t, &r3, repSchema, repValues)
+	if diff := testutil.Diff(r3, want); diff != "" {
+		t.Error(diff)
 	}
 	if got, want := cap(r3.Nums), 3; got != want {
 		t.Errorf("cap(r3.Nums) = %d, want %d", got, want)
 	}
+}
 
+type testStructNullable struct {
+	String    NullString
+	Bytes     []byte
+	Integer   NullInt64
+	Float     NullFloat64
+	Boolean   NullBool
+	Timestamp NullTimestamp
+	Date      NullDate
+	Time      NullTime
+	DateTime  NullDateTime
+	Record    *subNullable
+}
+
+type subNullable struct {
+	X NullInt64
+}
+
+var testStructNullableSchema = Schema{
+	{Name: "String", Type: StringFieldType, Required: false},
+	{Name: "Bytes", Type: BytesFieldType, Required: false},
+	{Name: "Integer", Type: IntegerFieldType, Required: false},
+	{Name: "Float", Type: FloatFieldType, Required: false},
+	{Name: "Boolean", Type: BooleanFieldType, Required: false},
+	{Name: "Timestamp", Type: TimestampFieldType, Required: false},
+	{Name: "Date", Type: DateFieldType, Required: false},
+	{Name: "Time", Type: TimeFieldType, Required: false},
+	{Name: "DateTime", Type: DateTimeFieldType, Required: false},
+	{Name: "Record", Type: RecordFieldType, Required: false, Schema: Schema{
+		{Name: "X", Type: IntegerFieldType, Required: false},
+	}},
+}
+
+func TestStructLoaderNullable(t *testing.T) {
+	var ts testStructNullable
+	nilVals := []Value{nil, nil, nil, nil, nil, nil, nil, nil, nil, nil}
+	mustLoad(t, &ts, testStructNullableSchema, nilVals)
+	want := testStructNullable{}
+	if diff := testutil.Diff(ts, want); diff != "" {
+		t.Error(diff)
+	}
+
+	nonnilVals := []Value{"x", []byte{1, 2, 3}, int64(1), 2.3, true, testTimestamp, testDate, testTime, testDateTime, []Value{int64(4)}}
+
+	// All ts fields are nil. Loading non-nil values will cause them all to
+	// be allocated.
+	mustLoad(t, &ts, testStructNullableSchema, nonnilVals)
+	want = testStructNullable{
+		String:    NullString{StringVal: "x", Valid: true},
+		Bytes:     []byte{1, 2, 3},
+		Integer:   NullInt64{Int64: 1, Valid: true},
+		Float:     NullFloat64{Float64: 2.3, Valid: true},
+		Boolean:   NullBool{Bool: true, Valid: true},
+		Timestamp: NullTimestamp{Timestamp: testTimestamp, Valid: true},
+		Date:      NullDate{Date: testDate, Valid: true},
+		Time:      NullTime{Time: testTime, Valid: true},
+		DateTime:  NullDateTime{DateTime: testDateTime, Valid: true},
+		Record:    &subNullable{X: NullInt64{Int64: 4, Valid: true}},
+	}
+	if diff := testutil.Diff(ts, want); diff != "" {
+		t.Error(diff)
+	}
+
+	// Struct pointers are reused, byte slices are not.
+	want = ts
+	want.Bytes = []byte{17}
+	vals2 := []Value{nil, []byte{17}, nil, nil, nil, nil, nil, nil, nil, []Value{int64(7)}}
+	mustLoad(t, &ts, testStructNullableSchema, vals2)
+	if ts.Record != want.Record {
+		t.Error("record pointers not identical")
+	}
 }
 
 func TestStructLoaderOverflow(t *testing.T) {
 	type S struct {
 		I int16
+		U uint16
 		F float32
 	}
 	schema := Schema{
 		{Name: "I", Type: IntegerFieldType},
+		{Name: "U", Type: IntegerFieldType},
 		{Name: "F", Type: FloatFieldType},
 	}
 	var s S
-	if err := load(&s, schema, []Value{int64(math.MaxInt16 + 1), 0}); err == nil {
-		t.Error("int: got nil, want error")
-	}
-	if err := load(&s, schema, []Value{int64(0), math.MaxFloat32 * 2}); err == nil {
-		t.Error("float: got nil, want error")
+	z64 := int64(0)
+	for _, vals := range [][]Value{
+		{int64(math.MaxInt16 + 1), z64, 0},
+		{z64, int64(math.MaxInt32), 0},
+		{z64, int64(-1), 0},
+		{z64, z64, math.MaxFloat32 * 2},
+	} {
+		if err := load(&s, schema, vals); err == nil {
+			t.Errorf("%+v: got nil, want error", vals)
+		}
 	}
 }
 
@@ -922,20 +1024,18 @@ func TestStructLoaderFieldOverlap(t *testing.T) {
 		t.Fatal(err)
 	}
 	want1 := S1{I: 7}
-	if !testutil.Equal(s1, want1) {
-		t.Errorf("got %+v, want %+v", pretty.Value(s1), pretty.Value(want1))
+	if diff := testutil.Diff(s1, want1); diff != "" {
+		t.Error(diff)
 	}
 
 	// It's even valid to have no overlapping fields at all.
 	type S2 struct{ Z int }
 
 	var s2 S2
-	if err := load(&s2, schema2, testValues); err != nil {
-		t.Fatal(err)
-	}
+	mustLoad(t, &s2, schema2, testValues)
 	want2 := S2{}
-	if !testutil.Equal(s2, want2) {
-		t.Errorf("got %+v, want %+v", pretty.Value(s2), pretty.Value(want2))
+	if diff := testutil.Diff(s2, want2); diff != "" {
+		t.Error(diff)
 	}
 }
 
@@ -989,21 +1089,17 @@ func TestStructLoaderErrors(t *testing.T) {
 		{Name: "f", Type: FloatFieldType},
 		{Name: "b", Type: BooleanFieldType},
 		{Name: "s", Type: StringFieldType},
-		{Name: "by", Type: BytesFieldType},
 		{Name: "d", Type: DateFieldType},
 	}
 	type s struct {
-		I  int
-		F  float64
-		B  bool
-		S  string
-		By []byte
-		D  civil.Date
-	}
-	vals := []Value{int64(0), 0.0, false, "", []byte{}, testDate}
-	if err := load(&s{}, schema, vals); err != nil {
-		t.Fatal(err)
+		I int
+		F float64
+		B bool
+		S string
+		D civil.Date
 	}
+	vals := []Value{int64(0), 0.0, false, "", testDate}
+	mustLoad(t, &s{}, schema, vals)
 	for i, e := range vals {
 		vals[i] = nil
 		got := load(&s{}, schema, vals)
@@ -1033,6 +1129,12 @@ func TestStructLoaderErrors(t *testing.T) {
 	}
 }
 
+func mustLoad(t *testing.T, pval interface{}, schema Schema, vals []Value) {
+	if err := load(pval, schema, vals); err != nil {
+		t.Fatalf("loading: %v", err)
+	}
+}
+
 func load(pval interface{}, schema Schema, vals []Value) error {
 	var sl structLoader
 	if err := sl.set(pval, schema); err != nil {