OrmUtilsRelationsTrait::getMemberJoinColumns() - Code Metrics - phpMv/ubiquity - Measure and Improve Code Quality continuously with Scrutinizer

OrmUtilsRelationsTrait::getMemberJoinColumns() A
last analyzed 2023-05-30 15:31 UTC

↳ Parent: OrmUtilsRelationsTrait

Complexity

Conditions	5
Paths	9

Size

Total Lines	16
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	9
CRAP Score	5.1502

Importance

Changes

Metric	Value
eloc	11
dl	0
loc	16
ccs	9
cts	11
cp	0.8182
rs	9.6111
c	0
b	0
f	0
cc	5
nc	9
nop	3
crap	5.1502

<?php

namespace Ubiquity\orm\traits;

use Ubiquity\orm\parser\ManyToManyParser;

/**
 * Trait for DAO relations.
 * Ubiquity\orm\traits$OrmUtilsRelationsTrait
 * This class is part of Ubiquity
 *
 * @author jcheron <[email protected]>
 * @version 1.0.8
 *
 */
trait OrmUtilsRelationsTrait {
	
	abstract public static function getAnnotationInfoMember($class, $keyAnnotation, $member);
	
	abstract public static function getAnnotationInfo($class, $keyAnnotation);
	
	abstract public static function getTableName($class);
	
	abstract public static function getFirstKey($class);
	
	abstract public static function getModelMetadata($className);
	
	abstract public static function getKeyFieldsAndValues($instance);
	
	public static function getJoinTables($class) {
		$result = [ ];
		
		if (isset ( self::getModelMetadata ( $class ) ['#joinTable'] )) {
			$jts = self::getModelMetadata ( $class ) ['#joinTable'];
			foreach ( $jts as $jt ) {
				$result [] = $jt ['name'];
			}
		}
		return $result;
	}
	
	public static function getAllJoinTables($models) {
		$result = [ ];
		foreach ( $models as $model ) {
			$result = \array_merge ( $result, self::getJoinTables ( $model ) );
		}
		return $result;
	}
	
	public static function getFieldsInRelations($class) {
		$result = [ ];
		
		if ($manyToOne = self::getAnnotationInfo ( $class, '#manyToOne' )) {
			$result = \array_merge ( $result, $manyToOne );
		}
		if ($oneToMany = self::getAnnotationInfo ( $class, '#oneToMany' )) {
			$result = \array_merge ( $result, \array_keys ( $oneToMany ) );
		}
		if ($manyToMany = self::getAnnotationInfo ( $class, '#manyToMany' )) {
			$result = \array_merge ( $result, \array_keys ( $manyToMany ) );
		}
		return $result;
	}
	
	public static function getRelationInfos($class) {
		$result = [ ];
		$joinColumns = self::getAnnotationInfo ( $class, '#joinColumn' );
		$invertedJoinColumns = self::getAnnotationInfo ( $class, '#invertedJoinColumn' );
		if ($manyToOne = self::getAnnotationInfo ( $class, '#manyToOne' )) {
			foreach ( $manyToOne as $oneField ) {
				$field = $joinColumns [$oneField] ['name'];
				$result [$field] = $invertedJoinColumns [$field];
				$result [$oneField] = $invertedJoinColumns [$field];
			}
		}
		if ($oneToMany = self::getAnnotationInfo ( $class, '#oneToMany' )) {
			$result = \array_merge ( $result, $oneToMany );
		}
		if ($manyToMany = self::getAnnotationInfo ( $class, '#manyToMany' )) {
			$result = \array_merge ( $result, $manyToMany );
		}
		return $result;
	}
	
	public static function getFieldsInRelations_($class) {
		return self::getFieldsInRelationsForUpdate_ ( $class ) ['relations'];
	}
	
	public static function getFieldsInRelationsForUpdate_($class) {
		$result = [ ];
		if ($manyToOne = self::getAnnotationInfo ( $class, '#manyToOne' )) {
			foreach ( $manyToOne as $member ) {
				$joinColumn = self::getAnnotationInfoMember ( $class, '#joinColumn', $member );
				$result [$joinColumn ['name']] = $member;
			}
		}
		if ($manyToMany = self::getAnnotationInfo ( $class, "#manyToMany" )) {
			$manyToMany = array_keys ( $manyToMany );
			foreach ( $manyToMany as $member ) {
				$result [$member . 'Ids'] = $member;
			}
		}
		if ($oneToMany = self::getAnnotationInfo ( $class, '#oneToMany' )) {
			$oneToMany = array_keys ( $oneToMany );
			foreach ( $oneToMany as $member ) {
				$result [$member . 'Ids'] = $member;
			}
		}
		return [ 'relations' => $result,'manyToOne' => $manyToOne,'manyToMany' => $manyToMany,'oneToMany' => $oneToMany ];
	}
	
	public static function getAnnotFieldsInRelations($class) {
		$result = [ ];
		if ($manyToOnes = self::getAnnotationInfo ( $class, '#manyToOne' )) {
			$joinColumns = self::getAnnotationInfo ( $class, '#joinColumn' );
			foreach ( $manyToOnes as $manyToOne ) {
				if (isset ( $joinColumns [$manyToOne] )) {
					$result [$manyToOne] = [ 'type' => 'manyToOne','value' => $joinColumns [$manyToOne] ];
				}
			}
		}
		if ($oneToManys = self::getAnnotationInfo ( $class, '#oneToMany' )) {
			foreach ( $oneToManys as $field => $oneToMany ) {
				$result [$field] = [ 'type' => 'oneToMany','value' => $oneToMany ];
			}
		}
		if ($manyToManys = self::getAnnotationInfo ( $class, "#manyToMany" )) {
			foreach ( $manyToManys as $field => $manyToMany ) {
				$result [$field] = [ 'type' => 'manyToMany','value' => $manyToMany ];
			}
		}
		return $result;
	}
	
	public static function getUJoinSQL($db, $model, $arrayAnnot, $field, &$aliases, $quote) {
		$type = $arrayAnnot ['type'];
		$annot = $arrayAnnot ['value'];
		$table = self::getTableName ( $model );
		$tableAlias = (isset ( $aliases [$table] )) ? $aliases [$table] : $table;
		if ($type === 'manyToOne') {
			$fkClass = $annot ['className'];
			$fkTable = self::getTableName ( $fkClass );
			$fkField = $annot ['name'];
			$pkField = self::getFirstKey ( $fkClass );
			$alias = self::getJoinAlias ( $table, $fkTable );
			$result = "LEFT JOIN {$quote}{$fkTable}{$quote} {$quote}{$alias}{$quote} ON {$quote}{$tableAlias}{$quote}.{$quote}{$fkField}{$quote}={$quote}{$alias}{$quote}.{$quote}{$pkField}{$quote}";
		} elseif ($type === 'oneToMany') {
			$fkClass = $annot ['className'];
			$fkAnnot = self::getAnnotationInfoMember ( $fkClass, '#joinColumn', $annot ['mappedBy'] );
			$fkTable = self::getTableName ( $fkClass );
			$fkField = $fkAnnot ['name'];
			$pkField = self::getFirstKey ( $model );
			$alias = self::getJoinAlias ( $table, $fkTable );
			$result = "LEFT JOIN {$quote}{$fkTable}{$quote} {$quote}{$alias}{$quote} ON {$quote}{$tableAlias}{$quote}.{$quote}{$pkField}{$quote}={$quote}{$alias}{$quote}.{$quote}{$fkField}{$quote}";
		} else {
			$parser = new ManyToManyParser ( $db, $model, $field );
			$parser->init ( $annot );
			$fkTable = $parser->getTargetEntityTable ();
			$fkClass = $parser->getTargetEntityClass ();
			$alias = self::getJoinAlias ( $table, $fkTable );
			$result = $parser->getSQL ( $alias, $aliases );
		}
		
		if (array_search ( $alias, $aliases ) !== false) {
			$result = "";
		}
		$aliases [$fkTable] = $alias;
		return [ 'class' => $fkClass,'table' => $fkTable,'sql' => $result,'alias' => $alias ];
	}
	
	private static function getJoinAlias($table, $fkTable) {
		return \uniqid ( $fkTable . '_' . $table [0] );
	}
	
	public static function getOneToManyFields($class) {
		return self::getAnnotationInfo ( $class, '#oneToMany' );
	}
	
	public static function getRemoveCascadeFields($class,$keyAnnotation='#oneToMany') {
		$infos= self::getAnnotationInfo ( $class, $keyAnnotation);
		$res=[];
		if($infos!==false){
			foreach ($infos as $f=>$annot){
				if(\array_search('remove',$annot['cascade']??[])!==false){
					$res[]=$f;
				}
			}
		}
		return $res;
	}
	
	public static function getManyToOneFields($class) {
		return self::getAnnotationInfo ( $class, '#manyToOne' );
	}
	
	public static function getManyToManyFields($class) {
		$result = self::getAnnotationInfo ( $class, '#manyToMany' );
		if ($result !== false)
			return \array_keys ( $result );
			return [ ];
	}
	
	public static function getDefaultFk($classname) {
		return 'id' . \ucfirst ( self::getTableName ( $classname ) );
	}
	
	public static function getMemberJoinColumns($instance, $member, $metaDatas = NULL) {
		if (! isset ( $metaDatas )) {
			if (\is_object ( $instance )) {
				$class = \get_class ( $instance );
			} else {
				$class = $instance;
			}
			$metaDatas = self::getModelMetadata ( $class );
		}
		$invertedJoinColumns = $metaDatas ['#invertedJoinColumn'];
		foreach ( $invertedJoinColumns as $field => $invertedJoinColumn ) {
			if ($invertedJoinColumn ['member'] === $member) {
				return [ $field,$invertedJoinColumn ];
			}
		}
		return null;
	}
	
	/**
	 *
	 * @param object $instance
	 * @return mixed[]
	 */
	public static function getManyToOneMembersAndValues($instance) {
		$ret = array ();
		$class = \get_class ( $instance );
		$members = self::getAnnotationInfo ( $class, '#manyToOne' );
		if ($members !== false) {
			foreach ( $members as $member ) {
				$memberAccessor = 'get' . ucfirst ( $member );
				if (\method_exists ( $instance, $memberAccessor )) {
					$memberInstance = $instance->$memberAccessor ();
					if (isset ( $memberInstance ) ){
						if(\is_object ( $memberInstance )) {
							$keyValues = self::getKeyFieldsAndValues($memberInstance);
							if (\count($keyValues) > 0) {
								$fkName = self::getJoinColumnName($class, $member);
								$ret [$fkName] = \current($keyValues);
							}
						}else{
							$fkName = self::getJoinColumnName($class, $member);
							$ret [$fkName] = $memberInstance;
						}
					} elseif (self::isNullable ( $class, $member )) {
						$fkName = self::getJoinColumnName ( $class, $member );
						$ret [$fkName] = null;
					}
				}
			}
		}
		return $ret;
	}
	
	public static function getJoinColumnName($class, $member) {
		$annot = self::getAnnotationInfoMember ( $class, '#joinColumn', $member );
		if ($annot !== false) {
			$fkName = $annot ['name'];
		} else {
			$fkName = 'id' . \ucfirst ( self::getTableName ( \ucfirst ( $member ) ) );
		}
		return $fkName;
	}
	
	public static function isManyToMany($class):bool{
		$metas=self::getModelMetadata ( $class );
		$pks=$metas['#primaryKeys'];
		$manyToOnes=$metas['#manyToOne'];
		$manysCount=\count($manyToOnes);
		$counter=0;
		if($manysCount>1) {
			foreach ($manyToOnes as $manyToOne) {
				$len = \strlen($manyToOne);
				foreach ($pks as $k) {
					if (\substr($k, -$len) === \ucfirst($manyToOne)) {
						$counter++;
					}
				}
			}
			return $counter>1;
		}
		return false;
	}
	
	public static function getManyToManyFieldsDt($class,$manyClass) {
		$fields=self::getSerializableMembers($manyClass);
		$joinColumns=self::getModelMetadata($manyClass)['#joinColumn'];
		foreach ($joinColumns as $joinColumn){
			if($joinColumn['className']===$class){
				if($index=\array_search($joinColumn['name'],$fields)!==false){
					unset($fields[$index]);
				}
			}
		}
		return \array_values($fields);
	}
}



1		<?php
2
3		namespace Ubiquity\orm\traits;
4
5		use Ubiquity\orm\parser\ManyToManyParser;
6
7		/**
8		* Trait for DAO relations.
9		* Ubiquity\orm\traits$OrmUtilsRelationsTrait
10		* This class is part of Ubiquity
11		*
12		* @author jcheron <[email protected]>
13		* @version 1.0.8
14		*
15		*/
16		trait OrmUtilsRelationsTrait {
17
18		abstract public static function getAnnotationInfoMember($class, $keyAnnotation, $member);
19
20		abstract public static function getAnnotationInfo($class, $keyAnnotation);
21
22		abstract public static function getTableName($class);
23
24		abstract public static function getFirstKey($class);
25
26		abstract public static function getModelMetadata($className);
27
28		abstract public static function getKeyFieldsAndValues($instance);
29
30		public static function getJoinTables($class) {
31		$result = [ ];
32
33		if (isset ( self::getModelMetadata ( $class ) ['#joinTable'] )) {
34		$jts = self::getModelMetadata ( $class ) ['#joinTable'];
35		foreach ( $jts as $jt ) {
36		$result [] = $jt ['name'];
37		}
38		}
39		return $result;
40		}
41
42		public static function getAllJoinTables($models) {
43		$result = [ ];
44		foreach ( $models as $model ) {
45		$result = \array_merge ( $result, self::getJoinTables ( $model ) );
46		}
47		return $result;
48		}
49
50	4	public static function getFieldsInRelations($class) {
51	4	$result = [ ];
52
53	4	if ($manyToOne = self::getAnnotationInfo ( $class, '#manyToOne' )) {
54	1	$result = \array_merge ( $result, $manyToOne );
55		}
56	4	if ($oneToMany = self::getAnnotationInfo ( $class, '#oneToMany' )) {
57	4	$result = \array_merge ( $result, \array_keys ( $oneToMany ) );
58		}
59	4	if ($manyToMany = self::getAnnotationInfo ( $class, '#manyToMany' )) {
60	1	$result = \array_merge ( $result, \array_keys ( $manyToMany ) );
61		}
62	4	return $result;
63		}
64
65	3	public static function getRelationInfos($class) {
66	3	$result = [ ];
67	3	$joinColumns = self::getAnnotationInfo ( $class, '#joinColumn' );
68	3	$invertedJoinColumns = self::getAnnotationInfo ( $class, '#invertedJoinColumn' );
69	3	if ($manyToOne = self::getAnnotationInfo ( $class, '#manyToOne' )) {
70	2	foreach ( $manyToOne as $oneField ) {
71	2	$field = $joinColumns [$oneField] ['name'];
72	2	$result [$field] = $invertedJoinColumns [$field];
73	2	$result [$oneField] = $invertedJoinColumns [$field];
74		}
75		}
76	3	if ($oneToMany = self::getAnnotationInfo ( $class, '#oneToMany' )) {
77	3	$result = \array_merge ( $result, $oneToMany );
78		}
79	3	if ($manyToMany = self::getAnnotationInfo ( $class, '#manyToMany' )) {
80	2	$result = \array_merge ( $result, $manyToMany );
81		}
82	3	return $result;
83		}
84
85	4	public static function getFieldsInRelations_($class) {
86	4	return self::getFieldsInRelationsForUpdate_ ( $class ) ['relations'];
87		}
88
89	5	public static function getFieldsInRelationsForUpdate_($class) {
90	5	$result = [ ];
91	5	if ($manyToOne = self::getAnnotationInfo ( $class, '#manyToOne' )) {
92	1	foreach ( $manyToOne as $member ) {
93	1	$joinColumn = self::getAnnotationInfoMember ( $class, '#joinColumn', $member );
94	1	$result [$joinColumn ['name']] = $member;
95		}
96		}
97	5	if ($manyToMany = self::getAnnotationInfo ( $class, "#manyToMany" )) {
98		$manyToMany = array_keys ( $manyToMany );
99		foreach ( $manyToMany as $member ) {
100		$result [$member . 'Ids'] = $member;
101		}
102		}
103	5	if ($oneToMany = self::getAnnotationInfo ( $class, '#oneToMany' )) {
104	4	$oneToMany = array_keys ( $oneToMany );
105	4	foreach ( $oneToMany as $member ) {
106	4	$result [$member . 'Ids'] = $member;
107		}
108		}
109	5	return [ 'relations' => $result,'manyToOne' => $manyToOne,'manyToMany' => $manyToMany,'oneToMany' => $oneToMany ];
110		}
111
112	2	public static function getAnnotFieldsInRelations($class) {
113	2	$result = [ ];
114	2	if ($manyToOnes = self::getAnnotationInfo ( $class, '#manyToOne' )) {
115	1	$joinColumns = self::getAnnotationInfo ( $class, '#joinColumn' );
116	1	foreach ( $manyToOnes as $manyToOne ) {
117	1	if (isset ( $joinColumns [$manyToOne] )) {
118	1	$result [$manyToOne] = [ 'type' => 'manyToOne','value' => $joinColumns [$manyToOne] ];
119		}
120		}
121		}
122	2	if ($oneToManys = self::getAnnotationInfo ( $class, '#oneToMany' )) {
123	2	foreach ( $oneToManys as $field => $oneToMany ) {
124	2	$result [$field] = [ 'type' => 'oneToMany','value' => $oneToMany ];
125		}
126		}
127	2	if ($manyToManys = self::getAnnotationInfo ( $class, "#manyToMany" )) {
128	1	foreach ( $manyToManys as $field => $manyToMany ) {
129	1	$result [$field] = [ 'type' => 'manyToMany','value' => $manyToMany ];
130		}
131		}
132	2	return $result;
133		}
134
135	4	public static function getUJoinSQL($db, $model, $arrayAnnot, $field, &$aliases, $quote) {
136	4	$type = $arrayAnnot ['type'];
137	4	$annot = $arrayAnnot ['value'];
138	4	$table = self::getTableName ( $model );
139	4	$tableAlias = (isset ( $aliases [$table] )) ? $aliases [$table] : $table;
140	4	if ($type === 'manyToOne') {
141		$fkClass = $annot ['className'];
142		$fkTable = self::getTableName ( $fkClass );
143		$fkField = $annot ['name'];
144		$pkField = self::getFirstKey ( $fkClass );
145		$alias = self::getJoinAlias ( $table, $fkTable );
146		$result = "LEFT JOIN {$quote}{$fkTable}{$quote} {$quote}{$alias}{$quote} ON {$quote}{$tableAlias}{$quote}.{$quote}{$fkField}{$quote}={$quote}{$alias}{$quote}.{$quote}{$pkField}{$quote}";
147	4	} elseif ($type === 'oneToMany') {
148		$fkClass = $annot ['className'];
149		$fkAnnot = self::getAnnotationInfoMember ( $fkClass, '#joinColumn', $annot ['mappedBy'] );
150		$fkTable = self::getTableName ( $fkClass );
151		$fkField = $fkAnnot ['name'];
152		$pkField = self::getFirstKey ( $model );
153		$alias = self::getJoinAlias ( $table, $fkTable );
154		$result = "LEFT JOIN {$quote}{$fkTable}{$quote} {$quote}{$alias}{$quote} ON {$quote}{$tableAlias}{$quote}.{$quote}{$pkField}{$quote}={$quote}{$alias}{$quote}.{$quote}{$fkField}{$quote}";
155		} else {
156	4	$parser = new ManyToManyParser ( $db, $model, $field );
157	4	$parser->init ( $annot );
158	4	$fkTable = $parser->getTargetEntityTable ();
159	4	$fkClass = $parser->getTargetEntityClass ();
160	4	$alias = self::getJoinAlias ( $table, $fkTable );
161	4	$result = $parser->getSQL ( $alias, $aliases );
162		}
163
164	4	if (array_search ( $alias, $aliases ) !== false) {
165		$result = "";
166		}
167	4	$aliases [$fkTable] = $alias;
168	4	return [ 'class' => $fkClass,'table' => $fkTable,'sql' => $result,'alias' => $alias ];
169		}
170
171	4	private static function getJoinAlias($table, $fkTable) {
172	4	return \uniqid ( $fkTable . '_' . $table [0] );
173		}
174
175		public static function getOneToManyFields($class) {
176		return self::getAnnotationInfo ( $class, '#oneToMany' );
177		}
178
179	13	public static function getRemoveCascadeFields($class,$keyAnnotation='#oneToMany') {
180	13	$infos= self::getAnnotationInfo ( $class, $keyAnnotation);
181	13	$res=[];
182	13	if($infos!==false){
183	13	foreach ($infos as $f=>$annot){
184	13	if(\array_search('remove',$annot['cascade']??[])!==false){
185		$res[]=$f;
186		}
187		}
188		}
189	13	return $res;
190		}
191
192		public static function getManyToOneFields($class) {
193		return self::getAnnotationInfo ( $class, '#manyToOne' );
194		}
195
196		public static function getManyToManyFields($class) {
197		$result = self::getAnnotationInfo ( $class, '#manyToMany' );
198		if ($result !== false)
199		return \array_keys ( $result );
200		return [ ];
201		}
202
203	40	public static function getDefaultFk($classname) {
204	40	return 'id' . \ucfirst ( self::getTableName ( $classname ) );
205		}
206
207	5	public static function getMemberJoinColumns($instance, $member, $metaDatas = NULL) {
208	5	if (! isset ( $metaDatas )) {
209	5	if (\is_object ( $instance )) {
210		$class = \get_class ( $instance );
211		} else {
212	5	$class = $instance;
213		}
214	5	$metaDatas = self::getModelMetadata ( $class );
215		}
216	5	$invertedJoinColumns = $metaDatas ['#invertedJoinColumn'];
217	5	foreach ( $invertedJoinColumns as $field => $invertedJoinColumn ) {
218	5	if ($invertedJoinColumn ['member'] === $member) {
219	5	return [ $field,$invertedJoinColumn ];
220		}
221		}
222		return null;
223		}
224
225		/**
226		*
227		* @param object $instance
228		* @return mixed[]
229		*/
230	22	public static function getManyToOneMembersAndValues($instance) {
231	22	$ret = array ();
232	22	$class = \get_class ( $instance );
233	22	$members = self::getAnnotationInfo ( $class, '#manyToOne' );
234	22	if ($members !== false) {
235	22	foreach ( $members as $member ) {
236	8	$memberAccessor = 'get' . ucfirst ( $member );
237	8	if (\method_exists ( $instance, $memberAccessor )) {
238	8	$memberInstance = $instance->$memberAccessor ();
239	8	if (isset ( $memberInstance ) ){
240	8	if(\is_object ( $memberInstance )) {
241	8	$keyValues = self::getKeyFieldsAndValues($memberInstance);
242	8	if (\count($keyValues) > 0) {
243	8	$fkName = self::getJoinColumnName($class, $member);
244	8	$ret [$fkName] = \current($keyValues);
245		}
246		}else{
247		$fkName = self::getJoinColumnName($class, $member);
248	8	$ret [$fkName] = $memberInstance;
249		}
250		} elseif (self::isNullable ( $class, $member )) {
251		$fkName = self::getJoinColumnName ( $class, $member );
252		$ret [$fkName] = null;
253		}
254		}
255		}
256		}
257	22	return $ret;
258		}
259
260	8	public static function getJoinColumnName($class, $member) {
261	8	$annot = self::getAnnotationInfoMember ( $class, '#joinColumn', $member );
262	8	if ($annot !== false) {
263	8	$fkName = $annot ['name'];
264		} else {
265		$fkName = 'id' . \ucfirst ( self::getTableName ( \ucfirst ( $member ) ) );
266		}
267	8	return $fkName;
268		}
269
270		public static function isManyToMany($class):bool{
271		$metas=self::getModelMetadata ( $class );
272		$pks=$metas['#primaryKeys'];
273		$manyToOnes=$metas['#manyToOne'];
274		$manysCount=\count($manyToOnes);
275		$counter=0;
276		if($manysCount>1) {
277		foreach ($manyToOnes as $manyToOne) {
278		$len = \strlen($manyToOne);
279		foreach ($pks as $k) {
280		if (\substr($k, -$len) === \ucfirst($manyToOne)) {
281		$counter++;
282		}
283		}
284		}
285		return $counter>1;
286		}
287		return false;
288		}
289
290		public static function getManyToManyFieldsDt($class,$manyClass) {
291		$fields=self::getSerializableMembers($manyClass);
292		$joinColumns=self::getModelMetadata($manyClass)['#joinColumn'];
293		foreach ($joinColumns as $joinColumn){
294		if($joinColumn['className']===$class){
295		if($index=\array_search($joinColumn['name'],$fields)!==false){
296		unset($fields[$index]);
297		}
298		}
299		}
300		return \array_values($fields);
301		}
302		}
303
304

phpMv / ubiquity

OrmUtilsRelationsTrait::getMemberJoinColumns() A last analyzed 2023-05-30 15:31 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

OrmUtilsRelationsTrait::getMemberJoinColumns() A
last analyzed 2023-05-30 15:31 UTC