QueryTest::testSetHydrationCacheProfileNull() - Code Metrics - Inspection of "Merge pull request #6748 from KonstantinKuklin/pat..." - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 739f51...c4a5e5 )

by Luís

created 2017-12-17 02:37 UTC

QueryTest::testSetHydrationCacheProfileNull() A

↳ Parent: QueryTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	3
nc	1
nop	0
dl	0
loc	5
rs	9.4285
c	0
b	0
f	0

<?php

namespace Doctrine\Tests\ORM\Query;

use Doctrine\Common\Cache\ArrayCache;
use Doctrine\Common\Collections\ArrayCollection;

use Doctrine\DBAL\Cache\QueryCacheProfile;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Internal\Hydration\IterableResult;
use Doctrine\ORM\Query\Parameter;
use Doctrine\ORM\Query\QueryException;
use Doctrine\Tests\Mocks\DriverConnectionMock;
use Doctrine\Tests\Mocks\StatementArrayMock;
use Doctrine\Tests\Models\CMS\CmsAddress;
use Doctrine\Tests\Models\CMS\CmsUser;
use Doctrine\Tests\OrmTestCase;

class QueryTest extends OrmTestCase
{
    /** @var EntityManager */
    protected $_em = null;

    protected function setUp()
    {
        $this->_em = $this->_getTestEntityManager();
    }

    public function testGetParameters()
    {
        $query = $this->_em->createQuery("select u from Doctrine\Tests\Models\CMS\CmsUser u where u.username = ?1");

        $parameters = new ArrayCollection();

        $this->assertEquals($parameters, $query->getParameters());
    }

    public function testGetParameters_HasSomeAlready()
    {
        $query = $this->_em->createQuery("select u from Doctrine\Tests\Models\CMS\CmsUser u where u.username = ?1");
        $query->setParameter(2, 84);

        $parameters = new ArrayCollection();
        $parameters->add(new Parameter(2, 84));

        $this->assertEquals($parameters, $query->getParameters());
    }

    public function testSetParameters()
    {
        $query = $this->_em->createQuery("select u from Doctrine\Tests\Models\CMS\CmsUser u where u.username = ?1");

        $parameters = new ArrayCollection();
        $parameters->add(new Parameter(1, 'foo'));
        $parameters->add(new Parameter(2, 'bar'));

        $query->setParameters($parameters);

        $this->assertEquals($parameters, $query->getParameters());
    }

    public function testFree()
    {
        $query = $this->_em->createQuery("select u from Doctrine\Tests\Models\CMS\CmsUser u where u.username = ?1");
        $query->setParameter(2, 84, \PDO::PARAM_INT);

        $query->free();

        $this->assertEquals(0, count($query->getParameters()));
    }

    public function testClone()
    {
        $dql = "select u from Doctrine\Tests\Models\CMS\CmsUser u where u.username = ?1";

        $query = $this->_em->createQuery($dql);
        $query->setParameter(2, 84, \PDO::PARAM_INT);
        $query->setHint('foo', 'bar');

        $cloned = clone $query;

        $this->assertEquals($dql, $cloned->getDQL());
        $this->assertEquals(0, count($cloned->getParameters()));
        $this->assertFalse($cloned->getHint('foo'));
    }

    public function testFluentQueryInterface()
    {
        $q = $this->_em->createQuery("select a from Doctrine\Tests\Models\CMS\CmsArticle a");
        $q2 = $q->expireQueryCache(true)
          ->setQueryCacheLifetime(3600)
          ->setQueryCacheDriver(null)
          ->expireResultCache(true)
          ->setHint('foo', 'bar')
          ->setHint('bar', 'baz')
          ->setParameter(1, 'bar')
          ->setParameters(new ArrayCollection([new Parameter(2, 'baz')]))
          ->setResultCacheDriver(null)
          ->setResultCacheId('foo')
          ->setDQL('foo')
          ->setFirstResult(10)
          ->setMaxResults(10);

        $this->assertSame($q2, $q);
    }

    /**
     * @group DDC-968
     */
    public function testHints()
    {
        $q = $this->_em->createQuery("select a from Doctrine\Tests\Models\CMS\CmsArticle a");
        $q->setHint('foo', 'bar')->setHint('bar', 'baz');

        $this->assertEquals('bar', $q->getHint('foo'));
        $this->assertEquals('baz', $q->getHint('bar'));
        $this->assertEquals(['foo' => 'bar', 'bar' => 'baz'], $q->getHints());
        $this->assertTrue($q->hasHint('foo'));
        $this->assertFalse($q->hasHint('barFooBaz'));
    }

    /**
     * @group DDC-1588
     */
    public function testQueryDefaultResultCache()
    {
        $this->_em->getConfiguration()->setResultCacheImpl(new ArrayCache());
        $q = $this->_em->createQuery("select a from Doctrine\Tests\Models\CMS\CmsArticle a");
        $q->useResultCache(true);
        $this->assertSame($this->_em->getConfiguration()->getResultCacheImpl(), $q->getQueryCacheProfile()->getResultCacheDriver());
    }

    /**
     * @expectedException Doctrine\ORM\Query\QueryException
     **/
    public function testIterateWithNoDistinctAndWrongSelectClause()
    {
        $q = $this->_em->createQuery("select u, a from Doctrine\Tests\Models\CMS\CmsUser u LEFT JOIN u.articles a");
        $q->iterate();
    }

    /**
     * @expectedException Doctrine\ORM\Query\QueryException
     **/
    public function testIterateWithNoDistinctAndWithValidSelectClause()
    {
        $q = $this->_em->createQuery("select u from Doctrine\Tests\Models\CMS\CmsUser u LEFT JOIN u.articles a");
        $q->iterate();
    }

    public function testIterateWithDistinct()
    {
        $q = $this->_em->createQuery("SELECT DISTINCT u from Doctrine\Tests\Models\CMS\CmsUser u LEFT JOIN u.articles a");

        self::assertInstanceOf(IterableResult::class, $q->iterate());
    }

    /**
     * @group DDC-1697
     */
    public function testCollectionParameters()
    {
        $cities = [
            0 => "Paris",
            3 => "Canne",
            9 => "St Julien"
        ];

        $query  = $this->_em
                ->createQuery("SELECT a FROM Doctrine\Tests\Models\CMS\CmsAddress a WHERE a.city IN (:cities)")
                ->setParameter('cities', $cities);

        $parameters = $query->getParameters();
        $parameter  = $parameters->first();

        $this->assertEquals('cities', $parameter->getName());
        $this->assertEquals($cities, $parameter->getValue());
    }

    /**
     * @group DDC-2224
     */
    public function testProcessParameterValueClassMetadata()
    {
        $query  = $this->_em->createQuery("SELECT a FROM Doctrine\Tests\Models\CMS\CmsAddress a WHERE a.city IN (:cities)");
        $this->assertEquals(
            CmsAddress::class,
            $query->processParameterValue($this->_em->getClassMetadata(CmsAddress::class))
        );
    }

    public function testDefaultQueryHints()
    {
        $config = $this->_em->getConfiguration();
        $defaultHints = [
            'hint_name_1' => 'hint_value_1',
            'hint_name_2' => 'hint_value_2',
            'hint_name_3' => 'hint_value_3',
        ];

        $config->setDefaultQueryHints($defaultHints);
        $query = $this->_em->createQuery();
        $this->assertSame($config->getDefaultQueryHints(), $query->getHints());
        $this->_em->getConfiguration()->setDefaultQueryHint('hint_name_1', 'hint_another_value_1');
        $this->assertNotSame($config->getDefaultQueryHints(), $query->getHints());
        $q2 = clone $query;
        $this->assertSame($config->getDefaultQueryHints(), $q2->getHints());
    }

    /**
     * @group DDC-3714
     */
    public function testResultCacheCaching()
    {
        $this->_em->getConfiguration()->setResultCacheImpl(new ArrayCache());
        $this->_em->getConfiguration()->setQueryCacheImpl(new ArrayCache());
        /** @var DriverConnectionMock $driverConnectionMock */
        $driverConnectionMock = $this->_em->getConnection()->getWrappedConnection();
        $stmt = new StatementArrayMock([
            [
                'id_0' => 1,
            ]
        ]);
        $driverConnectionMock->setStatementMock($stmt);
        $res = $this->_em->createQuery("select u from Doctrine\Tests\Models\CMS\CmsUser u")
            ->useQueryCache(true)
            ->useResultCache(true, 60)
            //let it cache
            ->getResult();

        $this->assertCount(1, $res);

        $driverConnectionMock->setStatementMock(null);

        $res = $this->_em->createQuery("select u from Doctrine\Tests\Models\CMS\CmsUser u")
            ->useQueryCache(true)
            ->useResultCache(false)
            ->getResult();
        $this->assertCount(0, $res);
    }

    /**
     * @group DDC-3741
     */
    public function testSetHydrationCacheProfileNull()
    {
        $query = $this->_em->createQuery();
        $query->setHydrationCacheProfile(null);
        $this->assertNull($query->getHydrationCacheProfile());
    }

    /**
     * @group 2947
     */
    public function testResultCacheEviction()
    {
        $this->_em->getConfiguration()->setResultCacheImpl(new ArrayCache());

        $query = $this->_em->createQuery("SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u")
                           ->useResultCache(true);

        /** @var DriverConnectionMock $driverConnectionMock */
        $driverConnectionMock = $this->_em->getConnection()
                                          ->getWrappedConnection();

        $driverConnectionMock->setStatementMock(new StatementArrayMock([['id_0' => 1]]));

        // Performs the query and sets up the initial cache
        self::assertCount(1, $query->getResult());

        $driverConnectionMock->setStatementMock(new StatementArrayMock([['id_0' => 1], ['id_0' => 2]]));

        // Retrieves cached data since expire flag is false and we have a cached result set
        self::assertCount(1, $query->getResult());

        // Performs the query and caches the result set since expire flag is true
        self::assertCount(2, $query->expireResultCache(true)->getResult());

        $driverConnectionMock->setStatementMock(new StatementArrayMock([['id_0' => 1]]));

        // Retrieves cached data since expire flag is false and we have a cached result set
        self::assertCount(2, $query->expireResultCache(false)->getResult());
    }

    /**
     * @group #6162
     */
    public function testSelectJoinSubquery()
    {
        $query = $this->_em->createQuery("select u from Doctrine\Tests\Models\CMS\CmsUser u JOIN (SELECT )");

        $this->expectException(QueryException::class);
        $this->expectExceptionMessage('Subquery');
        $query->getSQL();
    }

    /**
     * @group #6162
     */
    public function testSelectFromSubquery()
    {
        $query = $this->_em->createQuery("select u from (select Doctrine\Tests\Models\CMS\CmsUser c) as u");

        $this->expectException(QueryException::class);
        $this->expectExceptionMessage('Subquery');
        $query->getSQL();
    }

    /**
     * @group 6699
     */
    public function testGetParameterTypeJuggling() : void
    {
        $query = $this->_em->createQuery('select u from ' . CmsUser::class . ' u where u.id = ?0');

        $query->setParameter(0, 0);

        self::assertCount(1, $query->getParameters());
        self::assertSame(0, $query->getParameter(0)->getValue());
        self::assertSame(0, $query->getParameter('0')->getValue());
    }

    /**
     * @group 6699
     */
    public function testSetParameterWithNameZeroIsNotOverridden() : void
    {
        $query = $this->_em->createQuery('select u from ' . CmsUser::class . ' u where u.id != ?0 and u.username = :name');

        $query->setParameter(0, 0);
        $query->setParameter('name', 'Doctrine');

        self::assertCount(2, $query->getParameters());
        self::assertSame(0, $query->getParameter('0')->getValue());
        self::assertSame('Doctrine', $query->getParameter('name')->getValue());
    }

    /**
     * @group 6699
     */
    public function testSetParameterWithNameZeroDoesNotOverrideAnotherParameter() : void
    {
        $query = $this->_em->createQuery('select u from ' . CmsUser::class . ' u where u.id != ?0 and u.username = :name');

        $query->setParameter('name', 'Doctrine');
        $query->setParameter(0, 0);

        self::assertCount(2, $query->getParameters());
        self::assertSame(0, $query->getParameter(0)->getValue());
        self::assertSame('Doctrine', $query->getParameter('name')->getValue());
    }

    /**
     * @group 6699
     */
    public function testSetParameterWithTypeJugglingWorks() : void
    {
        $query = $this->_em->createQuery('select u from ' . CmsUser::class . ' u where u.id != ?0 and u.username = :name');

        $query->setParameter('0', 1);
        $query->setParameter('name', 'Doctrine');
        $query->setParameter(0, 2);
        $query->setParameter('0', 3);

        self::assertCount(2, $query->getParameters());
        self::assertSame(3, $query->getParameter(0)->getValue());
        self::assertSame(3, $query->getParameter('0')->getValue());
        self::assertSame('Doctrine', $query->getParameter('name')->getValue());
    }

    /**
     * @group 6748
     */
    public function testResultCacheProfileCanBeRemovedViaSetter() : void
    {
        $this->_em->getConfiguration()->setResultCacheImpl(new ArrayCache());

        $query = $this->_em->createQuery('SELECT u FROM ' . CmsUser::class . ' u');
        $query->useResultCache(true);
        $query->setResultCacheProfile();

        self::assertAttributeSame(null, '_queryCacheProfile', $query);
    }
}


1		<?php
2
3		namespace Doctrine\Tests\ORM\Query;
4
5		use Doctrine\Common\Cache\ArrayCache;
6		use Doctrine\Common\Collections\ArrayCollection;
7
8		use Doctrine\DBAL\Cache\QueryCacheProfile;
9		use Doctrine\ORM\EntityManager;
10		use Doctrine\ORM\Internal\Hydration\IterableResult;
11		use Doctrine\ORM\Query\Parameter;
12		use Doctrine\ORM\Query\QueryException;
13		use Doctrine\Tests\Mocks\DriverConnectionMock;
14		use Doctrine\Tests\Mocks\StatementArrayMock;
15		use Doctrine\Tests\Models\CMS\CmsAddress;
16		use Doctrine\Tests\Models\CMS\CmsUser;
17		use Doctrine\Tests\OrmTestCase;
18
19		class QueryTest extends OrmTestCase
20		{
21		/** @var EntityManager */
22		protected $_em = null;
23
24		protected function setUp()
25		{
26		$this->_em = $this->_getTestEntityManager();
27		}
28
29		public function testGetParameters()
30		{
31		$query = $this->_em->createQuery("select u from Doctrine\Tests\Models\CMS\CmsUser u where u.username = ?1");
32
33		$parameters = new ArrayCollection();
34
35		$this->assertEquals($parameters, $query->getParameters());
36		}
37
38	View Code Duplication	public function testGetParameters_HasSomeAlready()
39		{
40		$query = $this->_em->createQuery("select u from Doctrine\Tests\Models\CMS\CmsUser u where u.username = ?1");
41		$query->setParameter(2, 84);
42
43		$parameters = new ArrayCollection();
44		$parameters->add(new Parameter(2, 84));
45
46		$this->assertEquals($parameters, $query->getParameters());
47		}
48
49	View Code Duplication	public function testSetParameters()
50		{
51		$query = $this->_em->createQuery("select u from Doctrine\Tests\Models\CMS\CmsUser u where u.username = ?1");
52
53		$parameters = new ArrayCollection();
54		$parameters->add(new Parameter(1, 'foo'));
55		$parameters->add(new Parameter(2, 'bar'));
56
57		$query->setParameters($parameters);
58
59		$this->assertEquals($parameters, $query->getParameters());
60		}
61
62		public function testFree()
63		{
64		$query = $this->_em->createQuery("select u from Doctrine\Tests\Models\CMS\CmsUser u where u.username = ?1");
65		$query->setParameter(2, 84, \PDO::PARAM_INT);
66
67		$query->free();
68
69		$this->assertEquals(0, count($query->getParameters()));
70		}
71
72		public function testClone()
73		{
74		$dql = "select u from Doctrine\Tests\Models\CMS\CmsUser u where u.username = ?1";
75
76		$query = $this->_em->createQuery($dql);
77		$query->setParameter(2, 84, \PDO::PARAM_INT);
78		$query->setHint('foo', 'bar');
79
80		$cloned = clone $query;
81
82		$this->assertEquals($dql, $cloned->getDQL());
83		$this->assertEquals(0, count($cloned->getParameters()));
84		$this->assertFalse($cloned->getHint('foo'));
85		}
86
87		public function testFluentQueryInterface()
88		{
89		$q = $this->_em->createQuery("select a from Doctrine\Tests\Models\CMS\CmsArticle a");
90		$q2 = $q->expireQueryCache(true)
91		->setQueryCacheLifetime(3600)
92		->setQueryCacheDriver(null)
93		->expireResultCache(true)
94		->setHint('foo', 'bar')
95		->setHint('bar', 'baz')
96		->setParameter(1, 'bar')
97		->setParameters(new ArrayCollection([new Parameter(2, 'baz')]))
98		->setResultCacheDriver(null)
99		->setResultCacheId('foo')
100		->setDQL('foo')
101		->setFirstResult(10)
102		->setMaxResults(10);
103
104		$this->assertSame($q2, $q);
105		}
106
107		/**
108		* @group DDC-968
109		*/
110		public function testHints()
111		{
112		$q = $this->_em->createQuery("select a from Doctrine\Tests\Models\CMS\CmsArticle a");
113		$q->setHint('foo', 'bar')->setHint('bar', 'baz');
114
115		$this->assertEquals('bar', $q->getHint('foo'));
116		$this->assertEquals('baz', $q->getHint('bar'));
117		$this->assertEquals(['foo' => 'bar', 'bar' => 'baz'], $q->getHints());
118		$this->assertTrue($q->hasHint('foo'));
119		$this->assertFalse($q->hasHint('barFooBaz'));
120		}
121
122		/**
123		* @group DDC-1588
124		*/
125		public function testQueryDefaultResultCache()
126		{
127		$this->_em->getConfiguration()->setResultCacheImpl(new ArrayCache());
128		$q = $this->_em->createQuery("select a from Doctrine\Tests\Models\CMS\CmsArticle a");
129		$q->useResultCache(true);
130		$this->assertSame($this->_em->getConfiguration()->getResultCacheImpl(), $q->getQueryCacheProfile()->getResultCacheDriver());
131		}
132
133		/**
134		* @expectedException Doctrine\ORM\Query\QueryException
135		**/
136		public function testIterateWithNoDistinctAndWrongSelectClause()
137		{
138		$q = $this->_em->createQuery("select u, a from Doctrine\Tests\Models\CMS\CmsUser u LEFT JOIN u.articles a");
139		$q->iterate();
140		}
141
142		/**
143		* @expectedException Doctrine\ORM\Query\QueryException
144		**/
145		public function testIterateWithNoDistinctAndWithValidSelectClause()
146		{
147		$q = $this->_em->createQuery("select u from Doctrine\Tests\Models\CMS\CmsUser u LEFT JOIN u.articles a");
148		$q->iterate();
149		}
150
151		public function testIterateWithDistinct()
152		{
153		$q = $this->_em->createQuery("SELECT DISTINCT u from Doctrine\Tests\Models\CMS\CmsUser u LEFT JOIN u.articles a");
154
155		self::assertInstanceOf(IterableResult::class, $q->iterate());
156		}
157
158		/**
159		* @group DDC-1697
160		*/
161		public function testCollectionParameters()
162		{
163		$cities = [
164		0 => "Paris",
165		3 => "Canne",
166		9 => "St Julien"
167		];
168
169		$query = $this->_em
170		->createQuery("SELECT a FROM Doctrine\Tests\Models\CMS\CmsAddress a WHERE a.city IN (:cities)")
171		->setParameter('cities', $cities);
172
173		$parameters = $query->getParameters();
174		$parameter = $parameters->first();
175
176		$this->assertEquals('cities', $parameter->getName());
177		$this->assertEquals($cities, $parameter->getValue());
178		}
179
180		/**
181		* @group DDC-2224
182		*/
183		public function testProcessParameterValueClassMetadata()
184		{
185		$query = $this->_em->createQuery("SELECT a FROM Doctrine\Tests\Models\CMS\CmsAddress a WHERE a.city IN (:cities)");
186		$this->assertEquals(
187		CmsAddress::class,
188		$query->processParameterValue($this->_em->getClassMetadata(CmsAddress::class))
189		);
190		}
191
192		public function testDefaultQueryHints()
193		{
194		$config = $this->_em->getConfiguration();
195		$defaultHints = [
196		'hint_name_1' => 'hint_value_1',
197		'hint_name_2' => 'hint_value_2',
198		'hint_name_3' => 'hint_value_3',
199		];
200
201		$config->setDefaultQueryHints($defaultHints);
202		$query = $this->_em->createQuery();
203		$this->assertSame($config->getDefaultQueryHints(), $query->getHints());
204		$this->_em->getConfiguration()->setDefaultQueryHint('hint_name_1', 'hint_another_value_1');
205		$this->assertNotSame($config->getDefaultQueryHints(), $query->getHints());
206		$q2 = clone $query;
207		$this->assertSame($config->getDefaultQueryHints(), $q2->getHints());
208		}
209
210		/**
211		* @group DDC-3714
212		*/
213		public function testResultCacheCaching()
214		{
215		$this->_em->getConfiguration()->setResultCacheImpl(new ArrayCache());
216		$this->_em->getConfiguration()->setQueryCacheImpl(new ArrayCache());
217		/** @var DriverConnectionMock $driverConnectionMock */
218		$driverConnectionMock = $this->_em->getConnection()->getWrappedConnection();
219		$stmt = new StatementArrayMock([
220		[
221		'id_0' => 1,
222		]
223		]);
224		$driverConnectionMock->setStatementMock($stmt);
225		$res = $this->_em->createQuery("select u from Doctrine\Tests\Models\CMS\CmsUser u")
226		->useQueryCache(true)
227		->useResultCache(true, 60)
228		//let it cache
229		->getResult();
230
231		$this->assertCount(1, $res);
232
233		$driverConnectionMock->setStatementMock(null);
234
235		$res = $this->_em->createQuery("select u from Doctrine\Tests\Models\CMS\CmsUser u")
236		->useQueryCache(true)
237		->useResultCache(false)
238		->getResult();
239		$this->assertCount(0, $res);
240		}
241
242		/**
243		* @group DDC-3741
244		*/
245		public function testSetHydrationCacheProfileNull()
246		{
247		$query = $this->_em->createQuery();
248		$query->setHydrationCacheProfile(null);
249		$this->assertNull($query->getHydrationCacheProfile());
250		}
251
252		/**
253		* @group 2947
254		*/
255		public function testResultCacheEviction()
256		{
257		$this->_em->getConfiguration()->setResultCacheImpl(new ArrayCache());
258
259		$query = $this->_em->createQuery("SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u")
260		->useResultCache(true);
261
262		/** @var DriverConnectionMock $driverConnectionMock */
263		$driverConnectionMock = $this->_em->getConnection()
264		->getWrappedConnection();
265
266		$driverConnectionMock->setStatementMock(new StatementArrayMock([['id_0' => 1]]));
267
268		// Performs the query and sets up the initial cache
269		self::assertCount(1, $query->getResult());
270
271		$driverConnectionMock->setStatementMock(new StatementArrayMock([['id_0' => 1], ['id_0' => 2]]));
272
273		// Retrieves cached data since expire flag is false and we have a cached result set
274		self::assertCount(1, $query->getResult());
275
276		// Performs the query and caches the result set since expire flag is true
277		self::assertCount(2, $query->expireResultCache(true)->getResult());
278
279		$driverConnectionMock->setStatementMock(new StatementArrayMock([['id_0' => 1]]));
280
281		// Retrieves cached data since expire flag is false and we have a cached result set
282		self::assertCount(2, $query->expireResultCache(false)->getResult());
283		}
284
285		/**
286		* @group #6162
287		*/
288		public function testSelectJoinSubquery()
289		{
290		$query = $this->_em->createQuery("select u from Doctrine\Tests\Models\CMS\CmsUser u JOIN (SELECT )");
291
292		$this->expectException(QueryException::class);
293		$this->expectExceptionMessage('Subquery');
294		$query->getSQL();
295		}
296
297		/**
298		* @group #6162
299		*/
300		public function testSelectFromSubquery()
301		{
302		$query = $this->_em->createQuery("select u from (select Doctrine\Tests\Models\CMS\CmsUser c) as u");
303
304		$this->expectException(QueryException::class);
305		$this->expectExceptionMessage('Subquery');
306		$query->getSQL();
307		}
308
309		/**
310		* @group 6699
311		*/
312	View Code Duplication	public function testGetParameterTypeJuggling() : void
313		{
314		$query = $this->_em->createQuery('select u from ' . CmsUser::class . ' u where u.id = ?0');
315
316		$query->setParameter(0, 0);
317
318		self::assertCount(1, $query->getParameters());
319		self::assertSame(0, $query->getParameter(0)->getValue());
320		self::assertSame(0, $query->getParameter('0')->getValue());
321		}
322
323		/**
324		* @group 6699
325		*/
326	View Code Duplication	public function testSetParameterWithNameZeroIsNotOverridden() : void
327		{
328		$query = $this->_em->createQuery('select u from ' . CmsUser::class . ' u where u.id != ?0 and u.username = :name');
329
330		$query->setParameter(0, 0);
331		$query->setParameter('name', 'Doctrine');
332
333		self::assertCount(2, $query->getParameters());
334		self::assertSame(0, $query->getParameter('0')->getValue());
335		self::assertSame('Doctrine', $query->getParameter('name')->getValue());
336		}
337
338		/**
339		* @group 6699
340		*/
341	View Code Duplication	public function testSetParameterWithNameZeroDoesNotOverrideAnotherParameter() : void
342		{
343		$query = $this->_em->createQuery('select u from ' . CmsUser::class . ' u where u.id != ?0 and u.username = :name');
344
345		$query->setParameter('name', 'Doctrine');
346		$query->setParameter(0, 0);
347
348		self::assertCount(2, $query->getParameters());
349		self::assertSame(0, $query->getParameter(0)->getValue());
350		self::assertSame('Doctrine', $query->getParameter('name')->getValue());
351		}
352
353		/**
354		* @group 6699
355		*/
356		public function testSetParameterWithTypeJugglingWorks() : void
357		{
358		$query = $this->_em->createQuery('select u from ' . CmsUser::class . ' u where u.id != ?0 and u.username = :name');
359
360		$query->setParameter('0', 1);
361		$query->setParameter('name', 'Doctrine');
362		$query->setParameter(0, 2);
363		$query->setParameter('0', 3);
364
365		self::assertCount(2, $query->getParameters());
366		self::assertSame(3, $query->getParameter(0)->getValue());
367		self::assertSame(3, $query->getParameter('0')->getValue());
368		self::assertSame('Doctrine', $query->getParameter('name')->getValue());
369		}
370
371		/**
372		* @group 6748
373		*/
374		public function testResultCacheProfileCanBeRemovedViaSetter() : void
375		{
376		$this->_em->getConfiguration()->setResultCacheImpl(new ArrayCache());
377
378		$query = $this->_em->createQuery('SELECT u FROM ' . CmsUser::class . ' u');
379		$query->useResultCache(true);
380		$query->setResultCacheProfile();
381
382		self::assertAttributeSame(null, '_queryCacheProfile', $query);
383		}
384		}
385

doctrine / orm

Push — master ( 739f51...c4a5e5 )

QueryTest::testSetHydrationCacheProfileNull() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like