Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
fix(oracle): resolve database links by exact connect endpoint (#21468)
Vincent Huangc858a6e4ceca
diff --git a/backend/api/v1/sql_service.go b/backend/api/v1/sql_service.goindex 8d168a93cf..962daaeca8 100644--- a/backend/api/v1/sql_service.go+++ b/backend/api/v1/sql_service.go@@ -399,6 +399,7 @@ func (s *SQLService) Query(ctx context.Context, req *connect.Request[v1pb.QueryRstartTime := time.Now()queryContext := db.QueryContext{Explain: request.Explain,+ DataSourceType: dataSource.GetType(),Limit: int(queryRestriction.MaximumResultRows),OperatorEmail: user.Email,Option: request.QueryOption,@@ -640,6 +641,7 @@ func generateNewColumn(engine storepb.Engine, column parserbase.ColumnResource,switch engine {case storepb.Engine_POSTGRES:return parserbase.ColumnResource{+ Instance: column.Instance,Server: column.Server,Database: column.Database,Schema: database,@@ -648,6 +650,7 @@ func generateNewColumn(engine storepb.Engine, column parserbase.ColumnResource,}default:return parserbase.ColumnResource{+ Instance: column.Instance,Server: column.Server,Database: database,Schema: schema,@@ -657,6 +660,155 @@ func generateNewColumn(engine storepb.Engine, column parserbase.ColumnResource,}}+// privateDatabaseLinkOwner is implemented by a driver whose session account can own+// private database links (Oracle).+type privateDatabaseLinkOwner interface {+ OwnsPrivateDatabaseLink(ctx context.Context, conn *sql.Conn) (bool, error)+}++// refuseLinkedReadsShadowedByPrivateLinks refuses a linked read when the executing account+// owns any private database link. Oracle resolves @name to the executing account's private+// link before a public one, and the sync recorded the admin account's links only, so a+// private link on another account can shadow the synced definition. No link name is+// compared: Oracle expands a bare name with the database domain and accepts connection+// qualifiers, and the synced list cannot settle either. The admin data source is the synced+// account and is exempt. Runs on the executing connection right before execution, so a link+// created by an earlier statement of the same request is seen. A failed check refuses.+// BYT-10239 replaces this with resolution from the executing session's own links.+func refuseLinkedReadsShadowedByPrivateLinks(ctx context.Context, driver db.Driver, conn *sql.Conn, instance *store.InstanceMessage, queryContext db.QueryContext, spans []*parserbase.QuerySpan) error {+ if instance.Metadata.GetEngine() != storepb.Engine_ORACLE || queryContext.DataSourceType == storepb.DataSourceType_ADMIN {+ return nil+ }+ linked := linkedColumns(spans)+ if len(linked) == 0 {+ return nil+ }+ owner, ok := driver.(privateDatabaseLinkOwner)+ if !ok || conn == nil {+ return privateLinkRefusal(ctx, linked, false, errors.New("the driver exposes no session connection"))+ }+ owns, err := owner.OwnsPrivateDatabaseLink(ctx, conn)+ return privateLinkRefusal(ctx, linked, owns, err)+}++// linkedColumns lists the columns reached through a resolved database link, in a stable order.+func linkedColumns(spans []*parserbase.QuerySpan) []parserbase.ColumnResource {+ var linked []parserbase.ColumnResource+ for _, span := range spans {+ if span == nil {+ continue+ }+ for column := range span.SourceColumns {+ if column.Instance != "" {+ linked = append(linked, column)+ }+ }+ }+ slices.SortFunc(linked, func(a, b parserbase.ColumnResource) int { return strings.Compare(a.String(), b.String()) })+ return linked+}++// privateLinkRefusal is the verdict of refuseLinkedReadsShadowedByPrivateLinks: nil only when+// the check ran and found no private link.+func privateLinkRefusal(ctx context.Context, linked []parserbase.ColumnResource, owns bool, err error) error {+ if err != nil {+ return connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to check the executing account's private database links; %s", linkedTableRefusal(linked[0], "is not executed")))+ }+ if owns {+ return permissionDeniedError(ctx, errors.New(linkedTableRefusal(linked[0], "cannot be authorized: the executing account owns private database links, which Oracle resolves before the public links Bytebase synced. Run the query under the admin data source, or remove the private links from the account behind the read-only data source (BYT-10239)")))+ }+ return nil+}++// refuseLinkedTargetsOutsideProject mirrors authorizeWriteTargets: the access check+// evaluates the session project's IAM policy only, so a target in another project is+// refused. Runs after remoteColumnRefusal, so every linked column is on the connected+// instance. SUP-222 / BYT-9698, BYT-10226.+func (s *SQLService) refuseLinkedTargetsOutsideProject(ctx context.Context, columns parserbase.SourceColumnSet, instance *store.InstanceMessage, database *store.DatabaseMessage, perm permission.Permission) (*queryError, error) {+ targets := map[string]*store.DatabaseMessage{}+ for _, column := range linkedColumns([]*parserbase.QuerySpan{{SourceColumns: columns}}) {+ target, seen := targets[column.Database]+ if !seen {+ databaseName := column.Database+ var err error+ target, err = s.store.GetDatabase(ctx, &store.FindDatabaseMessage{+ Workspace: common.GetWorkspaceIDFromContext(ctx),+ InstanceID: &instance.ResourceID,+ DatabaseName: &databaseName,+ })+ if err != nil {+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to resolve linked database %q: %v", column.Database, err))+ }+ targets[column.Database] = target+ }+ if qe := linkedTargetProjectRefusal(ctx, column, target, database.ProjectID, perm); qe != nil {+ return qe, nil+ }+ }+ return nil, nil+}++// linkedTargetProjectRefusal decides refuseLinkedTargetsOutsideProject for one column, given+// the database the link resolved to (nil when Bytebase does not track it).+func linkedTargetProjectRefusal(ctx context.Context, column parserbase.ColumnResource, target *store.DatabaseMessage, requestProjectID string, perm permission.Permission) *queryError {+ var message string+ switch {+ case target == nil:+ message = linkedTableRefusal(column, "is in a database Bytebase does not track on this instance")+ case target.ProjectID != requestProjectID:+ message = linkedTableRefusal(column, fmt.Sprintf("is in project %q: reading another project's database through a link is not supported in SQL Editor", target.ProjectID))+ default:+ return nil+ }+ return &queryError{+ err: permissionDeniedError(ctx, errors.New(message)),+ permission: perm,+ }+}++// linkedTableRefusal names the linked table as written (an unqualified unresolved reference+// has no database) followed by the reason.+func linkedTableRefusal(column parserbase.ColumnResource, reason string) string {+ table := column.Table+ if column.Database != "" {+ table = column.Database + "." + table+ }+ return fmt.Sprintf("table %s reached through database link %q %s", table, column.Server, reason)+}++// remoteColumnRefusal refuses an Oracle database link Bytebase could not resolve or that+// resolves to another instance. The error carries no resource: a placeholder would satisfy+// a negated condition (table_name != "x") and request-access would offer a grant that+// cannot help. BYT-10226.+func remoteColumnRefusal(ctx context.Context, columns parserbase.SourceColumnSet, connectedInstanceID string, perm permission.Permission) *queryError {+ var remote []parserbase.ColumnResource+ for column := range columns {+ if column.Server != "" {+ remote = append(remote, column)+ }+ }+ slices.SortFunc(remote, func(a, b parserbase.ColumnResource) int { return strings.Compare(a.String(), b.String()) })+ for _, column := range remote {+ var message string+ switch {+ case column.Instance == "":+ message = linkedTableRefusal(column, "cannot be authorized: Bytebase could not establish which database it reaches. A link is authorized when the connect string Bytebase synced for it names the host, port and service of a data source of exactly one instance")+ case column.Instance != connectedInstanceID:+ // Links to another instance are refused until the masker resolves a linked column's+ // policy on its own instance; it lists databases by name on the connected instance+ // (BYT-10237).+ message = linkedTableRefusal(column, fmt.Sprintf("is on instance %q: querying another instance through a database link is not supported in SQL Editor", column.Instance))+ default:+ continue+ }+ return &queryError{+ err: permissionDeniedError(ctx, errors.New(message)),+ permission: perm,+ }+ }+ return nil+}+func isBackupTable(engine storepb.Engine, column parserbase.ColumnResource) bool {switch engine {case storepb.Engine_POSTGRES:@@ -739,6 +891,9 @@ func queryRetry(return nil, nil, time.Duration(0), err}}+ if err := refuseLinkedReadsShadowedByPrivateLinks(ctx, driver, conn, instance, queryContext, spans); err != nil {+ return nil, nil, time.Duration(0), err+ }slog.Debug("start execute with timeout", slog.String("instance", instance.ResourceID), slog.String("database", database.DatabaseName), slog.String("statement", originalStatement))results, duration, queryErr := executeWithTimeout(@@ -1126,6 +1281,7 @@ func doExport(database.ProjectID,)queryContext := buildExportQueryContext(queryRestriction, user.Email, request.Schema, request.GetContainer(), skipMasking)+ queryContext.DataSourceType = dataSource.GetType()// Split the statement for span analysisstatements, err := parserbase.SplitMultiSQL(instance.Metadata.GetEngine(), request.Statement)@@ -1561,6 +1717,22 @@ func (s *SQLService) accessCheckWithGrantedTargets(continue}+ // Oracle database links. Only a Select span carries linked columns, and a link never+ // makes it SelectInfoSchema (plsql getOmniQuerySpan). A DML, DDL or EXPLAIN PLAN span has+ // no source columns, so a link it reads through is not checked here (BOT-133).+ // Before the JIT-grant skip below: an unresolved link can carry a local+ // database name (ALLOWED_S.T@REMOTE2), which a grant on that database would otherwise+ // authorize. A SQL Server linked-server reference keeps its pre-existing path (BYT-10235).+ if instance.Metadata.GetEngine() == storepb.Engine_ORACLE {+ if qe := remoteColumnRefusal(ctx, span.SourceColumns, instance.ResourceID, perm); qe != nil {+ return qe+ }+ if qe, err := s.refuseLinkedTargetsOutsideProject(ctx, span.SourceColumns, instance, database, perm); err != nil {+ return err+ } else if qe != nil {+ return qe+ }+ }var deniedResources []stringfor column := range span.SourceColumns {columnDatabaseFullName := formatDatabaseResourceName(instance, &store.DatabaseMessage{diff --git a/backend/api/v1/sql_service_dblink_test.go b/backend/api/v1/sql_service_dblink_test.gonew file mode 100644index 0000000000..8a35f3e542--- /dev/null+++ b/backend/api/v1/sql_service_dblink_test.go@@ -0,0 +1,122 @@+package v1++import (+ "context"+ "testing"++ "connectrpc.com/connect"+ "github.com/pkg/errors"+ "github.com/stretchr/testify/require"++ "github.com/bytebase/bytebase/backend/common/permission"+ parserbase "github.com/bytebase/bytebase/backend/plugin/parser/base"+ "github.com/bytebase/bytebase/backend/store"+)++const wantAuditMark = "the audit interceptor stamps a refusal WARNING only when the request is marked"++func TestRemoteColumnRefusal(t *testing.T) {+ const connected = "oracle-dblink"+ local := parserbase.ColumnResource{Database: "ALLOWED_S", Table: "ALLOWED_T"}+ sameInstance := parserbase.ColumnResource{Instance: connected, Server: "REMOTE", Database: "SECRET_SCHEMA", Table: "SECRET_T"}+ otherInstance := parserbase.ColumnResource{Instance: "oracle-remote", Server: "REMOTE3", Database: "APP", Table: "T"}+ unresolved := parserbase.ColumnResource{Server: "REMOTE2", Database: "SECRET_SCHEMA", Table: "SECRET_T"}+ unresolvedUnqualified := parserbase.ColumnResource{Server: "REMOTE2", Table: "SECRET_T"}+ unresolvedLocalName := parserbase.ColumnResource{Server: "REMOTE2", Database: "ALLOWED_S", Table: "ALLOWED_T"}++ tests := []struct {+ name string+ columns []parserbase.ColumnResource+ want string+ }{+ {"local only", []parserbase.ColumnResource{local}, ""},+ {"link resolved to the connected instance", []parserbase.ColumnResource{local, sameInstance}, ""},+ {"link resolved to another instance", []parserbase.ColumnResource{local, otherInstance}, `table APP.T reached through database link "REMOTE3" is on instance "oracle-remote"`},+ {"unresolved link", []parserbase.ColumnResource{local, unresolved}, `table SECRET_SCHEMA.SECRET_T reached through database link "REMOTE2" cannot be authorized: Bytebase could not establish which database it reaches. A link is authorized when the connect string Bytebase synced for it names the host, port and service of a data source of exactly one instance`},+ {"unresolved link, unqualified table", []parserbase.ColumnResource{unresolvedUnqualified}, `table SECRET_T reached through database link "REMOTE2"`},+ {"unresolved link naming a local database", []parserbase.ColumnResource{unresolvedLocalName}, `table ALLOWED_S.ALLOWED_T reached through database link "REMOTE2"`},+ }+ for _, tc := range tests {+ columns := make(parserbase.SourceColumnSet, len(tc.columns))+ for _, column := range tc.columns {+ columns[column] = true+ }+ marked := false+ ctx := withSetPermissionDenied(context.Background(), func() { marked = true })+ got := remoteColumnRefusal(ctx, columns, connected, permission.SQLSelect)+ if tc.want == "" {+ require.Nil(t, got, tc.name)+ require.False(t, marked, tc.name)+ continue+ }+ require.NotNil(t, got, tc.name)+ require.Contains(t, got.Error(), tc.want, tc.name)+ require.Nil(t, got.resources, "%s: the refusal must offer no resource to request access to", tc.name)+ require.Equal(t, permission.SQLSelect, got.permission, tc.name)+ require.True(t, marked, "%s: %s", tc.name, wantAuditMark)+ }+}++func TestLinkedTargetProjectRefusal(t *testing.T) {+ column := parserbase.ColumnResource{Instance: "oracle-dblink", Server: "REMOTE", Database: "SECRET_SCHEMA", Table: "SECRET_T"}+ tests := []struct {+ name string+ target *store.DatabaseMessage+ want string+ }{+ {"target in the request's project", &store.DatabaseMessage{ProjectID: "default"}, ""},+ {"target Bytebase does not track", nil, `SECRET_SCHEMA.SECRET_T reached through database link "REMOTE" is in a database Bytebase does not track`},+ {"target in another project", &store.DatabaseMessage{ProjectID: "other"}, `is in project "other"`},+ }+ for _, tc := range tests {+ marked := false+ ctx := withSetPermissionDenied(context.Background(), func() { marked = true })+ got := linkedTargetProjectRefusal(ctx, column, tc.target, "default", permission.SQLSelect)+ if tc.want == "" {+ require.Nil(t, got, tc.name)+ require.False(t, marked, tc.name)+ continue+ }+ require.NotNil(t, got, tc.name)+ require.Contains(t, got.Error(), tc.want, tc.name)+ require.Nil(t, got.resources, "%s: the refusal must offer no resource to request access to", tc.name)+ require.Equal(t, permission.SQLSelect, got.permission, tc.name)+ require.True(t, marked, "%s: %s", tc.name, wantAuditMark)+ }+}++func TestPrivateLinkRefusal(t *testing.T) {+ linked := []parserbase.ColumnResource{{Instance: "oracle-dblink", Server: "REMOTE", Database: "SECRET_SCHEMA", Table: "SECRET_T"}}+ marked := false+ ctx := withSetPermissionDenied(context.Background(), func() { marked = true })++ require.NoError(t, privateLinkRefusal(ctx, linked, false, nil))+ require.False(t, marked, "no refusal, no mark")++ // An outage is not a verdict about the caller's permission.+ failed := privateLinkRefusal(ctx, linked, false, errors.New("ORA-00942"))+ require.Equal(t, connect.CodeInternal, connect.CodeOf(failed))+ require.Contains(t, failed.Error(), "ORA-00942")+ require.Contains(t, failed.Error(), `reached through database link "REMOTE" is not executed`)+ require.False(t, marked, "a failed check must stay unmarked")++ owns := privateLinkRefusal(ctx, linked, true, nil)+ require.Equal(t, connect.CodePermissionDenied, connect.CodeOf(owns))+ require.Contains(t, owns.Error(), `table SECRET_SCHEMA.SECRET_T reached through database link "REMOTE" cannot be authorized: the executing account owns private database links`)+ require.True(t, marked, wantAuditMark)+}++func TestLinkedColumns(t *testing.T) {+ local := parserbase.ColumnResource{Database: "ALLOWED_S", Table: "ALLOWED_T"}+ linkedB := parserbase.ColumnResource{Instance: "oracle-dblink", Server: "REMOTE", Database: "SECRET_SCHEMA", Table: "B"}+ linkedA := parserbase.ColumnResource{Instance: "oracle-dblink", Server: "REMOTE", Database: "SECRET_SCHEMA", Table: "A"}+ unresolved := parserbase.ColumnResource{Server: "REMOTE2", Database: "SECRET_SCHEMA", Table: "SECRET_T"}+ spans := []*parserbase.QuerySpan{+ nil,+ {SourceColumns: parserbase.SourceColumnSet{local: true, linkedB: true}},+ {SourceColumns: parserbase.SourceColumnSet{linkedA: true, unresolved: true}},+ }+ require.Equal(t, []parserbase.ColumnResource{linkedA, linkedB}, linkedColumns(spans))+ require.Empty(t, linkedColumns(nil))+ require.Empty(t, linkedColumns([]*parserbase.QuerySpan{{SourceColumns: parserbase.SourceColumnSet{local: true, unresolved: true}}}))+}diff --git a/backend/component/parsercontext/main_test.go b/backend/component/parsercontext/main_test.gonew file mode 100644index 0000000000..745b8b3f1c--- /dev/null+++ b/backend/component/parsercontext/main_test.go@@ -0,0 +1,9 @@+package parsercontext++import (+ "testing"++ "github.com/bytebase/bytebase/backend/common/testcontainer"+)++func TestMain(m *testing.M) { testcontainer.Main(m) }diff --git a/backend/component/parsercontext/oracle_link.go b/backend/component/parsercontext/oracle_link.gonew file mode 100644index 0000000000..72005d419e--- /dev/null+++ b/backend/component/parsercontext/oracle_link.go@@ -0,0 +1,378 @@+package parsercontext++import (+ "context"+ "regexp"+ "strings"++ metadatapb "github.com/bytebase/omni/metadata"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/store"+ "github.com/bytebase/bytebase/backend/store/model"+)++// oracleEndpoint is one listener address a database link may connect to.+type oracleEndpoint struct {+ host string+ port string+}++// oracleLinkTarget is what an Oracle database link's connect string+// (ALL_DB_LINKS.HOST) names: one service or SID, reachable at one or more+// addresses. Every address of one descriptor is taken as the same database,+// as in RAC and Data Guard links, so a descriptor mixing databases under one+// service resolves to whichever address a data source matches (BYT-10240).+type oracleLinkTarget struct {+ endpoints []oracleEndpoint+ // Exactly one of service and sid is set, as written. They name different+ // things on a listener and are never matched against each other.+ service string+ sid string+}++const oracleDefaultPort = "1521"++var (+ tnsKeywordPattern = regexp.MustCompile(`(?i)\(\s*(HOST|PORT|SERVICE_NAME|SID)\s*=\s*([^()]+?)\s*\)`)+ tnsAddressPattern = regexp.MustCompile(`(?i)\(\s*ADDRESS\s*=`)+ // tnsSourceRoutePattern matches a descriptor whose addresses are a hop chain+ // through Connection Manager rather than alternatives.+ tnsSourceRoutePattern = regexp.MustCompile(`(?i)\(\s*SOURCE_ROUTE\s*=\s*(YES|ON|TRUE)\s*\)`)+ // connectSchemePattern matches the Easy Connect Plus `tcp://` / `tcps://` prefix.+ connectSchemePattern = regexp.MustCompile(`(?i)^[a-z]+://`)+)++// parseOracleLinkTarget parses an Oracle connect string into the endpoints and+// the one service it names. Accepted, per the Net Services Administrator's+// Guide: Easy Connect Plus `[tcps://][//]host1[,host2][:port1][,host3:port2]/service[:server][/instance][?params]`,+// where a port applies to the hosts listed before it, and a connect descriptor+// whose ADDRESSes are alternatives for one service (RAC address lists, Data+// Guard description lists). ok=false for anything that names no single+// database: a TNS alias, a descriptor with no host or with several services,+// or a SOURCE_ROUTE hop chain, whose first address is a proxy.+func parseOracleLinkTarget(connectString string) (oracleLinkTarget, bool) {+ s := strings.TrimSpace(connectString)+ if s == "" {+ return oracleLinkTarget{}, false+ }+ if strings.HasPrefix(s, "(") {+ return parseTNSDescriptor(s)+ }+ return parseEasyConnect(s)+}++func parseEasyConnect(s string) (oracleLinkTarget, bool) {+ s = connectSchemePattern.ReplaceAllString(s, "")+ s = strings.TrimPrefix(s, "//")+ hostPart, rest, found := strings.Cut(s, "/")+ if !found || hostPart == "" {+ return oracleLinkTarget{}, false+ }+ service := rest+ if i := strings.IndexAny(service, ":/?"); i >= 0 {+ service = service[:i]+ }+ service = strings.TrimSpace(service)+ if service == "" || strings.ContainsAny(hostPart, " \t") {+ return oracleLinkTarget{}, false+ }+ endpoints, ok := parseEasyConnectHosts(hostPart)+ if !ok {+ return oracleLinkTarget{}, false+ }+ // Easy Connect names a service; a SID needs a descriptor.+ return oracleLinkTarget{endpoints: endpoints, service: service}, true+}++// parseEasyConnectHosts splits `host1[,host2][:port1][,host3:port2]`. A port+// belongs to every host listed since the previous port; hosts with no port+// after them get Oracle's default.+func parseEasyConnectHosts(hostPart string) ([]oracleEndpoint, bool) {+ var endpoints []oracleEndpoint+ unported := 0+ for _, item := range strings.Split(hostPart, ",") {+ host, port, hasPort, ok := splitHostPort(item)+ if !ok {+ return nil, false+ }+ endpoints = append(endpoints, oracleEndpoint{host: strings.ToLower(host), port: oracleDefaultPort})+ unported+++ if hasPort {+ for i := len(endpoints) - unported; i < len(endpoints); i++ {+ endpoints[i].port = port+ }+ unported = 0+ }+ }+ return endpoints, true+}++// splitHostPort splits `host[:port]`, with `[addr]:port` for IPv6.+func splitHostPort(s string) (host, port string, hasPort, ok bool) {+ host = s+ if strings.HasPrefix(s, "[") {+ end := strings.Index(s, "]")+ if end < 0 {+ return "", "", false, false+ }+ host = s[1:end]+ if tail := s[end+1:]; tail != "" {+ if !strings.HasPrefix(tail, ":") {+ return "", "", false, false+ }+ port, hasPort = tail[1:], true+ }+ } else if h, p, found := strings.Cut(s, ":"); found {+ host, port, hasPort = h, p, true+ }+ if host == "" || (hasPort && port == "") {+ return "", "", false, false+ }+ return host, port, hasPort, true+}++func parseTNSDescriptor(s string) (oracleLinkTarget, bool) {+ if tnsSourceRoutePattern.MatchString(s) {+ return oracleLinkTarget{}, false+ }+ // A DESCRIPTION_LIST repeats CONNECT_DATA per description; the same identity+ // named twice is still one. A service and a SID, or two different values,+ // name two databases.+ var identities []string+ target := oracleLinkTarget{}+ for _, m := range tnsKeywordPattern.FindAllStringSubmatch(s, -1) {+ key := strings.ToUpper(m[1])+ if key != "SERVICE_NAME" && key != "SID" {+ continue+ }+ if len(identities) == 0 {+ identities = append(identities, key+"="+m[2])+ if key == "SID" {+ target.sid = m[2]+ } else {+ target.service = m[2]+ }+ continue+ }+ if !strings.EqualFold(identities[0], key+"="+m[2]) {+ identities = append(identities, key+"="+m[2])+ }+ }+ if len(identities) != 1 {+ return oracleLinkTarget{}, false+ }+ var endpoints []oracleEndpoint+ for _, loc := range tnsAddressPattern.FindAllStringIndex(s, -1) {+ block := tnsBlock(s, loc[0])+ var hosts, ports []string+ for _, m := range tnsKeywordPattern.FindAllStringSubmatch(block, -1) {+ switch strings.ToUpper(m[1]) {+ case "HOST":+ hosts = append(hosts, m[2])+ case "PORT":+ ports = append(ports, m[2])+ default:+ }+ }+ if len(hosts) != 1 || len(ports) > 1 {+ return oracleLinkTarget{}, false+ }+ port := oracleDefaultPort+ if len(ports) == 1 {+ port = ports[0]+ }+ endpoints = append(endpoints, oracleEndpoint{host: strings.ToLower(hosts[0]), port: port})+ }+ if len(endpoints) == 0 {+ return oracleLinkTarget{}, false+ }+ target.endpoints = endpoints+ return target, true+}++// tnsBlock returns the parenthesized block that starts at s[start].+func tnsBlock(s string, start int) string {+ depth := 0+ for i := start; i < len(s); i++ {+ switch s[i] {+ case '(':+ depth+++ case ')':+ depth--+ if depth == 0 {+ return s[start : i+1]+ }+ default:+ }+ }+ return s[start:]+}++// dataSourceReachesLinkTarget reports whether a data source connects to the+// database the link names: its host and port equal one of the link's addresses+// and it connects by the same identity, service name or SID. go-ora connects+// by SID whenever the data source sets one, else by service name, so that is+// the identity compared. Compared whole: 10.0.0.5 is not 10.0.0.50, and ORCL is+// not ORCL.corp.com.+func dataSourceReachesLinkTarget(target oracleLinkTarget, dataSource *storepb.DataSource) bool {+ host := strings.ToLower(strings.TrimSpace(dataSource.GetHost()))+ port := dataSource.GetPort()+ reachable := false+ for _, endpoint := range target.endpoints {+ if host == endpoint.host && port == endpoint.port {+ reachable = true+ break+ }+ }+ if !reachable {+ return false+ }+ if sid := dataSource.GetSid(); sid != "" {+ return target.sid != "" && strings.EqualFold(sid, target.sid)+ }+ serviceName := dataSource.GetServiceName()+ return serviceName != "" && target.service != "" && strings.EqualFold(serviceName, target.service)+}++// selectLinkDefinition picks the link the statement names out of the+// definitions synced from ALL_DB_LINKS, comparing names case-insensitively.+// Oracle appends the domain of the database's global name to `@REMOTE` and+// looks up that name only: `REMOTE` without a domain, `REMOTE.WORLD` under+// the domain WORLD. The domain is not synced, so the name, its domained+// forms and a public and private link of one name are all candidates, and+// they resolve only when they agree on host and user; otherwise the+// statement could reach either, and nothing is returned. A connection+// qualifier follows the domain (`REMOTE.WORLD@Q`) and names a different+// link, so it must match. found reports whether any definition carried the+// name.+func selectLinkDefinition(name string, links []*metadatapb.LinkedDatabaseMetadata) (link *metadatapb.LinkedDatabaseMetadata, found bool) {+ base, qualifier, _ := strings.Cut(name, "@")+ for _, candidate := range links {+ candidateBase, candidateQualifier, _ := strings.Cut(candidate.GetName(), "@")+ if !strings.EqualFold(candidateQualifier, qualifier) {+ continue+ }+ domained := len(candidateBase) > len(base)+1 && strings.EqualFold(candidateBase[:len(base)+1], base+".")+ if !domained && !strings.EqualFold(candidateBase, base) {+ continue+ }+ found = true+ if link == nil {+ link = candidate+ continue+ }+ if !strings.EqualFold(link.GetHost(), candidate.GetHost()) || !strings.EqualFold(link.GetUsername(), candidate.GetUsername()) {+ return nil, true+ }+ }+ return link, found+}++// oracleLinkResolution is the database an Oracle link resolves to. Meta is+// nil when it resolves to nothing, and Reason says why.+type oracleLinkResolution struct {+ InstanceID string+ DatabaseName string+ Meta *model.DatabaseMetadata+ Reason string+}++// resolveOracleLink maps a database link named in a statement run against+// instanceID to the Bytebase database it reaches. The result may decide which+// grants apply to a linked table, so it never guesses: the link's connect+// string must name one service at addresses that a data source of exactly one+// candidate database matches exactly.+func resolveOracleLink(ctx context.Context, s *store.Store, workspaceID string, engine storepb.Engine, instanceID, linkName, schemaName string) (oracleLinkResolution, error) {+ databases, err := s.ListDatabases(ctx, &store.FindDatabaseMessage{+ Workspace: workspaceID,+ InstanceID: &instanceID,+ })+ if err != nil {+ return oracleLinkResolution{}, err+ }+ // Every database of the instance synced the same ALL_DB_LINKS rows, so the+ // first one that names the link has every definition of it.+ var link *metadatapb.LinkedDatabaseMetadata+ for _, database := range databases {+ meta, err := s.GetDBSchema(ctx, &store.FindDBSchemaMessage{+ Workspace: workspaceID,+ InstanceID: database.InstanceID,+ DatabaseName: database.DatabaseName,+ })+ if err != nil {+ return oracleLinkResolution{}, err+ }+ if meta == nil {+ continue+ }+ candidate, found := selectLinkDefinition(linkName, meta.GetProto().GetLinkedDatabases())+ if !found {+ continue+ }+ if candidate == nil {+ return oracleLinkResolution{Reason: "the link is defined more than once with different targets"}, nil+ }+ link = candidate+ break+ }+ if link == nil {+ return oracleLinkResolution{Reason: "no synced database of the instance defines the link"}, nil+ }+ target, ok := parseOracleLinkTarget(link.GetHost())+ if !ok {+ return oracleLinkResolution{Reason: "the link's connect string names no single service and host"}, nil+ }+ // The remote schema is the one the statement wrote, else the link's connect user.+ databaseName := link.GetUsername()+ if schemaName != "" {+ databaseName = schemaName+ }+ if databaseName == "" {+ return oracleLinkResolution{Reason: "the link has no connect user and the statement names no schema"}, nil+ }+ candidates, err := s.ListDatabases(ctx, &store.FindDatabaseMessage{+ Workspace: workspaceID,+ DatabaseName: &databaseName,+ Engine: &engine,+ })+ if err != nil {+ return oracleLinkResolution{}, err+ }+ var matches []*store.DatabaseMessage+ for _, database := range candidates {+ instance, err := s.GetInstance(ctx, &store.FindInstanceMessage{Workspace: workspaceID, ResourceID: &database.InstanceID})+ if err != nil {+ return oracleLinkResolution{}, err+ }+ if instance == nil {+ continue+ }+ for _, dataSource := range instance.Metadata.GetDataSources() {+ if dataSourceReachesLinkTarget(target, dataSource) {+ matches = append(matches, database)+ break+ }+ }+ }+ switch len(matches) {+ case 0:+ return oracleLinkResolution{Reason: "no data source of any instance holding that database reaches the link's host, port and service"}, nil+ case 1:+ default:+ return oracleLinkResolution{Reason: "data sources of several instances reach the link"}, nil+ }+ linkedDatabase := matches[0]+ meta, err := s.GetDBSchema(ctx, &store.FindDBSchemaMessage{+ Workspace: workspaceID,+ InstanceID: linkedDatabase.InstanceID,+ DatabaseName: linkedDatabase.DatabaseName,+ })+ if err != nil {+ return oracleLinkResolution{}, err+ }+ if meta == nil {+ return oracleLinkResolution{Reason: "the linked database has not been synced"}, nil+ }+ return oracleLinkResolution{InstanceID: linkedDatabase.InstanceID, DatabaseName: linkedDatabase.DatabaseName, Meta: meta}, nil+}diff --git a/backend/component/parsercontext/oracle_link_test.go b/backend/component/parsercontext/oracle_link_test.gonew file mode 100644index 0000000000..ca3d8442bf--- /dev/null+++ b/backend/component/parsercontext/oracle_link_test.go@@ -0,0 +1,161 @@+package parsercontext++import (+ "testing"++ metadatapb "github.com/bytebase/omni/metadata"+ "github.com/stretchr/testify/require"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+)++func TestParseOracleLinkTarget(t *testing.T) {+ ep := func(host, port string) oracleEndpoint { return oracleEndpoint{host: host, port: port} }+ svc := func(service string, endpoints ...oracleEndpoint) oracleLinkTarget {+ return oracleLinkTarget{endpoints: endpoints, service: service}+ }+ sid := func(sid string, endpoints ...oracleEndpoint) oracleLinkTarget {+ return oracleLinkTarget{endpoints: endpoints, sid: sid}+ }+ tests := []struct {+ connectString string+ want oracleLinkTarget+ ok bool+ }{+ {"localhost:1521/FREEPDB1", svc("FREEPDB1", ep("localhost", "1521")), true},+ {"//db.example.com:1522/ORCL", svc("ORCL", ep("db.example.com", "1522")), true},+ {"DB.EXAMPLE.COM/orcl", svc("orcl", ep("db.example.com", "1521")), true},+ {"host:1521/svc:dedicated/inst1", svc("svc", ep("host", "1521")), true},+ {"[::1]:1521/svc", svc("svc", ep("::1", "1521")), true},+ {"[::1]/svc", svc("svc", ep("::1", "1521")), true},+ {" host:1521/svc ", svc("svc", ep("host", "1521")), true},+ // Easy Connect Plus: scheme, parameters, several addresses.+ {"tcps://adb.example.com:1522/abc_high.adb.oraclecloud.com", svc("abc_high.adb.oraclecloud.com", ep("adb.example.com", "1522")), true},+ {"//host:1521/svc?connect_timeout=5&retry_count=2", svc("svc", ep("host", "1521")), true},+ {"rac1:1521,rac2:1522/svc", svc("svc", ep("rac1", "1521"), ep("rac2", "1522")), true},+ // A port applies to the hosts listed before it.+ {"rac1,rac2:1522/svc", svc("svc", ep("rac1", "1522"), ep("rac2", "1522")), true},+ {"rac1,rac2:1522,rac3/svc", svc("svc", ep("rac1", "1522"), ep("rac2", "1522"), ep("rac3", "1521")), true},+ {"[::1],[::2]:1522/svc", svc("svc", ep("::1", "1522"), ep("::2", "1522")), true},+ {"(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=db.example.com)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=orcl)))", svc("orcl", ep("db.example.com", "1521")), true},+ {"(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=db)(PORT=1522))(CONNECT_DATA=(SID=orcl)))", sid("orcl", ep("db", "1522")), true},+ {"(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=db))(CONNECT_DATA=(SERVICE_NAME=orcl)))", svc("orcl", ep("db", "1521")), true},+ {"( DESCRIPTION = ( ADDRESS = ( HOST = db ) ( PORT = 1521 ) ) ( CONNECT_DATA = ( SERVICE_NAME = orcl ) ) )", svc("orcl", ep("db", "1521")), true},+ // RAC and Data Guard: several addresses, one service.+ {"(DESCRIPTION=(ADDRESS_LIST=(LOAD_BALANCE=on)(ADDRESS=(PROTOCOL=TCP)(HOST=rac1-vip)(PORT=1521))(ADDRESS=(PROTOCOL=TCP)(HOST=rac2-vip)(PORT=1521)))(CONNECT_DATA=(SERVICE_NAME=proddb)))", svc("proddb", ep("rac1-vip", "1521"), ep("rac2-vip", "1521")), true},+ // A TNS alias names nothing on its own.+ {"PRODDB", oracleLinkTarget{}, false},+ {"", oracleLinkTarget{}, false},+ // No service or SID.+ {"host:1521", oracleLinkTarget{}, false},+ {"host:1521/", oracleLinkTarget{}, false},+ {"host:1521/?connect_timeout=5", oracleLinkTarget{}, false},+ {"/svc", oracleLinkTarget{}, false},+ {"(DESCRIPTION=(ADDRESS=(HOST=a)(PORT=1521)))", oracleLinkTarget{}, false},+ // A DESCRIPTION_LIST repeating one service is one database (Data Guard failover).+ {"(DESCRIPTION_LIST=(DESCRIPTION=(ADDRESS=(HOST=h1)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=proddb)))(DESCRIPTION=(ADDRESS=(HOST=h2)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=PRODDB))))", svc("proddb", ep("h1", "1521"), ep("h2", "1521")), true},+ // A SOURCE_ROUTE chain passes through a proxy; its first address is not the database.+ {"(DESCRIPTION=(SOURCE_ROUTE=yes)(ADDRESS=(HOST=cman)(PORT=1521))(ADDRESS=(HOST=real)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=svc)))", oracleLinkTarget{}, false},+ // A DESCRIPTION_LIST that switches service between addresses names two databases.+ {"(DESCRIPTION_LIST=(DESCRIPTION=(ADDRESS=(HOST=h1)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=proddb)))(DESCRIPTION=(ADDRESS=(HOST=h2)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=reportdb))))", oracleLinkTarget{}, false},+ // A service and a SID are different identities even when spelled the same.+ {"(DESCRIPTION=(ADDRESS=(HOST=a)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=orcl)(SID=orcl)))", oracleLinkTarget{}, false},+ {"(DESCRIPTION=(ADDRESS=(HOST=a)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=orcl)(SID=other)))", oracleLinkTarget{}, false},+ {"(DESCRIPTION_LIST=(DESCRIPTION=(ADDRESS=(HOST=h1)(PORT=1521))(CONNECT_DATA=(SID=orcl)))(DESCRIPTION=(ADDRESS=(HOST=h2)(PORT=1521))(CONNECT_DATA=(SID=ORCL))))", sid("orcl", ep("h1", "1521"), ep("h2", "1521")), true},+ // Malformed.+ {"host1 host2:1521/svc", oracleLinkTarget{}, false},+ {"rac1:1521,/svc", oracleLinkTarget{}, false},+ {"rac1:/svc", oracleLinkTarget{}, false},+ {"[::1:1521/svc", oracleLinkTarget{}, false},+ {"[::1]1521/svc", oracleLinkTarget{}, false},+ {"(DESCRIPTION=(ADDRESS=(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=orcl)))", oracleLinkTarget{}, false},+ {"(DESCRIPTION=(CONNECT_DATA=(SERVICE_NAME=orcl)))", oracleLinkTarget{}, false},+ }+ for _, tc := range tests {+ got, ok := parseOracleLinkTarget(tc.connectString)+ require.Equal(t, tc.ok, ok, tc.connectString)+ require.Equal(t, tc.want, got, tc.connectString)+ }+}++func TestDataSourceReachesLinkTarget(t *testing.T) {+ endpoints := []oracleEndpoint{{host: "10.0.0.50", port: "1521"}, {host: "rac2-vip", port: "1522"}}+ byService := oracleLinkTarget{endpoints: endpoints, service: "FREEPDB1"}+ bySID := oracleLinkTarget{endpoints: endpoints, sid: "FREEPDB1"}+ tests := []struct {+ name string+ target oracleLinkTarget+ dataSource *storepb.DataSource+ want bool+ }{+ {"exact", byService, &storepb.DataSource{Host: "10.0.0.50", Port: "1521", ServiceName: "FREEPDB1"}, true},+ {"host case and service case", byService, &storepb.DataSource{Host: "RAC2-VIP", Port: "1522", ServiceName: "freepdb1"}, true},+ {"sid link, sid data source", bySID, &storepb.DataSource{Host: "10.0.0.50", Port: "1521", Sid: "freepdb1"}, true},+ // go-ora connects by SID whenever one is set, so that is the identity compared.+ {"sid link, data source with both", bySID, &storepb.DataSource{Host: "10.0.0.50", Port: "1521", ServiceName: "OTHER", Sid: "FREEPDB1"}, true},+ {"service link, data source with both", byService, &storepb.DataSource{Host: "10.0.0.50", Port: "1521", ServiceName: "FREEPDB1", Sid: "FREEPDB1"}, false},+ {"service link, sid data source", byService, &storepb.DataSource{Host: "10.0.0.50", Port: "1521", Sid: "FREEPDB1"}, false},+ {"sid link, service data source", bySID, &storepb.DataSource{Host: "10.0.0.50", Port: "1521", ServiceName: "FREEPDB1"}, false},+ {"empty host", byService, &storepb.DataSource{Port: "1521", ServiceName: "FREEPDB1"}, false},+ {"empty port", byService, &storepb.DataSource{Host: "10.0.0.50", ServiceName: "FREEPDB1"}, false},+ {"host substring", byService, &storepb.DataSource{Host: "10.0.0.5", Port: "1521", ServiceName: "FREEPDB1"}, false},+ {"host superstring", byService, &storepb.DataSource{Host: "10.0.0.500", Port: "1521", ServiceName: "FREEPDB1"}, false},+ {"port of the other address", byService, &storepb.DataSource{Host: "10.0.0.50", Port: "1522", ServiceName: "FREEPDB1"}, false},+ {"service", byService, &storepb.DataSource{Host: "10.0.0.50", Port: "1521", ServiceName: "OTHER"}, false},+ {"service with a domain the link lacks", byService, &storepb.DataSource{Host: "10.0.0.50", Port: "1521", ServiceName: "FREEPDB1.corp.com"}, false},+ {"no service or sid", byService, &storepb.DataSource{Host: "10.0.0.50", Port: "1521"}, false},+ }+ for _, tc := range tests {+ require.Equal(t, tc.want, dataSourceReachesLinkTarget(tc.target, tc.dataSource), tc.name)+ }+ domained := oracleLinkTarget{endpoints: endpoints, service: "FREEPDB1.corp.com"}+ require.False(t, dataSourceReachesLinkTarget(domained, &storepb.DataSource{Host: "10.0.0.50", Port: "1521", ServiceName: "FREEPDB1"}))+}++func TestSelectLinkDefinition(t *testing.T) {+ link := func(name, host, user string) *metadatapb.LinkedDatabaseMetadata {+ return &metadatapb.LinkedDatabaseMetadata{Name: name, Host: host, Username: user}+ }+ remote := link("REMOTE", "h1:1521/s", "U1")+ tests := []struct {+ name string+ links []*metadatapb.LinkedDatabaseMetadata+ want *metadatapb.LinkedDatabaseMetadata+ wantFound bool+ }{+ {"REMOTE", []*metadatapb.LinkedDatabaseMetadata{remote}, remote, true},+ {"remote", []*metadatapb.LinkedDatabaseMetadata{remote}, remote, true},+ {"REMOTE", nil, nil, false},+ {"REMOTE", []*metadatapb.LinkedDatabaseMetadata{link("OTHER", "h1:1521/s", "U1")}, nil, false},+ {"REMOTE", []*metadatapb.LinkedDatabaseMetadata{link("REMOTEX", "h1:1521/s", "U1")}, nil, false},+ {"REMOTE", []*metadatapb.LinkedDatabaseMetadata{link("REMOTE.WORLD", "h1:1521/s", "U1")}, link("REMOTE.WORLD", "h1:1521/s", "U1"), true},+ // Oracle follows REMOTE when its global name has no domain and REMOTE.WORLD when the+ // domain is WORLD, so the two resolve only when they reach the same target.+ {"REMOTE", []*metadatapb.LinkedDatabaseMetadata{link("REMOTE.WORLD", "h2:1521/s", "U2"), remote}, nil, true},+ {"REMOTE", []*metadatapb.LinkedDatabaseMetadata{remote, link("REMOTE.WORLD", "h1:1521/s", "U1")}, remote, true},+ {"REMOTE@Q", []*metadatapb.LinkedDatabaseMetadata{link("REMOTE@Q", "h1:1521/s", "U1"), link("REMOTE.WORLD@Q", "h2:1521/s", "U2")}, nil, true},+ {"REMOTE", []*metadatapb.LinkedDatabaseMetadata{remote, link("REMOTE", "h1:1521/s", "u1")}, remote, true},+ {"REMOTE", []*metadatapb.LinkedDatabaseMetadata{link("REMOTE.WORLD", "h1:1521/s", "U1"), link("REMOTE.CORP", "h1:1521/s", "U1")}, link("REMOTE.WORLD", "h1:1521/s", "U1"), true},+ {"REMOTE", []*metadatapb.LinkedDatabaseMetadata{remote, link("REMOTE", "h2:1521/s", "U1")}, nil, true},+ {"REMOTE", []*metadatapb.LinkedDatabaseMetadata{remote, link("REMOTE", "h1:1521/s", "U2")}, nil, true},+ {"REMOTE", []*metadatapb.LinkedDatabaseMetadata{link("REMOTE.WORLD", "h1:1521/s", "U1"), link("REMOTE.CORP", "h2:1521/s", "U1")}, nil, true},+ // REMOTE.WORLD@Q is the qualified link Q of REMOTE.WORLD, not a domained REMOTE.+ {"REMOTE", []*metadatapb.LinkedDatabaseMetadata{link("REMOTE.WORLD@Q", "h2:1521/s", "U2")}, nil, false},+ {"REMOTE", []*metadatapb.LinkedDatabaseMetadata{link("REMOTE.WORLD", "h1:1521/s", "U1"), link("REMOTE.WORLD@Q", "h2:1521/s", "U2")}, link("REMOTE.WORLD", "h1:1521/s", "U1"), true},+ {"REMOTE@Q", []*metadatapb.LinkedDatabaseMetadata{remote, link("REMOTE@Q", "h2:1521/s", "U2"), link("REMOTE@R", "h3:1521/s", "U3")}, link("REMOTE@Q", "h2:1521/s", "U2"), true},+ {"remote@q", []*metadatapb.LinkedDatabaseMetadata{link("REMOTE@Q", "h2:1521/s", "U2")}, link("REMOTE@Q", "h2:1521/s", "U2"), true},+ {"REMOTE@Q", []*metadatapb.LinkedDatabaseMetadata{link("REMOTE.WORLD@Q", "h2:1521/s", "U2")}, link("REMOTE.WORLD@Q", "h2:1521/s", "U2"), true},+ {"REMOTE@Q", []*metadatapb.LinkedDatabaseMetadata{remote, link("REMOTE.WORLD@R", "h3:1521/s", "U3")}, nil, false},+ }+ for _, tc := range tests {+ got, found := selectLinkDefinition(tc.name, tc.links)+ require.Equal(t, tc.wantFound, found, tc.name)+ if tc.want == nil {+ require.Nil(t, got, tc.name)+ continue+ }+ require.NotNil(t, got, tc.name)+ require.Equal(t, tc.want.GetName(), got.GetName())+ require.Equal(t, tc.want.GetHost(), got.GetHost())+ }+}diff --git a/backend/component/parsercontext/parsercontext.go b/backend/component/parsercontext/parsercontext.goindex 798b9bf46a..63ffa21d49 100644--- a/backend/component/parsercontext/parsercontext.go+++ b/backend/component/parsercontext/parsercontext.go@@ -11,9 +11,7 @@ package parsercontextimport ("context"- "strings"-- metadatapb "github.com/bytebase/omni/metadata"+ "log/slog"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/store"@@ -63,86 +61,24 @@ func BuildListDatabaseNamesFunc(storeInstance *store.Store) parserbase.ListDatab}}-// BuildGetLinkedDatabaseMetadataFunc returns a closure that resolves Oracle-// linked-database references (DBLINK syntax) to the actual remote database-// metadata. Returns nil for non-Oracle engines — the parser interprets that-// as "linked references not supported here".+// BuildGetLinkedDatabaseMetadataFunc returns a closure that resolves an Oracle+// database link (`schema.table@link`) to the Bytebase database it reaches:+// (instance resource ID, database name, metadata), or nils when Bytebase+// cannot identify that database. Returns nil for non-Oracle engines; the+// parser treats that as "linked references not supported here".func BuildGetLinkedDatabaseMetadataFunc(storeInstance *store.Store, engine storepb.Engine) parserbase.GetLinkedDatabaseMetadataFunc {if engine != storepb.Engine_ORACLE {return nil}- return func(ctx context.Context, instanceID string, linkedDatabaseName string, schemaName string) (string, string, *model.DatabaseMetadata, error) {- // Find the linked database metadata.- databases, err := storeInstance.ListDatabases(ctx, &store.FindDatabaseMessage{- Workspace: common.GetWorkspaceIDFromContext(ctx),- InstanceID: &instanceID,- })- if err != nil {- return "", "", nil, err- }- var linkedMeta *metadatapb.LinkedDatabaseMetadata- for _, database := range databases {- meta, err := storeInstance.GetDBSchema(ctx, &store.FindDBSchemaMessage{- Workspace: common.GetWorkspaceIDFromContext(ctx),- InstanceID: database.InstanceID,- DatabaseName: database.DatabaseName,- })- if err != nil {- return "", "", nil, err- }- if linkedMeta = meta.GetLinkedDatabase(linkedDatabaseName); linkedMeta != nil {- break- }- }- if linkedMeta == nil {- return "", "", nil, nil- }- // Find the linked database in Bytebase.- var linkedDatabase *store.DatabaseMessage- databaseName := linkedMeta.GetUsername()- if schemaName != "" {- databaseName = schemaName- }- databaseList, err := storeInstance.ListDatabases(ctx, &store.FindDatabaseMessage{- Workspace: common.GetWorkspaceIDFromContext(ctx),- DatabaseName: &databaseName,- Engine: &engine,- })- if err != nil {- return "", "", nil, err- }- for _, database := range databaseList {- instance, err := storeInstance.GetInstance(ctx, &store.FindInstanceMessage{Workspace: common.GetWorkspaceIDFromContext(ctx), ResourceID: &database.InstanceID})- if err != nil {- return "", "", nil, err- }- if instance != nil {- for _, dataSource := range instance.Metadata.DataSources {- if strings.Contains(linkedMeta.GetHost(), dataSource.GetHost()) {- linkedDatabase = database- break- }- }- if linkedDatabase != nil {- break- }- }- }- if linkedDatabase == nil {- return "", "", nil, nil- }- // Get the linked database metadata.- linkedDatabaseMetadata, err := storeInstance.GetDBSchema(ctx, &store.FindDBSchemaMessage{- Workspace: common.GetWorkspaceIDFromContext(ctx),- InstanceID: linkedDatabase.InstanceID,- DatabaseName: linkedDatabase.DatabaseName,- })+ return func(ctx context.Context, instanceID string, linkName string, schemaName string) (string, string, *model.DatabaseMetadata, error) {+ resolution, err := resolveOracleLink(ctx, storeInstance, common.GetWorkspaceIDFromContext(ctx), engine, instanceID, linkName, schemaName)if err != nil {return "", "", nil, err}- if linkedDatabaseMetadata == nil {+ if resolution.Meta == nil {+ slog.Debug("database link not resolved", slog.String("instance", instanceID), slog.String("link", linkName), slog.String("reason", resolution.Reason))return "", "", nil, nil}- return linkedDatabase.InstanceID, linkedDatabaseName, linkedDatabaseMetadata, nil+ return resolution.InstanceID, resolution.DatabaseName, resolution.Meta, nil}}diff --git a/backend/component/parsercontext/parsercontext_test.go b/backend/component/parsercontext/parsercontext_test.gonew file mode 100644index 0000000000..45daa796bb--- /dev/null+++ b/backend/component/parsercontext/parsercontext_test.go@@ -0,0 +1,121 @@+package parsercontext++import (+ "context"+ "testing"++ metadatapb "github.com/bytebase/omni/metadata"+ "github.com/stretchr/testify/require"++ "github.com/bytebase/bytebase/backend/common"+ "github.com/bytebase/bytebase/backend/common/testcontainer"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/store"+)++func TestBuildGetLinkedDatabaseMetadataFunc(t *testing.T) {+ ctx := context.WithValue(context.Background(), common.WorkspaceIDContextKey, "default")+ db, s, _ := testcontainer.NewMetadataDB(t)+ _, err := db.ExecContext(ctx, `+ INSERT INTO workspace (resource_id) VALUES ('default');+ INSERT INTO project (resource_id, workspace, name) VALUES ('project-a', 'default', 'Project A');+ `)+ require.NoError(t, err)++ links := []*metadatapb.LinkedDatabaseMetadata{+ {Name: "REMOTE", Host: "localhost:1521/FREEPDB1", Username: "SECRET_SCHEMA"},+ {Name: "UNMANAGED", Host: "172.23.0.2:1521/FREEPDB1", Username: "SECRET_SCHEMA"},+ {Name: "RAC", Host: "(DESCRIPTION=(ADDRESS_LIST=(ADDRESS=(HOST=rac2)(PORT=1521))(ADDRESS=(HOST=LOCALHOST)(PORT=1521)))(CONNECT_DATA=(SERVICE_NAME=freepdb1)))", Username: "SECRET_SCHEMA"},+ {Name: "ALIAS", Host: "PRODDB", Username: "SECRET_SCHEMA"},+ {Name: "NOUSER", Host: "localhost:1521/FREEPDB1"},+ {Name: "DOMAINED.WORLD", Host: "localhost:1521/FREEPDB1", Username: "SECRET_SCHEMA"},+ {Name: "TWICE", Host: "localhost:1521/FREEPDB1", Username: "SECRET_SCHEMA"},+ {Name: "TWICE", Host: "elsewhere:1521/FREEPDB1", Username: "SECRET_SCHEMA"},+ {Name: "UNSYNCED", Host: "unsynced-host:1521/FREEPDB1", Username: "SECRET_SCHEMA"},+ {Name: "BYSID", Host: "(DESCRIPTION=(ADDRESS=(HOST=localhost)(PORT=1521))(CONNECT_DATA=(SID=FREEPDB1)))", Username: "SECRET_SCHEMA"},+ }+ seedInstance := func(instanceID string, dataSource *storepb.DataSource, databases ...string) {+ t.Helper()+ _, err := s.CreateInstance(ctx, &store.InstanceMessage{+ ResourceID: instanceID,+ Workspace: "default",+ Metadata: &storepb.Instance{+ Engine: storepb.Engine_ORACLE,+ DataSources: []*storepb.DataSource{dataSource},+ },+ })+ require.NoError(t, err)+ for _, name := range databases {+ _, err = s.UpsertDatabase(ctx, &store.DatabaseMessage{+ ProjectID: "project-a",+ InstanceID: instanceID,+ DatabaseName: name,+ Metadata: &storepb.DatabaseMetadata{},+ })+ require.NoError(t, err)+ require.NoError(t, s.UpsertDBSchema(ctx, instanceID, name, &metadatapb.DatabaseSchemaMetadata{+ Name: name,+ Schemas: []*metadatapb.SchemaMetadata{{Name: "", Tables: []*metadatapb.TableMetadata{{Name: "SECRET_T"}}}},+ LinkedDatabases: links,+ }, &storepb.DatabaseConfig{}, nil))+ }+ }+ // The instance the statements run against; its data source reaches the loopback links.+ seedInstance("ora-a", &storepb.DataSource{Id: "admin", Type: storepb.DataSourceType_ADMIN, Host: "localhost", Port: "1521", ServiceName: "FREEPDB1"}, "ALLOWED_S", "SECRET_SCHEMA")+ // Instances a substring match would have picked: an empty host is a substring of every+ // link host, and "local" is a substring of "localhost".+ seedInstance("ora-empty-host", &storepb.DataSource{Id: "admin", Type: storepb.DataSourceType_ADMIN, Port: "1521", ServiceName: "FREEPDB1"}, "SECRET_SCHEMA")+ seedInstance("ora-prefix-host", &storepb.DataSource{Id: "admin", Type: storepb.DataSourceType_ADMIN, Host: "local", Port: "1521", ServiceName: "FREEPDB1"}, "SECRET_SCHEMA")+ // Same host, other service: a different database on the same listener.+ seedInstance("ora-other-service", &storepb.DataSource{Id: "admin", Type: storepb.DataSourceType_ADMIN, Host: "localhost", Port: "1521", ServiceName: "OTHERPDB"}, "SECRET_SCHEMA")+ // Same host and spelling, but connecting by SID: only a SID link reaches it.+ seedInstance("ora-sid", &storepb.DataSource{Id: "admin", Type: storepb.DataSourceType_ADMIN, Host: "localhost", Port: "1521", Sid: "FREEPDB1"}, "SECRET_SCHEMA")+ // Reached by the UNSYNCED link, but its database has no synced schema yet.+ seedInstance("ora-unsynced", &storepb.DataSource{Id: "admin", Type: storepb.DataSourceType_ADMIN, Host: "unsynced-host", Port: "1521", ServiceName: "FREEPDB1"})+ _, err = s.UpsertDatabase(ctx, &store.DatabaseMessage{ProjectID: "project-a", InstanceID: "ora-unsynced", DatabaseName: "SECRET_SCHEMA", Metadata: &storepb.DatabaseMetadata{}})+ require.NoError(t, err)++ resolve := BuildGetLinkedDatabaseMetadataFunc(s, storepb.Engine_ORACLE)+ require.Nil(t, BuildGetLinkedDatabaseMetadataFunc(s, storepb.Engine_POSTGRES))++ tests := []struct {+ name string+ link string+ schema string+ wantInstance string+ wantDatabase string+ }{+ {"schema-qualified reference", "REMOTE", "SECRET_SCHEMA", "ora-a", "SECRET_SCHEMA"},+ {"unqualified reference uses the link user", "REMOTE", "", "ora-a", "SECRET_SCHEMA"},+ {"link name case", "remote", "", "ora-a", "SECRET_SCHEMA"},+ {"domained link named without its domain", "DOMAINED", "", "ora-a", "SECRET_SCHEMA"},+ {"RAC descriptor listing the data source among its addresses", "RAC", "", "ora-a", "SECRET_SCHEMA"},+ {"SID descriptor reaches the SID data source, not the service one", "BYSID", "", "ora-sid", "SECRET_SCHEMA"},+ {"schema Bytebase does not track", "REMOTE", "NOT_SYNCED", "", ""},+ {"host no data source reaches", "UNMANAGED", "", "", ""},+ {"TNS alias", "ALIAS", "", "", ""},+ {"no connect user and no schema", "NOUSER", "", "", ""},+ {"defined twice with different targets", "TWICE", "", "", ""},+ {"linked database not synced yet", "UNSYNCED", "", "", ""},+ {"unknown link", "NOSUCHLINK", "", "", ""},+ }+ for _, tc := range tests {+ instanceID, databaseName, meta, err := resolve(ctx, "ora-a", tc.link, tc.schema)+ require.NoError(t, err, tc.name)+ require.Equal(t, tc.wantInstance, instanceID, tc.name)+ require.Equal(t, tc.wantDatabase, databaseName, tc.name)+ if tc.wantInstance == "" {+ require.Nil(t, meta, tc.name)+ continue+ }+ require.NotNil(t, meta, tc.name)+ require.NotNil(t, meta.GetSchemaMetadata("").GetTable("SECRET_T"), tc.name)+ }++ // A second instance whose data source reaches the same listener and service makes the link ambiguous.+ seedInstance("ora-a-twin", &storepb.DataSource{Id: "admin", Type: storepb.DataSourceType_ADMIN, Host: "LOCALHOST", Port: "1521", ServiceName: "freepdb1"}, "SECRET_SCHEMA")+ instanceID, _, meta, err := resolve(ctx, "ora-a", "REMOTE", "")+ require.NoError(t, err)+ require.Empty(t, instanceID)+ require.Nil(t, meta)+}diff --git a/backend/plugin/db/driver.go b/backend/plugin/db/driver.goindex e58f2320fe..6cfea4500d 100644--- a/backend/plugin/db/driver.go+++ b/backend/plugin/db/driver.go@@ -135,6 +135,9 @@ type QueryContext struct {// from the statement, so a driver must withhold rows the statement does not trace// to columns, such as those a procedure call returns.MaskingEnabled bool+ // DataSourceType records which data source runs the query; the Oracle private-link guard+ // exempts the admin one, whose ALL_DB_LINKS the sync recorded.+ DataSourceType storepb.DataSourceType// The maximum number of bytes for sql results in response body.MaximumSQLResultSize int64Timeout *durationpb.Durationdiff --git a/backend/plugin/db/oracle/oracle.go b/backend/plugin/db/oracle/oracle.goindex 7d55f84a9a..10c4139448 100644--- a/backend/plugin/db/oracle/oracle.go+++ b/backend/plugin/db/oracle/oracle.go@@ -221,6 +221,17 @@ func (*Driver) executeInAutoCommitMode(ctx context.Context, conn *sql.Conn, commreturn totalRowsAffected, nil}+// OwnsPrivateDatabaseLink reports whether the session's account owns a private database link.+// SYS.USER_DB_LINKS lists the links owned by the current user; the SYS qualifier keeps a+// same-named local object from standing in for the dictionary view.+func (*Driver) OwnsPrivateDatabaseLink(ctx context.Context, conn *sql.Conn) (bool, error) {+ var count int+ if err := conn.QueryRowContext(ctx, "SELECT COUNT(*) FROM SYS.USER_DB_LINKS").Scan(&count); err != nil {+ return false, errors.Wrap(err, "failed to count private database links")+ }+ return count > 0, nil+}+// QueryConn queries a SQL statement in a given connection.func (d *Driver) QueryConn(ctx context.Context, conn *sql.Conn, statement string, queryContext db.QueryContext) ([]*v1pb.QueryResult, error) {singleSQLs, err := plsqlparser.SplitSQL(statement)diff --git a/backend/plugin/parser/base/query.go b/backend/plugin/parser/base/query.goindex 1b8a6083cb..90bc16244f 100644--- a/backend/plugin/parser/base/query.go+++ b/backend/plugin/parser/base/query.go@@ -11,7 +11,8 @@ type SchemaResource struct {Schema stringTable string- // LinkedServer is the special resource for MSSQL, which can be used to specify the linked server.+ // LinkedServer is the remote reference as the statement wrote it: an MSSQL linked server or+ // an Oracle database link. Empty for a table on the connected server.LinkedServer string}diff --git a/backend/plugin/parser/base/span.go b/backend/plugin/parser/base/span.goindex a079ee74ba..2d4801a733 100644--- a/backend/plugin/parser/base/span.go+++ b/backend/plugin/parser/base/span.go@@ -126,7 +126,13 @@ type QuerySpanResult struct {// ColumnResource is the resource key for a column.type ColumnResource struct {- // Server is the normalized server name, it's empty if the column comes from the connected server.+ // Instance is the resource ID of the Bytebase instance that owns Database when the column+ // was reached through an Oracle database link; empty means the connected instance. A column+ // with Server set and Instance empty was reached through a remote reference Bytebase could+ // not resolve.+ Instance string `yaml:"instance,omitempty"`+ // Server is the normalized server name as the statement wrote it (an MSSQL linked server or+ // an Oracle database link); it's empty if the column comes from the connected server.Server string// Database is the normalized database name, it should not be empty.Database stringdiff --git a/backend/plugin/parser/plsql/query_span_extractor.go b/backend/plugin/parser/plsql/query_span_extractor.goindex 4e538a1941..8eb6a56b74 100644--- a/backend/plugin/parser/plsql/query_span_extractor.go+++ b/backend/plugin/parser/plsql/query_span_extractor.go@@ -22,20 +22,40 @@ type querySpanExtractor struct {outerTableSources []base.TableSourcetableSourcesFrom []base.TableSource+ linkedDatabases map[string]linkedDatabaseResolution}func newQuerySpanExtractor(connectionDatabase string, gCtx base.GetQuerySpanContext) *querySpanExtractor {return &querySpanExtractor{defaultDatabase: connectionDatabase,gCtx: gCtx,+ linkedDatabases: make(map[string]linkedDatabaseResolution),}}+// linkedDatabaseResolution is what a database link resolved to; a nil meta means it+// resolved to nothing.+type linkedDatabaseResolution struct {+ instanceID string+ databaseName string+ meta *model.DatabaseMetadata+}++// getLinkedDatabaseMetadata resolves a database link once per (link, schema) for the+// statement; the access-table pass and the column pass both ask for the same links.func (q *querySpanExtractor) getLinkedDatabaseMetadata(linkName string, schema string) (string, string, *model.DatabaseMetadata, error) {+ if q.gCtx.GetLinkedDatabaseMetadataFunc == nil {+ return "", "", nil, nil+ }+ key := linkName + "\x00" + schema+ if r, ok := q.linkedDatabases[key]; ok {+ return r.instanceID, r.databaseName, r.meta, nil+ }linkedInstanceID, databaseName, meta, err := q.gCtx.GetLinkedDatabaseMetadataFunc(q.ctx, q.gCtx.InstanceID, linkName, schema)if err != nil {return "", "", nil, errors.Wrapf(err, "failed to get linked database metadata for schema: %s", schema)}+ q.linkedDatabases[key] = linkedDatabaseResolution{instanceID: linkedInstanceID, databaseName: databaseName, meta: meta}return linkedInstanceID, databaseName, meta, nil}@@ -48,9 +68,6 @@ func (q *querySpanExtractor) getDatabaseMetadata(schema string) (*model.Database}func (q *querySpanExtractor) existsTableMetadata(resource base.SchemaResource) bool {- if resource.Table == "DUAL" {- return false- }database := resource.Databaseif database == "" {database = q.defaultDatabase@@ -70,9 +87,12 @@ func (q *querySpanExtractor) existsTableMetadata(resource base.SchemaResource) bschema.GetExternalTable(resource.Table) != nil}-func isMixedQuery(m []base.SchemaResource) (bool, bool) {- hasSystem, hasUser := false, false- for _, item := range m {+// isMixedQuery classifies the tables a statement reads. A linked table is a user table:+// a remote schema name says nothing about the connected instance's system schemas, and an+// info-schema verdict would skip the per-table check for it.+func isMixedQuery(local, linked []base.SchemaResource) (allSystem, mixed bool) {+ hasSystem, hasUser := false, len(linked) > 0+ for _, item := range local {if systemSchemaMap[item.Database] {hasSystem = true} else {@@ -140,15 +160,9 @@ var systemSchemaMap = map[string]bool{}func (q *querySpanExtractor) plsqlFindTableSchema(dbLink []string, schemaName, tableName string) (base.TableSource, error) {- if tableName == "DUAL" {- return &base.PseudoTable{- Name: "DUAL",- Columns: []base.QuerySpanResult{},- }, nil- }if len(dbLink) > 0 {linkName := strings.Join(dbLink, ".")- linkedInstanceID, _, linkedMeta, err := q.getLinkedDatabaseMetadata(linkName, schemaName)+ linkedInstanceID, linkedDatabaseName, linkedMeta, err := q.getLinkedDatabaseMetadata(linkName, schemaName)if err != nil {return nil, errors.Wrapf(err, "failed to get linked database metadata for: %s", dbLink)}@@ -157,7 +171,9 @@ func (q *querySpanExtractor) plsqlFindTableSchema(dbLink []string, schemaName, tDatabaseLink: &linkName,}}- return q.findTableSchemaInMetadata(linkedInstanceID, linkedMeta, schemaName, tableName)+ // Lineage carries the resolved database, as the access set does, so the masker+ // finds the policy of the database the link reaches rather than of "" for `t@link`.+ return q.findTableSchemaInMetadata(linkedInstanceID, linkedMeta, linkedDatabaseName, tableName)}if schemaName == q.defaultDatabase {@@ -318,8 +334,8 @@ func (q *omniQuerySpanExtractor) getOmniQuerySpan(ctx context.Context, statementreturn nil, nil}- accessTables := collectOmniAccessTables(q.defaultDatabase, raw.Stmt)- allSystem, mixed := isMixedQuery(accessTables)+ accessTables, linkedTables := collectOmniAccessTables(q.defaultDatabase, raw.Stmt)+ allSystem, mixed := isMixedQuery(accessTables, linkedTables)if mixed {return nil, base.MixUserSystemTablesError}@@ -339,11 +355,17 @@ func (q *omniQuerySpanExtractor) getOmniQuerySpan(ctx context.Context, statementcontinue}columnSet[base.ColumnResource{- Server: resource.LinkedServer,Database: resource.Database,Table: resource.Table,}] = true}+ for _, resource := range linkedTables {+ column, err := q.linkedAccessColumn(resource)+ if err != nil {+ return nil, err+ }+ columnSet[column] = true+ }selectStmt, ok := raw.Stmt.(*oracleast.SelectStmt)if !ok {@@ -448,6 +470,27 @@ func omniQueryType(stmt oracleast.StmtNode, allSystem bool) base.QueryType {return base.QueryTypeUnknown}+// linkedAccessColumn authorizes the name as written, not looked up in connected-instance+// metadata, which would drop a remote table or keep a same-named local one as the wrong+// resource. A link that resolves to nothing yields Server set and Instance empty.+func (q *omniQuerySpanExtractor) linkedAccessColumn(resource base.SchemaResource) (base.ColumnResource, error) {+ column := base.ColumnResource{+ Server: resource.LinkedServer,+ Database: resource.Database,+ Table: resource.Table,+ }+ linkedInstanceID, linkedDatabaseName, linkedMeta, err := q.getLinkedDatabaseMetadata(resource.LinkedServer, resource.Database)+ if err != nil {+ return base.ColumnResource{}, err+ }+ if linkedMeta == nil || linkedInstanceID == "" || linkedDatabaseName == "" {+ return column, nil+ }+ column.Instance = linkedInstanceID+ column.Database = linkedDatabaseName+ return column, nil+}+func (q *omniQuerySpanExtractor) findMissingOmniAccessTable(stmt oracleast.StmtNode, accessTables []base.SchemaResource) *base.ResourceNotFoundError {cteNames := collectOmniCTENames(stmt)for _, resource := range accessTables {@@ -479,39 +522,79 @@ func collectOmniCTENames(stmt oracleast.StmtNode) map[string]bool {return result}-func collectOmniAccessTables(defaultDatabase string, stmt oracleast.StmtNode) []base.SchemaResource {+// isOmniDual reports whether a name is Oracle's DUAL pseudo-table: SYS.DUAL, "PUBLIC".DUAL,+// or an unqualified local DUAL. A schema may own a real table named DUAL, which a qualified+// name resolves to; an unqualified name through a link resolves in the link user's schema+// first, so it is a table there. The unqualified local case assumes the session schema+// owns no DUAL table, as the extractor always has.+func isOmniDual(name *oracleast.ObjectName) bool {+ if name.Name != "DUAL" {+ return false+ }+ return (name.Schema == "" && name.DBLink == "") || name.Schema == "SYS" || name.Schema == "PUBLIC"+}++func omniDualTable() base.TableSource {+ return &base.PseudoTable{+ Name: "DUAL",+ Columns: []base.QuerySpanResult{},+ }+}++// omniTableLink is the database link a table reference names, as Oracle identifies it. A+// connection qualifier is part of the name: `t@link@q` reaches the link LINK@Q, which omni+// splits between ObjectName.DBLink and TableRef.Dblink. TableRef.Dblink alone names no+// link: omni fills it for a link after a partition clause, which Oracle rejects (ORA-03048).+func omniTableLink(ref *oracleast.TableRef) string {+ if ref.Name == nil {+ return ""+ }+ if ref.Name.DBLink != "" && ref.Dblink != "" {+ return ref.Name.DBLink + "@" + ref.Dblink+ }+ return ref.Name.DBLink+}++// A linked table keeps the schema as written; an unqualified one lives in the link user's+// schema, which the resolver supplies.+func collectOmniAccessTables(defaultDatabase string, stmt oracleast.StmtNode) (local, linked []base.SchemaResource) {seen := make(map[base.SchemaResource]bool)- var result []base.SchemaResource- addResource := func(name *oracleast.ObjectName) {- if name == nil || name.Name == "DUAL" || name.DBLink != "" {+ addResource := func(name *oracleast.ObjectName, link string) {+ if name == nil || isOmniDual(name) {return}database := name.Schema- if database == "" {+ if database == "" && link == "" {database = defaultDatabase}resource := base.SchemaResource{- Database: database,- Table: name.Name,+ Database: database,+ Table: name.Name,+ LinkedServer: link,+ }+ if seen[resource] {+ return}- if !seen[resource] {- seen[resource] = true- result = append(result, resource)+ seen[resource] = true+ if link != "" {+ linked = append(linked, resource)+ return}+ local = append(local, resource)}oracleast.Inspect(stmt, func(node oracleast.Node) bool {switch node := node.(type) {case *oracleast.TableRef:- if node.Dblink == "" {- addResource(node.Name)- }+ addResource(node.Name, omniTableLink(node))case *oracleast.ContainersExpr:- addResource(node.Name)+ if node.Name != nil {+ addResource(node.Name, node.Name.DBLink)+ }default:}return true})- return result+ return local, linked}func (q *omniQuerySpanExtractor) clone() *omniQuerySpanExtractor {@@ -759,10 +842,10 @@ func (q *omniQuerySpanExtractor) extractOmniTableExpr(expr oracleast.TableExpr)if expr.Name == nil {return nil, nil}- dbLink := expr.Name.DBLink- if dbLink == "" {- dbLink = expr.Dblink+ if isOmniDual(expr.Name) {+ return aliasOmniTableSource(omniDualTable(), expr.Alias), nil}+ dbLink := omniTableLink(expr)database := expr.Name.Schemaif database == "" && dbLink == "" {database = q.defaultDatabase@@ -818,6 +901,9 @@ func (q *omniQuerySpanExtractor) extractOmniTableExpr(expr oracleast.TableExpr)if expr.Name == nil {return nil, nil}+ if isOmniDual(expr.Name) {+ return aliasOmniTableSource(omniDualTable(), expr.Alias), nil+ }database := expr.Name.Schemaif database == "" {database = q.defaultDatabasediff --git a/backend/plugin/parser/plsql/query_span_test.go b/backend/plugin/parser/plsql/query_span_test.goindex 287ceab497..db0cdbf331 100644--- a/backend/plugin/parser/plsql/query_span_test.go+++ b/backend/plugin/parser/plsql/query_span_test.go@@ -108,7 +108,7 @@ func buildMockDatabaseMetadataGetter(defaultMetadata []*metadatapb.DatabaseSchemnames = append(names, metadata.Name)}return names, nil- }, func(_ context.Context, _, linkedDatabaseName, _ string) (string, string, *model.DatabaseMetadata, error) {+ }, func(_ context.Context, _, linkedDatabaseName, schemaName string) (string, string, *model.DatabaseMetadata, error) {databaseMetadata := defaultMetadatavar linkedDBInfo *metadatapb.LinkedDatabaseMetadatafor _, metadata := range databaseMetadata {@@ -123,16 +123,28 @@ func buildMockDatabaseMetadataGetter(defaultMetadata []*metadatapb.DatabaseSchem}}if linkedDBInfo == nil {- return "", "", nil, errors.Errorf("linked database %q not found", linkedDatabaseName)+ // Production resolves an unknown link to nothing, not to an error.+ return "", "", nil, nil}- for _, metadata := range getLinkedDatabaseMetadata() {- if metadata.Name == linkedDBInfo.Username {- return instanceIDB, metadata.Name, model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_ORACLE, true /* isObjectCaseSensitive */), nil+ // As in production, the written schema wins over the link user, and a link resolves to+ // nothing when no database of that name exists. LOOPBACK points back at the connected+ // instance; every other link reaches instance B.+ databaseName := linkedDBInfo.Username+ if schemaName != "" {+ databaseName = schemaName+ }+ candidates, instanceID := getLinkedDatabaseMetadata(), instanceIDB+ if linkedDBInfo.Name == "LOOPBACK" {+ candidates, instanceID = defaultMetadata, instanceIDA+ }+ for _, metadata := range candidates {+ if metadata.Name == databaseName {+ return instanceID, metadata.Name, model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_ORACLE, true /* isObjectCaseSensitive */), nil}}- return "", "", nil, errors.Errorf("database %q not found", linkedDBInfo.Username)+ return "", "", nil, nil}}@@ -185,10 +197,33 @@ func getLinkedDatabaseMetadata() []*metadatapb.DatabaseSchemaMetadata {}}+func TestGetQuerySpanRefusesSystemTableWithLink(t *testing.T) {+ metadata := &metadatapb.DatabaseSchemaMetadata{+ Name: "PUBLIC",+ Schemas: []*metadatapb.SchemaMetadata{{Name: "", Tables: []*metadatapb.TableMetadata{{Name: "T", Columns: []*metadatapb.ColumnMetadata{{Name: "A"}}}}}},+ LinkedDatabases: []*metadatapb.LinkedDatabaseMetadata{{Name: "REMOTE", Username: "SCHEMA1"}},+ }+ databaseMetadataGetter, databaseNamesLister, linkedDatabaseMetadataGetter := buildMockDatabaseMetadataGetter([]*metadatapb.DatabaseSchemaMetadata{metadata})+ gCtx := base.GetQuerySpanContext{+ InstanceID: instanceIDA,+ GetDatabaseMetadataFunc: databaseMetadataGetter,+ ListDatabaseNamesFunc: databaseNamesLister,+ GetLinkedDatabaseMetadataFunc: linkedDatabaseMetadataGetter,+ }+ // A linked table is a user table: next to a local system table the statement is mixed,+ // and on its own it is never an info-schema read.+ _, err := GetQuerySpan(context.TODO(), gCtx, base.Statement{Text: "SELECT * FROM SYS.DBA_USERS, T@REMOTE;"}, "PUBLIC", "", false)+ require.ErrorIs(t, err, base.MixUserSystemTablesError)+ span, err := GetQuerySpan(context.TODO(), gCtx, base.Statement{Text: "SELECT * FROM SYS.DBA_USERS@REMOTE;"}, "PUBLIC", "", false)+ require.NoError(t, err)+ require.Equal(t, base.Select, span.Type)+}+func TestGetAccessTables(t *testing.T) {tests := []struct {statement stringexpected []base.SchemaResource+ linked []base.SchemaResource}{{statement: "SELECT * FROM t1 WHERE c1 = 1",@@ -225,6 +260,138 @@ func TestGetAccessTables(t *testing.T) {},},},+ {+ statement: "SELECT * FROM schema1.t1@remote;",+ linked: []base.SchemaResource{+ {+ Database: "SCHEMA1",+ Table: "T1",+ LinkedServer: "REMOTE",+ },+ },+ },+ {+ statement: "SELECT * FROM t1@remote;",+ linked: []base.SchemaResource{+ {+ Table: "T1",+ LinkedServer: "REMOTE",+ },+ },+ },+ {+ statement: "SELECT * FROM t1, schema1.t2@remote WHERE EXISTS (SELECT 1 FROM t3@remote);",+ expected: []base.SchemaResource{+ {+ Database: "DB",+ Table: "T1",+ },+ },+ linked: []base.SchemaResource{+ {+ Database: "SCHEMA1",+ Table: "T2",+ LinkedServer: "REMOTE",+ },+ {+ Table: "T3",+ LinkedServer: "REMOTE",+ },+ },+ },+ {+ statement: "SELECT * FROM sys.dba_users@remote;",+ linked: []base.SchemaResource{+ {+ Database: "SYS",+ Table: "DBA_USERS",+ LinkedServer: "REMOTE",+ },+ },+ },+ {+ statement: "SELECT sysdate FROM dual;",+ },+ // Through a link an unqualified DUAL resolves in the link user's schema first.+ {+ statement: "SELECT sysdate FROM dual@remote;",+ linked: []base.SchemaResource{+ {+ Table: "DUAL",+ LinkedServer: "REMOTE",+ },+ },+ },+ {+ statement: "SELECT * FROM t1, sys.dual;",+ expected: []base.SchemaResource{+ {+ Database: "DB",+ Table: "T1",+ },+ },+ },+ {+ statement: "SELECT sysdate FROM sys.dual@remote;",+ },+ // Oracle accepts the public synonym's owner only quoted (ORA-00903 unquoted).+ {+ statement: `SELECT sysdate FROM "PUBLIC".dual;`,+ },+ // A schema-qualified DUAL is a table in that schema, local or remote.+ {+ statement: "SELECT * FROM s.dual@remote;",+ linked: []base.SchemaResource{+ {+ Database: "S",+ Table: "DUAL",+ LinkedServer: "REMOTE",+ },+ },+ },+ {+ statement: "SELECT * FROM app.dual;",+ expected: []base.SchemaResource{+ {+ Database: "APP",+ Table: "DUAL",+ },+ },+ },+ // Oracle rejects a link after a partition clause (ORA-03048), so it names none.+ {+ statement: "SELECT * FROM t1 PARTITION (p1)@remote;",+ expected: []base.SchemaResource{+ {+ Database: "DB",+ Table: "T1",+ },+ },+ },+ // `t@remote@q` names the link REMOTE@Q.+ {+ statement: "SELECT * FROM s.t@remote@q;",+ linked: []base.SchemaResource{+ {+ Database: "S",+ Table: "T",+ LinkedServer: "REMOTE@Q",+ },+ },+ },+ {+ statement: "SELECT * FROM t1@remote@q, t1@remote;",+ linked: []base.SchemaResource{+ {+ Table: "T1",+ LinkedServer: "REMOTE@Q",+ },+ {+ Table: "T1",+ LinkedServer: "REMOTE",+ },+ },+ },}for _, test := range tests {@@ -234,7 +401,8 @@ func TestGetAccessTables(t *testing.T) {require.NotEmpty(t, results.Items)raw, ok := results.Items[0].(*oracleast.RawStmt)require.True(t, ok)- resources := collectOmniAccessTables("DB", raw.Stmt)- require.Equal(t, test.expected, resources, test.statement)+ local, linked := collectOmniAccessTables("DB", raw.Stmt)+ require.Equal(t, test.expected, local, test.statement)+ require.Equal(t, test.linked, linked, test.statement)}}diff --git a/backend/plugin/parser/plsql/test-data/query_span.yaml b/backend/plugin/parser/plsql/test-data/query_span.yamlindex e8521d390a..47f921aa18 100644--- a/backend/plugin/parser/plsql/test-data/query_span.yaml+++ b/backend/plugin/parser/plsql/test-data/query_span.yaml@@ -395,7 +395,13 @@isplainfield: falsesourcefieldpaths: []selectasterisk: false- sourcecolumns: []+ sourcecolumns:+ - instance: INSTANCE_ID_B+ server: REMOTE+ database: SCHEMA1+ schema: ""+ table: LV1+ column: ""predicatecolumns: []- description: Test For Database Linkstatement: SELECT * FROM SCHEMA1.LT1@REMOTE;@@ -438,7 +444,688 @@isplainfield: truesourcefieldpaths: []selectasterisk: false- sourcecolumns: []+ sourcecolumns:+ - instance: INSTANCE_ID_B+ server: REMOTE+ database: SCHEMA1+ schema: ""+ table: LT1+ column: ""+ predicatecolumns: []+- description: Test For Database Link Mixed With Local Table+ statement: SELECT * FROM T, SCHEMA1.LT1@REMOTE;+ defaultDatabase: PUBLIC+ metadata: |-+ {+ "name": "PUBLIC",+ "schemas": [+ {+ "name": "",+ "tables": [+ {+ "name": "T",+ "columns": [+ {+ "name": "A"+ }+ ]+ }+ ]+ }+ ],+ "linkedDatabases": [+ {+ "name": "REMOTE",+ "username": "SCHEMA1"+ }+ ]+ }+ querySpan:+ type: 1+ results:+ - name: A+ sourcecolumns:+ - server: ""+ database: PUBLIC+ schema: ""+ table: T+ column: A+ isplainfield: true+ sourcefieldpaths: []+ selectasterisk: false+ - name: LC1+ sourcecolumns:+ - server: ""+ database: SCHEMA1+ schema: ""+ table: LT1+ column: LC1+ isplainfield: true+ sourcefieldpaths: []+ selectasterisk: false+ sourcecolumns:+ - server: ""+ database: PUBLIC+ schema: ""+ table: T+ column: ""+ - instance: INSTANCE_ID_B+ server: REMOTE+ database: SCHEMA1+ schema: ""+ table: LT1+ column: ""+ predicatecolumns: []+- description: Test For Database Link Unqualified+ statement: SELECT * FROM LT1@REMOTE;+ defaultDatabase: PUBLIC+ metadata: |-+ {+ "name": "PUBLIC",+ "schemas": [+ {+ "name": "",+ "tables": [+ {+ "name": "T",+ "columns": [+ {+ "name": "A"+ }+ ]+ }+ ]+ }+ ],+ "linkedDatabases": [+ {+ "name": "REMOTE",+ "username": "SCHEMA1"+ }+ ]+ }+ querySpan:+ type: 1+ results:+ - name: LC1+ sourcecolumns:+ - server: ""+ database: SCHEMA1+ schema: ""+ table: LT1+ column: LC1+ isplainfield: true+ sourcefieldpaths: []+ selectasterisk: false+ sourcecolumns:+ - instance: INSTANCE_ID_B+ server: REMOTE+ database: SCHEMA1+ schema: ""+ table: LT1+ column: ""+ predicatecolumns: []+- description: Test For Database Link In Scalar Subquery+ statement: SELECT (SELECT MAX(LC1) FROM SCHEMA1.LT1@REMOTE) AS M FROM T;+ defaultDatabase: PUBLIC+ metadata: |-+ {+ "name": "PUBLIC",+ "schemas": [+ {+ "name": "",+ "tables": [+ {+ "name": "T",+ "columns": [+ {+ "name": "A"+ }+ ]+ }+ ]+ }+ ],+ "linkedDatabases": [+ {+ "name": "REMOTE",+ "username": "SCHEMA1"+ }+ ]+ }+ querySpan:+ type: 1+ results:+ - name: M+ sourcecolumns:+ - server: ""+ database: SCHEMA1+ schema: ""+ table: LT1+ column: LC1+ isplainfield: false+ sourcefieldpaths: []+ selectasterisk: false+ sourcecolumns:+ - server: ""+ database: PUBLIC+ schema: ""+ table: T+ column: ""+ - instance: INSTANCE_ID_B+ server: REMOTE+ database: SCHEMA1+ schema: ""+ table: LT1+ column: ""+ predicatecolumns: []+- description: Test For Database Link Unresolvable+ statement: SELECT * FROM T, SCHEMA1.LT1@NOLINK;+ defaultDatabase: PUBLIC+ metadata: |-+ {+ "name": "PUBLIC",+ "schemas": [+ {+ "name": "",+ "tables": [+ {+ "name": "T",+ "columns": [+ {+ "name": "A"+ }+ ]+ }+ ]+ }+ ],+ "linkedDatabases": [+ {+ "name": "REMOTE",+ "username": "SCHEMA1"+ }+ ]+ }+ querySpan:+ type: 1+ results: []+ sourcecolumns:+ - server: NOLINK+ database: SCHEMA1+ schema: ""+ table: LT1+ column: ""+ - server: ""+ database: PUBLIC+ schema: ""+ table: T+ column: ""+ predicatecolumns: []+- description: Test For Database Link With A Connection Qualifier+ statement: SELECT * FROM T, SCHEMA1.LT1@REMOTE@Q;+ defaultDatabase: PUBLIC+ metadata: |-+ {+ "name": "PUBLIC",+ "schemas": [+ {+ "name": "",+ "tables": [+ {+ "name": "T",+ "columns": [+ {+ "name": "A"+ }+ ]+ }+ ]+ }+ ],+ "linkedDatabases": [+ {+ "name": "REMOTE",+ "username": "SCHEMA1"+ }+ ]+ }+ querySpan:+ type: 1+ results: []+ sourcecolumns:+ - server: ""+ database: PUBLIC+ schema: ""+ table: T+ column: ""+ - server: REMOTE@Q+ database: SCHEMA1+ schema: ""+ table: LT1+ column: ""+ predicatecolumns: []+- description: Test For Database Link With Local Namesake+ statement: SELECT * FROM SCHEMA1.LT1@REMOTE;+ defaultDatabase: PUBLIC+ metadata: |-+ {+ "name": "PUBLIC",+ "schemas": [+ {+ "name": "",+ "tables": [+ {+ "name": "T",+ "columns": [+ {+ "name": "A"+ }+ ]+ }+ ]+ }+ ],+ "linkedDatabases": [+ {+ "name": "REMOTE",+ "username": "SCHEMA1"+ }+ ]+ }+ crossDatabaseMetadata: |-+ {+ "name": "SCHEMA1",+ "schemas": [+ {+ "name": "",+ "tables": [+ {+ "name": "LT1",+ "columns": [+ {+ "name": "LOCAL_ONLY"+ }+ ]+ }+ ]+ }+ ]+ }+ querySpan:+ type: 1+ results:+ - name: LC1+ sourcecolumns:+ - server: ""+ database: SCHEMA1+ schema: ""+ table: LT1+ column: LC1+ isplainfield: true+ sourcefieldpaths: []+ selectasterisk: false+ sourcecolumns:+ - instance: INSTANCE_ID_B+ server: REMOTE+ database: SCHEMA1+ schema: ""+ table: LT1+ column: ""+ predicatecolumns: []+- description: Test For Database Link To The Connected Instance+ statement: SELECT * FROM SCHEMA1.LT1@LOOPBACK;+ defaultDatabase: PUBLIC+ metadata: |-+ {+ "name": "PUBLIC",+ "schemas": [+ {+ "name": "",+ "tables": [+ {+ "name": "T",+ "columns": [+ {+ "name": "A"+ }+ ]+ }+ ]+ }+ ],+ "linkedDatabases": [+ {+ "name": "LOOPBACK",+ "username": "SCHEMA1"+ }+ ]+ }+ crossDatabaseMetadata: |-+ {+ "name": "SCHEMA1",+ "schemas": [+ {+ "name": "",+ "tables": [+ {+ "name": "LT1",+ "columns": [+ {+ "name": "LOCAL_LC1"+ }+ ]+ }+ ]+ }+ ]+ }+ querySpan:+ type: 1+ results:+ - name: LOCAL_LC1+ sourcecolumns:+ - server: ""+ database: SCHEMA1+ schema: ""+ table: LT1+ column: LOCAL_LC1+ isplainfield: true+ sourcefieldpaths: []+ selectasterisk: false+ sourcecolumns:+ - instance: INSTANCE_ID_A+ server: LOOPBACK+ database: SCHEMA1+ schema: ""+ table: LT1+ column: ""+ predicatecolumns: []+- description: Test For Database Link To The Connected Instance Unqualified+ statement: SELECT * FROM T, LT1@LOOPBACK;+ defaultDatabase: PUBLIC+ metadata: |-+ {+ "name": "PUBLIC",+ "schemas": [+ {+ "name": "",+ "tables": [+ {+ "name": "T",+ "columns": [+ {+ "name": "A"+ }+ ]+ }+ ]+ }+ ],+ "linkedDatabases": [+ {+ "name": "LOOPBACK",+ "username": "SCHEMA1"+ }+ ]+ }+ crossDatabaseMetadata: |-+ {+ "name": "SCHEMA1",+ "schemas": [+ {+ "name": "",+ "tables": [+ {+ "name": "LT1",+ "columns": [+ {+ "name": "LOCAL_LC1"+ }+ ]+ }+ ]+ }+ ]+ }+ querySpan:+ type: 1+ results:+ - name: A+ sourcecolumns:+ - server: ""+ database: PUBLIC+ schema: ""+ table: T+ column: A+ isplainfield: true+ sourcefieldpaths: []+ selectasterisk: false+ - name: LOCAL_LC1+ sourcecolumns:+ - server: ""+ database: SCHEMA1+ schema: ""+ table: LT1+ column: LOCAL_LC1+ isplainfield: true+ sourcefieldpaths: []+ selectasterisk: false+ sourcecolumns:+ - instance: INSTANCE_ID_A+ server: LOOPBACK+ database: SCHEMA1+ schema: ""+ table: LT1+ column: ""+ - server: ""+ database: PUBLIC+ schema: ""+ table: T+ column: ""+ predicatecolumns: []+- description: Test For Database Link Into A System Schema+ statement: SELECT * FROM SYS.DBA_USERS@REMOTE;+ defaultDatabase: PUBLIC+ metadata: |-+ {+ "name": "PUBLIC",+ "schemas": [+ {+ "name": "",+ "tables": [+ {+ "name": "T",+ "columns": [+ {+ "name": "A"+ }+ ]+ }+ ]+ }+ ],+ "linkedDatabases": [+ {+ "name": "REMOTE",+ "username": "SCHEMA1"+ }+ ]+ }+ querySpan:+ type: 1+ results: []+ sourcecolumns:+ - server: REMOTE+ database: SYS+ schema: ""+ table: DBA_USERS+ column: ""+ predicatecolumns: []+- description: Test For Database Link Into A System Schema Mixed With Local Table+ statement: SELECT * FROM T, SYS.DBA_USERS@REMOTE;+ defaultDatabase: PUBLIC+ metadata: |-+ {+ "name": "PUBLIC",+ "schemas": [+ {+ "name": "",+ "tables": [+ {+ "name": "T",+ "columns": [+ {+ "name": "A"+ }+ ]+ }+ ]+ }+ ],+ "linkedDatabases": [+ {+ "name": "REMOTE",+ "username": "SCHEMA1"+ }+ ]+ }+ querySpan:+ type: 1+ results: []+ sourcecolumns:+ - server: ""+ database: PUBLIC+ schema: ""+ table: T+ column: ""+ - server: REMOTE+ database: SYS+ schema: ""+ table: DBA_USERS+ column: ""+ predicatecolumns: []+- description: Test For Local Table With SYS.DUAL And A Link+ statement: SELECT T.A, (SELECT 1 FROM SYS.DUAL) AS ONE FROM T, SCHEMA1.LT1@REMOTE;+ defaultDatabase: PUBLIC+ metadata: |-+ {+ "name": "PUBLIC",+ "schemas": [+ {+ "name": "",+ "tables": [+ {+ "name": "T",+ "columns": [+ {+ "name": "A"+ }+ ]+ }+ ]+ }+ ],+ "linkedDatabases": [+ {+ "name": "REMOTE",+ "username": "SCHEMA1"+ }+ ]+ }+ querySpan:+ type: 1+ results:+ - name: A+ sourcecolumns:+ - server: ""+ database: PUBLIC+ schema: ""+ table: T+ column: A+ isplainfield: false+ sourcefieldpaths: []+ selectasterisk: false+ - name: ONE+ sourcecolumns: []+ isplainfield: false+ sourcefieldpaths: []+ selectasterisk: false+ sourcecolumns:+ - server: ""+ database: PUBLIC+ schema: ""+ table: T+ column: ""+ - instance: INSTANCE_ID_B+ server: REMOTE+ database: SCHEMA1+ schema: ""+ table: LT1+ column: ""+ predicatecolumns: []+- description: Test For A Real Table Named DUAL+ statement: SELECT * FROM APP.DUAL, SCHEMA1.DUAL@REMOTE, SYS.DUAL;+ defaultDatabase: PUBLIC+ metadata: |-+ {+ "name": "PUBLIC",+ "schemas": [+ {+ "name": "",+ "tables": [+ {+ "name": "T",+ "columns": [+ {+ "name": "A"+ }+ ]+ }+ ]+ }+ ],+ "linkedDatabases": [+ {+ "name": "REMOTE",+ "username": "SCHEMA1"+ }+ ]+ }+ crossDatabaseMetadata: |-+ {+ "name": "APP",+ "schemas": [+ {+ "name": "",+ "tables": [+ {+ "name": "DUAL",+ "columns": [+ {+ "name": "SECRET"+ }+ ]+ }+ ]+ }+ ]+ }+ querySpan:+ type: 1+ results: []+ sourcecolumns:+ - server: ""+ database: APP+ schema: ""+ table: DUAL+ column: ""+ - instance: INSTANCE_ID_B+ server: REMOTE+ database: SCHEMA1+ schema: ""+ table: DUAL+ column: ""predicatecolumns: []- description: Test For Explain statementsstatement: EXPLAIN PLAN for SELECT 1 FROM DUAL;diff --git a/backend/store/model/database.go b/backend/store/model/database.goindex 56cfa95b65..7f0b1f53b6 100644--- a/backend/store/model/database.go+++ b/backend/store/model/database.go@@ -23,9 +23,8 @@ type DatabaseMetadata struct {isDetailCaseSensitive bool// Metadata fields (formerly in DatabaseMetadata)- searchPath []PGSearchPathItem- internal map[string]*SchemaMetadata- linkedDatabase map[string]*metadatapb.LinkedDatabaseMetadata+ searchPath []PGSearchPathItem+ internal map[string]*SchemaMetadata}// SchemaMetadata is the unified metadata for a schema, combining proto metadata and catalog config.@@ -105,7 +104,6 @@ func NewDatabaseMetadata(isDetailCaseSensitive: isDetailCaseSensitive,searchPath: ParsePGConfiguredSearchPath(metadata.SearchPath),internal: make(map[string]*SchemaMetadata),- linkedDatabase: make(map[string]*metadatapb.LinkedDatabaseMetadata),}// Build a map of schema catalogs for quick lookup@@ -192,11 +190,6 @@ func NewDatabaseMetadata(dbMetadata.internal[schemaID] = schemaMetadata}- for _, dbLink := range metadata.LinkedDatabases {- dbLinkID := normalizeNameByCaseSensitivity(dbLink.Name, isObjectCaseSensitive)- dbMetadata.linkedDatabase[dbLinkID] = dbLink- }-return dbMetadata}@@ -215,7 +208,6 @@ func (d *DatabaseMetadata) ReplaceFrom(other *DatabaseMetadata) {d.isDetailCaseSensitive = other.isDetailCaseSensitived.searchPath = other.searchPathd.internal = other.internal- d.linkedDatabase = other.linkedDatabase}func (d *DatabaseMetadata) GetRawDump() []byte {@@ -271,11 +263,6 @@ func (d *DatabaseMetadata) ListSchemaNames() []string {return result}-func (d *DatabaseMetadata) GetLinkedDatabase(name string) *metadatapb.LinkedDatabaseMetadata {- nameID := normalizeNameByCaseSensitivity(name, d.isObjectCaseSensitive)- return d.linkedDatabase[nameID]-}-func (d *DatabaseMetadata) GetIsObjectCaseSensitive() bool {return d.isObjectCaseSensitive}