tabletserver

package
v0.0.0-...-444a4ab Latest Latest
Warning

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

 Go to latest Published: Feb 14, 2015 License: BSD-3-Clause Imports: 52 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	QR_CONTINUE = Action(iota)
	QR_FAIL
	QR_FAIL_RETRY
)
View Source 
const (
	QR_NOOP = Operator(iota)
	QR_EQ
	QR_NE
	QR_LT
	QR_GE
	QR_GT
	QR_LE
	QR_MATCH
	QR_NOMATCH
	QR_IN
	QR_NOTIN
)
View Source 
const (
	QR_OK = iota
	QR_MISMATCH
	QR_OUT_OF_RANGE
)
View Source 
const (
	RC_DELETED = 1

	// MAX_KEY_LEN is a value less than memcache's limit of 250.
	MAX_KEY_LEN = 200

	// MAX_DATA_LEN prevents large rows from being inserted in rowcache.
	MAX_DATA_LEN = 8000
)
View Source 
const (
	// Allowed state transitions:
	// NOT_SERVING -> INITIALIZING -> SERVING/NOT_SERVING,
	// SERVING -> SHUTTING_TX
	// SHUTTING_TX -> SHUTTING_QUERIES
	// SHUTTING_QUERIES -> NOT_SERVING
	//
	// NOT_SERVING: The query service is not serving queries.
	NOT_SERVING = iota
	// INITIALIZING: The query service is tyring to get to the SERVING state.
	// This is a transient state. It's only informational.
	INITIALIZING
	// SERVING: Query service is running. Everything is allowed.
	SERVING
	// SHUTTING_TX: Query service is shutting down and has disallowed
	// new transactions. New queries are still allowed as long as they
	// are part of an existing transaction. We remain in this state
	// until all existing transactions are completed.
	SHUTTING_TX
	// SHUTTING_QUERIES: Query service is shutting down and has disallowed
	// new queries. This state follows SHUTTING_TX. We enter this state
	// after all existing transactions have completed. We remain in this
	// state until all existing queries are completed. The next state
	// after this is NOT_SERVING.
	SHUTTING_QUERIES
)
View Source 
const (
	QUERY_SOURCE_ROWCACHE = 1 << iota
	QUERY_SOURCE_CONSOLIDATOR
	QUERY_SOURCE_MYSQL
)
View Source 
const (
	// ErrFail is returned when a query fails
	ErrFail = iota

	// ErrRetry is returned when a query can be retried
	ErrRetry

	// ErrFatal is returned when a query cannot be retried
	ErrFatal

	// ErrTxPoolFull is returned when we can't get a connection
	ErrTxPoolFull

	// ErrNotInTx is returned when we're not in a transaction but should be
	ErrNotInTx
)
View Source 
const (
	TX_CLOSE    = "close"
	TX_COMMIT   = "commit"
	TX_ROLLBACK = "rollback"
	TX_KILL     = "kill"
)
View Source 
const TRAILING_COMMENT = "_trailingComment"

Variables

View Source 
var (
	BEGIN    = "begin"
	COMMIT   = "commit"
	ROLLBACK = "rollback"
)
View Source 
var DefaultQsConfig = Config{
	PoolSize:           16,
	StreamPoolSize:     750,
	TransactionCap:     20,
	TransactionTimeout: 30,
	MaxResultSize:      10000,
	MaxDMLRows:         500,
	QueryCacheSize:     5000,
	SchemaReloadTime:   30 * 60,
	QueryTimeout:       0,
	TxPoolTimeout:      1,
	IdleTimeout:        30 * 60,
	StreamBufferSize:   32 * 1024,
	RowCache:           RowCacheConfig{Memory: -1, TcpPort: -1, Connections: -1, Threads: -1},
	SpotCheckRatio:     0,
	StrictMode:         true,
	StrictTableAcl:     false,
}

DefaultQSConfig is the default value for the query service config.

The value for StreamBufferSize was chosen after trying out a few of them. Too small buffers force too many packets to be sent. Too big buffers force the clients to read them in multiple chunks and make memory copies. so with the encoding overhead, this seems to work great (the overhead makes the final packets on the wire about twice bigger than this).

View Source 
var (
	// ErrConnPoolClosed is returned / panicked when the
	// connection pool is closed.
	ErrConnPoolClosed = errors.New("connection pool is closed")
)
View Source 
var QueryRuleSources = NewQueryRuleInfo()

Global variable to keep track of every registered query rule source

View Source 
var QueryServiceControlRegisterFunctions []QueryServiceControlRegisterFunction

QueryServiceControlRegisterFunctions is an array of all the QueryServiceControlRegisterFunction that will be called upon Register() on a QueryServiceControl

View Source 
var SqlQueryLogger = streamlog.New("SqlQuery", 50)
View Source 
var TimeoutErr = errors.New("timed out")
View Source 
var TxLogger = streamlog.New("TxLog", 10)

TxLogger can be used to enable logging of transactions. Call TxLogger.ServeLogs in your main program to enable logging. The log format can be inferred by looking at TxConnection.Format.

Functions

func Commit 

func Commit(logStats *SQLQueryStats, qe *QueryEngine, transactionID int64)

Commit commits the specified transaction.

func InitQueryService 

func InitQueryService(qsc QueryServiceControl)

InitQueryService registers the query service, after loading any necessary config files. It also starts any relevant streaming logs.

func IsConnErr 

func IsConnErr(err error) bool

IsConnErr returns true if the error is a connection error. If the error is of type TabletError or hasNumber, it checks the error code. Otherwise, it parses the string looking for (errno xxxx) and uses the extracted value to determine if it's a conn error.

func Rand 

func Rand() int64

Rand generates a pseudo-random int64 number.

Types

type Action 

type Action int

Action speficies the list of actions to perform when a QueryRule is triggered.

type BindVarCond 

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

BindVarCond represents a bind var condition.

type CacheInvalidator 

type CacheInvalidator interface {
	Delete(key string)
}

CacheInvalidator provides the abstraction needed for an instant invalidation vs. delayed invalidation in the case of in-transaction dmls

type CachePool 

type CachePool struct {
	DeleteExpiry uint64
	// contains filtered or unexported fields
}

CachePool re-exposes ResourcePool as a pool of Memcache connection objects.

func NewCachePool 

func NewCachePool(name string, rowCacheConfig RowCacheConfig, queryTimeout time.Duration, idleTimeout time.Duration) *CachePool

func (*CachePool) Available 

func (cp *CachePool) Available() int64

func (*CachePool) Capacity 

func (cp *CachePool) Capacity() int64

func (*CachePool) Close 

func (cp *CachePool) Close()

func (*CachePool) Get 

func (cp *CachePool) Get(timeout time.Duration) *memcache.Connection

You must call Put after Get.

func (*CachePool) IdleTimeout 

func (cp *CachePool) IdleTimeout() time.Duration

func (*CachePool) IsClosed 

func (cp *CachePool) IsClosed() bool

func (*CachePool) MaxCap 

func (cp *CachePool) MaxCap() int64

func (*CachePool) Open 

func (cp *CachePool) Open()

func (*CachePool) Put 

func (cp *CachePool) Put(conn *memcache.Connection)

func (*CachePool) ServeHTTP 

func (cp *CachePool) ServeHTTP(response http.ResponseWriter, request *http.Request)

func (*CachePool) StatsJSON 

func (cp *CachePool) StatsJSON() string

func (*CachePool) WaitCount 

func (cp *CachePool) WaitCount() int64

func (*CachePool) WaitTime 

func (cp *CachePool) WaitTime() time.Duration

type Config 

type Config struct {
	PoolSize           int
	StreamPoolSize     int
	TransactionCap     int
	TransactionTimeout float64
	MaxResultSize      int
	MaxDMLRows         int
	StreamBufferSize   int
	QueryCacheSize     int
	SchemaReloadTime   float64
	QueryTimeout       float64
	TxPoolTimeout      float64
	IdleTimeout        float64
	RowCache           RowCacheConfig
	SpotCheckRatio     float64
	StrictMode         bool
	StrictTableAcl     bool
}

Config contains all the configuration for query service

type ConnPool 

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

ConnPool implements a custom connection pool for tabletserver. It's similar to dbconnpool.ConnPool, but the connections it creates come with built-in ability to kill in-flight queries. These connections also trigger a CheckMySQL call if we fail to connect to MySQL. Other than the connection type, ConnPool maintains an additional pool of dba connections that are used to kill connections.

func NewConnPool 

func NewConnPool(name string, capacity int, idleTimeout time.Duration) *ConnPool

NewConnPool creates a new ConnPool. The name is used to publish stats only.

func (*ConnPool) Available 

func (cp *ConnPool) Available() int64

Available returns the number of available connections in the pool

func (*ConnPool) Capacity 

func (cp *ConnPool) Capacity() int64

Capacity returns the pool capacity.

func (*ConnPool) Close 

func (cp *ConnPool) Close()

Close will close the pool and wait for connections to be returned before exiting.

func (*ConnPool) Get 

func (cp *ConnPool) Get(timeout time.Duration) (*DBConn, error)

Get returns a connection. You must call Recycle on DBConn once done.

func (*ConnPool) IdleTimeout 

func (cp *ConnPool) IdleTimeout() time.Duration

IdleTimeout returns the idle timeout for the pool.

func (*ConnPool) MaxCap 

func (cp *ConnPool) MaxCap() int64

MaxCap returns the maximum size of the pool

func (*ConnPool) Open 

func (cp *ConnPool) Open(appParams, dbaParams *mysql.ConnectionParams)

Open must be called before starting to use the pool.

func (*ConnPool) Put 

func (cp *ConnPool) Put(conn *DBConn)

Put puts a connection into the pool.

func (*ConnPool) SetCapacity 

func (cp *ConnPool) SetCapacity(capacity int) (err error)

SetCapacity alters the size of the pool at runtime.

func (*ConnPool) SetIdleTimeout 

func (cp *ConnPool) SetIdleTimeout(idleTimeout time.Duration)

SetIdleTimeout sets the idleTimeout on the pool.

func (*ConnPool) StatsJSON 

func (cp *ConnPool) StatsJSON() string

StatsJSON returns the pool stats as a JSOn object.

func (*ConnPool) TryGet 

func (cp *ConnPool) TryGet() (*DBConn, error)

TryGet returns a connection, or nil. You must call Recycle on the DBConn once done.

func (*ConnPool) WaitCount 

func (cp *ConnPool) WaitCount() int64

WaitCount returns how many clients are waiting for a connection

func (*ConnPool) WaitTime 

func (cp *ConnPool) WaitTime() time.Duration

WaitTime return the pool WaitTime.

type Consolidator 

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

Consolidator consolidates duplicate queries from executing simulaneously and shares results between them.

func NewConsolidator 

func NewConsolidator() *Consolidator

NewConsolidator creates a new Consolidator

func (*Consolidator) Create 

func (co *Consolidator) Create(sql string) (r *Result, created bool)

Create adds a query to currently executing queries and acquires a lock on its Result if it is not already present. If the query is a duplicate, Create returns false.

func (*Consolidator) ServeHTTP 

func (co *Consolidator) ServeHTTP(response http.ResponseWriter, request *http.Request)

type CreateCacheFunc 

type CreateCacheFunc func() (*memcache.Connection, error)

type DBConn 

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

DBConn is a db connection for tabletserver. It performs automatic reconnects as needed. Its Execute function has a timeout that can kill its own queries and the underlying connection. It will also trigger a CheckMySQL whenever applicable.

func NewDBConn 

func NewDBConn(cp *ConnPool, appParams, dbaParams *mysql.ConnectionParams) (*DBConn, error)

NewDBConn creates a new DBConn. It triggers a CheckMySQL if creation fails.

func (*DBConn) Close 

func (dbc *DBConn) Close()

Close closes the DBConn.

func (*DBConn) Current 

func (dbc *DBConn) Current() string

Current returns the currently executing query.

func (*DBConn) Exec 

func (dbc *DBConn) Exec(query string, maxrows int, wantfields bool, deadline Deadline) (*mproto.QueryResult, error)

Exec executes the specified query. If there is a connection error, it will reconnect and retry. A failed reconnect will trigger a CheckMySQL.

func (*DBConn) ID 

func (dbc *DBConn) ID() int64

ID returns the connection id.

func (*DBConn) IsClosed 

func (dbc *DBConn) IsClosed() bool

IsClosed returns true if DBConn is closed.

func (*DBConn) Kill 

func (dbc *DBConn) Kill()

Kill kills the currently executing query both on MySQL side and on the connection side. If no query is executing, it's a no-op. Kill will also not kill a query more than once.

func (*DBConn) Recycle 

func (dbc *DBConn) Recycle()

Recycle returns the DBConn to the pool.

func (*DBConn) Stream 

func (dbc *DBConn) Stream(query string, callback func(*mproto.QueryResult) error, streamBufferSize int) error

Stream executes the query and streams the results.

func (*DBConn) VerifyStrict 

func (dbc *DBConn) VerifyStrict() bool

VerifyStrict returns true if MySQL is in STRICT mode.

type Deadline 

type Deadline time.Time

Deadline supports deadline oriented convenience functions.

func NewDeadline 

func NewDeadline(timeout time.Duration) Deadline

NewDeadline creates a deadline using the specified timeout. If the timeout is 0, then the deadline is a zero value.

func (Deadline) Timeout 

func (dl Deadline) Timeout() (time.Duration, error)

Timeout returns the timeout based on the current time. If the computed timeout is less than 10ms, it returns a TimeoutErr. If deadline is a zero value, it returns a timeout of 0.

type DirtyKeys 

type DirtyKeys map[string]bool

func (DirtyKeys) Delete 

func (dk DirtyKeys) Delete(key string)

Delete just keeps track of what needs to be deleted

type ExecPlan 

type ExecPlan struct {
	*planbuilder.ExecPlan
	TableInfo  *TableInfo
	Fields     []mproto.Field
	Rules      *QueryRules
	Authorized tableacl.ACL

	QueryCount int64
	Time       time.Duration
	RowCount   int64
	ErrorCount int64
	// contains filtered or unexported fields
}

func (*ExecPlan) AddStats 

func (ep *ExecPlan) AddStats(queryCount int64, duration time.Duration, rowCount, errorCount int64)

func (*ExecPlan) Size 

func (*ExecPlan) Size() int

func (*ExecPlan) Stats 

func (ep *ExecPlan) Stats() (queryCount int64, duration time.Duration, rowCount, errorCount int64)

type MemcacheStats 

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

MemcacheStats exports the Memcache internal stats through stats package.

func NewMemcacheStats 

func NewMemcacheStats(cachePool *CachePool, main, slabs, items bool) *MemcacheStats

NewMemcacheStats creates a new MemcacheStats based on given CachePool. main, slabs and items specify the categories of stats that need to be exported.

func (*MemcacheStats) Close 

func (s *MemcacheStats) Close()

Close clears the variable values and stops exporting the stats.

func (*MemcacheStats) Open 

func (s *MemcacheStats) Open()

Open starts exporting the stats.

type Operator 

type Operator int

Operator represents the list of operators.

func MapStrOperator 

func MapStrOperator(strop string) (op Operator, err error)

type PoolConn 

type PoolConn interface {
	Exec(query string, maxrows int, wantfields bool, deadline Deadline) (*mproto.QueryResult, error)
}

PoolConn is the interface implemented by users of this specialized pool.

type QueryDetail 

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

QueryDetail is a simple wrapper for Query, Context and a killable conn.

func NewQueryDetail 

func NewQueryDetail(context context.Context, conn killable) *QueryDetail

NewQueryDetail creates a new QueryDetail

type QueryDetailzRow 

type QueryDetailzRow struct {
	Query             string
	ContextHTML       template.HTML
	Start             time.Time
	Duration          time.Duration
	ConnID            int64
	State             string
	ShowTerminateLink bool
}

QueryDetailzRow is used for rendering QueryDetail in a template

type QueryEngine 

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

QueryEngine implements the core functionality of tabletserver. It assumes that no requests will be sent to it before Open is called and succeeds. Shutdown is done in the following order:

WaitForTxEmpty: There should be no more new calls to Begin once this function is called. This will return when there are no more pending transactions.

Close: There should be no more pending queries when this function is called.

Functions of QueryEngine do not return errors. They instead panic with NewTabletError as the error type. TODO(sougou): Switch to error return scheme.

func NewQueryEngine 

func NewQueryEngine(config Config) *QueryEngine

NewQueryEngine creates a new QueryEngine. This is a singleton class. You must call this only once.

func (*QueryEngine) CheckMySQL 

func (qe *QueryEngine) CheckMySQL() bool

CheckMySQL returns true if we can connect to MySQL.

func (*QueryEngine) Close 

func (qe *QueryEngine) Close()

Close must be called to shut down QueryEngine. You must ensure that no more queries will be sent before calling Close.

func (*QueryEngine) Launch 

func (qe *QueryEngine) Launch(f func())

Launch launches the specified function inside a goroutine. If Close or WaitForTxEmpty is called while a goroutine is running, QueryEngine will not return until the existing functions have completed. This functionality allows us to launch tasks with the assurance that the QueryEngine will not be closed underneath us.

func (*QueryEngine) Open 

func (qe *QueryEngine) Open(dbconfigs *dbconfigs.DBConfigs, schemaOverrides []SchemaOverride, mysqld *mysqlctl.Mysqld)

Open must be called before sending requests to QueryEngine.

func (*QueryEngine) WaitForTxEmpty 

func (qe *QueryEngine) WaitForTxEmpty()

WaitForTxEmpty must be called before calling Close. Before calling WaitForTxEmpty, you must ensure that there will be no more calls to Begin.

type QueryExecutor 

type QueryExecutor struct {
	RequestContext
	// contains filtered or unexported fields
}

QueryExecutor is used for executing a query request.

func (*QueryExecutor) Execute 

func (qre *QueryExecutor) Execute() (reply *mproto.QueryResult)

Execute performs a non-streaming query execution.

func (*QueryExecutor) Stream 

func (qre *QueryExecutor) Stream(sendReply func(*mproto.QueryResult) error)

Stream performs a streaming query execution.

type QueryList 

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

QueryList holds a thread safe list of QueryDetails

func NewQueryList 

func NewQueryList() *QueryList

NewQueryList creates a new QueryList

func (*QueryList) Add 

func (ql *QueryList) Add(qd *QueryDetail)

Add adds a QueryDetail to QueryList

func (*QueryList) GetQueryzRows 

func (ql *QueryList) GetQueryzRows() []QueryDetailzRow

GetQueryzRows returns a list of QueryDetailzRow sorted by start time

func (*QueryList) Remove 

func (ql *QueryList) Remove(qd *QueryDetail)

Remove removes a QueryDetail from QueryList

func (*QueryList) Terminate 

func (ql *QueryList) Terminate(connID int64) error

Terminate updates the query status and kills the connection

func (*QueryList) TerminateAll 

func (ql *QueryList) TerminateAll()

TerminateAll terminates all queries and kills the MySQL connections

type QueryRule 

type QueryRule struct {
	Description string
	Name        string
	// contains filtered or unexported fields
}

QueryRule represents one rule (conditions-action). Name is meant to uniquely identify a rule. Description is a human readable comment that describes the rule. For a QueryRule to fire, all conditions of the QueryRule have to match. For example, an empty QueryRule will match all requests. Every QueryRule has an associated Action. If all the conditions of the QueryRule are met, then the Action is triggerred.

func BuildQueryRule 

func BuildQueryRule(ruleInfo map[string]interface{}) (qr *QueryRule, err error)

func NewQueryRule 

func NewQueryRule(description, name string, act Action) (qr *QueryRule)

NewQueryRule creates a new QueryRule.

func (*QueryRule) AddBindVarCond 

func (qr *QueryRule) AddBindVarCond(name string, onAbsent, onMismatch bool, op Operator, value interface{}) error

AddBindVarCond adds a bind variable restriction to the QueryRule. All bind var conditions have to be satisfied for the QueryRule to be a match. name represents the name (not regexp) of the bind variable. onAbsent specifies the value of the condition if the bind variable is absent. onMismatch specifies the value of the condition if there's a type mismatch on the condition. For inequalities, the bindvar is the left operand and the value in the condition is the right operand: bindVar Operator value. Value & operator rules Type Operators Bindvar nil NOOP any type uint64 EQ, NE, LT, GE, GT, LE whole numbers int64 EQ, NE, LT, GE, GT, LE whole numbers string EQ, NE, LT, GE, GT, LE, MATCH, NOMATCH []byte, string KeyRange IN, NOTIN whole numbers whole numbers can be: int, int8, int16, int32, int64, uint64

func (*QueryRule) AddPlanCond 

func (qr *QueryRule) AddPlanCond(planType planbuilder.PlanType)

AddPlanCond adds to the list of plans that can be matched for the rule to fire. This function acts as an OR: Any plan id match is considered a match.

func (*QueryRule) AddTableCond 

func (qr *QueryRule) AddTableCond(tableName string)

AddTableCond adds to the list of tableNames that can be matched for the rule to fire. This function acts as an OR: Any tableName match is considered a match.

func (*QueryRule) Copy 

func (qr *QueryRule) Copy() (newqr *QueryRule)

Copy performs a deep copy of a QueryRule.

func (*QueryRule) SetIPCond 

func (qr *QueryRule) SetIPCond(pattern string) (err error)

SetIPCond adds a regular expression condition for the client IP. It has to be a full match (not substring).

func (*QueryRule) SetQueryCond 

func (qr *QueryRule) SetQueryCond(pattern string) (err error)

SetQueryCond adds a regular expression condition for the query.

func (*QueryRule) SetUserCond 

func (qr *QueryRule) SetUserCond(pattern string) (err error)

SetUserCond adds a regular expression condition for the user name used by the client.

type QueryRuleInfo 

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

QueryRuleInfo is the maintainer of QueryRules from multiple sources

func NewQueryRuleInfo 

func NewQueryRuleInfo() *QueryRuleInfo

NewQueryRuleInfo returns an empty QueryRuleInfo object for use

func (*QueryRuleInfo) GetRules 

func (qri *QueryRuleInfo) GetRules(ruleSource string) (*QueryRules, error)

GetRules returns the corresponding QueryRules as designated by ruleSource parameter

func (*QueryRuleInfo) RegisterQueryRuleSource 

func (qri *QueryRuleInfo) RegisterQueryRuleSource(ruleSource string)

RegisterQueryRuleSource registers a query rule source name with QueryRuleInfo

func (*QueryRuleInfo) SetRules 

func (qri *QueryRuleInfo) SetRules(ruleSource string, newRules *QueryRules) error

SetRules takes an external QueryRules structure and overwrite one of the internal QueryRules as designated by ruleSource parameter

type QueryRules 

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

QueryRules is used to store and execute rules for the tabletserver.

func NewQueryRules 

func NewQueryRules() *QueryRules

NewQueryRules creates a new QueryRules.

func (*QueryRules) Add 

func (qrs *QueryRules) Add(qr *QueryRule)

Add adds a QueryRule to QueryRules. It does not check for duplicates.

func (*QueryRules) Append 

func (qrs *QueryRules) Append(otherqrs *QueryRules)

Append merges the rules from another QueryRules into the receiver

func (*QueryRules) Copy 

func (qrs *QueryRules) Copy() (newqrs *QueryRules)

Copy performs a deep copy of QueryRules. A nil input produces a nil output.

func (*QueryRules) Delete 

func (qrs *QueryRules) Delete(name string) (qr *QueryRule)

Delete deletes a QueryRule by name and returns the rule that was deleted. It returns nil if the rule was not found.

func (*QueryRules) Find 

func (qrs *QueryRules) Find(name string) (qr *QueryRule)

Find finds the first occurrence of a QueryRule by matching the Name field. It returns nil if the rule was not found.

func (*QueryRules) UnmarshalJSON 

func (qrs *QueryRules) UnmarshalJSON(data []byte) (err error)

type QueryServiceControl 

type QueryServiceControl interface {
	// Register registers this query service with the RPC layer.
	Register()

	// AddStatusPart adds the status part to the status page
	AddStatusPart()

	// AllowQueries enables queries.
	AllowQueries(*dbconfigs.DBConfigs, []SchemaOverride, *mysqlctl.Mysqld) error

	// DisallowQueries shuts down the query service.
	DisallowQueries()

	// IsServing returns true if the query service is running
	IsServing() bool

	// IsHealthy returns the health status of the QueryService
	IsHealthy() error

	// ReloadSchema makes the quey service reload its schema cache
	ReloadSchema()

	// SetQueryRules sets the query rules for this QueryService
	SetQueryRules(ruleSource string, qrs *QueryRules) error

	// SqlQuery returns the SqlQuery object used by this QueryServiceControl
	SqlQuery() *SqlQuery
}

QueryServiceControl is the interface implemented by the controller for the query service.

func NewQueryServiceControl 

func NewQueryServiceControl() QueryServiceControl

NewQueryServiceControl returns a real implementation of QueryServiceControl

type QueryServiceControlRegisterFunction 

type QueryServiceControlRegisterFunction func(QueryServiceControl)

QueryServiceControlRegisterFunction is a callback type to be called when we Register() a QueryServiceControl

type QuerySplitter 

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

QuerySplitter splits a BoundQuery into equally sized smaller queries. QuerySplits are generated by adding primary key range clauses to the original query. Only a limited set of queries are supported, see QuerySplitter.validateQuery() for details. Also, the table must have at least one primary key and the leading primary key must be numeric, see QuerySplitter.getSplitBoundaries()

func NewQuerySplitter 

func NewQuerySplitter(query *proto.BoundQuery, splitCount int, schemaInfo *SchemaInfo) *QuerySplitter

NewQuerySplitter creates a new QuerySplitter. query is the original query to split and splitCount is the desired number of splits. splitCount must be a positive int, if not it will be set to 1.

type RCResult 

type RCResult struct {
	Row []sqltypes.Value
	Cas uint64
}

type RequestContext 

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

RequestContext encapsulates a context and associated variables for a request

type Result 

type Result struct {
	Result *proto.QueryResult
	Err    error
	// contains filtered or unexported fields
}

Result is a wrapper for QueryResult of a query.

func (*Result) Broadcast 

func (rs *Result) Broadcast()

Broadcast removes the entry from current queries and releases the lock on its Result. Broadcast should be invoked when original query completes execution.

func (*Result) Wait 

func (rs *Result) Wait()

Wait waits for the original query to complete execution. Wait should be invoked for duplicate queries.

type RowCache 

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

func NewRowCache 

func NewRowCache(tableInfo *TableInfo, cachePool *CachePool) *RowCache

func (*RowCache) Delete 

func (rc *RowCache) Delete(key string)

func (*RowCache) Get 

func (rc *RowCache) Get(keys []string) (results map[string]RCResult)

func (*RowCache) Set 

func (rc *RowCache) Set(key string, row []sqltypes.Value, cas uint64)

type RowCacheConfig 

type RowCacheConfig struct {
	Binary      string
	Memory      int
	Socket      string
	TcpPort     int
	Connections int
	Threads     int
	LockPaged   bool
}

RowCacheConfig encapsulates the configuration for RowCache

func (*RowCacheConfig) GetSubprocessFlags 

func (c *RowCacheConfig) GetSubprocessFlags() []string

GetSubprocessFlags returns the flags to use to call memcached

type RowcacheInvalidator 

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

RowcacheInvalidator runs the service to invalidate the rowcache based on binlog events.

func NewRowcacheInvalidator 

func NewRowcacheInvalidator(qe *QueryEngine) *RowcacheInvalidator

NewRowcacheInvalidator creates a new RowcacheInvalidator. Just like QueryEngine, this is a singleton class. You must call this only once.

func (*RowcacheInvalidator) AppendGTID 

func (rci *RowcacheInvalidator) AppendGTID(gtid myproto.GTID)

AppendGTID updates the current replication position by appending a GTID to the set of transactions that have been processed.

func (*RowcacheInvalidator) Close 

func (rci *RowcacheInvalidator) Close()

Close terminates the invalidation loop. It returns only of the loop has terminated.

func (*RowcacheInvalidator) Open 

func (rci *RowcacheInvalidator) Open(dbname string, mysqld *mysqlctl.Mysqld)

Open runs the invalidation loop.

func (*RowcacheInvalidator) Position 

func (rci *RowcacheInvalidator) Position() myproto.ReplicationPosition

Position returns the current ReplicationPosition.

func (*RowcacheInvalidator) PositionString 

func (rci *RowcacheInvalidator) PositionString() string

PositionString returns the current ReplicationPosition as a string.

func (*RowcacheInvalidator) SetPosition 

func (rci *RowcacheInvalidator) SetPosition(rp myproto.ReplicationPosition)

SetPosition sets the current ReplicationPosition.

type SQLQueryStats 

type SQLQueryStats struct {
	Method        string
	PlanType      string
	OriginalSql   string
	BindVariables map[string]interface{}

	RowsAffected         int
	NumberOfQueries      int
	StartTime            time.Time
	EndTime              time.Time
	MysqlResponseTime    time.Duration
	WaitingForConnection time.Duration
	CacheHits            int64
	CacheAbsent          int64
	CacheMisses          int64
	CacheInvalidations   int64
	QuerySources         byte
	Rows                 [][]sqltypes.Value
	TransactionID        int64

	Error error
	// contains filtered or unexported fields
}

func (*SQLQueryStats) AddRewrittenSql 

func (stats *SQLQueryStats) AddRewrittenSql(sql string, start time.Time)

func (*SQLQueryStats) ContextHTML 

func (log *SQLQueryStats) ContextHTML() template.HTML

func (*SQLQueryStats) ErrorStr 

func (log *SQLQueryStats) ErrorStr() string

func (*SQLQueryStats) FmtBindVariables 

func (stats *SQLQueryStats) FmtBindVariables(full bool) string

FmtBindVariables returns the map of bind variables as JSON. For values that are strings or byte slices it only reports their type and length.

func (*SQLQueryStats) FmtQuerySources 

func (stats *SQLQueryStats) FmtQuerySources() string

FmtQuerySources returns a comma separated list of query sources. If there were no query sources, it returns the string "none".

func (*SQLQueryStats) Format 

func (log *SQLQueryStats) Format(params url.Values) string

String returns a tab separated list of logged fields.

func (*SQLQueryStats) RemoteAddr 

func (log *SQLQueryStats) RemoteAddr() string

func (*SQLQueryStats) RewrittenSql 

func (stats *SQLQueryStats) RewrittenSql() string

RewrittenSql returns a semicolon separated list of SQL statements that were executed.

func (*SQLQueryStats) Send 

func (stats *SQLQueryStats) Send()

func (*SQLQueryStats) SizeOfResponse 

func (stats *SQLQueryStats) SizeOfResponse() int

SizeOfResponse returns the approximate size of the response in bytes (this does not take in account BSON encoding). It will return 0 for streaming requests.

func (*SQLQueryStats) TotalTime 

func (stats *SQLQueryStats) TotalTime() time.Duration

func (*SQLQueryStats) Username 

func (log *SQLQueryStats) Username() string

type SchemaInfo 

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

func NewSchemaInfo 

func NewSchemaInfo(queryCacheSize int, reloadTime time.Duration, idleTimeout time.Duration) *SchemaInfo

func (*SchemaInfo) ClearQueryPlanCache 

func (si *SchemaInfo) ClearQueryPlanCache()

ClearQueryPlanCache should be called if query plan cache is potentially obsolete

func (*SchemaInfo) Close 

func (si *SchemaInfo) Close()

func (*SchemaInfo) CreateOrUpdateTable 

func (si *SchemaInfo) CreateOrUpdateTable(tableName string)

func (*SchemaInfo) DropTable 

func (si *SchemaInfo) DropTable(tableName string)

func (*SchemaInfo) GetPlan 

func (si *SchemaInfo) GetPlan(logStats *SQLQueryStats, sql string) *ExecPlan

func (*SchemaInfo) GetSchema 

func (si *SchemaInfo) GetSchema() []*schema.Table

func (*SchemaInfo) GetStreamPlan 

func (si *SchemaInfo) GetStreamPlan(sql string) *ExecPlan

GetStreamPlan is similar to GetPlan, but doesn't use the cache and doesn't enforce a limit. It just returns the parsed query.

func (*SchemaInfo) GetTable 

func (si *SchemaInfo) GetTable(tableName string) *TableInfo

func (*SchemaInfo) Open 

func (si *SchemaInfo) Open(appParams, dbaParams *mysql.ConnectionParams, schemaOverrides []SchemaOverride, cachePool *CachePool, strictMode bool)

func (*SchemaInfo) Reload 

func (si *SchemaInfo) Reload()

func (*SchemaInfo) ServeHTTP 

func (si *SchemaInfo) ServeHTTP(response http.ResponseWriter, request *http.Request)

func (*SchemaInfo) SetQueryCacheSize 

func (si *SchemaInfo) SetQueryCacheSize(size int)

func (*SchemaInfo) SetReloadTime 

func (si *SchemaInfo) SetReloadTime(reloadTime time.Duration)

type SchemaOverride 

type SchemaOverride struct {
	Name      string
	PKColumns []string
	Cache     *struct {
		Type   string
		Prefix string
		Table  string
	}
}

type SqlQuery 

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

SqlQuery implements the RPC interface for the query service.

func NewSqlQuery 

func NewSqlQuery(config Config) *SqlQuery

NewSqlQuery creates an instance of SqlQuery. Only one instance of SqlQuery can be created per process.

func (*SqlQuery) Begin 

func (sq *SqlQuery) Begin(context context.Context, session *proto.Session, txInfo *proto.TransactionInfo) (err error)

Begin starts a new transaction. This is allowed only if the state is SERVING.

func (*SqlQuery) Commit 

func (sq *SqlQuery) Commit(context context.Context, session *proto.Session) (err error)

Commit commits the specified transaction.

func (*SqlQuery) Execute 

func (sq *SqlQuery) Execute(context context.Context, query *proto.Query, reply *mproto.QueryResult) (err error)

Execute executes the query and returns the result as response.

func (*SqlQuery) ExecuteBatch 

func (sq *SqlQuery) ExecuteBatch(context context.Context, queryList *proto.QueryList, reply *proto.QueryResultList) (err error)

ExecuteBatch executes a group of queries and returns their results as a list. ExecuteBatch can be called for an existing transaction, or it can also begin its own transaction, in which case it's expected to commit it also.

func (*SqlQuery) GetSessionId 

func (sq *SqlQuery) GetSessionId(sessionParams *proto.SessionParams, sessionInfo *proto.SessionInfo) error

GetSessionId returns a sessionInfo response if the state is SERVING.

func (*SqlQuery) GetState 

func (sq *SqlQuery) GetState() string

GetState returns the name of the current SqlQuery state.

func (*SqlQuery) Rollback 

func (sq *SqlQuery) Rollback(context context.Context, session *proto.Session) (err error)

Rollback rollsback the specified transaction.

func (*SqlQuery) SplitQuery 

func (sq *SqlQuery) SplitQuery(context context.Context, req *proto.SplitQueryRequest, reply *proto.SplitQueryResult) error

SplitQuery splits a BoundQuery into smaller queries that return a subset of rows from the original query.

func (*SqlQuery) StreamExecute 

func (sq *SqlQuery) StreamExecute(context context.Context, query *proto.Query, sendReply func(*mproto.QueryResult) error) (err error)

StreamExecute executes the query and streams the result. The first QueryResult will have Fields set (and Rows nil). The subsequent QueryResult will have Rows set (and Fields nil).

type TableInfo 

type TableInfo struct {
	*schema.Table
	Cache *RowCache
	// contains filtered or unexported fields
}

func NewTableInfo 

func NewTableInfo(conn *DBConn, tableName string, tableType string, createTime sqltypes.Value, comment string, cachePool *CachePool) (ti *TableInfo, err error)

func (*TableInfo) SetPK 

func (ti *TableInfo) SetPK(colnames []string) error

func (*TableInfo) Stats 

func (ti *TableInfo) Stats() (hits, absent, misses, invalidations int64)

func (*TableInfo) StatsJSON 

func (ti *TableInfo) StatsJSON() string

type TabletError 

type TabletError struct {
	ErrorType int
	Message   string
	SqlError  int
}

TabletError is the erro type we use in this library

func NewTabletError 

func NewTabletError(errorType int, format string, args ...interface{}) *TabletError

NewTabletError returns a TabletError of the given type

func NewTabletErrorSql 

func NewTabletErrorSql(errorType int, err error) *TabletError

NewTabletErrorSql returns a TabletError based on the error

func (*TabletError) Error 

func (te *TabletError) Error() string

func (*TabletError) RecordStats 

func (te *TabletError) RecordStats()

RecordStats will record the error in the proper stat bucket

type TestQueryServiceControl 

type TestQueryServiceControl struct {
	// QueryServiceEnabled is a state variable
	QueryServiceEnabled bool

	// AllowQueriesError is the return value for AllowQueries
	AllowQueriesError error

	// IsHealthy is the return value for IsHealthy
	IsHealthyError error

	// ReloadSchemaCount counts how many times ReloadSchema was called
	ReloadSchemaCount int
}

TestQueryServiceControl is a fake version of QueryServiceControl

func NewTestQueryServiceControl 

func NewTestQueryServiceControl() *TestQueryServiceControl

NewTestQueryServiceControl returns an implementation of QueryServiceControl that is entirely fake

func (*TestQueryServiceControl) AddStatusPart 

func (tqsc *TestQueryServiceControl) AddStatusPart()

AddStatusPart is part of the QueryServiceControl interface

func (*TestQueryServiceControl) AllowQueries 

func (tqsc *TestQueryServiceControl) AllowQueries(*dbconfigs.DBConfigs, []SchemaOverride, *mysqlctl.Mysqld) error

AllowQueries is part of the QueryServiceControl interface

func (*TestQueryServiceControl) DisallowQueries 

func (tqsc *TestQueryServiceControl) DisallowQueries()

DisallowQueries is part of the QueryServiceControl interface

func (*TestQueryServiceControl) IsHealthy 

func (tqsc *TestQueryServiceControl) IsHealthy() error

IsHealthy is part of the QueryServiceControl interface

func (*TestQueryServiceControl) IsServing 

func (tqsc *TestQueryServiceControl) IsServing() bool

IsServing is part of the QueryServiceControl interface

func (*TestQueryServiceControl) Register 

func (tqsc *TestQueryServiceControl) Register()

Register is part of the QueryServiceControl interface

func (*TestQueryServiceControl) ReloadSchema 

func (tqsc *TestQueryServiceControl) ReloadSchema()

ReloadSchema is part of the QueryServiceControl interface

func (*TestQueryServiceControl) SetQueryRules 

func (tqsc *TestQueryServiceControl) SetQueryRules(ruleSource string, qrs *QueryRules) error

SetQueryRules is part of the QueryServiceControl interface

func (*TestQueryServiceControl) SqlQuery 

func (tqsc *TestQueryServiceControl) SqlQuery() *SqlQuery

SqlQuery is part of the QueryServiceControl interface

type TxConnection 

type TxConnection struct {
	*DBConn
	TransactionID int64

	StartTime time.Time
	EndTime   time.Time

	Queries    []string
	Conclusion string
	LogToFile  sync2.AtomicInt32
	// contains filtered or unexported fields
}

func (*TxConnection) DirtyKeys 

func (txc *TxConnection) DirtyKeys(tableName string) DirtyKeys

func (*TxConnection) Exec 

func (txc *TxConnection) Exec(query string, maxrows int, wantfields bool, deadline Deadline) (*proto.QueryResult, error)

func (*TxConnection) Format 

func (txc *TxConnection) Format(params url.Values) string

func (*TxConnection) RecordQuery 

func (txc *TxConnection) RecordQuery(query string)

func (*TxConnection) Recycle 

func (txc *TxConnection) Recycle()

type TxPool 

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

func NewTxPool 

func NewTxPool(name string, capacity int, timeout, poolTimeout, idleTimeout time.Duration) *TxPool

func (*TxPool) Begin 

func (axp *TxPool) Begin() int64

func (*TxPool) Close 

func (axp *TxPool) Close()

func (*TxPool) Get 

func (axp *TxPool) Get(transactionId int64) (conn *TxConnection)

You must call Recycle on TxConnection once done.

func (*TxPool) LogActive 

func (axp *TxPool) LogActive()

LogActive causes all existing transactions to be logged when they complete. The logging is throttled to no more than once every txLogInterval.

func (*TxPool) Open 

func (axp *TxPool) Open(appParams, dbaParams *mysql.ConnectionParams)

func (*TxPool) Rollback 

func (axp *TxPool) Rollback(transactionId int64)

func (*TxPool) SafeCommit 

func (axp *TxPool) SafeCommit(transactionId int64) (invalidList map[string]DirtyKeys, err error)

func (*TxPool) SetPoolTimeout 

func (axp *TxPool) SetPoolTimeout(timeout time.Duration)

func (*TxPool) SetTimeout 

func (axp *TxPool) SetTimeout(timeout time.Duration)

func (*TxPool) Timeout 

func (axp *TxPool) Timeout() time.Duration

func (*TxPool) TransactionKiller 

func (axp *TxPool) TransactionKiller()

func (*TxPool) WaitForEmpty 

func (axp *TxPool) WaitForEmpty()

Source Files

View all Source files

Directories

Path Synopsis
customrule
filecustomrule
Package filecustomrule implements static custom rule from a config file
 Package filecustomrule implements static custom rule from a config file
zkcustomrule

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.