v1

package
v1.0.0-alpha.31 Latest Latest
Warning

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

 Go to latest Published: Aug 18, 2022 License: Apache-2.0 Imports: 52 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	AcceptHeader             = "Accept"
	ApplicationJsonHeaderVal = "application/json"
	DDApiKey                 = "DD-API-KEY"
	DDAppKey                 = "DD-APPLICATION-KEY"
	Query                    = "query"
	DDQueryEndpointPath      = "/api/v1/query"
)
View Source 
const (
	InsertedStatus string = "inserted"
	ReplacedStatus string = "replaced"
	UpdatedStatus  string = "updated"
	DeletedStatus  string = "deleted"
	CreatedStatus  string = "created"
	DroppedStatus  string = "dropped"
)

Variables

View Source 
var (
	ErrSearchIndexingFailed = fmt.Errorf("failed to index documents")
)
View Source 
var (
	ReservedNamespaceNames = set.New(metadata.DefaultNamespaceName, "unknown")
)

Functions

func CreateSearchKey 

func CreateSearchKey(table []byte, fdbKey []byte) (string, error)

func FlattenObjects 

func FlattenObjects(data map[string]any) map[string]any

func PackSearchFields 

func PackSearchFields(data *internal.TableData, collection *schema.DefaultCollection, id string) ([]byte, error)

func UnFlattenObjects 

func UnFlattenObjects(flat map[string]any) map[string]any

func UnpackAndSetMD 

func UnpackAndSetMD(doc map[string]interface{}, tableData *internal.TableData)

func UnpackSearchFields 

func UnpackSearchFields(doc map[string]interface{}, collection *schema.DefaultCollection) (string, *internal.TableData, map[string]interface{}, error)

Types

type Auth0 

type Auth0 struct {
	config.AuthConfig
}

func (Auth0) GetAccessToken 

func (a Auth0) GetAccessToken(req *api.GetAccessTokenRequest) (*api.GetAccessTokenResponse, error)

type BaseQueryRunner 

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

func NewBaseQueryRunner 

func NewBaseQueryRunner(encoder metadata.Encoder, cdcMgr *cdc.Manager, txMgr *transaction.Manager, searchStore search.Store) *BaseQueryRunner

func (*BaseQueryRunner) GetCollections 

func (runner *BaseQueryRunner) GetCollections(db *metadata.Database, collName string) (*schema.DefaultCollection, error)

func (*BaseQueryRunner) GetDatabase 

func (runner *BaseQueryRunner) GetDatabase(ctx context.Context, tx transaction.Tx, tenant *metadata.Tenant, dbName string) (*metadata.Database, error)

type CollectionQueryRunner 

type CollectionQueryRunner struct {
	*BaseQueryRunner
	// contains filtered or unexported fields
}

func (*CollectionQueryRunner) Run 

func (runner *CollectionQueryRunner) Run(ctx context.Context, tx transaction.Tx, tenant *metadata.Tenant) (*Response, context.Context, error)

func (*CollectionQueryRunner) SetCreateOrUpdateCollectionReq 

func (runner *CollectionQueryRunner) SetCreateOrUpdateCollectionReq(create *api.CreateOrUpdateCollectionRequest)

func (*CollectionQueryRunner) SetDescribeCollectionReq 

func (runner *CollectionQueryRunner) SetDescribeCollectionReq(describe *api.DescribeCollectionRequest)

func (*CollectionQueryRunner) SetDropCollectionReq 

func (runner *CollectionQueryRunner) SetDropCollectionReq(drop *api.DropCollectionRequest)

func (*CollectionQueryRunner) SetListCollectionReq 

func (runner *CollectionQueryRunner) SetListCollectionReq(list *api.ListCollectionsRequest)

type ContentType 

type ContentType string
const (
	JSON ContentType = "application/json"
)

type DatabaseQueryRunner 

type DatabaseQueryRunner struct {
	*BaseQueryRunner
	// contains filtered or unexported fields
}

func (*DatabaseQueryRunner) Run 

func (runner *DatabaseQueryRunner) Run(ctx context.Context, tx transaction.Tx, tenant *metadata.Tenant) (*Response, context.Context, error)

func (*DatabaseQueryRunner) SetCreateDatabaseReq 

func (runner *DatabaseQueryRunner) SetCreateDatabaseReq(create *api.CreateDatabaseRequest)

func (*DatabaseQueryRunner) SetDescribeDatabaseReq 

func (runner *DatabaseQueryRunner) SetDescribeDatabaseReq(describe *api.DescribeDatabaseRequest)

func (*DatabaseQueryRunner) SetDropDatabaseReq 

func (runner *DatabaseQueryRunner) SetDropDatabaseReq(drop *api.DropDatabaseRequest)

func (*DatabaseQueryRunner) SetListDatabaseReq 

func (runner *DatabaseQueryRunner) SetListDatabaseReq(list *api.ListDatabasesRequest)

type DatabaseRowReader 

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

func MakeDatabaseRowReader 

func MakeDatabaseRowReader(ctx context.Context, tx transaction.Tx, keys []keys.Key) (*DatabaseRowReader, error)

func (*DatabaseRowReader) Err 

func (d *DatabaseRowReader) Err() error

func (*DatabaseRowReader) Next 

func (d *DatabaseRowReader) Next(_ context.Context, row *Row) bool

type Datadog 

type Datadog struct {
	config.ObservabilityConfig
}

func (Datadog) QueryTimeSeriesMetrics 

func (dd Datadog) QueryTimeSeriesMetrics(ctx context.Context, req *api.QueryTimeSeriesMetricsRequest) (*api.QueryTimeSeriesMetricsResponse, error)

type DeleteQueryRunner 

type DeleteQueryRunner struct {
	*BaseQueryRunner
	// contains filtered or unexported fields
}

func (*DeleteQueryRunner) Run 

func (runner *DeleteQueryRunner) Run(ctx context.Context, tx transaction.Tx, tenant *metadata.Tenant) (*Response, context.Context, error)

type HitsResponse 

type HitsResponse struct {
	Hits *[]tsApi.SearchResultHit
}

func NewHits 

func NewHits() *HitsResponse

func (*HitsResponse) Append 

func (h *HitsResponse) Append(hit tsApi.SearchResultHit)

func (*HitsResponse) Count 

func (h *HitsResponse) Count() int

func (*HitsResponse) GetDocument 

func (h *HitsResponse) GetDocument(idx int) (*map[string]interface{}, bool)

func (*HitsResponse) HasMoreHits 

func (h *HitsResponse) HasMoreHits(idx int) bool

type InsertQueryRunner 

type InsertQueryRunner struct {
	*BaseQueryRunner
	// contains filtered or unexported fields
}

func (*InsertQueryRunner) Run 

func (runner *InsertQueryRunner) Run(ctx context.Context, tx transaction.Tx, tenant *metadata.Tenant) (*Response, context.Context, error)

type MetricsQueryResp 

type MetricsQueryResp struct {
	FromDate int64 `json:"from_date"`
	ToDate   int64 `json:"to_date"`
	Query    string
	Series   [1]struct {
		PointList [][2]float64 `json:"pointlist"`
	}
}

type NoopTxListener 

type NoopTxListener struct{}

func (*NoopTxListener) OnPostCommit 

func (l *NoopTxListener) OnPostCommit(context.Context, *metadata.Tenant, kv.EventListener) error

func (*NoopTxListener) OnPreCommit 

func (l *NoopTxListener) OnPreCommit(context.Context, *metadata.Tenant, transaction.Tx, kv.EventListener) error

func (*NoopTxListener) OnRollback 

func (l *NoopTxListener) OnRollback(context.Context, *metadata.Tenant, kv.EventListener)

type OAuthProvider 

type OAuthProvider interface {
	GetAccessToken(request *api.GetAccessTokenRequest) (*api.GetAccessTokenResponse, error)
}

type ObservableProvider 

type ObservableProvider interface {
	QueryTimeSeriesMetrics(ctx context.Context, request *api.QueryTimeSeriesMetricsRequest) (*api.QueryTimeSeriesMetricsResponse, error)
}

type QueryRunner 

type QueryRunner interface {
	Run(ctx context.Context, tx transaction.Tx, tenant *metadata.Tenant) (*Response, context.Context, error)
}

QueryRunner is responsible for executing the current query and return the response

type QueryRunnerFactory 

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

QueryRunnerFactory is responsible for creating query runners for different queries

func NewQueryRunnerFactory 

func NewQueryRunnerFactory(txMgr *transaction.Manager, cdcMgr *cdc.Manager, searchStore search.Store) *QueryRunnerFactory

NewQueryRunnerFactory returns QueryRunnerFactory object

func (*QueryRunnerFactory) GetCollectionQueryRunner 

func (f *QueryRunnerFactory) GetCollectionQueryRunner() *CollectionQueryRunner

func (*QueryRunnerFactory) GetDatabaseQueryRunner 

func (f *QueryRunnerFactory) GetDatabaseQueryRunner() *DatabaseQueryRunner

func (*QueryRunnerFactory) GetDeleteQueryRunner 

func (f *QueryRunnerFactory) GetDeleteQueryRunner(r *api.DeleteRequest) *DeleteQueryRunner

func (*QueryRunnerFactory) GetInsertQueryRunner 

func (f *QueryRunnerFactory) GetInsertQueryRunner(r *api.InsertRequest) *InsertQueryRunner

func (*QueryRunnerFactory) GetReplaceQueryRunner 

func (f *QueryRunnerFactory) GetReplaceQueryRunner(r *api.ReplaceRequest) *ReplaceQueryRunner

func (*QueryRunnerFactory) GetSearchQueryRunner 

func (f *QueryRunnerFactory) GetSearchQueryRunner(r *api.SearchRequest, streaming SearchStreaming) *SearchQueryRunner

GetSearchQueryRunner for executing Search

func (*QueryRunnerFactory) GetStreamingQueryRunner 

func (f *QueryRunnerFactory) GetStreamingQueryRunner(r *api.ReadRequest, streaming Streaming) *StreamingQueryRunner

GetStreamingQueryRunner returns StreamingQueryRunner

func (*QueryRunnerFactory) GetSubscribeQueryRunner 

func (f *QueryRunnerFactory) GetSubscribeQueryRunner(r *api.SubscribeRequest, streaming SubscribeStreaming) *SubscribeQueryRunner

GetSubscribeQueryRunner returns SubscribeQueryRunner

func (*QueryRunnerFactory) GetUpdateQueryRunner 

func (f *QueryRunnerFactory) GetUpdateQueryRunner(r *api.UpdateRequest) *UpdateQueryRunner

type QuerySession 

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

func (*QuerySession) Commit 

func (s *QuerySession) Commit(versionMgr *metadata.VersionHandler, incVersion bool, err error) error

func (*QuerySession) Rollback 

func (s *QuerySession) Rollback() error

func (*QuerySession) Run 

func (s *QuerySession) Run(runner QueryRunner) (*Response, context.Context, error)

type ReplaceQueryRunner 

type ReplaceQueryRunner struct {
	*BaseQueryRunner
	// contains filtered or unexported fields
}

func (*ReplaceQueryRunner) Run 

func (runner *ReplaceQueryRunner) Run(ctx context.Context, tx transaction.Tx, tenant *metadata.Tenant) (*Response, context.Context, error)

type ReqOptions 

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

ReqOptions are options used by queryLifecycle to execute a query

type Response 

type Response struct {
	api.Response
	// contains filtered or unexported fields
}

Response is a wrapper on api.Response

type Row 

type Row struct {
	Key  []byte
	Data *internal.TableData
}

type RowReader 

type RowReader interface {
	Next(context.Context, *Row) bool
	Err() error
}

type SearchIndexer 

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

func NewSearchIndexer 

func NewSearchIndexer(searchStore search.Store, tenantMgr *metadata.TenantManager) *SearchIndexer

func (*SearchIndexer) OnPostCommit 

func (i *SearchIndexer) OnPostCommit(ctx context.Context, tenant *metadata.Tenant, eventListener kv.EventListener) error

func (*SearchIndexer) OnPreCommit 

func (i *SearchIndexer) OnPreCommit(context.Context, *metadata.Tenant, transaction.Tx, kv.EventListener) error

func (*SearchIndexer) OnRollback 

func (i *SearchIndexer) OnRollback(context.Context, *metadata.Tenant, kv.EventListener)

type SearchQueryRunner 

type SearchQueryRunner struct {
	*BaseQueryRunner
	// contains filtered or unexported fields
}

SearchQueryRunner is a runner used for Queries that are reads and needs to return result in streaming fashion

func (*SearchQueryRunner) Run 

func (runner *SearchQueryRunner) Run(ctx context.Context, tx transaction.Tx, tenant *metadata.Tenant) (*Response, context.Context, error)

type SearchRowReader 

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

SearchRowReader is responsible for iterating on the search results. It uses pageReader internally to read page and then iterate on documents inside hits.

func NewSearchReader 

func NewSearchReader(ctx context.Context, store search.Store, coll *schema.DefaultCollection, query *qsearch.Query) (*SearchRowReader, error)

func SinglePageSearchReader 

func SinglePageSearchReader(_ context.Context, store search.Store, coll *schema.DefaultCollection, query *qsearch.Query, pageNo int32) (*SearchRowReader, error)

func (*SearchRowReader) Err 

func (s *SearchRowReader) Err() error

func (*SearchRowReader) Next 

func (s *SearchRowReader) Next(ctx context.Context, row *Row) bool

type SearchStreaming 

type SearchStreaming interface {
	api.Tigris_SearchServer
}

type Service 

type Service interface {
	RegisterHTTP(router chi.Router, inproc *inprocgrpc.Channel) error
	RegisterGRPC(grpc *grpc.Server) error
}

func GetRegisteredServices 

func GetRegisteredServices(kvStore kv.KeyValueStore, searchStore search.Store, tenantMgr *metadata.TenantManager, txMgr *transaction.Manager) []Service

type Session 

type Session interface {
	Create(ctx context.Context, trackVerInOwnTxn bool, instantVerTracking bool, track bool) (*QuerySession, error)
	Get(ctx context.Context) (*QuerySession, error)
	Remove(ctx context.Context) error
	Execute(ctx context.Context, req *ReqOptions) (*Response, error)
	// contains filtered or unexported methods
}

type SessionManager 

type SessionManager struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func NewSessionManager 

func NewSessionManager(txMgr *transaction.Manager, tenantMgr *metadata.TenantManager, versionH *metadata.VersionHandler, listeners []TxListener, tenantTracker *metadata.CacheTracker) *SessionManager

func (*SessionManager) Create 

func (sessMgr *SessionManager) Create(ctx context.Context, trackVerInOwnTxn bool, instantVerTracking bool, track bool) (*QuerySession, error)

Create returns the QuerySession after creating all the necessary elements that a query execution needs. It first creates or get a tenant, read the metadata version and based on that reload the tenant cache and then finally create a transaction which will be used to execute all the query in this session.

func (*SessionManager) Execute 

func (sessMgr *SessionManager) Execute(ctx context.Context, req *ReqOptions) (*Response, error)

Execute is responsible to execute a query. In a way this method is managing the lifecycle of a query. For implicit transaction everything is done in this method. For explicit transaction, a session may already exist, so it only needs to run without calling Commit/Rollback.

func (*SessionManager) Get 

func (sessMgr *SessionManager) Get(ctx context.Context) (*QuerySession, error)

func (*SessionManager) Remove 

func (sessMgr *SessionManager) Remove(ctx context.Context) error

type SessionManagerWithMetrics 

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

func NewSessionManagerWithMetrics 

func NewSessionManagerWithMetrics(txMgr *transaction.Manager, tenantMgr *metadata.TenantManager, versionH *metadata.VersionHandler, listeners []TxListener, tenantTracker *metadata.CacheTracker) *SessionManagerWithMetrics

func (SessionManagerWithMetrics) Create 

func (m SessionManagerWithMetrics) Create(ctx context.Context, trackVerInOwnTxn bool, instantVerTracking bool, track bool) (qs *QuerySession, err error)

func (SessionManagerWithMetrics) Execute 

func (m SessionManagerWithMetrics) Execute(ctx context.Context, req *ReqOptions) (resp *Response, err error)

func (SessionManagerWithMetrics) Get 

func (m SessionManagerWithMetrics) Get(ctx context.Context) (qs *QuerySession, err error)

func (SessionManagerWithMetrics) Remove 

func (m SessionManagerWithMetrics) Remove(ctx context.Context) (err error)

type Streaming 

type Streaming interface {
	api.Tigris_ReadServer
}

Streaming is a wrapper interface for passing around for streaming reads

type StreamingQueryRunner 

type StreamingQueryRunner struct {
	*BaseQueryRunner
	// contains filtered or unexported fields
}

StreamingQueryRunner is a runner used for Queries that are reads and needs to return result in streaming fashion

func (*StreamingQueryRunner) Run 

func (runner *StreamingQueryRunner) Run(ctx context.Context, tx transaction.Tx, tenant *metadata.Tenant) (*Response, context.Context, error)

Run is responsible for running/executing the query

type SubscribeQueryRunner 

type SubscribeQueryRunner struct {
	*BaseQueryRunner
	// contains filtered or unexported fields
}

func (*SubscribeQueryRunner) Run 

func (runner *SubscribeQueryRunner) Run(ctx context.Context, tx transaction.Tx, tenant *metadata.Tenant) (*Response, context.Context, error)

type SubscribeStreaming 

type SubscribeStreaming interface {
	api.Tigris_SubscribeServer
}

type TxListener 

type TxListener interface {
	// OnPreCommit is called before committing the transaction. This means this method is useful when an operation needs
	// to guarantee transaction atomicity. Error returned by this method will roll back the user transaction.
	OnPreCommit(context.Context, *metadata.Tenant, transaction.Tx, kv.EventListener) error
	// OnPostCommit is called after committing the transaction. This means the transaction is complete and any post
	// activity can happen as part of this implementation.
	OnPostCommit(context.Context, *metadata.Tenant, kv.EventListener) error
	// OnRollback is called when the user transaction is rolled back.
	OnRollback(context.Context, *metadata.Tenant, kv.EventListener)
}

TxListener allows listening to a transaction outcome and process the events that is passed in the param accordingly.

type UpdateQueryRunner 

type UpdateQueryRunner struct {
	*BaseQueryRunner
	// contains filtered or unexported fields
}

func (*UpdateQueryRunner) Run 

func (runner *UpdateQueryRunner) Run(ctx context.Context, tx transaction.Tx, tenant *metadata.Tenant) (*Response, context.Context, error)

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.