Wikibase\TermStore\MediaWiki\PackagePrivate\Util\ReplicaMasterAwareRecordIdsAcquirer

Complexity

Total Complexity

15

Size/Duplication

Total Lines	158
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;

/**
 * Allows acquiring ids of records in database table,
 * by insecting a given read-only replica database for initially
 * finding those records, falling back to a insert non-existing
 * records into a read-write master databas and getting those
 * ids as well from the master database.
 */
class ReplicaMasterAwareRecordIdsAcquirer {

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

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

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

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

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

	/**
	 * @param IDatabase $dbMaster master database to insert non-existing records into
	 * @param IDatabase $dbReplica replica database to initially query existing records in
	 * @param string $table the name of the table this acquirer is for
	 * @param string $idColumn the name of the column that contains the desired ids
	 * @param LoggerInterface $logger
	 */
	public function __construct(
		IDatabase $dbMaster,
		IDatabase $dbReplica,
		string $table,
		string $idColumn,
		LoggerInterface $logger = null
	) {
		$this->dbMaster = $dbMaster;

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

		$this->dbReplica = $dbReplica;

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

		$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?

	}

	/**
	 * Acquire ids of needed records in the table, inserting non-existing
	 * ones into master database.
	 *
	 * Note: this function assumes that all records given in this array specify
	 * the same columns. If some records specify less, more or different columns than
	 * the first one does, the behavior is not defined.
	 *
	 * @param array $neededRecords array of records to be looked-up or inserted.
	 *	Each entry in this array should an associative array of column => value pairs.
	 *	Example:
	 *	[
	 *		[ 'columnA' => 'valueA1', 'columnB' => 'valueB1' ],
	 *		[ 'columnA' => 'valueA2', 'columnB' => 'valueB2' ],
	 *		...
	 *	]
	 *
	 * @return array the array of input recrods along with their ids
	 *	Example:
	 *	[
	 *		[ 'columnA' => 'valueA1', 'columnB' => 'valueB1', 'idColumn' => '1' ],
	 *		[ 'columnA' => 'valueA2', 'columnB' => 'valueB2', 'idColumn' => '2' ],
	 *		...
	 *	]
	 */
	public function acquireIds( array $neededRecords ) {
		$existingRecords = $this->findExistingRecords( $this->dbReplica, $neededRecords );
		$neededRecords = $this->filterNonExistingRecords( $neededRecords, $existingRecords );

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

		return $existingRecords;
	}

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

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

		$existingRows = $db->select(
			$this->table,
			$selectColumns,
			$db->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 $db, array $neededRecords ) {
		$uniqueRecords = [];
		foreach ( $neededRecords as $record ) {
			$recordHash = $this->calcRecordHash( $record );
			if ( !isset( $uniqueRecords[$recordHash] ) ) {
				$uniqueRecords[$recordHash] = $record;
			}
		}

		try {
			$db->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 ): array {
		$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 ) );
	}

}