894 lines
24 KiB
Plaintext
894 lines
24 KiB
Plaintext
# Skipping the test temporarily when log-bin is enabled as the test contains a
|
|
# statement accessing mysql.general_log in an trxn. The trxn status tracker
|
|
# (@@session_track_transaction_info) marks it unsafe only when logbin is on
|
|
--source include/not_log_bin.inc
|
|
|
|
--echo #
|
|
--echo # WL#6631: Detect transaction boundaries
|
|
--echo #
|
|
|
|
###############################################################################
|
|
# The main functionality implemented by WL#6631 is enhanced reporting
|
|
# on transaction state. Historically, the server has already reported
|
|
# with a flag whether we're inside a transaction, but on one hand,
|
|
# BEGIN..COMMIT AND CHAIN..COMMIT AND CHAIN..COMMIT AND RELEASE would
|
|
# look like a single very long transaction to users of that flag; on
|
|
# the other, we could still re-locate the session elsewhere (e.g. load-
|
|
# balance it) as long as no actual reads or writes have been done.
|
|
# A client subscribing to WL#6631 reporting will see this more granular
|
|
# state (implicit transaction, explicit transaction, work attached, etc.).
|
|
# it may additionally subscribe to reporting on the characteristics of
|
|
# the transaction (READ ONLY/READ WRITE; WITH CONSISTENT SNAPSHOT;
|
|
# ISOLATION LEVEL) so it may restart the transaction elsewhere with the
|
|
# same characteristics as the original transaction.
|
|
#
|
|
# We can switch a connection:
|
|
#
|
|
# a) if no transaction is active
|
|
#
|
|
# b) if a transaction is active, but has no "work" attached to it yet,
|
|
# in which case we'll want to know its characteristics to move it:
|
|
#
|
|
# - was START TRANSACTION "WITH CONSISTENT SNAPSHOT" used?
|
|
#
|
|
# - was START TRANSACTION used with "READ ONLY" or "READ WRITE"?
|
|
# (if neither was given in the statement, we won't flag either,
|
|
# so the default will be used -- it's up to the client to
|
|
# replicate that setting from SET TRANSACTION (i.e. GLOBAL and
|
|
# SESSION transaction_isolation / transaction_read_only) as needed!
|
|
#
|
|
# - was "SET TRANSACTION ISOLATION LEVEL" one-shot set for this
|
|
# transaction?
|
|
#
|
|
# - was "SET TRANSACTION READ [WRITE|ONLY]" one-shot used?
|
|
#
|
|
#
|
|
# A transaction may be "explicit" (started with BEGIN WORK /
|
|
# START TRANSACTION) or "implicit" (autocommit==0 && not in an
|
|
# explicit transaction). A transaction of either type will end
|
|
# when a statement causes an implicit or explicit commit.
|
|
# In both cases, we'll see the union of any reads or writes
|
|
# (transactional and non-transactional) that happened up to
|
|
# that point in the transaction.
|
|
#
|
|
# In this test, we will document various state transitions between
|
|
# no transaction, implicit transaction, and explict transaction active.
|
|
# We will also show that "work attached" (read/write, transactional/
|
|
# non-transactional) as flagged as expected when a transaction is active.
|
|
# Next, we will show that CHARACTERISTICS tracking supplies the correct
|
|
# SQL statement or sequence of SQL statements to start a new transaction
|
|
# with characteristics identital to that of the on-going transaction.
|
|
# Finally, we'll explore some interesting situations -- reads within
|
|
# a stored function, within LOCK, etc.
|
|
|
|
|
|
|
|
--echo ########################################################################
|
|
--echo #
|
|
--echo # set up: save settings
|
|
--echo #
|
|
|
|
SET autocommit=1;
|
|
--echo # if we track CHARACTERISTICS, we must also track the tx_* sysvars!
|
|
SELECT @@session.session_track_system_variables INTO @old_track_list;
|
|
SET @track_list= CONCAT(@old_track_list, ",transaction_isolation,
|
|
transaction_read_only");
|
|
SET SESSION session_track_system_variables=@track_list;
|
|
|
|
SELECT @@session.session_track_state_change INTO @old_track_enable;
|
|
SET SESSION session_track_state_change=TRUE;
|
|
|
|
SELECT @@session.session_track_transaction_info INTO @old_track_tx;
|
|
|
|
FLUSH STATUS;
|
|
|
|
|
|
|
|
--echo ########################################################################
|
|
--echo #
|
|
--echo # test "STATE" tracking: transaction type transitions
|
|
--echo #
|
|
|
|
SET SESSION session_track_transaction_info="STATE";
|
|
|
|
--enable_session_track_info
|
|
|
|
--echo # 3.1.1.1.1 "explicit transaction active"
|
|
# transition: no trx -> explicit trx
|
|
START TRANSACTION;
|
|
--echo # 3.1.1.1.1 ending explicit transaction explicitly
|
|
# transition: explicit trx -> no trx
|
|
COMMIT;
|
|
--echo # 3.1.1.1.1 ending explicit transaction implicitly
|
|
CREATE TABLE t1 (f1 INT) ENGINE="InnoDB";
|
|
START TRANSACTION;
|
|
# DDL forcing an implicit commit (thereby ending the explicit transaction):
|
|
# transition: explicit trx -> no trx
|
|
DROP TABLE t1;
|
|
|
|
|
|
--echo # 3.1.1.2 "no work attached"
|
|
# no work attached after transaction started (unless WITH CONSISTENT SNAPSHOT)
|
|
START TRANSACTION;
|
|
# still no work attached as we do not access tables, and still in transaction:
|
|
SET @dummy=0;
|
|
ROLLBACK;
|
|
|
|
|
|
--echo # 3.1.1.1.2 "implicit transaction active"
|
|
--echo #
|
|
# autocommit=0 enables implicit transactions
|
|
# transition: no trx -> implicit trx
|
|
SET autocommit=0;
|
|
# DDL forcing an implicit commit
|
|
# transition: implicit trx -> no trx
|
|
CREATE TABLE t1 (f1 INT) ENGINE="InnoDB";
|
|
# attach a (transactional, since t1 is an InnoDB table) write:
|
|
# transition: no trx -> implicit trx (with work)
|
|
INSERT INTO t1 VALUES (1);
|
|
# attach a transaction read; show that we get the union of the accesses so far:
|
|
SELECT f1 FROM t1 LIMIT 1 INTO @dummy;
|
|
# add a result-set:
|
|
SELECT f1 FROM t1;
|
|
# force commit by starting an explict transaction:
|
|
# transition: implicit trx -> explicit trx
|
|
BEGIN WORK;
|
|
# end transaction by forcing an implicit commit:
|
|
# transition: explicit trx -> no trx
|
|
DROP TABLE t1;
|
|
# start an implicit transaction
|
|
SELECT RAND(22) INTO @dummy;
|
|
# implicit transaction, explicit commit:
|
|
# transition: implicit trx -> no trx
|
|
COMMIT;
|
|
#
|
|
# SET TRANSACTION is OK during implicit transaction UNTIL tables are accessed
|
|
CREATE TABLE t1 (f1 INT) ENGINE="InnoDB";
|
|
SET TRANSACTION READ ONLY;
|
|
SET TRANSACTION READ WRITE;
|
|
SELECT RAND(22) INTO @dummy;
|
|
SET TRANSACTION READ WRITE;
|
|
INSERT INTO t1 VALUES (1);
|
|
--error ER_CANT_CHANGE_TX_CHARACTERISTICS
|
|
SET TRANSACTION READ WRITE;
|
|
DROP TABLE t1;
|
|
|
|
# change back to autocommit mode.
|
|
# Axiom: This should reset state as the implicit transaction, if any, ends.
|
|
# transition: implicit trx -> no trx
|
|
SET autocommit=1;
|
|
|
|
|
|
|
|
--echo ########################################################################
|
|
--echo #
|
|
--echo # test "STATE" tracking: transaction state reporting
|
|
--echo #
|
|
|
|
CREATE TABLE t1 (f1 INT) ENGINE="InnoDB";
|
|
CREATE TABLE t2 (f1 INT) ENGINE="MyISAM";
|
|
|
|
--echo # We don't report when in autocommit mode and outside a transaction:
|
|
INSERT INTO t1 VALUES(1);
|
|
SELECT 1 FROM DUAL;
|
|
DELETE FROM t1;
|
|
|
|
|
|
|
|
# Now start a transaction so we can actually report things!
|
|
START TRANSACTION;
|
|
--echo # add "unsafe stmt" to the set:
|
|
SET @x=UUID();
|
|
--echo # next stmt is safe, but unsafe flag should stick:
|
|
SET @x=1;
|
|
--echo # however, after C/A/C, the status should revert to "empty trx":
|
|
COMMIT AND CHAIN;
|
|
--echo # SELECT with no tables gives us just a result set
|
|
SELECT 1 FROM DUAL;
|
|
COMMIT AND CHAIN;
|
|
--echo # SELECT with no tables and no result set
|
|
--replace_result $MYSQLTEST_VARDIR VARDIR
|
|
eval SELECT 1 FROM DUAL INTO OUTFILE '$MYSQLTEST_VARDIR/tmp/wl6631.csv';
|
|
--remove_file $MYSQLTEST_VARDIR/tmp/wl6631.csv
|
|
COMMIT AND CHAIN;
|
|
--echo # SELECT with trx tables but no result set
|
|
--replace_result $MYSQLTEST_VARDIR VARDIR
|
|
--eval SELECT f1 FROM t1 INTO OUTFILE '$MYSQLTEST_VARDIR/tmp/wl6631.csv';
|
|
--remove_file $MYSQLTEST_VARDIR/tmp/wl6631.csv
|
|
COMMIT AND CHAIN;
|
|
--echo # SELECT with non-trx tables but no result set
|
|
--replace_result $MYSQLTEST_VARDIR VARDIR
|
|
--eval SELECT f1 FROM t2 INTO OUTFILE '$MYSQLTEST_VARDIR/tmp/wl6631.csv';
|
|
--remove_file $MYSQLTEST_VARDIR/tmp/wl6631.csv
|
|
--echo # show that "unsafe read" sticks (isn't cleared by the dummy SELECT)
|
|
SELECT 1 FROM DUAL INTO @x;
|
|
--echo # clear state
|
|
COMMIT;
|
|
|
|
DROP TABLE t1;
|
|
DROP TABLE t2;
|
|
--echo
|
|
|
|
|
|
|
|
--echo # read with and without result set:
|
|
CREATE TABLE t1 (f1 INT) ENGINE="InnoDB";
|
|
CREATE TABLE t2 (f1 INT) ENGINE="InnoDB";
|
|
INSERT INTO t1 VALUES (123);
|
|
|
|
BEGIN;
|
|
# read + result set
|
|
SELECT f1 FROM t1;
|
|
COMMIT AND CHAIN;
|
|
# read + write
|
|
INSERT INTO t2 SELECT f1 FROM t1;
|
|
COMMIT;
|
|
|
|
DROP TABLE t1;
|
|
DROP TABLE t2;
|
|
--echo
|
|
|
|
|
|
|
|
--echo # states: read + write; transactional + non-transactional
|
|
--echo # state should be "no transaction":
|
|
CREATE TABLE t1 (f1 INT) ENGINE="InnoDB";
|
|
CREATE TABLE t2 (f1 INT) ENGINE="MyISAM";
|
|
--echo # resulting state should be "T", transaction started, no data modified:
|
|
START TRANSACTION;
|
|
--echo # resulting state should be "W", transactional write pending:
|
|
INSERT INTO t1 VALUES (1);
|
|
--echo # resulting state should be "wW", both safe and unsafe writes happened:
|
|
INSERT INTO t2 VALUES (1);
|
|
--echo # resulting state should STILL be "wW"!
|
|
INSERT INTO t1 VALUES (1);
|
|
ROLLBACK;
|
|
|
|
START TRANSACTION;
|
|
--echo # resulting state should be "w", unsafe non-transaction write happened:
|
|
INSERT INTO t2 VALUES (1);
|
|
--echo # resulting state should be "wW", both safe and unsafe writes happened:
|
|
INSERT INTO t1 VALUES (1);
|
|
--echo # resulting state should be "RwW" (adding transactional read):
|
|
SELECT f1 FROM t1;
|
|
--echo # resulting state should be "rRwW" (adding non-transactional read):
|
|
SELECT f1 FROM t2;
|
|
# ROLLBACK will throw "couldn't roll back some tables" here.
|
|
# Prevent an implicit, hidden "SHOW WARNINGS" here that would
|
|
# lead to an extra result set, and thereby to a hidden state edge
|
|
# (and a seemingly nonsensical logged change from TX_EMPTY to TX_EMPTY).
|
|
--disable_warnings
|
|
ROLLBACK;
|
|
--enable_warnings
|
|
DROP TABLE t1, t2;
|
|
--echo
|
|
|
|
|
|
|
|
--echo # autocommit (0)
|
|
CREATE TABLE t1 (f1 INT) ENGINE="InnoDB";
|
|
SET autocommit=0;
|
|
# unsafe stmt
|
|
SET @x=UUID();
|
|
SET @x=1;
|
|
SET @x=UUID();
|
|
--echo # SET TRANSACTION one-shot should generate a tracker item when
|
|
--echo # tracking statements. Transaction state however should not change.
|
|
--echo # We can still set chistics here because in_active_multi_stmt_transaction()
|
|
--echo # is still false (!SERVER_STATUS_IN_TRANS).
|
|
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
|
|
INSERT INTO t1 VALUES(1);
|
|
--echo # Now that we've involved tables in the implicit transaction, we're
|
|
--echo # no longer allowed to change its chistics:
|
|
--error ER_CANT_CHANGE_TX_CHARACTERISTICS
|
|
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
|
|
# implicit commit (because of DROP TABLE)
|
|
BEGIN;
|
|
INSERT INTO t1 VALUES(3);
|
|
DROP TABLE t1;
|
|
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
|
|
BEGIN;
|
|
SELECT 1 FROM DUAL;
|
|
SELECT 1 FROM DUAL INTO @dummy;
|
|
COMMIT;
|
|
|
|
CREATE TABLE t2 (f1 INT) ENGINE="MyISAM";
|
|
SELECT f1 FROM t2;
|
|
DROP TABLE t2;
|
|
SET autocommit=1;
|
|
--echo
|
|
|
|
|
|
|
|
--echo ########################################################################
|
|
--echo #
|
|
--echo # test "CHARACTERISTICS" tracking
|
|
--echo #
|
|
|
|
SET SESSION session_track_transaction_info="CHARACTERISTICS";
|
|
# side-effect: state will change to "explicit transaction active"
|
|
START TRANSACTION;
|
|
# side-effect: state -> "explicit transaction active" + "transactional read"
|
|
START TRANSACTION WITH CONSISTENT SNAPSHOT;
|
|
# side-effect: state -> "explicit transaction active"
|
|
START TRANSACTION READ WRITE;
|
|
--echo # state is again "we have an empty transaction", so make no state item
|
|
START TRANSACTION READ ONLY;
|
|
START TRANSACTION READ WRITE, WITH CONSISTENT SNAPSHOT;
|
|
START TRANSACTION READ ONLY, WITH CONSISTENT SNAPSHOT;
|
|
--echo # chain read chistics, but not snapshot:
|
|
COMMIT AND CHAIN;
|
|
|
|
# We can't set characteristics one-shots with an explicit transaction ongoing:
|
|
--error ER_CANT_CHANGE_TX_CHARACTERISTICS
|
|
SET TRANSACTION READ ONLY;
|
|
|
|
--echo # will create an empty characteristics item by convention, plus 0 state
|
|
ROLLBACK;
|
|
--echo
|
|
|
|
|
|
# Let's try the characteristics one-shots again, outside a transaction:
|
|
--echo # chistics: READ ONLY
|
|
SET TRANSACTION READ ONLY;
|
|
--echo # chistics: READ ONLY + ISOL RR
|
|
SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;
|
|
--echo # chistics: READ ONLY + ISOL RR
|
|
SET TRANSACTION READ ONLY;
|
|
--echo # chistics: READ WRITE + ISOL RR
|
|
SET TRANSACTION READ WRITE;
|
|
--echo # chistics: READ WRITE + ISOL RR
|
|
SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;
|
|
--echo # chistics: READ ONLY + ISOL SER
|
|
SET TRANSACTION READ ONLY, ISOLATION LEVEL SERIALIZABLE;
|
|
--echo # chistics: READ ONLY + ISOL SER
|
|
BEGIN WORK;
|
|
COMMIT;
|
|
--echo
|
|
|
|
|
|
|
|
# Show how the characteristics one-shots interact with the session values:
|
|
|
|
SET SESSION transaction_read_only=0;
|
|
--echo # one-shot (different from session default)
|
|
SET TRANSACTION READ ONLY;
|
|
START TRANSACTION;
|
|
COMMIT;
|
|
--echo
|
|
|
|
--echo # one-shot (repeats session default)
|
|
SET TRANSACTION READ WRITE;
|
|
START TRANSACTION;
|
|
COMMIT;
|
|
--echo
|
|
|
|
--echo # session
|
|
SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
|
|
SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;
|
|
SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
|
|
--echo # "isolation" one-shot is set, and added to chistics tracker (=> 1 item)
|
|
SET TRANSACTION ISOLATION LEVEL READ COMMITTED;
|
|
--echo # "read-only" one-shot is set, and added to chistics tracker (=> 2 items)
|
|
SET TRANSACTION READ ONLY;
|
|
--echo # setting the session default:
|
|
--echo # - we receive "changed variable" for @@session.transaction_read_only
|
|
--echo # - "read-only" one-shot is cleared, disappears from chistics tracker
|
|
--echo # - "isolation" one-shot remains set, and remains in chistics tracker
|
|
SET SESSION TRANSACTION READ ONLY;
|
|
--echo # chistics: isolation level is READ COMMITTED (from one-shot), READ ONLY
|
|
--echo # or READ WRITE not given, as we're using session default again
|
|
START TRANSACTION;
|
|
COMMIT;
|
|
--echo
|
|
|
|
--echo # chistics: READ ONLY
|
|
SET TRANSACTION READ ONLY;
|
|
--echo # chistics: READ ONLY, READ COMM
|
|
SET TRANSACTION ISOLATION LEVEL READ COMMITTED;
|
|
--echo # chistics: SESSION resets ISOL one-shot, READ ONLY remains
|
|
SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
|
|
--echo # chistics: SESSION resets READ one-shot, nothing remains
|
|
SET SESSION TRANSACTION READ ONLY;
|
|
--echo
|
|
|
|
SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;
|
|
SET SESSION TRANSACTION READ WRITE;
|
|
|
|
--echo
|
|
|
|
|
|
|
|
--echo # show that START TRANSACTION READ ... overrides SET TRANSACTION READ ..
|
|
SET TRANSACTION READ ONLY;
|
|
START TRANSACTION READ WRITE;
|
|
ROLLBACK;
|
|
--echo
|
|
|
|
|
|
|
|
--echo # chistics AND CHAIN
|
|
# At this point, (COMMIT as well as ROLLBACK) AND CHAIN preserves chistics:
|
|
SET TRANSACTION READ ONLY;
|
|
START TRANSACTION;
|
|
COMMIT AND CHAIN;
|
|
ROLLBACK;
|
|
--echo
|
|
|
|
SET TRANSACTION ISOLATION LEVEL READ COMMITTED;
|
|
START TRANSACTION READ ONLY;
|
|
ROLLBACK AND CHAIN;
|
|
COMMIT;
|
|
--echo
|
|
|
|
|
|
--echo # show that session_track_transaction_info="STATE" will hide some edges
|
|
SET session_track_transaction_info="STATE";
|
|
--echo # normal syntax: TR->T->0
|
|
START TRANSACTION WITH CONSISTENT SNAPSHOT;
|
|
COMMIT AND CHAIN;
|
|
COMMIT;
|
|
--echo # normal syntax: T->T->0
|
|
START TRANSACTION;
|
|
--echo # state does not change, and therefore isn't reported
|
|
COMMIT AND CHAIN;
|
|
COMMIT;
|
|
--echo # pathological syntax: TR->TR->0
|
|
START TRANSACTION WITH CONSISTENT SNAPSHOT;
|
|
--echo # state does not change, and therefore isn't reported
|
|
START TRANSACTION WITH CONSISTENT SNAPSHOT;
|
|
COMMIT;
|
|
--echo
|
|
|
|
--echo # show that session_track_transaction_info="CHARACTERISTICS" shows more edges
|
|
SET session_track_transaction_info="CHARACTERISTICS";
|
|
--echo # normal syntax: TR->T->0
|
|
START TRANSACTION WITH CONSISTENT SNAPSHOT;
|
|
COMMIT AND CHAIN;
|
|
COMMIT;
|
|
--echo # normal syntax: T->T->0
|
|
START TRANSACTION;
|
|
COMMIT AND CHAIN;
|
|
COMMIT;
|
|
--echo # pathological syntax: TR->TR->0
|
|
START TRANSACTION WITH CONSISTENT SNAPSHOT;
|
|
START TRANSACTION WITH CONSISTENT SNAPSHOT;
|
|
COMMIT;
|
|
--echo
|
|
|
|
|
|
--echo # chistics and interaction of implicit trx and explicit trx
|
|
CREATE TABLE t1 (f1 INT) ENGINE="InnoDB";
|
|
SET autocommit=0;
|
|
SET TRANSACTION READ ONLY;
|
|
--error ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION
|
|
INSERT INTO t1 VALUES(1);
|
|
ROLLBACK;
|
|
SET TRANSACTION READ WRITE;
|
|
# does not prevent further one-shots:
|
|
SET TRANSACTION READ ONLY;
|
|
SET TRANSACTION READ WRITE;
|
|
INSERT INTO t1 VALUES(1);
|
|
# in implicit transaction, can't set one-shots here using SET TRANSACTION
|
|
--error ER_CANT_CHANGE_TX_CHARACTERISTICS
|
|
SET TRANSACTION READ WRITE;
|
|
# we can set one-shots using START TRANSACTION though, as that commits
|
|
# an ongoing implicit transaction
|
|
START TRANSACTION READ ONLY;
|
|
# implicit COMMIT
|
|
DROP TABLE t1;
|
|
|
|
CREATE TABLE t1 (f1 INT) ENGINE="InnoDB";
|
|
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
|
|
# start implicit trx
|
|
INSERT INTO t1 VALUES(1);
|
|
--echo # implicit commit (chistics item here, clearing isolation level):
|
|
ALTER TABLE t1 ADD COLUMN f2 INT;
|
|
START TRANSACTION;
|
|
ROLLBACK;
|
|
--echo
|
|
# start implicit trx
|
|
INSERT INTO t1 VALUES(2,2);
|
|
--echo # implicit commit (no chistics item here):
|
|
ALTER TABLE t1 ADD COLUMN f3 INT;
|
|
START TRANSACTION;
|
|
ROLLBACK;
|
|
DROP TABLE t1;
|
|
|
|
SET autocommit=1;
|
|
|
|
# cleanup
|
|
SET session_track_transaction_info="STATE";
|
|
--echo
|
|
|
|
|
|
|
|
--echo ########################################################################
|
|
--echo #
|
|
--echo # show that table access reporting works in multi-statements
|
|
--echo #
|
|
|
|
--echo # multi-stmt #1
|
|
CREATE TABLE t2 (f1 INT) ENGINE="MyISAM";
|
|
BEGIN;
|
|
|
|
# COMMIT clears state, table write is not recorded as outside transaction,
|
|
# then transaction start is recorded:
|
|
delimiter |;
|
|
|
|
COMMIT; INSERT INTO t2 VALUES (1); BEGIN; |
|
|
|
|
delimiter ;|
|
|
|
|
COMMIT;
|
|
DROP TABLE t2;
|
|
|
|
|
|
--echo # multi-stmt #2
|
|
CREATE TABLE t1 (f1 INT) ENGINE="InnoDB";
|
|
CREATE TABLE t2 (f1 INT) ENGINE="MyISAM";
|
|
BEGIN;
|
|
|
|
# COMMIT clears state, table write is not recorded as outside transaction,
|
|
# then transaction start is recorded, finally a write is added:
|
|
delimiter |;
|
|
|
|
COMMIT; INSERT INTO t2 VALUES (1); BEGIN; INSERT INTO t1 VALUES (99); |
|
|
|
|
delimiter ;|
|
|
|
|
COMMIT;
|
|
DROP TABLE t1;
|
|
DROP TABLE t2;
|
|
--echo
|
|
|
|
|
|
|
|
--echo ########################################################################
|
|
--echo #
|
|
--echo # show that table access reporting works in Stored Functions (SF)
|
|
--echo #
|
|
|
|
CREATE TABLE t1 (f1 INT) ENGINE="InnoDB";
|
|
INSERT INTO t1 VALUES (1);
|
|
DELIMITER |;
|
|
|
|
--echo # create func1() in system table:
|
|
CREATE FUNCTION func1()
|
|
RETURNS INTEGER
|
|
BEGIN
|
|
SET @dummy = 0;
|
|
IF (SELECT * FROM t1) THEN
|
|
SET @dummy = 1;
|
|
END IF;
|
|
RETURN @dummy;
|
|
END|
|
|
|
|
DELIMITER ;|
|
|
|
|
--echo # func1() reads a trx table (and is read from a system table!):
|
|
BEGIN;
|
|
SELECT func1();
|
|
COMMIT;
|
|
DROP TABLE t1;
|
|
--echo # drop func1() from system table:
|
|
DROP FUNCTION func1;
|
|
|
|
|
|
|
|
--echo ########################################################################
|
|
--echo #
|
|
--echo # show that reporting works for Stored Procedures (SP)
|
|
--echo #
|
|
|
|
CREATE TABLE t1 (f1 INT) ENGINE="InnoDB";
|
|
CREATE TABLE t2 (f1 INT) ENGINE="MyISAM";
|
|
INSERT INTO t1 VALUES (1);
|
|
INSERT INTO t2 VALUES (2);
|
|
|
|
DELIMITER |;
|
|
|
|
CREATE PROCEDURE proc1()
|
|
BEGIN
|
|
SET @dummy = 0;
|
|
IF (SELECT f1 FROM t1) THEN
|
|
SET @dummy = 1;
|
|
END IF;
|
|
END|
|
|
|
|
CREATE PROCEDURE proc2()
|
|
BEGIN
|
|
CALL proc1();
|
|
UPDATE t1 SET f1=4;
|
|
END|
|
|
|
|
CREATE PROCEDURE proc3()
|
|
BEGIN
|
|
DECLARE x CHAR(36);
|
|
SET x=UUID();
|
|
END|
|
|
|
|
CREATE PROCEDURE proc4(x CHAR(36))
|
|
BEGIN
|
|
END|
|
|
|
|
CREATE PROCEDURE proc5()
|
|
BEGIN
|
|
SELECT f1 FROM t1;
|
|
SELECT f1 FROM t2;
|
|
END|
|
|
|
|
CREATE PROCEDURE proc6a()
|
|
BEGIN
|
|
IF (SELECT f1 FROM t1) THEN
|
|
SET @dummy = 1;
|
|
END IF;
|
|
ALTER TABLE t1 ADD COLUMN f2 INT;
|
|
IF (SELECT f1 FROM t2) THEN
|
|
SET @dummy = 1;
|
|
END IF;
|
|
END|
|
|
|
|
CREATE PROCEDURE proc6b()
|
|
BEGIN
|
|
SELECT f1 FROM t1;
|
|
ALTER TABLE t1 ADD COLUMN f3 INT;
|
|
SELECT f1 FROM t2;
|
|
END|
|
|
|
|
CREATE PROCEDURE proc7(x INT)
|
|
BEGIN
|
|
SELECT f1 FROM t1;
|
|
SELECT f1*2 FROM t1;
|
|
END|
|
|
|
|
CREATE PROCEDURE proc8(x INT)
|
|
BEGIN
|
|
SELECT f1 FROM t1;
|
|
IF (SELECT f1 FROM t2) THEN
|
|
SET @dummy = 1;
|
|
END IF;
|
|
END|
|
|
|
|
CREATE PROCEDURE proc9(x INT)
|
|
BEGIN
|
|
SELECT f1 FROM t1;
|
|
IF (SELECT f1 FROM t1) THEN
|
|
SET @dummy = 1;
|
|
END IF;
|
|
END|
|
|
|
|
DELIMITER ;|
|
|
|
|
BEGIN;
|
|
--echo # example unsafe call:
|
|
CALL proc3();
|
|
--echo # report on tables accessed within SP:
|
|
CALL proc1();
|
|
--echo # report on tables accessed within all (nested) SP:
|
|
CALL proc2();
|
|
COMMIT;
|
|
BEGIN;
|
|
CALL proc4(UUID());
|
|
COMMIT;
|
|
|
|
--echo # multiple result sets:
|
|
--echo # autocommit=1, not in a transaction, no tracker item:
|
|
CALL proc5();
|
|
--echo
|
|
|
|
BEGIN;
|
|
--echo # first SELECT adds R/S to present T and renders a tracker item;
|
|
--echo # second SELECT add r flag and renders another tracker item
|
|
CALL proc5();
|
|
COMMIT;
|
|
|
|
SET autocommit=0;
|
|
--echo # first SELECT renders I/R/S tracker item;
|
|
--echo # second SELECT add r flag and renders another tracker item
|
|
CALL proc5();
|
|
COMMIT;
|
|
--echo
|
|
|
|
BEGIN;
|
|
--echo # first SELECT adds R/S to present T and renders a tracker item;
|
|
--echo # second SELECT add r flag and renders another tracker item
|
|
CALL proc5();
|
|
COMMIT;
|
|
--echo
|
|
|
|
--echo # multiple result sets; implicit commit between them
|
|
BEGIN;
|
|
--echo # first SELECT adds R/S to present T and renders a tracker item;
|
|
--echo # second SELECT add r flag and renders another tracker item
|
|
CALL proc6b();
|
|
COMMIT;
|
|
BEGIN;
|
|
--echo # first SELECT adds R/S to present T and renders a tracker item;
|
|
--echo # second SELECT add r flag and renders another tracker item
|
|
CALL proc6a();
|
|
COMMIT;
|
|
--echo
|
|
|
|
--echo # multiple result sets; sub-query as argument, autocommit==0
|
|
BEGIN;
|
|
# add S to tracker item
|
|
SELECT 1 FROM DUAL;
|
|
CALL proc7((SELECT f1 FROM t2));
|
|
COMMIT;
|
|
|
|
SET autocommit=1;
|
|
|
|
--echo # multiple result sets; sub-query as argument, autocommit==1
|
|
BEGIN;
|
|
# add S to tracker item
|
|
SELECT 1 FROM DUAL;
|
|
CALL proc7((SELECT f1 FROM t2));
|
|
COMMIT;
|
|
|
|
--echo # not in a transaction, no tracking
|
|
CALL proc8((SELECT f1 FROM t2));
|
|
--echo
|
|
|
|
BEGIN;
|
|
--echo # body sets R/S in select, and r in sub-select
|
|
CALL proc8((SELECT f1 FROM t2));
|
|
COMMIT;
|
|
--echo
|
|
|
|
BEGIN;
|
|
--echo # argument sets r, body sets R
|
|
CALL proc9((SELECT f1 FROM t2));
|
|
COMMIT;
|
|
--echo
|
|
|
|
DROP PROCEDURE proc1;
|
|
DROP PROCEDURE proc2;
|
|
DROP PROCEDURE proc3;
|
|
DROP PROCEDURE proc4;
|
|
DROP PROCEDURE proc5;
|
|
DROP PROCEDURE proc6a;
|
|
DROP PROCEDURE proc6b;
|
|
DROP PROCEDURE proc7;
|
|
DROP PROCEDURE proc8;
|
|
DROP PROCEDURE proc9;
|
|
DROP TABLE t1;
|
|
DROP TABLE t2;
|
|
|
|
|
|
|
|
--echo ########################################################################
|
|
--echo #
|
|
--echo # interaction with system tables
|
|
--echo #
|
|
|
|
CREATE TABLE t2 (f1 INT) ENGINE="MyISAM";
|
|
BEGIN;
|
|
# CONVERT_TZ() accesses a transactional system table in an attached
|
|
# transaction. This is an implementation detail / artifact that does
|
|
# not concern the user transaction, so we hide it (as we do all state
|
|
# from attached transactions).
|
|
SELECT CONVERT_TZ('2004-01-01 12:00:00','GMT','MET');
|
|
COMMIT;
|
|
DROP TABLE t2;
|
|
|
|
--echo #
|
|
--echo # log tables
|
|
--echo #
|
|
|
|
SET @old_log_output= @@global.log_output;
|
|
SET @old_general_log= @@global.general_log;
|
|
SET @old_general_log_file= @@global.general_log_file;
|
|
|
|
TRUNCATE TABLE mysql.general_log;
|
|
|
|
SET GLOBAL log_output = 'TABLE';
|
|
SET GLOBAL general_log= 'ON';
|
|
|
|
BEGIN;
|
|
# Example query to be logged to the log table, general_log.
|
|
# That table access does not become part of our state:
|
|
SELECT 1 FROM DUAL;
|
|
# Show that the above query was actually logged.
|
|
# THIS (read) access will be flagged, as it's part of the user's transaction.
|
|
SELECT " -> ", argument FROM mysql.general_log WHERE argument LIKE '% DUAL' AND (command_type!='Prepare');
|
|
ROLLBACK;
|
|
|
|
TRUNCATE TABLE mysql.general_log;
|
|
|
|
SET GLOBAL general_log_file= @old_general_log_file;
|
|
SET GLOBAL general_log= @old_general_log;
|
|
SET GLOBAL log_output= @old_log_output;
|
|
|
|
|
|
--echo ########################################################################
|
|
--echo #
|
|
--echo # show that table access reporting works with LOCK TABLES
|
|
--echo #
|
|
|
|
CREATE TABLE t1 (f1 INT) ENGINE="InnoDB";
|
|
CREATE TABLE t2 (f1 INT) ENGINE="MyISAM";
|
|
SET autocommit=0;
|
|
SELECT 1 FROM DUAL;
|
|
SELECT f1 FROM t1;
|
|
--echo # no LOCK held this time, so no implicit commit:
|
|
UNLOCK TABLES;
|
|
--echo # LOCK TABLES pre-commits:
|
|
LOCK TABLES t1 WRITE;
|
|
INSERT INTO t1 VALUES (1);
|
|
INSERT INTO t1 VALUES (2);
|
|
SELECT f1 FROM t1;
|
|
COMMIT;
|
|
SET TRANSACTION READ ONLY;
|
|
SET TRANSACTION READ WRITE;
|
|
UNLOCK TABLES;
|
|
|
|
--echo
|
|
SET autocommit=1;
|
|
LOCK TABLE t1 WRITE, t2 WRITE;
|
|
INSERT INTO t2 VALUES (3);
|
|
INSERT INTO t1 VALUES (3);
|
|
SELECT f1 FROM t1 WHERE f1 > 2;
|
|
UNLOCK TABLES;
|
|
|
|
--echo # don't report chistics for autocommits while LOCK is held
|
|
SET SESSION session_track_transaction_info="CHARACTERISTICS";
|
|
LOCK TABLE t1 WRITE;
|
|
INSERT INTO t1 VALUES (3);
|
|
SELECT f1 FROM t1 WHERE f1 > 2;
|
|
UNLOCK TABLES;
|
|
SET session_track_transaction_info="STATE";
|
|
|
|
DROP TABLE t1;
|
|
DROP TABLE t2;
|
|
|
|
|
|
|
|
--echo ########################################################################
|
|
--echo #
|
|
--echo # XA
|
|
--echo #
|
|
|
|
CREATE TABLE t1 (f1 int) ENGINE="InnoDB";
|
|
SET SESSION session_track_transaction_info="CHARACTERISTICS";
|
|
|
|
--echo # XA ROLLBACK
|
|
XA START 'test1';
|
|
INSERT t1 VALUES (1);
|
|
XA END 'test1';
|
|
XA PREPARE 'test1';
|
|
XA ROLLBACK 'test1';
|
|
|
|
--echo # XA COMMIT
|
|
XA START 'test2', 'yy';
|
|
INSERT t1 VALUES (2);
|
|
XA END 'test2', 'yy';
|
|
XA PREPARE 'test2', 'yy';
|
|
XA COMMIT 'test2', 'yy';
|
|
|
|
--echo # XA COMMIT ONE PHASE
|
|
XA START 'test3','xx',5;
|
|
INSERT t1 VALUES (3);
|
|
XA END 'test3','xx',5;
|
|
XA COMMIT 'test3','xx',5 ONE PHASE;
|
|
|
|
SET SESSION session_track_transaction_info="OFF";
|
|
DROP TABLE t1;
|
|
|
|
|
|
|
|
--echo ########################################################################
|
|
--echo #
|
|
--echo # cleanup
|
|
--echo #
|
|
|
|
--disable_session_track_info
|
|
|
|
SET SESSION session_track_system_variables= @old_track_list;
|
|
SET SESSION session_track_state_change=@old_track_enable;
|
|
SET SESSION session_track_transaction_info=@old_track_tx;
|
|
|
|
# ends
|
|
|
|
--source suite/xengine/include/check_xengine_log_error.inc
|