Tests\Integration\Store\InMemoryStoreSqlite\Query\SelectQueryTest

Complexity

Total Complexity

40

Size/Duplication

Total Lines	1423
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

40 Methods

Rating	Name	Duplication	Size	Complexity
A	testSelectGraphSpecified()	0	24	1
A	testSelectFilterIsIriNotFound()	0	24	1
A	testSelectLimit()	0	42	1
A	testSelectFilterStrNotFound()	0	26	1
A	testSelectOptional()	0	36	1
A	testSelectFilterRelationalSmallerThan2()	0	21	1
A	testSelectFilterIsUriFound()	0	31	1
A	testSelectFilterIsUriNotFound()	0	24	1
A	testSelectFilterIsIriFound()	0	31	1
A	testSelectFilterRelationalSmallerThan()	0	29	1
A	testSelectFilterLangMatches()	0	34	1
A	testSelectFilterRelationalGreaterThan()	0	29	1
A	testSelectFilterIsLiteralNotFound()	0	24	1
A	testSelectOffsetLimit()	0	42	1
A	testSelectUnion()	0	39	1
A	testSelectOrderByAsc()	0	46	1
A	testSelectNoWhereClause()	0	24	1
A	testSelectFilterLang()	0	34	1
A	testSelectPrefix()	0	32	1
A	testSelectFilterIsLiteralFound()	0	31	1
A	testSelectOffset()	0	42	1
A	testSelectGroupBy()	0	40	1
A	testSelectFilterRelationalNotEqual()	0	29	1
A	testSelectOrderByAscWithFromClause()	0	46	1
A	testSelectDefaultGraph()	0	24	1
A	testSelectFilterRegex()	0	32	1
A	testSelectFilterStr()	0	34	1
A	testSelectFilterRegexWithModifier()	0	32	1
A	testSelectCount()	0	31	1
A	testSelectOrderByDesc()	0	46	1
A	testSelectOrderByWithoutContent()	0	5	1
A	testSelectFilterRelationalEqual()	0	29	1
A	testSelectFilterDatatype()	0	32	1
A	testSelectFilterBoundVariableBounded()	0	31	1
A	testSelectFilterIsBlankNotFound()	0	24	1
A	testSelectDistinct()	0	23	1
A	testSelectFilterIsBlankFound()	0	31	1
A	setUp()	0	5	1
A	testSelectLeftJoinUsingOptional()	0	55	1
A	testSelectFilterBoundNotBounding()	0	24	1

<?php

/**
 * This file is part of the sweetrdf/InMemoryStoreSqlite package and licensed under
 * the terms of the GPL-2 license.
 *
 * (c) Konrad Abicht <hi@inspirito.de>
 * (c) Benjamin Nowack
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Tests\Integration\Store\InMemoryStoreSqlite\Query;

use Exception;
use sweetrdf\InMemoryStoreSqlite\Store\InMemoryStoreSqlite;
use Tests\TestCase;

/**
 * Tests for query method - focus on SELECT queries.
 *
 * Output format is: raw
 */
class SelectQueryTest extends TestCase
{
    protected function setUp(): void
    {
        parent::setUp();

        $this->subjectUnderTest = InMemoryStoreSqlite::createInstance();
    }

    public function testSelectDefaultGraph()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://s> <http://p1> "baz" .
        }');

        $res = $this->subjectUnderTest->query('SELECT * WHERE {<http://s> <http://p1> ?o.}');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        'o',
                    ],
                    'rows' => [
                        [
                            'o' => 'baz',
                            'o type' => 'literal',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    public function testSelectGraphSpecified()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://s> <http://p1> "baz" .
        }');

        $res = $this->subjectUnderTest->query('SELECT * FROM <http://example.com/> WHERE {<http://s> <http://p1> ?o.}');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        'o',
                    ],
                    'rows' => [
                        [
                            'o' => 'baz',
                            'o type' => 'literal',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    // simulate a LEFT JOIN using OPTIONAL
    public function testSelectLeftJoinUsingOptional()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://a> <http://p1> <http://b> .
            <http://a> <http://p1> <http://c> .

            <http://b> <http://p1> <http://d> .
            <http://b> <http://p1> <http://e> .

            <http://c> <http://p1> <http://f> .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT * WHERE {
                ?s <http://p1> ?o .
                OPTIONAL {
                    ?o <http://p1> ?o2 .
                }
            }
        ');
        $this->assertEquals(
            [
                [
                    's' => 'http://a',
                    's type' => 'uri',
                    'o' => 'http://b',
                    'o type' => 'uri',
                ],
                [
                    's' => 'http://a',
                    's type' => 'uri',
                    'o' => 'http://c',
                    'o type' => 'uri',
                ],
                [
                    's' => 'http://b',
                    's type' => 'uri',
                    'o' => 'http://d',
                    'o type' => 'uri',
                ],
                [
                    's' => 'http://b',
                    's type' => 'uri',
                    'o' => 'http://e',
                    'o type' => 'uri',
                ],
                [
                    's' => 'http://c',
                    's type' => 'uri',
                    'o' => 'http://f',
                    'o type' => 'uri',
                ],
            ],
            $res['result']['rows']
        );
    }

    /*
     * OPTIONAL, artifical query to extend coverage for store code. (SelectQueryHandler::sameOptional)
     */
    public function testSelectOptional()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://s1> <http://p1> <http://s2> .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT * WHERE {
                ?s <http://p1> ?o .
                OPTIONAL {
                    ?o <http://p1> ?o2 .
                }
                OPTIONAL {
                    ?o <http://p1> ?o2 .
                }
            }
        ');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's', 'o', 'o2',
                    ],
                    'rows' => [
                        [
                            's' => 'http://s1',
                            's type' => 'uri',
                            'o' => 'http://s2',
                            'o type' => 'uri',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    public function testSelectNoWhereClause()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://s> <http://p1> "baz" .
        }');

        $res = $this->subjectUnderTest->query('SELECT * FROM <http://example.com/> {<http://s> <http://p1> ?o.}');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        'o',
                    ],
                    'rows' => [
                        [
                            'o' => 'baz',
                            'o type' => 'literal',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    /*
     * FILTER
     */

    // bound: is variable set?
    public function testSelectFilterBoundNotBounding()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://s> <http://p1> "foo" .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT ?s ?o WHERE {
                ?s <http://p2> ?o .
                FILTER (bound(?o))
            }
        ');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's', 'o',
                    ],
                    'rows' => [],
                ],
            ],
            $res
        );
    }

    // bound: is variable set?
    public function testSelectFilterBoundVariableBounded()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://s> <http://p1> "foo" .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT ?s ?o WHERE {
                ?s <http://p1> ?o .
                FILTER (bound(?o))
            }
        ');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's', 'o',
                    ],
                    'rows' => [
                        [
                            's' => 'http://s',
                            's type' => 'uri',
                            'o' => 'foo',
                            'o type' => 'literal',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    // datatype
    public function testSelectFilterDatatype()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://s> <http://p1> 3 .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT ?s ?o WHERE {
                ?s <http://p1> ?o .
                FILTER (datatype(?o) = xsd:integer)
            }
        ');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's', 'o',
                    ],
                    'rows' => [
                        [
                            's' => 'http://s',
                            's type' => 'uri',
                            'o' => '3',
                            'o type' => 'literal',
                            'o datatype' => 'http://www.w3.org/2001/XMLSchema#integer',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    // isBlank
    public function testSelectFilterIsBlankFound()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://s> <http://p1> _:foo .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT ?s ?o WHERE {
                ?s <http://p1> ?o .
                FILTER (isBlank(?o))
            }
        ');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's', 'o',
                    ],
                    'rows' => [
                        [
                            's' => 'http://s',
                            's type' => 'uri',
                            'o' => $res['result']['rows'][0]['o'],
                            'o type' => 'bnode',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    // isBlank
    public function testSelectFilterIsBlankNotFound()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://s> <http://p1> <http://foo> .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT ?s ?o WHERE {
                ?s <http://p1> ?o .
                FILTER (isBlank(?o))
            }
        ');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's', 'o',
                    ],
                    'rows' => [],
                ],
            ],
            $res
        );
    }

    // isIri
    public function testSelectFilterIsIriFound()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://s> <http://p1> <urn:id> .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT ?s ?o WHERE {
                ?s <http://p1> ?o .
                FILTER (isIri(?o))
            }
        ');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's', 'o',
                    ],
                    'rows' => [
                        [
                            's' => 'http://s',
                            's type' => 'uri',
                            'o' => 'urn:id',
                            'o type' => 'uri',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    // isIri
    public function testSelectFilterIsIriNotFound()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://s> <http://p1> "foo" .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT ?s ?o WHERE {
                ?s <http://p1> ?o .
                FILTER (isIri(?o))
            }
        ');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's', 'o',
                    ],
                    'rows' => [],
                ],
            ],
            $res
        );
    }

    // isLiteral
    public function testSelectFilterIsLiteralFound()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://s> <http://p1> "foo" .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT ?s ?o WHERE {
                ?s <http://p1> ?o .
                FILTER (isLiteral(?o))
            }
        ');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's', 'o',
                    ],
                    'rows' => [
                        [
                            's' => 'http://s',
                            's type' => 'uri',
                            'o' => 'foo',
                            'o type' => 'literal',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    // isLiteral
    public function testSelectFilterIsLiteralNotFound()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://s> <http://p1> <http://foo> .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT ?s ?o WHERE {
                ?s <http://p1> ?o .
                FILTER (isLiteral(?o))
            }
        ');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's', 'o',
                    ],
                    'rows' => [],
                ],
            ],
            $res
        );
    }

    // isUri
    public function testSelectFilterIsUriFound()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://s> <http://p1> <urn:id> .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT ?s ?o WHERE {
                ?s <http://p1> ?o .
                FILTER (isUri(?o))
            }
        ');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's', 'o',
                    ],
                    'rows' => [
                        [
                            's' => 'http://s',
                            's type' => 'uri',
                            'o' => 'urn:id',
                            'o type' => 'uri',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    // isUri
    public function testSelectFilterIsUriNotFound()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://s> <http://p1> "foo" .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT ?s ?o WHERE {
                ?s <http://p1> ?o .
                FILTER (isUri(?o))
            }
        ');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's', 'o',
                    ],
                    'rows' => [],
                ],
            ],
            $res
        );
    }

    // lang: test behavior when using a language
    public function testSelectFilterLang()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://s> <http://p1> "foo" .
            <http://s> <http://p1> "in de"@de .
            <http://s> <http://p1> "in en"@en .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT ?s ?o WHERE {
                ?s <http://p1> ?o .
                FILTER (lang(?o) = "en")
            }
        ');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's', 'o',
                    ],
                    'rows' => [
                        [
                            's' => 'http://s',
                            's type' => 'uri',
                            'o' => 'in en',
                            'o type' => 'literal',
                            'o lang' => 'en',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    // langMatches
    public function testSelectFilterLangMatches()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://s> <http://p1> "foo" .
            <http://s> <http://p1> "in de"@de .
            <http://s> <http://p1> "in en"@en .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT ?s ?o WHERE {
                ?s <http://p1> ?o .
                FILTER langMatches (lang(?o), "en")
            }
        ');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's', 'o',
                    ],
                    'rows' => [
                        [
                            's' => 'http://s',
                            's type' => 'uri',
                            'o' => 'in en',
                            'o type' => 'literal',
                            'o lang' => 'en',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    // regex
    public function testSelectFilterRegex()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://s> <http://p1> "Alice".
            <http://s2> <http://p1> "Bob" .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT ?s ?o WHERE {
                ?s <http://p1> ?o .
                FILTER regex (?o, "^Ali")
            }
        ');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's', 'o',
                    ],
                    'rows' => [
                        [
                            's' => 'http://s',
                            's type' => 'uri',
                            'o' => 'Alice',
                            'o type' => 'literal',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    // regex
    public function testSelectFilterRegexWithModifier()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://s> <http://p1> "Alice".
            <http://s2> <http://p1> "Bob" .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT ?s ?o WHERE {
                ?s <http://p1> ?o .
                FILTER regex (?o, "^ali", "i")
            }
        ');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's', 'o',
                    ],
                    'rows' => [
                        [
                            's' => 'http://s',
                            's type' => 'uri',
                            'o' => 'Alice',
                            'o type' => 'literal',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    // str
    public function testSelectFilterStr()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://s> <http://p1> "foo" .
            <http://s> <http://p1> "in de"@de .
            <http://s> <http://p1> "in en"@en .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT ?s ?o WHERE {
                ?s <http://p1> ?o .
                FILTER (str(?o) = "in en")
            }
        ');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's', 'o',
                    ],
                    'rows' => [
                        [
                            's' => 'http://s',
                            's type' => 'uri',
                            'o' => 'in en',
                            'o type' => 'literal',
                            'o lang' => 'en',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    // str
    public function testSelectFilterStrNotFound()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://s> <http://p1> "foo" .
            <http://s> <http://p1> "in de"@de .
            <http://s> <http://p1> "in en"@en .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT ?s ?o WHERE {
                ?s <http://p1> ?o .
                FILTER (str(?o) = "in it")
            }
        ');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's', 'o',
                    ],
                    'rows' => [],
                ],
            ],
            $res
        );
    }

    // >
    public function testSelectFilterRelationalGreaterThan()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://container1> <http://weight> "150" .
            <http://container2> <http://weight> "50" .
        }');

        $res = $this->subjectUnderTest->query('SELECT ?c WHERE {
            ?c <http://weight> ?w .

            FILTER (?w > 100)
        }');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        'c',
                    ],
                    'rows' => [
                        [
                            'c' => 'http://container1',
                            'c type' => 'uri',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    // <
    public function testSelectFilterRelationalSmallerThan()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://container1> <http://weight> "150" .
            <http://container2> <http://weight> "50" .
        }');

        $res = $this->subjectUnderTest->query('SELECT ?c WHERE {
            ?c <http://weight> ?w .

            FILTER (?w < 100)
        }');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        'c',
                    ],
                    'rows' => [
                        [
                            'c' => 'http://container2',
                            'c type' => 'uri',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    // <
    public function testSelectFilterRelationalSmallerThan2()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://container1> <http://weight> "150" .
            <http://container2> <http://weight> "50" .
        }');

        $res = $this->subjectUnderTest->query('SELECT ?c WHERE {
            ?c <http://weight> ?w .

            FILTER (?w < 100 && ?w > 10)
        }');
        $this->assertEquals(
            [
                [
                    'c' => 'http://container2',
                    'c type' => 'uri',
                ],
            ],
            $res['result']['rows']
        );
    }

    // =
    public function testSelectFilterRelationalEqual()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://container1> <http://weight> "150" .
            <http://container2> <http://weight> "50" .
        }');

        $res = $this->subjectUnderTest->query('SELECT ?c WHERE {
            ?c <http://weight> ?w .

            FILTER (?w = 150)
        }');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        'c',
                    ],
                    'rows' => [
                        [
                            'c' => 'http://container1',
                            'c type' => 'uri',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    // !=
    public function testSelectFilterRelationalNotEqual()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://container1> <http://weight> "150" .
            <http://container2> <http://weight> "50" .
        }');

        $res = $this->subjectUnderTest->query('SELECT ?c WHERE {
            ?c <http://weight> ?w .

            FILTER (?w != 150)
        }');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        'c',
                    ],
                    'rows' => [
                        [
                            'c' => 'http://container2',
                            'c type' => 'uri',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    /*
     * SELECT COUNT
     */

    public function testSelectCount()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://person1> <http://name> "baz" .
            <http://person2> <http://name> "baz" .
            <http://person3> <http://name> "baz" .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT COUNT(?s) AS ?count WHERE {
                ?s <http://name> "baz" .
            }
            ORDER BY DESC(?count)
        ');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        'count',
                    ],
                    'rows' => [
                        [
                            'count' => '3',
                            'count type' => 'literal',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    /*
     * GROUP BY
     */

    public function testSelectGroupBy()
    {
        $query = 'SELECT ?who COUNT(?person) as ?persons WHERE {
                ?who <http://knows> ?person .
            }
            GROUP BY ?who
        ';

        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://person1> <http://knows> <http://person2>, <http://person3> .
            <http://person2> <http://knows> <http://person3> .
        }');

        $res = $this->subjectUnderTest->query($query);
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        'who',
                        'persons',
                    ],
                    'rows' => [
                        [
                            'who' => 'http://person1',
                            'who type' => 'uri',
                            'persons' => '2',
                            'persons type' => 'literal',
                        ],
                        [
                            'who' => 'http://person2',
                            'who type' => 'uri',
                            'persons' => '1',
                            'persons type' => 'literal',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    /*
     * OFFSET and LIMIT
     */

    public function testSelectOffset()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://person1> <http://id> "1" .
            <http://person3> <http://id> "3" .
            <http://person2> <http://id> "2" .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT * WHERE { ?s ?p ?o . }
            OFFSET 1
        ');

        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's', 'p', 'o',
                    ],
                    'rows' => [
                        [
                            's' => 'http://person3',
                            's type' => 'uri',
                            'p' => 'http://id',
                            'p type' => 'uri',
                            'o' => '3',
                            'o type' => 'literal',
                        ],
                        [
                            's' => 'http://person2',
                            's type' => 'uri',
                            'p' => 'http://id',
                            'p type' => 'uri',
                            'o' => '2',
                            'o type' => 'literal',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    public function testSelectOffsetLimit()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://person1> <http://id> "1" .
            <http://person3> <http://id> "3" .
            <http://person2> <http://id> "2" .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT * WHERE { ?s ?p ?o . }
            OFFSET 1 LIMIT 2
        ');

        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's', 'p', 'o',
                    ],
                    'rows' => [
                        [
                            's' => 'http://person3',
                            's type' => 'uri',
                            'p' => 'http://id',
                            'p type' => 'uri',
                            'o' => '3',
                            'o type' => 'literal',
                        ],
                        [
                            's' => 'http://person2',
                            's type' => 'uri',
                            'p' => 'http://id',
                            'p type' => 'uri',
                            'o' => '2',
                            'o type' => 'literal',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    public function testSelectLimit()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://person1> <http://id> "1" .
            <http://person3> <http://id> "3" .
            <http://person2> <http://id> "2" .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT * WHERE { ?s ?p ?o . }
            LIMIT 2
        ');

        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's', 'p', 'o',
                    ],
                    'rows' => [
                        [
                            's' => 'http://person1',
                            's type' => 'uri',
                            'p' => 'http://id',
                            'p type' => 'uri',
                            'o' => '1',
                            'o type' => 'literal',
                        ],
                        [
                            's' => 'http://person3',
                            's type' => 'uri',
                            'p' => 'http://id',
                            'p type' => 'uri',
                            'o' => '3',
                            'o type' => 'literal',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    /*
     * ORDER BY
     */

    public function testSelectOrderByAsc()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://person1> <http://id> "1" .
            <http://person3> <http://id> "3" .
            <http://person2> <http://id> "2" .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT * WHERE {
                ?s <http://id> ?id .
            }
            ORDER BY ASC(?id)
        ');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's',
                        'id',
                    ],
                    'rows' => [
                        [
                            's' => 'http://person1',
                            's type' => 'uri',
                            'id' => '1',
                            'id type' => 'literal',
                        ],
                        [
                            's' => 'http://person2',
                            's type' => 'uri',
                            'id' => '2',
                            'id type' => 'literal',
                        ],
                        [
                            's' => 'http://person3',
                            's type' => 'uri',
                            'id' => '3',
                            'id type' => 'literal',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    public function testSelectOrderByDesc()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://person1> <http://id> "1" .
            <http://person3> <http://id> "3" .
            <http://person2> <http://id> "2" .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT * WHERE {
                ?s <http://id> ?id .
            }
            ORDER BY DESC(?id)
        ');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's',
                        'id',
                    ],
                    'rows' => [
                        [
                            's' => 'http://person3',
                            's type' => 'uri',
                            'id' => '3',
                            'id type' => 'literal',
                        ],
                        [
                            's' => 'http://person2',
                            's type' => 'uri',
                            'id' => '2',
                            'id type' => 'literal',
                        ],
                        [
                            's' => 'http://person1',
                            's type' => 'uri',
                            'id' => '1',
                            'id type' => 'literal',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    public function testSelectOrderByWithoutContent()
    {
        $this->expectException(Exception::class);

        $this->subjectUnderTest->query('
            SELECT * WHERE {
                ?s <http://id> ?id .
            }
            ORDER BY
        ');
    }

    /*
     * PREFIX
     */

    public function testSelectPrefix()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://person1> <http://example.com/kennt> <http://person2> .
        }');

        $res = $this->subjectUnderTest->query('
            PREFIX ex: <http://example.com/>
            SELECT * WHERE {
                ?s ex:kennt ?o
            }
        ');

        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's', 'o',
                    ],
                    'rows' => [
                        [
                            's' => 'http://person1',
                            's type' => 'uri',
                            'o' => 'http://person2',
                            'o type' => 'uri',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    /*
     * UNION
     */

    public function testSelectUnion()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://person1> <http://id> "1" .
            <http://person3> <http://id> "3" .
            <http://person2> <http://id> "2" .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT * WHERE {
                {
                    ?p <http://id> "1" .
                } UNION {
                    ?p <http://id> "3" .
                }
            }
        ');

        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        'p',
                    ],
                    'rows' => [
                        [
                            'p' => 'http://person1',
                            'p type' => 'uri',
                        ],
                        [
                            'p' => 'http://person3',
                            'p type' => 'uri',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    /*
     * Tests using certain queries with SELECT FROM WHERE and not just SELECT WHERE
     */

    public function testSelectOrderByAscWithFromClause()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://person1> <http://id> "1" .
            <http://person3> <http://id> "3" .
            <http://person2> <http://id> "2" .
        }');

        $res = $this->subjectUnderTest->query('
            SELECT * FROM <http://example.com/> WHERE {
                ?s <http://id> ?id .
            }
            ORDER BY ASC(?id)
        ');
        $this->assertEquals(
            [
                'query_type' => 'select',
                'result' => [
                    'variables' => [
                        's',
                        'id',
                    ],
                    'rows' => [
                        [
                            's' => 'http://person1',
                            's type' => 'uri',
                            'id' => '1',
                            'id type' => 'literal',
                        ],
                        [
                            's' => 'http://person2',
                            's type' => 'uri',
                            'id' => '2',
                            'id type' => 'literal',
                        ],
                        [
                            's' => 'http://person3',
                            's type' => 'uri',
                            'id' => '3',
                            'id type' => 'literal',
                        ],
                    ],
                ],
            ],
            $res
        );
    }

    /**
     * Select Distinct
     *
     * @see https://www.w3.org/TR/rdf-sparql-query/#modDistinct
     */
    public function testSelectDistinct()
    {
        // test data
        $this->subjectUnderTest->query('INSERT INTO <http://example.com/> {
            <http://person1> <http://example.com/kennt> "Test" .
            <http://person2> <http://example.com/kennt> "Test" .
            <http://person3> <http://example.com/kennt> "Test" .
            <http://person4> <http://example.com/kennt> "Test2" .
        }');

        $res = $this->subjectUnderTest->query('
            PREFIX ex: <http://example.com/>
            SELECT DISTINCT ?name WHERE {
                ?s ex:kennt ?name
            }
        ');

        $this->assertEquals(
            [
                ['name' => 'Test', 'name type' => 'literal'],
                ['name' => 'Test2', 'name type' => 'literal'],
            ],
            $res['result']['rows']
        );
    }
}