driver

package
v1.0.0-alpha.20 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 21, 2022 License: Apache-2.0 Imports: 21 Imported by: 9

Documentation

Overview

Package driver provides access to the low level Tigris API. It abstracts underlying transport protocol.

Index

Examples

Constants

View Source 
const (
	GRPC = iota
	HTTP = iota

	TokenEnv = "TIGRIS_TOKEN"

	Version   = "v1.0.0"
	UserAgent = "tigris-client-go/" + Version
)
View Source 
const (
	DefaultGRPCPort = 443
)
View Source 
const (
	DefaultHTTPPort = 443
)

Variables

View Source 
var (
	DefaultProtocol = GRPC
	TokenRefreshURL = "https://tigrisdata-dev.us.auth0.com/oauth/token"
)

Functions

func GRPCError 

func GRPCError(err error) error

func HTTPError 

func HTTPError(err error, resp *http.Response) error

HTTPError parses HTTP error into TigrisError Returns nil, if HTTP status is OK

func ToString 

func ToString(s *string) string

Types

type CRUDWithOptions 

type CRUDWithOptions interface {
	// contains filtered or unexported methods
}

type CollectionOptions 

type CollectionOptions api.CollectionOptions

type Database 

type Database interface {
	// Insert array of documents into specified database and collection.
	Insert(ctx context.Context, collection string, docs []Document, options ...*InsertOptions) (*InsertResponse, error)

	// Replace array of documents into specified database and collection
	// Creates document if it doesn't exist.
	Replace(ctx context.Context, collection string, docs []Document, options ...*ReplaceOptions) (*ReplaceResponse, error)

	// Read documents from the collection matching the specified filter.
	Read(ctx context.Context, collection string, filter Filter, fields Projection, options ...*ReadOptions) (Iterator, error)

	//Search for documents in the collection matching specified query
	Search(ctx context.Context, collection string, request *SearchRequest) (SearchResultIterator, error)

	// Update documents in the collection matching the specified filter.
	Update(ctx context.Context, collection string, filter Filter, fields Update, options ...*UpdateOptions) (*UpdateResponse, error)

	// Delete documents from the collection matching specified filter.
	Delete(ctx context.Context, collection string, filter Filter, options ...*DeleteOptions) (*DeleteResponse, error)

	// CreateOrUpdateCollection either creates a collection or update the collection with the new schema
	// There are three categories of data types supported:
	//   Primitive: Strings, Numbers, Binary Data, Booleans, UUIDs, DateTime
	//   Complex: Arrays
	//   Objects: A container data type defined by the user that stores fields of primitive types,
	//   complex types as well as other Objects
	//
	//  The data types are derived from the types defined in the JSON schema specification
	//  with extensions that enable support for richer semantics.
	//  As an example, the string is defined like this,
	//   {
	//     "name": {
	//       "type": "string"
	//     }
	//   }
	// More detailed information here: https://docs.tigrisdata.com/datamodels/types
	CreateOrUpdateCollection(ctx context.Context, collection string, schema Schema, options ...*CollectionOptions) error

	// DropCollection deletes the collection and all documents it contains.
	DropCollection(ctx context.Context, collection string, options ...*CollectionOptions) error

	// ListCollections lists collections in the database.
	ListCollections(ctx context.Context, options ...*CollectionOptions) ([]string, error)

	// DescribeCollection returns metadata of the collection in the database
	DescribeCollection(ctx context.Context, collection string, options ...*CollectionOptions) (*DescribeCollectionResponse, error)

	Events(ctx context.Context, collection string, options ...*EventsOptions) (EventIterator, error)
}

Database is the interface that encapsulates the CRUD portions of the transaction API.

type DatabaseOptions 

type DatabaseOptions api.DatabaseOptions

type DeleteOptions 

type DeleteOptions api.DeleteRequestOptions

type DeleteResponse 

type DeleteResponse api.DeleteResponse

type DescribeCollectionResponse 

type DescribeCollectionResponse api.DescribeCollectionResponse

type DescribeDatabaseResponse 

type DescribeDatabaseResponse api.DescribeDatabaseResponse

type Document 

type Document json.RawMessage

type Driver 

type Driver interface {
	// Info returns server information
	Info(ctx context.Context) (*InfoResponse, error)

	// UseDatabase returns and interface for collections and documents management
	// of the database
	UseDatabase(name string) Database

	// ListDatabases in the current namespace
	ListDatabases(ctx context.Context) ([]string, error)
	// DescribeDatabase returns database metadata
	DescribeDatabase(ctx context.Context, db string) (*DescribeDatabaseResponse, error)

	// CreateDatabase creates new database
	CreateDatabase(ctx context.Context, db string, options ...*DatabaseOptions) error
	// DropDatabase deletes the database and all collections it contains
	DropDatabase(ctx context.Context, db string, options ...*DatabaseOptions) error

	// BeginTx starts new transaction
	BeginTx(ctx context.Context, db string, options ...*TxOptions) (Tx, error)

	// Close releases resources of the driver
	Close() error
}

Driver implements Tigris API

Example 
ctx := context.TODO()

c, _ := NewDriver(ctx, &config.Driver{URL: "localhost"})

_ = c.CreateDatabase(ctx, "db1", &DatabaseOptions{})

db := c.UseDatabase("db1")

_ = db.CreateOrUpdateCollection(ctx, "coll1",
	Schema(`{ "properties": { "F1": { "type": "string" }, "F2": { "type": "string" } }, "primary_key": ["F1"] }`))

_, _ = db.Insert(ctx, "c1", []Document{Document(`{"F1":"V1"}`)})

it, _ := db.Read(ctx, "c1", Filter(`{"F1":"V1"}`), Projection(`{}`))

var doc Document
for it.Next(&doc) {
	fmt.Printf("doc: %v\n", doc)
}

_ = it.Err()

_, _ = db.Delete(ctx, "c1", Filter(`{"F1":"V1"}`))

tx, _ := c.BeginTx(ctx, "db1", nil)
defer func() { _ = tx.Rollback(ctx) }()

_, _ = tx.Insert(ctx, "c1", []Document{Document(`{"F1":"V1"}`)})

it, _ = tx.Read(ctx, "c1", Filter(`{"F1":"V1"}`), Projection("{}"))

for it.Next(&doc) {
	fmt.Printf("doc: %v\n", doc)
}

err := it.Err()
var e Error
if errors.As(err, &e) && e.Code == api.Code_ALREADY_EXISTS {
	// handle already exists error
}

_, _ = tx.Update(ctx, "c1", Filter(`{"F1":"V1"}`),
	Update(`{"$set" : { "F2" : "V2"}}`), &UpdateOptions{})

_, _ = tx.Delete(ctx, "c1", Filter(`{"F1":"V1"}`), &DeleteOptions{})

_ = tx.Commit(ctx)

_ = c.DropDatabase(ctx, "db1", &DatabaseOptions{})

Output:

func NewDriver 

func NewDriver(ctx context.Context, cfg *config.Driver) (Driver, error)

NewDriver connect to Tigris at the specified URL URL should be in the form: {hostname}:{port}

func NewGRPCClient 

func NewGRPCClient(ctx context.Context, url string, config *config.Driver) (Driver, error)

NewGRPCClient return Driver interface implementation using GRPC transport protocol

func NewHTTPClient 

func NewHTTPClient(ctx context.Context, url string, config *config.Driver) (Driver, error)

NewHTTPClient return Driver interface implementation using HTTP transport protocol

type Error 

type Error struct {
	*api.TigrisError
}

func (*Error) As 

func (e *Error) As(i any) bool

As converts driver.Error the error which implements AsTigrisError interface

type Event 

type Event *api.StreamEvent

type EventIterator 

type EventIterator interface {
	Next(d *Event) bool
	Err() error
	Close()
}

type EventsOptions 

type EventsOptions api.EventsRequestOptions

type Facet 

type Facet json.RawMessage

type Filter 

type Filter json.RawMessage

type InfoResponse 

type InfoResponse api.GetInfoResponse

type InsertOptions 

type InsertOptions api.InsertRequestOptions

type InsertResponse 

type InsertResponse api.InsertResponse

type Iterator 

type Iterator interface {
	Next(d *Document) bool
	Err() error
	Close()
}

type Projection 

type Projection json.RawMessage

type ReadOptions 

type ReadOptions api.ReadRequestOptions

type ReplaceOptions 

type ReplaceOptions api.ReplaceRequestOptions

type ReplaceResponse 

type ReplaceResponse api.ReplaceResponse

type Schema 

type Schema json.RawMessage

type SearchProjection 

type SearchProjection json.RawMessage

type SearchRequest 

type SearchRequest struct {
	Q            string
	SearchFields []string
	Filter       Filter
	Facet        Facet
	ReadFields   SearchProjection
	Page         int32
	PageSize     int32
}

type SearchResponse 

type SearchResponse *api.SearchResponse

type SearchResultIterator 

type SearchResultIterator interface {
	Next(r *SearchResponse) bool
	Err() error
	Close()
}

type Tx 

type Tx interface {
	// Commit all the modification of the transaction
	Commit(ctx context.Context) error

	// Rollback discard all the modification made by the transaction
	Rollback(ctx context.Context) error

	Database
}

Tx object is used to atomically modify documents. This object is returned by BeginTx

type TxOptions 

type TxOptions api.TransactionOptions

type Update 

type Update json.RawMessage

type UpdateOptions 

type UpdateOptions api.UpdateRequestOptions

type UpdateResponse 

type UpdateResponse api.UpdateResponse

type WriteOptions 

type WriteOptions api.WriteOptions

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.