Skip to content

Commit 7195dc6

Browse files
JanJakesJanJakes
committed
Support setting AUTO_INCREMENT via CREATE TABLE / ALTER TABLE
Implement the AUTO_INCREMENT table option in CREATE TABLE and ALTER TABLE by writing the requested value as seq - 1 into SQLite's sqlite_sequence. As in MySQL, the effective counter is clamped to MAX(col) so it never drops below an existing row, and the option is silently ignored when the table has no AUTO_INCREMENT column. Also skip the full table rebuild in ALTER TABLE when the statement only carries table options (no alterListItem) so that pure AUTO_INCREMENT = N changes are instant rather than a no-op full-table copy.
1 parent 47325ab commit 7195dc6

2 files changed

Lines changed: 234 additions & 75 deletions

File tree

‎packages/mysql-on-sqlite/src/sqlite/class-wp-pdo-mysql-on-sqlite.php‎

Lines changed: 92 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2378,6 +2378,9 @@ private function execute_create_table_statement( WP_Parser_Node $node ): void {
23782378
foreach ( $constraint_queries as $query ) {
23792379
$this->execute_sqlite_query( $query );
23802380
}
2381+
2382+
// Apply AUTO_INCREMENT = N table option, if any.
2383+
$this->apply_auto_increment_table_option( $table_is_temporary, $table_name, $node );
23812384
}
23822385

23832386
/**
@@ -2451,8 +2454,18 @@ private function execute_alter_table_statement( WP_Parser_Node $node ): void {
24512454
}
24522455
}
24532456

2454-
$this->information_schema_builder->record_alter_table( $node );
2455-
$this->recreate_table_from_information_schema( $table_is_temporary, $table_name, $column_map );
2457+
/*
2458+
* Skip the expensive table rebuild when the statement only carries
2459+
* table options (e.g. ALTER TABLE t AUTO_INCREMENT = N). These don't
2460+
* change the schema, so the recreate would be a pointless full copy.
2461+
*/
2462+
if ( count( $node->get_descendant_nodes( 'alterListItem' ) ) > 0 ) {
2463+
$this->information_schema_builder->record_alter_table( $node );
2464+
$this->recreate_table_from_information_schema( $table_is_temporary, $table_name, $column_map );
2465+
}
2466+
2467+
// Apply AUTO_INCREMENT = N table option, if any.
2468+
$this->apply_auto_increment_table_option( $table_is_temporary, $table_name, $node );
24562469

24572470
// @TODO: Consider using a "fast path" for ALTER TABLE statements that
24582471
// consist only of operations that SQLite's ALTER TABLE supports.
@@ -4916,6 +4929,83 @@ private function recreate_table_from_information_schema(
49164929
// @TODO: Triggers and views.
49174930
}
49184931

4932+
/**
4933+
* Apply the AUTO_INCREMENT table option from a CREATE TABLE or ALTER TABLE
4934+
* statement by adjusting the row in SQLite's "sqlite_sequence" table.
4935+
*
4936+
* @param bool $table_is_temporary Whether the table is temporary.
4937+
* @param string $table_name The table name.
4938+
* @param WP_Parser_Node $node The "createStatement" or "alterStatement" AST node.
4939+
*/
4940+
private function apply_auto_increment_table_option(
4941+
bool $table_is_temporary,
4942+
string $table_name,
4943+
WP_Parser_Node $node
4944+
): void {
4945+
// Find the last AUTO_INCREMENT = N option (MySQL uses the last one).
4946+
$value = null;
4947+
foreach ( $node->get_descendant_nodes( 'createTableOption' ) as $option ) {
4948+
if ( ! $option->has_child_token( WP_MySQL_Lexer::AUTO_INCREMENT_SYMBOL ) ) {
4949+
continue;
4950+
}
4951+
$number_node = $option->get_first_child_node( 'ulonglong_number' );
4952+
if ( null === $number_node ) {
4953+
continue;
4954+
}
4955+
$value = (int) $number_node->get_first_descendant_token()->get_value();
4956+
}
4957+
if ( null === $value ) {
4958+
return;
4959+
}
4960+
4961+
// Find the AUTO_INCREMENT column.
4962+
$columns_table = $this->information_schema_builder->get_table_name( $table_is_temporary, 'columns' );
4963+
$auto_column = $this->execute_sqlite_query(
4964+
sprintf(
4965+
"SELECT column_name FROM %s
4966+
WHERE table_schema = ?
4967+
AND table_name = ?
4968+
AND extra = 'auto_increment'",
4969+
$this->quote_sqlite_identifier( $columns_table )
4970+
),
4971+
array( $this->get_saved_db_name(), $table_name )
4972+
)->fetchColumn();
4973+
if ( false === $auto_column ) {
4974+
return;
4975+
}
4976+
4977+
/*
4978+
* Prepare an expression for the sequence value.
4979+
* 1. Use N - 1. MySQL stores the next value, SQLite the last one.
4980+
* 2. Clamp to MAX(col) like MySQL (we can't go below existing values).
4981+
*
4982+
* The value is inlined as an integer literal because PDO binds PHP ints
4983+
* as TEXT, and SQLite's type affinity ranks TEXT above INTEGER in MAX().
4984+
*/
4985+
$schema = $table_is_temporary ? 'temp' : 'main';
4986+
$seq_expr = sprintf(
4987+
'MAX(%d, COALESCE((SELECT MAX(%s) FROM %s), 0))',
4988+
$value - 1,
4989+
$this->quote_sqlite_identifier( $auto_column ),
4990+
$this->quote_sqlite_identifier( $table_name )
4991+
);
4992+
4993+
// Update the value in the "sqlite_sequence" table.
4994+
$updated = $this->execute_sqlite_query(
4995+
sprintf( 'UPDATE %s.sqlite_sequence SET seq = %s WHERE name = ?', $schema, $seq_expr ),
4996+
array( $table_name )
4997+
)->rowCount();
4998+
4999+
// If the sequence value does not exist yet, insert a new row.
5000+
// SQLite reports matched (not affected) rows, so the 0 check is safe.
5001+
if ( 0 === $updated ) {
5002+
$this->execute_sqlite_query(
5003+
sprintf( 'INSERT INTO %s.sqlite_sequence (name, seq) VALUES (?, %s)', $schema, $seq_expr ),
5004+
array( $table_name )
5005+
);
5006+
}
5007+
}
5008+
49195009
/**
49205010
* Translate a MySQL SHOW LIKE ... or SHOW WHERE ... condition to SQLite.
49215011
*

‎packages/mysql-on-sqlite/tests/WP_SQLite_Driver_Metadata_Tests.php‎

Lines changed: 142 additions & 73 deletions
Original file line numberDiff line numberDiff line change
@@ -639,17 +639,11 @@ public function testInformationSchemaTablesAutoIncrement(): void {
639639
$result = $this->assertQuery( "SELECT * FROM information_schema.tables WHERE table_name = 't'" );
640640
$this->assertSame( '1', $result[0]->AUTO_INCREMENT );
641641

642-
// After inserts, the stored value advances, and a backtick-quoted
643-
// projection returns the same result as SELECT *.
642+
// After inserts, the sequence advances.
644643
$this->assertQuery( "INSERT INTO t (name) VALUES ('a'), ('b'), ('c')" );
645644
$result = $this->assertQuery( "SELECT * FROM information_schema.tables WHERE table_name = 't'" );
646645
$this->assertSame( '4', $result[0]->AUTO_INCREMENT );
647646

648-
$result = $this->assertQuery(
649-
"SELECT table_name, `auto_increment` FROM information_schema.tables WHERE table_name = 't'"
650-
);
651-
$this->assertSame( '4', $result[0]->AUTO_INCREMENT );
652-
653647
// DELETE preserves the counter.
654648
$this->assertQuery( 'DELETE FROM t' );
655649
$result = $this->assertQuery( "SELECT * FROM information_schema.tables WHERE table_name = 't'" );
@@ -661,123 +655,198 @@ public function testInformationSchemaTablesAutoIncrement(): void {
661655
$this->assertSame( '1', $result[0]->AUTO_INCREMENT );
662656
}
663657

664-
public function testShowTableStatusAutoIncrement() {
658+
public function testInformationSchemaTablesFilterByAutoIncrement(): void {
659+
$this->assertQuery( 'CREATE TABLE low (id INT AUTO_INCREMENT PRIMARY KEY, name TEXT)' );
660+
$this->assertQuery( 'CREATE TABLE high (id INT AUTO_INCREMENT PRIMARY KEY, name TEXT)' );
661+
$this->assertQuery( 'CREATE TABLE plain (id INT, name TEXT)' );
662+
$this->assertQuery( "INSERT INTO low (name) VALUES ('a')" );
663+
$this->assertQuery( "INSERT INTO high (name) VALUES ('a'), ('b'), ('c'), ('d'), ('e')" );
664+
665+
// > 3
666+
$result = $this->assertQuery(
667+
'SELECT TABLE_NAME FROM information_schema.tables WHERE `AUTO_INCREMENT` > 3'
668+
);
669+
$this->assertCount( 1, $result );
670+
$this->assertSame( 'high', $result[0]->TABLE_NAME );
671+
672+
// IS NULL
673+
$result = $this->assertQuery(
674+
'SELECT TABLE_NAME FROM information_schema.tables WHERE `AUTO_INCREMENT` IS NULL'
675+
);
676+
$this->assertCount( 1, $result );
677+
$this->assertSame( 'plain', $result[0]->TABLE_NAME );
678+
}
679+
680+
public function testShowTableStatusAutoIncrement(): void {
665681
// A non-AUTO_INCREMENT table reports NULL.
666682
$this->assertQuery( 'CREATE TABLE plain (id INT, name TEXT)' );
667-
$this->assertSame( null, $this->getAutoIncrement( 'plain' ) );
683+
$result = $this->assertQuery( "SHOW TABLE STATUS LIKE 'plain'" );
684+
$this->assertSame( null, $result[0]->Auto_increment );
668685

669686
// A fresh AUTO_INCREMENT table reports 1.
670687
$this->assertQuery( 'CREATE TABLE t (id INT AUTO_INCREMENT PRIMARY KEY, name TEXT)' );
671-
$this->assertSame( '1', $this->getAutoIncrement( 't' ) );
688+
$result = $this->assertQuery( "SHOW TABLE STATUS LIKE 't'" );
689+
$this->assertSame( '1', $result[0]->Auto_increment );
672690

673-
// After inserts, Auto_increment is the next value.
691+
// After inserts, the sequence advances.
674692
$this->assertQuery( "INSERT INTO t (name) VALUES ('a'), ('b'), ('c')" );
675-
$this->assertSame( '4', $this->getAutoIncrement( 't' ) );
676-
677-
// DELETE must preserve the counter, matching InnoDB behavior.
678-
$this->assertQuery( 'DELETE FROM t WHERE id = 3' );
679-
$this->assertSame( '4', $this->getAutoIncrement( 't' ) );
693+
$result = $this->assertQuery( "SHOW TABLE STATUS LIKE 't'" );
694+
$this->assertSame( '4', $result[0]->Auto_increment );
680695

681-
// DELETE of all rows still preserves the counter.
696+
// DELETE preserves the counter.
682697
$this->assertQuery( 'DELETE FROM t' );
683-
$this->assertSame( '4', $this->getAutoIncrement( 't' ) );
698+
$result = $this->assertQuery( "SHOW TABLE STATUS LIKE 't'" );
699+
$this->assertSame( '4', $result[0]->Auto_increment );
684700

685701
// TRUNCATE resets the counter.
686702
$this->assertQuery( 'TRUNCATE TABLE t' );
687-
$this->assertSame( '1', $this->getAutoIncrement( 't' ) );
703+
$result = $this->assertQuery( "SHOW TABLE STATUS LIKE 't'" );
704+
$this->assertSame( '1', $result[0]->Auto_increment );
688705
}
689706

690-
public function testShowTableStatusFilterByAutoIncrement() {
707+
public function testShowTableStatusFilterByAutoIncrement(): void {
691708
$this->assertQuery( 'CREATE TABLE low (id INT AUTO_INCREMENT PRIMARY KEY, name TEXT)' );
692709
$this->assertQuery( 'CREATE TABLE high (id INT AUTO_INCREMENT PRIMARY KEY, name TEXT)' );
693710
$this->assertQuery( 'CREATE TABLE plain (id INT, name TEXT)' );
694711
$this->assertQuery( "INSERT INTO low (name) VALUES ('a')" );
695712
$this->assertQuery( "INSERT INTO high (name) VALUES ('a'), ('b'), ('c'), ('d'), ('e')" );
696713

697-
// WHERE must filter on the computed Auto_increment alias, not on the
698-
// always-NULL underlying info_schema column.
714+
// > 3
699715
$result = $this->assertQuery( 'SHOW TABLE STATUS WHERE `Auto_increment` > 3' );
700716
$this->assertCount( 1, $result );
701717
$this->assertSame( 'high', $result[0]->Name );
702718

719+
// IS NULL
703720
$result = $this->assertQuery( 'SHOW TABLE STATUS WHERE `Auto_increment` IS NULL' );
704721
$this->assertCount( 1, $result );
705722
$this->assertSame( 'plain', $result[0]->Name );
706723
}
707724

708725
public function testShowCreateTableAutoIncrement(): void {
709-
// No AUTO_INCREMENT=N on a non-AI table.
726+
// No AUTO_INCREMENT=N on a non-AUTO_INCREMENT table.
710727
$this->assertQuery( 'CREATE TABLE plain (id INT, name TEXT)' );
711-
$this->assertStringNotContainsString(
712-
'AUTO_INCREMENT=',
713-
$this->getCreateTable( 'plain' )
714-
);
728+
$result = $this->assertQuery( 'SHOW CREATE TABLE plain' );
729+
$this->assertStringNotContainsString( 'AUTO_INCREMENT=', $result[0]->{'Create Table'} );
715730

716-
// No AUTO_INCREMENT=N on a fresh AI table (counter has not advanced).
731+
// No AUTO_INCREMENT=N on a fresh AUTO_INCREMENT table (sequence not advanced).
717732
$this->assertQuery( 'CREATE TABLE t (id INT AUTO_INCREMENT PRIMARY KEY, name TEXT)' );
718-
$this->assertStringNotContainsString(
719-
'AUTO_INCREMENT=',
720-
$this->getCreateTable( 't' )
721-
);
733+
$result = $this->assertQuery( 'SHOW CREATE TABLE t' );
734+
$this->assertStringNotContainsString( 'AUTO_INCREMENT=', $result[0]->{'Create Table'} );
722735

723-
// After inserts, AUTO_INCREMENT=<next value> is emitted.
736+
// After inserts, the sequence advances.
724737
$this->assertQuery( "INSERT INTO t (name) VALUES ('a'), ('b'), ('c')" );
725-
$this->assertStringContainsString(
726-
'AUTO_INCREMENT=4',
727-
$this->getCreateTable( 't' )
728-
);
738+
$result = $this->assertQuery( 'SHOW CREATE TABLE t' );
739+
$this->assertStringContainsString( 'AUTO_INCREMENT=4', $result[0]->{'Create Table'} );
729740

730741
// DELETE preserves the counter.
731742
$this->assertQuery( 'DELETE FROM t' );
732-
$this->assertStringContainsString(
733-
'AUTO_INCREMENT=4',
734-
$this->getCreateTable( 't' )
735-
);
743+
$result = $this->assertQuery( 'SHOW CREATE TABLE t' );
744+
$this->assertStringContainsString( 'AUTO_INCREMENT=4', $result[0]->{'Create Table'} );
736745

737-
// TRUNCATE resets the counter; AUTO_INCREMENT=N is omitted again.
746+
// TRUNCATE resets the counter.
738747
$this->assertQuery( 'TRUNCATE TABLE t' );
739-
$this->assertStringNotContainsString(
740-
'AUTO_INCREMENT=',
741-
$this->getCreateTable( 't' )
742-
);
748+
$result = $this->assertQuery( 'SHOW CREATE TABLE t' );
749+
$this->assertStringNotContainsString( 'AUTO_INCREMENT=', $result[0]->{'Create Table'} );
743750
}
744751

745-
public function testShowCreateTableAutoIncrementOnTemporaryTable(): void {
746-
// Temporary tables live in SQLite's `temp` schema with their own
747-
// `sqlite_sequence`. Make sure the counter is read from the right one
748-
// even when a persistent AI table in `main` might shadow it.
749-
$this->assertQuery( 'CREATE TABLE main_tbl (id INT AUTO_INCREMENT PRIMARY KEY, name TEXT)' );
750-
$this->assertQuery( "INSERT INTO main_tbl (name) VALUES ('m')" );
751752

752-
$this->assertQuery( 'CREATE TEMPORARY TABLE tmp (id INT AUTO_INCREMENT PRIMARY KEY, name TEXT)' );
753-
$this->assertStringNotContainsString(
754-
'AUTO_INCREMENT=',
755-
$this->getCreateTable( 'tmp' )
753+
public function testCreateTableSetAutoIncrement(): void {
754+
$this->assertQuery(
755+
'CREATE TABLE t (id INT AUTO_INCREMENT PRIMARY KEY, name TEXT) AUTO_INCREMENT=100'
756756
);
757+
$result = $this->assertQuery( "SHOW TABLE STATUS LIKE 't'" );
758+
$this->assertSame( '100', $result[0]->Auto_increment );
757759

758-
$this->assertQuery( "INSERT INTO tmp (name) VALUES ('a'), ('b')" );
759-
$this->assertStringContainsString(
760-
'AUTO_INCREMENT=3',
761-
$this->getCreateTable( 'tmp' )
762-
);
760+
// INSERT advances the sequence.
761+
$this->assertQuery( "INSERT INTO t (name) VALUES ('a')" );
762+
$this->assertSame( '100', $this->assertQuery( 'SELECT id FROM t' )[0]->id );
763763

764-
// The persistent table's counter must remain independent.
765-
$this->assertStringContainsString(
766-
'AUTO_INCREMENT=2',
767-
$this->getCreateTable( 'main_tbl' )
768-
);
764+
// SHOW TABLE STATUS
765+
$result = $this->assertQuery( "SHOW TABLE STATUS LIKE 't'" );
766+
$this->assertSame( '101', $result[0]->Auto_increment );
767+
768+
// SHOW CREATE TABLE
769+
$result = $this->assertQuery( 'SHOW CREATE TABLE t' );
770+
$this->assertStringContainsString( 'AUTO_INCREMENT=101', $result[0]->{'Create Table'} );
771+
772+
// Without an AUTO_INCREMENT column, the option is ignored.
773+
$this->assertQuery( 'CREATE TABLE plain (id INT, name TEXT) AUTO_INCREMENT=500' );
774+
$result = $this->assertQuery( "SHOW TABLE STATUS LIKE 'plain'" );
775+
$this->assertSame( null, $result[0]->Auto_increment );
769776
}
770777

771-
private function getAutoIncrement( string $table_name ): ?string {
778+
public function testAlterTableSetAutoIncrement(): void {
779+
$this->assertQuery( 'CREATE TABLE t (id INT AUTO_INCREMENT PRIMARY KEY, name TEXT)' );
780+
781+
// Set the sequence value on an empty table.
782+
$this->assertQuery( 'ALTER TABLE t AUTO_INCREMENT = 50' );
783+
$result = $this->assertQuery( "SHOW TABLE STATUS LIKE 't'" );
784+
$this->assertSame( '50', $result[0]->Auto_increment );
785+
786+
// INSERT advances the sequence.
787+
$this->assertQuery( "INSERT INTO t (name) VALUES ('a')" );
788+
$this->assertSame( '50', $this->assertQuery( 'SELECT id FROM t' )[0]->id );
789+
$result = $this->assertQuery( "SHOW TABLE STATUS LIKE 't'" );
790+
$this->assertSame( '51', $result[0]->Auto_increment );
791+
792+
// Update the sequence value.
793+
$this->assertQuery( 'ALTER TABLE t AUTO_INCREMENT = 200' );
794+
795+
// SHOW TABLE STATUS
796+
$result = $this->assertQuery( "SHOW TABLE STATUS LIKE 't'" );
797+
$this->assertSame( '200', $result[0]->Auto_increment );
798+
799+
// SHOW CREATE TABLE
800+
$result = $this->assertQuery( 'SHOW CREATE TABLE t' );
801+
$this->assertStringContainsString( 'AUTO_INCREMENT=200', $result[0]->{'Create Table'} );
802+
803+
// Lowering the counter at or below MAX(id) clamps to MAX(id) + 1.
804+
$this->assertQuery( 'ALTER TABLE t AUTO_INCREMENT = 1' );
805+
$result = $this->assertQuery( "SHOW TABLE STATUS LIKE 't'" );
806+
$this->assertSame( '51', $result[0]->Auto_increment );
807+
808+
// Without an AUTO_INCREMENT column, the option is ignored.
809+
$this->assertQuery( 'CREATE TABLE plain (id INT, name TEXT) AUTO_INCREMENT=500' );
810+
$result = $this->assertQuery( "SHOW TABLE STATUS LIKE 'plain'" );
811+
$this->assertSame( null, $result[0]->Auto_increment );
812+
}
813+
814+
public function testTemporaryTableAutoIncrement(): void {
815+
// Persistent and temporary tables sharing a name must keep independent sequences.
816+
817+
// Persistent t: next id = 3.
818+
$this->assertQuery( 'CREATE TABLE t (id INT AUTO_INCREMENT PRIMARY KEY, name TEXT)' );
819+
$this->assertQuery( "INSERT INTO t (name) VALUES ('a'), ('b')" );
820+
821+
// Shadowing temporary t seeded to start at 500.
822+
$this->assertQuery(
823+
'CREATE TEMPORARY TABLE t (id INT AUTO_INCREMENT PRIMARY KEY, name TEXT) AUTO_INCREMENT=500'
824+
);
825+
826+
// SHOW TABLE STATUS and information_schema.tables list only the
827+
// persistent table; the temporary one is not visible here.
828+
$result = $this->assertQuery( "SHOW TABLE STATUS LIKE 't'" );
829+
$this->assertCount( 1, $result );
830+
$this->assertSame( '3', $result[0]->Auto_increment );
831+
772832
$result = $this->assertQuery(
773-
sprintf( "SHOW TABLE STATUS LIKE '%s'", $table_name )
833+
"SELECT `AUTO_INCREMENT` FROM information_schema.tables WHERE table_name = 't'"
774834
);
775-
return $result[0]->Auto_increment;
776-
}
835+
$this->assertCount( 1, $result );
836+
$this->assertSame( '3', $result[0]->AUTO_INCREMENT );
837+
838+
// Unqualified statements target the shadowing temporary table:
839+
// INSERT picks up the seeded value, ALTER updates the temp sequence.
840+
$this->assertQuery( "INSERT INTO t (name) VALUES ('x')" );
841+
$this->assertSame( '500', $this->assertQuery( "SELECT id FROM t WHERE name = 'x'" )[0]->id );
842+
843+
$this->assertQuery( 'ALTER TABLE t AUTO_INCREMENT = 1000' );
844+
$this->assertQuery( "INSERT INTO t (name) VALUES ('y')" );
845+
$this->assertSame( '1000', $this->assertQuery( "SELECT id FROM t WHERE name = 'y'" )[0]->id );
777846

778-
private function getCreateTable( string $table_name ): string {
779-
$result = $this->assertQuery( sprintf( 'SHOW CREATE TABLE %s', $table_name ) );
780-
return $result[0]->{'Create Table'};
847+
// The persistent table's sequence must remain unaffected throughout.
848+
$result = $this->assertQuery( "SHOW TABLE STATUS LIKE 't'" );
849+
$this->assertSame( '3', $result[0]->Auto_increment );
781850
}
782851

783852
public function testShowFullColumns(): void {

0 commit comments

Comments
 (0)