sql: use the correct locking strength for FOR SHARE clause

Previously, FOR SHARE and FOR KEY SHARE would use non-locking KV scans.
Now that the lock table supports shared locks, we can use lock.Shared as
the locking strength for KV scans. This patch does that, and in doing
so, wires up SHARED locks end to end.

By default, we turn off this functionality for serializable transactions.
Instead, it's gated behind a session setting called
`enable_shared_locking_for_serializable`.

Informs cockroachdb#91545

Release note (sql change): SELECT FOR SHARE and SELECT FOR KEY SHARE
previously did not acquire any locks. Users issuing these statements
would expect them to acquire shared locks (multiple readers allowed,
no writers though). This patch switches over the behavior to acquire
such read locks.

For serializable transactions, we default to the old behaviour, unless
the `enable_shared_locking_for_serializable` session setting is set
to true. We'll probably switch this behavior in the future, but for
now, given shared locks are a preview feature, we gate things behind
a session setting.

pkg/sql/exec_util.go

@@ -3641,6 +3641,10 @@ func (m *sessionDataMutator) SetDurableLockingForSerializable(val bool) {
 	m.data.DurableLockingForSerializable = val
 }
 
+func (m *sessionDataMutator) SetSharedLockingForSerializable(val bool) {
+	m.data.SharedLockingForSerializable = val
+}
+
 // Utility functions related to scrubbing sensitive information on SQL Stats.
 
 // quantizeCounts ensures that the Count field in the

pkg/sql/logictest/testdata/logic_test/information_schema

@@ -5346,6 +5346,7 @@ enable_insert_fast_path                                    on
 enable_multiple_modifications_of_table                     off
 enable_multiregion_placement_policy                        off
 enable_seqscan                                             on
+enable_shared_locking_for_serializable                     off
 enable_super_regions                                       off
 enable_zigzag_join                                         off
 enforce_home_region                                        off

pkg/sql/logictest/testdata/logic_test/pg_catalog

@@ -2788,6 +2788,7 @@ enable_insert_fast_path                                    on                  N
 enable_multiple_modifications_of_table                     off                 NULL      NULL        NULL        string
 enable_multiregion_placement_policy                        off                 NULL      NULL        NULL        string
 enable_seqscan                                             on                  NULL      NULL        NULL        string
+enable_shared_locking_for_serializable                     off                 NULL      NULL        NULL        string
 enable_super_regions                                       off                 NULL      NULL        NULL        string
 enable_zigzag_join                                         off                 NULL      NULL        NULL        string
 enforce_home_region                                        off                 NULL      NULL        NULL        string
@@ -2949,6 +2950,7 @@ enable_insert_fast_path                                    on                  N
 enable_multiple_modifications_of_table                     off                 NULL  user     NULL      off                 off
 enable_multiregion_placement_policy                        off                 NULL  user     NULL      off                 off
 enable_seqscan                                             on                  NULL  user     NULL      on                  on
+enable_shared_locking_for_serializable                     off                 NULL  user     NULL      off                 off
 enable_super_regions                                       off                 NULL  user     NULL      off                 off
 enable_zigzag_join                                         off                 NULL  user     NULL      off                 off
 enforce_home_region                                        off                 NULL  user     NULL      off                 off
@@ -3107,6 +3109,7 @@ enable_insert_fast_path                                    NULL    NULL     NULL
 enable_multiple_modifications_of_table                     NULL    NULL     NULL     NULL        NULL
 enable_multiregion_placement_policy                        NULL    NULL     NULL     NULL        NULL
 enable_seqscan                                             NULL    NULL     NULL     NULL        NULL
+enable_shared_locking_for_serializable                     NULL    NULL     NULL     NULL        NULL
 enable_super_regions                                       NULL    NULL     NULL     NULL        NULL
 enable_zigzag_join                                         NULL    NULL     NULL     NULL        NULL
 enforce_home_region                                        NULL    NULL     NULL     NULL        NULL

pkg/sql/logictest/testdata/logic_test/select_for_share

@@ -0,0 +1,119 @@
+# LogicTest: !local-mixed-22.2-23.1
+
+statement ok
+CREATE TABLE t(a INT PRIMARY KEY);
+INSERT INTO t VALUES(1);
+GRANT ALL ON t TO testuser;
+CREATE USER testuser2 WITH VIEWACTIVITY;
+GRANT SYSTEM MODIFYCLUSTERSETTING TO testuser;
+GRANT ALL ON t TO testuser2;
+
+user testuser
+
+statement ok
+SET enable_shared_locking_for_serializable = true;
+
+statement ok
+BEGIN
+
+query I
+SELECT * FROM t WHERE a = 1 FOR SHARE;
+----
+1
+
+# Start another transaction to show multiple transactions can acquire SHARED
+# locks at the same time.
+
+user root
+
+statement ok
+SET enable_shared_locking_for_serializable = true;
+
+statement ok
+BEGIN
+
+query I
+SELECT * FROM t  WHERE a = 1 FOR SHARE;
+----
+1
+
+user testuser2
+
+statement async writeReq count 1
+UPDATE t SET a = 2 WHERE a = 1
+
+# TODO(arul): Until https://github.com/cockroachdb/cockroach/issues/107766 is
+# addressed, we'll incorrectly report shared locks as having "Exclusive" lock
+# strength; We'll also only report a single holder (the other row in there is
+# the waiting UPDATE request, not the second shared lock holder). However,
+# having this query in here is useful to make sure there are locks and waiters
+# on our key, meaning setting the cluster setting above actually did something;
+# otherwise, had we used non-locking reads, we'd have failed here.
+query TTTTTTTBB colnames,retry,rowsort
+SELECT database_name, schema_name, table_name, lock_key_pretty, lock_strength, durability, isolation_level, granted, contended FROM crdb_internal.cluster_locks
+----
+database_name  schema_name  table_name  lock_key_pretty   lock_strength  durability    isolation_level  granted  contended
+test           public       t           /Table/106/1/1/0  Exclusive      Unreplicated  SERIALIZABLE     true     true
+test           public       t           /Table/106/1/1/0  Exclusive      Unreplicated  SERIALIZABLE     false    true
+
+# Commit the first transaction and rollback the second.
+
+user testuser
+
+statement ok
+COMMIT
+
+user root
+
+statement ok
+ROLLBACK
+
+user testuser2
+
+# Now that both the transactions that issued shared lock reads have been
+# finalized, the write should be able to proceed.
+
+awaitstatement writeReq
+
+query I
+SELECT * FROM t;
+----
+2
+
+# ------------------------------------------------------------------------------
+# Tests to ensure the enable_shared_locking_for_serializable session variable
+# works as expected.
+# -----------------------------------------------------------------------------
+
+user testuser
+
+statement ok
+SET enable_shared_locking_for_serializable = false
+
+statement ok
+BEGIN ISOLATION LEVEL SERIALIZABLE
+
+query I
+SELECT * FROM t WHERE a = 2 FOR SHARE
+----
+2
+
+user testuser2
+
+query TTTTTTTBB colnames,retry,rowsort
+SELECT database_name, schema_name, table_name, lock_key_pretty, lock_strength, durability, isolation_level, granted, contended FROM crdb_internal.cluster_locks
+----
+database_name  schema_name  table_name  lock_key_pretty   lock_strength  durability    isolation_level  granted  contended
+
+user testuser
+
+statement ok
+COMMIT
+
+# TODO(arul): Add a test to show that the session setting doesn't apply to read
+# committed transactions. We currently can't issue SELECT FOR SHARE statements
+# in read committed transactions because durable locking hasn't been fully
+# hooked up.
+
+
+

pkg/sql/logictest/testdata/logic_test/select_for_update

@@ -293,6 +293,7 @@ ROLLBACK
 statement ok
 BEGIN READ ONLY
 
+skipif config local-mixed-22.2-23.1
 statement error cannot execute FOR SHARE in a read-only transaction
 SELECT * FROM t FOR SHARE
 
@@ -302,6 +303,7 @@ ROLLBACK
 statement ok
 BEGIN READ ONLY
 
+skipif config local-mixed-22.2-23.1
 statement error cannot execute FOR KEY SHARE in a read-only transaction
 SELECT * FROM t FOR KEY SHARE
 
@@ -357,24 +359,33 @@ BEGIN; UPDATE t SET v = 2 WHERE k = 1
 
 user testuser
 
+statement ok
+SET enable_shared_locking_for_serializable = true
+
+skipif config local-mixed-22.2-23.1
 query error pgcode 55P03 could not obtain lock on row \(k\)=\(1\) in t@t_pkey
 SELECT v, v2 FROM t JOIN t2 USING (k) FOR SHARE FOR SHARE OF t NOWAIT
 
+skipif config local-mixed-22.2-23.1
 query error pgcode 55P03 could not obtain lock on row \(k\)=\(1\) in t@t_pkey
 SELECT v, v2 FROM t JOIN t2 USING (k) FOR SHARE OF t2 FOR SHARE OF t NOWAIT
 
+skipif config local-mixed-22.2-23.1
 query error pgcode 55P03 could not obtain lock on row \(k\)=\(1\) in t@t_pkey
 SELECT v, v2 FROM t JOIN t2 USING (k) FOR SHARE NOWAIT FOR SHARE OF t
 
+skipif config local-mixed-22.2-23.1
 query error pgcode 55P03 could not obtain lock on row \(k\)=\(1\) in t@t_pkey
 SELECT v, v2 FROM t JOIN t2 USING (k) FOR SHARE NOWAIT FOR SHARE OF t2
 
 statement ok
 SET statement_timeout = '10ms'
 
+skipif config local-mixed-22.2-23.1
 query error pgcode 57014 query execution canceled due to statement timeout
 SELECT v, v2 FROM t JOIN t2 USING (k) FOR SHARE FOR SHARE OF t2 NOWAIT
 
+skipif config local-mixed-22.2-23.1
 query error pgcode 57014 query execution canceled due to statement timeout
 SELECT v, v2 FROM t JOIN t2 USING (k) FOR SHARE OF t FOR SHARE OF t2 NOWAIT
 

pkg/sql/logictest/testdata/logic_test/show_source

@@ -70,6 +70,7 @@ enable_insert_fast_path                                    on
 enable_multiple_modifications_of_table                     off
 enable_multiregion_placement_policy                        off
 enable_seqscan                                             on
+enable_shared_locking_for_serializable                     off
 enable_super_regions                                       off
 enable_zigzag_join                                         off
 enforce_home_region                                        off

pkg/sql/opt/exec/execbuilder/BUILD.bazel

@@ -14,6 +14,8 @@ go_library(
     importpath = "github.com/cockroachdb/cockroach/pkg/sql/opt/exec/execbuilder",
     visibility = ["//visibility:public"],
     deps = [
+        "//pkg/clusterversion",
+        "//pkg/kv/kvserver/concurrency/isolation",
         "//pkg/server/telemetry",
         "//pkg/sql/catalog/colinfo",
         "//pkg/sql/catalog/descpb",

pkg/sql/opt/exec/execbuilder/relational.go

@@ -17,6 +17,8 @@ import (
 	"math"
 	"strings"
 
+	"github.com/cockroachdb/cockroach/pkg/clusterversion"
+	"github.com/cockroachdb/cockroach/pkg/kv/kvserver/concurrency/isolation"
 	"github.com/cockroachdb/cockroach/pkg/server/telemetry"
 	"github.com/cockroachdb/cockroach/pkg/sql/catalog/colinfo"
 	"github.com/cockroachdb/cockroach/pkg/sql/catalog/descpb"
@@ -623,6 +625,7 @@ func (b *Builder) scanParams(
 	}
 
 	locking, err := b.buildLocking(scan.Locking)
+
 	if err != nil {
 		return exec.ScanParams{}, opt.ColMap{}, err
 	}
@@ -2921,6 +2924,21 @@ func (b *Builder) buildLocking(locking opt.Locking) (opt.Locking, error) {
 				100193, "guaranteed-durable locking not yet implemented",
 			)
 		}
+		// Check if we can actually use shared locks here, or we need to use
+		// non-locking reads instead.
+		if locking.Strength == tree.ForShare || locking.Strength == tree.ForKeyShare {
+			// Shared locks weren't a thing prior to v23.2, so we must use non-locking
+			// reads.
+			if !b.evalCtx.Settings.Version.IsActive(b.ctx, clusterversion.V23_2) ||
+				// And in >= v23.2, their locking behavior for serializable transactions
+				// is dictated by session setting.
+				(b.evalCtx.TxnIsoLevel == isolation.Serializable &&
+					!b.evalCtx.SessionData().SharedLockingForSerializable) {
+				// Reset locking information as we've determined we're going to be
+				// performing a non-locking read.
+				return opt.Locking{}, nil // early return; do not set b.ContainsNonDefaultKeyLocking
+			}
+		}
 		b.ContainsNonDefaultKeyLocking = true
 	}
 	return locking, nil

pkg/sql/opt/exec/execbuilder/testdata/fk

@@ -46,6 +46,11 @@ vectorized: true
 statement ok
 SET enable_implicit_fk_locking_for_serializable = true
 
+# We need to enable shared locks for serializable transactions for this to have
+# a meaningful effect.
+statement ok
+SET enable_shared_locking_for_serializable=true
+
 query T
 EXPLAIN INSERT INTO child VALUES (1,1), (2,2)
 ----

pkg/sql/opt/exec/execbuilder/testdata/fk_read_committed

@@ -49,6 +49,11 @@ insert cookies
 statement ok
 SET enable_implicit_fk_locking_for_serializable = true
 
+# We als need to enable shared locks for serializable transactions for this to
+# have a meaningful effect.
+statement ok
+SET enable_shared_locking_for_serializable=true
+
 query T
 EXPLAIN (OPT) INSERT INTO cookies VALUES (1, 1)
 ----