rpc

type CommitTimeResp ¶

type CommitTimeResp struct {
	CommitTs time.Time
}

func (r CommitTimeResp) CommitTimestamp() time.Time

type Error ¶

type Error struct {
	// Code is the canonical error code for describing the nature of a
	// particular error.
	Code codes.Code
	// Desc explains more details of the error.
	Desc string
}

Error is the structured error returned by Cloud Spanner client.

func (e *Error) Error() string

func (e *Error) GRPCStatus() *status.Status

type GenericColumnValue ¶

type GenericColumnValue struct {
	Type  *tspb.Type
	Value *tspb.Value
}

GenericColumnValue represents the generic encoded value and type of the column. See google.spanner.v1.ResultSet proto for details. This can be useful for proxying query results when the result types are not known in advance.

If you populate a GenericColumnValue from a row using Row.Column or related methods, do not modify the contents of Type and Value.

func (v GenericColumnValue) Decode(ptr interface{}) error

type Key ¶

type Key []interface{}

A Key can be either a Cloud Spanner row's primary key or a secondary index key. It is essentially an interface{} array, which represents a set of Cloud Spanner columns. A Key can be used as:

• A primary key which uniquely identifies a Cloud Spanner row.
• A secondary index key which maps to a set of Cloud Spanner rows indexed under it.
• An endpoint of primary key/secondary index ranges; see the KeyRange type.

Rows that are identified by the Key type are outputs of read operation or targets of delete operation in a mutation. Note that for Insert/Update/InsertOrUpdate/Update mutation types, although they don't require a primary key explicitly, the column list provided must contain enough columns that can comprise a primary key.

Keys are easy to construct. For example, suppose you have a table with a primary key of username and product ID. To make a key for this table:

key := spanner.Key{"john", 16}

See the description of Row and Mutation types for how Go types are mapped to Cloud Spanner types. For convenience, Key type supports a wide range of Go types:

• int, int8, int16, int32, int64, and NullInt64 are mapped to Cloud Spanner's INT64 type.
• uint8, uint16 and uint32 are also mapped to Cloud Spanner's INT64 type.
• float32, float64, NullFloat64 are mapped to Cloud Spanner's FLOAT64 type.
• bool and NullBool are mapped to Cloud Spanner's BOOL type.
• []byte is mapped to Cloud Spanner's BYTES type.
• string and NullString are mapped to Cloud Spanner's STRING type.
• time.Time and NullTime are mapped to Cloud Spanner's TIMESTAMP type.
• civil.Date and NullDate are mapped to Cloud Spanner's DATE type.

func (key Key) AsPrefix() KeyRange

func (key Key) KeySetProto() (*tspb.KeySet, error)

func (key Key) Proto() (*tspb.ListValue, error)

func (key Key) String() string

type KeyRange ¶

type KeyRange struct {
	// Start specifies the left boundary of the key range; End specifies
	// the right boundary of the key range.
	Start, End Key

	// Kind describes whether the boundaries of the key range include
	// their keys.
	Kind KeyRangeKind
}

A KeyRange represents a range of rows in a table or index.

A range has a Start key and an End key. IncludeStart and IncludeEnd indicate whether the Start and End keys are included in the range.

For example, consider the following table definition:

CREATE TABLE UserEvents (
  UserName STRING(MAX),
  EventDate STRING(10),
) PRIMARY KEY(UserName, EventDate);

The following keys name rows in this table:

spanner.Key{"Bob", "2014-09-23"}
spanner.Key{"Alfred", "2015-06-12"}

Since the UserEvents table's PRIMARY KEY clause names two columns, each UserEvents key has two elements; the first is the UserName, and the second is the EventDate.

Key ranges with multiple components are interpreted lexicographically by component using the table or index key's declared sort order. For example, the following range returns all events for user "Bob" that occurred in the year 2015:

spanner.KeyRange{
	Start: spanner.Key{"Bob", "2015-01-01"},
	End:   spanner.Key{"Bob", "2015-12-31"},
	Kind:  ClosedClosed,
}

Start and end keys can omit trailing key components. This affects the inclusion and exclusion of rows that exactly match the provided key components: if IncludeStart is true, then rows that exactly match the provided components of the Start key are included; if IncludeStart is false then rows that exactly match are not included. IncludeEnd and End key behave in the same fashion.

For example, the following range includes all events for "Bob" that occurred during and after the year 2000:

spanner.KeyRange{
	Start: spanner.Key{"Bob", "2000-01-01"},
	End:   spanner.Key{"Bob"},
	Kind:  ClosedClosed,
}

The next example retrieves all events for "Bob":

spanner.Key{"Bob"}.AsPrefix()

To retrieve events before the year 2000:

spanner.KeyRange{
	Start: spanner.Key{"Bob"},
	End:   spanner.Key{"Bob", "2000-01-01"},
	Kind:  ClosedOpen,
}

Although we specified a Kind for this KeyRange, we didn't need to, because the default is ClosedOpen. In later examples we'll omit Kind if it is ClosedOpen.

The following range includes all rows in a table or under a index:

spanner.AllKeys()

This range returns all users whose UserName begins with any character from A to C:

spanner.KeyRange{
	Start: spanner.Key{"A"},
	End:   spanner.Key{"D"},
}

This range returns all users whose UserName begins with B:

spanner.KeyRange{
	Start: spanner.Key{"B"},
	End:   spanner.Key{"C"},
}

Key ranges honor column sort order. For example, suppose a table is defined as follows:

CREATE TABLE DescendingSortedTable {
  Key INT64,
  ...
) PRIMARY KEY(Key DESC);

The following range retrieves all rows with key values between 1 and 100 inclusive:

spanner.KeyRange{
	Start: spanner.Key{100},
	End:   spanner.Key{1},
	Kind:  ClosedClosed,
}

Note that 100 is passed as the start, and 1 is passed as the end, because Key is a descending column in the schema.

func (r KeyRange) KeySetProto() (*tspb.KeySet, error)

func (r KeyRange) Proto() (*tspb.KeyRange, error)

func (r KeyRange) String() string

type KeyRangeKind ¶

type KeyRangeKind int

KeyRangeKind describes the kind of interval represented by a KeyRange: whether it is open or closed on the left and right.

const (
	// ClosedOpen is closed on the left and open on the right: the Start
	// key is included, the End key is excluded.
	ClosedOpen KeyRangeKind = iota

	// ClosedClosed is closed on the left and the right: both keys are included.
	ClosedClosed

	// OpenClosed is open on the left and closed on the right: the Start
	// key is excluded, the End key is included.
	OpenClosed

	// OpenOpen is open on the left and the right: neither key is included.
	OpenOpen
)

type KeySet ¶

type KeySet interface {
	KeySetProto() (*tspb.KeySet, error)
}

A KeySet defines a collection of Cloud Spanner keys and/or key ranges. All the keys are expected to be in the same table or index. The keys need not be sorted in any particular way.

An individual Key can act as a KeySet, as can a KeyRange. Use the KeySets function to create a KeySet consisting of multiple Keys and KeyRanges. To obtain an empty KeySet, call KeySets with no arguments.

If the same key is specified multiple times in the set (for example if two ranges, two keys, or a key and a range overlap), the Cloud Spanner backend behaves as if the key were only specified once.

func AllKeys() KeySet

func KeySets(keySets ...KeySet) KeySet

type Mutation ¶

type Mutation struct {
	// op is the operation type of the mutation.
	// See documentation for spanner.op for more details.
	Op OP
	// Table is the name of the target table to be modified.
	Table string
	// keySet is a set of primary keys that names the rows
	// in a delete operation.
	KeySet *tspb.KeySet
	// columns names the set of columns that are going to be
	// modified by Insert, InsertOrUpdate, Replace or Update
	// operations.
	Columns []string
	// values specifies the new values for the target columns
	// named by Columns.
	Values     []interface{}
	ListValues []*tspb.ListValue
}

A Mutation describes a modification to one or more Cloud Spanner rows. The mutation represents an insert, update, delete, etc on a table.

func (m *Mutation) FromProto(mutation *tspb.Mutation) error

type MutationRequest ¶

type MutationRequest interface {
	GetSession() string
	GetMutations() []*tspb.Mutation
	GetTable() string
}

type NullBool ¶

type NullBool struct {
	Bool  bool
	Valid bool // Valid is true if Bool is not NULL.
}

NullBool represents a Cloud Spanner BOOL that may be NULL.

func (n NullBool) IsNull() bool

func (n NullBool) String() string

type NullDate ¶

type NullDate struct {
	Date  civil.Date
	Valid bool // Valid is true if Date is not NULL.
}

NullDate represents a Cloud Spanner DATE that may be null.

func (n NullDate) IsNull() bool

func (n NullDate) String() string

type NullFloat64 ¶

type NullFloat64 struct {
	Float64 float64
	Valid   bool // Valid is true if Float64 is not NULL.
}

NullFloat64 represents a Cloud Spanner FLOAT64 that may be NULL.

func (n NullFloat64) IsNull() bool

func (n NullFloat64) String() string

type NullInt64 ¶

type NullInt64 struct {
	Int64 int64
	Valid bool // Valid is true if Int64 is not NULL.
}

NullInt64 represents a Cloud Spanner INT64 that may be NULL.

func (n NullInt64) IsNull() bool

func (n NullInt64) String() string

type NullRow ¶

type NullRow struct {
	Row   Row
	Valid bool // Valid is true if Row is not NULL.
}

NullRow represents a Cloud Spanner STRUCT that may be NULL. See also the document for Row. Note that NullRow is not a valid Cloud Spanner column Type.

type NullString ¶

type NullString struct {
	StringVal string
	Valid     bool // Valid is true if StringVal is not NULL.
}

NullString represents a Cloud Spanner STRING that may be NULL.

func (n NullString) IsNull() bool

func (n NullString) String() string

type NullTime ¶

type NullTime struct {
	Time  time.Time
	Valid bool // Valid is true if Time is not NULL.
}

NullTime represents a Cloud Spanner TIMESTAMP that may be null.

func (n NullTime) IsNull() bool

func (n NullTime) String() string

type NullableValue ¶

type NullableValue interface {
	// IsNull returns true if the underlying database value is null.
	IsNull() bool
}

NullableValue is the interface implemented by all null value wrapper types.

type OP ¶

type OP int

Op is the mutation operation.

const (
	// OpUnknown indicate unknown operation
	OpUnknown OP = iota
	// OpDelete removes a row from a table.  Succeeds whether or not the
	// key was present.
	OpDelete
	// OpInsert inserts a row into a table.  If the row already exists, the
	// write or transaction fails.
	OpInsert
	// OpInsertOrUpdate inserts a row into a table. If the row already
	// exists, it updates it instead.  Any column values not explicitly
	// written are preserved.
	OpInsertOrUpdate
	// OpReplace inserts a row into a table, deleting any existing row.
	// Unlike InsertOrUpdate, this means any values not explicitly written
	// become NULL.
	OpReplace
	// OpUpdate updates a row in a table.  If the row does not already
	// exist, the write or transaction fails.
	OpUpdate
)

type ReadRequest ¶

type ReadRequest interface {
	GetSession() string
	GetTable() string
}

type Response ¶

type Response interface {
	CommitTimestamp() time.Time
}

type Row ¶

type Row struct {
	// contains filtered or unexported fields
}

A Row is a view of a row of data returned by a Cloud Spanner read. It consists of a number of columns; the number depends on the columns used to construct the read.

The column values can be accessed by index. For instance, if the read specified []string{"photo_id", "caption"}, then each row will contain two columns: "photo_id" with index 0, and "caption" with index 1.

Column values are decoded by using one of the Column, ColumnByName, or Columns methods. The valid values passed to these methods depend on the column type. For example:

var photoID int64
err := row.Column(0, &photoID) // Decode column 0 as an integer.

var caption string
err := row.Column(1, &caption) // Decode column 1 as a string.

// Decode all the columns.
err := row.Columns(&photoID, &caption)

Supported types and their corresponding Cloud Spanner column type(s) are:

*string(not NULL), *NullString - STRING
*[]string, *[]NullString - STRING ARRAY
*[]byte - BYTES
*[][]byte - BYTES ARRAY
*int64(not NULL), *NullInt64 - INT64
*[]int64, *[]NullInt64 - INT64 ARRAY
*bool(not NULL), *NullBool - BOOL
*[]bool, *[]NullBool - BOOL ARRAY
*float64(not NULL), *NullFloat64 - FLOAT64
*[]float64, *[]NullFloat64 - FLOAT64 ARRAY
*time.Time(not NULL), *NullTime - TIMESTAMP
*[]time.Time, *[]NullTime - TIMESTAMP ARRAY
*Date(not NULL), *NullDate - DATE
*[]civil.Date, *[]NullDate - DATE ARRAY
*[]*some_go_struct, *[]NullRow - STRUCT ARRAY
*GenericColumnValue - any Cloud Spanner type

For TIMESTAMP columns, the returned time.Time object will be in UTC.

To fetch an array of BYTES, pass a *[][]byte. To fetch an array of (sub)rows, pass a *[]spanner.NullRow or a *[]*some_go_struct where some_go_struct holds all information of the subrow, see spanner.Row.ToStruct for the mapping between a Cloud Spanner row and a Go struct. To fetch an array of other types, pass a *[]spanner.NullXXX type of the appropriate type. Use GenericColumnValue when you don't know in advance what column type to expect.

Row decodes the row contents lazily; as a result, each call to a getter has a chance of returning an error.

A column value may be NULL if the corresponding value is not present in Cloud Spanner. The spanner.NullXXX types (spanner.NullInt64 et al.) allow fetching values that may be null. A NULL BYTES can be fetched into a *[]byte as nil. It is an error to fetch a NULL value into any other type.

func NewRow(columnNames []string, columnValues []interface{}) (*Row, error)

func (r *Row) Column(i int, ptr interface{}) error

func (r *Row) ColumnByName(name string, ptr interface{}) error

func (r *Row) ColumnIndex(name string) (int, error)

func (r *Row) ColumnName(i int) string

func (r *Row) ColumnNames() []string

func (r *Row) Columns(ptrs ...interface{}) error

func (r *Row) Size() int

func (r *Row) ToStruct(p interface{}) error

type SparseReadRequest ¶

type SparseReadRequest struct {
	*tspb.SparseReadRequest
}