types

type CapacityMode ¶ added in v1.3.0

type CapacityMode int

CapacityMode defines the type of limits for a table.

const (
	// Provisioned table: fixed maximum of read/write units.
	// Note this value is purposefully zero as it is the default and
	// this enables existing app code to work properly
	Provisioned CapacityMode = iota // 0

	// OnDemand table: table scales with usage
	// Added in SDK Version 1.3.0
	OnDemand // 1
)

type Consistency ¶

type Consistency int

Consistency is used to provide consistency guarantees for read operations.

There are two consistency values available: Eventual and Absolute.

1. Eventual consistency means that the values read may be very slightly out of date.

2. Absolute consistency may be specified to guarantee that current values are read.

Absolute consistency results in higher cost, consuming twice the number of read units for the same data relative to Eventual consistency, and should only be used when required.

It is possible to set a default Consistency for a nosqldb.Client instance by using nosqldb.Config.Consistency. If no Consistency is specified in an operation and there is no default value, Eventual consistency is used.

Consistency can be specified as an optional argument to all read operations.

const (
	// Absolute consistency.
	Absolute Consistency = iota + 1 // 1

	// Eventual consistency.
	Eventual // 2
)

func (i Consistency) String() string

type DbType ¶

type DbType int

DbType represents the Oracle NoSQL database types used for field values.

const (
	// Array represents the Array data type.
	// An array is an ordered collection of zero or more elements,
	// all elements of an array have the same type.
	Array DbType = iota // 0

	// Binary represents the Binary data type.
	// A binary is an uninterpreted sequence of zero or more bytes.
	Binary // 1

	// Boolean data type has only two possible values: true and false.
	Boolean // 2

	// Double data type represents the set of all IEEE-754 64-bit floating-point numbers.
	Double // 3

	// Integer data type represents the set of all signed 32-bit integers (-2147483648 to 2147483647).
	Integer // 4

	// Long data type represents the set of all signed 64-bit
	// integers (-9223372036854775808 to 9223372036854775807).
	Long // 5

	// Map represents the Map data type.
	// A map is an unordered collection of zero or more key-value pairs,
	// where all keys are strings and all the values have the same type.
	Map // 6

	// String represents the set of string values.
	String // 7

	// Timestamp represents a point in time as a date or a time.
	Timestamp // 8

	// Number represents arbitrary precision numbers.
	Number // 9

	// JSONNull represents a special value that indicates the absence of
	// an actual value within a JSON data type.
	JSONNull // 10

	// Null represents a special value that indicates the absence of
	// an actual value, or the fact that a value is unknown or inapplicable.
	Null // 11

	// Empty represents the Empty data type.
	// It is used to describe the result of a query expression is empty.
	Empty // 12
)

func (i DbType) String() string

type DefinedTags ¶ added in v1.4.0

type DefinedTags struct {
	Tags *MapValue
}

DefinedTags encapsulates defined tags which are returned from calls to Client.GetTable(). They can also be set during table creation operations as well as alter table operations. Cloud service only. Added in SDK Version 1.4.0

func (dt *DefinedTags) AddTag(namespace, key, value string) (err error)

func (dt *DefinedTags) GetTag(namespace, key string) string

func (dt *DefinedTags) IsEmpty() bool

func (dt *DefinedTags) SetValuesFromJSON(jsonStr string) (err error)

type Durability ¶ added in v1.3.0

type Durability struct {
	// The sync policy in effect on the Master node.
	MasterSync SyncPolicy `json:"masterSync"`

	// The sync policy in effect on a replica.
	ReplicaSync SyncPolicy `json:"replicaSync"`

	// The replica acknowledgment policy to be used.
	ReplicaAck ReplicaAckPolicy `json:"replicaAck"`
}

Durability defines the durability characteristics associated with a standalone write (put or update) operation.

Added in SDK Version 1.3.0 ¶

This is currently only supported in On-Prem installations. It is ignored in the cloud service.

The overall durability is a function of the SyncPolicy and ReplicaAckPolicy in effect for the Master, and the SyncPolicy in effect for each Replica.

func (d *Durability) IsSet() bool

type EmptyValue ¶

type EmptyValue struct{}

EmptyValue represents an empty value.

This type is only relevant inside a table field of type JSON and only when that field is indexed.

It is used in index keys to represent missing value for the indexed field.

It is different from a JSONNullValue value, which is a concrete value.

It is also different from NullValue which represents a null or missing field in a fully-typed field in the table schema as opposed to a JSON field.

func (e *EmptyValue) MarshalJSON() ([]byte, error)

type FieldRange ¶

type FieldRange struct {
	// FieldPath specifies the path to the field used in the range.
	FieldPath string

	// Start specifies the start value of the range.
	Start interface{}

	// End specifies the end value of the range.
	End interface{}

	// StartInclusive specifies whether Start value is included in the range,
	// i.e., Start value is less than or equal to the first FieldValue in the range.
	//
	// This value is valid only if the Start value is specified.
	StartInclusive bool

	// EndInclusive specifies whether End value is included in the range,
	// i.e., End value is greater than or equal to the last FieldValue in the range.
	//
	// This value is valid only if the End value is specified.
	EndInclusive bool
}

FieldRange defines a range of values to be used in a Client.MultiDelete() operation, as specified in MultiDeleteRequest.FieldRange.

FieldRange is used as the least significant component in a partially specified key value in order to create a value range for an operation that returns multiple rows or keys. The data types supported by FieldRange are limited to the atomic types which are valid for primary keys.

The least significant component of a key is the first component of the key that is not fully specified. For example, if the primary key for a table is defined as the tuple:

<a, b, c>

A FieldRange can be specified for:

"a" if the primary key supplied is empty.
"b" if the primary key supplied to the operation has a concrete value for "a" but not for "b" or "c".

This object is used to scope a Client.MultiDelete() operation. The FieldPath specified must name a field in a table's primary key. The Start and End values used must be of the same type and that type must match the type of the field specified.

Validation of this object is performed when it is used in an operation. Validation includes verifying that the field is in the required key and, in the case of a composite key, that the field is in the proper order relative to the key used in the operation.

type FieldValue ¶

type FieldValue interface{}

FieldValue represents a field value of NoSQL database tables. This is an empty interface.

type FreeFormTags ¶ added in v1.4.0

type FreeFormTags struct {
	Tags *MapValue
}

FreeFormTags encapsulates free-form tags which are returned from calls to Client.GetTable(). They can also be set during table creation operations as well as alter table operations. Cloud service only. Added in SDK Version 1.4.0

func (fft *FreeFormTags) AddTag(key, value string) (err error)

func (fft *FreeFormTags) Contains(k string) (ok bool)

func (fft *FreeFormTags) GetMap() (m *map[string]interface{})

func (fft *FreeFormTags) GetTag(key string) string

func (fft *FreeFormTags) SetValuesFromJSON(jsonStr string) (err error)

func (fft *FreeFormTags) SetValuesFromMap(m map[string]interface{})

func (fft *FreeFormTags) Size() int

type JSONNullValue ¶

type JSONNullValue struct{}

JSONNullValue represents an explicit JSON null value in a JSON object or array. On input this type can only be used in a table field of type JSON.

This should be used as an immutable singleton object.

func (jn *JSONNullValue) MarshalJSON() ([]byte, error)

type MapValue ¶

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

MapValue represents a row in a NoSQL Database table. A top-level row is always a MapValue instance that contains FieldValue objects which may be instances of atomic types, embedded MapValue or an array of aforementioned types, creating a structured row.

MapValue is also used to represent key values used in get operations as well as nested maps or records within a row.

Field names in a MapValue are case-sensitive string values with no duplicates. On input, MapValues of any structure can be created, but when put into a table using a method such as Client.Put() they must conform to the schema of the target table or an error will be returned. Note that in the context of a RECORD field in a table schema, field names are treated as case-insensitive. If a MapValue represents JSON, field names are case-sensitive.

When a MapValue is received on output, such as from Client.Get() and Client.Query(), the value will always conform to the schema of the table from which the value was received or the implied schema of a query projection.

func NewEmptyMapValue() *MapValue

func NewMapValue(m map[string]interface{}) *MapValue

func NewMapValueFromJSON(jsonStr string) (*MapValue, error)

func NewOrderedMapValue() *MapValue

func ToMapValue(k string, v interface{}) *MapValue

func (m *MapValue) Contains(k string) (ok bool)

func (m *MapValue) Delete(k string)

func (m *MapValue) Get(k string) (v interface{}, ok bool)

func (m *MapValue) GetBinary(k string) (b []byte, ok bool)

func (m *MapValue) GetByIndex(idx int) (k string, v interface{}, ok bool)

func (m *MapValue) GetFloat64(k string) (f64 float64, ok bool)

func (m *MapValue) GetInt(k string) (i int, ok bool)

func (m *MapValue) GetInt64(k string) (i64 int64, ok bool)

func (m *MapValue) GetMapValue(k string) (mv MapValue, ok bool)

func (m *MapValue) GetString(k string) (s string, ok bool)

func (m *MapValue) IsOrdered() bool

func (m *MapValue) Len() int

func (m *MapValue) Map() map[string]interface{}

func (m *MapValue) MarshalJSON() ([]byte, error)

func (m *MapValue) Put(k string, v interface{}) *MapValue

type NullValue ¶

type NullValue struct{}

NullValue represents a null value or missing value in a fully-typed schema.

This type only exists in index keys on a fully-typed field and never inside indexed JSON.

func (n *NullValue) MarshalJSON() ([]byte, error)

type OperationState ¶

type OperationState int

OperationState represents the current state of the operation.

This is used for on-premise only.

const (
	// UnknownOpState represents the operation state is unknown.
	UnknownOpState OperationState = iota // 0

	// Complete represents the operation is complete and was successful.
	Complete // 1

	// Working represents the operation is in progress.
	Working // 2
)

func (st OperationState) GoString() string

func (i OperationState) String() string

type PutOption ¶

type PutOption int

PutOption represents an option for the put operation. It is used by PutRequest. The available put options are:

PutIfAbsent
PutIfPresent
PutIfVersion

const (
	// PutIfAbsent means put operation should only succeed if the row does not exist.
	PutIfAbsent PutOption = 4 // 4

	// PutIfPresent means put operation should only succeed if the row exists.
	PutIfPresent PutOption = 5 // 5

	// PutIfVersion means put operation should succeed only if the row exists
	// and its Version matches the specified version.
	PutIfVersion PutOption = 6 // 6
)

func (opt PutOption) GoString() string

func (i PutOption) String() string

type ReplicaAckPolicy ¶ added in v1.3.0

type ReplicaAckPolicy int

ReplicaAckPolicy defines the policy for how replicated commits are handled. A replicated environment makes it possible to increase an application's transaction commit guarantees by committing changes to its replicas on the network.

type SyncPolicy ¶ added in v1.3.0

type SyncPolicy int

SyncPolicy represents policies to be used when committing a transaction. High levels of synchronization offer a greater guarantee that the transaction is persistent to disk, but trade that off for lower performance.

type TableState ¶

type TableState int

TableState represents current state of a table.

The available table states are:

Active
Creating
Dropped
Dropping
Updating

const (
	// Active represents the table is ready to be used.
	// This is the steady state after table creation or modification.
	Active TableState = iota // 0

	// Creating represents the table is being created and cannot yet be used.
	Creating // 1

	// Dropped represents the table has been dropped or does not exist.
	Dropped // 2

	// Dropping represents the table is being dropped and cannot be used.
	Dropping // 3

	// Updating represents the table is being updated.
	// It is available for normal use, but additional table modification
	// operations are not permitted while the table is in this state.
	Updating // 4
)

func (st TableState) GoString() string

func (st TableState) IsTerminal() bool

func (i TableState) String() string

type TimeToLive ¶

type TimeToLive struct {
	// Value represents number of time units.
	Value int64

	// Unit represents the time unit that is either Hours or Days.
	Unit TimeUnit
}

TimeToLive represents a period of time, specialized to the needs of this driver.

This is restricted to durations of days and hours. It is only used as input related to time to live (TTL) for row instances.

Construction of TimeToLive values allows only day and hour durations for efficiency reasons. Durations of days are recommended as they result in the least amount of storage overhead.

Only positive durations are allowed on input, although negative durations can be returned if the expiration time of a row is in the past relative to the reference time.

func (ttl TimeToLive) ToDuration() time.Duration

type TimeUnit ¶

type TimeUnit int

TimeUnit represents time durations at a given unit.

const (
	// Hours represents time durations in hours.
	Hours TimeUnit = iota + 1 // 1

	// Days represents time durations in days.
	Days // 2
)

func (tu TimeUnit) GoString() string

func (i TimeUnit) String() string

type Version ¶

type Version []byte

Version represents the version of a row in the database. This is an opaque object from an application perspective.

It is returned by successful Client.Put() or Client.Get() operations and can be used in PutRequest.MatchVersion and DeleteRequest.MatchVersion to conditionally perform those operations to ensure an atomic read-modify-write cycle. Use of Version in this way adds cost to operations so it should be done only if necessary.