25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
fix(kingbase): recover view source hidden from non-owner roles (#13027)
ezreal7ea4031465d2
diff --git a/agents/drivers/kingbase-go/kingbase_metadata.go b/agents/drivers/kingbase-go/kingbase_metadata.goindex 3905c2e702..c5dc3414ab 100644--- a/agents/drivers/kingbase-go/kingbase_metadata.go+++ b/agents/drivers/kingbase-go/kingbase_metadata.go@@ -2787,25 +2787,7 @@ func (s *server) getObjectSourceForRelation(schema, name, objectType, relationNasource := ""kind := strings.ToUpper(objectType)if kind == "VIEW" {- if s.mode.mysqlCompat {- err = s.requireDBQueryRow("SELECT view_definition FROM information_schema.views WHERE table_schema = "+quoteLiteral(effective)+" AND table_name = "+quoteLiteral(name), &source)- } else {- catalog, prefix, function := "sys_catalog", "sys", "sys_get_viewdef"- if s.mode.postgresCatalog {- catalog, prefix, function = "pg_catalog", "pg", "pg_get_viewdef"- } else if s.usePgViewDefinition {- function = "pg_get_viewdef"- }- querySource := func(definitionFunction string) error {- query := fmt.Sprintf("SELECT %s(c.oid) FROM %s.%s_class c JOIN %s.%s_namespace n ON n.oid=c.relnamespace WHERE n.nspname=%s AND c.relname=%s LIMIT 1", definitionFunction, catalog, prefix, catalog, prefix, quoteLiteral(effective), quoteLiteral(name))- return s.requireDBQueryRow(query, &source)- }- err = querySource(function)- if err != nil && function == "sys_get_viewdef" && isUndefinedFunction(err, function) {- s.usePgViewDefinition = true- err = querySource("pg_get_viewdef")- }- }+ source, err = s.getViewSource(effective, name)} else if kind == "MATERIALIZED_VIEW" {source, err = s.getMaterializedViewSource(effective, name)} else if kind == "FUNCTION" || kind == "PROCEDURE" {@@ -2863,6 +2845,60 @@ func (s *server) getObjectSourceForRelation(schema, name, objectType, relationNareturn result, nil}+func (s *server) getViewSource(schema, name string) (string, error) {+ querySource := func(query string) (string, error) {+ var source sql.NullString+ if err := s.requireDBQueryRow(query, &source); err != nil {+ return "", err+ }+ if !source.Valid || strings.TrimSpace(source.String) == "" {+ return "", sql.ErrNoRows+ }+ return source.String, nil+ }+ if s.mode.mysqlCompat {+ // information_schema can expose a view while hiding its definition from+ // a non-owner with SELECT privileges. Try the catalogs as the same user.+ source, err := querySource("SELECT view_definition FROM information_schema.views WHERE table_schema = " + quoteLiteral(schema) + " AND table_name = " + quoteLiteral(name))+ if err == nil {+ return source, nil+ }+ if !errors.Is(err, sql.ErrNoRows) {+ return "", err+ }+ }++ catalog, prefix, function := "sys_catalog", "sys", "sys_get_viewdef"+ if s.mode.postgresCatalog {+ catalog, prefix, function = "pg_catalog", "pg", "pg_get_viewdef"+ } else if s.usePgViewDefinition {+ function = "pg_get_viewdef"+ }+ queryCatalog := func(definitionFunction string) (string, error) {+ query := fmt.Sprintf("SELECT %s(c.oid) FROM %s.%s_class c JOIN %s.%s_namespace n ON n.oid=c.relnamespace WHERE n.nspname=%s AND c.relname=%s AND c.relkind = 'v' LIMIT 1", definitionFunction, catalog, prefix, catalog, prefix, quoteLiteral(schema), quoteLiteral(name))+ return querySource(query)+ }+ source, err := queryCatalog(function)+ if err == nil {+ return source, nil+ }+ if function == "sys_get_viewdef" {+ if isUndefinedFunction(err, function) {+ s.usePgViewDefinition = true+ } else if !errors.Is(err, sql.ErrNoRows) {+ return "", err+ }+ source, err = queryCatalog("pg_get_viewdef")+ if err == nil {+ return source, nil+ }+ }+ if errors.Is(err, sql.ErrNoRows) {+ return "", fmt.Errorf("view %q.%q does not exist or its source definition is unavailable to the current user", schema, name)+ }+ return "", err+}+func (s *server) getMaterializedViewSource(schema, name string) (string, error) {catalog, prefix, function := "sys_catalog", "sys", "sys_get_viewdef"if s.mode.postgresCatalog {diff --git a/agents/drivers/kingbase-go/view_source_integration_test.go b/agents/drivers/kingbase-go/view_source_integration_test.gonew file mode 100644index 0000000000..9c58a68178--- /dev/null+++ b/agents/drivers/kingbase-go/view_source_integration_test.go@@ -0,0 +1,103 @@+package main++import (+ "database/sql"+ "fmt"+ "os"+ "strconv"+ "strings"+ "testing"+ "time"+)++func TestKingbaseNonOwnerViewSourceIntegration(t *testing.T) {+ host := os.Getenv("KINGBASE_TEST_HOST")+ portText := os.Getenv("KINGBASE_TEST_PORT")+ username := os.Getenv("KINGBASE_TEST_USERNAME")+ if host == "" || portText == "" || username == "" {+ t.Skip("Kingbase integration environment is not configured")+ }+ port, err := strconv.Atoi(portText)+ if err != nil {+ t.Fatal(err)+ }+ database := os.Getenv("KINGBASE_TEST_DATABASE")+ if database == "" {+ database = "test"+ }+ cp := connectParams{Host: host, Port: port, Database: database, Username: username, Password: os.Getenv("KINGBASE_TEST_PASSWORD")}+ if strings.HasPrefix(host, "/") {+ cp.URLParams = "sslmode=disable"+ }+ server := newServer()+ if err := server.connect(cp); err != nil {+ t.Fatal(err)+ }+ t.Cleanup(func() { _ = server.disconnect() })+ // SET ROLE and metadata queries must share the connection for the whole test.+ server.db.SetConnMaxLifetime(0)+ rolesCatalog := "sys_catalog.sys_roles"+ if server.mode.postgresCatalog {+ rolesCatalog = "pg_catalog.pg_roles"+ }+ var superuser bool+ if err := server.requireDBQueryRow("SELECT rolsuper FROM "+rolesCatalog+" WHERE rolname = current_user", &superuser); err != nil {+ t.Fatal(err)+ }+ if !superuser {+ t.Skip("non-owner view source integration requires a superuser to create and assume an isolated test role")+ }++ suffix := strconv.FormatInt(time.Now().UnixNano(), 36)+ schema := "dbx_view_src_" + suffix+ role := "dbx_view_reader_" + suffix+ view := "visible_view"+ qualifiedView := quoteIdentifier(schema) + "." + quoteIdentifier(view)+ mustExecute(t, server, "CREATE ROLE "+quoteIdentifier(role)+" NOLOGIN NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT")+ t.Cleanup(func() {+ for _, statement := range []string{+ "RESET ROLE",+ "DROP VIEW IF EXISTS " + qualifiedView,+ "DROP SCHEMA IF EXISTS " + quoteIdentifier(schema),+ "DROP ROLE IF EXISTS " + quoteIdentifier(role),+ } {+ if _, err := server.executeQuery(queryOptions{SQL: statement}); err != nil {+ t.Errorf("cleanup %s: %v", statement, err)+ }+ }+ })+ mustExecute(t, server, "CREATE SCHEMA "+quoteIdentifier(schema))+ mustExecute(t, server, "CREATE VIEW "+qualifiedView+" AS SELECT 13002 AS issue_no")+ mustExecute(t, server, "GRANT USAGE ON SCHEMA "+quoteIdentifier(schema)+" TO "+quoteIdentifier(role))+ mustExecute(t, server, "GRANT SELECT ON "+qualifiedView+" TO "+quoteIdentifier(role))++ ownerSource, err := server.getObjectSource(schema, view, "VIEW")+ if err != nil || !strings.Contains(fmt.Sprint(ownerSource["source"]), "13002") {+ t.Fatalf("owner could not read view source: source=%v err=%v", ownerSource, err)+ }+ mustExecute(t, server, "SET ROLE "+quoteIdentifier(role))+ var currentUser string+ if err := server.requireDBQueryRow("SELECT current_user", ¤tUser); err != nil || currentUser != role {+ t.Fatalf("test role was not applied: current_user=%q err=%v", currentUser, err)+ }+ var value int+ if err := server.requireDBQueryRow("SELECT issue_no FROM "+qualifiedView, &value); err != nil || value != 13002 {+ t.Fatalf("non-owner cannot select from test view: value=%d err=%v", value, err)+ }+ if server.mode.mysqlCompat {+ var definition sql.NullString+ query := "SELECT view_definition FROM information_schema.views WHERE table_schema = " + quoteLiteral(schema) + " AND table_name = " + quoteLiteral(view)+ if err := server.requireDBQueryRow(query, &definition); err != nil {+ t.Fatal(err)+ }+ if definition.Valid {+ t.Fatal("expected a hidden information_schema definition for the non-owner role")+ }+ t.Log("non-owner can SELECT the view while information_schema.view_definition is NULL")+ }+ source, err := server.getObjectSource(schema, view, "VIEW")+ if err != nil || !strings.Contains(fmt.Sprint(source["source"]), "13002") {+ t.Fatalf("non-owner could not read view source: source=%v err=%v", source, err)+ }+ t.Logf("non-owner view source recovered (mysqlCompat=%v, postgresCatalog=%v)", server.mode.mysqlCompat, server.mode.postgresCatalog)+}diff --git a/agents/drivers/kingbase-go/view_source_test.go b/agents/drivers/kingbase-go/view_source_test.gonew file mode 100644index 0000000000..30ae679fa9--- /dev/null+++ b/agents/drivers/kingbase-go/view_source_test.go@@ -0,0 +1,230 @@+package main++import (+ "database/sql/driver"+ "errors"+ "strings"+ "testing"++ "gitea.com/kingbase/gokb"+)++func TestOrdinaryViewSourceFallsBackFromHiddenInformationSchemaDefinition(t *testing.T) {+ for _, test := range []struct {+ name string+ rows [][]driver.Value+ }{+ {name: "NULL", rows: [][]driver.Value{{nil}}},+ {name: "empty", rows: [][]driver.Value{{""}}},+ {name: "whitespace", rows: [][]driver.Value{{" \t\n"}}},+ {name: "no rows"},+ } {+ t.Run(test.name, func(t *testing.T) {+ const definition = " SELECT 'kept verbatim' AS value;\n"+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {+ if strings.Contains(query, "information_schema.views") {+ if !strings.Contains(query, "table_schema = 'app''s'") || !strings.Contains(query, "table_name = 'View''s'") {+ return nil, errors.New("information schema query lost its quoted object identity: " + query)+ }+ return &valueRows{columns: []string{"view_definition"}, rows: test.rows}, nil+ }+ for _, fragment := range []string{"SELECT sys_get_viewdef(c.oid)", "FROM sys_catalog.sys_class", "n.nspname='app''s'", "c.relname='View''s'", "c.relkind = 'v'"} {+ if !strings.Contains(query, fragment) {+ return nil, errors.New("fallback query lost its catalog or object identity: " + query)+ }+ }+ return &valueRows{columns: []string{"source"}, rows: [][]driver.Value{{definition}}}, nil+ }}+ server := newServer()+ server.db = openMetadataDB(t, state)+ server.mode.mysqlCompat = true++ source, err := server.getObjectSource("app's", "View's", "VIEW")+ if err != nil || source["source"] != definition || source["schema"] != "app's" || source["name"] != "View's" {+ t.Fatalf("non-owner view definition was not recovered: source=%#v err=%v", source, err)+ }+ if queries := state.snapshotQueries(); len(queries) != 2 {+ t.Fatalf("expected one information schema query and one catalog fallback: %v", queries)+ }+ if server.usePgViewDefinition {+ t.Fatal("an object-specific missing definition must not change the function capability cache")+ }+ })+ }+}++func TestOrdinaryViewSourceUsesPostgresCatalog(t *testing.T) {+ for _, mysqlCompat := range []bool{false, true} {+ t.Run(map[bool]string{false: "direct", true: "information schema fallback"}[mysqlCompat], func(t *testing.T) {+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {+ if mysqlCompat && strings.Contains(query, "information_schema.views") {+ return &valueRows{columns: []string{"view_definition"}, rows: [][]driver.Value{{nil}}}, nil+ }+ for _, fragment := range []string{"SELECT pg_get_viewdef(c.oid)", "FROM pg_catalog.pg_class", "pg_catalog.pg_namespace", "n.nspname='app'", "c.relname='orders'", "c.relkind = 'v'"} {+ if !strings.Contains(query, fragment) {+ return nil, errors.New("unexpected PostgreSQL catalog query: " + query)+ }+ }+ return &valueRows{columns: []string{"source"}, rows: [][]driver.Value{{"SELECT 1 AS order_id"}}}, nil+ }}+ server := newServer()+ server.db = openMetadataDB(t, state)+ server.mode.mysqlCompat = mysqlCompat+ server.mode.postgresCatalog = true++ source, err := server.getObjectSource("app", "orders", "VIEW")+ if err != nil || source["source"] != "SELECT 1 AS order_id" {+ t.Fatalf("unexpected PostgreSQL catalog source: source=%#v err=%v", source, err)+ }+ wantQueries := 1+ if mysqlCompat {+ wantQueries+++ }+ if queries := state.snapshotQueries(); len(queries) != wantQueries {+ t.Fatalf("unexpected catalog probes: %v", queries)+ }+ })+ }+}++func TestOrdinaryViewSourceCachesUndefinedSysFunction(t *testing.T) {+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {+ switch {+ case strings.Contains(query, "information_schema.views"):+ return &valueRows{columns: []string{"view_definition"}, rows: [][]driver.Value{{nil}}}, nil+ case strings.Contains(query, "sys_get_viewdef("):+ return nil, &gokb.Error{Code: gokb.ErrorCode("42883"), Message: "function sys_get_viewdef(oid) does not exist"}+ case strings.Contains(query, "pg_get_viewdef("):+ return &valueRows{columns: []string{"source"}, rows: [][]driver.Value{{"SELECT 1"}}}, nil+ default:+ return nil, errors.New("unexpected query: " + query)+ }+ }}+ server := newServer()+ server.db = openMetadataDB(t, state)+ server.mode.mysqlCompat = true++ for _, name := range []string{"first_view", "second_view"} {+ source, err := server.getObjectSource("app", name, "VIEW")+ if err != nil || source["source"] != "SELECT 1" {+ t.Fatalf("view %s failed: source=%#v err=%v", name, source, err)+ }+ }+ queries := state.snapshotQueries()+ if !server.usePgViewDefinition || len(queries) != 5 || !strings.Contains(queries[1], "sys_get_viewdef(") || !strings.Contains(queries[2], "pg_get_viewdef(") || !strings.Contains(queries[4], "pg_get_viewdef(") {+ t.Fatalf("missing sys function was not cached correctly: cached=%v queries=%v", server.usePgViewDefinition, queries)+ }+}++func TestOrdinaryViewSourceEmptySysDefinitionDoesNotPoisonCache(t *testing.T) {+ for _, test := range []struct {+ name string+ rows [][]driver.Value+ }{+ {name: "NULL", rows: [][]driver.Value{{nil}}},+ {name: "whitespace", rows: [][]driver.Value{{" \t"}}},+ {name: "no rows"},+ } {+ t.Run(test.name, func(t *testing.T) {+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {+ switch {+ case strings.Contains(query, "sys_get_viewdef(") && strings.Contains(query, "c.relname='first_view'"):+ return &valueRows{columns: []string{"source"}, rows: test.rows}, nil+ case strings.Contains(query, "sys_get_viewdef(") && strings.Contains(query, "c.relname='second_view'"):+ return &valueRows{columns: []string{"source"}, rows: [][]driver.Value{{"SELECT 'sys'"}}}, nil+ case strings.Contains(query, "pg_get_viewdef("):+ return &valueRows{columns: []string{"source"}, rows: [][]driver.Value{{"SELECT 'pg'"}}}, nil+ default:+ return nil, errors.New("unexpected query: " + query)+ }+ }}+ server := newServer()+ server.db = openMetadataDB(t, state)++ for _, testView := range []struct{ name, source string }{{"first_view", "SELECT 'pg'"}, {"second_view", "SELECT 'sys'"}} {+ source, err := server.getObjectSource("app", testView.name, "VIEW")+ if err != nil || source["source"] != testView.source {+ t.Fatalf("view-specific fallback failed: source=%#v err=%v", source, err)+ }+ }+ if queries := state.snapshotQueries(); len(queries) != 3 || server.usePgViewDefinition {+ t.Fatalf("object-specific empty definition poisoned the cache: cached=%v queries=%v", server.usePgViewDefinition, queries)+ }+ })+ }+}++func TestOrdinaryViewSourceRejectsUnavailableDefinition(t *testing.T) {+ for _, mode := range []struct {+ name string+ mysql, postgres bool+ wantQueries int+ }{+ {name: "mysql", mysql: true, wantQueries: 3},+ {name: "sys", wantQueries: 2},+ {name: "postgres", postgres: true, wantQueries: 1},+ } {+ for _, empty := range []struct {+ name string+ rows [][]driver.Value+ }{+ {name: "NULL", rows: [][]driver.Value{{nil}}},+ {name: "blank", rows: [][]driver.Value{{" \n"}}},+ {name: "no rows"},+ } {+ t.Run(mode.name+"/"+empty.name, func(t *testing.T) {+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {+ return &valueRows{columns: []string{"view_definition"}, rows: empty.rows}, nil+ }}+ server := newServer()+ server.db = openMetadataDB(t, state)+ server.mode.mysqlCompat = mode.mysql+ server.mode.postgresCatalog = mode.postgres++ _, err := server.getObjectSource("app", "unavailable_view", "VIEW")+ if err == nil || !strings.Contains(err.Error(), "view") || !strings.Contains(err.Error(), "source") || strings.Contains(err.Error(), "Scan error") {+ t.Fatalf("expected an explicit unavailable view source error, got %v", err)+ }+ if queries := state.snapshotQueries(); len(queries) != mode.wantQueries || server.usePgViewDefinition {+ t.Fatalf("unbounded probes or invalid capability cache: cached=%v queries=%v", server.usePgViewDefinition, queries)+ }+ })+ }+ }+}++func TestOrdinaryViewSourcePreservesQueryErrors(t *testing.T) {+ for _, stage := range []struct {+ name string+ wantQueries int+ }{+ {name: "information_schema.views", wantQueries: 1},+ {name: "sys_get_viewdef(", wantQueries: 2},+ {name: "pg_get_viewdef(", wantQueries: 3},+ } {+ for _, queryErr := range []error{+ &gokb.Error{Code: gokb.ErrorCode("42501"), Message: "permission denied"},+ errors.New("connection reset by peer"),+ } {+ t.Run(stage.name+"/"+queryErr.Error(), func(t *testing.T) {+ state := &metadataDriverState{query: func(query string) (driver.Rows, error) {+ if strings.Contains(query, stage.name) {+ return nil, queryErr+ }+ return &valueRows{columns: []string{"source"}, rows: [][]driver.Value{{nil}}}, nil+ }}+ server := newServer()+ server.db = openMetadataDB(t, state)+ server.mode.mysqlCompat = true++ _, err := server.getObjectSource("app", "orders", "VIEW")+ if !errors.Is(err, queryErr) {+ t.Fatalf("query error was swallowed or replaced: want=%v got=%v", queryErr, err)+ }+ if queries := state.snapshotQueries(); len(queries) != stage.wantQueries || server.usePgViewDefinition {+ t.Fatalf("unrelated error triggered fallback or poisoned cache: cached=%v queries=%v", server.usePgViewDefinition, queries)+ }+ })+ }+ }+}