Index::deleteDocumentsByIds() - Code Metrics - Inspection of "This PR adds a method to delete multiple documents..." - manticoresoftware/manticoresearch-php - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 0c0986...0528ed )

unknown

created 2023-12-06 09:07 UTC

Index::deleteDocumentsByIds() A

↳ Parent: Index

Complexity

Conditions	2
Paths	2

Size

Total Lines	13
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	8
nc	2
nop	1
dl	0
loc	13
rs	10
c	0
b	0
f	0

<?php


namespace Manticoresearch;

use Manticoresearch\Exceptions\RuntimeException;
use Manticoresearch\Query\Percolate;
use Manticoresearch\Results;

/**
 * Manticore index object
 * @category ManticoreSearch
 * @package ManticoreSearch
 * @author Adrian Nuta <[email protected]>
 * @link https://manticoresearch.com
 */
class Index
{
    protected $client;
    protected $index;
    protected $cluster;

    public function __construct(Client $client, $index = null)
    {
        $this->client = $client;

        $this->index = $index;

        $this->cluster = null;
    }

    public function search($input): Search
    {
        $search = new Search($this->client);
        $search->setIndex($this->index);
        return $search->search($input);
    }

    public function getDocumentById($id)
    {
        static::checkDocumentId($id);
        $params = [
            'body' => [
                'index' => $this->index,
                'query' => [
                    'equals' => ['id' => $id]
                ]
            ]
        ];
        $result = new ResultSet($this->client->search($params, true));
        return $result->valid() ? $result->current() : null;
    }

    public function getDocumentByIds($ids)
    {
        if (!is_array($ids)) {
            $ids = [$ids];
        }
        array_walk($ids, [static::class, 'checkDocumentId']);
        $params = [
            'body' => [
                'index' => $this->index,
                'query' => [
                    'in' => ['id' => $ids]
                ]
            ]
        ];
        return new ResultSet($this->client->search($params, true));
    }

    public function addDocument($data, $id = 0)
    {
        static::checkDocumentId($id);
        if (is_object($data)) {
            $data = (array) $data;
        } elseif (is_string($data)) {
            $data = json_decode($data, true);
        }
        $params = [
            'body' => [
                'index' => $this->index,
                'id' => $id,
                'doc' => $data
            ]
        ];

        if ($this->cluster !== null) {
            $params['body']['cluster'] = $this->cluster;
        }
        return $this->client->insert($params);
    }

    public function addDocuments($documents)
    {
        $toinsert = [];
        foreach ($documents as $document) {
            if (is_object($document)) {
                $document = (array) $document;
            } elseif (is_string($document)) {
                $document = json_decode($document, true);
            }
            if (isset($document['id'])) {
                $id = $document['id'];
                static::checkDocumentId($id);
                unset($document['id']);
            } else {
                $id = 0;
            }
            $insert = [
                'index' => $this->index,
                'id' => $id,
                'doc' => $document
            ];
            if ($this->cluster !== null) {
                $insert['cluster'] = $this->cluster;
            }
            $toinsert[] = ['insert' => $insert];
        }
        return $this->client->bulk(['body' => $toinsert]);
    }

    public function deleteDocument($id)
    {
        static::checkDocumentId($id);
        $params = [
            'body' => [
                'index' => $this->index,
                'id' => $id
            ]
        ];
        if ($this->cluster !== null) {
            $params['body']['cluster'] = $this->cluster;
        }
        return $this->client->delete($params);
    }

    public function deleteDocumentsByIds(array $ids)
    {
        array_walk($ids, 'self::checkDocumentId');
        $params = [
            'body' => [
                'index' => $this->index,
                'id' => $ids
            ]
        ];
        if ($this->cluster !== null) {
            $params['body']['cluster'] = $this->cluster;
        }
        return $this->client->delete($params);
    }

    public function deleteDocuments($query)
    {
        if ($query instanceof Query) {
            $query = $query->toArray();
        }
        $params = [
            'body' => [
                'index' => $this->index,
                'query' => $query
            ]
        ];
        if ($this->cluster !== null) {
            $params['body']['cluster'] = $this->cluster;
        }
        return $this->client->delete($params);
    }

    public function updateDocument($data, $id)
    {
        static::checkDocumentId($id);
        $params = [
            'body' => [
                'index' => $this->index,
                'id' => $id,
                'doc' => $data
            ]
        ];
        if ($this->cluster !== null) {
            $params['body']['cluster'] = $this->cluster;
        }
        return $this->client->update($params);
    }

    public function updateDocuments($data, $query)
    {
        if ($query instanceof Query) {
            $query = $query->toArray();
        }
        $params = [
            'body' => [
                'index' => $this->index,
                'query' => $query,
                'doc' => $data
            ]
        ];
        if ($this->cluster !== null) {
            $params['body']['cluster'] = $this->cluster;
        }
        return $this->client->update($params);
    }

    public function replaceDocument($data, $id)
    {
        static::checkDocumentId($id);
        if (is_object($data)) {
            $data = (array) $data;
        } elseif (is_string($data)) {
            $data = json_decode($data, true);
        }
        $params = [
            'body' => [
                'index' => $this->index,
                'id' => $id,
                'doc' => $data
            ]
        ];
        if ($this->cluster !== null) {
            $params['body']['cluster'] = $this->cluster;
        }
        return $this->client->replace($params);
    }

    public function replaceDocuments($documents)
    {
        $toreplace = [];
        foreach ($documents as $document) {
            if (is_object($document)) {
                $document = (array) $document;
            } elseif (is_string($document)) {
                $document = json_decode($document, true);
            }
            $id = $document['id'];
            static::checkDocumentId($id);
            unset($document['id']);
            $replace = [
                'index' => $this->index,
                'id' => $id,
                'doc' => $document
            ];
            if ($this->cluster !== null) {
                $replace['cluster'] = $this->cluster;
            }
            $toreplace[] = ['replace' => $replace];
        }
        return $this->client->bulk(['body' => $toreplace]);
    }

    public function create($fields, $settings = [], $silent = false)
    {
        $params = [
            'index' => $this->index,
            'body' => [
                'columns' => $fields,
                'settings' => $settings
            ]
        ];
        if ($silent === true) {
            $params['body']['silent'] = true;
        }
        return $this->client->indices()->create($params);
    }

    public function drop($silent = false)
    {
        $params = [
            'index' => $this->index,
        ];
        if ($silent === true) {
            $params['body'] = ['silent' => true];
        }
        return $this->client->indices()->drop($params);
    }

    public function describe()
    {
        $params = [
            'index' => $this->index,
        ];
        return $this->client->indices()->describe($params);
    }

    public function status()
    {
        $params = [
            'index' => $this->index,
        ];
        return $this->client->indices()->status($params);
    }

    public function truncate()
    {
        $params = [
            'index' => $this->index,
        ];
        return $this->client->indices()->truncate($params);
    }

    public function optimize($sync = false)
    {
        $params = [
            'index' => $this->index,
        ];
        if ($sync === true) {
            $params['body'] = ['sync' => true];
        }
        return $this->client->indices()->optimize($params);
    }

    public function flush()
    {
        $params = [
            'index' => $this->index,
        ];
        $this->client->indices()->flushrtindex($params);
    }

    public function flushramchunk()
    {
        $params = [
            'index' => $this->index,
        ];
        $this->client->indices()->flushramchunk($params);
    }

    public function alter($operation, $name, $type = null)
    {
        if ($operation === 'add') {
            $params = [
                'index' => $this->index,
                'body' => [
                    'operation' => 'add',
                    'column' => ['name' => $name, 'type' => $type]
                ]
            ];
        } elseif ($operation === 'drop') {
            $params = [
                'index' => $this->index,
                'body' => [
                    'operation' => 'drop',
                    'column' => ['name' => $name]
                ]
            ];
        } else {
            throw new RuntimeException('Alter operation not recognized');
        }
        return $this->client->indices()->alter($params);
    }

    public function keywords($query, $options)
    {
        $params = [
            'index' => $this->index,
            'body' => [
                'query' => $query,
                'options' => $options
            ]
        ];
        return $this->client->keywords($params);
    }

    public function suggest($query, $options)
    {
        $params = [
            'index' => $this->index,
            'body' => [
                'query' => $query,
                'options' => $options
            ]
        ];
        return $this->client->suggest($params);
    }

    public function explainQuery($query)
    {
        $params = [
            'index' => $this->index,
            'body' => [
                'query' => $query,
            ]
        ];
        return $this->client->explainQuery($params);
    }


    public function percolate($docs)
    {
        $params = ['index' => $this->index, 'body' => []];
        if ($docs instanceof Percolate) {
            $params['body']['query'] = $docs->toArray();
        } else {
            if (isset($docs[0]) && is_array($docs[0])) {
                $params['body']['query'] = ['percolate' => ['documents' => $docs]];
            } else {
                $params['body']['query'] = ['percolate' => ['document' => $docs]];
            }
        }
        return new Results\PercolateResultSet($this->client->pq()->search($params, true));
    }

    public function percolateToDocs($docs)
    {
        $params = ['index' => $this->index, 'body' => []];
        if ($docs instanceof Percolate) {
            $params['body']['query'] = $docs->toArray();
        } else {
            if (isset($docs[0]) && is_array($docs[0])) {
                $params['body']['query'] = ['percolate' => ['documents' => $docs]];
            } else {
                $params['body']['query'] = ['percolate' => ['document' => $docs]];
            }
        }
        return new Results\PercolateDocsResultSet($this->client->pq()->search($params, true), $docs);
    }


    public function getClient(): Client
    {
        return $this->client;
    }

    public function getName(): string
    {
        return $this->index;
    }

    public function setName($index): self
    {
        $this->index = $index;
        return $this;
    }

    public function setCluster($cluster): self
    {
        $this->cluster = $cluster;
        return $this;
    }

    protected static function checkDocumentId(&$id)
    {
        if (is_string($id) && !is_numeric($id)) {
            throw new RuntimeException('Incorrect document id passed');
        }
        $id = (int)$id;
    }
}


1			<?php
2
3
4			namespace Manticoresearch;
5
6			use Manticoresearch\Exceptions\RuntimeException;
7			use Manticoresearch\Query\Percolate;
8			use Manticoresearch\Results;
9
10			/**
11			* Manticore index object
12			* @category ManticoreSearch
13			* @package ManticoreSearch
14			* @author Adrian Nuta <[email protected]>
15			* @link https://manticoresearch.com
16			*/
17			class Index
18			{
19			protected $client;
20			protected $index;
21			protected $cluster;
22
23			public function __construct(Client $client, $index = null)
24			{
25			$this->client = $client;
26
27			$this->index = $index;
28
29			$this->cluster = null;
30			}
31
32			public function search($input): Search
33			{
34			$search = new Search($this->client);
35			$search->setIndex($this->index);
36			return $search->search($input);
37			}
38
39			public function getDocumentById($id)
40			{
41			static::checkDocumentId($id);
42			$params = [
43			'body' => [
44			'index' => $this->index,
45			'query' => [
46			'equals' => ['id' => $id]
47			]
48			]
49			];
50			$result = new ResultSet($this->client->search($params, true));
51			return $result->valid() ? $result->current() : null;
52			}
53
54			public function getDocumentByIds($ids)
55			{
56			if (!is_array($ids)) {
57			$ids = [$ids];
58			}
59			array_walk($ids, [static::class, 'checkDocumentId']);
60			$params = [
61			'body' => [
62			'index' => $this->index,
63			'query' => [
64			'in' => ['id' => $ids]
65			]
66			]
67			];
68			return new ResultSet($this->client->search($params, true));
69			}
70
71			public function addDocument($data, $id = 0)
72			{
73			static::checkDocumentId($id);
74			if (is_object($data)) {
75			$data = (array) $data;
76			} elseif (is_string($data)) {
77			$data = json_decode($data, true);
78			}
79			$params = [
80			'body' => [
81			'index' => $this->index,
82			'id' => $id,
83			'doc' => $data
84			]
85			];
86
87			if ($this->cluster !== null) {
88			$params['body']['cluster'] = $this->cluster;
89			}
90			return $this->client->insert($params);
91			}
92
93			public function addDocuments($documents)
94			{
95			$toinsert = [];
96			foreach ($documents as $document) {
97			if (is_object($document)) {
98			$document = (array) $document;
99			} elseif (is_string($document)) {
100			$document = json_decode($document, true);
101			}
102			if (isset($document['id'])) {
103			$id = $document['id'];
104			static::checkDocumentId($id);
105			unset($document['id']);
106			} else {
107			$id = 0;
108			}
109			$insert = [
110			'index' => $this->index,
111			'id' => $id,
112			'doc' => $document
113			];
114			if ($this->cluster !== null) {
115			$insert['cluster'] = $this->cluster;
116			}
117			$toinsert[] = ['insert' => $insert];
118			}
119			return $this->client->bulk(['body' => $toinsert]);
120			}
121
122			public function deleteDocument($id)
123			{
124			static::checkDocumentId($id);
125			$params = [
126			'body' => [
127			'index' => $this->index,
128			'id' => $id
129			]
130			];
131			if ($this->cluster !== null) {
132			$params['body']['cluster'] = $this->cluster;
133			}
134			return $this->client->delete($params);
135			}
136
137			public function deleteDocumentsByIds(array $ids)
138			{
139			array_walk($ids, 'self::checkDocumentId');
140			$params = [
141			'body' => [
142			'index' => $this->index,
143			'id' => $ids
144			]
145			];
146			if ($this->cluster !== null) {
147			$params['body']['cluster'] = $this->cluster;
148			}
149			return $this->client->delete($params);
150			}
151
152			public function deleteDocuments($query)
153			{
154			if ($query instanceof Query) {
155			$query = $query->toArray();
156			}
157			$params = [
158			'body' => [
159			'index' => $this->index,
160			'query' => $query
161			]
162			];
163			if ($this->cluster !== null) {
164			$params['body']['cluster'] = $this->cluster;
165			}
166			return $this->client->delete($params);
167			}
168
169			public function updateDocument($data, $id)
170			{
171			static::checkDocumentId($id);
172			$params = [
173			'body' => [
174			'index' => $this->index,
175			'id' => $id,
176			'doc' => $data
177			]
178			];
179			if ($this->cluster !== null) {
180			$params['body']['cluster'] = $this->cluster;
181			}
182			return $this->client->update($params);
183			}
184
185			public function updateDocuments($data, $query)
186			{
187			if ($query instanceof Query) {
188			$query = $query->toArray();
189			}
190			$params = [
191			'body' => [
192			'index' => $this->index,
193			'query' => $query,
194			'doc' => $data
195			]
196			];
197			if ($this->cluster !== null) {
198			$params['body']['cluster'] = $this->cluster;
199			}
200			return $this->client->update($params);
201			}
202
203			public function replaceDocument($data, $id)
204			{
205			static::checkDocumentId($id);
206			if (is_object($data)) {
207			$data = (array) $data;
208			} elseif (is_string($data)) {
209			$data = json_decode($data, true);
210			}
211			$params = [
212			'body' => [
213			'index' => $this->index,
214			'id' => $id,
215			'doc' => $data
216			]
217			];
218			if ($this->cluster !== null) {
219			$params['body']['cluster'] = $this->cluster;
220			}
221			return $this->client->replace($params);
222			}
223
224			public function replaceDocuments($documents)
225			{
226			$toreplace = [];
227			foreach ($documents as $document) {
228			if (is_object($document)) {
229			$document = (array) $document;
230			} elseif (is_string($document)) {
231			$document = json_decode($document, true);
232			}
233			$id = $document['id'];
234			static::checkDocumentId($id);
235			unset($document['id']);
236			$replace = [
237			'index' => $this->index,
238			'id' => $id,
239			'doc' => $document
240			];
241			if ($this->cluster !== null) {
242			$replace['cluster'] = $this->cluster;
243			}
244			$toreplace[] = ['replace' => $replace];
245			}
246			return $this->client->bulk(['body' => $toreplace]);
247			}
248
249			public function create($fields, $settings = [], $silent = false)
250			{
251			$params = [
252			'index' => $this->index,
253			'body' => [
254			'columns' => $fields,
255			'settings' => $settings
256			]
257			];
258			if ($silent === true) {
259			$params['body']['silent'] = true;
260			}
261			return $this->client->indices()->create($params);
262			}
263
264			public function drop($silent = false)
265			{
266			$params = [
267			'index' => $this->index,
268			];
269			if ($silent === true) {
270			$params['body'] = ['silent' => true];
271			}
272			return $this->client->indices()->drop($params);
273			}
274
275			public function describe()
276			{
277			$params = [
278			'index' => $this->index,
279			];
280			return $this->client->indices()->describe($params);
281			}
282
283			public function status()
284			{
285			$params = [
286			'index' => $this->index,
287			];
288			return $this->client->indices()->status($params);
289			}
290
291			public function truncate()
292			{
293			$params = [
294			'index' => $this->index,
295			];
296			return $this->client->indices()->truncate($params);
297			}
298
299			public function optimize($sync = false)
300			{
301			$params = [
302			'index' => $this->index,
303			];
304			if ($sync === true) {
305			$params['body'] = ['sync' => true];
306			}
307			return $this->client->indices()->optimize($params);
308			}
309
310			public function flush()
311			{
312			$params = [
313			'index' => $this->index,
314			];
315			$this->client->indices()->flushrtindex($params);
316			}
317
318			public function flushramchunk()
319			{
320			$params = [
321			'index' => $this->index,
322			];
323			$this->client->indices()->flushramchunk($params);
324			}
325
326			public function alter($operation, $name, $type = null)
327			{
328			if ($operation === 'add') {
329			$params = [
330			'index' => $this->index,
331			'body' => [
332			'operation' => 'add',
333			'column' => ['name' => $name, 'type' => $type]
334			]
335			];
336			} elseif ($operation === 'drop') {
337			$params = [
338			'index' => $this->index,
339			'body' => [
340			'operation' => 'drop',
341			'column' => ['name' => $name]
342			]
343			];
344			} else {
345			throw new RuntimeException('Alter operation not recognized');
346			}
347			return $this->client->indices()->alter($params);
348			}
349
350			public function keywords($query, $options)
351			{
352			$params = [
353			'index' => $this->index,
354			'body' => [
355			'query' => $query,
356			'options' => $options
357			]
358			];
359			return $this->client->keywords($params);
360			}
361
362			public function suggest($query, $options)
363			{
364			$params = [
365			'index' => $this->index,
366			'body' => [
367			'query' => $query,
368			'options' => $options
369			]
370			];
371			return $this->client->suggest($params);
372			}
373
374			public function explainQuery($query)
375			{
376			$params = [
377			'index' => $this->index,
378			'body' => [
379			'query' => $query,
380			]
381			];
382			return $this->client->explainQuery($params);
383			}
384
385
386			public function percolate($docs)
387			{
388			$params = ['index' => $this->index, 'body' => []];
389			if ($docs instanceof Percolate) {
390			$params['body']['query'] = $docs->toArray();
391			} else {
392			if (isset($docs[0]) && is_array($docs[0])) {
393			$params['body']['query'] = ['percolate' => ['documents' => $docs]];
394			} else {
395			$params['body']['query'] = ['percolate' => ['document' => $docs]];
396			}
397			}
398			return new Results\PercolateResultSet($this->client->pq()->search($params, true));
399			}
400
401			public function percolateToDocs($docs)
402			{
403			$params = ['index' => $this->index, 'body' => []];
404			if ($docs instanceof Percolate) {
405			$params['body']['query'] = $docs->toArray();
406			} else {
407			if (isset($docs[0]) && is_array($docs[0])) {
408			$params['body']['query'] = ['percolate' => ['documents' => $docs]];
409			} else {
410			$params['body']['query'] = ['percolate' => ['document' => $docs]];
411			}
412			}
413			return new Results\PercolateDocsResultSet($this->client->pq()->search($params, true), $docs);
414			}
415
416
417			public function getClient(): Client
418			{
419			return $this->client;
420			}
421
422			public function getName(): string
423			{
424			return $this->index;
425			}
426
427			public function setName($index): self
428			{
429			$this->index = $index;
430			return $this;
431			}
432
433			public function setCluster($cluster): self
434			{
435			$this->cluster = $cluster;
436			return $this;
437			}
438
439			protected static function checkDocumentId(&$id)
440			{
441			if (is_string($id) && !is_numeric($id)) {
442			throw new RuntimeException('Incorrect document id passed');
443			}
444			$id = (int)$id;
445			}
446			}
447

manticoresoftware / manticoresearch-php

Push — master ( 0c0986...0528ed )

Index::deleteDocumentsByIds() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like