DAOPreparedQuery::updatePrepareStatement() - Code Metrics - Inspection of "Dao async opt (#139)" - phpMv/ubiquity - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 768736...0faf86 )

by Jean-Christophe

created 2020-08-02 01:23 UTC

DAOPreparedQuery::updatePrepareStatement() A

↳ Parent: DAOPreparedQuery

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
eloc	2
c	0
b	0
f	0
dl	0
loc	3
ccs	0
cts	0
cp	0
rs	10
cc	1
nc	1
nop	0
crap	2

<?php
namespace Ubiquity\orm\core\prepared;

use Ubiquity\db\SqlUtils;
use Ubiquity\orm\DAO;
use Ubiquity\orm\OrmUtils;
use Ubiquity\orm\parser\ConditionParser;
use Ubiquity\cache\database\DbCache;

/**
 * Ubiquity\orm\core\prepared$DAOPreparedQuery
 * This class is part of Ubiquity
 *
 * @author jcheron <[email protected]>
 * @version 1.0.6
 *
 */
abstract class DAOPreparedQuery {

	protected $databaseOffset;

	/**
	 *
	 * @var ConditionParser
	 */
	protected $conditionParser;

	protected $included;

	protected $hasIncluded;

	protected $useCache;

	protected $className;

	protected $tableName;

	protected $invertedJoinColumns = null;

	protected $oneToManyFields = null;

	protected $manyToManyFields = null;

	protected $transformers;

	protected $propsKeys;

	protected $accessors;

	protected $fieldList;

	protected $memberList;

	protected $firstPropKey;

	protected $condition;

	protected $preparedCondition;

	protected $additionalMembers = false;

	protected $sqlAdditionalMembers = "";

	protected $allPublic = false;

	protected $statement;

	/**
	 *
	 * @var \Ubiquity\db\Database
	 */
	protected $db;

	public function __construct($className, $condition = null, $included = false, $cache = null) {
		$this->className = $className;
		$this->included = $included;
		$this->condition = $condition;
		$this->conditionParser = new ConditionParser($condition);
		$this->prepare($cache);
	}

	public function getFirstPropKey() {
		return $this->firstPropKey;
	}

	/**
	 *
	 * @return \Ubiquity\db\Database
	 */
	public function getDb() {
		return $this->db;
	}

	/**
	 *
	 * @return mixed
	 */
	public function getDatabaseOffset() {
		return $this->databaseOffset;
	}

	/**
	 *
	 * @return \Ubiquity\orm\parser\ConditionParser
	 */
	public function getConditionParser() {
		return $this->conditionParser;
	}

	/**
	 *
	 * @return mixed
	 */
	public function getIncluded() {
		return $this->included;
	}

	/**
	 *
	 * @return boolean
	 */
	public function getHasIncluded() {
		return $this->hasIncluded;
	}

	/**
	 *
	 * @return mixed
	 */
	public function getUseCache() {
		return $this->useCache;
	}

	/**
	 *
	 * @return mixed
	 */
	public function getClassName() {
		return $this->className;
	}

	/**
	 *
	 * @return mixed
	 */
	public function getTableName() {
		return $this->tableName;
	}

	/**
	 *
	 * @return mixed
	 */
	public function getInvertedJoinColumns() {
		return $this->invertedJoinColumns;
	}

	/**
	 *
	 * @return mixed
	 */
	public function getOneToManyFields() {
		return $this->oneToManyFields;
	}

	/**
	 *
	 * @return mixed
	 */
	public function getManyToManyFields() {
		return $this->manyToManyFields;
	}

	public function getTransformers() {
		return $this->transformers;
	}

	public function getPropsKeys() {
		return $this->propsKeys;
	}

	/**
	 *
	 * @return mixed
	 */
	public function getAccessors() {
		return $this->accessors;
	}

	public function getFieldList() {
		return $this->fieldList;
	}

	/**
	 *
	 * @return mixed
	 */
	public function getMemberList() {
		return $this->memberList;
	}

	protected function prepare(?DbCache $cache = null) {
		$this->db = DAO::getDb($this->className);
		if (isset($cache)) {
			$this->db->setCacheInstance($cache);
		}
		$this->included = DAO::_getIncludedForStep($this->included);

		$metaDatas = OrmUtils::getModelMetadata($this->className);
		$this->tableName = $metaDatas['#tableName'];
		$this->hasIncluded = $this->included || (\is_array($this->included) && \sizeof($this->included) > 0);
		if ($this->hasIncluded) {
			DAO::_initRelationFields($this->included, $metaDatas, $this->invertedJoinColumns, $this->oneToManyFields, $this->manyToManyFields);
		}
		$this->transformers = $metaDatas['#transformers'][DAO::$transformerOp] ?? [];
		$this->fieldList = DAO::_getFieldList($this->tableName, $metaDatas);
		$this->memberList = \array_flip(\array_diff($metaDatas['#fieldNames'], $metaDatas['#notSerializable']));
		$this->propsKeys = OrmUtils::getPropKeys($this->className);

		$this->firstPropKey = OrmUtils::getFirstPropKey($this->className);
		if (! ($this->allPublic = OrmUtils::hasAllMembersPublic($this->className))) {
			$this->accessors = $metaDatas['#accessors'];
		}
	}

	protected function updatePrepareStatement() {
		$this->preparedCondition = SqlUtils::checkWhere($this->conditionParser->getCondition());
		$this->statement = $this->db->getDaoPreparedStatement($this->tableName, $this->preparedCondition, $this->fieldList . $this->sqlAdditionalMembers);
	}

	protected function updateSqlAdditionalMembers() {
		if ($this->additionalMembers) {
			$this->sqlAdditionalMembers = ',' . $this->parseExpressions();
			$this->updatePrepareStatement();
		}
	}

	protected function parseExpressions() {
		return \implode(',', $this->additionalMembers);
		return \implode(',', /** @scrutinizer ignore-type */ $this->additionalMembers);
	}

	protected function addAditionnalMembers($object, $row) {
		foreach ($this->additionalMembers as $member => $_) {

			$object->{$member} = $row[$member] ?? null;
			$object->_rest[$member] = $row[$member] ?? null;
		}
	}

	abstract public function execute($params = [], $useCache = false);

	/**
	 * Adds a new expression and associates it with a new member of the class added at runtime.
	 *
	 * @param string $sqlExpression
	 *        	The SQL expression (part of the SQL SELECT)
	 * @param string $memberName
	 *        	The new associated member name
	 */
	public function addMember(string $sqlExpression, string $memberName): void {
		$this->additionalMembers[$memberName] = $sqlExpression . " AS '{$memberName}'";
		$this->updateSqlAdditionalMembers();
	}

	/**
	 * Adds new expressions and their associated members at runtime.
	 *
	 * @param array $expressionsNames
	 *        	An associative array of [memberName=>sqlExpression,...]
	 */
	public function addMembers(array $expressionsNames): void {
		foreach ($expressionsNames as $member => $expression) {
			$this->additionalMembers[$member] = $expression . " AS '{$member}'";
		}
		$this->updateSqlAdditionalMembers();
	}

	/**
	 * Store the cache for a prepared Query
	 */
	public function storeDbCache() {
		$this->db->storeCache();
	}
}


phpMv / ubiquity

Push — master ( 768736...0faf86 )

DAOPreparedQuery::updatePrepareStatement() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like