/**

private $dry_run;

/**

private $export_handle = false;

/**

private $update_error_columns = array();

/**

private $export_insert_size;

/**

private $recurse_objects;

/**

private $regex;

/**

private $regex_flags;

/**

private $regex_delimiter;

/**

private $regex_limit = -1;

/**

private $skip_tables;

/**

private $skip_columns;

/**

private $include_columns;

/**

private $format;

/**

private $report;

/**

private $verbose;

/**

private $report_changed_only;

/**

private $log_handle = null;

/**

private $log_before_context = 40;

/**

private $log_after_context = 40;

/**

private $log_prefixes = array( '< ', '> ' );

/**

private $log_colors;

/**

private $log_encoding;

/**

private $start_time;

/**

public function __invoke( $args, $assoc_args ) {

global $wpdb;

// Support --old and --new flags as an alternative to positional arguments.

// This allows users to search/replace strings that start with '--'.

$old_flag = Utils\get_flag_value( $assoc_args, 'old' );

$new_flag = Utils\get_flag_value( $assoc_args, 'new' );

// Check if both flags and positional arguments are provided.

$both_flags_provided = null !== $old_flag && null !== $new_flag;

$has_positional_args = ! empty( $args );

if ( $both_flags_provided && $has_positional_args ) {

WP_CLI::error( 'Cannot use both positional arguments and --old/--new flags. Please use one method or the other.' );

}

// Determine old and new values.

$old = null !== $old_flag ? $old_flag : array_shift( $args );

$new = null !== $new_flag ? $new_flag : array_shift( $args );

// Validate that both old and new values are provided and not empty.

if ( null === $old || null === $new || '' === $old ) {

$missing = array();

if ( null === $old || '' === $old ) {

$missing[] = '<old>';

}

// new value is allowed to be empty.

if ( null === $new ) {

$missing[] = '<new>';

}

$error_msg = count( $missing ) === 2

? 'Please provide both <old> and <new> arguments.'

: sprintf( 'Please provide the %s argument.', $missing[0] );

$error_msg .= "\n\nNote: If your search or replacement string starts with '--', use the flag syntax instead:"

. "\n wp search-replace --old='--text' --new='replacement'";

WP_CLI::error( $error_msg );

}

$total = 0;

$report = array();

$this->dry_run = Utils\get_flag_value( $assoc_args, 'dry-run', false );

$php_only = Utils\get_flag_value( $assoc_args, 'precise', false );

$this->recurse_objects = Utils\get_flag_value( $assoc_args, 'recurse-objects', true );

$this->verbose = Utils\get_flag_value( $assoc_args, 'verbose', false );

$this->format = Utils\get_flag_value( $assoc_args, 'format' );

$this->regex = Utils\get_flag_value( $assoc_args, 'regex', false );

$default_regex_delimiter = false;

if ( null !== $this->regex ) {

$this->regex_flags = Utils\get_flag_value( $assoc_args, 'regex-flags', false );

$this->regex_delimiter = Utils\get_flag_value( $assoc_args, 'regex-delimiter', '' );

if ( '' === $this->regex_delimiter ) {

$this->regex_delimiter = chr( 1 );

$default_regex_delimiter = true;

}

}

$regex_limit = Utils\get_flag_value( $assoc_args, 'regex-limit' );

if ( null !== $regex_limit ) {

if ( ! preg_match( '/^(?:[0-9]+|-1)$/', $regex_limit ) || 0 === (int) $regex_limit ) {

WP_CLI::error( '`--regex-limit` expects a non-zero positive integer or -1.' );

}

$this->regex_limit = (int) $regex_limit;

}

if ( ! empty( $this->regex ) ) {

if ( '' === $this->regex_delimiter ) {

$this->regex_delimiter = chr( 1 );

}

$search_regex = $this->regex_delimiter;

$search_regex .= $old;

$search_regex .= $this->regex_delimiter;

$search_regex .= $this->regex_flags;

// phpcs:ignore WordPress.PHP.NoSilencedErrors.Discouraged -- Preventing a warning when testing the regex.

if ( false === @preg_match( $search_regex, '' ) ) {

$error = error_get_last();

$preg_error_message = ! empty( $error ) ? "\n{$error['message']}." : '';

if ( $default_regex_delimiter ) {

$flags_msg = $this->regex_flags ? "flags '$this->regex_flags'" : 'no flags';

$msg = "The regex pattern '$old' with default delimiter 'chr(1)' and {$flags_msg} fails.";

} else {

$msg = "The regex '$search_regex' fails.";

}

WP_CLI::error( $msg . $preg_error_message );

}

}

$this->skip_columns = explode( ',', Utils\get_flag_value( $assoc_args, 'skip-columns', '' ) );

$this->skip_tables = explode( ',', Utils\get_flag_value( $assoc_args, 'skip-tables', '' ) );

$this->include_columns = array_filter( explode( ',', Utils\get_flag_value( $assoc_args, 'include-columns', '' ) ) );

if ( $old === $new && ! $this->regex ) {

WP_CLI::warning( "Replacement value '{$old}' is identical to search value '{$new}'. Skipping operation." );

exit;

}

$export = Utils\get_flag_value( $assoc_args, 'export' );

if ( null !== $export ) {

if ( $this->dry_run ) {

WP_CLI::error( 'You cannot supply --dry-run and --export at the same time.' );

}

if ( true === $export ) {

$this->export_handle = STDOUT;

$this->verbose = false;

} else {

$this->export_handle = @fopen( $export, 'w' );

if ( false === $this->export_handle ) {

$error = error_get_last();

WP_CLI::error( sprintf( 'Unable to open export file "%s" for writing: %s.', $export, $error['message'] ?? '(unknown error)' ) );

}

}

$export_insert_size = Utils\get_flag_value( $assoc_args, 'export_insert_size', 50 );

// phpcs:ignore Universal.Operators.StrictComparisons.LooseEqual -- See the code, this is deliberate.

if ( (int) $export_insert_size == $export_insert_size && $export_insert_size > 0 ) {

$this->export_insert_size = (int) $export_insert_size;

}

$php_only = true;

}

$log = Utils\get_flag_value( $assoc_args, 'log' );

if ( null !== $log ) {

if ( true === $log || '-' === $log ) {

$this->log_handle = STDOUT;

} else {

$this->log_handle = @fopen( $log, 'w' );

if ( false === $this->log_handle ) {

$error = error_get_last();

WP_CLI::error( sprintf( 'Unable to open log file "%s" for writing: %s.', $log, $error['message'] ?? '(unknown error)' ) );

}

}

$before_context = Utils\get_flag_value( $assoc_args, 'before_context' );

if ( null !== $before_context && preg_match( '/^[0-9]+$/', $before_context ) ) {

$this->log_before_context = (int) $before_context;

}

$after_context = Utils\get_flag_value( $assoc_args, 'after_context' );

if ( null !== $after_context && preg_match( '/^[0-9]+$/', $after_context ) ) {

$this->log_after_context = (int) $after_context;

}

$log_prefixes = getenv( 'WP_CLI_SEARCH_REPLACE_LOG_PREFIXES' );

if ( false !== $log_prefixes && preg_match( '/^([^,]*),([^,]*)$/', $log_prefixes, $matches ) ) {

$this->log_prefixes = array( $matches[1], $matches[2] );

}

if ( STDOUT === $this->log_handle ) {

$default_log_colors = array(

'log_table_column_id' => '%B',

'log_old' => '%R',

'log_new' => '%G',

);

} else {

$default_log_colors = array(

'log_table_column_id' => '',

'log_old' => '',

'log_new' => '',

);

}

$log_colors = getenv( 'WP_CLI_SEARCH_REPLACE_LOG_COLORS' );

if ( false !== $log_colors && preg_match( '/^([^,]*),([^,]*),([^,]*)$/', $log_colors, $matches ) ) {

$default_log_colors = array(

'log_table_column_id' => $matches[1],

'log_old' => $matches[2],

'log_new' => $matches[3],

);

}

$this->log_colors = $this->get_colors( $assoc_args, $default_log_colors );

$this->log_encoding = 0 === strpos( $wpdb->charset, 'utf8' ) ? 'UTF-8' : false;

}

$this->report = Utils\get_flag_value( $assoc_args, 'report', true );

// Defaults to true if logging, else defaults to false.

$this->report_changed_only = Utils\get_flag_value( $assoc_args, 'report-changed-only', null !== $this->log_handle );

if ( $this->regex_flags ) {

$php_only = true;

}

// never mess with hashed passwords

$this->skip_columns[] = 'user_pass';

// Get table names based on leftover $args or supplied $assoc_args

$tables = Utils\wp_get_table_names( $args, $assoc_args );

// Identify views so they can be skipped; views are dynamic and cannot be directly modified.

// The SQLite integration drop-in does not support SHOW FULL TABLES and WordPress

// on SQLite does not use views, so skip the views query entirely.

if ( 'sqlite' === Utils\get_db_type() ) {

$view_set = array();

} else {

$views_args = $assoc_args;

$views_args['views-only'] = true;

$views = Utils\wp_get_table_names( [], $views_args );

$view_set = array_flip( array_intersect( $views, $tables ) );

}

foreach ( $tables as $table ) {

foreach ( $this->skip_tables as $skip_table ) {

if ( fnmatch( $skip_table, $table ) ) {

continue 2;

}

}

if ( isset( $view_set[ $table ] ) ) {

if ( $this->report && ! $this->report_changed_only ) {

$report[] = array( $table, '', 'skipped (view)', '' );

}

continue;

}

$table_sql = self::esc_sql_ident( $table );

if ( $this->export_handle ) {

fwrite( $this->export_handle, "\nDROP TABLE IF EXISTS $table_sql;\n" );

// phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- escaped through self::esc_sql_ident

$row = $wpdb->get_row( "SHOW CREATE TABLE $table_sql", ARRAY_N );

fwrite( $this->export_handle, $row[1] . ";\n" );

list( $table_report, $total_rows ) = $this->php_export_table( $table, $old, $new );

if ( $this->report ) {

$report = array_merge( $report, $table_report );

}

$total += $total_rows;

// Don't perform replacements on the actual database

continue;

}

list( $primary_keys, $columns, $all_columns ) = self::get_columns( $table );

// since we'll be updating one row at a time,

// we need a primary key to identify the row

if ( empty( $primary_keys ) ) {

// wasn't updated, so skip to the next table

if ( $this->report_changed_only ) {

continue;

}

if ( $this->report ) {

$report[] = array( $table, '', 'skipped', '' );

} else {

WP_CLI::warning( $all_columns ? "No primary keys for table '$table'." : "No such table '$table'." );

}

continue;

}

foreach ( $columns as $col ) {

if ( ! empty( $this->include_columns ) && ! in_array( $col, $this->include_columns, true ) && ! in_array( $table . '.' . $col, $this->include_columns, true ) ) {

continue;

}

if ( in_array( $col, $this->skip_columns, true ) || in_array( $table . '.' . $col, $this->skip_columns, true ) ) {

continue;

}

if ( $this->verbose && 'count' !== $this->format ) {

$this->start_time = microtime( true );

WP_CLI::log( sprintf( 'Checking: %s.%s', $table, $col ) );

}

$serial_row = false;

if ( ! $php_only && ! $this->regex ) {

$col_sql = self::esc_sql_ident( $col );

$wpdb->last_error = '';

if ( 'sqlite' === Utils\get_db_type() ) {

// SQLite does not support REGEXP by default, fall back to PHP processing.

$serial_row = true;

} else {

// phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- escaped through self::esc_sql_ident

$serial_row = $wpdb->get_row( "SELECT * FROM $table_sql WHERE $col_sql REGEXP '^[aiO]:[1-9]' LIMIT 1" );

// When the regex triggers an error, we should fall back to PHP

if ( false !== strpos( $wpdb->last_error, 'ERROR 1139' ) ) {

$serial_row = true;

}

}

}

if ( $php_only || $this->regex || null !== $serial_row ) {

$type = 'PHP';

$count = $this->php_handle_col( $col, $primary_keys, $table, $old, $new );

} else {

$type = 'SQL';

$count = $this->sql_handle_col( $col, $primary_keys, $table, $old, $new );

}

if ( $this->report && ( $count || ! $this->report_changed_only ) ) {

$report[] = array( $table, $col, $count, $type );

}

$total += $count;

}

}

if ( $this->export_handle && STDOUT !== $this->export_handle ) {

fclose( $this->export_handle );

}

// Only informational output after this point

if ( WP_CLI::get_config( 'quiet' ) || STDOUT === $this->export_handle ) {

return;

}

if ( 'count' === $this->format ) {

WP_CLI::line( (string) $total );

return;

}

if ( $this->report && ! empty( $report ) ) {

$table = new Table();

$table->setHeaders( array( 'Table', 'Column', 'Replacements', 'Type' ) );

$table->setRows( $report );

$table->display();

}

if ( ! $this->dry_run ) {

if ( ! empty( $assoc_args['export'] ) ) {

$success_message = 1 === $total ? "Made 1 replacement and exported to {$assoc_args['export']}." : "Made {$total} replacements and exported to {$assoc_args['export']}.";

} else {

$success_message = 1 === $total ? 'Made 1 replacement.' : "Made $total replacements.";

if ( $total && 'Default' !== Utils\wp_get_cache_type() ) {

$success_message .= ' Please remember to flush your persistent object cache with `wp cache flush`.';

}

}

WP_CLI::success( $success_message );

} else {

$success_message = ( 1 === $total ) ? '%d replacement to be made.' : '%d replacements to be made.';

WP_CLI::success( sprintf( $success_message, $total ) );

}

}

private function php_export_table( $table, $old, $new ) {

list( $primary_keys, $columns, $all_columns ) = self::get_columns( $table );

$chunk_size = getenv( 'BEHAT_RUN' ) ? 10 : 1000;

$args = array(

'table' => $table,

'fields' => $all_columns,

'chunk_size' => $chunk_size,

);

$replacer = new SearchReplacer( $old, $new, $this->recurse_objects, $this->regex, $this->regex_flags, $this->regex_delimiter, false, $this->regex_limit );

$col_counts = array_fill_keys( $all_columns, 0 );

if ( $this->verbose && 'table' === $this->format ) {

$this->start_time = microtime( true );

WP_CLI::log( sprintf( 'Checking: %s', $table ) );

}

$rows = array();

foreach ( new Iterators\Table( $args ) as $i => $row ) {

$row_fields = array();

foreach ( $all_columns as $col ) {

$value = $row->$col;

if ( $value

&& ! in_array( $col, $primary_keys, true )

&& ! in_array( $col, $this->skip_columns, true )

&& ! in_array( $table . '.' . $col, $this->skip_columns, true )

&& ( empty( $this->include_columns ) || in_array( $col, $this->include_columns, true ) || in_array( $table . '.' . $col, $this->include_columns, true ) )

) {

$new_value = $replacer->run( $value );

if ( $new_value !== $value ) {

++$col_counts[ $col ];

$value = $new_value;

}

}

$row_fields[ $col ] = $value;

}

$rows[] = $row_fields;

}

$this->write_sql_row_fields( $table, $rows );

$table_report = array();

$total_rows = 0;

$total_cols = 0;

foreach ( $col_counts as $col => $col_count ) {

if ( $this->report && ( $col_count || ! $this->report_changed_only ) ) {

$table_report[] = array( $table, $col, $col_count, 'PHP' );

}

if ( $col_count ) {

++$total_cols;

$total_rows += $col_count;

}

}

if ( $this->verbose && 'table' === $this->format ) {

$time = round( microtime( true ) - $this->start_time, 3 );

WP_CLI::log( sprintf( '%d columns and %d total rows affected using PHP (in %ss).', $total_cols, $total_rows, $time ) );

}

return array( $table_report, $total_rows );

}

private function sql_handle_col( $col, $primary_keys, $table, $old, $new ) {

global $wpdb;

$table_sql = self::esc_sql_ident( $table );

$col_sql = self::esc_sql_ident( $col );

$old_json = self::json_encode_strip_quotes( $old );

$new_json = self::json_encode_strip_quotes( $new );

$has_json = $old_json !== $old;

if ( $this->dry_run ) {

if ( $this->log_handle ) {

$count = $this->log_sql_diff( $col, $primary_keys, $table, $old, $new );

if ( $has_json ) {

$count += $this->log_sql_diff( $col, $primary_keys, $table, $old_json, $new_json );

}

} elseif ( $has_json ) {

// Single query with OR to avoid counting rows that match both forms twice.

// phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- escaped through self::esc_sql_ident

$count = (int) $wpdb->get_var( $wpdb->prepare( "SELECT COUNT($col_sql) FROM $table_sql WHERE $col_sql LIKE BINARY %s OR $col_sql LIKE BINARY %s;", '%' . self::esc_like( $old ) . '%', '%' . self::esc_like( $old_json ) . '%' ) );

} else {

// phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- escaped through self::esc_sql_ident

$count = (int) $wpdb->get_var( $wpdb->prepare( "SELECT COUNT($col_sql) FROM $table_sql WHERE $col_sql LIKE BINARY %s;", '%' . self::esc_like( $old ) . '%' ) );

}

} else {

if ( $this->log_handle ) {

$this->log_sql_diff( $col, $primary_keys, $table, $old, $new );

if ( $has_json ) {

$this->log_sql_diff( $col, $primary_keys, $table, $old_json, $new_json );

}

}

if ( $has_json ) {

// Single nested REPLACE handles both plain and JSON-encoded forms in one pass.

// phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- escaped through self::esc_sql_ident

$count = (int) $wpdb->query( $wpdb->prepare( "UPDATE $table_sql SET $col_sql = REPLACE(REPLACE($col_sql, %s, %s), %s, %s);", $old, $new, $old_json, $new_json ) );

} else {

// phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- escaped through self::esc_sql_ident

$count = (int) $wpdb->query( $wpdb->prepare( "UPDATE $table_sql SET $col_sql = REPLACE($col_sql, %s, %s);", $old, $new ) );

}

if ( $wpdb->last_error ) {

WP_CLI::warning( sprintf( "Error updating column '%s' in table '%s': %s", $col, $table, $wpdb->last_error ) );

}

}

if ( $this->verbose && 'table' === $this->format ) {

$time = round( microtime( true ) - $this->start_time, 3 );

WP_CLI::log( sprintf( '%d rows affected using SQL (in %ss).', $count, $time ) );

}

return $count;

}

private function php_handle_col( $col, $primary_keys, $table, $old, $new ) {

global $wpdb;

$count = 0;

$replacer = new SearchReplacer( $old, $new, $this->recurse_objects, $this->regex, $this->regex_flags, $this->regex_delimiter, null !== $this->log_handle, $this->regex_limit );

$table_sql = self::esc_sql_ident( $table );

$col_sql = self::esc_sql_ident( $col );

$base_key_condition = '';

$where_key = '';

if ( ! $this->regex ) {

$old_json = self::json_encode_strip_quotes( $old );

$base_key_condition = "$col_sql" . $wpdb->prepare( ' LIKE BINARY %s', '%' . self::esc_like( $old ) . '%' );

if ( $old_json !== $old ) {

$base_key_condition = "( $base_key_condition OR $col_sql" . $wpdb->prepare( ' LIKE BINARY %s', '%' . self::esc_like( $old_json ) . '%' ) . ' )';

}

$where_key = "WHERE $base_key_condition";

}

$escaped_primary_keys = self::esc_sql_ident( $primary_keys );

$primary_keys_sql = implode( ',', $escaped_primary_keys );

$order_by_keys = array_map(

static function ( $key ) {

return "{$key} ASC";

},

$escaped_primary_keys

);

$order_by_sql = 'ORDER BY ' . implode( ',', $order_by_keys );

$limit = 1000;

// 2 errors:

// - WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- escaped through self::esc_sql_ident

// - WordPress.CodeAnalysis.AssignmentInCondition -- no reason to do copy-paste for a single valid assignment in while

// phpcs:ignore

while ( $rows = $wpdb->get_results( "SELECT {$primary_keys_sql} FROM {$table_sql} {$where_key} {$order_by_sql} LIMIT {$limit}" ) ) {

foreach ( $rows as $keys ) {

$where_sql = '';

foreach ( (array) $keys as $k => $v ) {

if ( '' !== $where_sql ) {

$where_sql .= ' AND ';

}

$where_sql .= self::esc_sql_ident( $k ) . ' = ' . self::esc_sql_value( $v );

}

// phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- escaped through self::esc_sql_ident

$col_value = $wpdb->get_var( "SELECT {$col_sql} FROM {$table_sql} WHERE {$where_sql}" );

if ( '' === $col_value ) {

continue;

}

$value = $replacer->run( $col_value );

if ( $value === $col_value ) {

continue;

}

// In case a needed re-serialization was unsuccessful, we should not update the value,

// as this implies we hit an exception while processing.

if ( gettype( $value ) !== gettype( $col_value ) ) {

continue;

}

if ( $this->log_handle ) {

$this->log_php_diff( $col, $keys, $table, $old, $new, $replacer->get_log_data() );

$replacer->clear_log_data();

}

// If we've already seen an update error for this table/column and are not in dry-run,

// skip further attempts to avoid repeated failures and noisy warnings.

if ( ! $this->dry_run && ! empty( $this->update_error_columns[ $table ][ $col ] ) ) {

continue;

}

if ( $this->dry_run ) {

// In dry-run mode, count replacements once a change has been detected.

++$count;

} else {

$update_where = array();

foreach ( (array) $keys as $k => $v ) {

$update_where[ $k ] = $v;

}

$result = $wpdb->update( $table, array( $col => $value ), $update_where );

if ( false === $result ) {

if ( empty( $this->update_error_columns[ $table ][ $col ] ) ) {

$this->update_error_columns[ $table ][ $col ] = true;

if ( $wpdb->last_error ) {

WP_CLI::warning( sprintf( "Error updating column '%s' in table '%s': %s", $col, $table, $wpdb->last_error ) );

} else {

WP_CLI::warning( sprintf( "Error updating column '%s' in table '%s'.", $col, $table ) );

}

}

continue;

}

// Only count successful updates.

++$count;

}

}

// Because we are ordering by primary keys from least to greatest,

// we can exclude previous chunks from consideration by adding greater-than conditions

// to insist the next chunk's keys must be greater than the last of this chunk's keys.

$last_row = end( $rows );

$next_key_conditions = array();

// NOTE: For a composite key (X, Y, Z), selecting the next rows requires the following conditions:

// ( X = lastX AND Y = lastY AND Z > lastZ ) OR

// ( X = lastX AND Y > lastY ) OR

// ( X > lastX )

for ( $last_key_index = count( $primary_keys ) - 1; $last_key_index >= 0; $last_key_index-- ) {

$next_key_subconditions = array();

for ( $i = 0; $i <= $last_key_index; $i++ ) {

$k = $primary_keys[ $i ];

$v = $last_row->{ $k };

if ( $i < $last_key_index ) {

$next_key_subconditions[] = self::esc_sql_ident( $k ) . ' = ' . self::esc_sql_value( $v );

} else {

$next_key_subconditions[] = self::esc_sql_ident( $k ) . ' > ' . self::esc_sql_value( $v );

}

}

$next_key_conditions[] = '( ' . implode( ' AND ', $next_key_subconditions ) . ' )';

}

$where_key_conditions = array();

if ( $base_key_condition ) {

$where_key_conditions[] = $base_key_condition;

}

$where_key_conditions[] = '( ' . implode( ' OR ', $next_key_conditions ) . ' )';

$where_key = 'WHERE ' . implode( ' AND ', $where_key_conditions );

}

if ( $this->verbose && 'table' === $this->format ) {

$time = round( microtime( true ) - $this->start_time, 3 );

WP_CLI::log( sprintf( '%d rows affected using PHP (in %ss).', $count, $time ) );

}

return $count;

}

private function write_sql_row_fields( $table, $rows ) {

global $wpdb;

if ( empty( $rows ) ) {

return;

}

$table_sql = self::esc_sql_ident( $table );

$insert = "INSERT INTO $table_sql (";

$insert .= join( ', ', self::esc_sql_ident( array_keys( $rows[0] ) ) );

$insert .= ') VALUES ';

$insert .= "\n";

$sql = $insert;

$values = array();

$index = 1;

$count = count( $rows );

$export_insert_size = $this->export_insert_size;

foreach ( $rows as $row_fields ) {

$subs = array();

foreach ( $row_fields as $field_value ) {

if ( null === $field_value ) {

$subs[] = 'NULL';

} else {

$subs[] = '%s';

$values[] = $field_value;

}

}

$sql .= '(' . join( ', ', $subs ) . ')';

// Add new insert statement if needed. Before this we close the previous with semicolon and write statement to sql-file.

// "Statement break" is needed:

// 1. When the loop is running every nth time (where n is insert statement size, $export_index_size). Remainder is zero also on first round, so it have to be excluded.

// $index % $export_insert_size == 0 && $index > 0

// 2. Or when the loop is running last time

// $index == $count

if ( ( 0 === $index % $export_insert_size && $index > 0 ) || $index === $count ) {

$sql .= ";\n";

if ( method_exists( $wpdb, 'remove_placeholder_escape' ) ) {

// since 4.8.3

// @phpstan-ignore method.nonObject

$sql = $wpdb->remove_placeholder_escape( $wpdb->prepare( $sql, array_values( $values ) ) ); // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared -- verified inputs above

} else {

// 4.8.2 or less

// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared -- verified inputs above

$sql = $wpdb->prepare( $sql, array_values( $values ) );

}

fwrite( $this->export_handle, $sql );

// If there is still rows to loop, reset $sql and $values variables.

if ( $count > $index ) {

$sql = $insert;

$values = array();

}

} else { // Otherwise just add comma and new line

$sql .= ",\n";

}

++$index;

}

}

private static function get_columns( $table ) {

global $wpdb;

$table_sql = self::esc_sql_ident( $table );

$primary_keys = array();

$text_columns = array();

$all_columns = array();

$suppress_errors = $wpdb->suppress_errors();

// phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- escaped through self::esc_sql_ident

$results = $wpdb->get_results( "DESCRIBE $table_sql" );

if ( ! empty( $results ) ) {

foreach ( $results as $col ) {

if ( 'PRI' === $col->Key ) {

$primary_keys[] = $col->Field;

}

if ( self::is_text_col( $col->Type ) ) {

$text_columns[] = $col->Field;

}

$all_columns[] = $col->Field;

}

}

$wpdb->suppress_errors( $suppress_errors );

return array( $primary_keys, $text_columns, $all_columns );

}

private static function is_text_col( $type ) {

foreach ( array( 'text', 'varchar' ) as $token ) {

if ( false !== stripos( $type, $token ) ) {

return true;

}

}

return false;

}

private static function esc_like( $old ) {

global $wpdb;