package sql

import (

"bytes"

"context"

"encoding/hex"

"fmt"

"net"

"net/url"

"sort"

"strconv"

"strings"

"time"

"github.com/cockroachdb/apd/v3"

"github.com/cockroachdb/cockroach/pkg/base"

"github.com/cockroachdb/cockroach/pkg/build"

"github.com/cockroachdb/cockroach/pkg/clusterversion"

"github.com/cockroachdb/cockroach/pkg/config/zonepb"

"github.com/cockroachdb/cockroach/pkg/gossip"

"github.com/cockroachdb/cockroach/pkg/jobs"

"github.com/cockroachdb/cockroach/pkg/jobs/jobspb"

"github.com/cockroachdb/cockroach/pkg/jobs/jobsprotectedts"

"github.com/cockroachdb/cockroach/pkg/keys"

"github.com/cockroachdb/cockroach/pkg/kv/kvclient/kvcoord"

"github.com/cockroachdb/cockroach/pkg/kv/kvpb"

"github.com/cockroachdb/cockroach/pkg/kv/kvserver/kvflowcontrol/kvflowinspectpb"

"github.com/cockroachdb/cockroach/pkg/kv/kvserver/liveness/livenesspb"

"github.com/cockroachdb/cockroach/pkg/kv/kvserver/protectedts/ptpb"

slpb "github.com/cockroachdb/cockroach/pkg/kv/kvserver/storeliveness/storelivenesspb"

"github.com/cockroachdb/cockroach/pkg/multitenant/tenantcapabilities"

"github.com/cockroachdb/cockroach/pkg/multitenant/tenantcapabilitiespb"

"github.com/cockroachdb/cockroach/pkg/obs/ash"

"github.com/cockroachdb/cockroach/pkg/repstream/streampb"

"github.com/cockroachdb/cockroach/pkg/roachpb"

"github.com/cockroachdb/cockroach/pkg/scheduledjobs"

"github.com/cockroachdb/cockroach/pkg/security/username"

"github.com/cockroachdb/cockroach/pkg/server/serverpb"

"github.com/cockroachdb/cockroach/pkg/server/status/statuspb"

"github.com/cockroachdb/cockroach/pkg/server/telemetry"

"github.com/cockroachdb/cockroach/pkg/settings"

"github.com/cockroachdb/cockroach/pkg/sql/appstatspb"

"github.com/cockroachdb/cockroach/pkg/sql/catalog"

"github.com/cockroachdb/cockroach/pkg/sql/catalog/catalogkeys"

"github.com/cockroachdb/cockroach/pkg/sql/catalog/catenumpb"

"github.com/cockroachdb/cockroach/pkg/sql/catalog/catformat"

"github.com/cockroachdb/cockroach/pkg/sql/catalog/catpb"

"github.com/cockroachdb/cockroach/pkg/sql/catalog/catprivilege"

"github.com/cockroachdb/cockroach/pkg/sql/catalog/colinfo"

"github.com/cockroachdb/cockroach/pkg/sql/catalog/descpb"

"github.com/cockroachdb/cockroach/pkg/sql/catalog/descs"

"github.com/cockroachdb/cockroach/pkg/sql/catalog/multiregion"

"github.com/cockroachdb/cockroach/pkg/sql/catalog/nstree"

"github.com/cockroachdb/cockroach/pkg/sql/catalog/schemaexpr"

"github.com/cockroachdb/cockroach/pkg/sql/catalog/systemschema"

"github.com/cockroachdb/cockroach/pkg/sql/catalog/typedesc"

"github.com/cockroachdb/cockroach/pkg/sql/clusterunique"

"github.com/cockroachdb/cockroach/pkg/sql/contentionpb"

"github.com/cockroachdb/cockroach/pkg/sql/idxusage"

"github.com/cockroachdb/cockroach/pkg/sql/isql"

"github.com/cockroachdb/cockroach/pkg/sql/parser"

"github.com/cockroachdb/cockroach/pkg/sql/parserutils"

"github.com/cockroachdb/cockroach/pkg/sql/pgwire/pgcode"

"github.com/cockroachdb/cockroach/pkg/sql/pgwire/pgerror"

"github.com/cockroachdb/cockroach/pkg/sql/pgwire/pgnotice"

"github.com/cockroachdb/cockroach/pkg/sql/privilege"

"github.com/cockroachdb/cockroach/pkg/sql/protoreflect"

"github.com/cockroachdb/cockroach/pkg/sql/roleoption"

"github.com/cockroachdb/cockroach/pkg/sql/rowenc"

"github.com/cockroachdb/cockroach/pkg/sql/rowinfra"

"github.com/cockroachdb/cockroach/pkg/sql/sem/builtins"

"github.com/cockroachdb/cockroach/pkg/sql/sem/builtins/builtinsregistry"

"github.com/cockroachdb/cockroach/pkg/sql/sem/catconstants"

"github.com/cockroachdb/cockroach/pkg/sql/sem/catid"

"github.com/cockroachdb/cockroach/pkg/sql/sem/eval"

"github.com/cockroachdb/cockroach/pkg/sql/sem/idxtype"

"github.com/cockroachdb/cockroach/pkg/sql/sem/tree"

"github.com/cockroachdb/cockroach/pkg/sql/sessiondata"

"github.com/cockroachdb/cockroach/pkg/sql/sessiondatapb"

"github.com/cockroachdb/cockroach/pkg/sql/sqlstats"

"github.com/cockroachdb/cockroach/pkg/sql/sqlstats/persistedsqlstats/sqlstatsutil"

"github.com/cockroachdb/cockroach/pkg/sql/sqlstats/sslocal"

"github.com/cockroachdb/cockroach/pkg/sql/syntheticprivilege"

"github.com/cockroachdb/cockroach/pkg/sql/types"

"github.com/cockroachdb/cockroach/pkg/sql/vtable"

"github.com/cockroachdb/cockroach/pkg/sql/zoneconfig"

"github.com/cockroachdb/cockroach/pkg/util/admission/admissionpb"

"github.com/cockroachdb/cockroach/pkg/util/buildutil"

"github.com/cockroachdb/cockroach/pkg/util/duration"

"github.com/cockroachdb/cockroach/pkg/util/hlc"

"github.com/cockroachdb/cockroach/pkg/util/json"

"github.com/cockroachdb/cockroach/pkg/util/log"

"github.com/cockroachdb/cockroach/pkg/util/mon"

"github.com/cockroachdb/cockroach/pkg/util/protoutil"

"github.com/cockroachdb/cockroach/pkg/util/stop"

"github.com/cockroachdb/cockroach/pkg/util/timeutil"

"github.com/cockroachdb/cockroach/pkg/util/tracing"

"github.com/cockroachdb/cockroach/pkg/util/tracing/tracingpb"

"github.com/cockroachdb/errors"

"github.com/cockroachdb/redact"

"github.com/lib/pq/oid"

)

const CrdbInternalName = catconstants.CRDBInternalSchemaName

var crdbInternal = virtualSchema{

name: CrdbInternalName,

tableDefs: map[descpb.ID]virtualSchemaDef{

catconstants.CrdbInternalBackwardDependenciesTableID: crdbInternalBackwardDependenciesTable,

catconstants.CrdbInternalBuildInfoTableID: crdbInternalBuildInfoTable,

catconstants.CrdbInternalBuiltinFunctionsTableID: crdbInternalBuiltinFunctionsTable,

catconstants.CrdbInternalBuiltinFunctionCommentsTableID: crdbInternalBuiltinFunctionCommentsTable,

catconstants.CrdbInternalCatalogCommentsTableID: crdbInternalCatalogCommentsTable,

catconstants.CrdbInternalCatalogDescriptorTableID: crdbInternalCatalogDescriptorTable,

catconstants.CrdbInternalCatalogNamespaceTableID: crdbInternalCatalogNamespaceTable,

catconstants.CrdbInternalCatalogZonesTableID: crdbInternalCatalogZonesTable,

catconstants.CrdbInternalClusterContendedIndexesViewID: crdbInternalClusterContendedIndexesView,

catconstants.CrdbInternalClusterContendedKeysViewID: crdbInternalClusterContendedKeysView,

catconstants.CrdbInternalClusterContendedTablesViewID: crdbInternalClusterContendedTablesView,

catconstants.CrdbInternalClusterContentionEventsTableID: crdbInternalClusterContentionEventsTable,

catconstants.CrdbInternalClusterDistSQLFlowsTableID: crdbInternalClusterDistSQLFlowsTable,

catconstants.CrdbInternalClusterExecutionInsightsTableID: crdbInternalClusterExecutionInsightsTable,

catconstants.CrdbInternalClusterTxnExecutionInsightsTableID: crdbInternalClusterTxnExecutionInsightsTable,

catconstants.CrdbInternalClusterLocksTableID: crdbInternalClusterLocksTable,

catconstants.CrdbInternalClusterQueriesTableID: crdbInternalClusterQueriesTable,

catconstants.CrdbInternalClusterTransactionsTableID: crdbInternalClusterTxnsTable,

catconstants.CrdbInternalClusterSessionsTableID: crdbInternalClusterSessionsTable,

catconstants.CrdbInternalClusterHeldAdvisoryLocksTableID: crdbInternalClusterHeldAdvisoryLocksTable,

catconstants.CrdbInternalClusterSettingsTableID: crdbInternalClusterSettingsTable,

catconstants.CrdbInternalClusterStmtStatsTableID: crdbInternalClusterStmtStatsTable,

catconstants.CrdbInternalCreateFunctionStmtsTableID: crdbInternalCreateFunctionStmtsTable,

catconstants.CrdbInternalCreateTriggerStmtsTableID: crdbInternalCreateTriggerStmtsTable,

catconstants.CrdbInternalCreateProcedureStmtsTableID: crdbInternalCreateProcedureStmtsTable,

catconstants.CrdbInternalCreateSchemaStmtsTableID: crdbInternalCreateSchemaStmtsTable,

catconstants.CrdbInternalCreateStmtsTableID: crdbInternalCreateStmtsTable,

catconstants.CrdbInternalCreateTypeStmtsTableID: crdbInternalCreateTypeStmtsTable,

catconstants.CrdbInternalDatabasesTableID: crdbInternalDatabasesTable,

catconstants.CrdbInternalDroppedRelationsViewID: crdbInternalDroppedRelationsView,

catconstants.CrdbInternalSuperRegions: crdbInternalSuperRegions,

catconstants.CrdbInternalFeatureUsageID: crdbInternalFeatureUsage,

catconstants.CrdbInternalForwardDependenciesTableID: crdbInternalForwardDependenciesTable,

catconstants.CrdbInternalGossipNodesTableID: crdbInternalGossipNodesTable,

catconstants.CrdbInternalKVNodeLivenessTableID: crdbInternalKVNodeLivenessTable,

catconstants.CrdbInternalGossipAlertsTableID: crdbInternalGossipAlertsTable,

catconstants.CrdbInternalGossipLivenessTableID: crdbInternalGossipLivenessTable,

catconstants.CrdbInternalGossipNetworkTableID: crdbInternalGossipNetworkTable,

catconstants.CrdbInternalTransactionContentionEvents: crdbInternalTransactionContentionEventsTable,

catconstants.CrdbInternalIndexColumnsTableID: crdbInternalIndexColumnsTable,

catconstants.CrdbInternalIndexSpansTableID: crdbInternalIndexSpansTable,

catconstants.CrdbInternalIndexUsageStatisticsTableID: crdbInternalIndexUsageStatistics,

catconstants.CrdbInternalInflightTraceSpanTableID: crdbInternalInflightTraceSpanTable,

catconstants.CrdbInternalJobsTableID: crdbInternalJobsView,

catconstants.CrdbInternalSystemJobsTableID: crdbInternalSystemJobsTable,

catconstants.CrdbInternalKVNodeStatusTableID: crdbInternalKVNodeStatusTable,

catconstants.CrdbInternalKVStoreStatusTableID: crdbInternalKVStoreStatusTable,

catconstants.CrdbInternalLeasesTableID: crdbInternalLeasesTable,

catconstants.CrdbInternalLocalContentionEventsTableID: crdbInternalLocalContentionEventsTable,

catconstants.CrdbInternalLocalDistSQLFlowsTableID: crdbInternalLocalDistSQLFlowsTable,

catconstants.CrdbInternalLocalQueriesTableID: crdbInternalLocalQueriesTable,

catconstants.CrdbInternalLocalTransactionsTableID: crdbInternalLocalTxnsTable,

catconstants.CrdbInternalLocalSessionsTableID: crdbInternalLocalSessionsTable,

catconstants.CrdbInternalLocalMetricsTableID: crdbInternalLocalMetricsTable,

catconstants.CrdbInternalNodeExecutionInsightsTableID: crdbInternalNodeExecutionInsightsTable,

catconstants.CrdbInternalNodeMemoryMonitorsTableID: crdbInternalNodeMemoryMonitors,

catconstants.CrdbInternalNodeStmtStatsTableID: crdbInternalNodeStmtStatsTable,

catconstants.CrdbInternalNodeTxnExecutionInsightsTableID: crdbInternalNodeTxnExecutionInsightsTable,

catconstants.CrdbInternalNodeTxnStatsTableID: crdbInternalNodeTxnStatsTable,

catconstants.CrdbInternalPartitionsTableID: crdbInternalPartitionsTable,

catconstants.CrdbInternalRangesNoLeasesTableID: crdbInternalRangesNoLeasesTable,

catconstants.CrdbInternalRangesViewID: crdbInternalRangesView,

catconstants.CrdbInternalRuntimeInfoTableID: crdbInternalRuntimeInfoTable,

catconstants.CrdbInternalSchemaChangesTableID: crdbInternalSchemaChangesTable,

catconstants.CrdbInternalSessionTraceTableID: crdbInternalSessionTraceTable,

catconstants.CrdbInternalSessionVariablesTableID: crdbInternalSessionVariablesTable,

catconstants.CrdbInternalStmtActivityTableID: crdbInternalStmtActivityView,

catconstants.CrdbInternalStmtStatsTableID: crdbInternalStmtStatsView,

catconstants.CrdbInternalStmtStatsPersistedTableID: crdbInternalStmtStatsPersistedView,

catconstants.CrdbInternalStmtStatsPersistedV22_2TableID: crdbInternalStmtStatsPersistedViewV22_2,

catconstants.CrdbInternalTableColumnsTableID: crdbInternalTableColumnsTable,

catconstants.CrdbInternalTableIndexesTableID: crdbInternalTableIndexesTable,

catconstants.CrdbInternalTableSpansTableID: crdbInternalTableSpansTable,

catconstants.CrdbInternalTablesTableLastStatsID: crdbInternalTablesTableLastStats,

catconstants.CrdbInternalTablesTableID: crdbInternalTablesTable,

catconstants.CrdbInternalClusterTxnStatsTableID: crdbInternalClusterTxnStatsTable,

catconstants.CrdbInternalTxnActivityTableID: crdbInternalTxnActivityView,

catconstants.CrdbInternalTxnStatsTableID: crdbInternalTxnStatsView,

catconstants.CrdbInternalTxnStatsPersistedTableID: crdbInternalTxnStatsPersistedView,

catconstants.CrdbInternalTxnStatsPersistedV22_2TableID: crdbInternalTxnStatsPersistedViewV22_2,

catconstants.CrdbInternalTransactionStatsTableID: crdbInternalTransactionStatisticsTable,

catconstants.CrdbInternalZonesTableID: crdbInternalZonesTable,

catconstants.CrdbInternalInvalidDescriptorsTableID: crdbInternalInvalidDescriptorsTable,

catconstants.CrdbInternalClusterDatabasePrivilegesTableID: crdbInternalClusterDatabasePrivilegesTable,

catconstants.CrdbInternalCrossDbRefrences: crdbInternalCrossDbReferences,

catconstants.CrdbInternalLostTableDescriptors: crdbLostTableDescriptors,

catconstants.CrdbInternalClusterInflightTracesTable: crdbInternalClusterInflightTracesTable,

catconstants.CrdbInternalRegionsTable: crdbInternalRegionsTable,

catconstants.CrdbInternalDefaultPrivilegesTable: crdbInternalDefaultPrivilegesTable,

catconstants.CrdbInternalActiveRangeFeedsTable: crdbInternalActiveRangeFeedsTable,

catconstants.CrdbInternalTenantUsageDetailsViewID: crdbInternalTenantUsageDetailsView,

catconstants.CrdbInternalPgCatalogTableIsImplementedTableID: crdbInternalPgCatalogTableIsImplementedTable,

catconstants.CrdbInternalShowTenantCapabilitiesCacheTableID: crdbInternalShowTenantCapabilitiesCache,

catconstants.CrdbInternalInheritedRoleMembersTableID: crdbInternalInheritedRoleMembers,

catconstants.CrdbInternalKVSystemPrivilegesViewID: crdbInternalKVSystemPrivileges,

catconstants.CrdbInternalKVFlowHandlesID: crdbInternalKVFlowHandles,

catconstants.CrdbInternalKVFlowHandlesIDV2: crdbInternalKVFlowHandlesV2,

catconstants.CrdbInternalKVFlowControllerID: crdbInternalKVFlowController,

catconstants.CrdbInternalKVFlowControllerIDV2: crdbInternalKVFlowControllerV2,

catconstants.CrdbInternalKVFlowTokenDeductions: crdbInternalKVFlowTokenDeductions,

catconstants.CrdbInternalKVFlowTokenDeductionsV2: crdbInternalKVFlowTokenDeductionsV2,

catconstants.CrdbInternalRepairableCatalogCorruptionsViewID: crdbInternalRepairableCatalogCorruptions,

catconstants.CrdbInternalKVProtectedTS: crdbInternalKVProtectedTSTable,

catconstants.CrdbInternalKVSessionBasedLeases: crdbInternalSessionBasedLeases,

catconstants.CrdbInternalClusterReplicationResolvedViewID: crdbInternalClusterReplicationResolvedView,

catconstants.CrdbInternalLogicalReplicationResolvedViewID: crdbInternalLogicalReplicationResolvedView,

catconstants.CrdbInternalPCRStreamsTableID: crdbInternalPCRStreamsTable,

catconstants.CrdbInternalPCRStreamSpansTableID: crdbInternalPCRStreamSpansTable,

catconstants.CrdbInternalPCRStreamCheckpointsTableID: crdbInternalPCRStreamCheckpointsTable,

catconstants.CrdbInternalLDRProcessorTableID: crdbInternalLDRProcessorTable,

catconstants.CrdbInternalPCRProcessorTableID: crdbInternalPCRProcessorTable,

catconstants.CrdbInternalFullyQualifiedNamesViewID: crdbInternalFullyQualifiedNamesView,

catconstants.CrdbInternalStoreLivenessSupportFrom: crdbInternalStoreLivenessSupportFromTable,

catconstants.CrdbInternalStoreLivenessSupportFor: crdbInternalStoreLivenessSupportForTable,

catconstants.CrdbInternalClusterInspectErrorsViewID: crdbInternalClusterInspectErrorsView,

catconstants.CrdbInternalNodeActiveSessionHistoryTableID: crdbInternalNodeActiveSessionHistoryTable,

catconstants.CrdbInternalClusterActiveSessionHistoryTableID: crdbInternalClusterActiveSessionHistoryTable,

},

validWithNoDatabaseContext: true,

}

var SupportedCRDBInternalTables = map[string]struct{}{

// LOCKED: Do not add to this list.

// Supported tables now go in pkg/sql/vtable/information_schema_crdb.go

// More information can be found at the below document:

// https://docs.google.com/document/d/1STbb8bljTzK_jXRIJrxtijWsPhGErdH1vZdunzPwXvs/edit?tab=t.0

`cluster_contended_indexes`: {},

`cluster_contended_keys`: {},

`cluster_contended_tables`: {},

`cluster_contention_events`: {},

`cluster_locks`: {},

`cluster_queries`: {},

`cluster_sessions`: {},

`cluster_transactions`: {},

`index_usage_statistics`: {},

`statement_statistics`: {},

`transaction_contention_events`: {},

`transaction_statistics`: {},

`zones`: {},

}

var _ = SupportedCRDBInternalTables

var crdbInternalBuildInfoTable = virtualSchemaTable{

comment: `detailed identification strings (RAM, local node only)`,

schema: `

)`,

populate: func(_ context.Context, p *planner, _ catalog.DatabaseDescriptor, addRow func(...tree.Datum) error) error {

execCfg := p.ExecCfg()

nodeID, _ := execCfg.NodeInfo.NodeID.OptionalNodeID() // zero if not available

info := build.GetInfo()

for k, v := range map[string]string{

"Name": "CockroachDB",

"ClusterID": execCfg.NodeInfo.LogicalClusterID().String(),

"Organization": execCfg.Organization(),

"Build": info.Short().StripMarkers(),

"Version": info.Tag,

"Channel": info.Channel,

"VirtualClusterName": string(execCfg.VirtualClusterName),

} {

if err := addRow(

tree.NewDInt(tree.DInt(nodeID)),

tree.NewDString(k),

tree.NewDString(v),

); err != nil {

return err

}

}

return nil

},

}

var crdbInternalRuntimeInfoTable = virtualSchemaTable{

comment: `server parameters, useful to construct connection URLs (RAM, local node only)`,

schema: `

)`,

populate: func(ctx context.Context, p *planner, _ catalog.DatabaseDescriptor, addRow func(...tree.Datum) error) error {

if err := p.CheckPrivilege(ctx, syntheticprivilege.GlobalPrivilegeObject, privilege.VIEWCLUSTERMETADATA); err != nil {

return err

}

node := p.ExecCfg().NodeInfo

nodeID, _ := node.NodeID.OptionalNodeID() // zero if not available

dbURL, err := node.PGURL(url.User(username.RootUser))

if err != nil {

return err

}

for _, item := range []struct {

component string

url *url.URL

}{

{"DB", dbURL.ToPQ()}, {"UI", node.AdminURL()},

} {

var user string

if item.url.User != nil {

user = item.url.User.String()

}

host, port, err := net.SplitHostPort(item.url.Host)

if err != nil {

return err

}

for _, kv := range [][2]string{

{"URL", item.url.String()},

{"Scheme", item.url.Scheme},

{"User", user},

{"Host", host},

{"Port", port},

{"URI", item.url.RequestURI()},

} {

k, v := kv[0], kv[1]

if err := addRow(

tree.NewDInt(tree.DInt(nodeID)),

tree.NewDString(item.component),

tree.NewDString(k),

tree.NewDString(v),

); err != nil {

return err

}

}

}

return nil

},

}

var crdbInternalDatabasesTable = virtualSchemaTable{

comment: `databases accessible by the current user (KV scan)`,

schema: `

)`,

populate: func(ctx context.Context, p *planner, _ catalog.DatabaseDescriptor, addRow func(...tree.Datum) error) error {

return forEachDatabaseDesc(ctx, p, nil /* all databases */, true, /* requiresPrivileges */

func(ctx context.Context, db catalog.DatabaseDescriptor) error {

var survivalGoal = tree.DNull

var primaryRegion = tree.DNull

var secondaryRegion = tree.DNull

var placement = tree.DNull

regions := tree.NewDArray(types.String)

createNode := tree.CreateDatabase{}

createNode.ConnectionLimit = -1

createNode.Name = tree.Name(db.GetName())

if db.IsMultiRegion() {

primaryRegion = tree.NewDString(string(db.GetRegionConfig().PrimaryRegion))

createNode.PrimaryRegion = tree.Name(db.GetRegionConfig().PrimaryRegion)

secondaryRegion = tree.NewDString(string(db.GetRegionConfig().SecondaryRegion))

createNode.SecondaryRegion = tree.Name(db.GetRegionConfig().SecondaryRegion)

regionConfig, err := SynthesizeRegionConfig(ctx, p.txn, db.GetID(), p.Descriptors())

if err != nil {

return err

}

createNode.Regions = make(tree.NameList, len(regionConfig.Regions()))

for i, region := range regionConfig.Regions() {

if err := regions.Append(tree.NewDString(string(region))); err != nil {

return err

}

createNode.Regions[i] = tree.Name(region)

}

if db.GetRegionConfig().Placement == descpb.DataPlacement_RESTRICTED {

placement = tree.NewDString("restricted")

createNode.Placement = tree.DataPlacementRestricted

} else {

placement = tree.NewDString("default")

// We can't differentiate between a database that was created with

// unspecified and default, and we don't want to expose PLACEMENT

// unless we know the user wants to use PLACEMENT. Therefore, we

// only add a PLACEMENT clause if the database was configured with

// restricted placement.

createNode.Placement = tree.DataPlacementUnspecified

}

switch db.GetRegionConfig().SurvivalGoal {

case descpb.SurvivalGoal_ZONE_FAILURE:

survivalGoal = tree.NewDString("zone")

createNode.SurvivalGoal = tree.SurvivalGoalZoneFailure

case descpb.SurvivalGoal_REGION_FAILURE:

survivalGoal = tree.NewDString("region")

createNode.SurvivalGoal = tree.SurvivalGoalRegionFailure

default:

return errors.Newf("unknown survival goal: %d", db.GetRegionConfig().SurvivalGoal)

}

}

owner, err := p.getOwnerOfPrivilegeObject(ctx, db)

if err != nil {

return err

}

return addRow(

tree.NewDInt(tree.DInt(db.GetID())), // id

tree.NewDString(db.GetName()), // name

tree.NewDName(owner.Normalized()), // owner

primaryRegion, // primary_region

secondaryRegion, // secondary_region

regions, // regions

survivalGoal, // survival_goal

placement, // data_placement

tree.NewDString(createNode.String()), // create_statement

)

})

},

}

var crdbInternalSuperRegions = virtualSchemaTable{

comment: `list super regions of databases visible to the current user`,

schema: `

)`,

populate: func(ctx context.Context, p *planner, _ catalog.DatabaseDescriptor, addRow func(...tree.Datum) error) error {

return forEachDatabaseDesc(ctx, p, nil /* all databases */, true, /* requiresPrivileges */

func(ctx context.Context, db catalog.DatabaseDescriptor) error {

if !db.IsMultiRegion() {

return nil

}

typeID, err := db.MultiRegionEnumID()

if err != nil {

return err

}

typeDesc, err := descs.GetCatalogDescriptorGetter(ctx, p.Descriptors(), p.txn, p.EvalContext().Settings).WithoutNonPublic().Get().Type(ctx, typeID)

if err != nil {

return err

}

regionDesc := typeDesc.AsRegionEnumTypeDescriptor()

if regionDesc == nil {

return errors.AssertionFailedf("expected region enum type, not %s for type %q (%d)",

typeDesc.GetKind(), typeDesc.GetName(), typeDesc.GetID())

}

return regionDesc.ForEachSuperRegion(func(superRegion string) error {

regionList := tree.NewDArray(types.String)

if err := regionDesc.ForEachRegionInSuperRegion(superRegion, func(region catpb.RegionName) error {

return regionList.Append(tree.NewDString(region.String()))

}); err != nil {

return err

}

survivalGoalDatum := tree.DNull

goalStr, hasGoal, err := regionDesc.GetSuperRegionSurvivalGoal(superRegion)

if err != nil {

return err

}

if hasGoal {

survivalGoalDatum = tree.NewDString(goalStr)

}

return addRow(

tree.NewDInt(tree.DInt(db.GetID())), // id

tree.NewDString(db.GetName()), // database_name

tree.NewDString(superRegion), // super_region_name

regionList, // regions

survivalGoalDatum, // survival_goal

)

})

})

},

}

func makeCrdbInternalTablesAddRowFn(

}

var crdbInternalTablesTable = virtualSchemaTable{

comment: `table descriptors accessible by current user, including non-public and virtual (KV scan; expensive!)`,

schema: `

);`,

indexes: []virtualIndex{

{

// INDEX(parent_id) WHERE drop_time IS NULL

populate: func(ctx context.Context, unwrappedConstraint tree.Datum, p *planner, _ catalog.DatabaseDescriptor, addRow func(...tree.Datum) error) (matched bool, err error) {

dbID := descpb.ID(tree.MustBeDInt(unwrappedConstraint))

db, err := p.byIDGetterBuilder().WithoutDropped().Get().Database(ctx, dbID)

if err != nil {

return false, err

}

return crdbInternalTablesDatabaseLookupFunc(ctx, p, db, addRow)

},

},

{

// INDEX(database_name) WHERE drop_time IS NULL

populate: func(ctx context.Context, unwrappedConstraint tree.Datum, p *planner, _ catalog.DatabaseDescriptor, addRow func(...tree.Datum) error) (matched bool, err error) {

dbName := string(tree.MustBeDString(unwrappedConstraint))

db, err := p.byNameGetterBuilder().WithOffline().MaybeGet().Database(ctx, dbName)

if db == nil || err != nil {

return false, err

}

return crdbInternalTablesDatabaseLookupFunc(ctx, p, db, addRow)

},

},

},

populate: func(ctx context.Context, p *planner, db catalog.DatabaseDescriptor, addRow func(...tree.Datum) error) error {

all, err := p.Descriptors().GetAllDescriptors(ctx, p.txn, descs.GetCatalogGetAllOptions(ctx, p.EvalContext().Settings)...)

if err != nil {

return err

}

descs := all.OrderedDescriptors()

dbNames := make(map[descpb.ID]string)

scNames := make(map[descpb.ID]string)

// TODO(richardjcai): Remove this case for keys.PublicSchemaID in 22.2.

scNames[keys.PublicSchemaID] = catconstants.PublicSchemaName

// Record database descriptors for name lookups.

for _, desc := range descs {

if dbDesc, ok := desc.(catalog.DatabaseDescriptor); ok {

dbNames[dbDesc.GetID()] = dbDesc.GetName()

}

if scDesc, ok := desc.(catalog.SchemaDescriptor); ok {

scNames[scDesc.GetID()] = scDesc.GetName()

}

}

addDesc := makeCrdbInternalTablesAddRowFn(p, addRow)

// Note: we do not use forEachTableDesc() here because we want to

// include added and dropped descriptors.

for _, desc := range descs {

table, isTable := desc.(catalog.TableDescriptor)

if !isTable {

continue

}

dbName := dbNames[table.GetParentID()]

if dbName == "" {

// The parent database was deleted. This is possible e.g. when

// a database is dropped with CASCADE, and someone queries

// this virtual table before the dropped table descriptors are

// effectively deleted.

dbName = fmt.Sprintf("[%d]", table.GetParentID())

}

schemaName := scNames[table.GetParentSchemaID()]

if schemaName == "" {

// The parent schema was deleted, possibly due to reasons mentioned above.

schemaName = fmt.Sprintf("[%d]", table.GetParentSchemaID())

}

if err := addDesc(table, tree.NewDString(dbName), schemaName); err != nil {

return err

}

}

// Also add all the virtual descriptors.

vt := p.getVirtualTabler()

vSchemas := vt.getSchemas()

for _, virtSchemaName := range vt.getSchemaNames() {

e := vSchemas[virtSchemaName]

for _, tName := range e.orderedDefNames {

vTableEntry := e.defs[tName]

if err := addDesc(vTableEntry.desc, tree.DNull, virtSchemaName); err != nil {

return err

}

}

}

return nil

},

}

func crdbInternalTablesDatabaseLookupFunc(

}

var crdbInternalPgCatalogTableIsImplementedTable = virtualSchemaTable{

comment: `which entries of pg_catalog are implemented in this version of CockroachDB`,

schema: `

)`,

generator: func(ctx context.Context, p *planner, dbDesc catalog.DatabaseDescriptor, _ int64, stopper *stop.Stopper) (virtualTableGenerator, cleanupFunc, error) {

row := make(tree.Datums, 2)

worker := func(ctx context.Context, pusher rowPusher) error {

addDesc := func(table *virtualDefEntry, dbName tree.Datum, scName string) error {

tableDesc := table.desc

row = append(row[:0],

tree.NewDString(tableDesc.GetName()),

tree.MakeDBool(tree.DBool(table.unimplemented)),

)

return pusher.pushRow(row...)

}

vt := p.getVirtualTabler()

vSchemas := vt.getSchemas()

e := vSchemas["pg_catalog"]

for _, tName := range e.orderedDefNames {

vTableEntry := e.defs[tName]

if err := addDesc(vTableEntry, tree.DNull, "pg_catalog"); err != nil {

return err

}

}

return nil

}

return setupGenerator(ctx, worker, stopper)

},

}

var statsAsOfTimeClusterMode = settings.RegisterDurationSetting(

settings.ApplicationLevel,

"sql.crdb_internal.table_row_statistics.as_of_time",

"historical query time used to build the crdb_internal.table_row_statistics table",

-10*time.Second,

settings.WithValidateDuration(func(v time.Duration) error {

if v > 0 {

return errors.Errorf("cannot be set to a positive duration: %s", v)

}

return nil

}),

)

var crdbInternalTablesTableLastStats = virtualSchemaTable{

comment: "stats for all tables accessible by current user in current database as of 10s ago",

schema: `

)`,

populate: func(ctx context.Context, p *planner, dbContext catalog.DatabaseDescriptor, addRow func(...tree.Datum) error) error {

// Collect the statistics for all tables AS OF 10 seconds ago to avoid

// contention on the stats table. We pass a nil transaction so that the AS

// OF clause can be independent of any outer query.

query := fmt.Sprintf(`

ORDER BY "tableID", "createdAt" DESC, "rowCount" DESC`,

statsAsOfTimeClusterMode.String(&p.ExecCfg().Settings.SV))

statRows, err := p.ExtendedEvalContext().ExecCfg.InternalDB.Executor().QueryBufferedEx(

ctx, "crdb-internal-statistics-table", nil,

sessiondata.NodeUserSessionDataOverride,

query)

if err != nil {

// This query is likely to cause errors due to SHOW TABLES being run less

// than 10 seconds after cluster startup (10s is the default AS OF time

// for the query), causing the error "descriptor not found". We should

// tolerate this error and return nil.

if errors.Is(err, catalog.ErrDescriptorNotFound) {

return nil

}

return err

}

// Convert statistics into map: tableID -> rowCount.

statMap := make(map[tree.DInt]tree.Datum, len(statRows))

for _, r := range statRows {

statMap[tree.MustBeDInt(r[0])] = r[1]

}

// Walk over all available tables and show row count for each of them

// using collected statistics.

opts := forEachTableDescOptions{virtualOpts: virtualMany, allowAdding: true}

return forEachTableDesc(ctx, p, dbContext, opts,

func(ctx context.Context, descCtx tableDescContext) error {

table := descCtx.table

tableID := tree.DInt(table.GetID())

rowCount := tree.DNull

// For Virtual Tables report NULL row count.

if !table.IsVirtualTable() {

rowCount = tree.NewDInt(0)

if cnt, ok := statMap[tableID]; ok {

rowCount = cnt

}

}

return addRow(

tree.NewDInt(tableID),

tree.NewDString(table.GetName()),

rowCount,

)

},

)

},

}

var crdbInternalSchemaChangesTable = virtualSchemaTable{

comment: `ongoing schema changes, across all descriptors accessible by current user (KV scan; expensive!)`,

schema: `

)`,

populate: func(ctx context.Context, p *planner, _ catalog.DatabaseDescriptor, addRow func(...tree.Datum) error) error {

all, err := p.Descriptors().GetAllDescriptors(ctx, p.txn, descs.GetCatalogGetAllOptions(ctx, p.EvalContext().Settings)...)

if err != nil {

return err

}

descs := all.OrderedDescriptors()

// Note: we do not use forEachTableDesc() here because we want to

// include added and dropped descriptors.

for _, desc := range descs {

table, isTable := desc.(catalog.TableDescriptor)

if !isTable {

continue

}

if ok, err := p.HasAnyPrivilege(ctx, table); err != nil {

return err

} else if !ok {

continue

}

tableID := tree.NewDInt(tree.DInt(int64(table.GetID())))

parentID := tree.NewDInt(tree.DInt(int64(table.GetParentID())))

tableName := tree.NewDString(table.GetName())

for _, mut := range table.TableDesc().Mutations {

mutType := "UNKNOWN"

targetID := tree.DNull

targetName := tree.DNull

switch d := mut.Descriptor_.(type) {

case *descpb.DescriptorMutation_Column:

mutType = "COLUMN"

targetID = tree.NewDInt(tree.DInt(int64(d.Column.ID)))

targetName = tree.NewDString(d.Column.Name)

case *descpb.DescriptorMutation_Index:

mutType = "INDEX"

targetID = tree.NewDInt(tree.DInt(int64(d.Index.ID)))

targetName = tree.NewDString(d.Index.Name)

case *descpb.DescriptorMutation_Constraint:

mutType = "CONSTRAINT VALIDATION"

targetName = tree.NewDString(d.Constraint.Name)

}

if err := addRow(

tableID,

parentID,

tableName,

tree.NewDString(mutType),

targetID,

targetName,

tree.NewDString(mut.State.String()),

tree.NewDString(mut.Direction.String()),

); err != nil {

return err

}

}

}

return nil

},

}

type crdbInternalLeasesTableEntry struct {

}

var crdbInternalLeasesTable = virtualSchemaTable{

schema: `

)`,

comment: `acquired table leases (RAM; local node only)`,

populate: func(

ctx context.Context, p *planner, _ catalog.DatabaseDescriptor, addRow func(...tree.Datum) error,

) error {

if err := p.CheckPrivilege(ctx, syntheticprivilege.GlobalPrivilegeObject, privilege.VIEWCLUSTERMETADATA); err != nil {

return err

}

nodeID, _ := p.execCfg.NodeInfo.NodeID.OptionalNodeID() // zero if not available

var leaseEntries []crdbInternalLeasesTableEntry

p.LeaseMgr().VisitLeases(func(desc catalog.Descriptor, takenOffline bool, _ int, expiration tree.DTimestamp) (wantMore bool) {

// Because we have locked the lease manager while visiting every lease,

// it not safe to *acquire* or *release* any leases in the process. As

// a result, build an in memory cache of entries and process them after

// all the locks have been released. Previously we would check privileges,

// which would need to get the lease on the role_member table. Simply skipping

// this check on that table will not be sufficient since any active lease

// on it could expire or need an renewal and cause the sample problem.

leaseEntries = append(leaseEntries, crdbInternalLeasesTableEntry{

desc: desc,

takenOffline: takenOffline,

expiration: expiration,

})

return true

})

for _, entry := range leaseEntries {

if ok, err := p.HasAnyPrivilege(ctx, entry.desc); err != nil {

return err

} else if !ok {

continue

}

if err := addRow(

tree.NewDInt(tree.DInt(nodeID)),

tree.NewDInt(tree.DInt(int64(entry.desc.GetID()))),

tree.NewDString(entry.desc.GetName()),

tree.NewDInt(tree.DInt(int64(entry.desc.GetParentID()))),

&entry.expiration,

tree.MakeDBool(tree.DBool(entry.takenOffline)),

); err != nil {

return err

}

}

return nil

},

}

var crdbInternalSystemJobsTable = virtualSchemaView{

schema: `

`,

comment: `wrapper over system.jobs with row access control (KV scan)`,

resultColumns: colinfo.ResultColumns{

{Name: "id", Typ: types.Int},

{Name: "status", Typ: types.String},

{Name: "created", Typ: types.TimestampTZ},