Submission Review Guidelines:

• I have followed the WooCommerce Contributing Guidelines and the WordPress Coding Standards.
• I have checked to ensure there aren't other open Pull Requests for the same update/change.
• I have reviewed my code for security best practices.
• Following the above guidelines will result in quick merges and clear and detailed feedback when appropriate.

Changes proposed in this Pull Request:

Closes #45550.

Background:
The current OrderCaching works by attempting to cache the Order objects. However, the current implementation of WC_Data::__sleep()/__wakeup() only allow the ID to be serialized. The reason for this was to avoid serializing the datastore with a data object, but also prevents issues where complex hierarchies of objects can end up getting cached with the order object. The end result means that any unserialized WC_Data object has to be reinitialized completely, requiring DB queries to retrieve the data for re-hydration.

This PR introduces the following that are disabled by default:

1. Caching of raw order data is added to the HPOS DataStore layer reducing the queries needed to initialize order objects.
2. OrderCache (which is used to cache instantiated WC_Order class objects) now uses an order_object cache group that is set as non-persistent. We don't want to save the order objects in persistent storage and the time spent Instantiating a WC_Order object is small, but can add up. So non-persistent cache is used to avoid re-instantiating the same object over and over again during a single request.
3. Introduces a new WOOCOMMERCE_ENABLE_ALPHA_FEATURE_TESTING constant that can be used during initial alpha integration of new features/enhancements. When defined, the option to enable order data caching is available through the advanced features settings.

Benefits:

1. An entity doesn't need to care where it is stored (e.g. which datastore) or about it's own caching. So we can remove some of the work-arounds added to deal with cache when syncing.
2. Caching a set of Orders continues to only cache the set of IDs instead of the entire object. This ensures that the orders restored from the set are the latest versions of those orders as provided in the database.

Alternative Considered:
I looked at improving the serialization handling of WC_Data and it's child classes so that we could serialize all the relevant data with the entities without connected services, like the data stores. There were a couple issues with this:

First, PHP limitations meant that the serialization/deserialization would need to be pretty complex: PHP doesn't have a simple way to use the default serialization and just exclude certain properties. To properly restore an object, each class in the hierarchy would need to potentially deal with any private properties it defines. With extended classes from other plugins, those child classes would need to be properly modified for this to work or compatibility would break.

Second, there is already a bit of juggling going on around caching orders because the data stores have accessible public API's for making updates. Shifting the caching to them allows them to directly control the cache and update it when needed.

How to test the changes in this Pull Request:

Using the WooCommerce Testing Instructions Guide, include your detailed testing instructions:

Unit tests have been updated to validate proper cache invalidation.

The following can be used to test the functionality of the OrdersTableDataStore caching. :

1. Create a file named PR46023Tests.php somewhere within the plugins/woocommerce/tests/php/src diretory.

<?php

/**
 * Test for https://github.com/woocommerce/woocommerce/pull/46023 to verify that the caching actually makes
 * performance improvements over the current cache handling by caching the order data not currently preserved
 * with the WC_Data objects.  It works by forcing cached objects/arrays to be serialized like they would be with a 
 * persistent cache solution. 
 */
class PR46023Tests extends WC_Unit_Test_Case {

	use \Automattic\WooCommerce\RestApi\UnitTests\HPOSToggleTrait;

	public function setUp(): void {
		parent::setUp();
		add_filter( 'wc_allow_changing_orders_storage_while_sync_is_pending', '__return_true' );
		$this->setup_cot();
		$GLOBALS['wp_object_cache'] = new Serializing_Cache_Proxy( $GLOBALS['wp_object_cache'] );
	}

	public function tearDown(): void {
		$this->clean_up_cot_setup();
		remove_filter( 'wc_allow_changing_orders_storage_while_sync_is_pending', '__return_true' );
		parent::tearDown();
	}

	public function test_order_cache_perfmance() {
		global $wpdb;
		$order_1 = \Automattic\WooCommerce\RestApi\UnitTests\Helpers\OrderHelper::create_order();
		$order_2 = \Automattic\WooCommerce\RestApi\UnitTests\Helpers\OrderHelper::create_order();
		$order_3 = \Automattic\WooCommerce\RestApi\UnitTests\Helpers\OrderHelper::create_order();
		$order_4 = \Automattic\WooCommerce\RestApi\UnitTests\Helpers\OrderHelper::create_order();
		$order_5 = \Automattic\WooCommerce\RestApi\UnitTests\Helpers\OrderHelper::create_order();
		$order_6 = \Automattic\WooCommerce\RestApi\UnitTests\Helpers\OrderHelper::create_order();

		wc_get_orders( [
			$order_1->get_id(),
			$order_2->get_id(),
			$order_3->get_id(),
			$order_4->get_id(),
			$order_5->get_id(),
			$order_6->get_id(),
		] );

		$initial_queries = $wpdb->num_queries;
		wc_get_order( $order_1->get_id() );
		wc_get_order( $order_2->get_id() );
		wc_get_order( $order_3->get_id() );
		wc_get_order( $order_4->get_id() );
		wc_get_order( $order_5->get_id() );
		wc_get_order( $order_6->get_id() );

		$final_queries = $wpdb->num_queries;
		$this->assertEquals( 0, $final_queries - $initial_queries, 'Expected no queries to occur retrieving previously retrieved Orders' );
	}
}

/**
 * Proxy class used to mimic objects
 */
class Serializing_Cache_Proxy {
	public $original_cache_instance;

	public function __construct( $original_cache_instance ) {
		$this->original_cache_instance = $original_cache_instance;
	}

	public function __call( $function, $args ) {
		return $this->original_cache_instance->$function( ...$args );
	}

	public function get( $key, $group = 'default', $force = false, &$found = null ) {
		$data = $this->original_cache_instance->get( $key, $group, $found, $found );
		if ( is_object( $data ) || is_array( $data ) ) {
			return unserialize( serialize( $data ) );
		}

		return $data;
	}
}

2. Run the test unit tests, filtering to the new test with --filter=PR46023Tests

Manual Testing

1. Setup an environment with persistent object caching drop-in setup.
2. Under wp-admin/admin.php?page=wc-settings&tab=advanced&section=features, verify that the HPOS Data Caching Feature is not shown.
3. Add the following to the wp-config.php: define( 'WOOCOMMERCE_ENABLE_ALPHA_FEATURE_TESTING', true );
4. Reload the advanced->features and verify that the option now shows.
   
5. Disable persistent cache by temporarily removing the drop-in.
6. Reload the advanced->features and verify that the option is visible, but disabled noting that it is only suggested with external object caching.
   
7. Re-enable external object caching.
8. Enable HPOS and the HPOS Data Caching.
9. Place an order through the site
10. Within the admin, validate that the data is as expected.
11. Update the order within the admin, including any meta data.
12. Verify that the data is updated as expected.
13. Revising the order details as a customer and make sure the data reflects the latest data.

Additional Automated testing:

1. Modify OrderUtil:: custom_orders_table_datastore_cache_enabled() to always return true;
2. Run the woocommerce core testsuites.