cockroach: github.com/abhinavdahiya/cockroach/sql Index | Files | Directories

package sql

import "github.com/abhinavdahiya/cockroach/sql"

Package sql provides the user-facing API for access to a Cockroach datastore. As the name suggests, the API is based around SQL, the same SQL you find in traditional RDMBS systems like Oracle, MySQL or Postgres. The core Cockroach system implements a distributed, transactional, monolithic sorted key-value map. The sql package builds on top of this core system adding parsing, query planning and query execution as well as defining the privilege model.

Databases and Tables

The two primary objects are databases and tables. A database is a namespace which holds a series of tables. Conceptually, a database can be viewed like a directory in a filesystem plus some additional metadata (privileges). A table is like a file on steroids: containing a structured layout of rows and columns along with secondary indexes.

Like a directory, a database has a name and metadata. The metadata is defined by the DatabaseDescriptor:

message DatabaseDescriptor {
  optional string name;
  optional uint32 id;
  optional PrivilegeDescriptor privileges;
}

Similarly, tables have a TableDescriptor:

message TableDescriptor {
  optional string name;
  optional uint32 id;
  repeated ColumnDescriptor columns;
  optional IndexDescriptor primary_index;
  repeated IndexDescriptor indexes;
  optional PrivilegeDescriptor privileges;
}

Both the database ID and the table ID are allocate from the same "ID space" and IDs are never reused.

The namespace in which databases and tables exist contains only two levels: the root level contains databases and the database level contains tables. The "system.namespace" and "system.descriptor" tables implement the mapping from database/table name to ID and from ID to descriptor:

CREATE TABLE system.namespace (
  "parentID" INT,
  "name"     CHAR,
  "id"       INT,
  PRIMARY KEY (parentID, name)
);

CREATE TABLE system.descriptor (
  "id"         INT PRIMARY KEY,
  "descriptor" BLOB
);

The reserved ID of 0 is used for the "root" of the namespace in which the databases reside. In order to lookup the ID of a database given its name, the system effectively does a query like:

SELECT id FROM system.namespace WHERE parentID = 0 AND name = <database-name>

And given a database/table ID, the system looks up the descriptor using a query like:

SELECT descriptor FROM system.descriptor WHERE id = <ID>

Primary Key Addressing

All of the SQL data stored in tables is mapped down to keys and values. This mapping is referred to as key addressing. All tables have a primary key, whether explicitly listed in the schema or automatically generated. Note that a primary key is unrelated to the core Cockroach key-value functionality and is instead referring to the primary key for a SQL table.

The primary key consists of one or more non-NULL columns from the table. For a given row of the table, the columns for the primary key are encoded into a single string using the routines in util/encoding. These routines allow for the encoding of NULL values, integers, floating pointer numbers and strings in such a way that lexicographic ordering of the encoded strings corresponds to the same ordering of the unencoded data. Using "system.namespace" as an example, the primary key columns would be encoded as:

/parentID/name

[Note that "/" is being used to disambiguate the components of the key. The actual encodings do not use "/"].

Before being stored in the monolothic key-value space, the encoded primary key columns are prefixed with the table ID and an ID indicating that the key corresponds to the primary index:

/TableID/PrimaryIndexID/parentID/name

The column data associated with a row in a table is stored within the primary index which is the index associated with the primary key. Every column has a unique ID (that is local to the table). The value for a column is stored at the key:

/TableID/PrimaryIndexID/parentID/name/ColumnID -> Value

A column containing a NULL value is not stored in the monolithic map. In order to detect rows which only contain NULL values in non-primary key columns, every row has a sentinel key indicating its existence. The sentinel key is simply the primary index key:

/TableID/PrimaryIndexID/parentID/name -> NULL

As an optimization, columns that are part of the primary key are not stored separately as their data can be decoded from the sentinel value.

Secondary Indexes

Despite not being a formal part of SQL, secondary indexes are one of its most powerful features. Secondary indexes are a level of indirection that allow quick lookup of a row using something other than the primary key. As an example, we can imagine creating a secondary index on the "system.namespace" table:

CREATE INDEX name ON system.namespace (name);

This would create a "name" index composed solely of the "name" column. The key addressing for this non-unique index looks like:

/TableId/SecondaryIndexID/name/parentID -> NULL

Notice that while the index is on "name", the key contains both "name" and "parentID". This is done to ensure that each row for a table has a unique key for the non-unique index. In general, for a non-unique index we encoded the index's columns followed by any primary key columns that have not already been mentioned. This effectively transforms any non-unique index into a unique index.

Let's suppose that we had instead defined the index as:

CREATE UNIQUE INDEX name ON system.namespace (name, id);

The key addressing for a unique index looks like:

/TableID/SecondaryID/name/ID -> /parentID

Unique index keys are defined like this so that a conditional put operation can fail if that key already exists for another row, thereby enforcing the uniqueness constraint. The value for a unique index is composed of any primary key columns that are not part of the index ("parentID" in this example).

Query Planning and Execution

Query planning is the system which takes a parsed SQL statement (described by an abstract syntax tree) and creates an execution plan which is itself a tree consisting of a set of scan, join, group, sort and projection operations. For the bulk of SQL statements, query planning is straightforward: the complexity lies in SELECT.

At one end of the performance spectrum, an implementation of SELECT can be straightforward: do a full scan of the (joined) tables in the FROM clause, filter rows based on the WHERE clause, group the resulting rows based on the GROUP BY clause, filter those rows using the HAVING clause, sort using the ORDER BY clause. There are a number of steps, but they all have well defined semantics and are mostly just an exercise in software engineering: retrieve the rows as quickly as possible and then send them through the pipeline of filtering, grouping, filtering and sorting.

At the other end of the performance spectrum, query planners attempt to take advantage of secondary indexes to limit the data retrieved, make joining of data between two tables easier and faster and to avoid the need to sort data by retrieving it in a sorted or partially sorted form. The details of how we implement this are in flux and will continue to be in flux for the foreseeable future. This section is intended to provide a high-level overview of a few of the techniques involved.

After parsing a SELECT query, the query planner performs semantic analysis to verify the queries correctness and to resolve names within the query to actual objects within the system. Let's consider the query:

SELECT id FROM system.namespace WHERE parentID = 0 AND name = 'test'

This query would look up the ID of the database named "test". The query planner needs to resolve the "system.namespace" qualified name in the FROM clause to the appropriate TableDescriptor. It also needs to resolve the "id", "parentID" and "name" column references to the appropriate column descriptions with the "system.namespace" TableDescriptor. Lastly, as part of semantic analysis, the query planner verifies that the expressions in the select targets and the WHERE clause are valid (e.g. the WHERE clause evaluates to a boolean).

From that starting point, the query planner then analyzes the GROUP BY and ORDER BY clauses, adding "hidden" targets for expressions used in those clauses that are not explicit targets of the query. In our example without a GROUP BY or ORDER BY clause we move straight to the next step: index selection. Index selection is the stage where the query planner selects the best index to scan and selects the start and end keys to use for scanning the index. Depending on the query, the query planner might even select multiple ranges to scan from an index or multiple ranges from different indexes.

How does the query planner decide which index to use and which range of the index to scan? We currently use a restricted form of value propagation in oder to determine the range of possible values for columns referenced in the WHERE clause. Using this range information, each index is examined to determine if it is a potential candidate and ranked according to its specificity. In addition to ranking indexes by the column value range information, they are ranked by how well they match the sorting required by the ORDER BY clause. Back to the example above, the range information would determine that:

parentID >= 0 AND parentID <= 0 AND name >= 'test' and name <= 'test

Notice that each column has a start and end value associated with it. Since there is only a single index on the "system.namespace" table, it is always selected. The start key is computed using the range information as:

/system.descriptor/primary/0/test

The end key is computed as:

/system.descriptor/primary/0/tesu

The "tesu" suffix is not a typo: the end key is computed as the "prefix end key" for the key "/TableID/PrimaryIndexId/0/test". This is done by incrementing the final byte of the key such that "t" becomes "u".

Our example query thus only scans two key-value pairs:

/system.descriptor/primary/0/test    -> NULL
/system.descriptor/primary/0/test/id -> <ID>

Index

Package Files

alter_table.go analyze.go backfill.go check.go config.go create.go data_source.go database.go delete.go descriptor.go dist_sql_node.go distinct.go doc.go drop.go empty.go errors.go event_log.go executor.go explain.go expr_filter.go fk.go grant.go group.go index_selection.go insert.go internal.go join.go lease.go limit.go ordering.go plan.go planner.go prepare.go rename.go returning.go rowwriter.go scan.go schema_changer.go select.go select_qvalue.go select_top.go session.go set.go show.go sort.go subquery.go table.go table_join.go tablewriter.go trace.go truncate.go txn.go txnstateenum_string.go union.go update.go upsert.go values.go verify.go

Constants

const ColumnTruncateAndBackfillChunkSize = 600

ColumnTruncateAndBackfillChunkSize is the maximum number of rows of keys processed per chunk during the column truncate or backfill.

TODO(vivek): Run some experiments to set this value to something sensible or adjust it dynamically. Also add in a sleep after every chunk is processed to slow down the backfill and reduce its CPU usage.

const IndexBackfillChunkSize = 100

IndexBackfillChunkSize is the maximum number of rows processed per chunk during the index backfill.

TODO(vivek) Run some experiments to set this value to something sensible or adjust it dynamically. Also add in a sleep after every chunk is processed, to slow down the backfill and not have it interfere with OLTP commands.

Variables

var (
    // LeaseDuration is the mean duration a lease will be acquired for. The
    // actual duration is jittered in the range
    // [0.75,1.25]*LeaseDuration. Exported for testing purposes only.
    LeaseDuration = 5 * time.Minute
    // MinLeaseDuration is the minimum duration a lease will have remaining upon
    // acquisition. Exported for testing purposes only.
    MinLeaseDuration = time.Minute
)
var (
    // SchemaChangeLeaseDuration is the duration a lease will be acquired for.
    // Exported for testing purposes only.
    SchemaChangeLeaseDuration = 5 * time.Minute
    // MinSchemaChangeLeaseDuration is the minimum duration a lease will have
    // remaining upon acquisition. Exported for testing purposes only.
    MinSchemaChangeLeaseDuration = time.Minute
)

func AddEventLogToMetadataSchema Uses

func AddEventLogToMetadataSchema(schema *sqlbase.MetadataSchema)

AddEventLogToMetadataSchema adds the event log table to the supplied MetadataSchema.

func GetTableDesc Uses

func GetTableDesc(cfg config.SystemConfig, id sqlbase.ID) (*sqlbase.TableDescriptor, error)

GetTableDesc returns the table descriptor for the table with 'id'. Returns nil if the descriptor is not present, or is present but is not a table.

func GetZoneConfig Uses

func GetZoneConfig(cfg config.SystemConfig, id uint32) (*config.ZoneConfig, error)

GetZoneConfig returns the zone config for the object with 'id'.

func TestDisableTableLeases Uses

func TestDisableTableLeases() func()

TestDisableTableLeases disables table leases and returns a function that can be used to enable it.

type DatabaseAccessor Uses

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

DatabaseAccessor provides helper methods for using SQL database descriptors.

type DescriptorAccessor Uses

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

DescriptorAccessor provides helper methods for using descriptors to SQL objects.

type EventLogType Uses

type EventLogType string

EventLogType represents an event type that can be recorded in the event log.

const (
    // EventLogCreateDatabase is recorded when a database is created.
    EventLogCreateDatabase EventLogType = "create_database"
    // EventLogDropDatabase is recorded when a database is dropped.
    EventLogDropDatabase EventLogType = "drop_database"
    // EventLogCreateTable is recorded when a table is created.
    EventLogCreateTable EventLogType = "create_table"
    // EventLogDropTable is recorded when a table is dropped.
    EventLogDropTable EventLogType = "drop_table"

    // EventLogAlterTable is recorded when a table is altered.
    EventLogAlterTable EventLogType = "alter_table"
    // EventLogCreateIndex is recorded when an index is created.
    EventLogCreateIndex EventLogType = "create_index"
    // EventLogDropIndex is recorded when an index is created.
    EventLogDropIndex EventLogType = "drop_index"
    // EventLogReverseSchemaChange is recorded when an in-progress schema change
    // encounters a problem and is reversed.
    EventLogReverseSchemaChange EventLogType = "reverse_schema_change"
    // EventLogFinishSchemaChange is recorded when a previously initiated schema
    // change has completed.
    EventLogFinishSchemaChange EventLogType = "finish_schema_change"

    // EventLogNodeJoin is recorded when a node joins the cluster.
    EventLogNodeJoin EventLogType = "node_join"
    // EventLogNodeRestart is recorded when an existing node rejoins the cluster
    // after being offline.
    EventLogNodeRestart EventLogType = "node_restart"
)

type EventLogger Uses

type EventLogger struct {
    InternalExecutor
}

An EventLogger exposes methods used to record events to the event table.

func MakeEventLogger Uses

func MakeEventLogger(leaseMgr *LeaseManager) EventLogger

MakeEventLogger constructs a new EventLogger. A LeaseManager is required in order to correctly execute SQL statements.

func (EventLogger) InsertEventRecord Uses

func (ev EventLogger) InsertEventRecord(txn *client.Txn, eventType EventLogType, targetID, reportingID int32, info interface{}) error

InsertEventRecord inserts a single event into the event log as part of the provided transaction.

type Executor Uses

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

An Executor executes SQL statements. Executor is thread-safe.

func NewExecutor Uses

func NewExecutor(ctx ExecutorContext, stopper *stop.Stopper, registry *metric.Registry) *Executor

NewExecutor creates an Executor and registers a callback on the system config.

func (*Executor) ExecuteStatements Uses

func (e *Executor) ExecuteStatements(
    ctx context.Context, session *Session, stmts string, pinfo *parser.PlaceholderInfo,
) StatementResults

ExecuteStatements executes the given statement(s) and returns a response.

func (*Executor) Prepare Uses

func (e *Executor) Prepare(
    ctx context.Context,
    query string,
    session *Session,
    pinfo parser.PlaceholderTypes,
) ([]ResultColumn, error)

Prepare returns the result types of the given statement. pinfo may contain partial type information for placeholders. Prepare will populate the missing types. The column result types are returned (or nil if there are no results).

func (*Executor) Registry Uses

func (e *Executor) Registry() *metric.Registry

Registry returns a registry with the metrics tracked by this executor, which can be used to access its stats or be added to another registry.

func (*Executor) SetNodeID Uses

func (e *Executor) SetNodeID(nodeID roachpb.NodeID)

SetNodeID sets the node ID for the SQL server. This method must be called before actually using the Executor.

type ExecutorContext Uses

type ExecutorContext struct {
    DB           *client.DB
    Gossip       *gossip.Gossip
    LeaseManager *LeaseManager
    Clock        *hlc.Clock
    DistSQLSrv   *distsql.ServerImpl

    TestingKnobs *ExecutorTestingKnobs
}

An ExecutorContext encompasses the auxiliary objects and configuration required to create an executor. All fields holding a pointer or an interface are required to create a Executor; the rest will have sane defaults set if omitted.

type ExecutorTestingKnobs Uses

type ExecutorTestingKnobs struct {
    // WaitForGossipUpdate causes metadata-mutating operations to wait
    // for the new metadata to back-propagate through gossip.
    WaitForGossipUpdate bool

    // CheckStmtStringChange causes Executor.execStmtsInCurrentTxn to verify
    // that executed statements are not modified during execution.
    CheckStmtStringChange bool

    // FixTxnPriority causes transaction priority values to be hardcoded (for
    // each priority level) to avoid the randomness in the normal generation.
    FixTxnPriority bool

    // SyncSchemaChangersFilter is called before running schema changers
    // synchronously (at the end of a txn). The function can be used to clear the
    // schema changers (if the test doesn't want them run using the synchronous
    // path) or to temporarily block execution.
    // Note that this has nothing to do with the async path for running schema
    // changers. To block that, see TestDisableAsyncSchemaChangeExec().
    SyncSchemaChangersFilter SyncSchemaChangersFilter

    // SchemaChangersStartBackfillNotification is called before applying the
    // backfill for a schema change operation. It returns error to stop the
    // backfill and return an error to the caller of the SchemaChanger.exec().
    SchemaChangersStartBackfillNotification func() error

    //SyncSchemaChangersRenameOldNameNotInUseNotification is called during a rename
    //schema change, after all leases on the version of the descriptor with the
    //old name are gone, and just before the mapping of the old name to the
    //descriptor id is about to be deleted.
    SyncSchemaChangersRenameOldNameNotInUseNotification func()
}

ExecutorTestingKnobs is part of the context used to control parts of the system during testing.

func (*ExecutorTestingKnobs) ModuleTestingKnobs Uses

func (*ExecutorTestingKnobs) ModuleTestingKnobs()

ModuleTestingKnobs is part of the base.ModuleTestingKnobs interface.

type FKCheck Uses

type FKCheck int

FKCheck indicates a kind of FK check (delete, insert, or both).

const (
    // CheckDeletes checks if rows reference a changed value.
    CheckDeletes FKCheck = iota
    // CheckInserts checks if a new/changed value references an existing row.
    CheckInserts
    // CheckUpdates checks all references (CheckDeletes+CheckInserts).
    CheckUpdates
)

type InternalExecutor Uses

type InternalExecutor struct {
    LeaseManager *LeaseManager
}

InternalExecutor can be used internally by cockroach to execute SQL statements without needing to open a SQL connection. InternalExecutor assumes that the caller has access to a cockroach KV client to handle connection and transaction management.

func (InternalExecutor) ExecuteStatementInTransaction Uses

func (ie InternalExecutor) ExecuteStatementInTransaction(
    txn *client.Txn, statement string, qargs ...interface{},
) (int, error)

ExecuteStatementInTransaction executes the supplied SQL statement as part of the supplied transaction. Statements are currently executed as the root user.

func (InternalExecutor) GetTableSpan Uses

func (ie InternalExecutor) GetTableSpan(user string, txn *client.Txn, dbName, tableName string) (roachpb.Span, error)

GetTableSpan gets the key span for a SQL table, including any indices.

type LeaseManager Uses

type LeaseManager struct {
    LeaseStore
    // contains filtered or unexported fields
}

LeaseManager manages acquiring and releasing per-table leases. It also handles resolving table names to descriptor IDs.

Exported only for testing.

The locking order is: LeaseManager.mu > tableState.mu > tableNameCache.mu > LeaseState.mu

func NewLeaseManager Uses

func NewLeaseManager(
    nodeID uint32,
    db client.DB,
    clock *hlc.Clock,
    testingKnobs LeaseManagerTestingKnobs,
    stopper *stop.Stopper,
) *LeaseManager

NewLeaseManager creates a new LeaseManager.

stopper is used to run async tasks. Can be nil in tests.

func (*LeaseManager) Acquire Uses

func (m *LeaseManager) Acquire(
    txn *client.Txn, tableID sqlbase.ID, version sqlbase.DescriptorVersion,
) (*LeaseState, error)

Acquire acquires a read lease for the specified table ID. If version is non-zero the lease is grabbed for the specified version. Otherwise it is grabbed for the most recent version of the descriptor that the lease manager knows about. TODO(andrei): move the tests that use this to the sql package and un-export it.

func (*LeaseManager) AcquireByName Uses

func (m *LeaseManager) AcquireByName(
    txn *client.Txn, dbID sqlbase.ID, tableName string,
) (*LeaseState, error)

AcquireByName acquires a read lease for the specified table. The lease is grabbed for the most recent version of the descriptor that the lease manager knows about.

func (*LeaseManager) RefreshLeases Uses

func (m *LeaseManager) RefreshLeases(s *stop.Stopper, db *client.DB, gossip *gossip.Gossip)

RefreshLeases starts a goroutine that refreshes the lease manager leases for tables received in the latest system configuration via gossip.

func (*LeaseManager) Release Uses

func (m *LeaseManager) Release(lease *LeaseState) error

Release releases a previously acquired read lease.

type LeaseManagerTestingKnobs Uses

type LeaseManagerTestingKnobs struct {
    // A callback called when a gossip update is received, before the leases are
    // refreshed. Careful when using this to block for too long - you can block
    // all the gossip users in the system.
    GossipUpdateEvent func(config.SystemConfig)
    // A callback called after the leases are refreshed as a result of a gossip update.
    TestingLeasesRefreshedEvent func(config.SystemConfig)

    LeaseStoreTestingKnobs LeaseStoreTestingKnobs
}

LeaseManagerTestingKnobs contains test knobs.

func (*LeaseManagerTestingKnobs) ModuleTestingKnobs Uses

func (*LeaseManagerTestingKnobs) ModuleTestingKnobs()

ModuleTestingKnobs is part of the base.ModuleTestingKnobs interface.

type LeaseState Uses

type LeaseState struct {
    sqlbase.TableDescriptor
    // contains filtered or unexported fields
}

LeaseState holds the state for a lease. Exported only for testing.

func (*LeaseState) Expiration Uses

func (s *LeaseState) Expiration() time.Time

Expiration returns the expiration time of the lease.

func (*LeaseState) Refcount Uses

func (s *LeaseState) Refcount() int

Refcount returns the reference count of the lease.

func (*LeaseState) String Uses

func (s *LeaseState) String() string

type LeaseStore Uses

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

LeaseStore implements the operations for acquiring and releasing leases and publishing a new version of a descriptor. Exported only for testing.

func (LeaseStore) Acquire Uses

func (s LeaseStore) Acquire(
    txn *client.Txn,
    tableID sqlbase.ID,
    minVersion sqlbase.DescriptorVersion,
    minExpirationTime parser.DTimestamp,
) (*LeaseState, error)

Acquire a lease on the most recent version of a table descriptor. If the lease cannot be obtained because the descriptor is in the process of being deleted, the error will be errTableDeleted.

func (LeaseStore) Publish Uses

func (s LeaseStore) Publish(
    tableID sqlbase.ID,
    update func(*sqlbase.TableDescriptor) error,
    logEvent func(*client.Txn) error,
) (*sqlbase.Descriptor, error)

Publish updates a table descriptor. It also maintains the invariant that there are at most two versions of the descriptor out in the wild at any time by first waiting for all nodes to be on the current (pre-update) version of the table desc. The update closure is called after the wait, and it provides the new version of the descriptor to be written. In a multi-step schema operation, this update should perform a single step. The closure may be called multiple times if retries occur; make sure it does not have side effects. Returns the updated version of the descriptor.

func (LeaseStore) Release Uses

func (s LeaseStore) Release(lease *LeaseState) error

Release a previously acquired table descriptor lease.

type LeaseStoreTestingKnobs Uses

type LeaseStoreTestingKnobs struct {
    // Called after a lease is removed from the store, with any operation error.
    // See LeaseRemovalTracker.
    LeaseReleasedEvent func(lease *LeaseState, err error)
}

LeaseStoreTestingKnobs contains testing knobs.

func (*LeaseStoreTestingKnobs) ModuleTestingKnobs Uses

func (*LeaseStoreTestingKnobs) ModuleTestingKnobs()

ModuleTestingKnobs is part of the base.ModuleTestingKnobs interface.

type PreparedPortal Uses

type PreparedPortal struct {
    Stmt  *PreparedStatement
    Qargs parser.QueryArguments

    ProtocolMeta interface{} // a field for protocol implementations to hang metadata off of.
}

PreparedPortal is a PreparedStatement that has been bound with query arguments.

type PreparedPortals Uses

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

PreparedPortals is a mapping of PreparedPortal names to their corresponding PreparedPortals.

func (PreparedPortals) Delete Uses

func (pp PreparedPortals) Delete(name string) bool

Delete removes the PreparedPortal with the provided name from the PreparedPortals. The method returns whether a portal with that name was found and removed.

func (PreparedPortals) Exists Uses

func (pp PreparedPortals) Exists(name string) bool

Exists returns whether a PreparedPortal with the provided name exists.

func (PreparedPortals) Get Uses

func (pp PreparedPortals) Get(name string) (*PreparedPortal, bool)

Get returns the PreparedPortal with the provided name.

func (PreparedPortals) New Uses

func (pp PreparedPortals) New(name string, stmt *PreparedStatement, qargs parser.QueryArguments,
) *PreparedPortal

New creates a new PreparedPortal with the provided name and corresponding PreparedStatement, binding the statement using the given QueryArguments.

type PreparedStatement Uses

type PreparedStatement struct {
    Query    string
    SQLTypes parser.PlaceholderTypes
    Columns  []ResultColumn

    ProtocolMeta interface{} // a field for protocol implementations to hang metadata off of.
    // contains filtered or unexported fields
}

PreparedStatement is a SQL statement that has been parsed and the types of arguments and results have been determined.

type PreparedStatements Uses

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

PreparedStatements is a mapping of PreparedStatement names to their corresponding PreparedStatements.

func (PreparedStatements) Delete Uses

func (ps PreparedStatements) Delete(name string) bool

Delete removes the PreparedStatement with the provided name from the PreparedStatements. The method returns whether a statement with that name was found and removed.

func (PreparedStatements) DeleteAll Uses

func (ps PreparedStatements) DeleteAll()

DeleteAll removes all PreparedStatements from the PreparedStatements. This will in turn remove all PreparedPortals from the session's PreparedPortals.

func (PreparedStatements) Exists Uses

func (ps PreparedStatements) Exists(name string) bool

Exists returns whether a PreparedStatement with the provided name exists.

func (PreparedStatements) Get Uses

func (ps PreparedStatements) Get(name string) (*PreparedStatement, bool)

Get returns the PreparedStatement with the provided name.

func (PreparedStatements) New Uses

func (ps PreparedStatements) New(
    ctx context.Context,
    e *Executor,
    name, query string,
    placeholderHints parser.PlaceholderTypes,
) (*PreparedStatement, error)

New creates a new PreparedStatement with the provided name and corresponding query string, using the given PlaceholderTypes hints to assist in inferring placeholder types.

type Result Uses

type Result struct {
    Err error
    // The type of statement that the result is for.
    Type parser.StatementType
    // The tag of the statement that the result is for.
    PGTag string
    // RowsAffected will be populated if the statement type is "RowsAffected".
    RowsAffected int
    // Columns will be populated if the statement type is "Rows". It will contain
    // the names and types of the columns returned in the result set in the order
    // specified in the SQL statement. The number of columns will equal the number
    // of values in each Row.
    Columns []ResultColumn
    // Rows will be populated if the statement type is "Rows". It will contain
    // the result set of the result.
    // TODO(nvanbenschoten): Can this be streamed from the planNode?
    Rows []ResultRow
}

Result corresponds to the execution of a single SQL statement.

type ResultColumn Uses

type ResultColumn struct {
    Name string
    Typ  parser.Datum
    // contains filtered or unexported fields
}

ResultColumn contains the name and type of a SQL "cell".

type ResultList Uses

type ResultList []Result

ResultList represents a list of results for a list of SQL statements. There is one result object per SQL statement in the request.

type ResultRow Uses

type ResultRow struct {
    Values []parser.Datum
}

ResultRow is a collection of values representing a row in a result.

type SchemaAccessor Uses

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

SchemaAccessor provides helper methods for using the SQL schema.

type SchemaChangeManager Uses

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

SchemaChangeManager processes pending schema changes seen in gossip updates. Most schema changes are executed synchronously by the node that created the schema change. If the node dies while processing the schema change this manager acts as a backup execution mechanism.

func NewSchemaChangeManager Uses

func NewSchemaChangeManager(
    testingKnobs *SchemaChangeManagerTestingKnobs,
    db client.DB,
    gossip *gossip.Gossip,
    leaseMgr *LeaseManager,
) *SchemaChangeManager

NewSchemaChangeManager returns a new SchemaChangeManager.

func (*SchemaChangeManager) Start Uses

func (s *SchemaChangeManager) Start(stopper *stop.Stopper)

Start starts a goroutine that runs outstanding schema changes for tables received in the latest system configuration via gossip.

type SchemaChangeManagerTestingKnobs Uses

type SchemaChangeManagerTestingKnobs struct {
    // AsyncSchemaChangersExecNotification is a function called before running
    // a schema change asynchronously. Returning an error will prevent the
    // asynchronous execution path from running.
    AsyncSchemaChangerExecNotification func() error

    // AsyncSchemaChangerExecQuickly executes queued schema changes as soon as
    // possible.
    AsyncSchemaChangerExecQuickly bool
}

SchemaChangeManagerTestingKnobs for the SchemaChangeManager.

func (*SchemaChangeManagerTestingKnobs) ModuleTestingKnobs Uses

func (*SchemaChangeManagerTestingKnobs) ModuleTestingKnobs()

ModuleTestingKnobs is part of the base.ModuleTestingKnobs interface.

type SchemaChanger Uses

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

SchemaChanger is used to change the schema on a table.

func NewSchemaChangerForTesting Uses

func NewSchemaChangerForTesting(
    tableID sqlbase.ID,
    mutationID sqlbase.MutationID,
    nodeID roachpb.NodeID,
    db client.DB,
    leaseMgr *LeaseManager,
) SchemaChanger

NewSchemaChangerForTesting only for tests.

func (*SchemaChanger) AcquireLease Uses

func (sc *SchemaChanger) AcquireLease() (sqlbase.TableDescriptor_SchemaChangeLease, error)

AcquireLease acquires a schema change lease on the table if an unexpired lease doesn't exist. It returns the lease.

func (*SchemaChanger) ExtendLease Uses

func (sc *SchemaChanger) ExtendLease(
    existingLease sqlbase.TableDescriptor_SchemaChangeLease,
) (sqlbase.TableDescriptor_SchemaChangeLease, error)

ExtendLease for the current leaser. This needs to be called often while doing a schema change to prevent more than one node attempting to apply a schema change (which is still safe, but unwise).

func (*SchemaChanger) IsDone Uses

func (sc *SchemaChanger) IsDone() (bool, error)

IsDone returns true if the work scheduled for the schema changer is complete.

func (*SchemaChanger) MaybeIncrementVersion Uses

func (sc *SchemaChanger) MaybeIncrementVersion() (*sqlbase.Descriptor, error)

MaybeIncrementVersion increments the version if needed. If the version is to be incremented, it also assures that all nodes are on the current (pre-increment) version of the descriptor. Returns the (potentially updated) descriptor.

func (*SchemaChanger) ReleaseLease Uses

func (sc *SchemaChanger) ReleaseLease(lease sqlbase.TableDescriptor_SchemaChangeLease) error

ReleaseLease the table lease if it is the one registered with the table descriptor.

func (*SchemaChanger) RunStateMachineBeforeBackfill Uses

func (sc *SchemaChanger) RunStateMachineBeforeBackfill() error

RunStateMachineBeforeBackfill moves the state machine forward and wait to ensure that all nodes are seeing the latest version of the table.

type Session Uses

type Session struct {
    Database string
    User     string
    Syntax   int32

    // Info about the open transaction (if any).
    TxnState txnState

    PreparedStatements PreparedStatements
    PreparedPortals    PreparedPortals

    Location              *time.Location
    DefaultIsolationLevel enginepb.IsolationType
    Trace                 trace.Trace
    // contains filtered or unexported fields
}

Session contains the state of a SQL client connection. Create instances using NewSession().

func NewSession Uses

func NewSession(args SessionArgs, e *Executor, remote net.Addr) *Session

NewSession creates and initializes new Session object. remote can be nil.

func (*Session) Finish Uses

func (s *Session) Finish()

Finish releases resources held by the Session.

type SessionArgs Uses

type SessionArgs struct {
    Database string
    User     string
}

SessionArgs contains arguments for creating a new Session with NewSession().

type StatementResults Uses

type StatementResults struct {
    ResultList
    // Indicates that after parsing, the request contained 0 non-empty statements.
    Empty bool
}

StatementResults represents a list of results from running a batch of SQL statements, plus some meta info about the batch.

type SyncSchemaChangersFilter Uses

type SyncSchemaChangersFilter func(TestingSchemaChangerCollection)

SyncSchemaChangersFilter is the type of a hook to be installed through the ExecutorContext for blocking or otherwise manipulating schema changers run through the sync schema changers path.

type TablesByID Uses

type TablesByID map[sqlbase.ID]*sqlbase.TableDescriptor

TablesByID maps table IDs to looked up descriptors.

func TablesNeededForFKs Uses

func TablesNeededForFKs(table sqlbase.TableDescriptor, usage FKCheck) TablesByID

TablesNeededForFKs calculates the IDs of the additional TableDescriptors that will be needed for FK checking delete and/or insert operations on `table`.

NB: the returned map's values are *not* set -- higher level calling code, eg in planner, should fill the map's values by acquiring leases. This function is essentially just returning a slice of IDs, but the empty map can be filled in place and reused, avoiding a second allocation.

type TestingSchemaChangerCollection Uses

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

TestingSchemaChangerCollection is an exported (for testing) version of schemaChangerCollection. TODO(andrei): get rid of this type once we can have tests internal to the sql package (as of April 2016 we can't because sql can't import server).

func (TestingSchemaChangerCollection) ClearSchemaChangers Uses

func (tscc TestingSchemaChangerCollection) ClearSchemaChangers()

ClearSchemaChangers clears the schema changers from the collection. If this is called from a SyncSchemaChangersFilter, no schema changer will be run.

type TxnStateEnum Uses

type TxnStateEnum int

TxnStateEnum represents the state of a SQL txn.

const (
    // No txn is in scope. Either there never was one, or it got committed/rolled back.
    NoTxn TxnStateEnum = iota
    // A txn is in scope.
    Open
    // The txn has encoutered a (non-retriable) error.
    // Statements will be rejected until a COMMIT/ROLLBACK is seen.
    Aborted
    // The txn has encoutered a retriable error.
    // Statements will be rejected until a RESTART_TRANSACTION is seen.
    RestartWait
    // The KV txn has been committed successfully through a RELEASE.
    // Statements are rejected until a COMMIT is seen.
    CommitWait
)

go:generate stringer -type=TxnStateEnum

func (TxnStateEnum) String Uses

func (i TxnStateEnum) String() string

Directories

PathSynopsis
distsqlPackage distsql is a generated protocol buffer package.
parserCode generated by go yacc.
pgbench
pgwire
pgwire/pgerror
privilege
sqlbasePackage sqlbase is a generated protocol buffer package.
sqlutil

Package sql imports 45 packages (graph). Updated 2017-03-13. Refresh now. Tools for package owners. This is a dead-end fork (no commits since the fork).