Wikibase\TermStore\MediaWiki\PackagePrivate\Util\ReplicaMasterAwareRecordIdsAcquirer

Complexity

Total Complexity

15

Size/Duplication

Total Lines	126
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	1
A	acquireIds()	0	15	2
A	findExistingRecords()	0	25	3
A	insertNonExistingRecords()	0	22	4
A	filterNonExistingRecords()	0	19	4
A	calcRecordHash()	0	4	1

<?php

namespace Wikibase\TermStore\MediaWiki\PackagePrivate\Util;

use AppendIterator;
use ArrayIterator;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use Wikimedia\Rdbms\DBQueryError;
use Wikimedia\Rdbms\IDatabase;

class ReplicaMasterAwareRecordIdsAcquirer {

	/**
	 * @var Database $dbw
	 */
	private $dbw;

	/**
	 * @var Database $dbr
	 */
	private $dbr;

	/** @var string $table */
	private $table;

	/** @var string $idColumn */
	private $idColumn;

	/** @var LoggerInterface $logger */
	private $logger;

	public function __construct(
		IDatabase $dbw,
		IDatabase $dbr,
		string $table,
		string $idColumn,
		LoggerInterface $logger = null
	) {
		$this->dbw = $dbw;

It seems like $dbw of type object<Wikimedia\Rdbms\IDatabase> is incompatible with the declared type object<Wikibase\TermStore\MediaWiki\PackagePrivate\Util\Database> of property $dbw.

		$this->dbr = $dbr;

It seems like $dbr of type object<Wikimedia\Rdbms\IDatabase> is incompatible with the declared type object<Wikibase\TermStore\MediaWiki\PackagePrivate\Util\Database> of property $dbr.

		$this->table = $table;
		$this->idColumn = $idColumn;
		$this->logger = $logger ?? new NullLogger();

It seems like $logger ?? new \Psr\Log\NullLogger() can also be of type object<Psr\Log\NullLogger>. However, the property $logger is declared as type object<Psr\Log\LoggerInterface>. Maybe add an additional type check?

	}

	public function acquireIds( array $neededRecords ) {
		$existingRecords = $this->findExistingRecords( $this->dbr, $neededRecords );
		$neededRecords = $this->filterNonExistingRecords( $neededRecords, $existingRecords );

		while ( !empty( $neededRecords ) ) {
			$this->insertNonExistingRecords( $this->dbw, $neededRecords );
			$existingRecords = array_merge(
				$existingRecords,
				$this->findExistingRecords( $this->dbw, $neededRecords )
			);
			$neededRecords = $this->filterNonExistingRecords( $neededRecords, $existingRecords );
		}

		return $existingRecords;
	}

	private function findExistingRecords( IDatabase $dbr, array $neededRecords ) {
		$recordsSelectConditions = array_map( function ( $record ) use ( $dbr ) {
			return $dbr->makeList( $record, IDatabase::LIST_AND );
		}, $neededRecords );

		$selectColumns = array_keys( $neededRecords[0] );
		$selectColumns[] = $this->idColumn;

		$existingRows = $dbr->select(
			$this->table,
			$selectColumns,
			$dbr->makeList( $recordsSelectConditions, IDatabase::LIST_OR )
		);

		$existingRecords = [];
		foreach ( $existingRows as $row ) {
			$existingRecord = [];
			foreach ( $selectColumns as $column ) {
				$existingRecord[$column] = $row->$column;
			}
			$existingRecords[] = $existingRecord;
		}

		return $existingRecords;
	}

	private function insertNonExistingRecords( IDatabase $dbw, array $neededRecords ) {

The parameter $dbw is not used and could be removed.

		$uniqueRecords = [];
		foreach ( $neededRecords as $record ) {
			$recordHash = $this->calcRecordHash( $record );
			if ( !isset( $uniqueRecords[$recordHash] ) ) {
				$uniqueRecords[$recordHash] = $record;
			}
		}

		try {
			$this->dbw->insert( $this->table, array_values( $uniqueRecords ) );
		} catch ( DBQueryError $dbError ) {

The class Wikimedia\Rdbms\DBQueryError does not exist. Did you forget a USE statement, or did you not list all dependencies?

			$this->logger->info(
				'{method}: Inserting records {records} into {table} failed. {exception}',
				[
					'exception' => $dbError,
					'table' => $this->table,
					'records' => $uniqueRecords
				]
			);
		}
	}

	private function filterNonExistingRecords( $neededRecords, $existingRecords ) {
		$existingRecordsHashes = [];
		foreach ( $existingRecords as $record ) {
			unset( $record[$this->idColumn] );
			$recordHash = $this->calcRecordHash( $record );
			$existingRecordsHashes[$recordHash] = true;
		}

		$nonExistingRecords = [];
		foreach ( $neededRecords as $record ) {
			$recordHash = $this->calcRecordHash( $record );

			if ( !isset( $existingRecordsHashes[$recordHash] ) ) {
				$nonExistingRecords[] = $record;
			}
		}

		return $nonExistingRecords;
	}

	private function calcRecordHash( $record ) {
		ksort( $record );
		return md5( serialize( $record ) );
	}

}