QueryTest::testProcessParameterValueNull() - Code Metrics - Inspection of "Merge pull request #7382 from Majkl578/homepage-2...." - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — 2.7 ( 62fb49...c036c0 )

by Luís

created 2018-11-21 00:41 UTC

QueryTest::testProcessParameterValueNull() A

↳ Parent: QueryTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	2
nc	1
nop	0
dl	0
loc	5
rs	10
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 testProcessParameterValueObject() : void
    {
        $query = $this->_em->createQuery('SELECT a FROM Doctrine\Tests\Models\CMS\CmsAddress a WHERE a.user = :user');
        $user = new CmsUser();
        $user->id = 12345;

        self::assertSame(
            12345,
            $query->processParameterValue($user)
        );
    }

    public function testProcessParameterValueNull() : void
    {
        $query = $this->_em->createQuery('SELECT a FROM Doctrine\Tests\Models\CMS\CmsAddress a WHERE a.user = :user');

        self::assertNull($query->processParameterValue(null));
    }

    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			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			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 testProcessParameterValueObject() : void
193			{
194			$query = $this->_em->createQuery('SELECT a FROM Doctrine\Tests\Models\CMS\CmsAddress a WHERE a.user = :user');
195			$user = new CmsUser();
196			$user->id = 12345;
197
198			self::assertSame(
199			12345,
200			$query->processParameterValue($user)
201			);
202			}
203
204			public function testProcessParameterValueNull() : void
205			{
206			$query = $this->_em->createQuery('SELECT a FROM Doctrine\Tests\Models\CMS\CmsAddress a WHERE a.user = :user');
207
208			self::assertNull($query->processParameterValue(null));
209			}
210
211			public function testDefaultQueryHints()
212			{
213			$config = $this->_em->getConfiguration();
214			$defaultHints = [
215			'hint_name_1' => 'hint_value_1',
216			'hint_name_2' => 'hint_value_2',
217			'hint_name_3' => 'hint_value_3',
218			];
219
220			$config->setDefaultQueryHints($defaultHints);
221			$query = $this->_em->createQuery();
222			$this->assertSame($config->getDefaultQueryHints(), $query->getHints());
223			$this->_em->getConfiguration()->setDefaultQueryHint('hint_name_1', 'hint_another_value_1');
224			$this->assertNotSame($config->getDefaultQueryHints(), $query->getHints());
225			$q2 = clone $query;
226			$this->assertSame($config->getDefaultQueryHints(), $q2->getHints());
227			}
228
229			/**
230			* @group DDC-3714
231			*/
232			public function testResultCacheCaching()
233			{
234			$this->_em->getConfiguration()->setResultCacheImpl(new ArrayCache());
235			$this->_em->getConfiguration()->setQueryCacheImpl(new ArrayCache());
236			/** @var DriverConnectionMock $driverConnectionMock */
237			$driverConnectionMock = $this->_em->getConnection()->getWrappedConnection();
238			$stmt = new StatementArrayMock([
239			[
240			'id_0' => 1,
241			]
242			]);
243			$driverConnectionMock->setStatementMock($stmt);
244			$res = $this->_em->createQuery("select u from Doctrine\Tests\Models\CMS\CmsUser u")
245			->useQueryCache(true)
246			->useResultCache(true, 60)
247			//let it cache
248			->getResult();
249
250			$this->assertCount(1, $res);
251
252			$driverConnectionMock->setStatementMock(null);
253
254			$res = $this->_em->createQuery("select u from Doctrine\Tests\Models\CMS\CmsUser u")
255			->useQueryCache(true)
256			->useResultCache(false)
257			->getResult();
258			$this->assertCount(0, $res);
259			}
260
261			/**
262			* @group DDC-3741
263			*/
264			public function testSetHydrationCacheProfileNull()
265			{
266			$query = $this->_em->createQuery();
267			$query->setHydrationCacheProfile(null);
268			$this->assertNull($query->getHydrationCacheProfile());
269			}
270
271			/**
272			* @group 2947
273			*/
274			public function testResultCacheEviction()
275			{
276			$this->_em->getConfiguration()->setResultCacheImpl(new ArrayCache());
277
278			$query = $this->_em->createQuery("SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u")
279			->useResultCache(true);
280
281			/** @var DriverConnectionMock $driverConnectionMock */
282			$driverConnectionMock = $this->_em->getConnection()
283			->getWrappedConnection();
284
285			$driverConnectionMock->setStatementMock(new StatementArrayMock([['id_0' => 1]]));
286
287			// Performs the query and sets up the initial cache
288			self::assertCount(1, $query->getResult());
289
290			$driverConnectionMock->setStatementMock(new StatementArrayMock([['id_0' => 1], ['id_0' => 2]]));
291
292			// Retrieves cached data since expire flag is false and we have a cached result set
293			self::assertCount(1, $query->getResult());
294
295			// Performs the query and caches the result set since expire flag is true
296			self::assertCount(2, $query->expireResultCache(true)->getResult());
297
298			$driverConnectionMock->setStatementMock(new StatementArrayMock([['id_0' => 1]]));
299
300			// Retrieves cached data since expire flag is false and we have a cached result set
301			self::assertCount(2, $query->expireResultCache(false)->getResult());
302			}
303
304			/**
305			* @group #6162
306			*/
307			public function testSelectJoinSubquery()
308			{
309			$query = $this->_em->createQuery("select u from Doctrine\Tests\Models\CMS\CmsUser u JOIN (SELECT )");
310
311			$this->expectException(QueryException::class);
312			$this->expectExceptionMessage('Subquery');
313			$query->getSQL();
314			}
315
316			/**
317			* @group #6162
318			*/
319			public function testSelectFromSubquery()
320			{
321			$query = $this->_em->createQuery("select u from (select Doctrine\Tests\Models\CMS\CmsUser c) as u");
322
323			$this->expectException(QueryException::class);
324			$this->expectExceptionMessage('Subquery');
325			$query->getSQL();
326			}
327
328			/**
329			* @group 6699
330			*/
331			public function testGetParameterTypeJuggling() : void
332			{
333			$query = $this->_em->createQuery('select u from ' . CmsUser::class . ' u where u.id = ?0');
334
335			$query->setParameter(0, 0);
336
337			self::assertCount(1, $query->getParameters());
338			self::assertSame(0, $query->getParameter(0)->getValue());
339			self::assertSame(0, $query->getParameter('0')->getValue());
340			}
341
342			/**
343			* @group 6699
344			*/
345			public function testSetParameterWithNameZeroIsNotOverridden() : void
346			{
347			$query = $this->_em->createQuery('select u from ' . CmsUser::class . ' u where u.id != ?0 and u.username = :name');
348
349			$query->setParameter(0, 0);
350			$query->setParameter('name', 'Doctrine');
351
352			self::assertCount(2, $query->getParameters());
353			self::assertSame(0, $query->getParameter('0')->getValue());
354			self::assertSame('Doctrine', $query->getParameter('name')->getValue());
355			}
356
357			/**
358			* @group 6699
359			*/
360			public function testSetParameterWithNameZeroDoesNotOverrideAnotherParameter() : void
361			{
362			$query = $this->_em->createQuery('select u from ' . CmsUser::class . ' u where u.id != ?0 and u.username = :name');
363
364			$query->setParameter('name', 'Doctrine');
365			$query->setParameter(0, 0);
366
367			self::assertCount(2, $query->getParameters());
368			self::assertSame(0, $query->getParameter(0)->getValue());
369			self::assertSame('Doctrine', $query->getParameter('name')->getValue());
370			}
371
372			/**
373			* @group 6699
374			*/
375			public function testSetParameterWithTypeJugglingWorks() : void
376			{
377			$query = $this->_em->createQuery('select u from ' . CmsUser::class . ' u where u.id != ?0 and u.username = :name');
378
379			$query->setParameter('0', 1);
380			$query->setParameter('name', 'Doctrine');
381			$query->setParameter(0, 2);
382			$query->setParameter('0', 3);
383
384			self::assertCount(2, $query->getParameters());
385			self::assertSame(3, $query->getParameter(0)->getValue());
386			self::assertSame(3, $query->getParameter('0')->getValue());
387			self::assertSame('Doctrine', $query->getParameter('name')->getValue());
388			}
389
390			/**
391			* @group 6748
392			*/
393			public function testResultCacheProfileCanBeRemovedViaSetter() : void
394			{
395			$this->_em->getConfiguration()->setResultCacheImpl(new ArrayCache());
396
397			$query = $this->_em->createQuery('SELECT u FROM ' . CmsUser::class . ' u');
398			$query->useResultCache(true);
399			$query->setResultCacheProfile();
400
401			self::assertAttributeSame(null, '_queryCacheProfile', $query);
402			}
403			}
404

doctrine / orm

Push — 2.7 ( 62fb49...c036c0 )

QueryTest::testProcessParameterValueNull() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like