diff --git a/bigquery/params.go b/bigquery/params.go
index 046b874..97ebcc3 100644
--- a/bigquery/params.go
+++ b/bigquery/params.go
@@ -16,16 +16,21 @@
 
 import (
 	"encoding/base64"
+	"errors"
 	"fmt"
 	"reflect"
 	"time"
 
+	"cloud.google.com/go/internal/fields"
+
 	bq "google.golang.org/api/bigquery/v2"
 )
 
 // See https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#timestamp-type.
 var timestampFormat = "2006-01-02 15:04:05.999999-07:00"
 
+var fieldCache = fields.NewCache(nil)
+
 var (
 	int64ParamType     = &bq.QueryParameterType{Type: "INT64"}
 	float64ParamType   = &bq.QueryParameterType{Type: "FLOAT64"}
@@ -38,55 +43,118 @@
 var timeType = reflect.TypeOf(time.Time{})
 
 func paramType(t reflect.Type) (*bq.QueryParameterType, error) {
+	if t == nil {
+		return nil, errors.New("bigquery: nil parameter")
+	}
+	if t == timeType {
+		return timestampParamType, nil
+	}
 	switch t.Kind() {
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint8, reflect.Uint16, reflect.Uint32:
 		return int64ParamType, nil
+
 	case reflect.Float32, reflect.Float64:
 		return float64ParamType, nil
+
 	case reflect.Bool:
 		return boolParamType, nil
+
 	case reflect.String:
 		return stringParamType, nil
-	case reflect.Slice, reflect.Array:
-		if t.Kind() == reflect.Slice && t.Elem().Kind() == reflect.Uint8 {
+
+	case reflect.Slice:
+		if t.Elem().Kind() == reflect.Uint8 {
 			return bytesParamType, nil
 		}
+		fallthrough
+
+	case reflect.Array:
 		et, err := paramType(t.Elem())
 		if err != nil {
 			return nil, err
 		}
 		return &bq.QueryParameterType{Type: "ARRAY", ArrayType: et}, nil
+
+	case reflect.Ptr:
+		if t.Elem().Kind() != reflect.Struct {
+			break
+		}
+		t = t.Elem()
+		fallthrough
+
+	case reflect.Struct:
+		var fts []*bq.QueryParameterTypeStructTypes
+		for _, f := range fieldCache.Fields(t) {
+			pt, err := paramType(f.Type)
+			if err != nil {
+				return nil, err
+			}
+			fts = append(fts, &bq.QueryParameterTypeStructTypes{
+				Name: f.Name,
+				Type: pt,
+			})
+		}
+		return &bq.QueryParameterType{Type: "STRUCT", StructTypes: fts}, nil
 	}
-	if t == timeType {
-		return timestampParamType, nil
-	}
-	return nil, fmt.Errorf("Go type %s cannot be represented as a parameter type", t)
+	return nil, fmt.Errorf("bigquery: Go type %s cannot be represented as a parameter type", t)
 }
 
-func paramValue(x interface{}) (bq.QueryParameterValue, error) {
-	// convenience function for scalar value
-	sval := func(s string) bq.QueryParameterValue {
-		return bq.QueryParameterValue{Value: s}
+func paramValue(v reflect.Value) (bq.QueryParameterValue, error) {
+	var res bq.QueryParameterValue
+	if !v.IsValid() {
+		return res, errors.New("bigquery: nil parameter")
 	}
-	switch x := x.(type) {
-	case []byte:
-		return sval(base64.StdEncoding.EncodeToString(x)), nil
-	case time.Time:
-		return sval(x.Format(timestampFormat)), nil
+	t := v.Type()
+	if t == timeType {
+		res.Value = v.Interface().(time.Time).Format(timestampFormat)
+		return res, nil
 	}
-	t := reflect.TypeOf(x)
 	switch t.Kind() {
-	case reflect.Slice, reflect.Array:
+	case reflect.Slice:
+		if t.Elem().Kind() == reflect.Uint8 {
+			res.Value = base64.StdEncoding.EncodeToString(v.Interface().([]byte))
+			return res, nil
+		}
+		fallthrough
+
+	case reflect.Array:
 		var vals []*bq.QueryParameterValue
-		v := reflect.ValueOf(x)
 		for i := 0; i < v.Len(); i++ {
-			val, err := paramValue(v.Index(i).Interface())
+			val, err := paramValue(v.Index(i))
 			if err != nil {
 				return bq.QueryParameterValue{}, err
 			}
 			vals = append(vals, &val)
 		}
 		return bq.QueryParameterValue{ArrayValues: vals}, nil
+
+	case reflect.Ptr:
+		if t.Elem().Kind() != reflect.Struct {
+			return res, fmt.Errorf("bigquery: Go type %s cannot be represented as a parameter value", t)
+		}
+		t = t.Elem()
+		v = v.Elem()
+		if !v.IsValid() {
+			// nil pointer becomes empty value
+			return res, nil
+		}
+		fallthrough
+
+	case reflect.Struct:
+		fields := fieldCache.Fields(t)
+		res.StructValues = map[string]bq.QueryParameterValue{}
+		for _, f := range fields {
+			fv := v.FieldByIndex(f.Index)
+			fp, err := paramValue(fv)
+			if err != nil {
+				return bq.QueryParameterValue{}, err
+			}
+			res.StructValues[f.Name] = fp
+		}
+		return res, nil
 	}
-	return sval(fmt.Sprint(x)), nil
+	// None of the above: assume a scalar type. (If it's not a valid type,
+	// paramType will catch the error.)
+	res.Value = fmt.Sprint(v.Interface())
+	return res, nil
 }
diff --git a/bigquery/params_test.go b/bigquery/params_test.go
index 97c75cc..5a68204 100644
--- a/bigquery/params_test.go
+++ b/bigquery/params_test.go
@@ -41,45 +41,94 @@
 		"2016-03-20 04:22:09.000005-01:02"},
 }
 
+type S1 struct {
+	A int
+	B *S2
+	C bool
+}
+
+type S2 struct {
+	D string
+	e int
+}
+
+var s1 = S1{
+	A: 1,
+	B: &S2{D: "s"},
+	C: true,
+}
+
+func sval(s string) bq.QueryParameterValue {
+	return bq.QueryParameterValue{Value: s}
+}
+
 func TestParamValueScalar(t *testing.T) {
 	for _, test := range scalarTests {
-		got, err := paramValue(test.val)
+		got, err := paramValue(reflect.ValueOf(test.val))
 		if err != nil {
 			t.Errorf("%v: got %v, want nil", test.val, err)
 			continue
 		}
-		if got.ArrayValues != nil {
-			t.Errorf("%v, ArrayValues: got %v, expected nil", test.val, got.ArrayValues)
-		}
-		if got.StructValues != nil {
-			t.Errorf("%v, StructValues: got %v, expected nil", test.val, got.StructValues)
-		}
-		if got.Value != test.want {
-			t.Errorf("%v: got %q, want %q", test.val, got.Value, test.want)
+		want := sval(test.want)
+		if !reflect.DeepEqual(got, want) {
+			t.Errorf("%v:\ngot  %+v\nwant %+v", test.val, got, want)
 		}
 	}
 }
 
 func TestParamValueArray(t *testing.T) {
+	qpv := bq.QueryParameterValue{ArrayValues: []*bq.QueryParameterValue{
+		{Value: "1"},
+		{Value: "2"},
+	},
+	}
 	for _, test := range []struct {
 		val  interface{}
-		want []string
+		want bq.QueryParameterValue
 	}{
-		{[]int(nil), []string{}},
-		{[]int{}, []string{}},
-		{[]int{1, 2}, []string{"1", "2"}},
-		{[3]int{1, 2, 3}, []string{"1", "2", "3"}},
+		{[]int(nil), bq.QueryParameterValue{}},
+		{[]int{}, bq.QueryParameterValue{}},
+		{[]int{1, 2}, qpv},
+		{[2]int{1, 2}, qpv},
 	} {
-		got, err := paramValue(test.val)
+		got, err := paramValue(reflect.ValueOf(test.val))
 		if err != nil {
 			t.Fatal(err)
 		}
-		var want bq.QueryParameterValue
-		for _, s := range test.want {
-			want.ArrayValues = append(want.ArrayValues, &bq.QueryParameterValue{Value: s})
+		if !reflect.DeepEqual(got, test.want) {
+			t.Errorf("%#v:\ngot  %+v\nwant %+v", test.val, got, test.want)
 		}
-		if !reflect.DeepEqual(got, want) {
-			t.Errorf("%#v:\ngot  %+v\nwant %+v", test.val, got, want)
+	}
+}
+
+func TestParamValueStruct(t *testing.T) {
+	got, err := paramValue(reflect.ValueOf(s1))
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := bq.QueryParameterValue{
+		StructValues: map[string]bq.QueryParameterValue{
+			"A": sval("1"),
+			"B": bq.QueryParameterValue{
+				StructValues: map[string]bq.QueryParameterValue{
+					"D": sval("s"),
+				},
+			},
+			"C": sval("true"),
+		},
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("got  %+v\nwant %+v", got, want)
+	}
+}
+
+func TestParamValueErrors(t *testing.T) {
+	// paramValue lets a few invalid types through, but paramType catches them.
+	// Since we never call one without the other that's fine.
+	for _, val := range []interface{}{nil, new([]int)} {
+		_, err := paramValue(reflect.ValueOf(val))
+		if err == nil {
+			t.Errorf("%v (%T): got nil, want error", val, val)
 		}
 	}
 }
@@ -101,6 +150,19 @@
 		{[]byte("foo"), bytesParamType},
 		{[]int{}, &bq.QueryParameterType{Type: "ARRAY", ArrayType: int64ParamType}},
 		{[3]bool{}, &bq.QueryParameterType{Type: "ARRAY", ArrayType: boolParamType}},
+		{S1{}, &bq.QueryParameterType{
+			Type: "STRUCT",
+			StructTypes: []*bq.QueryParameterTypeStructTypes{
+				{Name: "A", Type: int64ParamType},
+				{Name: "B", Type: &bq.QueryParameterType{
+					Type: "STRUCT",
+					StructTypes: []*bq.QueryParameterTypeStructTypes{
+						{Name: "D", Type: stringParamType},
+					},
+				}},
+				{Name: "C", Type: boolParamType},
+			},
+		}},
 	} {
 		got, err := paramType(reflect.TypeOf(test.val))
 		if err != nil {
@@ -112,6 +174,17 @@
 	}
 }
 
+func TestParamTypeErrors(t *testing.T) {
+	for _, val := range []interface{}{
+		nil, uint(0), new([]int), make(chan int),
+	} {
+		_, err := paramType(reflect.TypeOf(val))
+		if err == nil {
+			t.Errorf("%v (%T): got nil, want error", val, val)
+		}
+	}
+}
+
 func TestIntegration_ScalarParam(t *testing.T) {
 	c := getClient(t)
 	for _, test := range scalarTests {
@@ -125,7 +198,7 @@
 	}
 }
 
-func TestIntegration_ArrayParam(t *testing.T) {
+func TestIntegration_OtherParam(t *testing.T) {
 	c := getClient(t)
 	for _, test := range []struct {
 		val  interface{}
@@ -135,6 +208,8 @@
 		{[]int{}, []Value(nil)},
 		{[]int{1, 2}, []Value{int64(1), int64(2)}},
 		{[3]int{1, 2, 3}, []Value{int64(1), int64(2), int64(3)}},
+		{S1{}, []Value{int64(0), nil, false}},
+		{s1, []Value{int64(1), []Value{"s"}, true}},
 	} {
 		got, err := paramRoundTrip(c, test.val)
 		if err != nil {
diff --git a/bigquery/query.go b/bigquery/query.go
index af40d23..ce6eb86 100644
--- a/bigquery/query.go
+++ b/bigquery/query.go
@@ -123,6 +123,8 @@
 	// string: STRING
 	// []byte: BYTES
 	// time.Time: TIMESTAMP
+	// Arrays and slices of the above.
+	// Structs of the above. Only the exported fields are used.
 	Value interface{}
 }
 
@@ -207,7 +209,7 @@
 		conf.DestinationTable = q.Dst.tableRefProto()
 	}
 	for _, p := range q.Parameters {
-		pv, err := paramValue(p.Value)
+		pv, err := paramValue(reflect.ValueOf(p.Value))
 		if err != nil {
 			return err
 		}