<h2>File Contents: /home/planet5/public_html/wp-content/plugins/wordpress-seo/lib/copy_of_orm.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/public_html/wp-content/plugins/wordpress-seo/lib/copy_of_orm.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php

namespace Yoast\WP\Lib;

use ArrayAccess;
use Exception;
use InvalidArgumentException;
use ReturnTypeWillChange;
use wpdb;
use Yoast\WP\SEO\Config\Migration_Status;

/**
 * Yoast ORM class.
 *
 * Based on Idiorm
 *
 * URL: http://github.com/j4mie/idiorm/
 *
 * A single-class super-simple database abstraction layer for PHP.
 * Provides (nearly) zero-configuration object-relational mapping
 * and a fluent interface for building basic, commonly-used queries.
 *
 * BSD Licensed.
 *
 * Copyright (c) 2010, Jamie Matthews
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * * Redistributions of source code must retain the above copyright notice, this
 *   list of conditions and the following disclaimer.
 *
 * * Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS &quot;AS IS&quot;
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * The methods documented below are magic methods that conform to PSR-1.
 * This documentation exposes these methods to doc generators and IDEs.
 *
 * @see http://www.php-fig.org/psr/psr-1/
 */
class ORM implements ArrayAccess {

	/*
	 * --- CLASS CONSTANTS ---
	 */

	public const CONDITION_FRAGMENT = 0;

	public const CONDITION_VALUES = 1;

	/*
	 * --- INSTANCE PROPERTIES ---
	 */

	/**
	 * Holds the class name. Wrapped find_one and find_many classes will return an instance or instances of this class.
	 *
	 * @var string
	 */
	protected $class_name;

	/**
	 * Holds the name of the table the current ORM instance is associated with.
	 *
	 * @var string
	 */
	protected $table_name;

	/**
	 * Holds the alias for the table to be used in SELECT queries.
	 *
	 * @var string|null
	 */
	protected $table_alias = null;

	/**
	 * Values to be bound to the query.
	 *
	 * @var array
	 */
	protected $values = [];

	/**
	 * Columns to select in the result.
	 *
	 * @var array
	 */
	protected $result_columns = [ &#039;*&#039; ];

	/**
	 * Are we using the default result column or have these been manually changed?
	 *
	 * @var bool
	 */
	protected $using_default_result_columns = true;

	/**
	 * Holds the join sources.
	 *
	 * @var array
	 */
	protected $join_sources = [];

	/**
	 * Should the query include a DISTINCT keyword?
	 *
	 * @var bool
	 */
	protected $distinct = false;

	/**
	 * Is this a raw query?
	 *
	 * @var bool
	 */
	protected $is_raw_query = false;

	/**
	 * The raw query.
	 *
	 * @var string
	 */
	protected $raw_query = &#039;&#039;;

	/**
	 * The raw query parameters.
	 *
	 * @var array
	 */
	protected $raw_parameters = [];

	/**
	 * Array of WHERE clauses.
	 *
	 * @var array
	 */
	protected $where_conditions = [];

	/**
	 * LIMIT.
	 *
	 * @var int|null
	 */
	protected $limit = null;

	/**
	 * OFFSET.
	 *
	 * @var int|null
	 */
	protected $offset = null;

	/**
	 * ORDER BY.
	 *
	 * @var array
	 */
	protected $order_by = [];

	/**
	 * GROUP BY.
	 *
	 * @var array
	 */
	protected $group_by = [];

	/**
	 * HAVING.
	 *
	 * @var array
	 */
	protected $having_conditions = [];

	/**
	 * The data for a hydrated instance of the class.
	 *
	 * @var array
	 */
	protected $data = [];

	/**
	 * Lifetime of the object.
	 *
	 * @var array
	 */
	protected $dirty_fields = [];

	/**
	 * Fields that are to be inserted in the DB raw.
	 *
	 * @var array
	 */
	protected $expr_fields = [];

	/**
	 * Is this a new object (has create() been called)?
	 *
	 * @var bool
	 */
	protected $is_new = false;

	/**
	 * Name of the column to use as the primary key for
	 * this instance only. Overrides the config settings.
	 *
	 * @var string|null
	 */
	protected $instance_id_column = null;

	/*
	 * --- STATIC METHODS ---
	 */

	/**
	 * Factory method, return an instance of this class bound to the supplied
	 * table name.
	 *
	 * A repeat of content in parent::for_table, so that created class is ORM.
	 *
	 * @param string $table_name The table to create instance for.
	 *
	 * @return ORM Instance of the ORM.
	 */
	public static function for_table( $table_name ) {
		return new static( $table_name, [] );
	}

	/**
	 * Executes a raw query as a wrapper for wpdb::query.
	 * Useful for queries that can&#039;t be accomplished through Idiorm,
	 * particularly those using engine-specific features.
	 *
	 * @example raw_execute(&#039;INSERT OR REPLACE INTO `widget` (`id`, `name`) SELECT `id`, `name` FROM `other_table`&#039;)
	 * @example raw_execute(&#039;SELECT `name`, AVG(`order`) FROM `customer` GROUP BY `name` HAVING AVG(`order`) &gt; 10&#039;)
	 *
	 * @param string $query      The raw SQL query.
	 * @param array  $parameters Optional bound parameters.
	 *
	 * @return bool Success.
	 */
	public static function raw_execute( $query, $parameters = [] ) {
		return self::execute( $query, $parameters );
	}

	/**
	 * Internal helper method for executing statements.
	 *
	 * @param string $query      The query.
	 * @param array  $parameters An array of parameters to be bound in to the query.
	 *
	 * @return bool|int Response of wpdb::query
	 */
	protected static function execute( $query, $parameters = [] ) {
		/**
		 * The global WordPress database variable.
		 *
		 * @var wpdb $wpdb
		 */
		global $wpdb;

		$show_errors = $wpdb-&gt;show_errors;

		if ( \YoastSEO()-&gt;classes-&gt;get( Migration_Status::class )-&gt;get_error( &#039;free&#039; ) ) {
			$wpdb-&gt;show_errors = false;
		}

		$parameters = \array_filter(
			$parameters,
			static function ( $parameter ) {
				return $parameter !== null;
			},
		);
		if ( ! empty( $parameters ) ) {
			$query = $wpdb-&gt;prepare( $query, $parameters );
		}

		$result = $wpdb-&gt;query( $query );

		$wpdb-&gt;show_errors = $show_errors;

		return $result;
	}

	/*
	 * --- INSTANCE METHODS ---
	 */

	/**
	 * &quot;Private&quot; constructor; shouldn&#039;t be called directly.
	 * Use the ORM::for_table factory method instead.
	 *
	 * @param string $table_name Table name.
	 * @param array  $data       Data to populate table.
	 */
	protected function __construct( $table_name, $data = [] ) {
		$this-&gt;table_name = $table_name;
		$this-&gt;data       = $data;
	}

	/**
	 * Sets the name of the class which the wrapped methods should return instances of.
	 *
	 * @param string $class_name The classname to set.
	 *
	 * @return void
	 */
	public function set_class_name( $class_name ) {
		$this-&gt;class_name = $class_name;
	}

	/**
	 * Creates a new, empty instance of the class. Used to add a new row to your database. May optionally be passed an
	 * associative array of data to populate the instance. If so, all fields will be flagged as dirty so all will be
	 * saved to the database when save() is called.
	 *
	 * @param array|null $data Data to populate table.
	 *
	 * @return bool|Model|ORM
	 */
	public function create( $data = null ) {
		$this-&gt;is_new = true;
		if ( $data !== null ) {
			$this-&gt;hydrate( $data )-&gt;force_all_dirty();
		}

		return $this-&gt;create_model_instance( $this );
	}

	/**
	 * Specifies the ID column to use for this instance or array of instances only.
	 * This overrides the id_column and id_column_overrides settings.
	 *
	 * This is mostly useful for libraries built on top of Idiorm, and will not normally be used in manually built
	 * queries. If you don&#039;t know why you would want to use this, you should probably just ignore it.
	 *
	 * @param string $id_column The ID column.
	 *
	 * @return ORM
	 */
	public function use_id_column( $id_column ) {
		$this-&gt;instance_id_column = $id_column;

		return $this;
	}

	/**
	 * Creates an ORM instance from the given row (an associative array of data fetched from the database).
	 *
	 * @param array $row A row from the database.
	 *
	 * @return bool|Model
	 */
	protected function create_instance_from_row( $row ) {
		$instance = self::for_table( $this-&gt;table_name );
		$instance-&gt;use_id_column( $this-&gt;instance_id_column );
		$instance-&gt;hydrate( $row );

		return $this-&gt;create_model_instance( $instance );
	}

	/**
	 * Tells the ORM that you are expecting a single result back from your query, and execute it. Will return a single
	 * instance of the ORM class, or false if no rows were returned. As a shortcut, you may supply an ID as a parameter
	 * to this method. This will perform a primary key lookup on the table.
	 *
	 * @param int|null $id An (optional) ID.
	 *
	 * @return bool|Model
	 */
	public function find_one( $id = null ) {
		if ( $id !== null ) {
			$this-&gt;where_id_is( $id );
		}
		$this-&gt;limit( 1 );
		$rows = $this-&gt;run();
		if ( empty( $rows ) ) {
			return false;
		}

		return $this-&gt;create_instance_from_row( $rows[0] );
	}

	/**
	 * Tells the ORM that you are expecting multiple results from your query, and execute it. Will return an array of
	 * instances of the ORM class, or an empty array if no rows were returned.
	 *
	 * @return array
	 */
	public function find_many() {
		$rows = $this-&gt;run();

		if ( $rows === false ) {
			return [];
		}

		return \array_map( [ $this, &#039;create_instance_from_row&#039; ], $rows );
	}

	/**
	 * Creates an instance of the model class associated with this wrapper and populate it with the supplied Idiorm
	 * instance.
	 *
	 * @param ORM $orm The ORM used by model.
	 *
	 * @return bool|Model Instance of the model class.
	 */
	protected function create_model_instance( $orm ) {
		if ( $orm === false ) {
			return false;
		}

		/**
		 * An instance of Model is being made.
		 *
		 * @var Model $model
		 */
		$model = new $this-&gt;class_name();
		$model-&gt;set_orm( $orm );

		return $model;
	}

	/**
	 * Tells the ORM that you are expecting multiple results from your query, and execute it. Will return an array, or
	 * an empty array if no rows were returned.
	 *
	 * @return array The query results.
	 */
	public function find_array() {
		return $this-&gt;run();
	}

	/**
	 * Tells the ORM that you wish to execute a COUNT query.
	 *
	 * @param string $column The table column.
	 *
	 * @return float|int An integer representing the number of rows returned.
	 */
	public function count( $column = &#039;*&#039; ) {
		return $this-&gt;call_aggregate_db_function( __FUNCTION__, $column );
	}

	/**
	 * Tells the ORM that you wish to execute a MAX query.
	 *
	 * @param string $column The table column.
	 *
	 * @return float|int The max value of the chosen column.
	 */
	public function max( $column ) {
		return $this-&gt;call_aggregate_db_function( __FUNCTION__, $column );
	}

	/**
	 * Tells the ORM that you wish to execute a MIN query.
	 *
	 * @param string $column The table column.
	 *
	 * @return float|int The min value of the chosen column.
	 */
	public function min( $column ) {
		return $this-&gt;call_aggregate_db_function( __FUNCTION__, $column );
	}

	/**
	 * Tells the ORM that you wish to execute a AVG query.
	 *
	 * @param string $column The table column.
	 *
	 * @return float|int The average value of the chosen column.
	 */
	public function avg( $column ) {
		return $this-&gt;call_aggregate_db_function( __FUNCTION__, $column );
	}

	/**
	 * Tells the ORM that you wish to execute a SUM query.
	 *
	 * @param string $column The table column.
	 *
	 * @return float|int The sum of the chosen column.
	 */
	public function sum( $column ) {
		return $this-&gt;call_aggregate_db_function( __FUNCTION__, $column );
	}

	/**
	 * Returns the select query as SQL.
	 *
	 * @return string The select query in SQL.
	 */
	public function get_sql() {
		return $this-&gt;build_select();
	}

	/**
	 * Returns the update query as SQL.
	 *
	 * @return string The update query in SQL.
	 */
	public function get_update_sql() {
		return $this-&gt;build_update();
	}

	/**
	 * Executes an aggregate query on the current connection.
	 *
	 * @param string $sql_function The aggregate function to call eg. MIN, COUNT, etc.
	 * @param string $column       The column to execute the aggregate query against.
	 *
	 * @return int
	 */
	protected function call_aggregate_db_function( $sql_function, $column ) {
		$alias        = \strtolower( $sql_function );
		$sql_function = \strtoupper( $sql_function );
		if ( $column !== &#039;*&#039; ) {
			$column = $this-&gt;quote_identifier( $column );
		}
		$result_columns       = $this-&gt;result_columns;
		$this-&gt;result_columns = [];
		$this-&gt;select_expr( &quot;{$sql_function}({$column})&quot;, $alias );
		$result               = $this-&gt;find_one();
		$this-&gt;result_columns = $result_columns;
		$return_value         = 0;
		if ( $result !== false &amp;&amp; isset( $result-&gt;{$alias} ) ) {
			if ( ! \is_numeric( $result-&gt;{$alias} ) ) {
				$return_value = $result-&gt;{$alias};
			}
			// phpcs:ignore Universal.Operators.StrictComparisons -- Reason: This loose comparison seems intentional.
			elseif ( (int) $result-&gt;{$alias} == (float) $result-&gt;{$alias} ) {
				$return_value = (int) $result-&gt;{$alias};
			}
			else {
				$return_value = (float) $result-&gt;{$alias};
			}
		}

		return $return_value;
	}

	/**
	 * Hydrates (populate) this instance of the class from an associative array of data. This will usually be called
	 * only from inside the class, but it&#039;s public in case you need to call it directly.
	 *
	 * @param array $data Data to populate table.
	 *
	 * @return ORM
	 */
	public function hydrate( $data = [] ) {
		$this-&gt;data = $data;

		return $this;
	}

	/**
	 * Forces the ORM to flag all the fields in the $data array as &quot;dirty&quot; and therefore update them when save() is
	 * called.
	 *
	 * @return ORM
	 */
	public function force_all_dirty() {
		$this-&gt;dirty_fields = $this-&gt;data;

		return $this;
	}

	/**
	 * Performs a raw query. The query can contain placeholders in either named or question mark style. If placeholders
	 * are used, the parameters should be an array of values which will be bound to the placeholders in the query.
	 * If this method is called, all other query building methods will be ignored.
	 *
	 * @param array $query      The query.
	 * @param array $parameters The parameters. Defaults to an empty array.
	 *
	 * @return ORM
	 */
	public function raw_query( $query, $parameters = [] ) {
		$this-&gt;is_raw_query   = true;
		$this-&gt;raw_query      = $query;
		$this-&gt;raw_parameters = $parameters;

		return $this;
	}

	/**
	 * Adds an alias for the main table to be used in SELECT queries.
	 *
	 * @param string $alias The alias.
	 *
	 * @return ORM
	 */
	public function table_alias( $alias ) {
		$this-&gt;table_alias = $alias;

		return $this;
	}

	/**
	 * Adds an unquoted expression to the set of columns returned by the SELECT query. Internal method.
	 *
	 * @param string      $expr  The expression.
	 * @param string|null $alias The alias to return the expression as. Defaults to null.
	 *
	 * @return ORM
	 */
	protected function add_result_column( $expr, $alias = null ) {
		if ( $alias !== null ) {
			$expr .= &#039; AS &#039; . $this-&gt;quote_identifier( $alias );
		}
		if ( $this-&gt;using_default_result_columns ) {
			$this-&gt;result_columns               = [ $expr ];
			$this-&gt;using_default_result_columns = false;
		}
		else {
			$this-&gt;result_columns[] = $expr;
		}

		return $this;
	}

	/**
	 * Counts the number of columns that belong to the primary key and their value is null.
	 *
	 * @return int The amount of null columns.
	 *
	 * @throws Exception Primary key ID contains null value(s).
	 * @throws Exception Primary key ID missing from row or is null.
	 */
	public function count_null_id_columns() {
		if ( \is_array( $this-&gt;get_id_column_name() ) ) {
			return \count( \array_filter( $this-&gt;id(), &#039;is_null&#039; ) );
		}
		else {
			return ( $this-&gt;id() === null ) ? 1 : 0;
		}
	}

	/**
	 * Adds a column to the list of columns returned by the SELECT query.
	 *
	 * @param string      $column The column. Defaults to &#039;*&#039;.
	 * @param string|null $alias  The alias to return the column as. Defaults to null.
	 *
	 * @return ORM
	 */
	public function select( $column, $alias = null ) {
		$column = $this-&gt;quote_identifier( $column );

		return $this-&gt;add_result_column( $column, $alias );
	}

	/**
	 * Adds an unquoted expression to the list of columns returned by the SELECT query.
	 *
	 * @param string      $expr  The expression.
	 * @param string|null $alias The alias to return the column as. Defaults to null.
	 *
	 * @return ORM
	 */
	public function select_expr( $expr, $alias = null ) {
		return $this-&gt;add_result_column( $expr, $alias );
	}

	/**
	 * Adds columns to the list of columns returned by the SELECT query.
	 *
	 * This defaults to &#039;*&#039;.
	 * Many columns can be supplied as either an array or as a list of parameters to the method.
	 * Note that the alias must not be numeric - if you want a numeric alias then prepend it with some alpha chars. eg.
	 * a1.
	 *
	 * @example select_many(array(&#039;column&#039;, &#039;column2&#039;, &#039;column3&#039;), &#039;column4&#039;, &#039;column5&#039;);
	 * @example select_many(array(&#039;alias&#039; =&gt; &#039;column&#039;, &#039;column2&#039;, &#039;alias2&#039; =&gt; &#039;column3&#039;), &#039;column4&#039;, &#039;column5&#039;);
	 * @example select_many(&#039;column&#039;, &#039;column2&#039;, &#039;column3&#039;);
	 *
	 * @return ORM
	 */
	public function select_many() {
		$columns = \func_get_args();
		if ( ! empty( $columns ) ) {
			$columns = $this-&gt;normalise_select_many_columns( $columns );
			foreach ( $columns as $alias =&gt; $column ) {
				if ( \is_numeric( $alias ) ) {
					$alias = null;
				}
				$this-&gt;select( $column, $alias );
			}
		}

		return $this;
	}

	/**
	 * Adds an unquoted expression to the list of columns returned by the SELECT query.
	 *
	 * Many columns can be supplied as either an array or as a list of parameters to the method.
	 * Note that the alias must not be numeric - if you want a numeric alias then prepend it with some alpha chars. eg.
	 * a1
	 *
	 * @example select_many_expr(array(&#039;alias&#039; =&gt; &#039;column&#039;, &#039;column2&#039;, &#039;alias2&#039; =&gt; &#039;column3&#039;), &#039;column4&#039;, &#039;column5&#039;)
	 * @example select_many_expr(&#039;column&#039;, &#039;column2&#039;, &#039;column3&#039;)
	 * @example select_many_expr(array(&#039;column&#039;, &#039;column2&#039;, &#039;column3&#039;), &#039;column4&#039;, &#039;column5&#039;)
	 *
	 * @return ORM
	 */
	public function select_many_expr() {
		$columns = \func_get_args();
		if ( ! empty( $columns ) ) {
			$columns = $this-&gt;normalise_select_many_columns( $columns );
			foreach ( $columns as $alias =&gt; $column ) {
				if ( \is_numeric( $alias ) ) {
					$alias = null;
				}
				$this-&gt;select_expr( $column, $alias );
			}
		}

		return $this;
	}

	/**
	 * Takes a column specification for the select many methods and convert it into a normalised array of columns and
	 * aliases.
	 *
	 * It is designed to turn the following styles into a normalised array:
	 * array(array(&#039;alias&#039; =&gt; &#039;column&#039;, &#039;column2&#039;, &#039;alias2&#039; =&gt; &#039;column3&#039;), &#039;column4&#039;, &#039;column5&#039;))
	 *
	 * @param array $columns The columns.
	 *
	 * @return array
	 */
	protected function normalise_select_many_columns( $columns ) {
		$return = [];
		foreach ( $columns as $column ) {
			if ( \is_array( $column ) ) {
				foreach ( $column as $key =&gt; $value ) {
					if ( ! \is_numeric( $key ) ) {
						$return[ $key ] = $value;
					}
					else {
						$return[] = $value;
					}
				}
			}
			else {
				$return[] = $column;
			}
		}

		return $return;
	}

	/**
	 * Adds a DISTINCT keyword before the list of columns in the SELECT query.
	 *
	 * @return ORM
	 */
	public function distinct() {
		$this-&gt;distinct = true;

		return $this;
	}

	/**
	 * Add a JOIN source to the query. Internal method.
	 *
	 * The join_operator should be one of INNER, LEFT OUTER, CROSS etc - this
	 * will be prepended to JOIN.
	 *
	 * The table should be the name of the table to join to.
	 *
	 * The constraint may be either a string or an array with three elements. If it
	 * is a string, it will be compiled into the query as-is, with no escaping. The
	 * recommended way to supply the constraint is as an array with three elements:
	 *
	 * first_column, operator, second_column
	 *
	 * Example: array(&#039;user.id&#039;, &#039;=&#039;, &#039;profile.user_id&#039;)
	 *
	 * will compile to
	 *
	 * ON `user`.`id` = `profile`.`user_id`
	 *
	 * The final (optional) argument specifies an alias for the joined table.
	 *
	 * @param string      $join_operator The join_operator should be one of INNER, LEFT OUTER, CROSS etc - this will be
	 *                                   prepended to JOIN.
	 * @param string      $table         The table should be the name of the table to join to.
	 * @param string      $constraint    The constraint.
	 * @param string|null $table_alias   The alias for the joined table. Defaults to null.
	 *
	 * @return ORM
	 */
	protected function add_join_source( $join_operator, $table, $constraint, $table_alias = null ) {
		$join_operator = \trim( &quot;{$join_operator} JOIN&quot; );
		$table         = $this-&gt;quote_identifier( $table );
		// Add table alias if present.
		if ( $table_alias !== null ) {
			$table_alias = $this-&gt;quote_identifier( $table_alias );
			$table      .= &quot; {$table_alias}&quot;;
		}
		// Build the constraint.
		if ( \is_array( $constraint ) ) {
			list( $first_column, $operator, $second_column ) = $constraint;

			$first_column  = $this-&gt;quote_identifier( $first_column );
			$second_column = $this-&gt;quote_identifier( $second_column );
			$constraint    = &quot;{$first_column} {$operator} {$second_column}&quot;;
		}
		$this-&gt;join_sources[] = &quot;{$join_operator} {$table} ON {$constraint}&quot;;

		return $this;
	}

	/**
	 * Adds a RAW JOIN source to the query.
	 *
	 * @param string $table       The table name.
	 * @param string $constraint  The constraint.
	 * @param string $table_alias The table alias.
	 * @param array  $parameters  The parameters. Defaults to an empty array.
	 *
	 * @return ORM
	 */
	public function raw_join( $table, $constraint, $table_alias, $parameters = [] ) {
		// Add table alias if present.
		if ( $table_alias !== null ) {
			$table_alias = $this-&gt;quote_identifier( $table_alias );
			$table      .= &quot; {$table_alias}&quot;;
		}
		$this-&gt;values = \array_merge( $this-&gt;values, $parameters );
		// Build the constraint.
		if ( \is_array( $constraint ) ) {
			list( $first_column, $operator, $second_column ) = $constraint;

			$first_column  = $this-&gt;quote_identifier( $first_column );
			$second_column = $this-&gt;quote_identifier( $second_column );
			$constraint    = &quot;{$first_column} {$operator} {$second_column}&quot;;
		}
		$this-&gt;join_sources[] = &quot;{$table} ON {$constraint}&quot;;

		return $this;
	}

	/**
	 * Adds a simple JOIN source to the query.
	 *
	 * @param string      $table       The table name.
	 * @param string      $constraint  The constraint.
	 * @param string|null $table_alias The table alias. Defaults to null.
	 *
	 * @return ORM
	 */
	public function join( $table, $constraint, $table_alias = null ) {
		return $this-&gt;add_join_source( &#039;&#039;, $table, $constraint, $table_alias );
	}

	/**
	 * Adds an INNER JOIN source to the query.
	 *
	 * @param string      $table       The table name.
	 * @param string      $constraint  The constraint.
	 * @param string|null $table_alias The table alias. Defaults to null.
	 *
	 * @return ORM
	 */
	public function inner_join( $table, $constraint, $table_alias = null ) {
		return $this-&gt;add_join_source( &#039;INNER&#039;, $table, $constraint, $table_alias );
	}

	/**
	 * Adds a LEFT OUTER JOIN source to the query.
	 *
	 * @param string      $table       The table name.
	 * @param string      $constraint  The constraint.
	 * @param string|null $table_alias The table alias. Defaults to null.
	 *
	 * @return ORM
	 */
	public function left_outer_join( $table, $constraint, $table_alias = null ) {
		return $this-&gt;add_join_source( &#039;LEFT OUTER&#039;, $table, $constraint, $table_alias );
	}

	/**
	 * Adds a RIGHT OUTER JOIN source to the query.
	 *
	 * @param string      $table       The table name.
	 * @param string      $constraint  The constraint.
	 * @param string|null $table_alias The table alias. Defaults to null.
	 *
	 * @return ORM
	 */
	public function right_outer_join( $table, $constraint, $table_alias = null ) {
		return $this-&gt;add_join_source( &#039;RIGHT OUTER&#039;, $table, $constraint, $table_alias );
	}

	/**
	 * Adds a FULL OUTER JOIN source to the query.
	 *
	 * @param string      $table       The table name.
	 * @param string      $constraint  The constraint.
	 * @param string|null $table_alias The table alias. Defaults to null.
	 *
	 * @return ORM
	 */
	public function full_outer_join( $table, $constraint, $table_alias = null ) {
		return $this-&gt;add_join_source( &#039;FULL OUTER&#039;, $table, $constraint, $table_alias );
	}

	/**
	 * Adds a HAVING condition to the query. Internal method.
	 *
	 * @param string $fragment The fragment.
	 * @param array  $values   The values. Defaults to an empty array.
	 *
	 * @return ORM
	 */
	protected function add_having( $fragment, $values = [] ) {
		return $this-&gt;add_condition( &#039;having&#039;, $fragment, $values );
	}

	/**
	 * Adds a HAVING condition to the query. Internal method.
	 *
	 * @param string $column_name The table column.
	 * @param string $separator   The separator.
	 * @param mixed  $value       The value.
	 *
	 * @return ORM
	 */
	protected function add_simple_having( $column_name, $separator, $value ) {
		return $this-&gt;add_simple_condition( &#039;having&#039;, $column_name, $separator, $value );
	}

	/**
	 * Adds a HAVING clause with multiple values (like IN and NOT IN). Internal method.
	 *
	 * @param string|array $column_name The table column.
	 * @param string       $separator   The separator.
	 * @param array        $values      The values.
	 *
	 * @return ORM
	 */
	public function add_having_placeholder( $column_name, $separator, $values ) {
		if ( ! \is_array( $column_name ) ) {
			$data = [ $column_name =&gt; $values ];
		}
		else {
			$data = $column_name;
		}
		$result = $this;
		foreach ( $data as $key =&gt; $val ) {
			$column       = $result-&gt;quote_identifier( $key );
			$placeholders = $result-&gt;create_placeholders( $val );
			$result       = $result-&gt;add_having( &quot;{$column} {$separator} ({$placeholders})&quot;, $val );
		}

		return $result;
	}

	/**
	 * Adds a HAVING clause with no parameters(like IS NULL and IS NOT NULL). Internal method.
	 *
	 * @param string $column_name The column name.
	 * @param string $operator    The operator.
	 *
	 * @return ORM
	 */
	public function add_having_no_value( $column_name, $operator ) {
		$conditions = \is_array( $column_name ) ? $column_name : [ $column_name ];
		$result     = $this;
		foreach ( $conditions as $column ) {
			$column = $this-&gt;quote_identifier( $column );
			$result = $result-&gt;add_having( &quot;{$column} {$operator}&quot; );
		}

		return $result;
	}

	/**
	 * Adds a WHERE condition to the query. Internal method.
	 *
	 * @param string $fragment The fragment.
	 * @param array  $values   The values. Defaults to an empty array.
	 *
	 * @return ORM
	 */
	protected function add_where( $fragment, $values = [] ) {
		return $this-&gt;add_condition( &#039;where&#039;, $fragment, $values );
	}

	/**
	 * Adds a WHERE condition to the query. Internal method.
	 *
	 * @param string|array $column_name The table column.
	 * @param string       $separator   The separator.
	 * @param mixed        $value       The value.
	 *
	 * @return ORM
	 */
	protected function add_simple_where( $column_name, $separator, $value ) {
		return $this-&gt;add_simple_condition( &#039;where&#039;, $column_name, $separator, $value );
	}

	/**
	 * Adds a WHERE clause with multiple values (like IN and NOT IN).
	 *
	 * @param string|array $column_name The table column.
	 * @param string       $separator   The separator.
	 * @param array        $values      The values.
	 *
	 * @return ORM
	 */
	public function add_where_placeholder( $column_name, $separator, $values ) {
		if ( ! \is_array( $column_name ) ) {
			$data = [ $column_name =&gt; $values ];
		}
		else {
			$data = $column_name;
		}
		$result = $this;
		foreach ( $data as $key =&gt; $val ) {
			$column       = $result-&gt;quote_identifier( $key );
			$placeholders = $result-&gt;create_placeholders( $val );
			$result       = $result-&gt;add_where( &quot;{$column} {$separator} ({$placeholders})&quot;, $val );
		}

		return $result;
	}

	/**
	 * Adds a WHERE clause with no parameters(like IS NULL and IS NOT NULL).
	 *
	 * @param string $column_name The column name.
	 * @param string $operator    The operator.
	 *
	 * @return ORM
	 */
	public function add_where_no_value( $column_name, $operator ) {
		$conditions = \is_array( $column_name ) ? $column_name : [ $column_name ];
		$result     = $this;
		foreach ( $conditions as $column ) {
			$column = $this-&gt;quote_identifier( $column );
			$result = $result-&gt;add_where( &quot;{$column} {$operator}&quot; );
		}

		return $result;
	}

	/**
	 * Adds a HAVING or WHERE condition to the query. Internal method.
	 *
	 * @param string $type     The type.
	 * @param string $fragment The fragment.
	 * @param array  $values   The values. Defaults to empty array.
	 *
	 * @return ORM
	 */
	protected function add_condition( $type, $fragment, $values = [] ) {
		$conditions_class_property_name = &quot;{$type}_conditions&quot;;
		if ( ! \is_array( $values ) ) {
			$values = [ $values ];
		}
		\array_push(
			$this-&gt;{$conditions_class_property_name},
			[
				self::CONDITION_FRAGMENT =&gt; $fragment,
				self::CONDITION_VALUES   =&gt; $values,
			],
		);

		return $this;
	}

	/**
	 * Compiles a simple COLUMN SEPARATOR VALUE style HAVING or WHERE condition into a string and value ready to be
	 * passed to the add_condition method.
	 *
	 * Avoids duplication of the call to quote_identifier.
	 * If column_name is an associative array, it will add a condition for each column.
	 *
	 * @param string       $type        The type.
	 * @param string|array $column_name The table column.
	 * @param string       $separator   The separator.
	 * @param mixed        $value       The value.
	 *
	 * @return ORM
	 */
	protected function add_simple_condition( $type, $column_name, $separator, $value ) {
		$multiple = \is_array( $column_name ) ? $column_name : [ $column_name =&gt; $value ];
		$result   = $this;
		foreach ( $multiple as $key =&gt; $val ) {
			// Add the table name in case of ambiguous columns.
			if ( \count( $result-&gt;join_sources ) &gt; 0 &amp;&amp; \strpos( $key, &#039;.&#039; ) === false ) {
				$table = $result-&gt;table_name;
				if ( $result-&gt;table_alias !== null ) {
					$table = $result-&gt;table_alias;
				}
				$key = &quot;{$table}.{$key}&quot;;
			}
			$key         = $result-&gt;quote_identifier( $key );
			$placeholder = ( $val === null ) ? &#039;NULL&#039; : &#039;%s&#039;;
			$result      = $result-&gt;add_condition( $type, &quot;{$key} {$separator} {$placeholder}&quot;, $val );
		}

		return $result;
	}

	/**
	 * Returns a string containing the given number of question marks, separated by commas. Eg &quot;?, ?, ?&quot;.
	 *
	 * @param array $fields Fields to create placeholder for.
	 *
	 * @return string
	 */
	protected function create_placeholders( $fields ) {
		if ( ! empty( $fields ) ) {
			$db_fields = [];
			foreach ( $fields as $key =&gt; $value ) {
				// Process expression fields directly into the query.
				if ( \array_key_exists( $key, $this-&gt;expr_fields ) ) {
					$db_fields[] = $value;
				}
				else {
					$db_fields[] = ( $value === null ) ? &#039;NULL&#039; : &#039;%s&#039;;
				}
			}

			return \implode( &#039;, &#039;, $db_fields );
		}

		return &#039;&#039;;
	}

	/**
	 * Filters a column/value array returning only those columns that belong to a compound primary key.
	 *
	 * If the key contains a column that does not exist in the given array, a null value will be returned for it.
	 *
	 * @param mixed $value The value.
	 *
	 * @return array
	 */
	protected function get_compound_id_column_values( $value ) {
		$filtered = [];
		foreach ( $this-&gt;get_id_column_name() as $key ) {
			$filtered[ $key ] = ( $value[ $key ] ?? null );
		}

		return $filtered;
	}

	/**
	 * Filters an array containing compound column/value arrays.
	 *
	 * @param array $values The values.
	 *
	 * @return array
	 */
	protected function get_compound_id_column_values_array( $values ) {
		$filtered = [];
		foreach ( $values as $value ) {
			$filtered[] = $this-&gt;get_compound_id_column_values( $value );
		}

		return $filtered;
	}

	/**
	 * Add a WHERE column = value clause to your query. Each time this is called in the chain, an additional WHERE will
	 * be added, and these will be ANDed together when the final query is built.
	 *
	 * If you use an array in $column_name, a new clause will be added for each element. In this case, $value is
	 * ignored.
	 *
	 * @param string|array $column_name The table column.
	 * @param mixed|null   $value       The value. Defaults to null.
	 *
	 * @return ORM
	 */
	public function where( $column_name, $value = null ) {
		return $this-&gt;where_equal( $column_name, $value );
	}

	/**
	 * More explicitly named version of for the where() method. Can be used if preferred.
	 *
	 * @param string|array $column_name The table column.
	 * @param mixed|null   $value       The value. Defaults to null.
	 *
	 * @return ORM
	 */
	public function where_equal( $column_name, $value = null ) {
		return $this-&gt;add_simple_where( $column_name, &#039;=&#039;, $value );
	}

	/**
	 * Add a WHERE column != value clause to your query.
	 *
	 * @param string|array $column_name The table column.
	 * @param mixed|null   $value       The value. Defaults to null.
	 *
	 * @return ORM
	 */
	public function where_not_equal( $column_name, $value = null ) {
		return $this-&gt;add_simple_where( $column_name, &#039;!=&#039;, $value );
	}

	/**
	 * Queries the table by its primary key. Special method.
	 *
	 * If primary key is compound, only the columns that belong to they key will be used for the query.
	 *
	 * @param string $id The ID.
	 *
	 * @return ORM
	 */
	public function where_id_is( $id ) {
		return \is_array( $this-&gt;get_id_column_name() ) ? $this-&gt;where( $this-&gt;get_compound_id_column_values( $id ), null ) : $this-&gt;where( $this-&gt;get_id_column_name(), $id );
	}

	/**
	 * Allows adding a WHERE clause that matches any of the conditions specified in the array. Each element in the
	 * associative array will be a different condition, where the key will be the column name.
	 *
	 * By default, an equal operator will be used against all columns, but it can be overriden for any or every column
	 * using the second parameter.
	 *
	 * Each condition will be ORed together when added to the final query.
	 *
	 * @param array  $values   The values.
	 * @param string $operator The operator.
	 *
	 * @return ORM
	 */
	public function where_any_is( $values, $operator = &#039;=&#039; ) {
		$data  = [];
		$query = [ &#039;((&#039; ];
		$first = true;
		foreach ( $values as $value ) {
			if ( $first ) {
				$first = false;
			}
			else {
				$query[] = &#039;) OR (&#039;;
			}
			$firstsub = true;
			foreach ( $value as $key =&gt; $item ) {
				$op = \is_string( $operator ) ? $operator : ( $operator[ $key ] ?? &#039;=&#039; );
				if ( $op === &#039;=&#039; &amp;&amp; $item === null ) {
					$op = &#039;IS&#039;;
				}
				if ( $firstsub ) {
					$firstsub = false;
				}
				else {
					$query[] = &#039;AND&#039;;
				}
				$query[] = $this-&gt;quote_identifier( $key );
				$data[]  = $item;
				$query[] = $op;
				$query[] = ( ( $item === null ) ? &#039;NULL&#039; : &#039;%s&#039; );
			}
		}
		$query[] = &#039;))&#039;;

		return $this-&gt;where_raw( \implode( &#039; &#039;, $query ), $data );
	}

	/**
	 * Queries the table by its primary key.
	 *
	 * Similar to where_id_is() but allowing multiple primary keys.
	 * If primary key is compound, only the columns that belong to they key will be used for the query.
	 *
	 * @param string[] $ids The IDs.
	 *
	 * @return ORM
	 */
	public function where_id_in( $ids ) {
		return \is_array( $this-&gt;get_id_column_name() ) ? $this-&gt;where_any_is( $this-&gt;get_compound_id_column_values_array( $ids ) ) : $this-&gt;where_in( $this-&gt;get_id_column_name(), $ids );
	}

	/**
	 * Adds a WHERE ... LIKE clause to your query.
	 *
	 * @param string|array $column_name The table column.
	 * @param mixed|null   $value       The value. Defaults to null.
	 *
	 * @return ORM
	 */
	public function where_like( $column_name, $value = null ) {
		return $this-&gt;add_simple_where( $column_name, &#039;LIKE&#039;, $value );
	}

	/**
	 * Adds where WHERE ... NOT LIKE clause to your query.
	 *
	 * @param string|array $column_name The table column.
	 * @param mixed|null   $value       The value. Defaults to null.
	 *
	 * @return ORM
	 */
	public function where_not_like( $column_name, $value = null ) {
		return $this-&gt;add_simple_where( $column_name, &#039;NOT LIKE&#039;, $value );
	}

	/**
	 * Adds a WHERE ... &gt; clause to your query.
	 *
	 * @param string|array $column_name The table column.
	 * @param mixed|null   $value       The value. Defaults to null.
	 *
	 * @return ORM
	 */
	public function where_gt( $column_name, $value = null ) {
		return $this-&gt;add_simple_where( $column_name, &#039;&gt;&#039;, $value );
	}

	/**
	 * Adds a WHERE ... &lt; clause to your query.
	 *
	 * @param string|array $column_name The table column.
	 * @param mixed|null   $value       The value. Defaults to null.
	 *
	 * @return ORM
	 */
	public function where_lt( $column_name, $value = null ) {
		return $this-&gt;add_simple_where( $column_name, &#039;&lt;&#039;, $value );
	}

	/**
	 * Adds a WHERE ... &gt;= clause to your query.
	 *
	 * @param string|array $column_name The table column.
	 * @param mixed|null   $value       The value. Defaults to null.
	 *
	 * @return ORM
	 */
	public function where_gte( $column_name, $value = null ) {
		return $this-&gt;add_simple_where( $column_name, &#039;&gt;=&#039;, $value );
	}

	/**
	 * Adds a WHERE ... &lt;= clause to your query.
	 *
	 * @param string|array $column_name The table column.
	 * @param mixed|null   $value       The value. Defaults to null.
	 *
	 * @return ORM
	 */
	public function where_lte( $column_name, $value = null ) {
		return $this-&gt;add_simple_where( $column_name, &#039;&lt;=&#039;, $value );
	}

	/**
	 * Adds a WHERE ... IN clause to your query.
	 *
	 * @param string|array $column_name The table column.
	 * @param array        $values      The values.
	 *
	 * @return ORM
	 */
	public function where_in( $column_name, $values ) {
		return $this-&gt;add_where_placeholder( $column_name, &#039;IN&#039;, $values );
	}

	/**
	 * Adds a WHERE ... NOT IN clause to your query.
	 *
	 * @param string|array $column_name The table column.
	 * @param array        $values      The values.
	 *
	 * @return ORM
	 */
	public function where_not_in( $column_name, $values ) {
		return $this-&gt;add_where_placeholder( $column_name, &#039;NOT IN&#039;, $values );
	}

	/**
	 * Adds a WHERE column IS NULL clause to your query.
	 *
	 * @param string|array $column_name The table column.
	 *
	 * @return ORM
	 */
	public function where_null( $column_name ) {
		return $this-&gt;add_where_no_value( $column_name, &#039;IS NULL&#039; );
	}

	/**
	 * Adds a WHERE column IS NOT NULL clause to your query.
	 *
	 * @param string|array $column_name The table column.
	 *
	 * @return ORM
	 */
	public function where_not_null( $column_name ) {
		return $this-&gt;add_where_no_value( $column_name, &#039;IS NOT NULL&#039; );
	}

	/**
	 * Adds a raw WHERE clause to the query. The clause should contain question mark placeholders, which will be bound
	 * to the parameters supplied in the second argument.
	 *
	 * @param string $clause     The clause that should contain question mark placeholders.
	 * @param array  $parameters The parameters to include in the query.
	 *
	 * @return ORM
	 */
	public function where_raw( $clause, $parameters = [] ) {
		return $this-&gt;add_where( $clause, $parameters );
	}

	/**
	 * Adds a LIMIT to the query.
	 *
	 * @param int $limit The limit.
	 *
	 * @return ORM
	 */
	public function limit( $limit ) {
		$this-&gt;limit = $limit;

		return $this;
	}

	/**
	 * Adds an OFFSET to the query.
	 *
	 * @param int $offset The offset.
	 *
	 * @return ORM
	 */
	public function offset( $offset ) {
		$this-&gt;offset = $offset;

		return $this;
	}

	/**
	 * Adds an ORDER BY clause to the query.
	 *
	 * @param string $column_name The column name.
	 * @param string $ordering    The ordering. DESC or ASC.
	 *
	 * @return ORM
	 */
	protected function add_order_by( $column_name, $ordering ) {
		$column_name      = $this-&gt;quote_identifier( $column_name );
		$this-&gt;order_by[] = &quot;{$column_name} {$ordering}&quot;;

		return $this;
	}

	/**
	 * Adds an ORDER BY column DESC clause.
	 *
	 * @param string|array $column_name The table column.
	 *
	 * @return ORM
	 */
	public function order_by_desc( $column_name ) {
		return $this-&gt;add_order_by( $column_name, &#039;DESC&#039; );
	}

	/**
	 * Adds an ORDER BY column ASC clause.
	 *
	 * @param string|array $column_name The table column.
	 *
	 * @return ORM
	 */
	public function order_by_asc( $column_name ) {
		return $this-&gt;add_order_by( $column_name, &#039;ASC&#039; );
	}

	/**
	 * Adds an unquoted expression as an ORDER BY clause.
	 *
	 * @param string $clause The clause.
	 *
	 * @return ORM
	 */
	public function order_by_expr( $clause ) {
		$this-&gt;order_by[] = $clause;

		return $this;
	}

	/**
	 * Adds a column to the list of columns to GROUP BY.
	 *
	 * @param string|array $column_name The table column.
	 *
	 * @return ORM
	 */
	public function group_by( $column_name ) {
		$column_name      = $this-&gt;quote_identifier( $column_name );
		$this-&gt;group_by[] = $column_name;

		return $this;
	}

	/**
	 * Adds an unquoted expression to the list of columns to GROUP BY.
	 *
	 * @param string $expr The expression.
	 *
	 * @return ORM
	 */
	public function group_by_expr( $expr ) {
		$this-&gt;group_by[] = $expr;

		return $this;
	}

	/**
	 * Adds a HAVING column = value clause to your query.
	 *
	 * Each time this is called in the chain, an additional HAVING will be added, and these will be ANDed together when
	 * the final query is built.
	 *
	 * If you use an array in $column_name, a new clause will be added for each element. In this case, $value is
	 * ignored.
	 *
	 * @param string|array $column_name The table column.
	 * @param mixed|null   $value       The value.
	 *
	 * @return ORM
	 */
	public function having( $column_name, $value = null ) {
		return $this-&gt;having_equal( $column_name, $value );
	}

	/**
	 * Adds a having equal to your query.
	 *
	 * More explicitly named version of for the having() method. Can be used if preferred.
	 *
	 * @param string|array $column_name The table column.
	 * @param mixed|null   $value       The value.
	 *
	 * @return ORM
	 */
	public function having_equal( $column_name, $value = null ) {
		return $this-&gt;add_simple_having( $column_name, &#039;=&#039;, $value );
	}

	/**
	 * Adds a HAVING column != value clause to your query.
	 *
	 * @param string|array $column_name The table column.
	 * @param mixed|null   $value       The value.
	 *
	 * @return ORM
	 */
	public function having_not_equal( $column_name, $value = null ) {
		return $this-&gt;add_simple_having( $column_name, &#039;!=&#039;, $value );
	}

	/**
	 * Queries the table by its primary key. Special method.
	 *
	 * If primary key is compound, only the columns that belong to they key will be used for the query.
	 *
	 * @param string $id The ID.
	 *
	 * @return ORM
	 */
	public function having_id_is( $id ) {
		return \is_array( $this-&gt;get_id_column_name() ) ? $this-&gt;having( $this-&gt;get_compound_id_column_values( $id ), null ) : $this-&gt;having( $this-&gt;get_id_column_name(), $id );
	}

	/**
	 * Adds a HAVING ... LIKE clause to your query.
	 *
	 * @param string|array $column_name The table column.
	 * @param string|null  $value       The value.
	 *
	 * @return ORM
	 */
	public function having_like( $column_name, $value = null ) {
		return $this-&gt;add_simple_having( $column_name, &#039;LIKE&#039;, $value );
	}

	/**
	 * Adds where HAVING ... NOT LIKE clause to your query.
	 *
	 * @param string|array $column_name The table column.
	 * @param string|null  $value       The value.
	 *
	 * @return ORM
	 */
	public function having_not_like( $column_name, $value = null ) {
		return $this-&gt;add_simple_having( $column_name, &#039;NOT LIKE&#039;, $value );
	}

	/**
	 * Adds a HAVING ... &gt; clause to your query.
	 *
	 * @param string|array $column_name The table column.
	 * @param mixed        $value       The value.
	 *
	 * @return ORM
	 */
	public function having_gt( $column_name, $value = null ) {
		return $this-&gt;add_simple_having( $column_name, &#039;&gt;&#039;, $value );
	}

	/**
	 * Adds a HAVING ... &lt; clause to your query.
	 *
	 * @param string|array $column_name The table column.
	 * @param mixed        $value       The value.
	 *
	 * @return ORM
	 */
	public function having_lt( $column_name, $value = null ) {
		return $this-&gt;add_simple_having( $column_name, &#039;&lt;&#039;, $value );
	}

	/**
	 * Adds a HAVING ... &gt;= clause to your query.
	 *
	 * @param string|array $column_name The table column.
	 * @param mixed        $value       The value. Defaults to null.
	 *
	 * @return ORM
	 */
	public function having_gte( $column_name, $value = null ) {
		return $this-&gt;add_simple_having( $column_name, &#039;&gt;=&#039;, $value );
	}

	/**
	 * Adds a HAVING ... &lt;= clause to your query.
	 *
	 * @param string|array $column_name The table column.
	 * @param mixed        $value       The value.
	 *
	 * @return ORM
	 */
	public function having_lte( $column_name, $value = null ) {
		return $this-&gt;add_simple_having( $column_name, &#039;&lt;=&#039;, $value );
	}

	/**
	 * Adds a HAVING ... IN clause to your query.
	 *
	 * @param string|array $column_name The table column.
	 * @param array|null   $values      The values. Defaults to null.
	 *
	 * @return ORM
	 */
	public function having_in( $column_name, $values = null ) {
		return $this-&gt;add_having_placeholder( $column_name, &#039;IN&#039;, $values );
	}

	/**
	 * Adds a HAVING ... NOT IN clause to your query.
	 *
	 * @param string|array $column_name The table column.
	 * @param array|null   $values      The values. Defaults to null.
	 *
	 * @return ORM
	 */
	public function having_not_in( $column_name, $values = null ) {
		return $this-&gt;add_having_placeholder( $column_name, &#039;NOT IN&#039;, $values );
	}

	/**
	 * Adds a HAVING column IS NULL clause to your query.
	 *
	 * @param string|array $column_name The table column.
	 *
	 * @return ORM
	 */
	public function having_null( $column_name ) {
		return $this-&gt;add_having_no_value( $column_name, &#039;IS NULL&#039; );
	}

	/**
	 * Adds a HAVING column IS NOT NULL clause to your query.
	 *
	 * @param string|array $column_name The table column.
	 *
	 * @return ORM
	 */
	public function having_not_null( $column_name ) {
		return $this-&gt;add_having_no_value( $column_name, &#039;IS NOT NULL&#039; );
	}

	/**
	 * Adds a raw HAVING clause to the query. The clause should contain question mark placeholders, which will be bound
	 * to the parameters supplied in the second argument.
	 *
	 * @param string $clause     The clause that should contain question mark placeholders.
	 * @param array  $parameters The parameters to include in the query.
	 *
	 * @return ORM
	 */
	public function having_raw( $clause, $parameters = [] ) {
		return $this-&gt;add_having( $clause, $parameters );
	}

	/**
	 * Builds a SELECT statement based on the clauses that have been passed to this instance by chaining method calls.
	 *
	 * @return string
	 */
	protected function build_select() {
		// If the query is raw, just set the $this-&gt;values to be the raw query parameters and return the raw query.
		if ( $this-&gt;is_raw_query ) {
			$this-&gt;values = $this-&gt;raw_parameters;

			return $this-&gt;raw_query;
		}

		// Build and return the full SELECT statement by concatenating the results of calling each separate builder method.
		return $this-&gt;join_if_not_empty(
			&#039; &#039;,
			[
				$this-&gt;build_select_start(),
				$this-&gt;build_join(),
				$this-&gt;build_where(),
				$this-&gt;build_group_by(),
				$this-&gt;build_having(),
				$this-&gt;build_order_by(),
				$this-&gt;build_limit(),
				$this-&gt;build_offset(),
			],
		);
	}

	/**
	 * Builds the start of the SELECT statement.
	 *
	 * @return string
	 */
	protected function build_select_start() {
		$fragment       = &#039;SELECT &#039;;
		$result_columns = \implode( &#039;, &#039;, $this-&gt;result_columns );
		if ( $this-&gt;distinct ) {
			$result_columns = &#039;DISTINCT &#039; . $result_columns;
		}
		$fragment .= &quot;{$result_columns} FROM &quot; . $this-&gt;quote_identifier( $this-&gt;table_name );
		if ( $this-&gt;table_alias !== null ) {
			$fragment .= &#039; &#039; . $this-&gt;quote_identifier( $this-&gt;table_alias );
		}

		return $fragment;
	}

	/**
	 * Builds the JOIN sources.
	 *
	 * @return string
	 */
	protected function build_join() {
		if ( \count( $this-&gt;join_sources ) === 0 ) {
			return &#039;&#039;;
		}

		return \implode( &#039; &#039;, $this-&gt;join_sources );
	}

	/**
	 * Builds the WHERE clause(s).
	 *
	 * @return string
	 */
	protected function build_where() {
		return $this-&gt;build_conditions( &#039;where&#039; );
	}

	/**
	 * Build the HAVING clause(s)
	 *
	 * @return string
	 */
	protected function build_having() {
		return $this-&gt;build_conditions( &#039;having&#039; );
	}

	/**
	 * Builds GROUP BY.
	 *
	 * @return string
	 */
	protected function build_group_by() {
		if ( \count( $this-&gt;group_by ) === 0 ) {
			return &#039;&#039;;
		}

		return &#039;GROUP BY &#039; . \implode( &#039;, &#039;, $this-&gt;group_by );
	}

	/**
	 * Builds a WHERE or HAVING clause.
	 *
	 * @param string $type Where or having.
	 *
	 * @return string
	 */
	protected function build_conditions( $type ) {
		$conditions_class_property_name = &quot;{$type}_conditions&quot;;
		// If there are no clauses, return empty string.
		if ( \count( $this-&gt;{$conditions_class_property_name} ) === 0 ) {
			return &#039;&#039;;
		}
		$conditions = [];
		foreach ( $this-&gt;{$conditions_class_property_name} as $condition ) {
			$conditions[] = $condition[ self::CONDITION_FRAGMENT ];
			$this-&gt;values = \array_merge( $this-&gt;values, $condition[ self::CONDITION_VALUES ] );
		}

		return \strtoupper( $type ) . &#039; &#039; . \implode( &#039; AND &#039;, $conditions );
	}

	/**
	 * Builds ORDER BY.
	 *
	 * @return string
	 */
	protected function build_order_by() {
		if ( \count( $this-&gt;order_by ) === 0 ) {
			return &#039;&#039;;
		}

		return &#039;ORDER BY &#039; . \implode( &#039;, &#039;, $this-&gt;order_by );
	}

	/**
	 * Builds LIMIT.
	 *
	 * @return string
	 */
	protected function build_limit() {
		if ( $this-&gt;limit !== null ) {
			return &quot;LIMIT {$this-&gt;limit}&quot;;
		}

		return &#039;&#039;;
	}

	/**
	 * Builds OFFSET.
	 *
	 * @return string
	 */
	protected function build_offset() {
		if ( $this-&gt;offset !== null ) {
			return &#039;OFFSET &#039; . $this-&gt;offset;
		}

		return &#039;&#039;;
	}

	/**
	 * Joins strings if they are not empty.
	 *
	 * @param string   $glue   Glue.
	 * @param string[] $pieces Pieces to join.
	 *
	 * @return string
	 */
	protected function join_if_not_empty( $glue, $pieces ) {
		$filtered_pieces = [];
		foreach ( $pieces as $piece ) {
			if ( \is_string( $piece ) ) {
				$piece = \trim( $piece );
			}
			if ( ! empty( $piece ) ) {
				$filtered_pieces[] = $piece;
			}
		}

		return \implode( $glue, $filtered_pieces );
	}

	/**
	 * Quotes a string that is used as an identifier (table names, column names etc).
	 * This method can also deal with dot-separated identifiers eg table.column.
	 *
	 * @param string|string[] $identifier One or more identifiers.
	 *
	 * @return string
	 */
	protected function quote_one_identifier( $identifier ) {
		$parts = \explode( &#039;.&#039;, $identifier );
		$parts = \array_map( [ $this, &#039;quote_identifier_part&#039; ], $parts );

		return \implode( &#039;.&#039;, $parts );
	}

	/**
	 * Quotes a string that is used as an identifier (table names, column names etc) or an array containing multiple
	 * identifiers. This method can also deal with dot-separated identifiers eg table.column.
	 *
	 * @param string|string[] $identifier One or more identifiers.
	 *
	 * @return string
	 */
	protected function quote_identifier( $identifier ) {
		if ( \is_array( $identifier ) ) {
			$result = \array_map( [ $this, &#039;quote_one_identifier&#039; ], $identifier );

			return \implode( &#039;, &#039;, $result );
		}
		else {
			return $this-&gt;quote_one_identifier( $identifier );
		}
	}

	/**
	 * Quotes a single part of an identifier, using the identifier quote character specified in the config
	 * (or autodetected).
	 *
	 * @param string $part The part to quote.
	 *
	 * @return string
	 */
	protected function quote_identifier_part( $part ) {
		if ( $part === &#039;*&#039; ) {
			return $part;
		}
		$quote_character = &#039;`&#039;;

		// Double up any identifier quotes to escape them.
		return $quote_character . \str_replace( $quote_character, $quote_character . $quote_character, $part ) . $quote_character;
	}

	/**
	 * Executes the SELECT query that has been built up by chaining methods on this class.
	 * Return an array of rows as associative arrays.
	 *
	 * @return array|false The result rows. False if the query failed.
	 */
	protected function run() {
		global $wpdb;

		$query   = $this-&gt;build_select();
		$success = self::execute( $query, $this-&gt;values );

		if ( $success === false ) {
			// If the query fails run the migrations and try again.
			// Action is intentionally undocumented and should not be used by third-parties.
			\do_action( &#039;_yoast_run_migrations&#039; );
			$success = self::execute( $query, $this-&gt;values );
		}

		$this-&gt;reset_idiorm_state();

		if ( $success === false ) {
			return false;
		}

		$rows = [];
		foreach ( $wpdb-&gt;last_result as $row ) {
			$rows[] = \get_object_vars( $row );
		}

		return $rows;
	}

	/**
	 * Resets the Idiorm instance state.
	 *
	 * @return void
	 */
	private function reset_idiorm_state() {
		$this-&gt;values                       = [];
		$this-&gt;result_columns               = [ &#039;*&#039; ];
		$this-&gt;using_default_result_columns = true;
	}

	/**
	 * Returns the raw data wrapped by this ORM instance as an associative array. Column names may optionally be
	 * supplied as arguments, if so, only those keys will be returned.
	 *
	 * @return array Associative array of the raw data.
	 */
	public function as_array() {
		if ( \func_num_args() === 0 ) {
			return $this-&gt;data;
		}
		$args = \func_get_args();

		return \array_intersect_key( $this-&gt;data, \array_flip( $args ) );
	}

	/**
	 * Returns the value of a property of this object (database row) or null if not present.
	 *
	 * If a column-names array is passed, it will return a associative array with the value of each column or null if
	 * it is not present.
	 *
	 * @param string|array $key Key.
	 *
	 * @return array|mixed|null
	 */
	public function get( $key ) {
		if ( \is_array( $key ) ) {
			$result = [];
			foreach ( $key as $column ) {
				$result[ $column ] = ( $this-&gt;data[ $column ] ?? null );
			}

			return $result;
		}
		else {
			return ( $this-&gt;data[ $key ] ?? null );
		}
	}

	/**
	 * Returns the name of the column in the database table which contains the primary key ID of the row.
	 *
	 * @return string The primary key ID of the row.
	 */
	protected function get_id_column_name() {
		if ( $this-&gt;instance_id_column !== null ) {
			return $this-&gt;instance_id_column;
		}

		return &#039;id&#039;;
	}

	/**
	 * Gets the primary key ID of this object.
	 *
	 * @param bool $disallow_null Whether to allow null IDs.
	 *
	 * @return array|mixed|null
	 *
	 * @throws Exception Primary key ID contains null value(s).
	 * @throws Exception Primary key ID missing from row or is null.
	 */
	public function id( $disallow_null = false ) {
		$id = $this-&gt;get( $this-&gt;get_id_column_name() );
		if ( $disallow_null ) {
			if ( \is_array( $id ) ) {
				foreach ( $id as $id_part ) {
					if ( $id_part === null ) {
						throw new Exception( &#039;Primary key ID contains null value(s)&#039; );
					}
				}
			}
			elseif ( $id === null ) {
				throw new Exception( &#039;Primary key ID missing from row or is null&#039; );
			}
		}

		return $id;
	}

	/**
	 * Sets a property to a particular value on this object.
	 *
	 * To set multiple properties at once, pass an associative array as the first parameter and leave out the second
	 * parameter. Flags the properties as &#039;dirty&#039; so they will be saved to the database when save() is called.
	 *
	 * @param string|array $key   Key.
	 * @param string|null  $value Value.
	 *
	 * @return ORM
	 */
	public function set( $key, $value = null ) {
		return $this-&gt;set_orm_property( $key, $value );
	}

	/**
	 * Set a property to a particular value on this object as expression.
	 *
	 * To set multiple properties at once, pass an associative array as the first parameter and leave out the second
	 * parameter. Flags the properties as &#039;dirty&#039; so they will be saved to the database when save() is called.
	 *
	 * @param string|array $key   Key.
	 * @param string|null  $value Value.
	 *
	 * @return ORM
	 */
	public function set_expr( $key, $value = null ) {
		return $this-&gt;set_orm_property( $key, $value, true );
	}

	/**
	 * Sets a property on the ORM object.
	 *
	 * @param string|array $key   Key.
	 * @param string|null  $value Value.
	 * @param bool         $expr  Expression.
	 *
	 * @return ORM
	 */
	protected function set_orm_property( $key, $value = null, $expr = false ) {
		if ( ! \is_array( $key ) ) {
			$key = [ $key =&gt; $value ];
		}
		foreach ( $key as $field =&gt; $value ) {
			$this-&gt;data[ $field ]         = $value;
			$this-&gt;dirty_fields[ $field ] = $value;
			if ( $expr === false &amp;&amp; isset( $this-&gt;expr_fields[ $field ] ) ) {
				unset( $this-&gt;expr_fields[ $field ] );
			}
			elseif ( $expr === true ) {
				$this-&gt;expr_fields[ $field ] = true;
			}
		}

		return $this;
	}

	/**
	 * Checks whether the given field has been changed since this object was saved.
	 *
	 * @param mixed $key Key.
	 *
	 * @return bool
	 */
	public function is_dirty( $key ) {
		return \array_key_exists( $key, $this-&gt;dirty_fields );
	}

	/**
	 * Checks whether the model was the result of a call to create() or not.
	 *
	 * @return bool
	 */
	public function is_new() {
		return $this-&gt;is_new;
	}

	/**
	 * Saves any fields which have been modified on this object to the database.
	 *
	 * @return bool True on success.
	 *
	 * @throws Exception Primary key ID contains null value(s).
	 * @throws Exception Primary key ID missing from row or is null.
	 */
	public function save() {
		global $wpdb;

		// Remove any expression fields as they are already baked into the query.
		$values = \array_values( \array_diff_key( $this-&gt;dirty_fields, $this-&gt;expr_fields ) );
		if ( ! $this-&gt;is_new ) {
			// UPDATE.
			// If there are no dirty values, do nothing.
			if ( empty( $values ) &amp;&amp; empty( $this-&gt;expr_fields ) ) {
				return true;
			}
			$query = \implode( &#039; &#039;, [ $this-&gt;build_update(), $this-&gt;add_id_column_conditions() ] );

			$id = $this-&gt;id( true );
			if ( \is_array( $id ) ) {
				$values = \array_merge( $values, \array_values( $id ) );
			}
			else {
				$values[] = $id;
			}
		}
		else {
			// INSERT.
			$query = $this-&gt;build_insert();
		}
		$success = self::execute( $query, $values );
		// If we&#039;ve just inserted a new record, set the ID of this object.
		if ( $this-&gt;is_new ) {
			$this-&gt;is_new = false;
			if ( $this-&gt;count_null_id_columns() !== 0 ) {
				$column = $this-&gt;get_id_column_name();
				// If the primary key is compound, assign the last inserted id to the first column.
				if ( \is_array( $column ) ) {
					$column = \reset( $column );
				}
				// Explicitly cast to int to make dealing with Id&#039;s simpler.
				$this-&gt;data[ $column ] = (int) $wpdb-&gt;insert_id;
			}
		}
		$this-&gt;dirty_fields = [];
		$this-&gt;expr_fields  = [];

		return $success;
	}

	/**
	 * Extracts and gathers all dirty column names from the given model instances.
	 *
	 * @param array $models Array of model instances to be inserted.
	 *
	 * @return array The distinct set of columns that are dirty in at least one of the models.
	 *
	 * @throws InvalidArgumentException Instance to be inserted is not a new one.
	 */
	public function get_dirty_column_names( $models ) {
		$dirty_column_names = [];

		foreach ( $models as $model ) {
			if ( ! $model-&gt;orm-&gt;is_new() ) {
				throw new InvalidArgumentException( &#039;Instance to be inserted is not a new one&#039; );
			}

			// Remove any expression fields as they are already baked into the query.
			$dirty_fields       = \array_diff_key( $model-&gt;orm-&gt;dirty_fields, $model-&gt;orm-&gt;expr_fields );
			$dirty_column_names = \array_merge( $dirty_column_names, $dirty_fields );
		}

		$dirty_column_names = \array_keys( $dirty_column_names );

		return $dirty_column_names;
	}

	/**
	 * Inserts multiple rows in a single query. Expects new rows as it&#039;s a strictly insert function, not an update one.
	 *
	 * @example From the Indexable_Link_Builder class: $this-&gt;seo_links_repository-&gt;query()-&gt;insert_many( $links );
	 *
	 * @param array $models Array of model instances to be inserted.
	 *
	 * @return bool True for successful insert, false for failed.
	 *
	 * @throws InvalidArgumentException Invalid instances to be inserted.
	 * @throws InvalidArgumentException Instance to be inserted is not a new one.
	 */
	public function insert_many( $models ) {
		// Validate the input first.
		if ( ! \is_array( $models ) ) {
			throw new InvalidArgumentException( &#039;Invalid instances to be inserted&#039; );
		}

		if ( empty( $models ) ) {
			return true;
		}

		$success = true;

		/**
		 * Filter: &#039;wpseo_chunk_bulked_insert_queries&#039; - Allow filtering the chunk size of each bulked INSERT query.
		 *
		 * @param int $chunk_size The chunk size of the bulked INSERT queries.
		 */
		$chunk = \apply_filters( &#039;wpseo_chunk_bulk_insert_queries&#039;, 100 );
		$chunk = ! \is_int( $chunk ) ? 100 : $chunk;
		$chunk = ( $chunk &lt;= 0 ) ? 100 : $chunk;

		$chunked_models = \array_chunk( $models, $chunk );
		foreach ( $chunked_models as $models_chunk ) {
			$values = [];

			// First, we&#039;ll gather all the dirty fields throughout the models to be inserted.
			$dirty_column_names = $this-&gt;get_dirty_column_names( $models_chunk );

			// Now, we&#039;re creating all dirty fields throughout the models and
			// setting them to null if they don&#039;t exist in each model.
			foreach ( $models_chunk as $model ) {
				$model_values = [];

				foreach ( $dirty_column_names as $dirty_column ) {
					// Set the value to null if it hasn&#039;t been set already.
					if ( ! isset( $model-&gt;orm-&gt;dirty_fields[ $dirty_column ] ) ) {
						$model-&gt;orm-&gt;dirty_fields[ $dirty_column ] = null;
					}

					// Only register the value if it is not null.
					if ( $model-&gt;orm-&gt;dirty_fields[ $dirty_column ] !== null ) {
						$model_values[] = $model-&gt;orm-&gt;dirty_fields[ $dirty_column ];
					}
				}
				$values = \array_merge( $values, $model_values );
			}

			// We now have the same set of dirty columns in all our models and also gathered all values.
			$query   = $this-&gt;build_insert_many( $models_chunk, $dirty_column_names );
			$success = $success &amp;&amp; (bool) self::execute( $query, $values );
		}

		return $success;
	}

	/**
	 * Updates many records in the database.
	 *
	 * @return int|bool The number of rows changed if the query was succesful. False otherwise.
	 */
	public function update_many() {
		// Remove any expression fields as they are already baked into the query.
		$values = \array_values( \array_diff_key( $this-&gt;dirty_fields, $this-&gt;expr_fields ) );

		// UPDATE.
		// If there are no dirty values, do nothing.
		if ( empty( $values ) &amp;&amp; empty( $this-&gt;expr_fields ) ) {
			return true;
		}

		$query = $this-&gt;join_if_not_empty( &#039; &#039;, [ $this-&gt;build_update(), $this-&gt;build_where() ] );

		$success            = self::execute( $query, \array_merge( $values, $this-&gt;values ) );
		$this-&gt;dirty_fields = [];
		$this-&gt;expr_fields  = [];

		return $success;
	}

	/**
	 * Adds a WHERE clause for every column that belongs to the primary key.
	 *
	 * @return string The where part of the query.
	 */
	public function add_id_column_conditions() {
		$query   = [];
		$query[] = &#039;WHERE&#039;;
		$keys    = \is_array( $this-&gt;get_id_column_name() ) ? $this-&gt;get_id_column_name() : [ $this-&gt;get_id_column_name() ];
		$first   = true;
		foreach ( $keys as $key ) {
			if ( $first ) {
				$first = false;
			}
			else {
				$query[] = &#039;AND&#039;;
			}
			$query[] = $this-&gt;quote_identifier( $key );
			$query[] = &#039;= %s&#039;;
		}

		return \implode( &#039; &#039;, $query );
	}

	/**
	 * Builds an UPDATE query.
	 *
	 * @return string The update query.
	 */
	protected function build_update() {
		$query      = [];
		$query[]    = &quot;UPDATE {$this-&gt;quote_identifier($this-&gt;table_name)} SET&quot;;
		$field_list = [];
		foreach ( $this-&gt;dirty_fields as $key =&gt; $value ) {
			if ( ! \array_key_exists( $key, $this-&gt;expr_fields ) ) {
				$value = ( $value === null ) ? &#039;NULL&#039; : &#039;%s&#039;;
			}
			$field_list[] = &quot;{$this-&gt;quote_identifier($key)} = {$value}&quot;;
		}
		$query[] = \implode( &#039;, &#039;, $field_list );

		return \implode( &#039; &#039;, $query );
	}

	/**
	 * Builds an INSERT query.
	 *
	 * @return string The insert query.
	 */
	protected function build_insert() {
		$query        = [];
		$query[]      = &#039;INSERT INTO&#039;;
		$query[]      = $this-&gt;quote_identifier( $this-&gt;table_name );
		$field_list   = \array_map( [ $this, &#039;quote_identifier&#039; ], \array_keys( $this-&gt;dirty_fields ) );
		$query[]      = &#039;(&#039; . \implode( &#039;, &#039;, $field_list ) . &#039;)&#039;;
		$query[]      = &#039;VALUES&#039;;
		$placeholders = $this-&gt;create_placeholders( $this-&gt;dirty_fields );
		$query[]      = &quot;({$placeholders})&quot;;

		return \implode( &#039; &#039;, $query );
	}

	/**
	 * Builds a bulk INSERT query.
	 *
	 * @param array $models             Array of model instances to be inserted.
	 * @param array $dirty_column_names Array of dirty fields to be used in INSERT.
	 *
	 * @return string The insert query.
	 */
	protected function build_insert_many( $models, $dirty_column_names ) {
		$example_model      = $models[0];
		$total_placeholders = &#039;&#039;;

		$query      = [];
		$query[]    = &#039;INSERT INTO&#039;;
		$query[]    = $this-&gt;quote_identifier( $example_model-&gt;orm-&gt;table_name );
		$field_list = \array_map( [ $this, &#039;quote_identifier&#039; ], $dirty_column_names );
		$query[]    = &#039;(&#039; . \implode( &#039;, &#039;, $field_list ) . &#039;)&#039;;
		$query[]    = &#039;VALUES&#039;;

		// We assign placeholders per model for dirty fields that have values and NULL for dirty fields that don&#039;t.
		foreach ( $models as $model ) {
			$placeholder = [];
			foreach ( $dirty_column_names as $dirty_field ) {
				$placeholder[] = ( $model-&gt;orm-&gt;dirty_fields[ $dirty_field ] === null ) ? &#039;NULL&#039; : &#039;%s&#039;;
			}
			$placeholders        = \implode( &#039;, &#039;, $placeholder );
			$total_placeholders .= &quot;({$placeholders}),&quot;;
		}

		$query[] = \rtrim( $total_placeholders, &#039;,&#039; );
		return \implode( &#039; &#039;, $query );
	}

	/**
	 * Deletes this record from the database.
	 *
	 * @return string The delete query.
	 *
	 * @throws Exception Primary key ID contains null value(s).
	 * @throws Exception Primary key ID missing from row or is null.
	 */
	public function delete() {
		$query = [ &#039;DELETE FROM&#039;, $this-&gt;quote_identifier( $this-&gt;table_name ), $this-&gt;add_id_column_conditions() ];

		return self::execute( \implode( &#039; &#039;, $query ), \is_array( $this-&gt;id( true ) ) ? \array_values( $this-&gt;id( true ) ) : [ $this-&gt;id( true ) ] );
	}

	/**
	 * Deletes many records from the database.
	 *
	 * @return bool|int Response of wpdb::query.
	 */
	public function delete_many() {
		// Build and return the full DELETE statement by concatenating
		// the results of calling each separate builder method.
		$query = $this-&gt;join_if_not_empty(
			&#039; &#039;,
			[
				&#039;DELETE FROM&#039;,
				$this-&gt;quote_identifier( $this-&gt;table_name ),
				$this-&gt;build_where(),
			],
		);

		return self::execute( $query, $this-&gt;values );
	}

	/*
	 * ---  ArrayAccess  ---
	 */

	/**
	 * Checks whether the data has the key.
	 *
	 * @param mixed $offset Key.
	 *
	 * @return bool Whether the data has the key.
	 */
	#[ReturnTypeWillChange]
	public function offsetExists( $offset ) {
		return \array_key_exists( $offset, $this-&gt;data );
	}

	/**
	 * Retrieves the value of the key.
	 *
	 * @param mixed $offset Key.
	 *
	 * @return array|mixed|null The value.
	 */
	#[ReturnTypeWillChange]
	public function offsetGet( $offset ) {
		return $this-&gt;get( $offset );
	}

	/**
	 * Sets the value of the key.
	 *
	 * @param string|int $offset Key.
	 * @param mixed      $value  Value.
	 *
	 * @return void
	 */
	#[ReturnTypeWillChange]
	public function offsetSet( $offset, $value ) {
		if ( $offset === null ) {
			return;
		}
		$this-&gt;set( $offset, $value );
	}

	/**
	 * Removes the given key from the data.
	 *
	 * @param mixed $offset Key.
	 *
	 * @return void
	 */
	#[ReturnTypeWillChange]
	public function offsetUnset( $offset ) {
		unset( $this-&gt;data[ $offset ] );
		unset( $this-&gt;dirty_fields[ $offset ] );
	}

	/*
	 * --- MAGIC METHODS ---
	 */

	/**
	 * Handles magic get via offset.
	 *
	 * @param mixed $key Key.
	 *
	 * @return array|mixed|null The value in the offset.
	 */
	public function __get( $key ) {
		return $this-&gt;offsetGet( $key );
	}

	/**
	 * Handles magic set via offset.
	 *
	 * @param string|int $key   Key.
	 * @param mixed      $value Value.
	 *
	 * @return void
	 */
	public function __set( $key, $value ) {
		$this-&gt;offsetSet( $key, $value );
	}

	/**
	 * Handles magic unset via offset.
	 *
	 * @param mixed $key Key.
	 *
	 * @return void
	 */
	public function __unset( $key ) {
		$this-&gt;offsetUnset( $key );
	}

	/**
	 * Handles magic isset via offset.
	 *
	 * @param mixed $key Key.
	 *
	 * @return bool Whether the offset has the key.
	 */
	public function __isset( $key ) {
		return $this-&gt;offsetExists( $key );
	}
}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fpublic_html%2Fwp-content%2Fplugins%2Fwordpress-seo%2Flib'>⬅ Back to Directory</a>