JezK

Edit File: DataStore.php

<?php
/**
 * API\Reports\Taxes\DataStore class file.
 */

namespace Automattic\WooCommerce\Admin\API\Reports\Taxes;

defined( 'ABSPATH' ) || exit;

use Automattic\WooCommerce\Admin\API\Reports\DataStore as ReportsDataStore;
use Automattic\WooCommerce\Admin\API\Reports\DataStoreInterface;
use Automattic\WooCommerce\Admin\API\Reports\TimeInterval;
use Automattic\WooCommerce\Admin\API\Reports\SqlQuery;
use Automattic\WooCommerce\Admin\API\Reports\Cache as ReportsCache;
use Automattic\WooCommerce\Enums\OrderItemType;

/**
 * API\Reports\Taxes\DataStore.
 */
class DataStore extends ReportsDataStore implements DataStoreInterface {

/**
	 * Table used to get the data.
	 *
	 * @override ReportsDataStore::$table_name
	 *
	 * @var string
	 */
	protected static $table_name = 'wc_order_tax_lookup';

/**
	 * Cache identifier.
	 *
	 * @override ReportsDataStore::$cache_key
	 *
	 * @var string
	 */
	protected $cache_key = 'taxes';

/**
	 * Mapping columns to data type to return correct response types.
	 *
	 * @override ReportsDataStore::$column_types
	 *
	 * @var array
	 */
	protected $column_types = array(
		'tax_rate_id'    => 'intval',
		'name'           => 'strval',
		'tax_rate'       => 'floatval',
		'country'        => 'strval',
		'state'          => 'strval',
		'priority'       => 'intval',
		'total_tax'      => 'floatval',
		'order_tax'      => 'floatval',
		'shipping_tax'   => 'floatval',
		'taxable_amount' => 'floatval',
		'orders_count'   => 'intval',
	);

/**
	 * Data store context used to pass to filters.
	 *
	 * @override ReportsDataStore::$context
	 *
	 * @var string
	 */
	protected $context = 'taxes';

/**
	 * Constructor.
	 *
	 * Report on the date type configured in Analytics settings (default `date_paid`),
	 * matching the Orders and Revenue reports. The reporting period is filtered against
	 * the chosen column on `wc_order_stats` so the Taxes report reconciles with them.
	 *
	 * @override ReportsDataStore::__construct()
	 */
	public function __construct() {
		$this->date_column_name = $this->sanitize_date_column_name( get_option( 'woocommerce_date_type' ), 'date_paid' );
		parent::__construct();
	}

/**
	 * Assign report columns once full table name has been assigned.
	 *
	 * @override ReportsDataStore::assign_report_columns()
	 */
	protected function assign_report_columns() {
		global $wpdb;
		$table_name = self::get_db_table_name();

// Using wp_woocommerce_tax_rates table limits the result to only the existing tax rates and
		// omits the historical records which differs from the purpose of wp_wc_order_tax_lookup table.
		// So in order to get the same data present in wp_woocommerce_tax_rates without breaking the
		// API contract the values are now retrieved from wp_woocommerce_order_items and wp_woocommerce_order_itemmeta.
		// And given that country, state and priority are not separate columns within the woocommerce_order_items,
		// a split to order_item_name column value is required to separate those values. This is not ideal,
		// but given this query is paginated and cached, then it is not a big deal. There is always room for
		// improvements here.
		$this->report_columns = array(
			'tax_rate_id'    => "{$table_name}.tax_rate_id",
			'name'           => "SUBSTRING_INDEX(SUBSTRING_INDEX({$wpdb->prefix}woocommerce_order_items.order_item_name,'-',-2), '-', 1) as name",
			'tax_rate'       => 'CAST(itemmeta_rate_percent.meta_value AS DECIMAL(7,4)) as tax_rate',
			'country'        => "SUBSTRING_INDEX({$wpdb->prefix}woocommerce_order_items.order_item_name,'-',1) as country",
			'state'          => "SUBSTRING_INDEX(SUBSTRING_INDEX({$wpdb->prefix}woocommerce_order_items.order_item_name,'-',-3), '-', 1) as state",
			'priority'       => "SUBSTRING_INDEX({$wpdb->prefix}woocommerce_order_items.order_item_name,'-',-1) as priority",
			'total_tax'      => 'SUM(total_tax) as total_tax',
			'order_tax'      => 'SUM(order_tax) as order_tax',
			'shipping_tax'   => 'SUM(shipping_tax) as shipping_tax',
			'taxable_amount' => 'SUM(taxable_amount) as taxable_amount',
			// parent_id stays unqualified: wc_order_stats is the only joined table carrying it, and
			// this string is carried by the public woocommerce_admin_report_columns filter, so it must
			// match the released form for extension callbacks that inspect or rewrite it.
			'orders_count'   => "COUNT( DISTINCT ( CASE WHEN parent_id = 0 THEN {$table_name}.order_id END ) ) as orders_count",
		);

// Guard against the column not existing yet: the report otherwise breaks entirely on a
		// site where the upgrade routine has not run (or could not run) the schema update.
		if ( ! static::has_taxable_amount_column() ) {
			unset( $this->report_columns['taxable_amount'] );
		}
	}

/**
	 * Check if the wc_order_tax_lookup table has the taxable_amount column.
	 *
	 * Asks the schema on every request rather than caching the answer in an option, so a
	 * column that appears or disappears behind WooCommerce's back (a partial restore, a
	 * manual drop) corrects the report on the next request.
	 *
	 * @internal For exclusive usage of WooCommerce core, backwards compatibility not guaranteed.
	 * @since 11.2.0
	 *
	 * @return bool
	 */
	public static function has_taxable_amount_column() {
		global $wpdb;

// One schema check per request: imports call this once per synced order. Keyed by
		// blog id since the schema is per site.
		static $has_column = array();

$blog_id = get_current_blog_id();

if ( isset( $has_column[ $blog_id ] ) ) {
			return $has_column[ $blog_id ];
		}

$table_name = self::get_db_table_name();

// If the table itself does not exist yet, checking its columns would be a DB error.
		$table_exists = $wpdb->get_var(
			$wpdb->prepare(
				'SHOW TABLES LIKE %s',
				$table_name
			)
		);

if ( ! $table_exists ) {
			$has_column[ $blog_id ] = false;
			return false;
		}

$column_exists = $wpdb->get_var(
			$wpdb->prepare(
				// phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Table name cannot be prepared.
				"SHOW COLUMNS FROM `{$table_name}` LIKE %s",
				'taxable_amount'
			)
		);

$has_column[ $blog_id ] = ! empty( $column_exists );

return $has_column[ $blog_id ];
	}

/**
	 * Set up all the hooks for maintaining and populating table data.
	 */
	public static function init() {
		add_action( 'woocommerce_analytics_delete_order_stats', array( __CLASS__, 'sync_on_order_delete' ), 15 );
	}

/**
	 * Fills FROM clause of SQL request based on user supplied parameters.
	 *
	 * @param array  $query_args          Query arguments supplied by the user.
	 * @param string $order_status_filter Order status subquery. Retained for signature compatibility; the wc_order_stats join is now always added.
	 */
	protected function add_from_sql_params( $query_args, $order_status_filter ) {
		global $wpdb;
		$table_name = self::get_db_table_name();

// Always join wc_order_stats: the reporting period is filtered against its
		// configured date column (date_paid by default) and the status subquery relies on it.
		$this->subquery->add_sql_clause( 'join', "JOIN {$wpdb->prefix}wc_order_stats ON {$table_name}.order_id = {$wpdb->prefix}wc_order_stats.order_id" );

$this->subquery->add_sql_clause( 'join', "JOIN {$wpdb->prefix}woocommerce_order_items ON {$table_name}.order_id = {$wpdb->prefix}woocommerce_order_items.order_id AND {$wpdb->prefix}woocommerce_order_items.order_item_type = 'tax'" );
		$this->subquery->add_sql_clause( 'join', "JOIN {$wpdb->prefix}woocommerce_order_itemmeta itemmeta_rate_id ON itemmeta_rate_id.order_item_id = {$wpdb->prefix}woocommerce_order_items.order_item_id AND itemmeta_rate_id.meta_key = 'rate_id'" );
		$this->subquery->add_sql_clause( 'join', "JOIN {$wpdb->prefix}woocommerce_order_itemmeta itemmeta_rate_percent ON itemmeta_rate_percent.order_item_id = {$wpdb->prefix}woocommerce_order_items.order_item_id AND itemmeta_rate_percent.meta_key = 'rate_percent'" );
	}

/**
	 * Updates the database query with parameters used for Taxes report: categories and order status.
	 *
	 * @see Automattic\WooCommerce\Admin\API\Reports\Taxes\Stats\DataStore::update_sql_query_params()
	 * @param array $query_args Query arguments supplied by the user.
	 */
	protected function add_sql_query_params( $query_args ) {
		global $wpdb;

$order_tax_lookup_table = self::get_db_table_name();
		$order_stats_table      = $wpdb->prefix . 'wc_order_stats';

// Filter the reporting period against the configured date type on wc_order_stats
		// (date_paid by default) rather than the lookup's date_created, so the Taxes report
		// reconciles with the Orders and Revenue reports.
		$this->add_time_period_sql_params( $query_args, $order_stats_table );
		$this->get_limit_sql_params( $query_args );
		$this->add_order_by_sql_params( $query_args );
		$order_status_filter = $this->get_status_subquery( $query_args );
		$this->add_from_sql_params( $query_args, $order_status_filter );

$this->subquery->add_sql_clause( 'where', "AND itemmeta_rate_id.meta_value = {$order_tax_lookup_table}.tax_rate_id" );

/*
		 * Narrow the rate match to the single tax line the row was written for. The rate id on its
		 * own fans one lookup row out across every line of the order that shares it, which is how
		 * an order carrying several lines on one rate id came to report the wrong tax.
		 *
		 * Rows recorded before the lookup held one row per tax order item sit at the column's zero
		 * default and have no line to narrow to, so they go on matching the rate id alone, which is
		 * how the report read them all along, for as long as no per-line row has replaced them.
		 * See get_legacy_row_condition(). OrderTaxLookupMigrator rebuilds them in the
		 * background.
		 */
		$this->subquery->add_sql_clause( 'where', "AND ( {$order_tax_lookup_table}.order_item_id = {$wpdb->prefix}woocommerce_order_items.order_item_id OR " . self::get_legacy_row_condition() . ' )' );

if ( isset( $query_args['taxes'] ) && ! empty( $query_args['taxes'] ) ) {
			$allowed_taxes = self::get_filtered_ids( $query_args, 'taxes' );
			$this->subquery->add_sql_clause( 'where', "AND {$order_tax_lookup_table}.tax_rate_id IN ({$allowed_taxes})" );
		}

if ( $order_status_filter ) {
			$this->subquery->add_sql_clause( 'where', "AND ( {$order_status_filter} )" );
		}
	}

/**
	 * Get the default query arguments to be used by get_data().
	 * These defaults are only partially applied when used via REST API, as that has its own defaults.
	 *
	 * @override ReportsDataStore::get_default_query_vars()
	 *
	 * @return array Query parameters.
	 */
	public function get_default_query_vars() {
		$defaults            = parent::get_default_query_vars();
		$defaults['orderby'] = 'tax_rate_id';
		$defaults['taxes']   = array();

return $defaults;
	}

/**
	 * Returns the report data based on normalized parameters.
	 * Will be called by `get_data` if there is no data in cache.
	 *
	 * @override ReportsDataStore::get_noncached_data()
	 *
	 * @see get_data
	 * @param array $query_args Query parameters.
	 * @return stdClass|WP_Error Data object `{ totals: *, intervals: array, total: int, pages: int, page_no: int }`, or error.
	 */
	public function get_noncached_data( $query_args ) {
		global $wpdb;

$this->initialize_queries();

$data = (object) array(
			'data'    => array(),
			'total'   => 0,
			'pages'   => 0,
			'page_no' => 0,
		);

// While the taxable_amount column is missing its report column is unset, so ordering
		// by it would be a SQL error. Fall back to the default order.
		if ( 'taxable_amount' === ( $query_args['orderby'] ?? '' ) && ! isset( $this->report_columns['taxable_amount'] ) ) {
			$query_args['orderby'] = 'tax_rate_id';
		}

$this->add_sql_query_params( $query_args );
		$params = $this->get_limit_params( $query_args );

if ( isset( $query_args['taxes'] ) && is_array( $query_args['taxes'] ) && ! empty( $query_args['taxes'] ) ) {
			$total_results = count( $query_args['taxes'] );
			$total_pages   = (int) ceil( $total_results / $params['per_page'] );
		} else {
			$db_records_count = (int) $wpdb->get_var(
				// phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- cache ok, DB call ok, unprepared SQL ok.
				"SELECT COUNT(*) FROM ( {$this->subquery->get_query_statement()} ) AS tt"
			);

$total_results = $db_records_count;
			$total_pages   = (int) ceil( $db_records_count / $params['per_page'] );

if ( $query_args['page'] < 1 || $query_args['page'] > $total_pages ) {
				return $data;
			}
		}

$this->subquery->clear_sql_clause( 'select' );
		$this->subquery->add_sql_clause( 'select', $this->selected_columns( $query_args ) );
		if ( in_array( $query_args['orderby'], array( 'total_tax', 'order_tax', 'shipping_tax', 'taxable_amount', 'orders_count' ), true ) ) {
			$this->subquery->add_sql_clause( 'order_by', $this->get_sql_clause( 'order_by' ) . ', tax_rate_id' );
		} else {
			$this->subquery->add_sql_clause( 'order_by', $this->get_sql_clause( 'order_by' ) );
		}
		$this->subquery->add_sql_clause( 'limit', $this->get_sql_clause( 'limit' ) );

$taxes_query = $this->subquery->get_query_statement();

$tax_data = $wpdb->get_results(
			// phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared -- cache ok, DB call ok, unprepared SQL ok.
			$taxes_query,
			ARRAY_A
		);

if ( null === $tax_data ) {
			return $data;
		}

$tax_data = array_map( array( $this, 'cast_numbers' ), $tax_data );
		$data     = (object) array(
			'data'    => $tax_data,
			'total'   => $total_results,
			'pages'   => $total_pages,
			'page_no' => (int) $query_args['page'],
		);

return $data;
	}

/**
	 * Maps ordering specified by the user to columns in the database/fields in the data.
	 *
	 * @override ReportsDataStore::normalize_order_by()
	 *
	 * @param string $order_by Sorting criterion.
	 * @return string
	 */
	protected function normalize_order_by( $order_by ) {
		global $wpdb;

if ( 'tax_code' === $order_by ) {
			return "{$wpdb->prefix}woocommerce_order_items.order_item_name";
		} elseif ( 'rate' === $order_by ) {
			return 'tax_rate';
		}

return $order_by;
	}

/**
	 * Cache of lookup_is_keyed_by_order_item(). Only `true` sticks: the re-key can land while a
	 * request runs (the "Verify base database tables" tool re-keys right before the tools list
	 * re-renders), and a cached `false` would outlive it.
	 *
	 * @var bool|null
	 */
	private static $lookup_keyed_by_order_item = null;

/**
	 * Whether the lookup's primary key includes the tax order item.
	 *
	 * The re-key in `WC_Install::create_tables()` can fail on a large store, and dbDelta adds the
	 * `order_item_id` column either way. Writing a real tax order item id into a table still keyed
	 * on (order_id, tax_rate_id) collapses the lines sharing a rate into one row that the report
	 * then matches to a single line, which reads worse than it did before the column existed.
	 *
	 * `OrderTaxLookupMigrator` reads this too: a rebuild over such a table would write every row
	 * back at zero while stepping the cursor past it, so it waits instead.
	 *
	 * @internal For exclusive usage of WooCommerce core, backwards compatibility not guaranteed.
	 * @since 11.2.0
	 *
	 * @return bool
	 */
	public static function lookup_is_keyed_by_order_item(): bool {
		global $wpdb;

if ( true !== self::$lookup_keyed_by_order_item ) {
			$table_name = self::get_db_table_name();
			// phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Table name is not user input.
			self::$lookup_keyed_by_order_item = (bool) $wpdb->get_var( "SHOW KEYS FROM `{$table_name}` WHERE Key_name = 'PRIMARY' AND Column_name = 'order_item_id'" );
		}

return self::$lookup_keyed_by_order_item;
	}

/**
	 * SQL condition matching a lookup row at the tax order item column's zero default that the
	 * reports should still read.
	 *
	 * A row at zero stands in for every tax line of its order that shares its rate, which is how
	 * the report read the lookup before the column existed. Rows written per tax line say the same
	 * thing line by line, so an order holding both shapes for one rate reports that rate twice.
	 * The per-line rows are the ones the sync maintains, so a legacy row they already cover is
	 * left out.
	 *
	 * A store ends up holding both shapes when code outside WooCommerce writes the lookup on the
	 * (order_id, tax_rate_id) key the table was released with: such a write lands on the zero
	 * default instead of replacing the rows WooCommerce holds for the order. A prune that could
	 * not run in `sync_order_taxes()` leaves the same shape behind.
	 *
	 * Once the lookup is keyed by tax order item it only holds rows at zero until the rebuild has
	 * been through it, so the check costs nothing on a store that is through it:
	 * `order_item_id > 0` is true and the subquery is never reached. It is paid for while the
	 * rebuild runs, where every row at zero takes an index lookup to find no per-line row beside
	 * it. Measured on a 2M row lookup over a 30 day report, that is 177ms against 595ms, and it
	 * goes away as the rebuild does.
	 *
	 * @internal For exclusive usage of WooCommerce core, backwards compatibility not guaranteed.
	 * @since 11.2.0
	 *
	 * @return string
	 */
	public static function get_legacy_row_condition(): string {
		$table_name = self::get_db_table_name();

// Nothing can have replaced a row while the lookup is still keyed on
		// (order_id, tax_rate_id): the sync writes every row at zero and `OrderTaxLookupMigrator`
		// waits for the re-key. Unlike a rebuild that is still queued, that state does not clear
		// itself, so the subquery would read the report range on every uncached report and come
		// back empty for good.
		if ( ! self::lookup_is_keyed_by_order_item() ) {
			return "{$table_name}.order_item_id = 0";
		}

return "( {$table_name}.order_item_id = 0 AND NOT EXISTS ( SELECT 1 FROM {$table_name} per_line WHERE per_line.order_id = {$table_name}.order_id AND per_line.tax_rate_id = {$table_name}.tax_rate_id AND per_line.order_item_id > 0 ) )";
	}

/**
	 * Create or update an entry in the wc_order_tax_lookup table for an order.
	 *
	 * Writes one row per tax order item, in a single statement so that a write that does not land
	 * rebuilds none of the order's tax lines rather than some of them, then drops the rows the
	 * order held before and no longer carries.
	 *
	 * @param int $order_id Order ID.
	 * @return int|bool Returns -1 if order won't be processed, or a boolean indicating processing success.
	 */
	public static function sync_order_taxes( $order_id ) {
		global $wpdb;

$order = wc_get_order( $order_id );

// An order with no creation date has nothing to date its lookup rows by, and
		// `WC_Data::set_date_prop()` leaves the date null for a zero datetime, not only for a
		// missing one. `OrdersScheduler::import()` leaves such an order out of the reports for the
		// same reason.
		if ( ! $order || ! $order->get_date_created( 'edit' ) ) {
			return -1;
		}

$table_name   = self::get_db_table_name();
		$date_created = $order->get_date_created( 'edit' )->date( TimeInterval::$sql_datetime_format );
		/**
		 * Tax line items of the order.
		 *
		 * @var \WC_Order_Item_Tax[] $tax_items
		 */
		$tax_items     = $order->get_items( OrderItemType::TAX );
		$keyed_by_item = self::lookup_is_keyed_by_order_item();

// Read the rows the order already holds, so that the prune below names the rows this sync
		// found, the way the Products and Coupons stores do. Deleting everything outside the
		// snapshot instead would let two syncs that read different tax lines delete each other's
		// rows and leave the order with none.
		$existing_rows = $wpdb->get_results(
			$wpdb->prepare(
				// phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared -- Table name is not user input.
				"SELECT tax_rate_id, order_item_id FROM {$table_name} WHERE order_id = %d",
				$order->get_id()
			),
			ARRAY_A
		);

// Nothing has been written yet, so the order keeps the rows it came in with. Carrying on
		// would prune against an empty snapshot, which leaves every row the order no longer
		// carries in place for the reports to go on counting.
		if ( $wpdb->last_error ) {
			wc_get_logger()->error(
				"Could not read the analytics tax lookup rows of order {$order->get_id()}. The order keeps the rows it had and reports the way it did before.",
				array( 'source' => 'wc-order-tax-lookup' )
			);

return false;
		}

$stale  = array();
		$rows   = array();
		$values = array();

foreach ( $existing_rows as $existing_row ) {
			$stale[ $existing_row['tax_rate_id'] . '-' . $existing_row['order_item_id'] ] = array(
				(int) $existing_row['tax_rate_id'],
				(int) $existing_row['order_item_id'],
			);
		}

// Guard against the column not existing yet: wpdb::replace() with an unknown column
		// fails whole, which would silently drop the order from the Taxes report.
		$has_taxable_amount_column = static::has_taxable_amount_column();
		$taxable_amounts           = array();

// Also skip orders without tax lines: computing bases would hydrate every
		// line item, fee and shipping row for a write that never happens.
		if ( $has_taxable_amount_column && ! empty( $tax_items ) ) {
			// A refund's tax items re-derive the compound flag from the live rate, which can
			// be gone by refund time; the parent's tax items carry the flags as charged, and
			// the refund base must mirror them or a refunded order stops netting to zero.
			$flag_items = $tax_items;
			if ( $order instanceof \WC_Order_Refund ) {
				$parent = wc_get_order( $order->get_parent_id() );
				if ( $parent ) {
					/**
					 * Tax line items of the parent order.
					 *
					 * @var \WC_Order_Item_Tax[] $parent_tax_items
					 */
					$parent_tax_items = $parent->get_items( OrderItemType::TAX );
					if ( ! empty( $parent_tax_items ) ) {
						$flag_items = $parent_tax_items;
					}
				}
			}

$compound_rate_ids = array();
			foreach ( $flag_items as $tax_item ) {
				if ( $tax_item->get_compound() ) {
					$compound_rate_ids[] = $tax_item->get_rate_id();
				}
			}
			$taxable_amounts = static::get_taxable_amounts_by_rate( $order, $compound_rate_ids );
		}

foreach ( $tax_items as $tax_item ) {
			// Leaving the column at zero on a table the re-key never reached keeps the row in the
			// shape the released report reads, rather than collapsing the order's tax lines into
			// one row the report matches to a single line.
			$order_item_id = $keyed_by_item ? $tax_item->get_id() : 0;
			$tax_rate_id   = (int) $tax_item->get_rate_id();

// A row this sync is about to write is not stale. The key is the rate and the item
			// together, so a line whose rate id has changed leaves behind the row it held before.
			unset( $stale[ $tax_rate_id . '-' . $order_item_id ] );

array_push(
				$values,
				$order->get_id(),
				$date_created,
				$tax_rate_id,
				$order_item_id,
				$tax_item->get_shipping_tax_total(),
				$tax_item->get_tax_total(),
				(float) $tax_item->get_tax_total() + (float) $tax_item->get_shipping_tax_total()
			);

if ( $has_taxable_amount_column ) {
				// The bases are computed per rate and the report sums the column per rate, so
				// when tax lines share a rate only the first row carries the rate's base. On an
				// unkeyed table the lines collapse into one row and the last write wins, so
				// there every write carries the base.
				$values[] = $taxable_amounts[ $tax_rate_id ] ?? 0;
				if ( $keyed_by_item ) {
					unset( $taxable_amounts[ $tax_rate_id ] );
				}
				$rows[] = '(%d, %s, %d, %d, %f, %f, %f, %f)';
			} else {
				$rows[] = '(%d, %s, %d, %d, %f, %f, %f)';
			}
		}

// One statement for the whole order. Rebuilding only some of its lines would leave a row
		// still on the order item column's zero default beside the rows written next to it, and
		// that row stands in for every line of the order sharing its rate, so the reports would
		// count those lines twice.
		if ( $rows ) {
			$columns = 'order_id, date_created, tax_rate_id, order_item_id, shipping_tax, order_tax, total_tax';
			if ( $has_taxable_amount_column ) {
				$columns .= ', taxable_amount';
			}

$written = $wpdb->query(
				$wpdb->prepare(
					// phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.PreparedSQLPlaceholders.UnfinishedPrepare -- Table name is not user input, and the value placeholders are built above, one set per tax line.
					"REPLACE INTO {$table_name} ({$columns}) VALUES " . implode( ', ', $rows ),
					$values
				)
			);

if ( false === $written ) {
				wc_get_logger()->error(
					"Could not write the analytics tax lookup rows of order {$order->get_id()}. The order keeps the rows it had and reports the way it did before.",
					array( 'source' => 'wc-order-tax-lookup' )
				);

return false;
			}
		}

// Drop the rows the order came in with that it no longer carries, which includes the rows
		// written before the order item column existed, since those sit at zero. Prune only once
		// the writes have landed, so a write that did not land leaves the order with the rows it
		// came in with.
		if ( $stale ) {
			$keys       = array();
			$key_values = array( $order->get_id() );

foreach ( $stale as $stale_key ) {
				$keys[] = '(%d, %d)';
				array_push( $key_values, $stale_key[0], $stale_key[1] );
			}

$deleted = $wpdb->query(
				$wpdb->prepare(
					// phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.PreparedSQL.NotPrepared, WordPress.DB.PreparedSQLPlaceholders.UnfinishedPrepare -- Table name is not user input, and the key placeholders are built above, one pair per stale row.
					"DELETE FROM {$table_name} WHERE order_id = %d AND (tax_rate_id, order_item_id) IN (" . implode( ', ', $keys ) . ')',
					$key_values
				)
			);

// A row the order no longer carries goes on being counted by the reports, so a prune
			// that failed is not a sync that succeeded.
			if ( false === $deleted ) {
				wc_get_logger()->error(
					"Could not drop the analytics tax lookup rows order {$order->get_id()} no longer carries. Its old rows stand beside the rows just written, so the reports count those tax lines twice until the order is synced again.",
					array( 'source' => 'wc-order-tax-lookup' )
				);

return false;
			}
		}

foreach ( $tax_items as $tax_item ) {
			/**
			 * Fires when tax's reports are updated.
			 *
			 * @param int $tax_rate_id Tax Rate ID.
			 * @param int $order_id    Order ID.
			 *
			 * @since 4.0.0
			 */
			do_action( 'woocommerce_analytics_update_tax', $tax_item->get_rate_id(), $order->get_id() );
		}

return true;
	}

/**
	 * Sum the net totals of the order parts (line items, fees, shipping) each tax rate applied to.
	 *
	 * Computed from the items rather than derived from the tax amounts, so zero-rated
	 * sales still record the base amount they were taxed on. A compound rate is applied
	 * on top of the other taxes of the same item, so its base includes them.
	 *
	 * @since 11.2.0
	 *
	 * @param \WC_Order|\WC_Order_Refund $order             Order object.
	 * @param int[]                      $compound_rate_ids Ids of the order's compound tax rates.
	 * @return array Map of tax rate id => taxable amount.
	 */
	protected static function get_taxable_amounts_by_rate( $order, $compound_rate_ids = array() ) {
		$amounts = array();
		/**
		 * Taxable line items of the order.
		 *
		 * @var \WC_Order_Item_Product[]|\WC_Order_Item_Fee[]|\WC_Order_Item_Shipping[] $items
		 */
		$items = $order->get_items( array( OrderItemType::LINE_ITEM, OrderItemType::FEE, OrderItemType::SHIPPING ) );

foreach ( $items as $item ) {
			$taxes = $item->get_taxes();
			if ( empty( $taxes['total'] ) || ! is_array( $taxes['total'] ) ) {
				continue;
			}

$non_compound_tax = 0.0;
			foreach ( $taxes['total'] as $rate_id => $tax ) {
				if ( is_numeric( $tax ) && ! in_array( (int) $rate_id, $compound_rate_ids, true ) ) {
					$non_compound_tax += (float) $tax;
				}
			}

// Mirror WC_Tax::calc_exclusive_tax(): a compound rate is applied over the item
			// total plus all non-compound taxes plus the compound taxes applied before it.
			// Assumes the item tax data keeps core's rate order (compound rates after the
			// rates they compound over); a third-party engine writing another order would
			// only mis-split the base between multiple compound rates, not the total.
			$compound_running_tax = 0.0;
			foreach ( $taxes['total'] as $rate_id => $tax ) {
				// Admin saves without recalculating store '' for rates that never applied
				// to the item. Numeric zero still counts (zero-rated sales).
				if ( ! is_numeric( $tax ) ) {
					continue;
				}

$base = (float) $item->get_total();
				if ( in_array( (int) $rate_id, $compound_rate_ids, true ) ) {
					$base                 += $non_compound_tax + $compound_running_tax;
					$compound_running_tax += (float) $tax;
				}
				$amounts[ $rate_id ] = ( $amounts[ $rate_id ] ?? 0 ) + $base;
			}
		}

return $amounts;
	}

/**
	 * Clean taxes data when an order is deleted.
	 *
	 * @param int $order_id Order ID.
	 */
	public static function sync_on_order_delete( $order_id ) {
		global $wpdb;

$wpdb->delete( self::get_db_table_name(), array( 'order_id' => $order_id ) );

/**
		 * Fires when tax's reports are removed from database.
		 *
		 * @param int $tax_rate_id Tax Rate ID.
		 * @param int $order_id    Order ID.
		 */
		do_action( 'woocommerce_analytics_delete_tax', 0, $order_id );

ReportsCache::invalidate();
	}

/**
	 * Initialize query objects.
	 */
	protected function initialize_queries() {
		global $wpdb;

$this->clear_all_clauses();
		$this->subquery = new SqlQuery( $this->context . '_subquery' );
		$this->subquery->add_sql_clause( 'select', self::get_db_table_name() . '.tax_rate_id' );
		$this->subquery->add_sql_clause( 'from', self::get_db_table_name() );
		$this->subquery->add_sql_clause( 'group_by', self::get_db_table_name() . '.tax_rate_id' );
		$this->subquery->add_sql_clause( 'group_by', ", {$wpdb->prefix}woocommerce_order_items.order_item_name, itemmeta_rate_percent.meta_value" );
	}
}