SearchUpdateBatchedProcessor::process() - Code Metrics - silverstripe/silverstripe-fulltextsearch - Measure and Improve Code Quality continuously with Scrutinizer

SearchUpdateBatchedProcessor::process() A
last analyzed 2022-08-08 23:38 UTC

↳ Parent: SearchUpdateBatchedProcessor

Complexity

Conditions	3
Paths	3

Size

Total Lines	18
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	7
nc	3
nop	0
dl	0
loc	18
rs	10
c	0
b	0
f	0

<?php

namespace SilverStripe\FullTextSearch\Search\Processors;

use SilverStripe\Core\Config\Configurable;

/**
 * Provides batching of search updates
 */
abstract class SearchUpdateBatchedProcessor extends SearchUpdateProcessor
{
    use Configurable;

    /**
     * List of batches to be processed
     *
     * @var array
     */
    protected $batches;

    /**
     * Pointer to index of $batches assigned to $current.
     * Set to 0 (first index) if not started, or count + 1 if completed.
     *
     * @var int
     */
    protected $currentBatch;

    /**
     * List of indexes successfully comitted in the current batch
     *
     * @var array
     */
    protected $completedIndexes;

    /**
     * Maximum number of record-states to process in one batch.
     * Set to zero to process all records in a single batch
     *
     * @config
     * @var int
     */
    private static $batch_size = 100;


    /**
     * Up to this number of additional ids can be added to any batch in order to reduce the number
     * of batches
     *
     * @config
     * @var int
     */
    private static $batch_soft_cap = 10;


    public function __construct()
    {
        parent::__construct();

        $this->batches = array();
        $this->setBatch(0);
    }

    /**
     * Set the current batch index
     *
     * @param int $batch Index of the batch
     */
    protected function setBatch($batch)
    {
        $this->currentBatch = $batch;
    }

    protected function getSource()
    {
        if (isset($this->batches[$this->currentBatch])) {
            return $this->batches[$this->currentBatch];
        }
    }

    /**
     * Process the current queue
     *
     * @return boolean
     */
    public function process()
    {
        // Skip blank queues
        if (empty($this->batches)) {
            return true;
        }

        // Don't re-process completed queue
        if ($this->currentBatch >= count($this->batches)) {
            return true;
        }

        // Send current patch to indexes
        $this->prepareIndexes();

        // Advance to next batch if successful
        $this->setBatch($this->currentBatch + 1);
        return true;
    }

    /**
     * Segments batches acording to the specified rules
     *
     * @param array $source Source input
     * @return array Batches
     */
    protected function segmentBatches($source)
    {
        // Measure batch_size
        $batchSize = static::config()->get('batch_size');
        if ($batchSize === 0) {
            return array($source);
        }
        $softCap = static::config()->get('batch_soft_cap');

        // Clear batches
        $batches = array();
        $current = array();
        $currentSize = 0;

        // Build batches from data
        foreach ($source as $base => $statefulids) {
            if (!$statefulids) {
                continue;
            }

            foreach ($statefulids as $stateKey => $statefulid) {
                $state = $statefulid['state'];
                $ids = $statefulid['ids'];
                if (!$ids) {
                    continue;
                }

                // Extract items from $ids until empty
                while ($ids) {
                    // Estimate maximum number of items to take for this iteration, allowing for the soft cap
                    $take = $batchSize - $currentSize;
                    if (count($ids) <= $take + $softCap) {
                        $take += $softCap;
                    }
                    $items = array_slice($ids, 0, $take, true);
                    $ids = array_slice($ids, count($items), null, true);

                    // Update batch
                    $currentSize += count($items);
                    $merge = array(
                        $base => array(
                            $stateKey => array(
                                'state' => $state,
                                'ids' => $items
                            )
                        )
                    );
                    $current = $current ? array_merge_recursive($current, $merge) : $merge;
                    if ($currentSize >= $batchSize) {
                        $batches[] = $current;
                        $current = array();
                        $currentSize = 0;
                    }
                }
            }
        }
        // Add incomplete batch
        if ($currentSize) {
            $batches[] = $current;
        }

        return $batches;
    }

    public function batchData()
    {
        $this->batches = $this->segmentBatches($this->dirty);
        $this->setBatch(0);
    }

    public function triggerProcessing()
    {
        $this->batchData();
    }
}


1			<?php
2
3			namespace SilverStripe\FullTextSearch\Search\Processors;
4
5			use SilverStripe\Core\Config\Configurable;
6
7			/**
8			* Provides batching of search updates
9			*/
10			abstract class SearchUpdateBatchedProcessor extends SearchUpdateProcessor
11			{
12			use Configurable;
13
14			/**
15			* List of batches to be processed
16			*
17			* @var array
18			*/
19			protected $batches;
20
21			/**
22			* Pointer to index of $batches assigned to $current.
23			* Set to 0 (first index) if not started, or count + 1 if completed.
24			*
25			* @var int
26			*/
27			protected $currentBatch;
28
29			/**
30			* List of indexes successfully comitted in the current batch
31			*
32			* @var array
33			*/
34			protected $completedIndexes;
35
36			/**
37			* Maximum number of record-states to process in one batch.
38			* Set to zero to process all records in a single batch
39			*
40			* @config
41			* @var int
42			*/
43			private static $batch_size = 100;
			0 ignored issues – show introduced 2018-03-14 04:25 UTC by Report Bug Copy Issue Report The private property `$batch_size` is not used, and could be removed. Loading history...
44
45			/**
46			* Up to this number of additional ids can be added to any batch in order to reduce the number
47			* of batches
48			*
49			* @config
50			* @var int
51			*/
52			private static $batch_soft_cap = 10;
			0 ignored issues – show introduced 2018-03-14 04:25 UTC by Report Bug Copy Issue Report The private property `$batch_soft_cap` is not used, and could be removed. Loading history...
53
54			public function __construct()
55			{
56			parent::__construct();
57
58			$this->batches = array();
59			$this->setBatch(0);
60			}
61
62			/**
63			* Set the current batch index
64			*
65			* @param int $batch Index of the batch
66			*/
67			protected function setBatch($batch)
68			{
69			$this->currentBatch = $batch;
70			}
71
72			protected function getSource()
73			{
74			if (isset($this->batches[$this->currentBatch])) {
75			return $this->batches[$this->currentBatch];
76			}
77			}
78
79			/**
80			* Process the current queue
81			*
82			* @return boolean
83			*/
84			public function process()
85			{
86			// Skip blank queues
87			if (empty($this->batches)) {
88			return true;
89			}
90
91			// Don't re-process completed queue
92			if ($this->currentBatch >= count($this->batches)) {
93			return true;
94			}
95
96			// Send current patch to indexes
97			$this->prepareIndexes();
98
99			// Advance to next batch if successful
100			$this->setBatch($this->currentBatch + 1);
101			return true;
102			}
103
104			/**
105			* Segments batches acording to the specified rules
106			*
107			* @param array $source Source input
108			* @return array Batches
109			*/
110			protected function segmentBatches($source)
111			{
112			// Measure batch_size
113			$batchSize = static::config()->get('batch_size');
114			if ($batchSize === 0) {
115			return array($source);
116			}
117			$softCap = static::config()->get('batch_soft_cap');
118
119			// Clear batches
120			$batches = array();
121			$current = array();
122			$currentSize = 0;
123
124			// Build batches from data
125			foreach ($source as $base => $statefulids) {
126			if (!$statefulids) {
127			continue;
128			}
129
130			foreach ($statefulids as $stateKey => $statefulid) {
131			$state = $statefulid['state'];
132			$ids = $statefulid['ids'];
133			if (!$ids) {
134			continue;
135			}
136
137			// Extract items from $ids until empty
138			while ($ids) {
139			// Estimate maximum number of items to take for this iteration, allowing for the soft cap
140			$take = $batchSize - $currentSize;
141			if (count($ids) <= $take + $softCap) {
142			$take += $softCap;
143			}
144			$items = array_slice($ids, 0, $take, true);
145			$ids = array_slice($ids, count($items), null, true);
146
147			// Update batch
148			$currentSize += count($items);
149			$merge = array(
150			$base => array(
151			$stateKey => array(
152			'state' => $state,
153			'ids' => $items
154			)
155			)
156			);
157			$current = $current ? array_merge_recursive($current, $merge) : $merge;
158			if ($currentSize >= $batchSize) {
159			$batches[] = $current;
160			$current = array();
161			$currentSize = 0;
162			}
163			}
164			}
165			}
166			// Add incomplete batch
167			if ($currentSize) {
168			$batches[] = $current;
169			}
170
171			return $batches;
172			}
173
174			public function batchData()
175			{
176			$this->batches = $this->segmentBatches($this->dirty);
177			$this->setBatch(0);
178			}
179
180			public function triggerProcessing()
181			{
182			$this->batchData();
183			}
184			}
185

silverstripe / silverstripe-fulltextsearch

SearchUpdateBatchedProcessor::process() A last analyzed 2022-08-08 23:38 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

SearchUpdateBatchedProcessor::process() A
last analyzed 2022-08-08 23:38 UTC