// ShowColumns of a table.
// Privileges: None.
// Notes: postgres does not have a SHOW COLUMNS statement.
// mysql only returns columns you have privileges on.
func (p *planner) ShowColumns(n *parser.ShowColumns) (planNode, error) {
desc, err := p.getTableDesc(n.Table)
if err != nil {
return nil, err
}
if desc == nil {
return nil, sqlbase.NewUndefinedTableError(n.Table.String())
}
v := &valuesNode{
columns: []ResultColumn{
{Name: "Field", Typ: parser.TypeString},
{Name: "Type", Typ: parser.TypeString},
{Name: "Null", Typ: parser.TypeBool},
{Name: "Default", Typ: parser.TypeString},
},
}
for i, col := range desc.Columns {
defaultExpr := parser.Datum(parser.DNull)
if e := desc.Columns[i].DefaultExpr; e != nil {
defaultExpr = parser.NewDString(*e)
}
v.rows = append(v.rows, []parser.Datum{
parser.NewDString(desc.Columns[i].Name),
parser.NewDString(col.Type.SQLString()),
parser.MakeDBool(parser.DBool(desc.Columns[i].Nullable)),
defaultExpr,
})
}
return v, nil
}
// SetUIData is an endpoint that stores the given key/value pairs in the
// system.ui table. See GetUIData for more details on semantics.
func (s *adminServer) SetUIData(ctx context.Context, req *SetUIDataRequest) (*SetUIDataResponse, error) {
if len(req.KeyValues) == 0 {
return nil, grpc.Errorf(codes.InvalidArgument, "KeyValues cannot be empty")
}
session := sql.NewSession(sql.SessionArgs{User: s.getUser(req)}, s.server.sqlExecutor, nil)
for key, val := range req.KeyValues {
// Do an upsert of the key. We update each key in a separate transaction to
// avoid long-running transactions and possible deadlocks.
br := s.server.sqlExecutor.ExecuteStatements(ctx, session, "BEGIN;", nil)
if err := s.checkQueryResults(br.ResultList, 1); err != nil {
return nil, s.serverError(err)
}
// See if the key already exists.
resp, err := s.getUIData(session, s.getUser(req), []string{key})
if err != nil {
return nil, s.serverError(err)
}
_, alreadyExists := resp.KeyValues[key]
// INSERT or UPDATE as appropriate.
if alreadyExists {
query := "UPDATE system.ui SET value = $1, lastUpdated = NOW() WHERE key = $2; COMMIT;"
params := []parser.Datum{
parser.NewDString(string(val)), // $1
parser.NewDString(key), // $2
}
r := s.server.sqlExecutor.ExecuteStatements(ctx, session, query, params)
if err := s.checkQueryResults(r.ResultList, 2); err != nil {
return nil, s.serverError(err)
}
if a, e := r.ResultList[0].RowsAffected, 1; a != e {
return nil, s.serverErrorf("rows affected %d != expected %d", a, e)
}
} else {
query := "INSERT INTO system.ui (key, value, lastUpdated) VALUES ($1, $2, NOW()); COMMIT;"
params := []parser.Datum{
parser.NewDString(key), // $1
parser.NewDBytes(parser.DBytes(val)), // $2
}
r := s.server.sqlExecutor.ExecuteStatements(ctx, session, query, params)
if err := s.checkQueryResults(r.ResultList, 2); err != nil {
return nil, s.serverError(err)
}
if a, e := r.ResultList[0].RowsAffected, 1; a != e {
return nil, s.serverErrorf("rows affected %d != expected %d", a, e)
}
}
}
return &SetUIDataResponse{}, nil
}
// ShowIndex returns all the indexes for a table.
// Privileges: Any privilege on table.
// Notes: postgres does not have a SHOW INDEXES statement.
// mysql requires some privilege for any column.
func (p *planner) ShowIndex(n *parser.ShowIndex) (planNode, error) {
tn, err := n.Table.NormalizeWithDatabaseName(p.session.Database)
if err != nil {
return nil, err
}
desc, err := p.mustGetTableDesc(tn)
if err != nil {
return nil, err
}
if err := p.anyPrivilege(desc); err != nil {
return nil, err
}
v := &valuesNode{
columns: []ResultColumn{
{Name: "Table", Typ: parser.TypeString},
{Name: "Name", Typ: parser.TypeString},
{Name: "Unique", Typ: parser.TypeBool},
{Name: "Seq", Typ: parser.TypeInt},
{Name: "Column", Typ: parser.TypeString},
{Name: "Direction", Typ: parser.TypeString},
{Name: "Storing", Typ: parser.TypeBool},
},
}
appendRow := func(index sqlbase.IndexDescriptor, colName string, sequence int,
direction string, isStored bool) {
v.rows = append(v.rows, []parser.Datum{
parser.NewDString(tn.Table()),
parser.NewDString(index.Name),
parser.MakeDBool(parser.DBool(index.Unique)),
parser.NewDInt(parser.DInt(sequence)),
parser.NewDString(colName),
parser.NewDString(direction),
parser.MakeDBool(parser.DBool(isStored)),
})
}
for _, index := range append([]sqlbase.IndexDescriptor{desc.PrimaryIndex}, desc.Indexes...) {
sequence := 1
for i, col := range index.ColumnNames {
appendRow(index, col, sequence, index.ColumnDirections[i].String(), false)
sequence++
}
for _, col := range index.StoreColumnNames {
appendRow(index, col, sequence, "N/A", true)
sequence++
}
}
return v, nil
}
// ShowTables returns all the tables.
// Privileges: None.
// Notes: postgres does not have a SHOW TABLES statement.
// mysql only returns tables you have privileges on.
func (p *planner) ShowTables(n *parser.ShowTables) (planNode, error) {
// TODO(pmattis): This could be implemented as:
//
// SELECT name FROM system.namespace
// WHERE parentID = (SELECT id FROM system.namespace
// WHERE parentID = 0 AND name = <database>)
name := n.Name
if name == nil {
if p.session.Database == "" {
return nil, errNoDatabase
}
name = &parser.QualifiedName{Base: parser.Name(p.session.Database)}
}
dbDesc, err := p.getDatabaseDesc(string(name.Base))
if err != nil {
return nil, err
}
if dbDesc == nil {
return nil, sqlbase.NewUndefinedDatabaseError(string(name.Base))
}
tableNames, err := p.getTableNames(dbDesc)
if err != nil {
return nil, err
}
v := &valuesNode{columns: []ResultColumn{{Name: "Table", Typ: parser.TypeString}}}
for _, name := range tableNames {
v.rows = append(v.rows, []parser.Datum{parser.NewDString(name.Table())})
}
return v, nil
}
// queryNamespaceID queries for the ID of the namespace with the given name and
// parent ID.
func (s *adminServer) queryNamespaceID(
session *sql.Session, parentID sqlbase.ID, name string,
) (sqlbase.ID, error) {
const query = `SELECT id FROM system.namespace WHERE parentID = $1 AND name = $2`
params := parser.NewPlaceholderInfo()
params.SetValue(`1`, parser.NewDInt(parser.DInt(parentID)))
params.SetValue(`2`, parser.NewDString(name))
r := s.server.sqlExecutor.ExecuteStatements(session, query, params)
if err := s.checkQueryResults(r.ResultList, 1); err != nil {
return 0, err
}
result := r.ResultList[0]
if len(result.Rows) == 0 {
return 0, errors.Errorf("namespace %s with ParentID %d not found", name, parentID)
}
var id int64
scanner := resultScanner{}
err := scanner.ScanIndex(result.Rows[0], 0, &id)
if err != nil {
return 0, err
}
return sqlbase.ID(id), nil
}
// ShowTables returns all the tables.
// Privileges: None.
// Notes: postgres does not have a SHOW TABLES statement.
// mysql only returns tables you have privileges on.
func (p *planner) ShowTables(n *parser.ShowTables) (planNode, error) {
// TODO(pmattis): This could be implemented as:
//
// SELECT name FROM system.namespace
// WHERE parentID = (SELECT id FROM system.namespace
// WHERE parentID = 0 AND name = <database>)
name := p.session.Database
if n.Database != "" {
name = string(n.Database)
}
if name == "" {
return nil, errNoDatabase
}
dbDesc, err := p.mustGetDatabaseDesc(name)
if err != nil {
return nil, err
}
tableNames, err := p.getTableNames(dbDesc)
if err != nil {
return nil, err
}
v := &valuesNode{columns: []ResultColumn{{Name: "Table", Typ: parser.TypeString}}}
for _, name := range tableNames {
v.rows = append(v.rows, []parser.Datum{parser.NewDString(name.Table())})
}
return v, nil
}
// ShowGrants returns grant details for the specified objects and users.
// TODO(marc): implement no targets (meaning full scan).
// Privileges: None.
// Notes: postgres does not have a SHOW GRANTS statement.
// mysql only returns the user's privileges.
func (p *planner) ShowGrants(n *parser.ShowGrants) (planNode, error) {
if n.Targets == nil {
return nil, util.Errorf("TODO(marc): implement SHOW GRANT with no targets")
}
descriptors, err := p.getDescriptorsFromTargetList(*n.Targets)
if err != nil {
return nil, err
}
objectType := "Database"
if n.Targets.Tables != nil {
objectType = "Table"
}
v := &valuesNode{
columns: []ResultColumn{
{Name: objectType, Typ: parser.TypeString},
{Name: "User", Typ: parser.TypeString},
{Name: "Privileges", Typ: parser.TypeString},
},
}
var wantedUsers map[string]struct{}
if len(n.Grantees) != 0 {
wantedUsers = make(map[string]struct{})
}
for _, u := range n.Grantees {
wantedUsers[u] = struct{}{}
}
for _, descriptor := range descriptors {
userPrivileges := descriptor.GetPrivileges().Show()
for _, userPriv := range userPrivileges {
if wantedUsers != nil {
if _, ok := wantedUsers[userPriv.User]; !ok {
continue
}
}
v.rows = append(v.rows, []parser.Datum{
parser.NewDString(descriptor.GetName()),
parser.NewDString(userPriv.User),
parser.NewDString(userPriv.Privileges),
})
}
}
return v, nil
}
// golangFillQueryArguments populates the placeholder map with
// types and values from an array of Go values.
// TODO: This does not support arguments of the SQL 'Date' type, as there is not
// an equivalent type in Go's standard library. It's not currently needed by any
// of our internal tables.
func golangFillQueryArguments(pinfo *parser.PlaceholderInfo, args []interface{}) {
pinfo.Clear()
for i, arg := range args {
k := fmt.Sprint(i + 1)
if arg == nil {
pinfo.SetValue(k, parser.DNull)
continue
}
// A type switch to handle a few explicit types with special semantics:
// - Datums are passed along as is.
// - Time datatypes get special representation in the database.
var d parser.Datum
switch t := arg.(type) {
case parser.Datum:
d = t
case time.Time:
d = parser.MakeDTimestamp(t, time.Microsecond)
case time.Duration:
d = &parser.DInterval{Duration: duration.Duration{Nanos: t.Nanoseconds()}}
case *inf.Dec:
dd := &parser.DDecimal{}
dd.Set(t)
d = dd
}
if d == nil {
// Handle all types which have an underlying type that can be stored in the
// database.
// Note: if this reflection becomes a performance concern in the future,
// commonly used types could be added explicitly into the type switch above
// for a performance gain.
val := reflect.ValueOf(arg)
switch val.Kind() {
case reflect.Bool:
d = parser.MakeDBool(parser.DBool(val.Bool()))
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
d = parser.NewDInt(parser.DInt(val.Int()))
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
d = parser.NewDInt(parser.DInt(val.Uint()))
case reflect.Float32, reflect.Float64:
d = parser.NewDFloat(parser.DFloat(val.Float()))
case reflect.String:
d = parser.NewDString(val.String())
case reflect.Slice:
// Handle byte slices.
if val.Type().Elem().Kind() == reflect.Uint8 {
d = parser.NewDBytes(parser.DBytes(val.Bytes()))
}
}
if d == nil {
panic(fmt.Sprintf("unexpected type %T", arg))
}
}
pinfo.SetValue(k, d)
}
}
// Events is an endpoint that returns the latest event log entries, with the following
// optional URL parameters:
//
// type=STRING returns events with this type (e.g. "create_table")
// targetID=INT returns events for that have this targetID
func (s *adminServer) Events(ctx context.Context, req *serverpb.EventsRequest) (*serverpb.EventsResponse, error) {
args := sql.SessionArgs{User: s.getUser(req)}
session := sql.NewSession(ctx, args, s.server.sqlExecutor, nil)
// Execute the query.
q := makeSQLQuery()
q.Append("SELECT timestamp, eventType, targetID, reportingID, info, uniqueID ")
q.Append("FROM system.eventlog ")
q.Append("WHERE true ") // This simplifies the WHERE clause logic below.
if len(req.Type) > 0 {
q.Append("AND eventType = $ ", parser.NewDString(req.Type))
}
if req.TargetId > 0 {
q.Append("AND targetID = $ ", parser.NewDInt(parser.DInt(req.TargetId)))
}
q.Append("ORDER BY timestamp DESC ")
q.Append("LIMIT $", parser.NewDInt(parser.DInt(apiEventLimit)))
if len(q.Errors()) > 0 {
return nil, s.serverErrors(q.Errors())
}
r := s.server.sqlExecutor.ExecuteStatements(session, q.String(), q.QueryArguments())
if err := s.checkQueryResults(r.ResultList, 1); err != nil {
return nil, s.serverError(err)
}
// Marshal response.
var resp serverpb.EventsResponse
scanner := makeResultScanner(r.ResultList[0].Columns)
for _, row := range r.ResultList[0].Rows {
var event serverpb.EventsResponse_Event
var ts time.Time
if err := scanner.ScanIndex(row, 0, &ts); err != nil {
return nil, err
}
event.Timestamp = serverpb.EventsResponse_Event_Timestamp{Sec: ts.Unix(), Nsec: uint32(ts.Nanosecond())}
if err := scanner.ScanIndex(row, 1, &event.EventType); err != nil {
return nil, err
}
if err := scanner.ScanIndex(row, 2, &event.TargetID); err != nil {
return nil, err
}
if err := scanner.ScanIndex(row, 3, &event.ReportingID); err != nil {
return nil, err
}
if err := scanner.ScanIndex(row, 4, &event.Info); err != nil {
return nil, err
}
if err := scanner.ScanIndex(row, 5, &event.UniqueID); err != nil {
return nil, err
}
resp.Events = append(resp.Events, event)
}
return &resp, nil
}
// Arg implements the parser.Args interface.
// TODO: This does not support arguments of the SQL 'Date' type, as there is not
// an equivalent type in Go's standard library. It's not currently needed by any
// of our internal tables.
func (gp golangParameters) Arg(name string) (parser.Datum, bool) {
i, err := processPositionalArgument(name)
if err != nil {
return nil, false
}
if i < 1 || int(i) > len(gp) {
return nil, false
}
arg := gp[i-1]
if arg == nil {
return parser.DNull, true
}
// A type switch to handle a few explicit types with special semantics.
switch t := arg.(type) {
// Datums are passed along as is.
case parser.Datum:
return t, true
// Time datatypes get special representation in the database.
case time.Time:
return parser.MakeDTimestamp(t, time.Microsecond), true
case time.Duration:
return &parser.DInterval{Duration: duration.Duration{Nanos: t.Nanoseconds()}}, true
case *inf.Dec:
dd := &parser.DDecimal{}
dd.Set(t)
return dd, true
}
// Handle all types which have an underlying type that can be stored in the
// database.
// Note: if this reflection becomes a performance concern in the future,
// commonly used types could be added explicitly into the type switch above
// for a performance gain.
val := reflect.ValueOf(arg)
switch val.Kind() {
case reflect.Bool:
return parser.MakeDBool(parser.DBool(val.Bool())), true
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return parser.NewDInt(parser.DInt(val.Int())), true
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return parser.NewDInt(parser.DInt(val.Uint())), true
case reflect.Float32, reflect.Float64:
return parser.NewDFloat(parser.DFloat(val.Float())), true
case reflect.String:
return parser.NewDString(val.String()), true
case reflect.Slice:
// Handle byte slices.
if val.Type().Elem().Kind() == reflect.Uint8 {
return parser.NewDBytes(parser.DBytes(val.Bytes())), true
}
}
panic(fmt.Sprintf("unexpected type %T", arg))
}
// Show a session-local variable name.
func (p *planner) Show(n *parser.Show) (planNode, error) {
name := strings.ToUpper(n.Name)
v := &valuesNode{columns: []ResultColumn{{Name: name, Typ: parser.TypeString}}}
switch name {
case `DATABASE`:
v.rows = append(v.rows, []parser.Datum{parser.NewDString(p.session.Database)})
case `TIME ZONE`:
v.rows = append(v.rows, []parser.Datum{parser.NewDString(p.session.Location.String())})
case `SYNTAX`:
v.rows = append(v.rows, []parser.Datum{parser.NewDString(parser.Syntax(p.session.Syntax).String())})
case `DEFAULT_TRANSACTION_ISOLATION`:
level := p.session.DefaultIsolationLevel.String()
v.rows = append(v.rows, []parser.Datum{parser.NewDString(level)})
case `TRANSACTION ISOLATION LEVEL`:
v.rows = append(v.rows, []parser.Datum{parser.NewDString(p.txn.Proto.Isolation.String())})
case `TRANSACTION PRIORITY`:
v.rows = append(v.rows, []parser.Datum{parser.NewDString(p.txn.UserPriority.String())})
default:
return nil, fmt.Errorf("unknown variable: %q", name)
}
return v, nil
}
// ShowColumns of a table.
// Privileges: Any privilege on table.
// Notes: postgres does not have a SHOW COLUMNS statement.
// mysql only returns columns you have privileges on.
func (p *planner) ShowColumns(n *parser.ShowColumns) (planNode, error) {
tn, err := n.Table.NormalizeWithDatabaseName(p.session.Database)
if err != nil {
return nil, err
}
desc, err := p.mustGetTableDesc(tn)
if err != nil {
return nil, err
}
if err := p.anyPrivilege(desc); err != nil {
return nil, err
}
v := &valuesNode{
columns: []ResultColumn{
{Name: "Field", Typ: parser.TypeString},
{Name: "Type", Typ: parser.TypeString},
{Name: "Null", Typ: parser.TypeBool},
{Name: "Default", Typ: parser.TypeString},
},
}
for i, col := range desc.Columns {
defaultExpr := parser.DNull
if e := desc.Columns[i].DefaultExpr; e != nil {
defaultExpr = parser.NewDString(*e)
}
v.rows = append(v.rows, []parser.Datum{
parser.NewDString(desc.Columns[i].Name),
parser.NewDString(col.Type.SQLString()),
parser.MakeDBool(parser.DBool(desc.Columns[i].Nullable)),
defaultExpr,
})
}
return v, nil
}
// ShowDatabases returns all the databases.
// Privileges: None.
// Notes: postgres does not have a "show databases"
// mysql has a "SHOW DATABASES" permission, but we have no system-level permissions.
func (p *planner) ShowDatabases(n *parser.ShowDatabases) (planNode, error) {
// TODO(pmattis): This could be implemented as:
//
// SELECT id FROM system.namespace WHERE parentID = 0
prefix := sqlbase.MakeNameMetadataKey(keys.RootNamespaceID, "")
sr, err := p.txn.Scan(prefix, prefix.PrefixEnd(), 0)
if err != nil {
return nil, err
}
v := &valuesNode{columns: []ResultColumn{{Name: "Database", Typ: parser.TypeString}}}
for db := range virtualSchemaMap {
v.rows = append(v.rows, []parser.Datum{parser.NewDString(db)})
}
for _, row := range sr {
_, name, err := encoding.DecodeUnsafeStringAscending(
bytes.TrimPrefix(row.Key, prefix), nil)
if err != nil {
return nil, err
}
v.rows = append(v.rows, []parser.Datum{parser.NewDString(name)})
}
return v, nil
}
// getUIData returns the values and timestamps for the given UI keys. Keys
// that are not found will not be returned.
func (s *adminServer) getUIData(session *sql.Session, user string, keys []string) (*serverpb.GetUIDataResponse, error) {
if len(keys) == 0 {
return &serverpb.GetUIDataResponse{}, nil
}
// Query database.
query := makeSQLQuery()
query.Append("SELECT key, value, lastUpdated FROM system.ui WHERE key IN (")
for i, key := range keys {
if i != 0 {
query.Append(",")
}
query.Append("$", parser.NewDString(key))
}
query.Append(");")
if err := query.Errors(); err != nil {
return nil, s.serverErrorf("error constructing query: %v", err)
}
r := s.server.sqlExecutor.ExecuteStatements(context.Background(),
session, query.String(), query.QueryArguments())
if err := s.checkQueryResults(r.ResultList, 1); err != nil {
return nil, s.serverError(err)
}
// Marshal results.
resp := serverpb.GetUIDataResponse{KeyValues: make(map[string]serverpb.GetUIDataResponse_Value)}
for _, row := range r.ResultList[0].Rows {
dKey, ok := row.Values[0].(*parser.DString)
if !ok {
return nil, s.serverErrorf("unexpected type for UI key: %T", row.Values[0])
}
dValue, ok := row.Values[1].(*parser.DBytes)
if !ok {
return nil, s.serverErrorf("unexpected type for UI value: %T", row.Values[1])
}
dLastUpdated, ok := row.Values[2].(*parser.DTimestamp)
if !ok {
return nil, s.serverErrorf("unexpected type for UI lastUpdated: %T", row.Values[2])
}
resp.KeyValues[string(*dKey)] = serverpb.GetUIDataResponse_Value{
Value: []byte(*dValue),
LastUpdated: serverpb.GetUIDataResponse_Timestamp{Sec: dLastUpdated.Unix(), Nsec: uint32(dLastUpdated.Nanosecond())},
}
}
return &resp, nil
}
// RandDatum generates a random Datum of the given type.
// If null is true, the datum can be DNull.
func RandDatum(rng *rand.Rand, typ ColumnType_Kind, null bool) parser.Datum {
if null && rng.Intn(10) == 0 {
return parser.DNull
}
switch typ {
case ColumnType_BOOL:
return parser.MakeDBool(rng.Intn(2) == 1)
case ColumnType_INT:
return parser.NewDInt(parser.DInt(rng.Int63()))
case ColumnType_FLOAT:
return parser.NewDFloat(parser.DFloat(rng.NormFloat64()))
case ColumnType_DECIMAL:
d := &parser.DDecimal{}
d.Dec.SetScale(inf.Scale(rng.Intn(40) - 20))
d.Dec.SetUnscaled(rng.Int63())
return d
case ColumnType_DATE:
return parser.NewDDate(parser.DDate(rng.Intn(10000)))
case ColumnType_TIMESTAMP:
return &parser.DTimestamp{Time: time.Unix(rng.Int63n(1000000), rng.Int63n(1000000))}
case ColumnType_INTERVAL:
return &parser.DInterval{Duration: duration.Duration{Months: rng.Int63n(1000),
Days: rng.Int63n(1000),
Nanos: rng.Int63n(1000000),
}}
case ColumnType_STRING:
// Generate a random ASCII string.
p := make([]byte, rng.Intn(10))
for i := range p {
p[i] = byte(1 + rng.Intn(127))
}
return parser.NewDString(string(p))
case ColumnType_BYTES:
p := make([]byte, rng.Intn(10))
_, _ = rng.Read(p)
return parser.NewDBytes(parser.DBytes(p))
case ColumnType_TIMESTAMPTZ:
return &parser.DTimestampTZ{Time: time.Unix(rng.Int63n(1000000), rng.Int63n(1000000))}
default:
panic(fmt.Sprintf("invalid type %s", typ))
}
}
func makePrefixRange(prefix parser.DString, datum parser.TypedExpr, complete bool) parser.TypedExpr {
if complete {
return parser.NewTypedComparisonExpr(
parser.EQ,
datum,
&prefix,
)
}
if len(prefix) == 0 {
return parser.MakeDBool(true)
}
return parser.NewTypedAndExpr(
parser.NewTypedComparisonExpr(
parser.GE,
datum,
&prefix,
),
parser.NewTypedComparisonExpr(
parser.LT,
datum,
parser.NewDString(string(roachpb.Key(prefix).PrefixEnd())),
),
)
}
func dumpTable(w io.Writer, conn *sqlConn, origDBName, origTableName string) error {
const limit = 100
// Escape names since they can't be used in placeholders.
dbname := parser.Name(origDBName).String()
tablename := parser.Name(origTableName).String()
if err := conn.Exec(fmt.Sprintf("SET DATABASE = %s", dbname), nil); err != nil {
return err
}
// Fetch all table metadata in a transaction and its time to guarantee it
// doesn't change between the various SHOW statements.
if err := conn.Exec("BEGIN", nil); err != nil {
return err
}
vals, err := conn.QueryRow("SELECT cluster_logical_timestamp()::int", nil)
if err != nil {
return err
}
clusterTSStart := vals[0].(int64)
clusterTS := time.Unix(0, clusterTSStart).Format(time.RFC3339Nano)
// Fetch table descriptor.
vals, err = conn.QueryRow(`
SELECT descriptor
FROM system.descriptor
JOIN system.namespace tables
ON tables.id = descriptor.id
JOIN system.namespace dbs
ON dbs.id = tables.parentid
WHERE tables.name = $1 AND dbs.name = $2`,
[]driver.Value{origTableName, origDBName})
if err == io.EOF {
return errors.Errorf("unknown database or table %s.%s", origTableName, origDBName)
} else if err != nil {
return err
}
b := vals[0].([]byte)
var desc sqlbase.Descriptor
if err := proto.Unmarshal(b, &desc); err != nil {
return err
}
table := desc.GetTable()
if table == nil {
return errors.New("internal error: expected table descriptor")
}
coltypes := make(map[string]string)
for _, c := range table.Columns {
coltypes[c.Name] = c.Type.SQLString()
}
primaryIndex := table.PrimaryIndex.Name
index := table.PrimaryIndex.ColumnNames
indexes := strings.Join(index, ", ")
// Build the SELECT query.
var sbuf bytes.Buffer
fmt.Fprintf(&sbuf, "SELECT %s, * FROM %s@%s AS OF SYSTEM TIME '%s'", indexes, tablename, primaryIndex, clusterTS)
var wbuf bytes.Buffer
fmt.Fprintf(&wbuf, " WHERE ROW (%s) > ROW (", indexes)
for i := range index {
if i > 0 {
wbuf.WriteString(", ")
}
fmt.Fprintf(&wbuf, "$%d", i+1)
}
wbuf.WriteString(")")
// No WHERE clause first time, so add a place to inject it.
fmt.Fprintf(&sbuf, "%%s ORDER BY %s LIMIT %d", indexes, limit)
bs := sbuf.String()
vals, err = conn.QueryRow(fmt.Sprintf("SHOW CREATE TABLE %s", tablename), nil)
if err != nil {
return err
}
create := vals[1].([]byte)
if _, err := w.Write(create); err != nil {
return err
}
if _, err := w.Write([]byte(";\n")); err != nil {
return err
}
if err := conn.Exec("COMMIT", nil); err != nil {
return err
}
// pk holds the last values of the fetched primary keys
var pk []driver.Value
q := fmt.Sprintf(bs, "")
for {
rows, err := conn.Query(q, pk)
if err != nil {
return err
}
cols := rows.Columns()
pkcols := cols[:len(index)]
cols = cols[len(index):]
inserts := make([][]string, 0, limit)
i := 0
for i < limit {
vals := make([]driver.Value, len(cols)+len(pkcols))
if err := rows.Next(vals); err == io.EOF {
break
} else if err != nil {
return err
}
if pk == nil {
q = fmt.Sprintf(bs, wbuf.String())
}
pk = vals[:len(index)]
vals = vals[len(index):]
ivals := make([]string, len(vals))
// Values need to be correctly encoded for INSERT statements in a text file.
for si, sv := range vals {
switch t := sv.(type) {
case nil:
ivals[si] = "NULL"
case bool:
ivals[si] = parser.MakeDBool(parser.DBool(t)).String()
case int64:
ivals[si] = parser.NewDInt(parser.DInt(t)).String()
case float64:
ivals[si] = parser.NewDFloat(parser.DFloat(t)).String()
case []byte:
switch ct := coltypes[cols[si]]; ct {
case "INTERVAL":
ivals[si] = fmt.Sprintf("'%s'", t)
case "DECIMAL":
ivals[si] = fmt.Sprintf("%s", t)
default:
// STRING and BYTES types can have optional length suffixes, so only examine
// the prefix of the type.
if strings.HasPrefix(coltypes[cols[si]], "STRING") {
ivals[si] = parser.NewDString(string(t)).String()
} else if strings.HasPrefix(coltypes[cols[si]], "BYTES") {
ivals[si] = parser.NewDBytes(parser.DBytes(t)).String()
} else {
panic(errors.Errorf("unknown []byte type: %s, %v: %s", t, cols[si], coltypes[cols[si]]))
}
}
case time.Time:
var d parser.Datum
ct := coltypes[cols[si]]
switch ct {
case "DATE":
d = parser.NewDDateFromTime(t, time.UTC)
case "TIMESTAMP":
d = parser.MakeDTimestamp(t, time.Nanosecond)
case "TIMESTAMP WITH TIME ZONE":
d = parser.MakeDTimestampTZ(t, time.Nanosecond)
default:
panic(errors.Errorf("unknown timestamp type: %s, %v: %s", t, cols[si], coltypes[cols[si]]))
}
ivals[si] = fmt.Sprintf("'%s'", d)
default:
panic(errors.Errorf("unknown field type: %T (%s)", t, cols[si]))
}
}
inserts = append(inserts, ivals)
i++
}
for si, sv := range pk {
b, ok := sv.([]byte)
if ok && strings.HasPrefix(coltypes[pkcols[si]], "STRING") {
// Primary key strings need to be converted to a go string, but not SQL
// encoded since they aren't being written to a text file.
pk[si] = string(b)
}
}
if err := rows.Close(); err != nil {
return err
}
if i == 0 {
break
}
fmt.Fprintf(w, "\nINSERT INTO %s VALUES", tablename)
for idx, values := range inserts {
if idx > 0 {
fmt.Fprint(w, ",")
}
fmt.Fprint(w, "\n\t(")
for vi, v := range values {
if vi > 0 {
fmt.Fprint(w, ", ")
}
fmt.Fprint(w, v)
}
fmt.Fprint(w, ")")
}
fmt.Fprintln(w, ";")
if i < limit {
break
}
}
return nil
}
func dStringOrNull(s *string) parser.Datum {
if s == nil {
return parser.DNull
}
return parser.NewDString(*s)
}
"github.com/pkg/errors"
)
var informationSchema = virtualSchema{
name: "information_schema",
tables: []virtualSchemaTable{
informationSchemaColumnsTable,
informationSchemaTablesTable,
},
}
var (
// defString is used as the value for columns included in the sql standard
// of information_schema that don't make sense for CockroachDB. This is
// identical to the behavior of MySQL.
defString = parser.NewDString("def")
// information_schema was defined before the BOOLEAN data type was added to
// the SQL specification. Because of this, boolean values are represented
// as strings.
yesString = parser.NewDString("YES")
noString = parser.NewDString("NO")
)
func yesOrNoDatum(b bool) parser.Datum {
if b {
return yesString
}
return noString
}
func TestValues(t *testing.T) {
defer leaktest.AfterTest(t)()
p := makePlanner()
vInt := int64(5)
vNum := 3.14159
vStr := "two furs one cub"
vBool := true
unsupp := &parser.RangeCond{}
intVal := func(v int64) *parser.NumVal {
return &parser.NumVal{Value: constant.MakeInt64(v)}
}
floatVal := func(f float64) *parser.CastExpr {
return &parser.CastExpr{
Expr: &parser.NumVal{Value: constant.MakeFloat64(f)},
Type: &parser.FloatColType{},
}
}
asRow := func(datums ...parser.Datum) []parser.DTuple {
return []parser.DTuple{datums}
}
makeValues := func(tuples ...*parser.Tuple) *parser.ValuesClause {
return &parser.ValuesClause{Tuples: tuples}
}
makeTuple := func(exprs ...parser.Expr) *parser.Tuple {
return &parser.Tuple{Exprs: exprs}
}
testCases := []struct {
stmt *parser.ValuesClause
rows []parser.DTuple
ok bool
}{
{
makeValues(makeTuple(intVal(vInt))),
asRow(parser.NewDInt(parser.DInt(vInt))),
true,
},
{
makeValues(makeTuple(intVal(vInt), intVal(vInt))),
asRow(parser.NewDInt(parser.DInt(vInt)), parser.NewDInt(parser.DInt(vInt))),
true,
},
{
makeValues(makeTuple(floatVal(vNum))),
asRow(parser.NewDFloat(parser.DFloat(vNum))),
true,
},
{
makeValues(makeTuple(parser.NewDString(vStr))),
asRow(parser.NewDString(vStr)),
true,
},
{
makeValues(makeTuple(parser.NewDBytes(parser.DBytes(vStr)))),
asRow(parser.NewDBytes(parser.DBytes(vStr))),
true,
},
{
makeValues(makeTuple(parser.MakeDBool(parser.DBool(vBool)))),
asRow(parser.MakeDBool(parser.DBool(vBool))),
true,
},
{
makeValues(makeTuple(unsupp)),
nil,
false,
},
}
for i, tc := range testCases {
plan, err := func() (_ planNode, err error) {
defer func() {
if r := recover(); r != nil {
err = errors.Errorf("%v", r)
}
}()
return p.ValuesClause(tc.stmt, nil)
}()
if err == nil != tc.ok {
t.Errorf("%d: error_expected=%t, but got error %v", i, tc.ok, err)
}
if plan != nil {
if err := plan.expandPlan(); err != nil {
t.Errorf("%d: unexpected error in expandPlan: %v", i, err)
continue
}
if err := plan.Start(); err != nil {
t.Errorf("%d: unexpected error in Start: %v", i, err)
continue
}
var rows []parser.DTuple
next, err := plan.Next()
for ; next; next, err = plan.Next() {
rows = append(rows, plan.Values())
}
if err != nil {
t.Error(err)
continue
}
if !reflect.DeepEqual(rows, tc.rows) {
t.Errorf("%d: expected rows:\n%+v\nactual rows:\n%+v", i, tc.rows, rows)
}
}
}
}
func dumpTable(w io.Writer, conn *sqlConn, origDBName, origTableName string) error {
const limit = 100
// Escape names since they can't be used in placeholders.
dbname := parser.Name(origDBName).String()
tablename := parser.Name(origTableName).String()
if err := conn.Exec(fmt.Sprintf("SET DATABASE = %s", dbname), nil); err != nil {
return err
}
// Fetch all table metadata in a transaction and its time to guarantee it
// doesn't change between the various SHOW statements.
if err := conn.Exec("BEGIN", nil); err != nil {
return err
}
vals, err := conn.QueryRow("SELECT cluster_logical_timestamp()::int", nil)
if err != nil {
return err
}
clusterTSStart := vals[0].(int64)
clusterTS := time.Unix(0, clusterTSStart).Format(time.RFC3339Nano)
// A previous version of the code did a SELECT on system.descriptor. This
// required the SELECT privilege to the descriptor table, which only root
// has. Allowing non-root to do this would let users see other users' table
// descriptors which is a problem in multi-tenancy.
// Fetch column types.
rows, err := conn.Query(fmt.Sprintf("SHOW COLUMNS FROM %s", tablename), nil)
if err != nil {
return err
}
vals = make([]driver.Value, 2)
coltypes := make(map[string]string)
for {
if err := rows.Next(vals); err == io.EOF {
break
} else if err != nil {
return err
}
name, ok := vals[0].(string)
if !ok {
return fmt.Errorf("unexpected value: %T", vals[1])
}
typ, ok := vals[1].(string)
if !ok {
return fmt.Errorf("unexpected value: %T", vals[4])
}
coltypes[name] = typ
}
if err := rows.Close(); err != nil {
return err
}
// index holds the names, in order, of the primary key columns.
var index []string
// Primary index is always the first index returned by SHOW INDEX.
rows, err = conn.Query(fmt.Sprintf("SHOW INDEX FROM %s", tablename), nil)
if err != nil {
return err
}
vals = make([]driver.Value, 5)
var primaryIndex string
// Find the primary index columns.
for {
if err := rows.Next(vals); err == io.EOF {
break
} else if err != nil {
return err
}
b, ok := vals[1].(string)
if !ok {
return fmt.Errorf("unexpected value: %T", vals[1])
}
if primaryIndex == "" {
primaryIndex = b
} else if primaryIndex != b {
break
}
b, ok = vals[4].(string)
if !ok {
return fmt.Errorf("unexpected value: %T", vals[4])
}
index = append(index, parser.Name(b).String())
}
if err := rows.Close(); err != nil {
return err
}
if len(index) == 0 {
return fmt.Errorf("no primary key index found")
}
indexes := strings.Join(index, ", ")
// Build the SELECT query.
var sbuf bytes.Buffer
fmt.Fprintf(&sbuf, "SELECT %s, * FROM %s@%s AS OF SYSTEM TIME '%s'", indexes, tablename, primaryIndex, clusterTS)
var wbuf bytes.Buffer
fmt.Fprintf(&wbuf, " WHERE ROW (%s) > ROW (", indexes)
for i := range index {
if i > 0 {
wbuf.WriteString(", ")
}
fmt.Fprintf(&wbuf, "$%d", i+1)
}
wbuf.WriteString(")")
// No WHERE clause first time, so add a place to inject it.
fmt.Fprintf(&sbuf, "%%s ORDER BY %s LIMIT %d", indexes, limit)
bs := sbuf.String()
vals, err = conn.QueryRow(fmt.Sprintf("SHOW CREATE TABLE %s", tablename), nil)
if err != nil {
return err
}
create := vals[1].(string)
if _, err := w.Write([]byte(create)); err != nil {
return err
}
if _, err := w.Write([]byte(";\n")); err != nil {
return err
}
if err := conn.Exec("COMMIT", nil); err != nil {
return err
}
// pk holds the last values of the fetched primary keys
var pk []driver.Value
q := fmt.Sprintf(bs, "")
for {
rows, err := conn.Query(q, pk)
if err != nil {
return err
}
cols := rows.Columns()
pkcols := cols[:len(index)]
cols = cols[len(index):]
inserts := make([][]string, 0, limit)
i := 0
for i < limit {
vals := make([]driver.Value, len(cols)+len(pkcols))
if err := rows.Next(vals); err == io.EOF {
break
} else if err != nil {
return err
}
if pk == nil {
q = fmt.Sprintf(bs, wbuf.String())
}
pk = vals[:len(index)]
vals = vals[len(index):]
ivals := make([]string, len(vals))
// Values need to be correctly encoded for INSERT statements in a text file.
for si, sv := range vals {
switch t := sv.(type) {
case nil:
ivals[si] = "NULL"
case bool:
ivals[si] = parser.MakeDBool(parser.DBool(t)).String()
case int64:
ivals[si] = parser.NewDInt(parser.DInt(t)).String()
case float64:
ivals[si] = parser.NewDFloat(parser.DFloat(t)).String()
case string:
ivals[si] = parser.NewDString(t).String()
case []byte:
switch ct := coltypes[cols[si]]; ct {
case "INTERVAL":
ivals[si] = fmt.Sprintf("'%s'", t)
case "BYTES":
ivals[si] = parser.NewDBytes(parser.DBytes(t)).String()
default:
// STRING and DECIMAL types can have optional length
// suffixes, so only examine the prefix of the type.
if strings.HasPrefix(coltypes[cols[si]], "STRING") {
ivals[si] = parser.NewDString(string(t)).String()
} else if strings.HasPrefix(coltypes[cols[si]], "DECIMAL") {
ivals[si] = string(t)
} else {
panic(errors.Errorf("unknown []byte type: %s, %v: %s", t, cols[si], coltypes[cols[si]]))
}
}
case time.Time:
var d parser.Datum
ct := coltypes[cols[si]]
switch ct {
case "DATE":
d = parser.NewDDateFromTime(t, time.UTC)
case "TIMESTAMP":
d = parser.MakeDTimestamp(t, time.Nanosecond)
case "TIMESTAMP WITH TIME ZONE":
d = parser.MakeDTimestampTZ(t, time.Nanosecond)
default:
panic(errors.Errorf("unknown timestamp type: %s, %v: %s", t, cols[si], coltypes[cols[si]]))
}
ivals[si] = fmt.Sprintf("'%s'", d)
default:
panic(errors.Errorf("unknown field type: %T (%s)", t, cols[si]))
}
}
inserts = append(inserts, ivals)
i++
}
for si, sv := range pk {
b, ok := sv.([]byte)
if ok && strings.HasPrefix(coltypes[pkcols[si]], "STRING") {
// Primary key strings need to be converted to a go string, but not SQL
// encoded since they aren't being written to a text file.
pk[si] = string(b)
}
}
if err := rows.Close(); err != nil {
return err
}
if i == 0 {
break
}
fmt.Fprintf(w, "\nINSERT INTO %s VALUES", tablename)
for idx, values := range inserts {
if idx > 0 {
fmt.Fprint(w, ",")
}
fmt.Fprint(w, "\n\t(")
for vi, v := range values {
if vi > 0 {
fmt.Fprint(w, ", ")
}
fmt.Fprint(w, v)
}
fmt.Fprint(w, ")")
}
fmt.Fprintln(w, ";")
if i < limit {
break
}
}
return nil
}
// ShowCreateTable returns a CREATE TABLE statement for the specified table in
// Traditional syntax.
// Privileges: None.
func (p *planner) ShowCreateTable(n *parser.ShowCreateTable) (planNode, error) {
desc, err := p.getTableDesc(n.Table)
if err != nil {
return nil, err
}
if desc == nil {
return nil, sqlbase.NewUndefinedTableError(n.Table.String())
}
v := &valuesNode{
columns: []ResultColumn{
{Name: "Table", Typ: parser.TypeString},
{Name: "CreateTable", Typ: parser.TypeString},
},
}
var buf bytes.Buffer
fmt.Fprintf(&buf, "CREATE TABLE %s (", quoteNames(n.Table.String()))
var primary string
for i, col := range desc.VisibleColumns() {
if i != 0 {
buf.WriteString(",")
}
buf.WriteString("\n\t")
fmt.Fprintf(&buf, "%s %s", quoteNames(col.Name), col.Type.SQLString())
if col.Nullable {
buf.WriteString(" NULL")
} else {
buf.WriteString(" NOT NULL")
}
if col.DefaultExpr != nil {
fmt.Fprintf(&buf, " DEFAULT %s", *col.DefaultExpr)
}
if desc.PrimaryIndex.ColumnIDs[0] == col.ID {
// Only set primary if the primary key is on a visible column (not rowid).
primary = fmt.Sprintf(",\n\tCONSTRAINT %s PRIMARY KEY (%s)",
quoteNames(desc.PrimaryIndex.Name),
quoteNames(desc.PrimaryIndex.ColumnNames...),
)
}
}
buf.WriteString(primary)
for _, idx := range desc.Indexes {
var storing string
if len(idx.StoreColumnNames) > 0 {
storing = fmt.Sprintf(" STORING (%s)", quoteNames(idx.StoreColumnNames...))
}
fmt.Fprintf(&buf, ",\n\t%sINDEX %s (%s)%s",
isUnique[idx.Unique],
quoteNames(idx.Name),
quoteNames(idx.ColumnNames...),
storing,
)
}
for _, e := range desc.Checks {
fmt.Fprintf(&buf, ",\n\t")
if len(e.Name) > 0 {
fmt.Fprintf(&buf, "CONSTRAINT %s ", quoteNames(e.Name))
}
fmt.Fprintf(&buf, "CHECK (%s)", e.Expr)
}
buf.WriteString("\n)")
v.rows = append(v.rows, []parser.Datum{
parser.NewDString(n.Table.String()),
parser.NewDString(buf.String()),
})
return v, nil
}
// ShowCreateTable returns a CREATE TABLE statement for the specified table in
// Traditional syntax.
// Privileges: None.
func (p *planner) ShowCreateTable(n *parser.ShowCreateTable) (planNode, error) {
desc, err := p.mustGetTableDesc(n.Table)
if err != nil {
return nil, err
}
v := &valuesNode{
columns: []ResultColumn{
{Name: "Table", Typ: parser.TypeString},
{Name: "CreateTable", Typ: parser.TypeString},
},
}
var buf bytes.Buffer
fmt.Fprintf(&buf, "CREATE TABLE %s (", quoteNames(n.Table.String()))
var primary string
for i, col := range desc.VisibleColumns() {
if i != 0 {
buf.WriteString(",")
}
buf.WriteString("\n\t")
fmt.Fprintf(&buf, "%s %s", quoteNames(col.Name), col.Type.SQLString())
if col.NullableConstraintName != "" {
fmt.Fprintf(&buf, " CONSTRAINT %s", col.NullableConstraintName)
}
if col.Nullable {
buf.WriteString(" NULL")
} else {
buf.WriteString(" NOT NULL")
}
if col.DefaultExpr != nil {
if col.DefaultExprConstraintName != "" {
fmt.Fprintf(&buf, " CONSTRAINT %s", col.DefaultExprConstraintName)
}
fmt.Fprintf(&buf, " DEFAULT %s", *col.DefaultExpr)
}
if desc.PrimaryIndex.ColumnIDs[0] == col.ID {
// Only set primary if the primary key is on a visible column (not rowid).
primary = fmt.Sprintf(",\n\tCONSTRAINT %s PRIMARY KEY (%s)",
quoteNames(desc.PrimaryIndex.Name),
quoteNames(desc.PrimaryIndex.ColumnNames...),
)
}
}
buf.WriteString(primary)
for _, idx := range desc.Indexes {
var storing string
if len(idx.StoreColumnNames) > 0 {
storing = fmt.Sprintf(" STORING (%s)", quoteNames(idx.StoreColumnNames...))
}
interleave, err := p.showCreateInterleave(&idx)
if err != nil {
return nil, err
}
fmt.Fprintf(&buf, ",\n\t%sINDEX %s (%s)%s%s",
isUnique[idx.Unique],
quoteNames(idx.Name),
quoteNames(idx.ColumnNames...),
storing,
interleave,
)
}
for _, fam := range desc.Families {
activeColumnNames := make([]string, 0, len(fam.ColumnNames))
for i, colID := range fam.ColumnIDs {
if _, err := desc.FindActiveColumnByID(colID); err == nil {
activeColumnNames = append(activeColumnNames, fam.ColumnNames[i])
}
}
fmt.Fprintf(&buf, ",\n\tFAMILY %s (%s)",
quoteNames(fam.Name),
quoteNames(activeColumnNames...),
)
}
for _, e := range desc.Checks {
fmt.Fprintf(&buf, ",\n\t")
if len(e.Name) > 0 {
fmt.Fprintf(&buf, "CONSTRAINT %s ", quoteNames(e.Name))
}
fmt.Fprintf(&buf, "CHECK (%s)", e.Expr)
}
buf.WriteString("\n)")
interleave, err := p.showCreateInterleave(&desc.PrimaryIndex)
if err != nil {
return nil, err
}
buf.WriteString(interleave)
v.rows = append(v.rows, []parser.Datum{
parser.NewDString(n.Table.String()),
parser.NewDString(buf.String()),
})
return v, nil
}
// ShowConstraints returns all the constraints for a table.
// Privileges: None.
// Notes: postgres does not have a SHOW CONSTRAINTS statement.
// mysql requires some privilege for any column.
func (p *planner) ShowConstraints(n *parser.ShowConstraints) (planNode, error) {
desc, err := p.mustGetTableDesc(n.Table)
if err != nil {
return nil, err
}
v := &valuesNode{
columns: []ResultColumn{
{Name: "Table", Typ: parser.TypeString},
{Name: "Name", Typ: parser.TypeString},
{Name: "Type", Typ: parser.TypeString},
{Name: "Column(s)", Typ: parser.TypeString},
{Name: "Details", Typ: parser.TypeString},
},
}
appendRow := func(name, typ, columns, details string) {
detailsDatum := parser.DNull
if details != "" {
detailsDatum = parser.NewDString(details)
}
columnsDatum := parser.DNull
if columns != "" {
columnsDatum = parser.NewDString(columns)
}
v.rows = append(v.rows, []parser.Datum{
parser.NewDString(n.Table.Table()),
parser.NewDString(name),
parser.NewDString(typ),
columnsDatum,
detailsDatum,
})
}
for _, index := range append([]sqlbase.IndexDescriptor{desc.PrimaryIndex}, desc.Indexes...) {
if index.ID == desc.PrimaryIndex.ID {
appendRow(index.Name, "PRIMARY KEY", fmt.Sprintf("%+v", index.ColumnNames), "")
} else if index.Unique {
appendRow(index.Name, "UNIQUE", fmt.Sprintf("%+v", index.ColumnNames), "")
}
if index.ForeignKey != nil {
other, err := p.getTableLeaseByID(index.ForeignKey.Table)
if err != nil {
return nil, errors.Errorf("error resolving table %d referenced in foreign key",
index.ForeignKey.Table)
}
otherIdx, err := other.FindIndexByID(index.ForeignKey.Index)
if err != nil {
return nil, errors.Errorf("error resolving index %d in table %s referenced in foreign key",
index.ForeignKey.Index, other.Name)
}
appendRow(index.ForeignKey.Name, "FOREIGN KEY", fmt.Sprintf("%v", index.ColumnNames),
fmt.Sprintf("%s.%v", other.Name, otherIdx.ColumnNames))
}
}
for _, c := range desc.Checks {
appendRow(c.Name, "CHECK", "", c.Expr)
}
for _, c := range desc.Columns {
if c.DefaultExprConstraintName != "" {
appendRow(c.DefaultExprConstraintName, "DEFAULT", c.Name, *c.DefaultExpr)
}
if c.NullableConstraintName != "" {
if c.Nullable {
appendRow(c.NullableConstraintName, "NULL", c.Name, "")
} else {
appendRow(c.NullableConstraintName, "NOT NULL", c.Name, "")
}
}
}
// Sort the results by constraint name.
sort := &sortNode{
ordering: sqlbase.ColumnOrdering{
{ColIdx: 0, Direction: encoding.Ascending},
{ColIdx: 1, Direction: encoding.Ascending},
},
columns: v.columns,
}
return &selectTopNode{source: v, sort: sort}, nil
}
// RowEnglishFn is a GenValueFn which returns an English representation of the
// row number, as a DString
func RowEnglishFn(row int) parser.Datum {
return parser.NewDString(IntToEnglish(row))
}
// decodeOidDatum decodes bytes with specified Oid and format code into
// a datum.
func decodeOidDatum(id oid.Oid, code formatCode, b []byte) (parser.Datum, error) {
var d parser.Datum
switch id {
case oid.T_bool:
switch code {
case formatText:
v, err := strconv.ParseBool(string(b))
if err != nil {
return d, err
}
d = parser.MakeDBool(parser.DBool(v))
case formatBinary:
switch b[0] {
case 0:
d = parser.MakeDBool(false)
case 1:
d = parser.MakeDBool(true)
default:
return d, util.Errorf("unsupported binary bool: %q", b)
}
default:
return d, util.Errorf("unsupported bool format code: %s", code)
}
case oid.T_int2:
switch code {
case formatText:
i, err := strconv.ParseInt(string(b), 10, 64)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
case formatBinary:
var i int16
err := binary.Read(bytes.NewReader(b), binary.BigEndian, &i)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
default:
return d, util.Errorf("unsupported int2 format code: %s", code)
}
case oid.T_int4:
switch code {
case formatText:
i, err := strconv.ParseInt(string(b), 10, 64)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
case formatBinary:
var i int32
err := binary.Read(bytes.NewReader(b), binary.BigEndian, &i)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
default:
return d, util.Errorf("unsupported int4 format code: %s", code)
}
case oid.T_int8:
switch code {
case formatText:
i, err := strconv.ParseInt(string(b), 10, 64)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
case formatBinary:
var i int64
err := binary.Read(bytes.NewReader(b), binary.BigEndian, &i)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
default:
return d, util.Errorf("unsupported int8 format code: %s", code)
}
case oid.T_float4:
switch code {
case formatText:
f, err := strconv.ParseFloat(string(b), 64)
if err != nil {
return d, err
}
d = parser.NewDFloat(parser.DFloat(f))
case formatBinary:
var f float32
err := binary.Read(bytes.NewReader(b), binary.BigEndian, &f)
if err != nil {
return d, err
}
d = parser.NewDFloat(parser.DFloat(f))
default:
return d, util.Errorf("unsupported float4 format code: %s", code)
}
case oid.T_float8:
switch code {
case formatText:
f, err := strconv.ParseFloat(string(b), 64)
if err != nil {
return d, err
}
d = parser.NewDFloat(parser.DFloat(f))
case formatBinary:
var f float64
err := binary.Read(bytes.NewReader(b), binary.BigEndian, &f)
if err != nil {
return d, err
}
d = parser.NewDFloat(parser.DFloat(f))
default:
return d, util.Errorf("unsupported float8 format code: %s", code)
}
case oid.T_numeric:
switch code {
case formatText:
dd := &parser.DDecimal{}
if _, ok := dd.SetString(string(b)); !ok {
return nil, util.Errorf("could not parse string %q as decimal", b)
}
d = dd
case formatBinary:
r := bytes.NewReader(b)
alloc := struct {
pgNum pgNumeric
i16 int16
dd parser.DDecimal
}{}
for _, ptr := range []interface{}{
&alloc.pgNum.ndigits,
&alloc.pgNum.weight,
&alloc.pgNum.sign,
&alloc.pgNum.dscale,
} {
if err := binary.Read(r, binary.BigEndian, ptr); err != nil {
return d, err
}
}
decDigits := make([]byte, 0, alloc.pgNum.ndigits*pgDecDigits)
for i := int16(0); i < alloc.pgNum.ndigits-1; i++ {
if err := binary.Read(r, binary.BigEndian, &alloc.i16); err != nil {
return d, err
}
decDigits = strconv.AppendUint(decDigits, uint64(alloc.i16), 10)
}
// The last digit may contain padding, which we need to deal with.
if err := binary.Read(r, binary.BigEndian, &alloc.i16); err != nil {
return d, err
}
dscale := (alloc.pgNum.ndigits - 1 - alloc.pgNum.weight) * pgDecDigits
if overScale := dscale - alloc.pgNum.dscale; overScale > 0 {
dscale -= overScale
for i := int16(0); i < overScale; i++ {
alloc.i16 /= 10
}
}
decDigits = strconv.AppendUint(decDigits, uint64(alloc.i16), 10)
alloc.dd.UnscaledBig().SetString(string(decDigits), 10)
alloc.dd.SetScale(inf.Scale(dscale))
switch alloc.pgNum.sign {
case pgNumericPos:
case pgNumericNeg:
alloc.dd.Neg(&alloc.dd.Dec)
default:
return d, util.Errorf("unsupported numeric sign: %s", alloc.pgNum.sign)
}
d = &alloc.dd
default:
return d, util.Errorf("unsupported numeric format code: %s", code)
}
case oid.T_text, oid.T_varchar:
switch code {
case formatText, formatBinary:
d = parser.NewDString(string(b))
default:
return d, util.Errorf("unsupported text format code: %s", code)
}
case oid.T_bytea:
switch code {
case formatText:
// http://www.postgresql.org/docs/current/static/datatype-binary.html#AEN5667
// Code cribbed from github.com/lib/pq.
// We only support hex encoding.
if len(b) >= 2 && bytes.Equal(b[:2], []byte("\\x")) {
b = b[2:] // trim off leading "\\x"
result := make([]byte, hex.DecodedLen(len(b)))
_, err := hex.Decode(result, b)
if err != nil {
return d, err
}
d = parser.NewDBytes(parser.DBytes(result))
} else {
return d, util.Errorf("unsupported bytea encoding: %q", b)
}
case formatBinary:
d = parser.NewDBytes(parser.DBytes(b))
default:
return d, util.Errorf("unsupported bytea format code: %s", code)
}
case oid.T_timestamp, oid.T_timestamptz:
switch code {
case formatText:
ts, err := parseTs(string(b))
if err != nil {
return d, util.Errorf("could not parse string %q as timestamp", b)
}
d = parser.MakeDTimestamp(ts, time.Microsecond)
default:
return d, util.Errorf("unsupported timestamp format code: %s", code)
}
case oid.T_date:
switch code {
case formatText:
ts, err := parseTs(string(b))
if err != nil {
return d, util.Errorf("could not parse string %q as date", b)
}
daysSinceEpoch := ts.Unix() / secondsInDay
d = parser.NewDDate(parser.DDate(daysSinceEpoch))
default:
return d, util.Errorf("unsupported date format code: %s", code)
}
default:
return d, util.Errorf("unsupported OID: %v", id)
}
return d, nil
}
// decodeOidDatum decodes bytes with specified Oid and format code into
// a datum.
func decodeOidDatum(id oid.Oid, code formatCode, b []byte) (parser.Datum, error) {
var d parser.Datum
switch id {
case oid.T_bool:
switch code {
case formatText:
v, err := strconv.ParseBool(string(b))
if err != nil {
return d, err
}
d = parser.MakeDBool(parser.DBool(v))
default:
return d, fmt.Errorf("unsupported bool format code: %d", code)
}
case oid.T_int2:
switch code {
case formatText:
i, err := strconv.ParseInt(string(b), 10, 64)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
case formatBinary:
var i int16
err := binary.Read(bytes.NewReader(b), binary.BigEndian, &i)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
default:
return d, fmt.Errorf("unsupported int2 format code: %d", code)
}
case oid.T_int4:
switch code {
case formatText:
i, err := strconv.ParseInt(string(b), 10, 64)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
case formatBinary:
var i int32
err := binary.Read(bytes.NewReader(b), binary.BigEndian, &i)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
default:
return d, fmt.Errorf("unsupported int4 format code: %d", code)
}
case oid.T_int8:
switch code {
case formatText:
i, err := strconv.ParseInt(string(b), 10, 64)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
case formatBinary:
var i int64
err := binary.Read(bytes.NewReader(b), binary.BigEndian, &i)
if err != nil {
return d, err
}
d = parser.NewDInt(parser.DInt(i))
default:
return d, fmt.Errorf("unsupported int8 format code: %d", code)
}
case oid.T_float4:
switch code {
case formatText:
f, err := strconv.ParseFloat(string(b), 64)
if err != nil {
return d, err
}
d = parser.NewDFloat(parser.DFloat(f))
case formatBinary:
var f float32
err := binary.Read(bytes.NewReader(b), binary.BigEndian, &f)
if err != nil {
return d, err
}
d = parser.NewDFloat(parser.DFloat(f))
default:
return d, fmt.Errorf("unsupported float4 format code: %d", code)
}
case oid.T_float8:
switch code {
case formatText:
f, err := strconv.ParseFloat(string(b), 64)
if err != nil {
return d, err
}
d = parser.NewDFloat(parser.DFloat(f))
case formatBinary:
var f float64
err := binary.Read(bytes.NewReader(b), binary.BigEndian, &f)
if err != nil {
return d, err
}
d = parser.NewDFloat(parser.DFloat(f))
default:
return d, fmt.Errorf("unsupported float8 format code: %d", code)
}
case oid.T_numeric:
switch code {
case formatText:
dd := &parser.DDecimal{}
if _, ok := dd.SetString(string(b)); !ok {
return nil, fmt.Errorf("could not parse string %q as decimal", b)
}
d = dd
default:
return d, fmt.Errorf("unsupported numeric format code: %d", code)
}
case oid.T_text, oid.T_varchar:
switch code {
case formatText:
d = parser.NewDString(string(b))
default:
return d, fmt.Errorf("unsupported text format code: %d", code)
}
case oid.T_bytea:
switch code {
case formatText:
// http://www.postgresql.org/docs/current/static/datatype-binary.html#AEN5667
// Code cribbed from github.com/lib/pq.
// We only support hex encoding.
if len(b) >= 2 && bytes.Equal(b[:2], []byte("\\x")) {
b = b[2:] // trim off leading "\\x"
result := make([]byte, hex.DecodedLen(len(b)))
_, err := hex.Decode(result, b)
if err != nil {
return d, err
}
d = parser.NewDBytes(parser.DBytes(result))
} else {
return d, fmt.Errorf("unsupported bytea encoding: %q", b)
}
case formatBinary:
d = parser.NewDBytes(parser.DBytes(b))
default:
return d, fmt.Errorf("unsupported bytea format code: %d", code)
}
case oid.T_timestamp, oid.T_timestamptz:
switch code {
case formatText:
ts, err := parseTs(string(b))
if err != nil {
return d, fmt.Errorf("could not parse string %q as timestamp", b)
}
d = &parser.DTimestamp{Time: ts}
case formatBinary:
return d, fmt.Errorf("unsupported timestamp format code: %d", code)
}
case oid.T_date:
switch code {
case formatText:
ts, err := parseTs(string(b))
if err != nil {
return d, fmt.Errorf("could not parse string %q as date", b)
}
daysSinceEpoch := ts.Unix() / secondsInDay
d = parser.NewDDate(parser.DDate(daysSinceEpoch))
case formatBinary:
return d, fmt.Errorf("unsupported date format code: %d", code)
}
default:
return d, fmt.Errorf("unsupported OID: %v", id)
}
return d, nil
}