ResultSetMappingTest::testAddNamedNativeQueryResultSetMappingWithoutFields() - Code Metrics - Inspection of "Allows use of nested new operators" - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — master (#6709)

by Sergey

created 2017-09-19 14:21 UTC

testAddNamedNativeQueryResultSetMappingWithoutFields() B

↳ Parent: ResultSetMappingTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	45
Code Lines	26

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	45
rs	8.8571
c	0
b	0
f	0
cc	1
eloc	26
nc	1
nop	0

<?php

namespace Doctrine\Tests\ORM\Hydration;

use Doctrine\ORM\Mapping\ClassMetadata;
use Doctrine\ORM\Query\ResultSetMapping;
use Doctrine\Tests\Models\CMS\CmsEmail;
use Doctrine\Tests\Models\CMS\CmsPhonenumber;
use Doctrine\Tests\Models\CMS\CmsUser;
use Doctrine\Tests\Models\Legacy\LegacyUser;
use Doctrine\Tests\Models\Legacy\LegacyUserReference;

/**
 * Description of ResultSetMappingTest
 *
 * @author robo
 */
class ResultSetMappingTest extends \Doctrine\Tests\OrmTestCase
{
    /**
     * @var ResultSetMapping
     */
    private $_rsm;

    /**
     * @var \Doctrine\ORM\EntityManager
     */
    private $_em;

    protected function setUp() {
        parent::setUp();
        $this->_rsm = new ResultSetMapping;
        $this->_em = $this->_getTestEntityManager();
    }

    /**
     * For SQL: SELECT id, status, username, name FROM cms_users
     */
    public function testBasicResultSetMapping()
    {
        $this->_rsm->addEntityResult(
            CmsUser::class,
            'u'
        );
        $this->_rsm->addFieldResult('u', 'id', 'id');
        $this->_rsm->addFieldResult('u', 'status', 'status');
        $this->_rsm->addFieldResult('u', 'username', 'username');
        $this->_rsm->addFieldResult('u', 'name', 'name');

        $this->assertFalse($this->_rsm->isScalarResult('id'));
        $this->assertFalse($this->_rsm->isScalarResult('status'));
        $this->assertFalse($this->_rsm->isScalarResult('username'));
        $this->assertFalse($this->_rsm->isScalarResult('name'));

        $this->assertTrue($this->_rsm->getClassName('u') == CmsUser::class);
        $class = $this->_rsm->getDeclaringClass('id');
        $this->assertTrue($class == CmsUser::class);

        $this->assertEquals('u', $this->_rsm->getEntityAlias('id'));
        $this->assertEquals('u', $this->_rsm->getEntityAlias('status'));
        $this->assertEquals('u', $this->_rsm->getEntityAlias('username'));
        $this->assertEquals('u', $this->_rsm->getEntityAlias('name'));

        $this->assertEquals('id', $this->_rsm->getFieldName('id'));
        $this->assertEquals('status', $this->_rsm->getFieldName('status'));
        $this->assertEquals('username', $this->_rsm->getFieldName('username'));
        $this->assertEquals('name', $this->_rsm->getFieldName('name'));
    }

    /**
     * @group DDC-1057
     *
     * Fluent interface test, not a real result set mapping
     */
    public function testFluentInterface()
    {
        $rms = $this->_rsm;

        $this->_rsm->addEntityResult(CmsUser::class,'u');
        $this->_rsm->addJoinedEntityResult(CmsPhonenumber::class,'p','u','phonenumbers');
        $this->_rsm->addFieldResult('u', 'id', 'id');
        $this->_rsm->addFieldResult('u', 'name', 'name');
        $this->_rsm->setDiscriminatorColumn('name', 'name');
        $this->_rsm->addIndexByColumn('id', 'id');
        $this->_rsm->addIndexBy('username', 'username');
        $this->_rsm->addIndexByScalar('sclr0');
        $this->_rsm->addScalarResult('sclr0', 'numPhones');
        $this->_rsm->addMetaResult('a', 'user_id', 'user_id');

        $this->assertTrue($rms->hasIndexBy('id'));
        $this->assertTrue($rms->isFieldResult('id'));
        $this->assertTrue($rms->isFieldResult('name'));
        $this->assertTrue($rms->isScalarResult('sclr0'));
        $this->assertTrue($rms->isRelation('p'));
        $this->assertTrue($rms->hasParentAlias('p'));
        $this->assertTrue($rms->isMixedResult());
    }

    /**
     * @group DDC-1663
     */
    public function testAddNamedNativeQueryResultSetMapping()
    {
        $cm = new ClassMetadata(CmsUser::class);
        $cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);

        $cm->mapOneToOne(
            [
            'fieldName'     => 'email',
            'targetEntity'  => CmsEmail::class,
            'cascade'       => ['persist'],
            'inversedBy'    => 'user',
            'orphanRemoval' => false,
            'joinColumns'   => [
                [
                    'nullable' => true,
                    'referencedColumnName' => 'id',
                ]
            ]
            ]
        );

        $cm->addNamedNativeQuery(
            [
            'name'              => 'find-all',
            'query'             => 'SELECT u.id AS user_id, e.id AS email_id, u.name, e.email, u.id + e.id AS scalarColumn FROM cms_users u INNER JOIN cms_emails e ON e.id = u.email_id',
            'resultSetMapping'  => 'find-all',
            ]
        );

        $cm->addSqlResultSetMapping(
            [
            'name'      => 'find-all',
            'entities'  => [
                [
                    'entityClass'   => '__CLASS__',
                    'fields'        => [
                        [
                            'name'  => 'id',
                            'column'=> 'user_id'
                        ],
                        [
                            'name'  => 'name',
                            'column'=> 'name'
                        ]
                    ]
                ],
                [
                    'entityClass'   => 'CmsEmail',
                    'fields'        => [
                        [
                            'name'  => 'id',
                            'column'=> 'email_id'
                        ],
                        [
                            'name'  => 'email',
                            'column'=> 'email'
                        ]
                    ]
                ]
            ],
            'columns'   => [
                [
                    'name' => 'scalarColumn'
                ]
            ]
            ]
        );

        $queryMapping = $cm->getNamedNativeQuery('find-all');

        $rsm = new \Doctrine\ORM\Query\ResultSetMappingBuilder($this->_em);
        $rsm->addNamedNativeQueryMapping($cm, $queryMapping);

        $this->assertEquals('scalarColumn', $rsm->getScalarAlias('scalarColumn'));

        $this->assertEquals('c0', $rsm->getEntityAlias('user_id'));
        $this->assertEquals('c0', $rsm->getEntityAlias('name'));
        $this->assertEquals(CmsUser::class, $rsm->getClassName('c0'));
        $this->assertEquals(CmsUser::class, $rsm->getDeclaringClass('name'));
        $this->assertEquals(CmsUser::class, $rsm->getDeclaringClass('user_id'));


        $this->assertEquals('c1', $rsm->getEntityAlias('email_id'));
        $this->assertEquals('c1', $rsm->getEntityAlias('email'));
        $this->assertEquals(CmsEmail::class, $rsm->getClassName('c1'));
        $this->assertEquals(CmsEmail::class, $rsm->getDeclaringClass('email'));
        $this->assertEquals(CmsEmail::class, $rsm->getDeclaringClass('email_id'));
    }

        /**
     * @group DDC-1663
     */
    public function testAddNamedNativeQueryResultSetMappingWithoutFields()
    {
        $cm = new ClassMetadata(CmsUser::class);
        $cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);

        $cm->addNamedNativeQuery(
            [
            'name'              => 'find-all',
            'query'             => 'SELECT u.id AS user_id, e.id AS email_id, u.name, e.email, u.id + e.id AS scalarColumn FROM cms_users u INNER JOIN cms_emails e ON e.id = u.email_id',
            'resultSetMapping'  => 'find-all',
            ]
        );

        $cm->addSqlResultSetMapping(
            [
            'name'      => 'find-all',
            'entities'  => [
                [
                    'entityClass'   => '__CLASS__',
                ]
            ],
            'columns'   => [
                [
                    'name' => 'scalarColumn'
                ]
            ]
            ]
        );

        $queryMapping = $cm->getNamedNativeQuery('find-all');
        $rsm          = new \Doctrine\ORM\Query\ResultSetMappingBuilder($this->_em);

        $rsm->addNamedNativeQueryMapping($cm, $queryMapping);

        $this->assertEquals('scalarColumn', $rsm->getScalarAlias('scalarColumn'));
        $this->assertEquals('c0', $rsm->getEntityAlias('id'));
        $this->assertEquals('c0', $rsm->getEntityAlias('name'));
        $this->assertEquals('c0', $rsm->getEntityAlias('status'));
        $this->assertEquals('c0', $rsm->getEntityAlias('username'));
        $this->assertEquals(CmsUser::class, $rsm->getClassName('c0'));
        $this->assertEquals(CmsUser::class, $rsm->getDeclaringClass('id'));
        $this->assertEquals(CmsUser::class, $rsm->getDeclaringClass('name'));
        $this->assertEquals(CmsUser::class, $rsm->getDeclaringClass('status'));
        $this->assertEquals(CmsUser::class, $rsm->getDeclaringClass('username'));
    }

    /**
     * @group DDC-1663
     */
    public function testAddNamedNativeQueryResultClass()
    {
        $cm = new ClassMetadata(CmsUser::class);

        $cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);

        $cm->addNamedNativeQuery(
            [
            'name'              => 'find-all',
            'resultClass'       => '__CLASS__',
            'query'             => 'SELECT * FROM cms_users',
            ]
        );

        $queryMapping = $cm->getNamedNativeQuery('find-all');
        $rsm          = new \Doctrine\ORM\Query\ResultSetMappingBuilder($this->_em);

        $rsm->addNamedNativeQueryMapping($cm, $queryMapping);

        $this->assertEquals('c0', $rsm->getEntityAlias('id'));
        $this->assertEquals('c0', $rsm->getEntityAlias('name'));
        $this->assertEquals('c0', $rsm->getEntityAlias('status'));
        $this->assertEquals('c0', $rsm->getEntityAlias('username'));
        $this->assertEquals(CmsUser::class, $rsm->getClassName('c0'));
        $this->assertEquals(CmsUser::class, $rsm->getDeclaringClass('id'));
        $this->assertEquals(CmsUser::class, $rsm->getDeclaringClass('name'));
        $this->assertEquals(CmsUser::class, $rsm->getDeclaringClass('status'));
        $this->assertEquals(CmsUser::class, $rsm->getDeclaringClass('username'));
    }
    /**
     * @group DDC-117
     */
    public function testIndexByMetadataColumn()
    {
        $this->_rsm->addEntityResult(LegacyUser::class, 'u');
        $this->_rsm->addJoinedEntityResult(LegacyUserReference::class, 'lu', 'u', '_references');
        $this->_rsm->addMetaResult('lu', '_source',  '_source', true, 'integer');
        $this->_rsm->addMetaResult('lu', '_target',  '_target', true, 'integer');
        $this->_rsm->addIndexBy('lu', '_source');

        $this->assertTrue($this->_rsm->hasIndexBy('lu'));
    }

    public function testNewObjectNestedArgumentsDeepestLeavesShouldComeFirst()
    {
        $this->_rsm->addNewObjectAsArgument('objALevel2', 'objALevel1', 0);
        $this->_rsm->addNewObjectAsArgument('objALevel3', 'objALevel2', 1);
        $this->_rsm->addNewObjectAsArgument('objBLevel3', 'objBLevel2', 0);
        $this->_rsm->addNewObjectAsArgument('objBLevel2', 'objBLevel1', 1);

        $expectedArgumentMapping = [
            'objALevel3' => ['ownerIndex' => 'objALevel2', 'argIndex' => 1],
            'objALevel2' => ['ownerIndex' => 'objALevel1', 'argIndex' => 0],
            'objBLevel3' => ['ownerIndex' => 'objBLevel2', 'argIndex' => 0],
            'objBLevel2' => ['ownerIndex' => 'objBLevel1', 'argIndex' => 1],
        ];

        $this->assertEquals($expectedArgumentMapping, $this->_rsm->nestedNewObjectArguments);
    }
}



1			<?php
2
3			namespace Doctrine\Tests\ORM\Hydration;
4
5			use Doctrine\ORM\Mapping\ClassMetadata;
6			use Doctrine\ORM\Query\ResultSetMapping;
7			use Doctrine\Tests\Models\CMS\CmsEmail;
8			use Doctrine\Tests\Models\CMS\CmsPhonenumber;
9			use Doctrine\Tests\Models\CMS\CmsUser;
10			use Doctrine\Tests\Models\Legacy\LegacyUser;
11			use Doctrine\Tests\Models\Legacy\LegacyUserReference;
12
13			/**
14			* Description of ResultSetMappingTest
15			*
16			* @author robo
17			*/
18			class ResultSetMappingTest extends \Doctrine\Tests\OrmTestCase
19			{
20			/**
21			* @var ResultSetMapping
22			*/
23			private $_rsm;
24
25			/**
26			* @var \Doctrine\ORM\EntityManager
27			*/
28			private $_em;
29
30			protected function setUp() {
31			parent::setUp();
32			$this->_rsm = new ResultSetMapping;
33			$this->_em = $this->_getTestEntityManager();
34			}
35
36			/**
37			* For SQL: SELECT id, status, username, name FROM cms_users
38			*/
39			public function testBasicResultSetMapping()
40			{
41			$this->_rsm->addEntityResult(
42			CmsUser::class,
43			'u'
44			);
45			$this->_rsm->addFieldResult('u', 'id', 'id');
46			$this->_rsm->addFieldResult('u', 'status', 'status');
47			$this->_rsm->addFieldResult('u', 'username', 'username');
48			$this->_rsm->addFieldResult('u', 'name', 'name');
49
50			$this->assertFalse($this->_rsm->isScalarResult('id'));
51			$this->assertFalse($this->_rsm->isScalarResult('status'));
52			$this->assertFalse($this->_rsm->isScalarResult('username'));
53			$this->assertFalse($this->_rsm->isScalarResult('name'));
54
55			$this->assertTrue($this->_rsm->getClassName('u') == CmsUser::class);
56			$class = $this->_rsm->getDeclaringClass('id');
57			$this->assertTrue($class == CmsUser::class);
58
59			$this->assertEquals('u', $this->_rsm->getEntityAlias('id'));
60			$this->assertEquals('u', $this->_rsm->getEntityAlias('status'));
61			$this->assertEquals('u', $this->_rsm->getEntityAlias('username'));
62			$this->assertEquals('u', $this->_rsm->getEntityAlias('name'));
63
64			$this->assertEquals('id', $this->_rsm->getFieldName('id'));
65			$this->assertEquals('status', $this->_rsm->getFieldName('status'));
66			$this->assertEquals('username', $this->_rsm->getFieldName('username'));
67			$this->assertEquals('name', $this->_rsm->getFieldName('name'));
68			}
69
70			/**
71			* @group DDC-1057
72			*
73			* Fluent interface test, not a real result set mapping
74			*/
75			public function testFluentInterface()
76			{
77			$rms = $this->_rsm;
78
79			$this->_rsm->addEntityResult(CmsUser::class,'u');
80			$this->_rsm->addJoinedEntityResult(CmsPhonenumber::class,'p','u','phonenumbers');
81			$this->_rsm->addFieldResult('u', 'id', 'id');
82			$this->_rsm->addFieldResult('u', 'name', 'name');
83			$this->_rsm->setDiscriminatorColumn('name', 'name');
84			$this->_rsm->addIndexByColumn('id', 'id');
85			$this->_rsm->addIndexBy('username', 'username');
86			$this->_rsm->addIndexByScalar('sclr0');
87			$this->_rsm->addScalarResult('sclr0', 'numPhones');
88			$this->_rsm->addMetaResult('a', 'user_id', 'user_id');
89
90			$this->assertTrue($rms->hasIndexBy('id'));
91			$this->assertTrue($rms->isFieldResult('id'));
92			$this->assertTrue($rms->isFieldResult('name'));
93			$this->assertTrue($rms->isScalarResult('sclr0'));
94			$this->assertTrue($rms->isRelation('p'));
95			$this->assertTrue($rms->hasParentAlias('p'));
96			$this->assertTrue($rms->isMixedResult());
97			}
98
99			/**
100			* @group DDC-1663
101			*/
102			public function testAddNamedNativeQueryResultSetMapping()
103			{
104			$cm = new ClassMetadata(CmsUser::class);
105			$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
106
107			$cm->mapOneToOne(
108			[
109			'fieldName' => 'email',
110			'targetEntity' => CmsEmail::class,
111			'cascade' => ['persist'],
112			'inversedBy' => 'user',
113			'orphanRemoval' => false,
114			'joinColumns' => [
115			[
116			'nullable' => true,
117			'referencedColumnName' => 'id',
118			]
119			]
120			]
121			);
122
123			$cm->addNamedNativeQuery(
124			[
125			'name' => 'find-all',
126			'query' => 'SELECT u.id AS user_id, e.id AS email_id, u.name, e.email, u.id + e.id AS scalarColumn FROM cms_users u INNER JOIN cms_emails e ON e.id = u.email_id',
127			'resultSetMapping' => 'find-all',
128			]
129			);
130
131			$cm->addSqlResultSetMapping(
132			[
133			'name' => 'find-all',
134			'entities' => [
135			[
136			'entityClass' => '__CLASS__',
137			'fields' => [
138			[
139			'name' => 'id',
140			'column'=> 'user_id'
141			],
142			[
143			'name' => 'name',
144			'column'=> 'name'
145			]
146			]
147			],
148			[
149			'entityClass' => 'CmsEmail',
150			'fields' => [
151			[
152			'name' => 'id',
153			'column'=> 'email_id'
154			],
155			[
156			'name' => 'email',
157			'column'=> 'email'
158			]
159			]
160			]
161			],
162			'columns' => [
163			[
164			'name' => 'scalarColumn'
165			]
166			]
167			]
168			);
169
170			$queryMapping = $cm->getNamedNativeQuery('find-all');
171
172			$rsm = new \Doctrine\ORM\Query\ResultSetMappingBuilder($this->_em);
173			$rsm->addNamedNativeQueryMapping($cm, $queryMapping);
174
175			$this->assertEquals('scalarColumn', $rsm->getScalarAlias('scalarColumn'));
176
177			$this->assertEquals('c0', $rsm->getEntityAlias('user_id'));
178			$this->assertEquals('c0', $rsm->getEntityAlias('name'));
179			$this->assertEquals(CmsUser::class, $rsm->getClassName('c0'));
180			$this->assertEquals(CmsUser::class, $rsm->getDeclaringClass('name'));
181			$this->assertEquals(CmsUser::class, $rsm->getDeclaringClass('user_id'));
182
183
184			$this->assertEquals('c1', $rsm->getEntityAlias('email_id'));
185			$this->assertEquals('c1', $rsm->getEntityAlias('email'));
186			$this->assertEquals(CmsEmail::class, $rsm->getClassName('c1'));
187			$this->assertEquals(CmsEmail::class, $rsm->getDeclaringClass('email'));
188			$this->assertEquals(CmsEmail::class, $rsm->getDeclaringClass('email_id'));
189			}
190
191			/**
192			* @group DDC-1663
193			*/
194			public function testAddNamedNativeQueryResultSetMappingWithoutFields()
195			{
196			$cm = new ClassMetadata(CmsUser::class);
197			$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
198
199			$cm->addNamedNativeQuery(
200			[
201			'name' => 'find-all',
202			'query' => 'SELECT u.id AS user_id, e.id AS email_id, u.name, e.email, u.id + e.id AS scalarColumn FROM cms_users u INNER JOIN cms_emails e ON e.id = u.email_id',
203			'resultSetMapping' => 'find-all',
204			]
205			);
206
207			$cm->addSqlResultSetMapping(
208			[
209			'name' => 'find-all',
210			'entities' => [
211			[
212			'entityClass' => '__CLASS__',
213			]
214			],
215			'columns' => [
216			[
217			'name' => 'scalarColumn'
218			]
219			]
220			]
221			);
222
223			$queryMapping = $cm->getNamedNativeQuery('find-all');
224			$rsm = new \Doctrine\ORM\Query\ResultSetMappingBuilder($this->_em);
225
226			$rsm->addNamedNativeQueryMapping($cm, $queryMapping);
227
228			$this->assertEquals('scalarColumn', $rsm->getScalarAlias('scalarColumn'));
229			$this->assertEquals('c0', $rsm->getEntityAlias('id'));
230			$this->assertEquals('c0', $rsm->getEntityAlias('name'));
231			$this->assertEquals('c0', $rsm->getEntityAlias('status'));
232			$this->assertEquals('c0', $rsm->getEntityAlias('username'));
233			$this->assertEquals(CmsUser::class, $rsm->getClassName('c0'));
234			$this->assertEquals(CmsUser::class, $rsm->getDeclaringClass('id'));
235			$this->assertEquals(CmsUser::class, $rsm->getDeclaringClass('name'));
236			$this->assertEquals(CmsUser::class, $rsm->getDeclaringClass('status'));
237			$this->assertEquals(CmsUser::class, $rsm->getDeclaringClass('username'));
238			}
239
240			/**
241			* @group DDC-1663
242			*/
243			public function testAddNamedNativeQueryResultClass()
244			{
245			$cm = new ClassMetadata(CmsUser::class);
246
247			$cm->initializeReflection(new \Doctrine\Common\Persistence\Mapping\RuntimeReflectionService);
248
249			$cm->addNamedNativeQuery(
250			[
251			'name' => 'find-all',
252			'resultClass' => '__CLASS__',
253			'query' => 'SELECT * FROM cms_users',
254			]
255			);
256
257			$queryMapping = $cm->getNamedNativeQuery('find-all');
258			$rsm = new \Doctrine\ORM\Query\ResultSetMappingBuilder($this->_em);
259
260			$rsm->addNamedNativeQueryMapping($cm, $queryMapping);
261
262			$this->assertEquals('c0', $rsm->getEntityAlias('id'));
263			$this->assertEquals('c0', $rsm->getEntityAlias('name'));
264			$this->assertEquals('c0', $rsm->getEntityAlias('status'));
265			$this->assertEquals('c0', $rsm->getEntityAlias('username'));
266			$this->assertEquals(CmsUser::class, $rsm->getClassName('c0'));
267			$this->assertEquals(CmsUser::class, $rsm->getDeclaringClass('id'));
268			$this->assertEquals(CmsUser::class, $rsm->getDeclaringClass('name'));
269			$this->assertEquals(CmsUser::class, $rsm->getDeclaringClass('status'));
270			$this->assertEquals(CmsUser::class, $rsm->getDeclaringClass('username'));
271			}
272			/**
273			* @group DDC-117
274			*/
275			public function testIndexByMetadataColumn()
276			{
277			$this->_rsm->addEntityResult(LegacyUser::class, 'u');
278			$this->_rsm->addJoinedEntityResult(LegacyUserReference::class, 'lu', 'u', '_references');
279			$this->_rsm->addMetaResult('lu', '_source', '_source', true, 'integer');
280			$this->_rsm->addMetaResult('lu', '_target', '_target', true, 'integer');
281			$this->_rsm->addIndexBy('lu', '_source');
282
283			$this->assertTrue($this->_rsm->hasIndexBy('lu'));
284			}
285
286			public function testNewObjectNestedArgumentsDeepestLeavesShouldComeFirst()
287			{
288			$this->_rsm->addNewObjectAsArgument('objALevel2', 'objALevel1', 0);
289			$this->_rsm->addNewObjectAsArgument('objALevel3', 'objALevel2', 1);
290			$this->_rsm->addNewObjectAsArgument('objBLevel3', 'objBLevel2', 0);
291			$this->_rsm->addNewObjectAsArgument('objBLevel2', 'objBLevel1', 1);
292
293			$expectedArgumentMapping = [
294			'objALevel3' => ['ownerIndex' => 'objALevel2', 'argIndex' => 1],
295			'objALevel2' => ['ownerIndex' => 'objALevel1', 'argIndex' => 0],
296			'objBLevel3' => ['ownerIndex' => 'objBLevel2', 'argIndex' => 0],
297			'objBLevel2' => ['ownerIndex' => 'objBLevel1', 'argIndex' => 1],
298			];
299
300			$this->assertEquals($expectedArgumentMapping, $this->_rsm->nestedNewObjectArguments);
301			}
302			}
303
304

doctrine / orm

Pull Request — master (#6709)

testAddNamedNativeQueryResultSetMappingWithoutFields() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like