// getVirtualTableEntry checks if the provided name matches a virtual database/table // pair. The function will return the table's virtual table entry if the name matches // a specific table. It will return an error if the name references a virtual database // but the table is non-existent. func getVirtualTableEntry(tn *parser.TableName) (virtualTableEntry, error) { if db, ok := getVirtualSchemaEntry(tn.Database()); ok { if t, ok := db.tables[sqlbase.NormalizeName(tn.TableName)]; ok { return t, nil } return virtualTableEntry{}, sqlbase.NewUndefinedTableError(tn.String()) } return virtualTableEntry{}, nil }
// mustGetTableDesc implements the SchemaAccessor interface. func (p *planner) mustGetTableDesc(tn *parser.TableName) (*sqlbase.TableDescriptor, error) { desc, err := p.getTableDesc(tn) if err != nil { return nil, err } if desc == nil { return nil, sqlbase.NewUndefinedTableError(tn.String()) } if err := filterTableState(desc); err != nil { return nil, err } return desc, nil }
// checkDatabaseName checks whether the given TableName is unambiguous // within this source and if it is, qualifies the missing database name. func (src *dataSourceInfo) checkDatabaseName(tn parser.TableName) (parser.TableName, error) { found := false if tn.DatabaseName == "" { // No database name yet. Try to find one. for name := range src.sourceAliases { if name.TableName == tn.TableName { if found { return parser.TableName{}, fmt.Errorf("ambiguous source name: %q", tn.TableName) } tn.DatabaseName = name.DatabaseName found = true } } if !found { return parser.TableName{}, fmt.Errorf("source name %q not found in FROM clause", tn.TableName) } return tn, nil } // Database given. Check that the name is unambiguous. if _, ok := src.sourceAliases[tn]; ok { if found { return parser.TableName{}, fmt.Errorf("ambiguous source name: %q (within database %q)", tn.TableName, tn.DatabaseName) } found = true } if !found { return parser.TableName{}, fmt.Errorf("table %q not selected in FROM clause", &tn) } return tn, 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 }
func (c *conn) normalizeTableName(table *parser.TableName) error { if table.Qualifier == "" { if c.database == "" { return fmt.Errorf("no database specified") } table.Qualifier = c.database } if table.Name == "" { return fmt.Errorf("empty table name: %s", table) } return nil }
func (s *Server) normalizeTableName(database string, table *parser.TableName) error { if table.Qualifier == "" { if database == "" { return fmt.Errorf("no database specified") } table.Qualifier = database } if table.Name == "" { return fmt.Errorf("empty table name: %s", table) } return 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 }
// 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 }
// 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 }
// getDataSource builds a planDataSource from a single data source clause // (TableExpr) in a SelectClause. func (p *planner) getDataSource( src parser.TableExpr, hints *parser.IndexHints, scanVisibility scanVisibility, ) (planDataSource, error) { switch t := src.(type) { case *parser.NormalizableTableName: // Usual case: a table. tn, err := t.NormalizeWithDatabaseName(p.session.Database) if err != nil { return planDataSource{}, err } // Is this perhaps a name for a virtual table? ds, foundVirtual, err := p.getVirtualDataSource(tn) if err != nil { return planDataSource{}, err } if foundVirtual { return ds, nil } // This name designates a real table. scan := p.Scan() if err := scan.initTable(p, tn, hints, scanVisibility); err != nil { return planDataSource{}, err } return planDataSource{ info: newSourceInfoForSingleTable(*tn, scan.Columns()), plan: scan, }, nil case *parser.Subquery: // We have a subquery (this includes a simple "VALUES"). plan, err := p.newPlan(t.Select, nil, false) if err != nil { return planDataSource{}, err } return planDataSource{ info: newSourceInfoForSingleTable(parser.TableName{}, plan.Columns()), plan: plan, }, nil case *parser.JoinTableExpr: // Joins: two sources. left, err := p.getDataSource(t.Left, nil, scanVisibility) if err != nil { return left, err } right, err := p.getDataSource(t.Right, nil, scanVisibility) if err != nil { return right, err } return p.makeJoin(t.Join, left, right, t.Cond) case *parser.ParenTableExpr: return p.getDataSource(t.Expr, hints, scanVisibility) case *parser.AliasedTableExpr: // Alias clause: source AS alias(cols...) src, err := p.getDataSource(t.Expr, t.Hints, scanVisibility) if err != nil { return src, err } var tableAlias parser.TableName if t.As.Alias != "" { // If an alias was specified, use that. tableAlias.TableName = parser.Name(sqlbase.NormalizeName(t.As.Alias)) src.info.sourceAliases = sourceAliases{ tableAlias: fillColumnRange(0, len(src.info.sourceColumns)-1), } } colAlias := t.As.Cols if len(colAlias) > 0 { // Make a copy of the slice since we are about to modify the contents. src.info.sourceColumns = append([]ResultColumn(nil), src.info.sourceColumns...) // The column aliases can only refer to explicit columns. for colIdx, aliasIdx := 0, 0; aliasIdx < len(colAlias); colIdx++ { if colIdx >= len(src.info.sourceColumns) { var srcName string if tableAlias.DatabaseName != "" { srcName = tableAlias.String() } else { srcName = tableAlias.TableName.String() } return planDataSource{}, errors.Errorf( "source %q has %d columns available but %d columns specified", srcName, aliasIdx, len(colAlias)) } if src.info.sourceColumns[colIdx].hidden { continue } src.info.sourceColumns[colIdx].Name = string(colAlias[aliasIdx]) aliasIdx++ } } return src, nil default: return planDataSource{}, errors.Errorf("unsupported FROM type %T", src) } }
// 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 }