Add support for AUTO_INCREMENT value management (#367)

## Summary

Adds support for **reporting** and **adjusting** `AUTO_INCREMENT`
counters, which the driver previously ignored.

### Reporting `AUTO_INCREMENT` values (commit 1)

`SHOW TABLE STATUS`, `SHOW CREATE TABLE`, and
`INFORMATION_SCHEMA.TABLES` now compute the `Auto_increment` value live
from `sqlite_sequence` rather than returning `NULL`. The counter is
preserved past `DELETE` and reset by `TRUNCATE`, matching InnoDB
semantics.

### Adjusting `AUTO_INCREMENT` values (commit 2)

Three MySQL forms are now honored:

1. `CREATE TABLE t (...) AUTO_INCREMENT = N` — seeds the counter.
2. `ALTER TABLE t AUTO_INCREMENT = N` — instant; no table rebuild.
3. `ALTER TABLE t <actions>, AUTO_INCREMENT = N` — applied alongside
other alter items.

The requested value is written as `N - 1` into `sqlite_sequence` (MySQL
stores the next value, SQLite the last used), clamped to `MAX(col)` so
the effective counter never drops below an existing row — matching
MySQL. When the table has no `AUTO_INCREMENT` column, the option is
silently ignored, matching MySQL.

**Not covered:** `SET @@auto_increment_increment` / `SET
@@auto_increment_offset`. These change the *step* and *offset* of
generated values, not the counter, and SQLite's `AUTOINCREMENT` always
steps by 1 — so emulating non-1 increments would require generating IDs
in PHP for every insert. Out of scope here.

## Notes

- `sqlite_sequence` has no `UNIQUE` constraint on `name`, so native
upsert is unavailable; the row is maintained with `UPDATE`-then-`INSERT`
(second query only runs when the first matches nothing).
- The clamp expression is inlined as an integer literal rather than a
bound parameter. PDO binds PHP ints as `TEXT`, and SQLite's type
affinity ranks `TEXT` above `INTEGER` in `MAX()`, which would silently
produce wrong results.
- `ALTER TABLE` with *only* table options (no `alterListItem`) now skips
the unnecessary full-table copy.

Fixes #114 and #140.

Author: JanJakes

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

@@ -2410,6 +2410,9 @@ private function execute_create_table_statement( WP_Parser_Node $node ): void {
 		foreach ( $constraint_queries as $query ) {
 			$this->execute_sqlite_query( $query );
 		}
+
+		// Apply AUTO_INCREMENT = N table option, if any.
+		$this->apply_auto_increment_table_option( $table_is_temporary, $table_name, $node );
 	}
 
 	/**
@@ -2483,8 +2486,18 @@ private function execute_alter_table_statement( WP_Parser_Node $node ): void {
 			}
 		}
 
-		$this->information_schema_builder->record_alter_table( $node );
-		$this->recreate_table_from_information_schema( $table_is_temporary, $table_name, $column_map );
+		/*
+		 * Skip the expensive table rebuild when the statement only carries
+		 * table options (e.g. ALTER TABLE t AUTO_INCREMENT = N). These don't
+		 * change the schema, so the recreate would be a pointless full copy.
+		 */
+		if ( count( $node->get_descendant_nodes( 'alterListItem' ) ) > 0 ) {
+			$this->information_schema_builder->record_alter_table( $node );
+			$this->recreate_table_from_information_schema( $table_is_temporary, $table_name, $column_map );
+		}
+
+		// Apply AUTO_INCREMENT = N table option, if any.
+		$this->apply_auto_increment_table_option( $table_is_temporary, $table_name, $node );
 
 		// @TODO: Consider using a "fast path" for ALTER TABLE statements that
 		//        consist only of operations that SQLite's ALTER TABLE supports.
@@ -2990,41 +3003,64 @@ private function execute_show_table_status_statement( WP_Parser_Node $node ): vo
 		// LIKE and WHERE clauses.
 		$like_or_where = $node->get_first_child_node( 'likeOrWhere' );
 		if ( null !== $like_or_where ) {
-			$condition = $this->translate_show_like_or_where_condition( $like_or_where, 'table_name' );
+			$condition = $this->translate_show_like_or_where_condition( $like_or_where, 'Name' );
 		}
 
-		// Fetch table information.
-		$tables_tables = $this->information_schema_builder->get_table_name(
-			false, // SHOW TABLE STATUS lists only non-temporary tables.
-			'tables'
+		// SHOW TABLE STATUS lists only non-temporary tables.
+		$tables_table  = $this->information_schema_builder->get_table_name( false, 'tables' );
+		$columns_table = $this->information_schema_builder->get_table_name( false, 'columns' );
+
+		// Compose a subquery to compute auto-increment values.
+		$has_sequence_table = (bool) $this->execute_sqlite_query(
+			"SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'sqlite_sequence'"
+		)->fetchColumn();
+
+		$auto_increment_subquery = sprintf(
+			"(
+				SELECT COALESCE(s.seq + 1, 1)
+				FROM %s AS c
+				%s
+				WHERE c.extra = 'auto_increment'
+				AND c.table_schema = t.table_schema
+				AND c.table_name = t.table_name
+			)",
+			$this->quote_sqlite_identifier( $columns_table ),
+			$has_sequence_table
+				? 'LEFT JOIN main.sqlite_sequence AS s ON s.name = c.table_name'
+				: 'LEFT JOIN (SELECT 0 AS seq) AS s'
 		);
-		$query         = sprintf(
-			'SELECT
-				table_name AS `Name`,
-				engine AS `Engine`,
-				version AS `Version`,
-				row_format AS `Row_format`,
-				table_rows AS `Rows`,
-				avg_row_length AS `Avg_row_length`,
-				data_length AS `Data_length`,
-				max_data_length AS `Max_data_length`,
-				index_length AS `Index_length`,
-				data_free AS `Data_free`,
-				auto_increment AS `Auto_increment`,
-				create_time AS `Create_time`,
-				update_time AS `Update_time`,
-				check_time AS `Check_time`,
-				table_collation AS `Collation`,
-				checksum AS `Checksum`,
-				create_options AS `Create_options`,
-				table_comment AS `Comment`
-			FROM %s
-			WHERE table_schema = ? %s
-			ORDER BY table_name',
-			$this->quote_sqlite_identifier( $tables_tables ),
+
+		$query  = sprintf(
+			'SELECT * FROM (
+				SELECT
+					table_name AS `Name`,
+					engine AS `Engine`,
+					version AS `Version`,
+					row_format AS `Row_format`,
+					table_rows AS `Rows`,
+					avg_row_length AS `Avg_row_length`,
+					data_length AS `Data_length`,
+					max_data_length AS `Max_data_length`,
+					index_length AS `Index_length`,
+					data_free AS `Data_free`,
+					%s AS `Auto_increment`,
+					create_time AS `Create_time`,
+					update_time AS `Update_time`,
+					check_time AS `Check_time`,
+					table_collation AS `Collation`,
+					checksum AS `Checksum`,
+					create_options AS `Create_options`,
+					table_comment AS `Comment`
+				FROM %s AS t
+				WHERE table_schema = ?
+			)
+			WHERE 1 %s
+			ORDER BY `Name`',
+			$auto_increment_subquery,
+			$this->quote_sqlite_identifier( $tables_table ),
 			$condition ?? ''
 		);
-		$params        = array(
+		$params = array(
 			$this->get_saved_db_name( $database ),
 		);
 
@@ -4729,7 +4765,7 @@ public function translate_table_ref( WP_Parser_Node $node ): string {
 		$table_name  = $this->unquote_sqlite_identifier( $this->translate( $table ) );
 
 		// When the table reference targets an information schema table,
-		// we need to inject the configured database name dynamically.
+		// we need to inject some additional values dynamically.
 		if (
 			( null === $schema_name && 'information_schema' === $this->db_name )
 			|| ( null !== $schema_name && 'information_schema' === strtolower( $schema_name ) )
@@ -4775,14 +4811,40 @@ public function translate_table_ref( WP_Parser_Node $node ): string {
 			$expanded_list = array();
 			foreach ( $columns as $column ) {
 				$quoted_column = $this->quote_sqlite_identifier( $column );
-				if ( isset( $information_schema_db_column_map[ strtoupper( $column ) ] ) ) {
+				if ( isset( $information_schema_db_column_map[ $column ] ) ) {
+					// Replace the database name with the configured database name.
 					$expanded_list[] = sprintf(
 						"CASE WHEN %s = 'information_schema' THEN %s ELSE %s END AS %s",
 						$quoted_column,
 						$quoted_column,
 						$this->quote_sqlite_value( $this->main_db_name ),
-						strtoupper( $quoted_column )
+						$quoted_column
 					);
+				} elseif ( 'tables' === $table_name && 'AUTO_INCREMENT' === $column ) {
+					// Inject the auto-increment values.
+					$columns_table      = $this->information_schema_builder->get_table_name( false, 'columns' );
+					$has_sequence_table = (bool) $this->execute_sqlite_query(
+						"SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'sqlite_sequence'"
+					)->fetchColumn();
+
+					$auto_increment_subquery = sprintf(
+						"(
+							SELECT COALESCE(s.seq + 1, 1)
+							FROM %s AS c
+							%s
+							WHERE c.extra = 'auto_increment'
+							AND c.table_schema = %s.table_schema
+							AND c.table_name = %s.table_name
+						)",
+						$this->quote_sqlite_identifier( $columns_table ),
+						$has_sequence_table
+							? 'LEFT JOIN main.sqlite_sequence AS s ON s.name = c.table_name'
+							: 'LEFT JOIN (SELECT 0 AS seq) AS s',
+						$this->quote_sqlite_identifier( $table_name ),
+						$this->quote_sqlite_identifier( $table_name )
+					);
+
+					$expanded_list[] = sprintf( '%s AS %s', $auto_increment_subquery, $quoted_column );
 				} else {
 					$expanded_list[] = $quoted_column;
 				}
@@ -4899,6 +4961,83 @@ private function recreate_table_from_information_schema(
 		// @TODO: Triggers and views.
 	}
 
+	/**
+	 * Apply the AUTO_INCREMENT table option from a CREATE TABLE or ALTER TABLE
+	 * statement by adjusting the row in SQLite's "sqlite_sequence" table.
+	 *
+	 * @param bool           $table_is_temporary Whether the table is temporary.
+	 * @param string         $table_name         The table name.
+	 * @param WP_Parser_Node $node               The "createStatement" or "alterStatement" AST node.
+	 */
+	private function apply_auto_increment_table_option(
+		bool $table_is_temporary,
+		string $table_name,
+		WP_Parser_Node $node
+	): void {
+		// Find the last AUTO_INCREMENT = N option (MySQL uses the last one).
+		$value = null;
+		foreach ( $node->get_descendant_nodes( 'createTableOption' ) as $option ) {
+			if ( ! $option->has_child_token( WP_MySQL_Lexer::AUTO_INCREMENT_SYMBOL ) ) {
+				continue;
+			}
+			$number_node = $option->get_first_child_node( 'ulonglong_number' );
+			if ( null === $number_node ) {
+				continue;
+			}
+			$value = (int) $number_node->get_first_descendant_token()->get_value();
+		}
+		if ( null === $value ) {
+			return;
+		}
+
+		// Find the AUTO_INCREMENT column.
+		$columns_table = $this->information_schema_builder->get_table_name( $table_is_temporary, 'columns' );
+		$auto_column   = $this->execute_sqlite_query(
+			sprintf(
+				"SELECT column_name FROM %s
+				WHERE table_schema = ?
+				AND table_name = ?
+				AND extra = 'auto_increment'",
+				$this->quote_sqlite_identifier( $columns_table )
+			),
+			array( $this->get_saved_db_name(), $table_name )
+		)->fetchColumn();
+		if ( false === $auto_column ) {
+			return;
+		}
+
+		/*
+		 * Prepare an expression for the sequence value.
+		 *   1. Use N - 1. MySQL stores the next value, SQLite the last one.
+		 *   2. Clamp to MAX(col) like MySQL (we can't go below existing values).
+		 *
+		 * The value is inlined as an integer literal because PDO binds PHP ints
+		 * as TEXT, and SQLite's type affinity ranks TEXT above INTEGER in MAX().
+		 */
+		$schema   = $table_is_temporary ? 'temp' : 'main';
+		$seq_expr = sprintf(
+			'MAX(%d, COALESCE((SELECT MAX(%s) FROM %s), 0))',
+			$value - 1,
+			$this->quote_sqlite_identifier( $auto_column ),
+			$this->quote_sqlite_identifier( $table_name )
+		);
+
+		// Update the value in the "sqlite_sequence" table.
+		$updated = $this->execute_sqlite_query(
+			sprintf( 'UPDATE %s.sqlite_sequence SET seq = %s WHERE name = ?', $schema, $seq_expr ),
+			array( $table_name )
+		)->rowCount();
+
+		// If the sequence value does not exist yet, insert a new row.
+		// SQLite reports matched (not affected) rows, so the 0 check is safe.
+		if ( 0 === $updated ) {
+			$this->execute_sqlite_query(
+				sprintf( 'INSERT INTO %s.sqlite_sequence (name, seq) VALUES (?, %s)', $schema, $seq_expr ),
+				array( $table_name )
+			);
+		}
+	}
+
 	/**
 	 * Translate a MySQL SHOW LIKE ... or SHOW WHERE ... condition to SQLite.
 	 *
@@ -6335,7 +6474,8 @@ private function get_mysql_create_table_statement( bool $table_is_temporary, str
 		)->fetchAll( PDO::FETCH_ASSOC );
 
 		// 6. Generate CREATE TABLE statement columns.
-		$rows = array();
+		$rows               = array();
+		$has_auto_increment = false;
 		foreach ( $column_info as $column ) {
 			$sql  = '  ';
 			$sql .= $this->quote_mysql_identifier( $column['COLUMN_NAME'] );
@@ -6347,7 +6487,8 @@ private function get_mysql_create_table_statement( bool $table_is_temporary, str
 				$sql .= ' NULL';
 			}
 			if ( 'auto_increment' === $column['EXTRA'] ) {
-				$sql .= ' AUTO_INCREMENT';
+				$has_auto_increment = true;
+				$sql               .= ' AUTO_INCREMENT';
 			}
 
 			// Handle DEFAULT CURRENT_TIMESTAMP. This works only with timestamp
@@ -6486,6 +6627,28 @@ function ( $column ) {
 		$sql .= implode( ",\n", $rows );
 		$sql .= "\n)";
 		$sql .= sprintf( ' ENGINE=%s', $table_info['ENGINE'] );
+
+		// Add "AUTO_INCREMENT=N" if a sequence exists and has been advanced.
+		if ( $has_auto_increment ) {
+			try {
+				$seq = (int) $this->execute_sqlite_query(
+					sprintf(
+						'SELECT seq FROM %s.sqlite_sequence WHERE name = ?',
+						$table_is_temporary ? 'temp' : 'main'
+					),
+					array( $table_name )
+				)->fetchColumn();
+			} catch ( PDOException $e ) {
+				if ( ! str_contains( $e->getMessage(), 'no such table' ) ) {
+					throw $e;
+				}
+				$seq = 0;
+			}
+			if ( $seq > 0 ) {
+				$sql .= sprintf( ' AUTO_INCREMENT=%d', $seq + 1 );
+			}
+		}
+
 		$sql .= sprintf( ' DEFAULT CHARSET=%s', $charset );
 		$sql .= sprintf( ' COLLATE=%s', $collation );
 		if ( '' !== $table_info['TABLE_COMMENT'] ) {