fulltype.yo.go

// Code generated by yo. DO NOT EDIT.
// Package models contains the types.
package models

import (
	"context"
	"fmt"
	"strings"
	"time"

	"cloud.google.com/go/civil"
	"cloud.google.com/go/spanner"
	"google.golang.org/api/iterator"
	"google.golang.org/grpc/codes"
)

// FullType represents a row from 'FullTypes'.
type FullType struct {
	PKey                 string              `spanner:"PKey" json:"PKey"`                                 // PKey
	FTString             string              `spanner:"FTString" json:"FTString"`                         // FTString
	FTStringNull         spanner.NullString  `spanner:"FTStringNull" json:"FTStringNull"`                 // FTStringNull
	FTBool               bool                `spanner:"FTBool" json:"FTBool"`                             // FTBool
	FTBoolNull           spanner.NullBool    `spanner:"FTBoolNull" json:"FTBoolNull"`                     // FTBoolNull
	FTBytes              []byte              `spanner:"FTBytes" json:"FTBytes"`                           // FTBytes
	FTBytesNull          []byte              `spanner:"FTBytesNull" json:"FTBytesNull"`                   // FTBytesNull
	FTTimestamp          time.Time           `spanner:"FTTimestamp" json:"FTTimestamp"`                   // FTTimestamp
	FTTimestampNull      spanner.NullTime    `spanner:"FTTimestampNull" json:"FTTimestampNull"`           // FTTimestampNull
	FTInt                int64               `spanner:"FTInt" json:"FTInt"`                               // FTInt
	FTIntNull            spanner.NullInt64   `spanner:"FTIntNull" json:"FTIntNull"`                       // FTIntNull
	FTFloat              float64             `spanner:"FTFloat" json:"FTFloat"`                           // FTFloat
	FTFloatNull          spanner.NullFloat64 `spanner:"FTFloatNull" json:"FTFloatNull"`                   // FTFloatNull
	FTDate               civil.Date          `spanner:"FTDate" json:"FTDate"`                             // FTDate
	FTDateNull           spanner.NullDate    `spanner:"FTDateNull" json:"FTDateNull"`                     // FTDateNull
	FTJSON               spanner.NullJSON    `spanner:"FTJson" json:"FTJson"`                             // FTJson
	FTJSONNull           spanner.NullJSON    `spanner:"FTJsonNull" json:"FTJsonNull"`                     // FTJsonNull
	FTArrayStringNull    []string            `spanner:"FTArrayStringNull" json:"FTArrayStringNull"`       // FTArrayStringNull
	FTArrayString        []string            `spanner:"FTArrayString" json:"FTArrayString"`               // FTArrayString
	FTArrayBoolNull      []bool              `spanner:"FTArrayBoolNull" json:"FTArrayBoolNull"`           // FTArrayBoolNull
	FTArrayBool          []bool              `spanner:"FTArrayBool" json:"FTArrayBool"`                   // FTArrayBool
	FTArrayBytesNull     [][]byte            `spanner:"FTArrayBytesNull" json:"FTArrayBytesNull"`         // FTArrayBytesNull
	FTArrayBytes         [][]byte            `spanner:"FTArrayBytes" json:"FTArrayBytes"`                 // FTArrayBytes
	FTArrayTimestampNull []time.Time         `spanner:"FTArrayTimestampNull" json:"FTArrayTimestampNull"` // FTArrayTimestampNull
	FTArrayTimestamp     []time.Time         `spanner:"FTArrayTimestamp" json:"FTArrayTimestamp"`         // FTArrayTimestamp
	FTArrayIntNull       []int64             `spanner:"FTArrayIntNull" json:"FTArrayIntNull"`             // FTArrayIntNull
	FTArrayInt           []int64             `spanner:"FTArrayInt" json:"FTArrayInt"`                     // FTArrayInt
	FTArrayFloatNull     []float64           `spanner:"FTArrayFloatNull" json:"FTArrayFloatNull"`         // FTArrayFloatNull
	FTArrayFloat         []float64           `spanner:"FTArrayFloat" json:"FTArrayFloat"`                 // FTArrayFloat
	FTArrayDateNull      []civil.Date        `spanner:"FTArrayDateNull" json:"FTArrayDateNull"`           // FTArrayDateNull
	FTArrayDate          []civil.Date        `spanner:"FTArrayDate" json:"FTArrayDate"`                   // FTArrayDate
	FTArrayJSONNull      []spanner.NullJSON  `spanner:"FTArrayJsonNull" json:"FTArrayJsonNull"`           // FTArrayJsonNull
	FTArrayJSON          []spanner.NullJSON  `spanner:"FTArrayJson" json:"FTArrayJson"`                   // FTArrayJson
}

func FullTypePrimaryKeys() []string {
	return []string{
		"PKey",
	}
}

func FullTypeColumns() []string {
	return []string{
		"PKey",
		"FTString",
		"FTStringNull",
		"FTBool",
		"FTBoolNull",
		"FTBytes",
		"FTBytesNull",
		"FTTimestamp",
		"FTTimestampNull",
		"FTInt",
		"FTIntNull",
		"FTFloat",
		"FTFloatNull",
		"FTDate",
		"FTDateNull",
		"FTJson",
		"FTJsonNull",
		"FTArrayStringNull",
		"FTArrayString",
		"FTArrayBoolNull",
		"FTArrayBool",
		"FTArrayBytesNull",
		"FTArrayBytes",
		"FTArrayTimestampNull",
		"FTArrayTimestamp",
		"FTArrayIntNull",
		"FTArrayInt",
		"FTArrayFloatNull",
		"FTArrayFloat",
		"FTArrayDateNull",
		"FTArrayDate",
		"FTArrayJsonNull",
		"FTArrayJson",
	}
}

func FullTypeWritableColumns() []string {
	return []string{
		"PKey",
		"FTString",
		"FTStringNull",
		"FTBool",
		"FTBoolNull",
		"FTBytes",
		"FTBytesNull",
		"FTTimestamp",
		"FTTimestampNull",
		"FTInt",
		"FTIntNull",
		"FTFloat",
		"FTFloatNull",
		"FTDate",
		"FTDateNull",
		"FTJson",
		"FTJsonNull",
		"FTArrayStringNull",
		"FTArrayString",
		"FTArrayBoolNull",
		"FTArrayBool",
		"FTArrayBytesNull",
		"FTArrayBytes",
		"FTArrayTimestampNull",
		"FTArrayTimestamp",
		"FTArrayIntNull",
		"FTArrayInt",
		"FTArrayFloatNull",
		"FTArrayFloat",
		"FTArrayDateNull",
		"FTArrayDate",
		"FTArrayJsonNull",
		"FTArrayJson",
	}
}

func (ft *FullType) columnsToPtrs(cols []string, customPtrs map[string]interface{}) ([]interface{}, error) {
	ret := make([]interface{}, 0, len(cols))
	for _, col := range cols {
		if val, ok := customPtrs[col]; ok {
			ret = append(ret, val)
			continue
		}

		switch col {
		case "PKey":
			ret = append(ret, &ft.PKey)
		case "FTString":
			ret = append(ret, &ft.FTString)
		case "FTStringNull":
			ret = append(ret, &ft.FTStringNull)
		case "FTBool":
			ret = append(ret, &ft.FTBool)
		case "FTBoolNull":
			ret = append(ret, &ft.FTBoolNull)
		case "FTBytes":
			ret = append(ret, &ft.FTBytes)
		case "FTBytesNull":
			ret = append(ret, &ft.FTBytesNull)
		case "FTTimestamp":
			ret = append(ret, &ft.FTTimestamp)
		case "FTTimestampNull":
			ret = append(ret, &ft.FTTimestampNull)
		case "FTInt":
			ret = append(ret, &ft.FTInt)
		case "FTIntNull":
			ret = append(ret, &ft.FTIntNull)
		case "FTFloat":
			ret = append(ret, &ft.FTFloat)
		case "FTFloatNull":
			ret = append(ret, &ft.FTFloatNull)
		case "FTDate":
			ret = append(ret, &ft.FTDate)
		case "FTDateNull":
			ret = append(ret, &ft.FTDateNull)
		case "FTJson":
			ret = append(ret, &ft.FTJSON)
		case "FTJsonNull":
			ret = append(ret, &ft.FTJSONNull)
		case "FTArrayStringNull":
			ret = append(ret, &ft.FTArrayStringNull)
		case "FTArrayString":
			ret = append(ret, &ft.FTArrayString)
		case "FTArrayBoolNull":
			ret = append(ret, &ft.FTArrayBoolNull)
		case "FTArrayBool":
			ret = append(ret, &ft.FTArrayBool)
		case "FTArrayBytesNull":
			ret = append(ret, &ft.FTArrayBytesNull)
		case "FTArrayBytes":
			ret = append(ret, &ft.FTArrayBytes)
		case "FTArrayTimestampNull":
			ret = append(ret, &ft.FTArrayTimestampNull)
		case "FTArrayTimestamp":
			ret = append(ret, &ft.FTArrayTimestamp)
		case "FTArrayIntNull":
			ret = append(ret, &ft.FTArrayIntNull)
		case "FTArrayInt":
			ret = append(ret, &ft.FTArrayInt)
		case "FTArrayFloatNull":
			ret = append(ret, &ft.FTArrayFloatNull)
		case "FTArrayFloat":
			ret = append(ret, &ft.FTArrayFloat)
		case "FTArrayDateNull":
			ret = append(ret, &ft.FTArrayDateNull)
		case "FTArrayDate":
			ret = append(ret, &ft.FTArrayDate)
		case "FTArrayJsonNull":
			ret = append(ret, &ft.FTArrayJSONNull)
		case "FTArrayJson":
			ret = append(ret, &ft.FTArrayJSON)
		default:
			return nil, fmt.Errorf("unknown column: %s", col)
		}
	}
	return ret, nil
}

func (ft *FullType) columnsToValues(cols []string) ([]interface{}, error) {
	ret := make([]interface{}, 0, len(cols))
	for _, col := range cols {
		switch col {
		case "PKey":
			ret = append(ret, ft.PKey)
		case "FTString":
			ret = append(ret, ft.FTString)
		case "FTStringNull":
			ret = append(ret, ft.FTStringNull)
		case "FTBool":
			ret = append(ret, ft.FTBool)
		case "FTBoolNull":
			ret = append(ret, ft.FTBoolNull)
		case "FTBytes":
			ret = append(ret, ft.FTBytes)
		case "FTBytesNull":
			ret = append(ret, ft.FTBytesNull)
		case "FTTimestamp":
			ret = append(ret, ft.FTTimestamp)
		case "FTTimestampNull":
			ret = append(ret, ft.FTTimestampNull)
		case "FTInt":
			ret = append(ret, ft.FTInt)
		case "FTIntNull":
			ret = append(ret, ft.FTIntNull)
		case "FTFloat":
			ret = append(ret, ft.FTFloat)
		case "FTFloatNull":
			ret = append(ret, ft.FTFloatNull)
		case "FTDate":
			ret = append(ret, ft.FTDate)
		case "FTDateNull":
			ret = append(ret, ft.FTDateNull)
		case "FTJson":
			ret = append(ret, ft.FTJSON)
		case "FTJsonNull":
			ret = append(ret, ft.FTJSONNull)
		case "FTArrayStringNull":
			ret = append(ret, ft.FTArrayStringNull)
		case "FTArrayString":
			ret = append(ret, ft.FTArrayString)
		case "FTArrayBoolNull":
			ret = append(ret, ft.FTArrayBoolNull)
		case "FTArrayBool":
			ret = append(ret, ft.FTArrayBool)
		case "FTArrayBytesNull":
			ret = append(ret, ft.FTArrayBytesNull)
		case "FTArrayBytes":
			ret = append(ret, ft.FTArrayBytes)
		case "FTArrayTimestampNull":
			ret = append(ret, ft.FTArrayTimestampNull)
		case "FTArrayTimestamp":
			ret = append(ret, ft.FTArrayTimestamp)
		case "FTArrayIntNull":
			ret = append(ret, ft.FTArrayIntNull)
		case "FTArrayInt":
			ret = append(ret, ft.FTArrayInt)
		case "FTArrayFloatNull":
			ret = append(ret, ft.FTArrayFloatNull)
		case "FTArrayFloat":
			ret = append(ret, ft.FTArrayFloat)
		case "FTArrayDateNull":
			ret = append(ret, ft.FTArrayDateNull)
		case "FTArrayDate":
			ret = append(ret, ft.FTArrayDate)
		case "FTArrayJsonNull":
			ret = append(ret, ft.FTArrayJSONNull)
		case "FTArrayJson":
			ret = append(ret, ft.FTArrayJSON)
		default:
			return nil, fmt.Errorf("unknown column: %s", col)
		}
	}

	return ret, nil
}

// newFullType_Decoder returns a decoder which reads a row from *spanner.Row
// into FullType. The decoder is not goroutine-safe. Don't use it concurrently.
func newFullType_Decoder(cols []string) func(*spanner.Row) (*FullType, error) {
	customPtrs := map[string]interface{}{}

	return func(row *spanner.Row) (*FullType, error) {
		var ft FullType
		ptrs, err := ft.columnsToPtrs(cols, customPtrs)
		if err != nil {
			return nil, err
		}

		if err := row.Columns(ptrs...); err != nil {
			return nil, err
		}

		return &ft, nil
	}
}

// Insert returns a Mutation to insert a row into a table. If the row already
// exists, the write or transaction fails.
func (ft *FullType) Insert(ctx context.Context) *spanner.Mutation {
	values, _ := ft.columnsToValues(FullTypeWritableColumns())
	return spanner.Insert("FullTypes", FullTypeWritableColumns(), values)
}

// Update returns a Mutation to update a row in a table. If the row does not
// already exist, the write or transaction fails.
func (ft *FullType) Update(ctx context.Context) *spanner.Mutation {
	values, _ := ft.columnsToValues(FullTypeWritableColumns())
	return spanner.Update("FullTypes", FullTypeWritableColumns(), values)
}

// InsertOrUpdate returns a Mutation to insert a row into a table. If the row
// already exists, it updates it instead. Any column values not explicitly
// written are preserved.
func (ft *FullType) InsertOrUpdate(ctx context.Context) *spanner.Mutation {
	values, _ := ft.columnsToValues(FullTypeWritableColumns())
	return spanner.InsertOrUpdate("FullTypes", FullTypeWritableColumns(), values)
}

// UpdateColumns returns a Mutation to update specified columns of a row in a table.
func (ft *FullType) UpdateColumns(ctx context.Context, cols ...string) (*spanner.Mutation, error) {
	// add primary keys to columns to update by primary keys
	colsWithPKeys := append(cols, FullTypePrimaryKeys()...)

	values, err := ft.columnsToValues(colsWithPKeys)
	if err != nil {
		return nil, newErrorWithCode(codes.InvalidArgument, "FullType.UpdateColumns", "FullTypes", err)
	}

	return spanner.Update("FullTypes", colsWithPKeys, values), nil
}

// FindFullType gets a FullType by primary key
func FindFullType(ctx context.Context, db YORODB, pKey string) (*FullType, error) {
	key := spanner.Key{pKey}
	row, err := db.ReadRow(ctx, "FullTypes", key, FullTypeColumns())
	if err != nil {
		return nil, newError("FindFullType", "FullTypes", err)
	}

	decoder := newFullType_Decoder(FullTypeColumns())
	ft, err := decoder(row)
	if err != nil {
		return nil, newErrorWithCode(codes.Internal, "FindFullType", "FullTypes", err)
	}

	return ft, nil
}

// ReadFullType retrieves multiples rows from FullType by KeySet as a slice.
func ReadFullType(ctx context.Context, db YORODB, keys spanner.KeySet) ([]*FullType, error) {
	var res []*FullType

	decoder := newFullType_Decoder(FullTypeColumns())

	rows := db.Read(ctx, "FullTypes", keys, FullTypeColumns())
	err := rows.Do(func(row *spanner.Row) error {
		ft, err := decoder(row)
		if err != nil {
			return err
		}
		res = append(res, ft)

		return nil
	})
	if err != nil {
		return nil, newErrorWithCode(codes.Internal, "ReadFullType", "FullTypes", err)
	}

	return res, nil
}

// Delete deletes the FullType from the database.
func (ft *FullType) Delete(ctx context.Context) *spanner.Mutation {
	values, _ := ft.columnsToValues(FullTypePrimaryKeys())
	return spanner.Delete("FullTypes", spanner.Key(values))
}

// FindFullTypeByFTString retrieves a row from 'FullTypes' as a FullType.
//
// If no row is present with the given key, then ReadRow returns an error where
// spanner.ErrCode(err) is codes.NotFound.
//
// Generated from unique index 'FullTypesByFTString'.
func FindFullTypeByFTString(ctx context.Context, db YORODB, fTString string) (*FullType, error) {
	const sqlstr = "SELECT " +
		"PKey, FTString, FTStringNull, FTBool, FTBoolNull, FTBytes, FTBytesNull, FTTimestamp, FTTimestampNull, FTInt, FTIntNull, FTFloat, FTFloatNull, FTDate, FTDateNull, FTJson, FTJsonNull, FTArrayStringNull, FTArrayString, FTArrayBoolNull, FTArrayBool, FTArrayBytesNull, FTArrayBytes, FTArrayTimestampNull, FTArrayTimestamp, FTArrayIntNull, FTArrayInt, FTArrayFloatNull, FTArrayFloat, FTArrayDateNull, FTArrayDate, FTArrayJsonNull, FTArrayJson " +
		"FROM FullTypes@{FORCE_INDEX=FullTypesByFTString} " +
		"WHERE FTString = @param0"

	stmt := spanner.NewStatement(sqlstr)
	stmt.Params["param0"] = fTString

	decoder := newFullType_Decoder(FullTypeColumns())

	// run query
	YOLog(ctx, sqlstr, fTString)
	iter := db.Query(ctx, stmt)
	defer iter.Stop()

	row, err := iter.Next()
	if err != nil {
		if err == iterator.Done {
			return nil, newErrorWithCode(codes.NotFound, "FindFullTypeByFTString", "FullTypes", err)
		}
		return nil, newError("FindFullTypeByFTString", "FullTypes", err)
	}

	ft, err := decoder(row)
	if err != nil {
		return nil, newErrorWithCode(codes.Internal, "FindFullTypeByFTString", "FullTypes", err)
	}

	return ft, nil
}

// ReadFullTypeByFTString retrieves multiples rows from 'FullTypes' by KeySet as a slice.
//
// This does not retrieve all columns of 'FullTypes' because an index has only columns
// used for primary key, index key and storing columns. If you need more columns, add storing
// columns or Read by primary key or Query with join.
//
// Generated from unique index 'FullTypesByFTString'.
func ReadFullTypeByFTString(ctx context.Context, db YORODB, keys spanner.KeySet) ([]*FullType, error) {
	var res []*FullType
	columns := []string{
		"PKey",
		"FTString",
	}

	decoder := newFullType_Decoder(columns)

	rows := db.ReadUsingIndex(ctx, "FullTypes", "FullTypesByFTString", keys, columns)
	err := rows.Do(func(row *spanner.Row) error {
		ft, err := decoder(row)
		if err != nil {
			return err
		}
		res = append(res, ft)

		return nil
	})
	if err != nil {
		return nil, newErrorWithCode(codes.Internal, "ReadFullTypeByFTString", "FullTypes", err)
	}

	return res, nil
}

// FindFullTypesByFTIntFTTimestampNull retrieves multiple rows from 'FullTypes' as a slice of FullType.
//
// Generated from index 'FullTypesByInTimestampNull'.
func FindFullTypesByFTIntFTTimestampNull(ctx context.Context, db YORODB, fTInt int64, fTTimestampNull spanner.NullTime) ([]*FullType, error) {
	var sqlstr = "SELECT " +
		"PKey, FTString, FTStringNull, FTBool, FTBoolNull, FTBytes, FTBytesNull, FTTimestamp, FTTimestampNull, FTInt, FTIntNull, FTFloat, FTFloatNull, FTDate, FTDateNull, FTJson, FTJsonNull, FTArrayStringNull, FTArrayString, FTArrayBoolNull, FTArrayBool, FTArrayBytesNull, FTArrayBytes, FTArrayTimestampNull, FTArrayTimestamp, FTArrayIntNull, FTArrayInt, FTArrayFloatNull, FTArrayFloat, FTArrayDateNull, FTArrayDate, FTArrayJsonNull, FTArrayJson " +
		"FROM FullTypes@{FORCE_INDEX=FullTypesByInTimestampNull} "

	conds := make([]string, 2)
	conds[0] = "FTInt = @param0"
	if fTTimestampNull.IsNull() {
		conds[1] = "FTTimestampNull IS NULL"
	} else {
		conds[1] = "FTTimestampNull = @param1"
	}
	sqlstr += "WHERE " + strings.Join(conds, " AND ")

	stmt := spanner.NewStatement(sqlstr)
	stmt.Params["param0"] = fTInt
	stmt.Params["param1"] = fTTimestampNull

	decoder := newFullType_Decoder(FullTypeColumns())

	// run query
	YOLog(ctx, sqlstr, fTInt, fTTimestampNull)
	iter := db.Query(ctx, stmt)
	defer iter.Stop()

	// load results
	res := []*FullType{}
	for {
		row, err := iter.Next()
		if err != nil {
			if err == iterator.Done {
				break
			}
			return nil, newError("FindFullTypesByFTIntFTTimestampNull", "FullTypes", err)
		}

		ft, err := decoder(row)
		if err != nil {
			return nil, newErrorWithCode(codes.Internal, "FindFullTypesByFTIntFTTimestampNull", "FullTypes", err)
		}

		res = append(res, ft)
	}

	return res, nil
}

// ReadFullTypesByFTIntFTTimestampNull retrieves multiples rows from 'FullTypes' by KeySet as a slice.
//
// This does not retrieve all columns of 'FullTypes' because an index has only columns
// used for primary key, index key and storing columns. If you need more columns, add storing
// columns or Read by primary key or Query with join.
//
// Generated from unique index 'FullTypesByInTimestampNull'.
func ReadFullTypesByFTIntFTTimestampNull(ctx context.Context, db YORODB, keys spanner.KeySet) ([]*FullType, error) {
	var res []*FullType
	columns := []string{
		"PKey",
		"FTInt",
		"FTTimestampNull",
	}

	decoder := newFullType_Decoder(columns)

	rows := db.ReadUsingIndex(ctx, "FullTypes", "FullTypesByInTimestampNull", keys, columns)
	err := rows.Do(func(row *spanner.Row) error {
		ft, err := decoder(row)
		if err != nil {
			return err
		}
		res = append(res, ft)

		return nil
	})
	if err != nil {
		return nil, newErrorWithCode(codes.Internal, "ReadFullTypesByFTIntFTTimestampNull", "FullTypes", err)
	}

	return res, nil
}

// FindFullTypesByFTIntFTDate retrieves multiple rows from 'FullTypes' as a slice of FullType.
//
// Generated from index 'FullTypesByIntDate'.
func FindFullTypesByFTIntFTDate(ctx context.Context, db YORODB, fTInt int64, fTDate civil.Date) ([]*FullType, error) {
	const sqlstr = "SELECT " +
		"PKey, FTString, FTStringNull, FTBool, FTBoolNull, FTBytes, FTBytesNull, FTTimestamp, FTTimestampNull, FTInt, FTIntNull, FTFloat, FTFloatNull, FTDate, FTDateNull, FTJson, FTJsonNull, FTArrayStringNull, FTArrayString, FTArrayBoolNull, FTArrayBool, FTArrayBytesNull, FTArrayBytes, FTArrayTimestampNull, FTArrayTimestamp, FTArrayIntNull, FTArrayInt, FTArrayFloatNull, FTArrayFloat, FTArrayDateNull, FTArrayDate, FTArrayJsonNull, FTArrayJson " +
		"FROM FullTypes@{FORCE_INDEX=FullTypesByIntDate} " +
		"WHERE FTInt = @param0 AND FTDate = @param1"

	stmt := spanner.NewStatement(sqlstr)
	stmt.Params["param0"] = fTInt
	stmt.Params["param1"] = fTDate

	decoder := newFullType_Decoder(FullTypeColumns())

	// run query
	YOLog(ctx, sqlstr, fTInt, fTDate)
	iter := db.Query(ctx, stmt)
	defer iter.Stop()

	// load results
	res := []*FullType{}
	for {
		row, err := iter.Next()
		if err != nil {
			if err == iterator.Done {
				break
			}
			return nil, newError("FindFullTypesByFTIntFTDate", "FullTypes", err)
		}

		ft, err := decoder(row)
		if err != nil {
			return nil, newErrorWithCode(codes.Internal, "FindFullTypesByFTIntFTDate", "FullTypes", err)
		}

		res = append(res, ft)
	}

	return res, nil
}

// ReadFullTypesByFTIntFTDate retrieves multiples rows from 'FullTypes' by KeySet as a slice.
//
// This does not retrieve all columns of 'FullTypes' because an index has only columns
// used for primary key, index key and storing columns. If you need more columns, add storing
// columns or Read by primary key or Query with join.
//
// Generated from unique index 'FullTypesByIntDate'.
func ReadFullTypesByFTIntFTDate(ctx context.Context, db YORODB, keys spanner.KeySet) ([]*FullType, error) {
	var res []*FullType
	columns := []string{
		"PKey",
		"FTInt",
		"FTDate",
	}

	decoder := newFullType_Decoder(columns)

	rows := db.ReadUsingIndex(ctx, "FullTypes", "FullTypesByIntDate", keys, columns)
	err := rows.Do(func(row *spanner.Row) error {
		ft, err := decoder(row)
		if err != nil {
			return err
		}
		res = append(res, ft)

		return nil
	})
	if err != nil {
		return nil, newErrorWithCode(codes.Internal, "ReadFullTypesByFTIntFTDate", "FullTypes", err)
	}

	return res, nil
}

// FindFullTypesByFTIntFTTimestamp retrieves multiple rows from 'FullTypes' as a slice of FullType.
//
// Generated from index 'FullTypesByIntTimestamp'.
func FindFullTypesByFTIntFTTimestamp(ctx context.Context, db YORODB, fTInt int64, fTTimestamp time.Time) ([]*FullType, error) {
	const sqlstr = "SELECT " +
		"PKey, FTString, FTStringNull, FTBool, FTBoolNull, FTBytes, FTBytesNull, FTTimestamp, FTTimestampNull, FTInt, FTIntNull, FTFloat, FTFloatNull, FTDate, FTDateNull, FTJson, FTJsonNull, FTArrayStringNull, FTArrayString, FTArrayBoolNull, FTArrayBool, FTArrayBytesNull, FTArrayBytes, FTArrayTimestampNull, FTArrayTimestamp, FTArrayIntNull, FTArrayInt, FTArrayFloatNull, FTArrayFloat, FTArrayDateNull, FTArrayDate, FTArrayJsonNull, FTArrayJson " +
		"FROM FullTypes@{FORCE_INDEX=FullTypesByIntTimestamp} " +
		"WHERE FTInt = @param0 AND FTTimestamp = @param1"

	stmt := spanner.NewStatement(sqlstr)
	stmt.Params["param0"] = fTInt
	stmt.Params["param1"] = fTTimestamp

	decoder := newFullType_Decoder(FullTypeColumns())

	// run query
	YOLog(ctx, sqlstr, fTInt, fTTimestamp)
	iter := db.Query(ctx, stmt)
	defer iter.Stop()

	// load results
	res := []*FullType{}
	for {
		row, err := iter.Next()
		if err != nil {
			if err == iterator.Done {
				break
			}
			return nil, newError("FindFullTypesByFTIntFTTimestamp", "FullTypes", err)
		}

		ft, err := decoder(row)
		if err != nil {
			return nil, newErrorWithCode(codes.Internal, "FindFullTypesByFTIntFTTimestamp", "FullTypes", err)
		}

		res = append(res, ft)
	}

	return res, nil
}

// ReadFullTypesByFTIntFTTimestamp retrieves multiples rows from 'FullTypes' by KeySet as a slice.
//
// This does not retrieve all columns of 'FullTypes' because an index has only columns
// used for primary key, index key and storing columns. If you need more columns, add storing
// columns or Read by primary key or Query with join.
//
// Generated from unique index 'FullTypesByIntTimestamp'.
func ReadFullTypesByFTIntFTTimestamp(ctx context.Context, db YORODB, keys spanner.KeySet) ([]*FullType, error) {
	var res []*FullType
	columns := []string{
		"PKey",
		"FTInt",
		"FTTimestamp",
	}

	decoder := newFullType_Decoder(columns)

	rows := db.ReadUsingIndex(ctx, "FullTypes", "FullTypesByIntTimestamp", keys, columns)
	err := rows.Do(func(row *spanner.Row) error {
		ft, err := decoder(row)
		if err != nil {
			return err
		}
		res = append(res, ft)

		return nil
	})
	if err != nil {
		return nil, newErrorWithCode(codes.Internal, "ReadFullTypesByFTIntFTTimestamp", "FullTypes", err)
	}

	return res, nil
}

// FindFullTypesByFTTimestamp retrieves multiple rows from 'FullTypes' as a slice of FullType.
//
// Generated from index 'FullTypesByTimestamp'.
func FindFullTypesByFTTimestamp(ctx context.Context, db YORODB, fTTimestamp time.Time) ([]*FullType, error) {
	const sqlstr = "SELECT " +
		"PKey, FTString, FTStringNull, FTBool, FTBoolNull, FTBytes, FTBytesNull, FTTimestamp, FTTimestampNull, FTInt, FTIntNull, FTFloat, FTFloatNull, FTDate, FTDateNull, FTJson, FTJsonNull, FTArrayStringNull, FTArrayString, FTArrayBoolNull, FTArrayBool, FTArrayBytesNull, FTArrayBytes, FTArrayTimestampNull, FTArrayTimestamp, FTArrayIntNull, FTArrayInt, FTArrayFloatNull, FTArrayFloat, FTArrayDateNull, FTArrayDate, FTArrayJsonNull, FTArrayJson " +
		"FROM FullTypes@{FORCE_INDEX=FullTypesByTimestamp} " +
		"WHERE FTTimestamp = @param0"

	stmt := spanner.NewStatement(sqlstr)
	stmt.Params["param0"] = fTTimestamp

	decoder := newFullType_Decoder(FullTypeColumns())

	// run query
	YOLog(ctx, sqlstr, fTTimestamp)
	iter := db.Query(ctx, stmt)
	defer iter.Stop()

	// load results
	res := []*FullType{}
	for {
		row, err := iter.Next()
		if err != nil {
			if err == iterator.Done {
				break
			}
			return nil, newError("FindFullTypesByFTTimestamp", "FullTypes", err)
		}

		ft, err := decoder(row)
		if err != nil {
			return nil, newErrorWithCode(codes.Internal, "FindFullTypesByFTTimestamp", "FullTypes", err)
		}

		res = append(res, ft)
	}

	return res, nil
}

// ReadFullTypesByFTTimestamp retrieves multiples rows from 'FullTypes' by KeySet as a slice.
//
// This does not retrieve all columns of 'FullTypes' because an index has only columns
// used for primary key, index key and storing columns. If you need more columns, add storing
// columns or Read by primary key or Query with join.
//
// Generated from unique index 'FullTypesByTimestamp'.
func ReadFullTypesByFTTimestamp(ctx context.Context, db YORODB, keys spanner.KeySet) ([]*FullType, error) {
	var res []*FullType
	columns := []string{
		"PKey",
		"FTTimestamp",
	}

	decoder := newFullType_Decoder(columns)

	rows := db.ReadUsingIndex(ctx, "FullTypes", "FullTypesByTimestamp", keys, columns)
	err := rows.Do(func(row *spanner.Row) error {
		ft, err := decoder(row)
		if err != nil {
			return err
		}
		res = append(res, ft)

		return nil
	})
	if err != nil {
		return nil, newErrorWithCode(codes.Internal, "ReadFullTypesByFTTimestamp", "FullTypes", err)
	}

	return res, nil
}