Merge #146114 #146280 #146287

146114: opt: remove unnecessary RLS allocation and refactor r=mgartner a=mgartner

#### opt: remove unnecessary RLS allocation

```
name                                                  old time/op    new time/op    delta
Phases/json-insert/Prepared/AssignPlaceholdersNoNorm    3.89µs ± 1%    3.72µs ± 1%  -4.45%

name                                                  old alloc/op   new alloc/op   delta
Phases/json-insert/Prepared/AssignPlaceholdersNoNorm    3.05kB ± 0%    3.00kB ± 0%  -1.57%

name                                                  old allocs/op  new allocs/op  delta
Phases/json-insert/Prepared/AssignPlaceholdersNoNorm      22.0 ± 0%      21.0 ± 0%  -4.55%
```

Release note: None

#### opt: add RowLevelSecurityMeta.Copy

Release note: None


146280: structlogging: hot ranges log modify interval loop check to be 1m r=angles-n-daemons a=angles-n-daemons

structlogging: hot ranges log modify interval loop check to be 1m

It seems like the interval loop checker for hot ranges was set to 1s for testing, and accidentally committed. This change reverts the original change.

Fixes: #138767
Epic: CRDB-43150

Release note: None

146287: sql: maintain index dependencies during truncate r=spilchen a=spilchen

When a table is truncated, new IDs are assigned to all its indexes. However, we previously failed to update any existing back-references to these index IDs in the table descriptor. This prevented the truncate from succeeding.

This change ensures that all references to old index IDs are properly remapped to the new ones, which allows the truncate to succeed.

Fixes #146065

Epic: none
Release note (bug fix): Fixed a bug that prevented TRUNCATE from succeeding if any indexes on the table had back-reference dependencies, such as from a view or function referencing the index.

Co-authored-by: Marcus Gartner <[email protected]>
Co-authored-by: Brian Dillmann <[email protected]>
Co-authored-by: Matt Spilchen <[email protected]>

Author: 4 people

pkg/server/structlogging/hot_ranges_log.go

@@ -29,7 +29,7 @@ var ReportTopHottestRanges int32 = 5
 
 // CheckInterval is the interval at which the system checks
 // whether or not to log the hot ranges.
-var CheckInterval = time.Second
+var CheckInterval = time.Minute
 
 // TestLoopChannel triggers the hot ranges logging loop to start again.
 // It's useful in the context of a test, where we don't want to wait

pkg/sql/logictest/testdata/logic_test/truncate

@@ -88,6 +88,64 @@ TRUNCATE bar
 statement ok
 DROP TABLE bar;
 
+subtest index_dependencies
+
+statement ok
+CREATE TABLE t0(c0 INT UNIQUE CHECK(true));
+
+statement ok
+INSERT INTO t0 VALUES (0),(1),(2);
+
+# Create two dependencies on the index. One from a view and one from a
+# function.
+statement ok
+CREATE VIEW v0 AS SELECT c0 FROM t0 @{FORCE_INDEX = t0_c0_key};
+
+statement ok
+create function get_min_t0() RETURNS INT LANGUAGE SQL AS $$ SELECT c0 FROM t0@t0_c0_key ORDER BY c0 LIMIT 1; $$;
+
+query I
+SELECT * FROM v0 ORDER BY c0;
+----
+0
+1
+2
+
+query I
+SELECT get_min_t0();
+----
+0
+
+statement ok
+TRUNCATE TABLE t0;
+
+query I
+SELECT * FROM v0 ORDER BY c0;
+----
+
+query I
+SELECT get_min_t0();
+----
+NULL
+
+# Ensure the index dependency was copied over.
+statement error pq: index "t0_c0_key" is in use as unique constraint.*
+DROP INDEX t0@t0_c0_key;
+
+statement ok
+DROP INDEX t0@t0_c0_key CASCADE;
+
+# Ensure the cascade got rid of the view
+statement error pq: relation "v0" does not exist
+SELECT * FROM v0;
+
+# Ensure the cascade got rid of the function
+statement error pq: unknown function: get_min_t0()
+SELECT get_min_t0();
+
+statement ok
+DROP TABLE t0;
+
 subtest truncate_30547
 
 statement ok

pkg/sql/opt/metadata.go

@@ -334,11 +334,7 @@ func (md *Metadata) CopyFrom(from *Metadata, copyScalarFn func(Expr) Expr) {
 	// We cannot copy the bound expressions; they must be rebuilt in the new memo.
 	md.withBindings = nil
 
-	md.rlsMeta = from.rlsMeta
-	md.rlsMeta.PoliciesApplied = make(map[TableID]PoliciesApplied)
-	for id, policies := range from.rlsMeta.PoliciesApplied {
-		md.rlsMeta.PoliciesApplied[id] = policies.Copy()
-	}
+	md.rlsMeta = from.rlsMeta.Copy()
 }
 
 // MDDepName stores either the unresolved DataSourceName or the StableID from

pkg/sql/opt/row_level_security.go

@@ -104,6 +104,23 @@ func (r *RowLevelSecurityMeta) RefreshNoPoliciesAppliedForTable(tableID TableID)
 	}
 }
 
+// Copy returns a deep copy of the RowLevelSecurityMeta.
+func (r *RowLevelSecurityMeta) Copy() RowLevelSecurityMeta {
+	cpy := RowLevelSecurityMeta{
+		IsInitialized:     r.IsInitialized,
+		User:              r.User,
+		HasAdminRole:      r.HasAdminRole,
+		NoPoliciesApplied: r.NoPoliciesApplied,
+	}
+	for id, policies := range r.PoliciesApplied {
+		if cpy.PoliciesApplied == nil {
+			cpy.PoliciesApplied = make(map[TableID]PoliciesApplied)
+		}
+		cpy.PoliciesApplied[id] = policies.Copy()
+	}
+	return cpy
+}
+
 // PoliciesApplied stores the set of policies that were applied to a table.
 type PoliciesApplied struct {
 	// NoForceExempt is true if the policies were exempt because they were the

pkg/sql/truncate.go

@@ -209,18 +209,12 @@ func (p *planner) truncateTable(ctx context.Context, id descpb.ID, jobDesc strin
 		}
 	}
 
-	// Create new ID's for all of the indexes in the table.
-	{
-		version := p.ExecCfg().Settings.Version.ActiveVersion(ctx)
-		// Temporarily empty the mutation jobs slice otherwise the descriptor
-		// validation performed by AllocateIDs will fail: the Mutations slice
-		// has been emptied but MutationJobs only gets emptied later on.
-		mutationJobs := tableDesc.MutationJobs
-		tableDesc.MutationJobs = nil
-		if err := tableDesc.AllocateIDs(ctx, version); err != nil {
-			return err
-		}
-		tableDesc.MutationJobs = mutationJobs
+	// Allocate new IDs for all indexes in the table descriptor. We use the
+	// AllocateIDsWithoutValidation variant because some DependedOnBy references
+	// may still point to the old index IDs, which we haven't remapped yet.
+	// Full validation will occur later when writeSchemaChange is called.
+	if err := tableDesc.AllocateIDsWithoutValidation(ctx, true /*createMissingPrimaryKey*/); err != nil {
+		return err
 	}
 
 	// Construct a mapping from old index ID's to new index ID's.
@@ -229,6 +223,18 @@ func (p *planner) truncateTable(ctx context.Context, id descpb.ID, jobDesc strin
 		indexIDMapping[oldIndexes[idx.Ordinal()].ID] = idx.GetID()
 	}
 
+	// Remap index IDs in the DependedOnBy references using the new index ID mapping.
+	for i := range tableDesc.DependedOnBy {
+		ref := &tableDesc.DependedOnBy[i]
+		if ref.IndexID != 0 {
+			var ok bool
+			ref.IndexID, ok = indexIDMapping[ref.IndexID]
+			if !ok {
+				return errors.AssertionFailedf("could not find index ID %d in mapping", ref.IndexID)
+			}
+		}
+	}
+
 	// Create schema change GC jobs for all of the indexes.
 	dropTime := timeutil.Now().UnixNano()
 	droppedIndexes := make([]jobspb.SchemaChangeGCDetails_DroppedIndex, 0, len(oldIndexes))