// 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 }