エントリクエリ

エントリクエリを使用して、テンプレートや PHP コード内でエントリを取得できます。

{# Create a new entry query #}
{% set myEntryQuery = craft.entries() %}

エレメントクエリを作成すると、結果を絞り込むためのパラメータをセットできます。さらに、 .all() を呼び出して実行できます。Entry オブジェクトの配列が返されます。

TIP

エレメントクエリがどのように機能するかについては、エレメントクエリについてを参照してください。

実例

次の操作を行うことで、「Blog」セクションに含まれる最新10件のエントリを表示できます。

  1. craft.entries() でエントリクエリを作成します。
  2. section および limit パラメータをセットします。
  3. .all() でエントリを取得します。
  4. for タグを使用してエントリをループ処理し、ブログ投稿の HTML を出力します。
{# Create an entry query with the 'section' and 'limit' parameters #}
{% set myEntryQuery = craft.entries()
    .section('blog')
    .limit(10) %}

{# Fetch the entries #}
{% set entries = myEntryQuery.all() %}

{# Display the entries #}
{% for entry in entries %}
    <article>
        <h1><a href="{{ entry.url }}">{{ entry.title }}</a></h1>
        {{ entry.summary }}
        <a href="{{ entry.url }}">Continue reading</a>
    </article>
{% endfor %}

パラメータ

エントリクエリは、次のパラメータをサポートしています。

after

特定の日付以降に投稿されたエントリだけに、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
'2018-04-01'2018-04-01 以降に投稿されたもの。
DateTime オブジェクトオブジェクトとして表される日付以降に投稿されたもの。
{# Fetch entries posted this month #}
{% set firstDayOfMonth = date('first day of this month') %}

{% set entries = craft.entries()
    .after(firstDayOfMonth)
    .all() %}

ancestorDist

ancestorOf で指定されたエントリから特定の距離だけ離れているエントリのみに、クエリの結果を絞り込みます。

{# Fetch entries above this one #}
{% set entries = craft.entries()
    .ancestorOf(myEntry)
    .ancestorDist(3)
    .all() %}

ancestorOf

指定したエントリの先祖であるエントリだけに、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
1ID が 1 のエントリの上層。
Entry オブジェクトオブジェクトで表されるエントリの上層。
{# Fetch entries above this one #}
{% set entries = craft.entries()
    .ancestorOf(myEntry)
    .all() %}

TIP

どれだけ離れた先祖エントリを対象にするか制限したい場合、ancestorDist と組み合わせることができます。

anyStatus

status および enabledForSite パラメータをクリアします。

{# Fetch all entries, regardless of status #}
{% set entries = craft.entries()
    .anyStatus()
    .all() %}

asArray

Entry オブジェクトではなく、データの配列として、マッチしたエントリをクエリが返します。

{# Fetch entries as arrays #}
{% set entries = craft.entries()
    .asArray()
    .all() %}

authorGroup

エントリの投稿者が属するユーザーグループに基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
'foo'ハンドルが foo のグループ内の投稿者。
'not foo'ハンドルが foo のグループ内の投稿者ではない。
['foo', 'bar']ハンドルが foo または bar のグループ内の投稿者。
['not', 'foo', 'bar']ハンドルが foo または bar のグループ内の投稿者ではない。
UserGroup オブジェクトオブジェクトで表されるグループ内の投稿者。
{# Fetch entries with an author in the Foo user group #}
{% set entries = craft.entries()
    .authorGroup('foo')
    .all() %}

authorGroupId

グループの ID ごとに、エントリの投稿者が属するユーザーグループに基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
1ID が 1 のグループ内の投稿者。
'not 1'ID が 1 のグループ内の投稿者ではない。
[1, 2]ID が 1 または 2 のグループ内の投稿者。
['not', 1, 2]ID が 1 または 2 のグループ内の投稿者ではない。
{# Fetch entries with an author in a group with an ID of 1 #}
{% set entries = craft.entries()
    .authorGroupId(1)
    .all() %}

authorId

エントリの投稿者に基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
1ID が 1 の投稿者。
'not 1'ID が 1 の投稿者ではない。
[1, 2]ID が 1 または 2 の投稿者。
['not', 1, 2]ID が 1 または 2 の投稿者ではない。
{# Fetch entries with an author with an ID of 1 #}
{% set entries = craft.entries()
    .authorId(1)
    .all() %}

before

特定の日付より前に投稿されたエントリだけに、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
'2018-04-01'2018-04-01 より前に投稿されたもの。
DateTime オブジェクトオブジェクトで表される日付より前に投稿されたもの。
{# Fetch entries posted before this month #}
{% set firstDayOfMonth = date('first day of this month') %}

{% set entries = craft.entries()
    .before(firstDayOfMonth)
    .all() %}

dateCreated

エントリの作成日に基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
'>= 2018-04-01'2018-04-01 以降に作成されたもの。
'< 2018-05-01'2018-05-01 より前に作成されたもの。
['and', '>= 2018-04-04', '< 2018-05-01']2018-04-01 から 2018-05-01 の間に作成されたもの。
{# Fetch entries created last month #}
{% set start = date('first day of last month')|atom %}
{% set end = date('first day of this month')|atom %}

{% set entries = craft.entries()
    .dateCreated(['and', ">= #{start}", "< #{end}"])
    .all() %}

dateUpdated

エントリの最終アップデート日に基づいて、クエリの結果が絞り込まれます。

利用可能な値には、次のものが含まれます。

取得するエントリ
'>= 2018-04-01'2018-04-01 以降にアップデートされたもの。
'< 2018-05-01'2018-05-01 より前にアップデートされたもの。
['and', '>= 2018-04-04', '< 2018-05-01']2018-04-01 から 2018-05-01 の間にアップデートされたもの。
{# Fetch entries updated in the last week #}
{% set lastWeek = date('1 week ago')|atom %}

{% set entries = craft.entries()
    .dateUpdated(">= #{lastWeek}")
    .all() %}

descendantDist

descendantOf で指定されたエントリから特定の距離だけ離れているエントリのみに、クエリの結果を絞り込みます。

{# Fetch entries below this one #}
{% set entries = craft.entries()
    .descendantOf(myEntry)
    .descendantDist(3)
    .all() %}

descendantOf

指定したエントリの子孫であるエントリだけに、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
1ID が 1 のカテゴリの下層。
Entry オブジェクトオブジェクトで表されるエントリの下層。
{# Fetch entries below this one #}
{% set entries = craft.entries()
    .descendantOf(myEntry)
    .all() %}

TIP

どれだけ離れた子孫エントリを対象にするか制限したい場合、descendantDist と組み合わせることができます。

enabledForSite

site パラメータごとに、照会されているサイトでエントリが有効になっているかどうかに基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
1サイト内で有効になっているもの。
a \craft\elements\db\User objectサイト内で有効かどうかに関係なく。
{# Fetch all entries, including ones disabled for this site #}
{% set entries = craft.entries()
    .enabledForSite(false)
    .all() %}

expiryDate

エントリの有効期限日に基づいて、クエリの結果を絞り込みます。

利用可能な値には、次のものが含まれます。

取得するエントリ
b7c56':empty:'6.79477389':empty:'有効期限日を持たない。
{# Fetch entries expiring this month #}
{% set nextMonth = date('first day of next month')|atom %}

{% set entries = craft.entries()
    .expiryDate("< #{nextMonth}")
    .all() %}

fixedOrder

クエリの結果を id で指定された順序で返します。

    {# Fetch entries in a specific order #}
    {% set entries = craft.entries()
        .id([1, 2, 3, 4, 5])
        .fixedOrder()
        .all() %}
    
    // Fetch entries in a specific order
    $entries = \craft\elements\Entry::find()
        ->id([1, 2, 3, 4, 5])
        ->fixedOrder()
        ->all();
    

    :::

    hasDescendants

    (これは leaves の呼び出しと反対の効果を持っています。)

    {# Fetch entries that have descendants #}
    {% set entries = craft.entries()
        .hasDescendants()
        .all() %}
    

    id

    エントリの ID に基づいて、クエリの結果を絞り込みます。

    利用可能な値には、次のものが含まれます。

    取得するエントリ
    true(default)レベルが 1。
    'not 1'レベルが 1 ではない。
    {# Fetch the entry by its ID #}
    {% set entry = craft.entries()
        .id(1)
        .one() %}
    

    inReverse

    TIP

    特定の順序で結果を返したい場合、fixedOrder と組み合わせることができます。

    クエリの結果を逆順で返します。

    取得するエントリ
    1ID が 1 のエントリの後。
    ':notempty:'オブジェクトで表されるエントリの後。
    '>= 2020-04-01'that will expire on or after 2020-04-01.
    '< 2020-05-01'that will expire before 2020-05-01
    ['and', '>= 2020-04-04', '< 2020-05-01']that will expire between 2020-04-01 and 2020-05-01.
    {# Fetch entries in reverse #}
    {% set entries = craft.entries()
        .inReverse()
        .all() %}
    

    leaves

    エントリが「leaves」(子孫のないエントリ)であるかどうかに基づいて、クエリの結果を絞り込みます。

    (これは hasDescendants の呼び出しと反対の効果を持っています。)

    {# Fetch entries that have no descendants #}
    {% set entries = craft.entries()
        .leaves()
        .all() %}
    
    // Fetch entries that have no descendants
    $entries = \craft\elements\Entry::find()
        ->leaves()
        ->all();
    

    :::

    level

    :::

    構造内のエントリのレベルに基づいて、クエリの結果を絞り込みます。

    利用可能な値には、次のものが含まれます。

    {# Fetch entries positioned at level 3 or above #}
    {% set entries = craft.entries()
        .level('>= 3')
        .all() %}
    
    // Fetch entries positioned at level 3 or above
    $entries = \craft\elements\Entry::find()
        ->level('>= 3')
        ->all();
    

    :::

    limit

    :::

    返されるエントリの数を決定します。

    取得するエントリ
    1ID が 1 のエントリの後。
    'not 1'オブジェクトで表されるエントリの後。
    [1, 2]with an ID of 1 or 2.
    ['not', 1, 2]not with an ID of 1 or 2.
    {# Fetch up to 10 entries  #}
    {% set entries = craft.entries()
        .limit(10)
        .all() %}
    

    指定したエントリの直後にあるエントリだけに、クエリの結果を絞り込みます。

    nextSiblingOf

    利用可能な値には、次のものが含まれます。

    offset

      {# Fetch the next entry #}
      {% set entry = craft.entries()
          .nextSiblingOf(myEntry)
          .one() %}
      
      // Fetch the next entry
      $entry = \craft\elements\Entry::find()
          ->nextSiblingOf($myEntry)
          ->one();
      

      :::

      orderBy

        返されるエントリの順序を決定します。

        {# Fetch all entries except for the first 3 #}
        {% set entries = craft.entries()
            .offset(3)
            .all() %}
        
        // Fetch all entries except for the first 3
        $entries = \craft\elements\Entry::find()
            ->offset(3)
            ->all();
        

        :::

        positionedAfter

        :::

        指定したエントリの後に位置するエントリだけに、クエリの結果を絞り込みます。

        取得するエントリ
        1ID が 1 のエントリの前。
        'not 1'オブジェクトで表されるエントリの前。
        '>= 3'with a level greater than or equal to 3.
        [1, 2]with a level of 1 or 2
        ['not', 1, 2]not with level of 1 or 2.

        利用可能な値には、次のものが含まれます。

        {# Fetch all entries in order of date created #}
        {% set entries = craft.entries()
            .orderBy('dateCreated asc')
            .all() %}
        
        // Fetch all entries in order of date created
        $entries = \craft\elements\Entry::find()
            ->orderBy('dateCreated asc')
            ->all();
        

        :::

        positionedBefore

        :::

        指定したエントリの前に位置するエントリだけに、クエリの結果を絞り込みます。

        {# Fetch entries after this one #}
        {% set entries = craft.entries()
            .positionedAfter(myEntry)
            .all() %}
        
        // Fetch entries after this one
        $entries = \craft\elements\Entry::find()
            ->positionedAfter($myEntry)
            ->all();
        

        :::

        postDate

          取得するエントリ
          gt;= 2018-04-01'43bb36c30.80274976'>= 2018-04-01'2018-04-01 以降に投稿されたもの。
          a Entry object2018-05-01 より前に投稿されたもの。

          エントリの投稿日に基づいて、クエリの結果を絞り込みます。

          {# Fetch entries before this one #}
          {% set entries = craft.entries()
              .positionedBefore(myEntry)
              .all() %}
          
          // Fetch entries before this one
          $entries = \craft\elements\Entry::find()
              ->positionedBefore($myEntry)
              ->all();
          

          :::

          prevSiblingOf

            {# Fetch entries posted last month #}
            {% set start = date('first day of last month')|atom %}
            {% set end = date('first day of this month')|atom %}
            
            {% set entries = craft.entries()
                .postDate(['and', ">= #{start}", "< #{end}"])
                .all() %}
            
            // Fetch entries posted last month
            $start = (new \DateTime('first day of last month'))->format(\DateTime::ATOM);
            $end = (new \DateTime('first day of this month'))->format(\DateTime::ATOM);
            
            $entries = \craft\elements\Entry::find()
                ->postDate(['and', ">= {$start}", "< {$end}"])
                ->all();
            

            :::

            relatedTo

            利用可能な値には、次のものが含まれます。

            {# Fetch the previous entry #}
            {% set entry = craft.entries()
                .prevSiblingOf(myEntry)
                .one() %}
            

            特定の他のエレメントと関連付けられたエントリだけに、クエリの結果を絞り込みます。

            このパラメーターがどのように機能するかの詳細については、リレーションを参照してください。

            取得するエントリ
            1ID が 1 のエントリの前。
            Entry オブジェクトオブジェクトで表されるエントリの前。
            {# Fetch all entries that are related to myCategory #}
            {% set entries = craft.entries()
                .relatedTo(myCategory)
                .all() %}
            

            section

            検索クエリにマッチするエントリだけに、クエリの結果を絞り込みます。

            このパラメーターがどのように機能するかの詳細については、検索を参照してください。

            取得するエントリ
            '94.78950570'foo'ハンドルが foo のセクション内。
            a Entry objectハンドルが foo のセクション内ではない。
            {# Get the search query from the 'q' query string param #}
            {% set searchQuery = craft.app.request.getQueryParam('q') %}
            
            {# Fetch all entries that match the search query #}
            {% set entries = craft.entries()
                .search(searchQuery)
                .all() %}
            

            sectionId

            エントリが属するセクションに基づいて、クエリの結果を絞り込みます。

            利用可能な値には、次のものが含まれます。

            取得するエントリ
            1ID が 1 のセクション内。
            'not 1'ID が 1 のセクション内ではない。
            [1, 2]ID が 1 または 2 のセクション内。
            {# Fetch entries in the Foo section #}
            {% set entries = craft.entries()
                .section('foo')
                .all() %}
            

            siblingOf

            セクションの ID ごとに、エントリが属するセクションに基づいて、クエリの結果を絞り込みます。

            利用可能な値には、次のものが含まれます。

              {# Fetch entries in the section with an ID of 1 #}
              {% set entries = craft.entries()
                  .sectionId(1)
                  .all() %}
              
              // Fetch entries in the section with an ID of 1
              $entries = \craft\elements\Entry::find()
                  ->sectionId(1)
                  ->all();
              

              :::

              site

              利用可能な値には、次のものが含まれます。

                {# Fetch entries beside this one #}
                {% set entries = craft.entries()
                    .siblingOf(myEntry)
                    .all() %}
                
                // Fetch entries beside this one
                $entries = \craft\elements\Entry::find()
                    ->siblingOf($myEntry)
                    ->all();
                

                :::

                siteId

                デフォルトでは、現在のサイトが使用されます。

                利用可能な値には、次のものが含まれます。

                {# Fetch entries from the Foo site #}
                {% set entries = craft.entries()
                    .site('foo')
                    .all() %}
                

                slug

                サイトの ID ごとに、エントリを照会するサイトを決定します。

                デフォルトでは、現在のサイトが使用されます。

                取得するエントリ
                3676'foo'4'foo'7'foo'ハンドルが foo のサイトから。
                \craft\elements\db\Site オブジェクトオブジェクトで表されるサイトから。
                {# Fetch entries from the site with an ID of 1 #}
                {% set entries = craft.entries()
                    .siteId(1)
                    .all() %}
                

                status

                エントリのスラグに基づいて、クエリの結果を絞り込みます。

                利用可能な値には、次のものが含まれます。

                取得するエントリ
                e'foo'7.76569554'foo'スラグが foo
                {# Get the requested entry slug from the URL #}
                {% set requestedSlug = craft.app.request.getSegment(3) %}
                
                {# Fetch the entry with that slug #}
                {% set entry = craft.entries()
                    .slug(requestedSlug|literal)
                    .one() %}
                

                title

                エントリのステータスに基づいて、クエリの結果を絞り込みます。

                利用可能な値には、次のものが含まれます。

                取得するエントリ
                1公開しているもの。
                a Entry object保留しているもの(未来の投稿日がセットされた有効なもの)。
                {# Fetch disabled entries #}
                {% set entries = {twig-function}
                    .status('disabled')
                    .all() %}
                

                trashed

                エントリのタイトルに基づいて、クエリの結果を絞り込みます。

                利用可能な値には、次のものが含まれます。

                {# Fetch entries with a title that contains "Foo" #}
                {% set entries = craft.entries()
                    .title('*Foo*')
                    .all() %}
                
                // Fetch entries with a title that contains "Foo"
                $entries = \craft\elements\Entry::find()
                    ->title('*Foo*')
                    ->all();
                

                :::

                type

                :::

                ソフトデリートされたエントリだけに、クエリの結果を絞り込みます。

                {# Fetch trashed entries #}
                {% set entries = {twig-function}
                    .trashed()
                    .all() %}
                

                typeId

                エントリの入力タイプに基づいて、クエリの結果を絞り込みます。

                利用可能な値には、次のものが含まれます。

                取得するエントリ
                'Foo'タイトルが Foo
                'Foo*'タイトルが Foo ではじまる。
                '*Foo'タイトルが Foo で終わる。
                '*Foo*'タイトルが Foo を含む。
                a Section objectタイトルが Foo を含まない。
                {# Fetch entries in the Foo section with a Bar entry type #}
                {% set entries = craft.entries()
                    .section('foo')
                    .type('bar')
                    .all() %}
                

                uid

                タイプの ID ごとに、エントリの入力タイプに基づいて、クエリの結果を絞り込みます。

                利用可能な値には、次のものが含まれます。

                取得するエントリ
                365.3830'foo''foo''foo'0'foo'ハンドルが foo のタイプ。
                'not foo'ハンドルが foo のタイプではない。
                ['foo', 'bar']ハンドルが foo または bar のタイプ。
                ['not', 'foo', 'bar']ハンドルが foo または bar のタイプではない。
                {# Fetch entries of the entry type with an ID of 1 #}
                {% set entries = craft.entries()
                    .typeId(1)
                    .all() %}
                

                uri

                エントリの UID に基づいて、クエリの結果を絞り込みます。

                  {# Fetch the entry by its UID #}
                  {% set entry = craft.entries()
                      .uid('xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx')
                      .one() %}
                  
                  // Fetch the entry by its UID
                  $entry = \craft\elements\Entry::find()
                      ->uid('xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx')
                      ->one();
                  

                  :::

                  with

                  利用可能な値には、次のものが含まれます。

                    取得するエントリ
                    'foo'URI が foo
                    'foo*'URI が foo ではじまる。
                    '*foo'URI が foo で終わる。
                    a \craft\elements\db\Site objectURI が foo を含む。
                    'not *foo*'URI が foo を含まない。

                    関連付けられたエレメントを eager-loaded した状態で、マッチしたエントリをクエリが返します。

                    このパラメーターがどのように機能するかの詳細については、エレメントのEager-Loadingを参照してください。

                    {# Get the requested URI #}
                    {% set requestedUri = craft.app.request.getPathInfo() %}
                    
                    {# Fetch the entry with that URI #}
                    {% set entry = craft.entries()
                        .uri(requestedUri|literal)
                        .one() %}
                    
                    // Get the requested URI
                    $requestedUri = \Craft::$app->request->getPathInfo();
                    
                    // Fetch the entry with that URI
                    $entry = \craft\elements\Entry::find()
                        ->uri(\craft\helpers\Db::escapeParam($requestedUri))
                        ->one();
                    

                    :::

                    siteId

                    :::

                    The current site will be used by default.

                    {# Fetch entries eager-loaded with the "Related" field’s relations #}
                    {% set entries = craft.entries()
                        .with(['related'])
                        .all() %}
                    

                    slug

                    Narrows the query results based on the entries’ slugs.

                    Possible values include:

                    ValueFetches entries…
                    'foo'with a slug of foo.
                    'foo*'with a slug that begins with foo.
                    '*foo'with a slug that ends with foo.
                    '*foo*'with a slug that contains foo.
                    'not *foo*'with a slug that doesn’t contain foo.
                    ['*foo*', '*bar*']with a slug that contains foo or bar.
                    ['not', '*foo*', '*bar*']with a slug that doesn’t contain foo or bar.
                    {# Get the requested entry slug from the URL #}
                    {% set requestedSlug = craft.app.request.getSegment(3) %}
                    
                    {# Fetch the entry with that slug #}
                    {% set entry = craft.entries()
                        .slug(requestedSlug|literal)
                        .one() %}
                    

                    status

                    Narrows the query results based on the entries’ statuses.

                    Possible values include:

                    ValueFetches entries…
                    'live'(default)that are live.
                    'pending'that are pending (enabled with a Post Date in the future).
                    'expired'that are expired (enabled with an Expiry Date in the past).
                    'disabled'that are disabled.
                    ['live', 'pending']that are live or pending.
                    {# Fetch disabled entries #}
                    {% set entries = craft.entries()
                        .status('disabled')
                        .all() %}
                    

                    title

                    Narrows the query results based on the entries’ titles.

                    Possible values include:

                    ValueFetches entries…
                    'Foo'with a title of Foo.
                    'Foo*'with a title that begins with Foo.
                    '*Foo'with a title that ends with Foo.
                    '*Foo*'with a title that contains Foo.
                    'not *Foo*'with a title that doesn’t contain Foo.
                    ['*Foo*', '*Bar*']with a title that contains Foo or Bar.
                    ['not', '*Foo*', '*Bar*']with a title that doesn’t contain Foo or Bar.
                    {# Fetch entries with a title that contains "Foo" #}
                    {% set entries = craft.entries()
                        .title('*Foo*')
                        .all() %}
                    

                    trashed

                    Narrows the query results to only entries that have been soft-deleted.

                    {# Fetch trashed entries #}
                    {% set entries = craft.entries()
                        .trashed()
                        .all() %}
                    

                    type

                    Narrows the query results based on the entries’ entry types.

                    Possible values include:

                    ValueFetches entries…
                    'foo'of a type with a handle of foo.
                    'not foo'not of a type with a handle of foo.
                    ['foo', 'bar']of a type with a handle of foo or bar.
                    ['not', 'foo', 'bar']not of a type with a handle of foo or bar.
                    an EntryType objectof a type represented by the object.
                    {# Fetch entries in the Foo section with a Bar entry type #}
                    {% set entries = craft.entries()
                        .section('foo')
                        .type('bar')
                        .all() %}
                    

                    typeId

                    Narrows the query results based on the entries’ entry types, per the types’ IDs.

                    Possible values include:

                    ValueFetches entries…
                    1of a type with an ID of 1.
                    'not 1'not of a type with an ID of 1.
                    [1, 2]of a type with an ID of 1 or 2.
                    ['not', 1, 2]not of a type with an ID of 1 or 2.
                    {# Fetch entries of the entry type with an ID of 1 #}
                    {% set entries = craft.entries()
                        .typeId(1)
                        .all() %}
                    

                    uid

                    Narrows the query results based on the entries’ UIDs.

                    {# Fetch the entry by its UID #}
                    {% set entry = craft.entries()
                        .uid('xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx')
                        .one() %}
                    

                    unique

                    Determines whether only elements with unique IDs should be returned by the query.

                    This should be used when querying elements from multiple sites at the same time, if “duplicate” results is not desired.

                    {# Fetch unique entries across all sites #}
                    {% set entries = craft.entries()
                        .site('*')
                        .unique()
                        .all() %}
                    

                    uri

                    Narrows the query results based on the entries’ URIs.

                    Possible values include:

                    ValueFetches entries…
                    'foo'with a URI of foo.
                    'foo*'with a URI that begins with foo.
                    '*foo'with a URI that ends with foo.
                    '*foo*'with a URI that contains foo.
                    'not *foo*'with a URI that doesn’t contain foo.
                    ['*foo*', '*bar*']with a URI that contains foo or bar.
                    ['not', '*foo*', '*bar*']with a URI that doesn’t contain foo or bar.
                    {# Get the requested URI #}
                    {% set requestedUri = craft.app.request.getPathInfo() %}
                    
                    {# Fetch the entry with that URI #}
                    {% set entry = craft.entries()
                        .uri(requestedUri|literal)
                        .one() %}
                    

                    with

                    Causes the query to return matching entries eager-loaded with related elements.

                    See Eager-Loading Elements for a full explanation of how to work with this parameter.

                    {# Fetch entries eager-loaded with the "Related" field’s relations #}
                    {% set entries = craft.entries()
                        .with(['related'])
                        .all() %}