// getTableID retrieves the table ID for the specified table.
func getTableID(p *planner, tn *parser.TableName) (sqlbase.ID, error) {
if err := tn.QualifyWithDatabase(p.session.Database); err != nil {
return 0, err
}
virtual, err := getVirtualTableDesc(tn)
if err != nil {
return 0, err
}
if virtual != nil {
return virtual.GetID(), nil
}
dbID, err := p.getDatabaseID(tn.Database())
if err != nil {
return 0, err
}
nameKey := tableKey{dbID, tn.Table()}
key := nameKey.Key()
gr, err := p.txn.Get(key)
if err != nil {
return 0, err
}
if !gr.Exists() {
return 0, sqlbase.NewUndefinedTableError(parser.AsString(tn))
}
return sqlbase.ID(gr.ValueInt()), nil
}
// expandStar returns the array of column metadata and name
// expressions that correspond to the expansion of a star.
func (src *dataSourceInfo) expandStar(
v parser.VarName, qvals qvalMap,
) (columns []ResultColumn, exprs []parser.TypedExpr, err error) {
if len(src.sourceColumns) == 0 {
return nil, nil, fmt.Errorf("cannot use \"%s\" without a FROM clause", v)
}
colSel := func(idx int) {
col := src.sourceColumns[idx]
if !col.hidden {
qval := qvals.getQVal(columnRef{src, idx})
columns = append(columns, ResultColumn{Name: col.Name, Typ: qval.datum})
exprs = append(exprs, qval)
}
}
tableName := parser.TableName{}
if a, ok := v.(*parser.AllColumnsSelector); ok {
tableName = a.TableName
}
if tableName.Table() == "" {
for i := 0; i < len(src.sourceColumns); i++ {
colSel(i)
}
} else {
norm := sqlbase.NormalizeTableName(tableName)
qualifiedTn, err := src.checkDatabaseName(norm)
if err != nil {
return nil, nil, err
}
colRange, ok := src.sourceAliases[qualifiedTn]
if !ok {
return nil, nil, fmt.Errorf("table %q not found", tableName.String())
}
for _, i := range colRange {
colSel(i)
}
}
return columns, exprs, nil
}
// getTableDesc implements the SchemaAccessor interface.
func (p *planner) getTableDesc(tn *parser.TableName) (*sqlbase.TableDescriptor, error) {
virtual, err := getVirtualTableDesc(tn)
if err != nil || virtual != nil {
return virtual, err
}
dbDesc, err := p.mustGetDatabaseDesc(tn.Database())
if err != nil {
return nil, err
}
desc := sqlbase.TableDescriptor{}
found, err := p.getDescriptor(tableKey{parentID: dbDesc.ID, name: tn.Table()}, &desc)
if err != nil {
return nil, err
}
if !found {
return nil, nil
}
return &desc, nil
}
// findColumn looks up the column specified by a VarName. The normalized VarName
// is returned.
func (sources multiSourceInfo) findColumn(
c *parser.ColumnItem,
) (info *dataSourceInfo, colIdx int, err error) {
if len(c.Selector) > 0 {
return nil, invalidColIdx, util.UnimplementedWithIssueErrorf(8318, "compound types not supported yet: %q", c)
}
colName := sqlbase.NormalizeName(c.ColumnName)
var tableName parser.TableName
if c.TableName.Table() != "" {
tableName = sqlbase.NormalizeTableName(c.TableName)
tn, err := sources.checkDatabaseName(tableName)
if err != nil {
return nil, invalidColIdx, err
}
tableName = tn
// Propagate the discovered database name back to the original VarName.
// (to clarify the output of e.g. EXPLAIN)
c.TableName.DatabaseName = tableName.DatabaseName
}
colIdx = invalidColIdx
for _, src := range sources {
findCol := func(src, info *dataSourceInfo, colIdx int, idx int) (*dataSourceInfo, int, error) {
col := src.sourceColumns[idx]
if sqlbase.ReNormalizeName(col.Name) == colName {
if colIdx != invalidColIdx {
return nil, invalidColIdx, fmt.Errorf("column reference %q is ambiguous", c)
}
info = src
colIdx = idx
}
return info, colIdx, nil
}
if tableName.Table() == "" {
for idx := 0; idx < len(src.sourceColumns); idx++ {
info, colIdx, err = findCol(src, info, colIdx, idx)
if err != nil {
return info, colIdx, err
}
}
} else {
colRange, ok := src.sourceAliases[tableName]
if !ok {
// The data source "src" has no column for table tableName.
// Try again with the net one.
continue
}
for _, idx := range colRange {
info, colIdx, err = findCol(src, info, colIdx, idx)
if err != nil {
return info, colIdx, err
}
}
}
}
if colIdx == invalidColIdx {
return nil, invalidColIdx, fmt.Errorf("column name %q not found", c)
}
return info, colIdx, nil
}
// getTableLease implements the SchemaAccessor interface.
func (p *planner) getTableLease(tn *parser.TableName) (*sqlbase.TableDescriptor, error) {
if log.V(2) {
log.Infof(p.ctx(), "planner acquiring lease on table %s", tn)
}
isSystemDB := tn.Database() == sqlbase.SystemDB.Name
isVirtualDB := isVirtualDatabase(tn.Database())
if isSystemDB || isVirtualDB || testDisableTableLeases {
// We don't go through the normal lease mechanism for:
// - system tables. The system.lease and system.descriptor table, in
// particular, are problematic because they are used for acquiring
// leases itself, creating a chicken&egg problem.
// - virtual tables. These tables' descriptors are not persisted,
// so they cannot be leased. Instead, we simply return the static
// descriptor and rely on the immutability privileges set on the
// descriptors to cause upper layers to reject mutations statements.
tbl, err := p.mustGetTableDesc(tn)
if err != nil {
return nil, err
}
if err := filterTableState(tbl); err != nil {
return nil, err
}
return tbl, nil
}
dbID, err := p.getDatabaseID(tn.Database())
if err != nil {
return nil, err
}
// First, look to see if we already have a lease for this table.
// This ensures that, once a SQL transaction resolved name N to id X, it will
// continue to use N to refer to X even if N is renamed during the
// transaction.
var lease *LeaseState
for _, l := range p.leases {
if sqlbase.ReNormalizeName(l.Name) == sqlbase.NormalizeName(tn.TableName) &&
l.ParentID == dbID {
lease = l
if log.V(2) {
log.Infof(p.ctx(), "found lease in planner cache for table %q", tn)
}
break
}
}
// If we didn't find a lease or the lease is about to expire, acquire one.
if lease == nil || p.removeLeaseIfExpiring(lease) {
var err error
lease, err = p.leaseMgr.AcquireByName(p.txn, dbID, tn.Table())
if err != nil {
if err == sqlbase.ErrDescriptorNotFound {
// Transform the descriptor error into an error that references the
// table's name.
return nil, sqlbase.NewUndefinedTableError(tn.String())
}
return nil, err
}
p.leases = append(p.leases, lease)
// If the lease we just acquired expires before the txn's deadline, reduce
// the deadline.
p.txn.UpdateDeadlineMaybe(hlc.Timestamp{WallTime: lease.Expiration().UnixNano()})
}
return &lease.TableDescriptor, nil
}
