sql_on

Nutzung

explore: view_name_1 {
  join: view_name_2 {
    sql_on: ${view_name_1.id} = ${view_name_2.id} ;;
  }
}

Hierarchie Modelldatei explore join sql_on

Standardwert Keine Akzeptiert Eine SQL-ON-Klausel Sonderregeln sql_on, sql_foreign_key und foreign_key dürfen nicht gleichzeitig innerhalb desselben join verwendet werden.

Definition

sql_on stellt eine Join-Beziehung zwischen einer Ansicht und ihrem Explore auf der Grundlage einer von Ihnen bereitgestellten SQL-ON-Klausel her.

Bei LookML spielt die Reihenfolge der Bedingungen in sql_on keine Rolle. Daher sind sql_on: ${order.user_id} = ${user.id} ;; und sql_on: ${user.id} = ${order.user_id} ;; gleichwertig. Sie können die Bedingungen in beliebiger Reihenfolge angeben, es sei denn, die Reihenfolge ist für den SQL-Dialekt Ihrer Datenbank relevant.

Eine Ansicht kann direkt mit einem Explore verknüpft werden, wenn Sie sql_on verwenden. Alternativ kann sie über eine zweite Ansicht verknüpft werden, die bereits mit diesem Explore verknüpft ist.

Ein Beispiel für den ersten Fall, in dem eine Ansicht direkt mit dem Explore verknüpft wird, sieht so aus:

explore: order {
  join: customer {
    sql_on: ${order.customer_id} = ${customer.id} ;;
  }
}

Der SQL-Code, den Looker aus diesem LookML-Code generieren würde, sieht so aus:

SELECT    ...
FROM      order
LEFT JOIN customer
ON        order.customer_id = customer.id

Im zweiten Fall wird eine Ansicht über eine Zwischenansicht mit einem Explore verknüpft, die bereits mit diesem Explore verknüpft ist. Ein Beispiel dafür wäre:

explore: order_items {
  join: order {
    sql_on: ${order_items.order_id} = ${order.id} ;;
  }
  join: customer {
    sql_on: ${order.customer_id} = ${customer.id} ;;
  }
}

Hier kann customer nicht direkt mit order_items verknüpft werden. Stattdessen muss die Verknüpfung über order erfolgen. Der SQL-Code, den Looker aus diesem LookML-Code generieren würde, sieht so aus:

SELECT    ...
FROM      order_items
LEFT JOIN order
ON        order_items.order_id = order.id
LEFT JOIN customer
ON        order.customer_id = customer.id

Damit das ordnungsgemäß funktioniert, müssen Sie nur die richtigen Ansichtsnamen in den Feldverweisen verwenden. Da customer mit einem Feld in order verknüpft werden muss, verweisen wir auf ${order.customer_id}.

In einigen älteren Modellen werden Felder möglicherweise mit der Syntax view_name.native_column_name referenziert. Das funktioniert zwar immer noch, aber die Verwendung der ${view_name.looker_dimension_name} Syntax hat einen wichtigen Vorteil: Sie können den required_joins Parameter vermeiden. Dieses Konzept wird auf dieser Seite im Abschnitt Verwenden Sie required_joins, wenn die Syntax ${view_name.looker_dimension_name} nicht verwendet werden kann näher erläutert.

Bedingte Joins

Es ist auch möglich, Nutzereingaben in sql_on zu verwenden. Dafür kann es verschiedene Gründe geben. Ein wichtiger Anwendungsfall ist die Optimierung der Abfragegeschwindigkeit in MPP-Datenbanken (z. B. Redshift), wie im Community-Beitrag Bedingungen in Join-Klauseln beschrieben.

Wenn Sie Ihrer Join-Bedingung Nutzereingaben hinzufügen möchten, müssen Sie zuerst einen Filter für die Eingabe erstellen. Diese Arten von Filtern werden auf der Seite Vorlagenbasierte Filter näher beschrieben. Die Grundform sieht so aus:

view: view_name {
  filter: filter_name {
    type: number | datetime | date | string
  }
}

Nachdem Sie einen Filter zum Erfassen der Nutzereingabe hinzugefügt haben, verwenden Sie ihn so im Parameter sql_on:

{% condition view_name.filter_name %} view_name.dimension_name {% endcondition %}

Beispiel:

explore: order {
  join: customer {
    sql_on:
      ${order.customer_id} = ${customer.id} AND
      {% condition customer.creation_date_filter %} customer.created_at {% endcondition %} ;;
  }
}

Das bedeutet: Setzen Sie customer.created_at auf den Wert von customer.creation_date_filter.

Liquid-Variablen _in_query, _is_selected und _is_filtered verwenden

Die _in_query, _is_selected und _is_filtered Liquid-Variablen können in Verbindung mit dem Parameter sql_on nützlich sein. Sie ermöglichen es Ihnen, Join-Beziehungen basierend auf den Feldern zu ändern, die ein Nutzer für seine Abfrage ausgewählt hat. Beispiel:

explore: dates {
  join: dynamic_order_counts {
    sql_on:
      ${dynamic_order_counts.period} =
      {% if dates.reporting_date._in_query %}
        ${dates.date_string}
      {% elsif dates.reporting_week._in_query %}
        ${dates.week_string}
      {% else %}
        ${dates.month_string}
      {% endif %} ;;
  }
}

Beispiele

Verknüpfen Sie die Ansicht customer mit dem Explore order, indem Sie die Dimension customer_id aus order mit der Dimension id aus customer abgleichen:

explore: order {
  join: customer {
    sql_on: ${order.customer_id} = ${customer.id} ;;
  }
}

Verknüpfen Sie die Ansicht customer über die Ansicht order mit dem Explore order_items. Gleichen Sie die customer_id Dimension aus order mit der id Dimension aus customer ab. Gleichen Sie die order_id Dimension aus order_items mit der id Dimension aus order ab. Das wird so angegeben:

explore: order_items {
  join: order {
    sql_on: ${order_items.order_id} = ${order.id} ;;
  }
  join: customer {
    sql_on: ${order.customer_id} = ${customer.id} ;;
  }
}

Verknüpfen Sie die Ansichten order und inventory_items mit dem Explore order_items. Gleichen Sie die inventory_id Dimension aus order_items mit der id Dimension aus inventory_item ab. Gleichen Sie die order_id Dimension aus order_items mit der id Dimension aus order ab. Das wird so angegeben:

explore: order_items {
  join: order {
    sql_on: ${order_items.order_id} = ${order.id} ;;
  }
  join: inventory_item {
    sql_on: ${order_items.inventory_id} = ${inventory_item.id} ;;
  }
}

Wichtige Punkte

required_joins verwenden, wenn die Syntax ${view_name.looker_dimension_name} nicht verwendet werden kann

Wenn Sie Felder in sql_on mit der ${view_name.looker_dimension_name} Syntax referenzieren, müssen Sie sich keine Gedanken über die Verwendung von required_joins machen.

In einigen älteren Modellen wird jedoch noch die Syntax view_name.native_column_name verwendet. Es gibt auch Fälle, in denen Sie die Syntax ${view_name.looker_dimension_name} nicht verwenden können, z. B. wenn Sie benutzerdefinierten SQL-Code anwenden möchten.

In diesen Fällen müssen Sie möglicherweise required_joins verwenden. Weitere Informationen finden Sie auf der required_joins Dokumentationsseite zum Parameter.