SQL 명령을 사용하여 의미 체계 뷰 생성하기 및 관리하기

이 항목에서는 다음 SQL 명령을 사용하여 의미 체계 뷰 를 만들고 관리하는 방법을 설명합니다.

이 항목에서는 다음 저장 프로시저와 함수를 호출하여 :doc:`YAML 사양 <semantic-view-yaml-spec>`에서 의미 체계 뷰를 생성하고 의미 체계 뷰에 대한 사양을 가져오는 방법에 대해 설명합니다.

의미 체계 뷰를 생성하거나 바꾸는 데 필요한 권한

의미 체계 뷰를 생성하거나 바꾸려면 다음 권한이 있는 역할을 사용해야 합니다.

  • 의미 체계 뷰를 생성하는 스키마에 CREATE SEMANTIC VIEW 를 추가합니다.

  • 의미 체계 뷰를 생성하는 데이터베이스 및 스키마에 USAGE 를 추가합니다.

  • 의미 체계 뷰에 사용된 테이블과 뷰에 대한 SELECT 권한

의미 체계 뷰를 쿼리하는 데 필요한 권한에 대한 내용은 의미 체계 뷰를 쿼리하는 데 필요한 권한 섹션을 참조하세요.

CREATE SEMANTIC VIEW 명령을 사용하여 의미 체계 뷰 생성하기

의미 체계 뷰를 생성하려면 CREATE SEMANTIC VIEW 명령을 사용합니다.

참고

YAML 사양 <semantic-view-yaml-spec>`에서 의미 체계 뷰를 생성하려면 :doc:/sql-reference/stored-procedures/system_create_semantic_view_from_yaml` 저장 프로시저를 호출합니다.

의미 체계 뷰가 유효해야 합니다. Snowflake가 의미 체계 뷰를 검증하는 방법 섹션을 참조하십시오.

다음 예제에서는 Snowflake에서 사용할 수 있는 :doc:`TPC-H 샘플 데이터 </user-guide/sample-data-tpch>`를 사용합니다. 이 데이터 세트에는 고객, 주문 및 품목을 포함한 단순화된 비즈니스 시나리오를 보여주는 테이블이 포함되어 있습니다.

TPC-H 샘플 데이터에 사용된 테이블의 데이터 모델링

이 예제에서는 TPC-H 데이터 세트의 테이블을 사용하여 tpch_rev_analysis 라는 이름의 의미 체계 뷰를 생성합니다. 의미 체계 뷰는 다음을 정의합니다.

  • 3개의 논리 테이블(orders, customers, line_items).

  • orders 및 customers 테이블 간의 관계.

  • line_items 및 orders 테이블 간의 관계.

  • 메트릭을 계산하는 데 사용되는 정보.

  • 고객 이름, 주문 날짜 및 주문이 이루어진 연도에 대한 차원.

  • 주문의 평균값 및 주문의 평균 품목 수에 대한 메트릭.

CREATE SEMANTIC VIEW tpch_rev_analysis

  TABLES (
    orders AS SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.ORDERS
      PRIMARY KEY (o_orderkey)
      WITH SYNONYMS ('sales orders')
      COMMENT = 'All orders table for the sales domain',
    customers AS SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.CUSTOMER
      PRIMARY KEY (c_custkey)
      COMMENT = 'Main table for customer data',
    line_items AS SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.LINEITEM
      PRIMARY KEY (l_orderkey, l_linenumber)
      COMMENT = 'Line items in orders'
  )

  RELATIONSHIPS (
    orders_to_customers AS
      orders (o_custkey) REFERENCES customers,
    line_item_to_orders AS
      line_items (l_orderkey) REFERENCES orders
  )

  FACTS (
    line_items.line_item_id AS CONCAT(l_orderkey, '-', l_linenumber),
    orders.count_line_items AS COUNT(line_items.line_item_id),
    line_items.discounted_price AS l_extendedprice * (1 - l_discount)
      COMMENT = 'Extended price after discount'
  )

  DIMENSIONS (
    customers.customer_name AS customers.c_name
      WITH SYNONYMS = ('customer name')
      COMMENT = 'Name of the customer',
    orders.order_date AS o_orderdate
      COMMENT = 'Date when the order was placed',
    orders.order_year AS YEAR(o_orderdate)
      COMMENT = 'Year when the order was placed'
  )

  METRICS (
    customers.customer_count AS COUNT(c_custkey)
      COMMENT = 'Count of number of customers',
    orders.order_average_value AS AVG(orders.o_totalprice)
      COMMENT = 'Average order value across all orders',
    orders.average_line_items_per_order AS AVG(orders.count_line_items)
      COMMENT = 'Average number of line items per order'
  )

  COMMENT = 'Semantic view for revenue analysis';

다음 섹션에서는 이 예제에 대해 자세히 설명합니다.

참고

전체 예제는 SQL 을 사용하여 의미 체계 뷰를 생성하는 예제 섹션을 참조하십시오.

논리 테이블 정의하기

CREATE SEMANTIC VIEW 명령에서 TABLES 절을 사용하여 뷰의 논리적 테이블을 정의합니다. 이 절에서는 다음을 할 수 있습니다.

  • 실제 테이블 이름과 선택적 별칭을 지정합니다.

  • 논리 테이블에서 다음 열을 식별합니다.

    • 기본 키 역할을 하는 열입니다.

    • 고유한 값을 포함하는 열(기본 키 열 제외).

    이러한 열을 사용하여 이 의미 체계 뷰에서 관계를 정의할 수 있습니다.

  • 테이블의 동의어 추가(검색 가능성 개선).

  • 설명이 포함된 설명을 입력합니다.

앞서 제공된 예제 에서 TABLES 절은 세 개의 논리 테이블을 정의합니다.

  • TPC-H orders 테이블의 주문 정보가 포함된 orders 테이블.

  • TPC-H customers 테이블의 고객 정보가 포함된 customers 테이블.

  • line_items-H TPC 테이블의 주문 품목이 포함된 lineitem 테이블.

이 예에서는 PRIMARY KEY 절을 사용하여 각 논리 테이블의 기본 키로 사용할 열을 식별합니다. 기본 키와 고유 값은 테이블 간(예: 다대일 또는 일대일) :ref:`관계<label-semantic_views_create_relationships>`의 유형을 결정하는 데 도움이 됩니다.

이 예제에서는 논리 테이블을 설명하고 데이터를 더 쉽게 검색할 수 있도록 동의어와 설명도 제공합니다.

TABLES (
  orders AS SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.ORDERS
    PRIMARY KEY (o_orderkey)
    WITH SYNONYMS ('sales orders')
    COMMENT = 'All orders table for the sales domain',
  customers AS SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.CUSTOMER
    PRIMARY KEY (c_custkey)
    COMMENT = 'Main table for customer data',
  line_items AS SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.LINEITEM
    PRIMARY KEY (l_orderkey, l_linenumber)
    COMMENT = 'Line items in orders'
)

논리 테이블 간의 관계 식별하기

CREATE SEMANTIC VIEW 명령에서 RELATIONSHIPS 절을 사용하여 뷰에 있는 테이블 간의 관계를 식별합니다. 각 관계에 대해 다음을 지정합니다.

  • 관계의 선택적 이름입니다.

  • 외래 키가 포함된 논리적 테이블의 이름입니다.

  • 해당 테이블에서 외래 키를 정의하는 열입니다.

  • 기본 키 또는 고유 값을 가진 열을 포함하는 논리 테이블의 이름입니다.

  • 해당 테이블에서 기본 키를 정의하거나 고유 값을 포함하는 열입니다.

    • TABLES 절에서 논리적 테이블에 PRIMARY KEY 를 이미 지정한 경우 관계에서 기본 키 열을 지정할 필요가 없습니다.

    • TABLES 절에 논리적 테이블에 대한 단일 UNIQUE 키워드가 있는 경우 관계에서 해당 열을 지정할 필요가 없습니다.

    :ref:`범위에 열을 조인<label-semantic_views_create_relationships_asof>`하려면 날짜, 시간, 타임스탬프 또는 숫자 열을 지정할 수도 있습니다.

앞서 제공된 예제 에서 RELATIONSHIPS 절은 2개의 관계를 지정합니다.

  • orders 및 customers 테이블 간의 관계. orders 테이블에서 o_custkey 는 customers 테이블의 기본 키(c_custkey)를 참조하는 외래 키입니다.

  • line_items 및 orders 테이블 간의 관계. line_items 테이블에서 l_orderkey 는 orders 테이블의 기본 키(o_orderkey)를 참조하는 외래 키입니다.

RELATIONSHIPS (
  orders_to_customers AS
    orders (o_custkey) REFERENCES customers (c_custkey),
  line_item_to_orders AS
    line_items (l_orderkey) REFERENCES orders (o_orderkey)
)

날짜, 시간, 타임스탬프 또는 숫자 범위를 사용하여 논리 테이블 조인

기본적으로, 두 논리 테이블 간의 관계를 지정하면 테이블이 같음 조건으로 조인됩니다.

날짜, 시간, 타임스탬프 또는 숫자 범위(한 테이블의 열에 있는 값이 다른 테이블의 열에 있는 값과 동일한 범위에 있어야 함)에서 두 개의 논리 테이블을 조인해야 하는 경우 REFERENCES 절에 열 이름과 함께 ASOF 키워드를 지정할 수 있습니다.

RELATIONSHIPS(
  my_relationship AS
    logical_table_1(
      col_table_1
    )
    REFERENCES
    logical_table_2(
      ASOF col_table_2
    )
)

위에 정의된 의미 체계 뷰의 쿼리는 MATCH_CONDITION 절에서 >= 비교 연산자를 사용하는 :doc:`ASOF JOIN</sql-reference/constructs/asof-join>`을 생성합니다. 이렇게 하면 두 테이블이 조인되어 ``col_table_1``의 값이 ``col_table_2``의 값보다 크거나 같게 됩니다.

...
FROM logical_table_1 ASOF JOIN logical_table_2
  MATCH_CONDITION(
    logical_table_1.col_table_1 >= logical_table_2.col_table_2
  )
...

참고

MATCH_CONDITION 절의 다른 어떤 비교 연산자도 지원되지 않습니다.

:ref:`ASOF JOIN과 함께 사용할 수 있는 동일한 유형<label-asof_join_data_types>`의 ASOF 키워드를 사용할 수 있습니다.

참고

주어진 관계의 정의에서 ASOF 키워드를 최대 1개만 지정할 수 있습니다. 목록의 열 앞에 이 키워드를 지정할 수 있습니다.

예를 들어, 고객, 고객 주소, 주문 데이터가 포함된 테이블이 있다고 가정해 보겠습니다.

CREATE OR REPLACE TABLE customer(
  c_cust_id VARCHAR,
  c_first_name VARCHAR,
  c_last_name VARCHAR);

INSERT INTO customer VALUES
  ('cust001', 'Mary', 'Smith'),
  ('cust002', 'Bill', 'Wilson');

CREATE OR REPLACE TABLE customer_address(
  ca_cust_id VARCHAR,
  ca_zipcode VARCHAR,
  ca_street_addr VARCHAR,
  ca_start_date DATE,
  ca_end_date DATE
);

INSERT INTO customer_address VALUES
  ('cust001', '94025', '100 Main Street', '2024-01-01', '2024-03-31'),
  ('cust001', '94026', '200 Main Street', '2024-04-01', '2024-06-30'),
  ('cust001', '94027', '300 Main Street', '2024-07-01', NULL),
  ('cust002', '94028', '400 Main Street', '2024-01-01', '2024-04-30'),
  ('cust002', '94029', '500 Main Street', '2024-05-01', '2024-07-31'),
  ('cust002', '94030', '600 Main Street', '2024-08-01', NULL);

CREATE OR REPLACE TABLE orders(
  o_ord_id VARCHAR,
  o_cust_id VARCHAR,
  o_ord_date DATE,
  o_amount NUMBER
);

INSERT INTO orders VALUES
  ('ord100', 'cust001', '2024-02-01', 100),
  ('ord101', 'cust001', '2024-02-02', 200),
  ('ord102', 'cust001', '2024-05-01', 300),
  ('ord103', 'cust001', '2024-05-02', 400),
  ('ord104', 'cust001', '2024-08-01', 500),
  ('ord105', 'cust001', '2024-08-02', 600),
  ('ord106', 'cust002', '2024-03-01', 100),
  ('ord107', 'cust002', '2024-03-02', 200),
  ('ord108', 'cust002', '2024-06-01', 300),
  ('ord109', 'cust002', '2024-06-02', 400),
  ('ord110', 'cust002', '2024-09-01', 500),
  ('ord111', 'cust002', '2024-09-02', 600);

이 예에서는 customer_address 테이블에 고객이 지정된 주소에 거주하기 시작한 시점을 나타내는 ca_start_date 열이 있습니다. orders 테이블에 주문 날짜인 o_ord_date 열이 있습니다.

고객 주문에 대한 정보를 쿼리하고 주문 시 고객이 거주했던 곳에 해당하는 우편번호를 검색하려고 한다고 가정해 보겠습니다.

ca_start_date 및 o_ord_date 열 사이에 ASOF 조인을 지정하는 의미 체계 뷰를 정의할 수 있습니다.

CREATE OR REPLACE SEMANTIC VIEW customer_orders_view
  TABLES (
    customer_address UNIQUE (ca_cust_id, ca_start_date),
    customer UNIQUE (c_cust_id),
    orders UNIQUE (o_ord_id)
  )
  RELATIONSHIPS (
    customer_address(ca_cust_id) REFERENCES customer,
    -- Defines an ASOF JOIN on the date columns.
    orders(o_cust_id, o_ord_date)
      REFERENCES
        customer_address(ca_cust_id, ASOF ca_start_date)
  )
  FACTS (
    customer_address.f_zipcode AS ca_zipcode
  )
  DIMENSIONS (
    -- Relies on the ASOF join to retrieve the zip code
    -- where the order date is greater than or equal to
    -- the address starting date.
    orders.f_cust_zipcode AS customer_address.f_zipcode,
    orders.dim_year_month AS DATE_TRUNC('month', o_ord_date)
  )
  METRICS (
    orders.m_order_amount AS SUM(o_amount)
  );

:doc:`이 의미 체계 뷰를 쿼리<querying>`하여 각 우편번호에 대한 월별 주문 금액의 합계를 반환하려고 합니다.

SELECT * FROM SEMANTIC_VIEW(
  customer_orders_view
  DIMENSIONS orders.dim_year_month, orders.f_cust_zipcode
  METRICS orders.m_order_amount
);

+----------------+----------------+----------------+
| DIM_YEAR_MONTH | F_CUST_ZIPCODE | M_ORDER_AMOUNT |
|----------------+----------------+----------------|
| 2024-02-01     | 94025          |            300 |
| 2024-05-01     | 94026          |            700 |
| 2024-08-01     | 94027          |           1100 |
| 2024-03-01     | 94028          |            300 |
| 2024-09-01     | 94030          |           1100 |
| 2024-06-01     | 94029          |            700 |
+----------------+----------------+----------------+

쿼리는 ASOF JOIN을 효과적으로 사용하여 주문 날짜가 주소 시작 날짜보다 크거나 같은 날짜 열의 테이블을 조인합니다.

...
FROM orders ASOF JOIN customer_address
  MATCH_CONDITION(
    orders.o_ord_date >= customer_address.ca_start_date
  )
  ON
    orders.o_cust_id = customer_address.ca_cust_id
...

값 범위가 포함된 논리 테이블 조인하기

첫 번째 테이블에서 가능한 값의 범위를 정의하는 다른 테이블과 테이블을 조인하려는 경우 *범위 조인*을 사용할 수 있습니다. 예를 들어, 한 테이블이 판매 주문을 나타내고 주문 시점의 타임스탬프가 있는 열이 있다고 가정해 보겠습니다. 다른 테이블은 회계 분기를 나타내고 이러한 분기를 나타내는 고유한 시간 범위가 포함되어 있다고 가정해 보겠습니다. 주문의 행에 주문이 이루어진 회계 분기가 포함되도록 두 테이블을 조인하는 의미 체계 뷰를 생성할 수 있습니다.

범위가 포함된 테이블에서 각 범위는 고유해야 합니다. 두 범위는 겹칠 수 없습니다.

테이블 데이터에서 범위에 대해 가능한 가장 낮은 값이나 범위에 대해 가능한 가장 높은 값을 지정하려면 NULL을 사용합니다.

예를 들어, 다음 테이블은 겹치지 않는 시간 범위 세트를 정의합니다.

  • 첫 번째 행은 2024년 1월 1일(해당 날짜는 포함되지 않음)까지의 모든 기간을 포함하는 범위를 다룹니다.

  • 마지막 행은 2024년 3월 20일 이후의 모든 기간을 포함하는 범위를 다룹니다.

+----------------+------------------+-------------------------+-------------------------+
| TIME_PERIOD_ID | TIME_PERIOD_NAME | START_TIME              | END_TIME                |
|----------------+------------------+-------------------------+-------------------------|
|              1 | Before_January   | NULL                    | 2024-01-01 00:00:00.000 |
|              2 | Early_January    | 2024-01-01 00:00:00.000 | 2024-01-15 00:00:00.000 |
|              3 | Late_January     | 2024-01-15 00:00:00.000 | 2024-02-01 00:00:00.000 |
|              4 | Early_February   | 2024-02-01 00:00:00.000 | 2024-02-15 00:00:00.000 |
|              5 | Late_February    | 2024-02-15 00:00:00.000 | 2024-03-01 00:00:00.000 |
|              6 | Early_March      | 2024-03-01 00:00:00.000 | 2024-03-20 00:00:00.000 |
|              7 | After_March20    | 2024-03-20 00:00:00.000 | NULL                    |
+----------------+------------------+-------------------------+-------------------------+

참고

어떤 행도 시작 열에 NULL을 포함할 수 없으며, 어떤 행도 마지막 열에 NULL을 포함할 수 없습니다.

이러한 경우에는 범위 조인 쿼리를 지원하는 :doc:`의미 체계 뷰 </user-guide/views-semantic/overview>`를 설정할 수 있습니다. 의미 체계 뷰를 생성할 때 다음을 수행해야 합니다.

  1. 기간의 시작 시간과 종료 시간이 포함된 논리 테이블의 경우, 두 범위가 겹치지 않도록 지정하는 제약 조건을 정의합니다.

    CREATE SEMANTIC VIEW 명령의 TABLE 절에서 논리 테이블 정의에 CONSTRAINT 절을 지정합니다. 구문은 :ref:`CREATE SEMANTIC VIEW 항목의 CONSTRAINT에 대한 설명서 <label-create_semantic_view_tables_constraint>`를 참조하세요.

  2. 한 테이블의 타임스탬프가 포함된 열 및 다른 테이블의 시작 및 종료 시간 열 간의 관계를 정의합니다.

    CREATE SEMANTIC VIEW 명령의 RELATIONSHIPS 절에서 BETWEEN 절을 사용하여 시작 및 종료 시간이 포함된 열을 지정합니다. 구문은 :ref:`CREATE SEMANTIC VIEW 항목의 RELATIONSHIP에 대한 설명서 <label-create_semantic_view_relationships>`를 참조하세요.

예를 들어, my_time_periods 테이블은 고유한 기간을 정의한다고 가정해 보겠습니다.

CREATE OR REPLACE TABLE my_time_periods (
  time_period_id INT PRIMARY KEY,
  time_period_name VARCHAR(50),
  start_time TIMESTAMP,
  end_time TIMESTAMP
);

INSERT INTO my_time_periods (
    time_period_id, time_period_name, start_time, end_time
  ) VALUES
    (1, 'Before_January', NULL, '2024-01-01 00:00:00'::TIMESTAMP),
    (2, 'Early_January', '2024-01-01 00:00:00'::TIMESTAMP, '2024-01-15 00:00:00'::TIMESTAMP),
    (3, 'Late_January', '2024-01-15 00:00:00'::TIMESTAMP, '2024-02-01 00:00:00'::TIMESTAMP),
    (4, 'Early_February', '2024-02-01 00:00:00'::TIMESTAMP, '2024-02-15 00:00:00'::TIMESTAMP),
    (5, 'Late_February', '2024-02-15 00:00:00'::TIMESTAMP, '2024-03-01 00:00:00'::TIMESTAMP),
    (6, 'Early_March', '2024-03-01 00:00:00'::TIMESTAMP, '2024-03-20 00:00:00'::TIMESTAMP),
    (7, 'After_March20', '2024-03-20 00:00:00'::TIMESTAMP, NULL);

my_events 테이블은 해당 기간 내에 발생한 이벤트를 캡처한다고 가정해 보겠습니다.

CREATE OR REPLACE TABLE my_events (
  event_id INTEGER PRIMARY KEY,
  event_timestamp TIMESTAMP,
  event_name VARCHAR
);

INSERT INTO my_events (event_id, event_name, event_timestamp) VALUES
  (1, 'Login', '2024-01-15 10:00:00'::TIMESTAMP),
  (2, 'Purchase', '2024-01-15 14:30:00'::TIMESTAMP),
  (3, 'Logout', '2024-01-15 18:45:00'::TIMESTAMP),
  (4, 'Review', '2024-02-10 12:00:00'::TIMESTAMP),
  (5, 'Support', '2024-02-20 09:30:00'::TIMESTAMP),
  (6, 'Upgrade', '2024-03-05 16:00:00'::TIMESTAMP),
  (7, 'Feedback', '2024-03-25 11:00:00'::TIMESTAMP);

테이블을 조인하는 의미 체계 뷰를 정의할 수 있습니다. my_events``의 행은 ``my_time_periods``의 행과 조인되며, 여기서 ``my_events``의 ``event_timestamp 열은 my_time_periods``의 ``start_time 및 ``end_time``으로 지정된 범위 내에 있습니다.

CREATE OR REPLACE SEMANTIC VIEW my_semantic_view_range_join
  TABLES (
    my_events PRIMARY KEY (event_id),
    my_time_periods UNIQUE (start_time, end_time)
      CONSTRAINT my_time_period_range DISTINCT RANGE BETWEEN start_time AND end_time EXCLUSIVE
  )
  RELATIONSHIPS (
    my_time_periods_for_events AS
      my_events(event_timestamp) REFERENCES
        my_time_periods(BETWEEN start_time AND end_time EXCLUSIVE)
  )
  DIMENSIONS (
    my_events.dim_event_name AS event_name,
    my_events.dim_event_timestamp AS event_timestamp,
    my_time_periods.dim_time_period_name AS time_period_name
  )
  METRICS (
    my_events.m_event_count AS COUNT(*)
  );

다음 쿼리는 행이 조인되는 방법을 보여줍니다.

SELECT
    sv.dim_event_name,
    sv.dim_event_timestamp,
    sv.dim_time_period_name,
    sv.m_event_count
  FROM SEMANTIC_VIEW(
    my_semantic_view_range_join
    METRICS my_events.m_event_count
    DIMENSIONS
      my_events.dim_event_name,
      my_events.dim_event_timestamp,
      my_time_periods.dim_time_period_name
  ) AS sv
  ORDER BY
    sv.dim_event_timestamp,
    sv.dim_time_period_name;

+----------------+-------------------------+----------------------+---------------+
| DIM_EVENT_NAME | DIM_EVENT_TIMESTAMP     | DIM_TIME_PERIOD_NAME | M_EVENT_COUNT |
|----------------+-------------------------+----------------------+---------------|
| Login          | 2024-01-15 10:00:00.000 | Late_January         |             1 |
| Purchase       | 2024-01-15 14:30:00.000 | Late_January         |             1 |
| Logout         | 2024-01-15 18:45:00.000 | Late_January         |             1 |
| Review         | 2024-02-10 12:00:00.000 | Early_February       |             1 |
| Support        | 2024-02-20 09:30:00.000 | Late_February        |             1 |
| Upgrade        | 2024-03-05 16:00:00.000 | Early_March          |             1 |
| Feedback       | 2024-03-25 11:00:00.000 | After_March20        |             1 |
+----------------+-------------------------+----------------------+---------------+

예제에서 볼 수 있듯이, 결과의 각 행에 대한 dim_time_period_name 차원은 dim_event_timestamp 차원이 속한 기간의 이름입니다.

팩트, 차원 및 메트릭 정의하기

CREATE SEMANTIC VIEW 명령에서 FACTS, DIMENSIONS, METRICS 절을 사용하여 의미 체계 뷰에서 팩트, 차원 및 메트릭을 정의합니다.

의미 체계 뷰에서 1개 이상의 차원 또는 메트릭을 정의해야 합니다.

각 팩트, 차원 또는 메트릭에 대해 지정합니다.

  • 그것이 속한 논리 테이블입니다.

    참고

    파생 메트릭(하나의 논리적 테이블에만 국한되지 않는 메트릭)을 정의하려면 논리적 테이블 이름을 생략해야 합니다. 파생 메트릭 정의하기 섹션을 참조하십시오.

  • 팩트, 차원 또는 메트릭의 이름입니다.

  • SQL 식을 사용하여 이를 계산합니다.

    참고

    차원의 경우 차원에 사용할 Cortex Search Service</user-guide/snowflake-cortex/cortex-search/cortex-search-overview>`를 지정할 수 있습니다. 자세한 내용은 :ref:`label-semantic_views_create_cortex_search_service_dimension 섹션을 참조하십시오.

  • 선택적 동의어 및 설명.

참고

특정 차원에서 메트릭을 집계하지 않아야 하는 경우 해당 차원이 비가산 상태여야 함을 지정해야 합니다.

자세한 내용은 메트릭에 대해 비가산되어야 하는 차원 식별하기 섹션을 참조하십시오.

앞서 제공된 예제 는 몇 가지 정보, 차원 및 메트릭을 정의합니다.

FACTS (
  line_items.line_item_id AS CONCAT(l_orderkey, '-', l_linenumber),
  orders.count_line_items AS COUNT(line_items.line_item_id),
  line_items.discounted_price AS l_extendedprice * (1 - l_discount)
    COMMENT = 'Extended price after discount'
)

DIMENSIONS (
  customers.customer_name AS customers.c_name
    WITH SYNONYMS = ('customer name')
    COMMENT = 'Name of the customer',
  orders.order_date AS o_orderdate
    COMMENT = 'Date when the order was placed',
  orders.order_year AS YEAR(o_orderdate)
    COMMENT = 'Year when the order was placed'
)

METRICS (
  customers.customer_count AS COUNT(c_custkey)
    COMMENT = 'Count of number of customers',
  orders.order_average_value AS AVG(orders.o_totalprice)
    COMMENT = 'Average order value across all orders',
  orders.average_line_items_per_order AS AVG(orders.count_line_items)
    COMMENT = 'Average number of line items per order'
)

참고

윈도우 함수를 사용하는 메트릭을 정의하는 방법에 대한 추가 지침은 윈도우 함수 메트릭 정의 및 쿼리 섹션을 참조하세요.

Cortex Search Service를 사용하는 차원 정의

Cortex Search Service. 예:

DIMENSIONS (
  my_table.my_dimension AS my_dimension_expression
    WITH CORTEX SEARCH SERVICE my_db.my_schema.my_dimension_search_service
)

파생 메트릭 정의하기

메트릭을 정의할 때 메트릭이 속한 논리적 테이블의 이름을 지정합니다. 이는 메트릭이 집계되는 논리적 테이블입니다.

다양한 논리적 테이블의 메트릭을 기반으로 메트릭을 정의하려면 *파생 메트릭*을 정의하면 됩니다. 파생 메트릭은 (특정 논리적 테이블이 아닌) 의미 체계 뷰로 범위가 지정된 메트릭입니다. 파생 메트릭은 여러 논리적 테이블의 메트릭을 결합할 수 있습니다.

파생 메트릭의 정의에서 논리적 테이블 이름을 생략합니다.

예를 들어, table_1.metric_1 및 table_2.metric_2``의 합계인 ``my_derived_metric_1 메트릭을 정의하려고 한다고 가정해 보겠습니다. ``my_derived_metric_1``을 정의할 때 논리적 테이블 이름으로 이름을 한정하지 않습니다.

CREATE SEMANTIC VIEW sv_with_derived_metrics
  TABLES (
    table_1 PRIMARY KEY (column_1),
    table_2 PRIMARY KEY (column_2)
  )
  ...
  METRICS (
    table_1.metric_1 AS SUM(...),
    table_2.metric_2 AS SUM(...),
    my_derived_metric_1 AS table_1.metric_1 + table_2.metric_2
  )
 ...

표현식에서 다른 파생 메트릭을 사용할 수 있습니다. 예:

METRICS (
  ...
  my_derived_metric_1 AS table_1.metric_1 + table_2.metric_2,
  my_view_metric_2 AS my_derived_metric_1 + table_3.metric_3
)

파생 메트릭을 정의할 때 다음 제한 사항에 유의하세요.

  • 파생 메트릭과 일반 메트릭에 같은 이름을 사용할 수 없습니다.

  • 파생 메트릭에 대한 식은 다음을 사용할 수 있습니다.

    • 의미 체계 뷰의 논리 테이블에 정의된 차원 및 팩트의 집계.

    • 의미 체계 뷰에서 논리 테이블에 정의된 메트릭의 Scalar 식.

    • 기타 파생 메트릭.

    다음 예제에서는 다음을 수행합니다.

    • ``derived_metric_1``은 두 개의 메트릭이 있는 scalar 식을 사용합니다.

    • ``derived_metric_2``는 차원의 집계를 사용합니다.

    • ``derived_metric_3``은 차원의 집계를 다른 파생 메트릭에 추가합니다.

    CREATE OR REPLACE SEMANTIC VIEW sv_derived_metrics
  TABLES (t1)
  DIMENSIONS (t1.dim1 AS t1.col1)
  METRICS (
    t1.m1 AS SUM(t1.col1),
    t2.m2 AS SUM(t1.col2),
    derived_metric_1 AS t1.m1 + t2.m2,
    derived_metric_2 AS SUM(t1.dim1),
    derived_metric_3 AS SUM(t1.dim1) + derived_metric_2
  )
  ...

  • 이름이 모호하지 않은 경우 식에서 메트릭, 차원 또는 팩트의 이름을 한정할 필요가 없습니다. 예:

    METRICS (
  table_1.metric_1 AS ...,
  table_1.my_unique_metric_name AS ...,
  table_2.metric_1 AS ...,
  my_derived_metric_1 AS table_1.metric_1 + my_unique_metric_name
)

    ``metric_1``에는 ``metric_1``이라는 이름의 두 메트릭이 있기 때문에 ``table_1``로 한정되어야 하지만, 이름이 고유하므로 ``my_unique_metric_name``은 한정될 필요가 없습니다.

  • 파생 메트릭에 대한 표현식에는 다음을 사용할 수 없습니다.

    • 메트릭 집계.

    • 윈도우 함수.

    • 물리적 열에 대한 참조.

    • 집계되지 않은 팩트 또는 차원에 대한 참조.

  • 일반 메트릭, 차원 또는 정보에 대한 표현식에는 파생 메트릭을 사용할 수 없습니다. 다른 파생 메트릭만 해당 표현식에서 파생 메트릭을 사용할 수 있습니다.

여러 관계 경로가 있는 경우 메트릭에 대한 관계 지정하기

의미 체계 뷰에서 두 개의 특정 논리적 테이블 간에 여러 관계 경로가 존재하는 경우가 있습니다. 이러한 경우 메트릭을 정의할 때 사용할 관계 경로를 지정해야 합니다.

여러 관계 경로의 문제

항공편과 공항에 대한 정보가 포함된 두 개의 테이블이 있다고 가정해 보겠습니다.

CREATE OR REPLACE TABLE airports (
  airport_code VARCHAR PRIMARY KEY,
  city_name VARCHAR,
  airport_region_code VARCHAR
);

INSERT INTO airports VALUES
  ('SEA', 'Seattle', 'NA'),
  ('SFO', 'San Fransico', 'NA'),
  ('PVG', 'Shanghai', 'AS');

SELECT * FROM airports;

+--------------+--------------+---------------------+
| AIRPORT_CODE | CITY_NAME    | AIRPORT_REGION_CODE |
|--------------+--------------+---------------------|
| SEA          | Seattle      | NA                  |
| SFO          | San Fransico | NA                  |
| PVG          | Shanghai     | AS                  |
+--------------+--------------+---------------------+

CREATE OR REPLACE TABLE flights (
  flight_id INTEGER PRIMARY KEY,
  departure_airport VARCHAR,
  arrival_airport VARCHAR,
  is_late BOOLEAN,
  aircraft_id INTEGER,
  departure_time DATETIME,
  arrival_time DATETIME
);

INSERT INTO flights VALUES
  (1, 'SFO', 'SEA', true, 1, '2025-01-03 06:00:00', '2025-01-03 11:00:00'),
  (2, 'SEA', 'SFO', false, 2, '2025-01-03 11:00:00', '2025-01-03 16:00:00'),
  (3, 'SEA', 'PVG', false, 3, '2025-01-03 11:00:00', '2025-01-04 11:00:00'),
  (4, 'SFO', 'PVG', true, 1, '2025-01-03 06:00:00', '2025-01-04 11:00:00');

SELECT * FROM flights;

+-----------+-------------------+-----------------+---------+-------------+-------------------------+-------------------------+
| FLIGHT_ID | DEPARTURE_AIRPORT | ARRIVAL_AIRPORT | IS_LATE | AIRCRAFT_ID | DEPARTURE_TIME          | ARRIVAL_TIME            |
|-----------+-------------------+-----------------+---------+-------------+-------------------------+-------------------------|
|         1 | SFO               | SEA             | True    |           1 | 2025-01-03 06:00:00.000 | 2025-01-03 11:00:00.000 |
|         2 | SEA               | SFO             | False   |           2 | 2025-01-03 11:00:00.000 | 2025-01-03 16:00:00.000 |
|         3 | SEA               | PVG             | False   |           3 | 2025-01-03 11:00:00.000 | 2025-01-04 11:00:00.000 |
|         4 | SFO               | PVG             | True    |           1 | 2025-01-03 06:00:00.000 | 2025-01-04 11:00:00.000 |
+-----------+-------------------+-----------------+---------+-------------+-------------------------+-------------------------+

특정 도시에서 출발하고 특정 도시에 도착하는 총 항공편 수에 대한 정보를 제공하는 의미 체계 뷰를 정의한다고 가정해 보겠습니다.

CREATE OR REPLACE SEMANTIC VIEW flights_sv
  TABLES (
    flights PRIMARY KEY (flight_id),
    airports PRIMARY KEY (airport_code)
  ) RELATIONSHIPS (
    flight_departure_airport AS flights(departure_airport) REFERENCES airports(airport_code),
    flight_arrival_airport AS flights(arrival_airport) REFERENCES airports(airport_code)
  ) DIMENSIONS (
    airports.city_name AS city_name
  ) METRICS (
    flights.m_flight_count AS COUNT(flight_id)
  );

의미 체계 뷰는 flights 테이블과 airports 테이블(flight_departure_airport 및 flight_arrival_airport) 간에 두 가지 다른 관계를 지정합니다. 테이블 간에는 여러 관계 경로가 있으므로 m_flight_count 메트릭에 대해 쿼리하고 airports.city_name 차원(또는 airports 테이블의 모든 차원)을 선택하면 오류가 발생합니다.

SELECT * FROM SEMANTIC_VIEW (
  flights_sv
  METRICS flights.m_flight_count
  DIMENSIONS airports.city_name
);

010246 (42601): SQL compilation error:
Invalid dimension specified: Multi-path relationship between the dimension entity 'AIRPORTS'
  and the base metric or dimension entity 'FLIGHTS' is not supported.

flights``와 ``airports 테이블 간에는 여러 경로가 있으므로 쿼리가 실패합니다. 쿼리가 airports 테이블에서 차원을 선택하지 않았다면 성공했을 것입니다.

사용할 관계 지정하기

CREATE SEMANTIC VIEW 명령의 메트릭 정의에서 USING 절을 사용할 관계를 지정할 수 있습니다.

METRICS (
  <table_alias>.<metric>
    [ USING ( <relationship_name> [ , ... ] )
    AS <sql_expr>
  [ , ... ]
)

참고

  • 지정하는 각 관계는 메트릭이 포함된 논리 테이블에서 시작해야 합니다. 예를 들어, 다음을 지정한다고 가정해 보겠습니다.

    METRICS (
  table_a.metric_a
    USING ( table_a_to_table_b )
    ...

    table_a_to_table_b 관계는 ``table_a``에서 시작해야 합니다.

    RELATIONSHIPS (
  table_a_to_table_b AS table_a(col_1) REFERENCES table_b(col_1)
  ...

  • 관계의 시퀀스는 지정할 수 없습니다(예: table_a_to_table_b 및 table_b_to_table_c). 각 관계는 메트릭이 포함된 논리 테이블에서 시작해야 합니다.

  • 메트릭이 포함된 논리 테이블과 다른 테이블 간의 관계를 식별해야 하는 경우 USING 절에서 관계를 지정하면 됩니다. 예를 들어, ``table_a``에서 ``table_b``로의 특정 관계 및 ``table_a``에서 ``table_c``로의 특정 관계로 메트릭을 계산한다고 가정해 보겠습니다. 이 경우 USING 절에서 두 관계를 모두 지정합니다.

    METRICS (
  table_a.metric_a
    USING ( table_a_to_table_b, table_a_to_table_c )
    ...

  • :ref:`파생 메트릭 <label-semantic_views_create_derived_metrics>`에서는 USING 절을 지정할 수 없습니다.

예를 들어, 다음 문은 특정 관계를 사용하는 두 개의 추가 메트릭을 정의합니다.

  • flight_departure_airport 관계를 사용하는 m_flight_departure_count.

  • flight_arrival_airport 관계를 사용하는 m_flight_arrival_count.

CREATE OR REPLACE SEMANTIC VIEW flights_sv
  TABLES (
    flights PRIMARY KEY (flight_id),
    airports PRIMARY KEY (airport_code)
  ) RELATIONSHIPS (
    flight_departure_airport AS flights(departure_airport) REFERENCES airports(airport_code),
    flight_arrival_airport AS flights(arrival_airport) REFERENCES airports(airport_code)
  ) DIMENSIONS (
    airports.city_name AS city_name
  ) METRICS (
    flights.m_flight_count AS COUNT(flight_id),
    flights.m_flight_departure_count USING (flight_departure_airport) AS flights.m_flight_count,
    flights.m_flight_arrival_count USING (flight_arrival_airport) AS flights.m_flight_count
  );

이 뷰를 쿼리할 때 특정 관계를 사용하는 두 가지 새로운 메트릭을 지정할 수 있습니다.

SELECT * FROM SEMANTIC_VIEW (
  flights_sv
  METRICS flights.m_flight_arrival_count, flights.m_flight_departure_count
  DIMENSIONS airports.city_name
);

+------------------------+--------------------------+--------------+
| M_FLIGHT_ARRIVAL_COUNT | M_FLIGHT_DEPARTURE_COUNT | CITY_NAME    |
|------------------------+--------------------------+--------------|
|                      1 |                        2 | San Fransico |
|                      1 |                        2 | Seattle      |
|                      2 |                     NULL | Shanghai     |
+------------------------+--------------------------+--------------+

동일한 관계를 사용하는 차원 추가

이전 예제의 쿼리에서는 관계의 기반이 되는 airports 논리 테이블에 있는 airports.city_name 차원을 사용했습니다.

다른 논리 테이블의 차원을 뷰에 추가하면 해당 차원의 쿼리가 이전에 지정한 관계의 이점을 활용할 수 있습니다.

예를 들어, airports 테이블의 airport_region_code 열에 지정된 공항 리전에 대한 추가 정보가 포함된 ``regions``라는 테이블을 생성한다고 가정해 보겠습니다.

CREATE OR REPLACE TABLE regions (
  region_code VARCHAR PRIMARY KEY,
  region_name VARCHAR
);

INSERT INTO regions VALUES
  ('NA', 'North America'),
  ('AS', 'Asia');

SELECT * FROM regions;

+-------------+---------------+
| REGION_CODE | REGION_NAME   |
|-------------+---------------|
| NA          | North America |
| AS          | Asia          |
+-------------+---------------+

이전에 정의한 의미 체계 뷰를 확장하여 리전 이름을 반환할 수 있습니다.

  • regions 테이블에 대한 새 논리 테이블을 추가합니다.

  • regions 테이블과 airports 테이블 간의 관계를 추가합니다.

  • 리전 이름에 대한 차원을 추가합니다.

regions``와 ``airports 간에는 단일 관계가 있으므로 메트릭에 대한 USING 절을 추가로 변경할 필요가 없습니다.

CREATE OR REPLACE SEMANTIC VIEW flights_by_regions_sv
  TABLES (
    flights PRIMARY KEY (flight_id),
    airports PRIMARY KEY (airport_code),
    regions PRIMARY KEY (region_code)
  ) RELATIONSHIPS (
    flight_departure_airport AS flights(departure_airport) REFERENCES airports(airport_code),
    flight_arrival_airport AS flights(arrival_airport) REFERENCES airports(airport_code),
    airport_region AS airports(airport_region_code) REFERENCES regions(region_code)
  ) DIMENSIONS (
    airports.city_name AS city_name,
    regions.region_name AS region_name
  ) METRICS (
    flights.m_flight_count AS COUNT(flight_id),
    flights.m_flight_departure_count USING (flight_departure_airport) AS flights.m_flight_count,
    flights.m_flight_arrival_count USING (flight_arrival_airport) AS flights.m_flight_count
  );

뷰를 쿼리하는 경우 region_name 차원을 지정했는데 어떤 관계를 사용할지 모호한 경우 USING 절에 따라 사용할 관계가 결정됩니다.

SELECT * FROM SEMANTIC_VIEW (
  flights_by_regions_sv
  METRICS flights.m_flight_arrival_count, flights.m_flight_departure_count
  DIMENSIONS regions.region_name
);

+------------------------+--------------------------+---------------+
| M_FLIGHT_ARRIVAL_COUNT | M_FLIGHT_DEPARTURE_COUNT | REGION_NAME   |
|------------------------+--------------------------+---------------|
|                      2 |                        4 | North America |
|                      2 |                     NULL | Asia          |
+------------------------+--------------------------+---------------+

다른 테이블에 대한 관계 지정

의미 체계 뷰가 여러 테이블의 차원을 사용하고 이러한 차원에 사용할 관계를 지정해야 하는 경우, USING 절에서 여러 관계를 지정할 수 있습니다.

예를 들어, airports 테이블의 공항에 대한 날씨 정보가 포함된 ``weather``라는 테이블을 생성한다고 가정해 보겠습니다.

CREATE OR REPLACE TABLE weather (
  airport_code VARCHAR PRIMARY KEY,
  weather_condition VARCHAR,
  start_date DATETIME,
  end_date DATETIME
);

INSERT INTO weather VALUES
  ('SEA', 'rainy', '2025-01-01 10:00:00', '2025-01-01 12:00:00'),
  ('SEA', 'rainy', '2025-01-03 10:00:00', '2025-01-03 12:00:00'),
  ('SFO', 'sunny', '2025-01-03 05:00:00', '2025-01-03 09:00:00'),
  ('SFO', 'sunny', '2025-01-03 10:00:00', '2025-01-03 18:00:00'),
  ('PVG', 'cloudy', '2025-01-04 10:00:00', '2025-01-04 12:00:00');

SELECT * FROM weather;

+--------------+-------------------+-------------------------+-------------------------+
| AIRPORT_CODE | WEATHER_CONDITION | START_DATE              | END_DATE                |
|--------------+-------------------+-------------------------+-------------------------|
| SEA          | rainy             | 2025-01-01 10:00:00.000 | 2025-01-01 12:00:00.000 |
| SEA          | rainy             | 2025-01-03 10:00:00.000 | 2025-01-03 12:00:00.000 |
| SFO          | sunny             | 2025-01-03 05:00:00.000 | 2025-01-03 09:00:00.000 |
| SFO          | sunny             | 2025-01-03 10:00:00.000 | 2025-01-03 18:00:00.000 |
| PVG          | cloudy            | 2025-01-04 10:00:00.000 | 2025-01-04 12:00:00.000 |
+--------------+-------------------+-------------------------+-------------------------+

앞서 정의한 의미 체계 뷰를 확장하여 날씨 조건을 반환할 수 있습니다.

  • weather 테이블에 대한 새 논리 테이블을 추가합니다.

  • weather 테이블과 flights 테이블(출발 항공편용 테이블 1개, 도착 항공편용 테이블 1개) 간의 두 가지 관계를 추가합니다.

  • 날씨 정보에 대한 차원을 추가합니다.

  • 메트릭이 weather 테이블과 flights 테이블 간의 두 가지 새로운 관계도 사용해야 함을 지정합니다.

CREATE OR REPLACE SEMANTIC VIEW flights_and_weather_sv
  TABLES (
    flights PRIMARY KEY (flight_id),
    airports PRIMARY KEY (airport_code),
    weather PRIMARY KEY (airport_code, start_date, end_date)
  ) RELATIONSHIPS (
    flight_departure_airport AS flights(departure_airport) REFERENCES airports(airport_code),
    flight_arrival_airport AS flights(arrival_airport) REFERENCES airports(airport_code),
    flight_departure_weather AS flights(departure_airport, departure_time) REFERENCES weather(airport_code, BETWEEN start_date AND end_date EXCLUSIVE),
    flight_arrival_weather AS flights(arrival_airport, arrival_time) REFERENCES weather(airport_code, BETWEEN start_date AND end_date EXCLUSIVE)
  ) DIMENSIONS (
    airports.city_name AS city_name,
    weather.weather_condition AS weather_condition
  ) METRICS (
    flights.m_flight_count AS COUNT(flight_id),
    flights.m_flight_departure_count USING (flight_departure_airport, flight_departure_weather) AS flights.m_flight_count,
    flights.m_flight_arrival_count USING (flight_arrival_airport, flight_arrival_weather) AS flights.m_flight_count
  );

뷰를 쿼리하고 weather_condition 차원을 지정할 때, USING 절에 따라 사용되는 관계가 결정됩니다.

SELECT * FROM SEMANTIC_VIEW (
  flights_by_regions_sv
  METRICS flights.m_flight_arrival_count, flights.m_flight_departure_count
  DIMENSIONS weather.weather_condition
);

+------------------------+--------------------------+-------------------+
| M_FLIGHT_ARRIVAL_COUNT | M_FLIGHT_DEPARTURE_COUNT | WEATHER_CONDITION |
|------------------------+--------------------------+-------------------|
|                      2 |                     NULL | cloudy            |
|                      1 |                        2 | sunny             |
|                      1 |                        2 | rainy             |
+------------------------+--------------------------+-------------------+

특정 관계를 사용하는 메트릭을 기반으로 파생 메트릭 정의

:ref:`파생 메트릭 <label-semantic_views_create_derived_metrics>`에서는 USING 절을 지정할 수는 없지만, USING 절을 지정하는 메트릭을 사용하는 파생 메트릭을 정의할 수는 있습니다.

예를 들어, 다음 의미 체계 뷰는 두 개의 파생 메트릭을 정의합니다.

  • global_m_departure_arrival_ratio

  • global_m_departure_arrival_sum

이러한 파생 메트릭의 정의는 flights.m_flight_departure_count 및 flights.m_flight_arrival_count 메트릭을 사용하며, 두 메트릭 모두 USING 절을 지정합니다.

CREATE OR REPLACE SEMANTIC VIEW flights_derived_metrics_sv
  TABLES (
    flights PRIMARY KEY (flight_id),
    airports PRIMARY KEY (airport_code)
  ) RELATIONSHIPS (
    flight_departure_airport AS flights(departure_airport) REFERENCES airports(airport_code),
    flight_arrival_airport AS flights(arrival_airport) REFERENCES airports(airport_code)
  ) DIMENSIONS (
    airports.city_name AS city_name
  ) METRICS (
    flights.m_flight_count AS COUNT(flight_id),
    flights.m_flight_departure_count USING (flight_departure_airport) AS flights.m_flight_count,
    flights.m_flight_arrival_count USING (flight_arrival_airport) AS flights.m_flight_count,
    global_m_departure_arrival_ratio AS DIV0(flights.m_flight_departure_count, flights.m_flight_arrival_count),
    global_m_departure_arrival_sum AS flights.m_flight_departure_count + flights.m_flight_arrival_count
  );

SELECT * FROM SEMANTIC_VIEW (
  flights_derived_metrics_sv
  METRICS global_m_departure_arrival_ratio,
    flights.m_flight_arrival_count, flights.m_flight_departure_count
  DIMENSIONS airports.city_name
);

+------------------------+--------------------------+----------------------------------+--------------+
| M_FLIGHT_ARRIVAL_COUNT | M_FLIGHT_DEPARTURE_COUNT | GLOBAL_M_DEPARTURE_ARRIVAL_RATIO | CITY_NAME    |
|------------------------+--------------------------+----------------------------------+--------------|
|                      1 |                        2 |                         2.000000 | Seattle      |
|                      1 |                        2 |                         2.000000 | San Fransico |
|                      2 |                     NULL |                             NULL | Shanghai     |
+------------------------+--------------------------+----------------------------------+--------------+

메트릭에 대해 비가산되어야 하는 차원 식별하기

메트릭이 특정 차원에 걸쳐 집계되어서는 안되는 경우가 있습니다. 이러한 경우 차원을 *비가산*으로 표시할 수 있습니다.

일부 차원에서 메트릭 집계 관련 문제 이해하기

특정 날짜에 각 고객의 당좌 예금 계좌와 저축 계좌의 계좌 잔액이 포함된 테이블이 있다고 가정해 보겠습니다.

CREATE OR REPLACE TABLE bank_accounts (
  customer_id VARCHAR,
  account_type VARCHAR,
  year NUMBER,
  month NUMBER,
  day NUMBER,
  balance NUMBER
);

INSERT INTO bank_accounts VALUES
  ('cust-001', 'checking', 2024, 01, 01, 100),
  ('cust-001', 'savings', 2024, 01, 01, 110),
  ('cust-001', 'checking', 2024, 02, 10, 140),
  ('cust-001', 'savings', 2024, 02, 10, 150),
  ('cust-001', 'checking', 2024, 03, 15, 200),
  ('cust-001', 'savings', 2024, 03, 30, 210),
  ('cust-001', 'checking', 2025, 02, 15, 280),
  ('cust-001', 'savings', 2025, 02, 15, 290),
  ('cust-001', 'checking', 2025, 03, 20, 300),
  ('cust-001', 'savings', 2025, 03, 20, 310),
  ('cust-002', 'checking', 2025, 03, 30, 200),
  ('cust-002', 'savings', 2025, 03, 30, 310);

SELECT * FROM bank_accounts;

+-------------+--------------+------+-------+-----+---------+
| CUSTOMER_ID | ACCOUNT_TYPE | YEAR | MONTH | DAY | BALANCE |
|-------------+--------------+------+-------+-----+---------|
| cust-001    | checking     | 2024 |     1 |   1 |     100 |
| cust-001    | savings      | 2024 |     1 |   1 |     110 |
| cust-001    | checking     | 2024 |     2 |  10 |     140 |
| cust-001    | savings      | 2024 |     2 |  10 |     150 |
| cust-001    | checking     | 2024 |     3 |  15 |     200 |
| cust-001    | savings      | 2024 |     3 |  30 |     210 |
| cust-001    | checking     | 2025 |     2 |  15 |     280 |
| cust-001    | savings      | 2025 |     2 |  15 |     290 |
| cust-001    | checking     | 2025 |     3 |  20 |     300 |
| cust-001    | savings      | 2025 |     3 |  20 |     310 |
| cust-002    | checking     | 2025 |     3 |  30 |     200 |
| cust-002    | savings      | 2025 |     3 |  30 |     310 |
+-------------+--------------+------+-------+-----+---------+

다음을 포함하는 의미 체계 뷰를 정의한다고 가정해 보겠습니다.

  • 다음 차원:

    • 고객 ID

    • 계좌 유형

    • Year

    • Month

    • 일

  • 잔액 합계에 대한 메트릭.

다음 문은 위에 나열된 차원과 메트릭을 포함하는 의미 체계 뷰를 생성합니다.

CREATE OR REPLACE SEMANTIC VIEW bank_accounts_sv
  TABLES (
    bank_accounts
  )
  DIMENSIONS (
    bank_accounts.customer_id_dim AS bank_accounts.customer_id,
    bank_accounts.account_type_dim AS bank_accounts.account_type,
    bank_accounts.year_dim AS bank_accounts.year,
    bank_accounts.month_dim AS bank_accounts.month,
    bank_accounts.day_dim AS bank_accounts.day
  )
  METRICS (
    bank_accounts.m_account_balance AS SUM(balance)
  );

매년 말에 각 고객의 당좌 예금 계좌와 저축 계좌의 총 잔액을 검색하려면 m_account_balance 메트릭에 대한 의미 체계 뷰를 쿼리하고 customer_id_dim 및 year_dim 차원을 지정하면 됩니다.

그러나 m_account_balance 메트릭은 날짜 차원을 기준으로 집계되므로 각 고객에 대한 각 날짜의 잔액 합계가 됩니다.

SELECT * FROM SEMANTIC_VIEW(
    bank_accounts_sv
    METRICS bank_accounts.m_account_balance
    DIMENSIONS customer_id_dim, year_dim
  )
  ORDER BY customer_id_dim, year_dim;

+-------------------+-----------------+----------+
| M_ACCOUNT_BALANCE | CUSTOMER_ID_DIM | YEAR_DIM |
|-------------------+-----------------+----------|
|               910 | cust-001        |     2024 |
|              1180 | cust-001        |     2025 |
|               510 | cust-002        |     2025 |
+-------------------+-----------------+----------+

위의 예제에서 2024년 cust-001``의 경우, ``910``은 각 날짜의 잔액 합계(``100 + 110 + 140 + 150 + 200 + 210)입니다.

특정 차원에서 메트릭 집계 방지하기

메트릭이 날짜 차원을 기준으로 집계되지 않도록 하려면 의미 체계 뷰를 생성할 때 NON ADDITIVE BY 절에서 날짜 차원을 지정합니다.

CREATE OR REPLACE SEMANTIC VIEW bank_accounts_sv
  TABLES (
    bank_accounts
  )
  DIMENSIONS (
    bank_accounts.customer_id_dim AS bank_accounts.customer_id,
    bank_accounts.account_type_dim AS bank_accounts.account_type,
    bank_accounts.year_dim AS bank_accounts.year,
    bank_accounts.month_dim AS bank_accounts.month,
    bank_accounts.day_dim AS bank_accounts.day
  )
  METRICS (
    bank_accounts.m_account_balance
      NON ADDITIVE BY (year_dim, month_dim, day_dim)
      AS SUM(balance)
  );

참고

  • 메트릭에 NON ADDITIVE BY 절을 지정하는 경우, 파생되지 않은 메트릭의 정의에서 해당 메트릭을 참조할 수 없습니다. 파생된 메트릭만 비가산 차원을 지정하는 메트릭을 참조할 수 있습니다.

NON ADDITIVE BY 절을 지정하면 메트릭이 반가산 메트릭이 됩니다.

이 의미 체계 뷰를 쿼리하는 경우 m_account_balance 메트릭은 더 이상 날짜 차원을 기준으로 집계되지 않습니다. 이 쿼리는 쿼리된 각 차원 그룹의 기간 말에 계좌 잔액을 집계합니다.

SELECT * FROM SEMANTIC_VIEW(
    bank_accounts_sv
    METRICS bank_accounts.m_account_balance
    DIMENSIONS customer_id_dim, year_dim
  )
  ORDER BY customer_id_dim, year_dim;

+-------------------+-----------------+----------+
| M_ACCOUNT_BALANCE | CUSTOMER_ID_DIM | YEAR_DIM |
|-------------------+-----------------+----------|
|               210 | cust-001        |     2024 |
|               610 | cust-001        |     2025 |
|               510 | cust-002        |     2025 |
+-------------------+-----------------+----------+

위의 예제에서 2024년 ``cust-001``의 경우, ``210``은 데이터가 포함된 연도의 마지막 날 당좌 예금 계좌와 저축 계좌 잔액의 합계입니다.

  • 데이터가 포함된 2024년의 마지막 날은 ``2024-03-30``입니다.

  • 당좌 예금 계좌에는 해당 날짜가 있는 행이 없으므로, 결과 메트릭은 예금 계좌의 잔액(210)입니다.

또 다른 예제로, 연도의 마지막 날 모든 고객의 총 계좌 잔액만 확인하려면 year_dim 차원을 지정하면 됩니다.

날짜 차원은 비가산으로 표시되므로 이 쿼리는 각 고객의 당좌 예금 계좌와 저축 계좌 잔액에 대해 기간 말(날짜 기준)의 값을 합산합니다.

SELECT * FROM SEMANTIC_VIEW(
    bank_accounts_sv
    METRICS bank_accounts.m_account_balance
    DIMENSIONS year_dim
  )
  ORDER BY year_dim;

+-------------------+----------+
| M_ACCOUNT_BALANCE | YEAR_DIM |
|-------------------+----------|
|               210 |     2024 |
|               510 |     2025 |
+-------------------+----------+

쿼리 처리 중에 행이 비가산 차원을 기준으로 정렬되고 마지막 행의 값(값의 최신 스냅샷)이 집계되어 메트릭을 계산합니다.

참고

행은 비가산 차원을 기준으로 정렬되므로 차원을 지정하는 순서가 중요합니다. 이는 ORDER BY 절에서 열을 지정하는 순서와 유사합니다.

비가산 차원의 정렬 순서 지정하기

예제에서 볼 수 있듯이, 이 메트릭은 기간이 끝날 때 각 고객의 당좌 예금 계좌와 저축 계좌 잔액의 값을 집계합니다. 정렬 순서를 변경하려면 차원 이름 옆에 있는 ASC 또는 DESC 키워드를 지정하면 됩니다. 예:

METRICS (
  bank_accounts.m_account_balance
    NON ADDITIVE BY (year_dim DESC, month_dim DESC, day_dim DESC)
    AS SUM(balance)
);

이 예제에서 메트릭은 year_dim, month_dim, ``day_dim``에 의해 지정된 가장 빠른 날짜로 평가됩니다.

차원에 NULL 값이 포함된 경우 NULLS FIRST 또는 NULLS LAST 키워드를 사용하여 NULL 값을 결과에서 첫 번째에 정렬할지 또는 마지막에 정렬할지 여부를 지정할 수 있습니다.

METRICS (
  bank_accounts.m_account_balance
    NON ADDITIVE BY (
      year_dim DESC NULLS FIRST,
      month_dim DESC NULLS FIRST,
      day_dim DESC NULLS FIRST
    )
    AS SUM(balance)

팩트 또는 메트릭을 비공개로 표시

의미 체계 뷰의 계산에만 사용할 팩트 또는 메트릭을 정의하고 쿼리에서 팩트 또는 메트릭이 반환되지 않도록 하려면 PRIVATE 키워드를 지정하여 팩트 또는 메트릭을 비공개로 표시하면 됩니다. 예:

FACTS (
  PRIVATE my_private_fact AS ...
)

METRICS (
  PRIVATE my_private_metric AS ...
)

참고

차원은 비공개로 표시할 수 없습니다. 차원은 항상 공개입니다.

비공개 팩트 또는 메트릭이 있는 의미 체계 뷰를 쿼리할 때는 다음 절에 비공개 팩트 또는 메트릭을 지정할 수 없습니다.

일부 명령과 함수에는 다음과 같이 비공개 팩트와 메트릭이 포함됩니다.

일부 명령과 함수에는 특정 조건에서만 비공개 팩트와 메트릭이 포함됩니다.

다른 명령과 함수에는 비공개 팩트와 메트릭이 포함되지 않습니다.

|cortex-analyst|용 사용자 지정 지침 제공하기

의미 체계 뷰에서 다음 방법을 설명하는 :doc:`Cortex Analyst용 지침</user-guide/snowflake-cortex/cortex-analyst/custom-instructions>`을 제공할 수 있습니다.

  • SQL 문 생성

  • 질문 분류 및 추가 정보를 묻는 메시지 표시

이러한 사용자 지정 지침을 제공하려면 다음 절을 사용합니다.

  • SQL 문을 생성하는 방법에 대한 지침을 보려면 CREATE SEMANTIC VIEW 명령의 AI_SQL_GENERATION 절을 사용하세요.

    예를 들어, |cortex-analyst|에 모든 숫자 열이 소수점 이하 두 자리로 반올림되도록 SQL 문을 생성하라고 지시하려면 다음을 지정합니다.

    CREATE SEMANTIC VIEW my_semantic_view
  ...
  -- Definitions of logical tables, relationships, dimensions, facts, and metrics
  ...
  AI_SQL_GENERATION 'Ensure that all numeric columns are rounded to 2 decimal points.'
  ...
  -- Additional clauses

  • 질문을 분류하는 방법에 대한 지침을 보려면 AI_QUESTION_CATEGORIZATION 절을 사용하세요.

    예를 들어, |cortex-analyst|에 사용자에 대한 질문을 거부하라고 지시하려면 다음을 지정합니다.

    CREATE SEMANTIC VIEW my_semantic_view
  ...
  -- Definitions of logical tables, relationships, dimensions, facts, and metrics
  ...
  AI_QUESTION_CATEGORIZATION 'Reject all questions asking about users. Ask users to contact their admin.'
  ...
  -- Additional clauses

    질문이 명확하지 않은 경우 자세한 내용을 묻는 지침을 제공할 수도 있습니다. 예:

    AI_QUESTION_CATEGORIZATION 'If the question asks for users without providing a product_type, consider this question UNCLEAR and ask the user to specify product_type.'

YAML 사양에서 의미 체계 뷰 만들기

YAML 사양 <semantic-view-yaml-spec>`에서 의미 체계 뷰를 생성하려면 :doc:/sql-reference/stored-procedures/system_create_semantic_view_from_yaml` 저장 프로시저를 호출하면 됩니다.

먼저, TRUE를 세 번째 인자로 전달하여 YAML 사양에서 의미 체계 뷰를 만들 수 있는지 확인합니다.

다음 예제에서는 YAML에서 지정된 의미 체계 모델 사양을 사용하여 데이터베이스 my_db 및 스키마 my_schema 에 tpch_analysis 이름의 의미 체계를 만들 수 있는지 확인합니다.

CALL SYSTEM$CREATE_SEMANTIC_VIEW_FROM_YAML(
  'my_db.my_schema',
  $$
  name: TPCH_REV_ANALYSIS
  description: Semantic view for revenue analysis
  tables:
    - name: CUSTOMERS
      description: Main table for customer data
      base_table:
        database: SNOWFLAKE_SAMPLE_DATA
        schema: TPCH_SF1
        table: CUSTOMER
      primary_key:
        columns:
          - C_CUSTKEY
      dimensions:
        - name: CUSTOMER_NAME
          synonyms:
            - customer name
          description: Name of the customer
          expr: customers.c_name
          data_type: VARCHAR(25)
        - name: C_CUSTKEY
          expr: C_CUSTKEY
          data_type: VARCHAR(134217728)
      metrics:
        - name: CUSTOMER_COUNT
          description: Count of number of customers
          expr: COUNT(c_custkey)
    - name: LINE_ITEMS
      description: Line items in orders
      base_table:
        database: SNOWFLAKE_SAMPLE_DATA
        schema: TPCH_SF1
        table: LINEITEM
      primary_key:
        columns:
          - L_ORDERKEY
          - L_LINENUMBER
      dimensions:
        - name: L_ORDERKEY
          expr: L_ORDERKEY
          data_type: VARCHAR(134217728)
        - name: L_LINENUMBER
          expr: L_LINENUMBER
          data_type: VARCHAR(134217728)
      facts:
        - name: DISCOUNTED_PRICE
          description: Extended price after discount
          expr: l_extendedprice * (1 - l_discount)
          data_type: "NUMBER(25,4)"
        - name: LINE_ITEM_ID
          expr: "CONCAT(l_orderkey, '-', l_linenumber)"
          data_type: VARCHAR(134217728)
    - name: ORDERS
      synonyms:
        - sales orders
      description: All orders table for the sales domain
      base_table:
        database: SNOWFLAKE_SAMPLE_DATA
        schema: TPCH_SF1
        table: ORDERS
      primary_key:
        columns:
          - O_ORDERKEY
      dimensions:
        - name: ORDER_DATE
          description: Date when the order was placed
          expr: o_orderdate
          data_type: DATE
        - name: ORDER_YEAR
          description: Year when the order was placed
          expr: YEAR(o_orderdate)
          data_type: "NUMBER(4,0)"
        - name: O_ORDERKEY
          expr: O_ORDERKEY
          data_type: VARCHAR(134217728)
        - name: O_CUSTKEY
          expr: O_CUSTKEY
          data_type: VARCHAR(134217728)
      facts:
        - name: COUNT_LINE_ITEMS
          expr: COUNT(line_items.line_item_id)
          data_type: "NUMBER(18,0)"
      metrics:
        - name: AVERAGE_LINE_ITEMS_PER_ORDER
          description: Average number of line items per order
          expr: AVG(orders.count_line_items)
        - name: ORDER_AVERAGE_VALUE
          description: Average order value across all orders
          expr: AVG(orders.o_totalprice)
  relationships:
    - name: LINE_ITEM_TO_ORDERS
      left_table: LINE_ITEMS
      right_table: ORDERS
      relationship_columns:
        - left_column: L_ORDERKEY
          right_column: O_ORDERKEY
      relationship_type: many_to_one
    - name: ORDERS_TO_CUSTOMERS
      left_table: ORDERS
      right_table: CUSTOMERS
      relationship_columns:
        - left_column: O_CUSTKEY
          right_column: C_CUSTKEY
      relationship_type: many_to_one
  $$,
TRUE);

이 사양이 유효한 경우 해당 저장 프로시저는 다음 메시지를 반환합니다.

+----------------------------------------------------------------------------------+
| SYSTEM$CREATE_SEMANTIC_VIEW_FROM_YAML                                            |
|----------------------------------------------------------------------------------|
| YAML file is valid for creating a semantic view. No object has been created yet. |
+----------------------------------------------------------------------------------+

YAML 구문이 유효하지 않은 경우 해당 저장 프로시저는 예외를 발생시킵니다. 예를 들어, 콜론이 누락된 경우 다음 결과가 나타납니다.

relationships
  - name: LINE_ITEM_TO_ORDERS

저장 프로시저는 예외를 발생시켜 YAML 구문이 유효하지 않음을 나타냅니다.

392400 (22023): Uncaught exception of type 'EXPRESSION_ERROR' on line 3 at position 23 :
  Invalid semantic model YAML: while scanning a simple key
   in 'reader', line 90, column 3:
        relationships
        ^
  could not find expected ':'
   in 'reader', line 91, column 11:
          - name: LINE_ITEM_TO_ORDERS
                ^

해당 사양이 존재하지 않는 물리적 테이블을 참조하는 경우 저장 프로시저는 예외를 발생시킵니다.

base_table:
  database: SNOWFLAKE_SAMPLE_DATA
  schema: TPCH_SF1
  table: NONEXISTENT

002003 (42S02): Uncaught exception of type 'EXPRESSION_ERROR' on line 3 at position 23 :
  SQL compilation error:
  Table 'SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.NONEXISTENT' does not exist or not authorized.

마찬가지로, 사양이 존재하지 않는 기본 키 열을 참조하는 경우 저장 프로시저는 예외를 발생시킵니다.

primary_key:
  columns:
    - NONEXISTENT

000904 (42000): Uncaught exception of type 'EXPRESSION_ERROR' on line 3 at position 23 :
  SQL compilation error: error line 0 at position -1
  invalid identifier 'NONEXISTENT'

그러면 세 번째 인자를 전달하지 않고 저장 프로시저를 호출하여 의미 체계 뷰를 만들 수 있습니다.

다음 예제에서는 데이터베이스 my_db 및 스키마 my_schema 에서 tpch_analysis 이름의 의미 체계 뷰를 만듭니다.

CALL SYSTEM$CREATE_SEMANTIC_VIEW_FROM_YAML(
  'my_db.my_schema',
  $$
  name: TPCH_REV_ANALYSIS
  description: Semantic view for revenue analysis
  tables:
    - name: CUSTOMERS
      description: Main table for customer data
      base_table:
        database: SNOWFLAKE_SAMPLE_DATA
        schema: TPCH_SF1
        table: CUSTOMER
      primary_key:
        columns:
          - C_CUSTKEY
      dimensions:
        - name: CUSTOMER_NAME
          synonyms:
            - customer name
          description: Name of the customer
          expr: customers.c_name
          data_type: VARCHAR(25)
        - name: C_CUSTKEY
          expr: C_CUSTKEY
          data_type: VARCHAR(134217728)
      metrics:
        - name: CUSTOMER_COUNT
          description: Count of number of customers
          expr: COUNT(c_custkey)
    - name: LINE_ITEMS
      description: Line items in orders
      base_table:
        database: SNOWFLAKE_SAMPLE_DATA
        schema: TPCH_SF1
        table: LINEITEM
      primary_key:
        columns:
          - L_ORDERKEY
          - L_LINENUMBER
      dimensions:
        - name: L_ORDERKEY
          expr: L_ORDERKEY
          data_type: VARCHAR(134217728)
        - name: L_LINENUMBER
          expr: L_LINENUMBER
          data_type: VARCHAR(134217728)
      facts:
        - name: DISCOUNTED_PRICE
          description: Extended price after discount
          expr: l_extendedprice * (1 - l_discount)
          data_type: "NUMBER(25,4)"
        - name: LINE_ITEM_ID
          expr: "CONCAT(l_orderkey, '-', l_linenumber)"
          data_type: VARCHAR(134217728)
    - name: ORDERS
      synonyms:
        - sales orders
      description: All orders table for the sales domain
      base_table:
        database: SNOWFLAKE_SAMPLE_DATA
        schema: TPCH_SF1
        table: ORDERS
      primary_key:
        columns:
          - O_ORDERKEY
      dimensions:
        - name: ORDER_DATE
          description: Date when the order was placed
          expr: o_orderdate
          data_type: DATE
        - name: ORDER_YEAR
          description: Year when the order was placed
          expr: YEAR(o_orderdate)
          data_type: "NUMBER(4,0)"
        - name: O_ORDERKEY
          expr: O_ORDERKEY
          data_type: VARCHAR(134217728)
        - name: O_CUSTKEY
          expr: O_CUSTKEY
          data_type: VARCHAR(134217728)
      facts:
        - name: COUNT_LINE_ITEMS
          expr: COUNT(line_items.line_item_id)
          data_type: "NUMBER(18,0)"
      metrics:
        - name: AVERAGE_LINE_ITEMS_PER_ORDER
          description: Average number of line items per order
          expr: AVG(orders.count_line_items)
        - name: ORDER_AVERAGE_VALUE
          description: Average order value across all orders
          expr: AVG(orders.o_totalprice)
  relationships:
    - name: LINE_ITEM_TO_ORDERS
      left_table: LINE_ITEMS
      right_table: ORDERS
      relationship_columns:
        - left_column: L_ORDERKEY
          right_column: O_ORDERKEY
      relationship_type: many_to_one
    - name: ORDERS_TO_CUSTOMERS
      left_table: ORDERS
      right_table: CUSTOMERS
      relationship_columns:
        - left_column: O_CUSTKEY
          right_column: C_CUSTKEY
      relationship_type: many_to_one
  $$
);

+-----------------------------------------+
| SYSTEM$CREATE_SEMANTIC_VIEW_FROM_YAML   |
|-----------------------------------------|
| Semantic view was successfully created. |
+-----------------------------------------+

기존 의미 체계 뷰의 주석 수정

기존 의미 체계 뷰의 주석을 수정하려면 ALTER SEMANTIC VIEW 명령을 실행합니다.

ALTER SEMANTIC VIEW my_semantic_view SET COMMENT = 'my comment';

참고

ALTERSEMANTICVIEW 명령을 사용하는 경우 주석 이외의 속성을 변경할 수 없습니다. 의미 체계 뷰의 다른 속성을 변경하려면 의미 체계 뷰를 바꿉니다. 기존 의미 체계 뷰 바꾸기 섹션을 참조하십시오.

COMMENT 명령을 사용하여 의미 체계 뷰의 주석을 설정할 수 있습니다.

COMMENT ON SEMANTIC VIEW my_semantic_view IS 'my comment';

기존 의미 체계 뷰 바꾸기

기존 의미 체계 뷰를 바꾸려면(예: 뷰의 정의를 변경하려면) CREATE SEMANTIC VIEW 를 실행할 때 OR REPLACE 를 지정합니다. 기존 의미 체계 뷰에 부여된 권한을 유지하려면 COPY GRANTS 를 지정합니다. 예:

CREATE OR REPLACE SEMANTIC VIEW tpch_rev_analysis

  TABLES (
    orders AS SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.ORDERS
      PRIMARY KEY (o_orderkey)
      WITH SYNONYMS ('sales orders')
      COMMENT = 'All orders table for the sales domain',
    customers AS SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.CUSTOMER
      PRIMARY KEY (c_custkey)
      COMMENT = 'Main table for customer data',
    line_items AS SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.LINEITEM
      PRIMARY KEY (l_orderkey, l_linenumber)
      COMMENT = 'Line items in orders'
  )

  RELATIONSHIPS (
    orders_to_customers AS
      orders (o_custkey) REFERENCES customers,
    line_item_to_orders AS
      line_items (l_orderkey) REFERENCES orders
  )

  FACTS (
    line_items.line_item_id AS CONCAT(l_orderkey, '-', l_linenumber),
    orders.count_line_items AS COUNT(line_items.line_item_id),
    line_items.discounted_price AS l_extendedprice * (1 - l_discount)
      COMMENT = 'Extended price after discount'
  )

  DIMENSIONS (
    customers.customer_name AS customers.c_name
      WITH SYNONYMS = ('customer name')
      COMMENT = 'Name of the customer',
    orders.order_date AS o_orderdate
      COMMENT = 'Date when the order was placed',
    orders.order_year AS YEAR(o_orderdate)
      COMMENT = 'Year when the order was placed'
  )

  METRICS (
    customers.customer_count AS COUNT(c_custkey)
      COMMENT = 'Count of number of customers',
    orders.order_average_value AS AVG(orders.o_totalprice)
      COMMENT = 'Average order value across all orders',
    orders.average_line_items_per_order AS AVG(orders.count_line_items)
      COMMENT = 'Average number of line items per order'
  )

  COMMENT = 'Semantic view for revenue analysis and different comment'
  COPY GRANTS;

의미 체계 뷰 목록 보기

현재 스키마 또는 지정된 스키마에서 의미 체계 뷰를 목록으로 표시하려면 SHOW SEMANTIC VIEWS 명령을 실행합니다. 예:

SHOW SEMANTIC VIEWS;

+-------------------------------+-----------------------+---------------+-------------------+----------------------------------------------+-----------------+-----------------+-----------+
| created_on                    | name                  | database_name | schema_name       | comment                                      | owner           | owner_role_type | extension |
|-------------------------------+-----------------------+---------------+-------------------+----------------------------------------------+-----------------+-----------------+-----------|
| 2025-03-20 15:06:34.039 -0700 | MY_NEW_SEMANTIC_MODEL | MY_DB         | MY_SCHEMA         | A semantic model created through the wizard. | MY_ROLE         | ROLE            | ["CA"]    |
| 2025-02-28 16:16:04.002 -0800 | O_TPCH_SEMANTIC_VIEW  | MY_DB         | MY_SCHEMA         | NULL                                         | MY_ROLE         | ROLE            | NULL      |
| 2025-03-21 07:03:54.120 -0700 | TPCH_REV_ANALYSIS     | MY_DB         | MY_SCHEMA         | Semantic view for revenue analysis           | MY_ROLE         | ROLE            | NULL      |
+-------------------------------+-----------------------+---------------+-------------------+----------------------------------------------+-----------------+-----------------+-----------+

SHOW OBJECTS 명령의 출력에 의미 체계 뷰가 포함됩니다. kind 열에서 오브젝트 유형은 ``VIEW``로 나열됩니다. 예:

SHOW OBJECTS LIKE '%TPCH_ANALYSIS%' IN SCHEMA;

+-------------------------------+---------------+---------------+-------------+------+---------+------------+------+-------+---------+----------------+-----------------+-----------+------------+------------+
| created_on                    | name          | database_name | schema_name | kind | comment | cluster_by | rows | bytes | owner   | retention_time | owner_role_type | is_hybrid | is_dynamic | is_iceberg |
|-------------------------------+---------------+---------------+-------------+------+---------+------------+------+-------+---------+----------------+-----------------+-----------+------------+------------|
| 2025-10-03 16:28:01.505 -0700 | TPCH_ANALYSIS | MY_DB         | MY_SCHEMA   | VIEW |         |            |    0 |     0 | MY_ROLE | 1              | ROLE            | N         | N          | N          |
+-------------------------------+---------------+---------------+-------------+------+---------+------------+------+-------+---------+----------------+-----------------+-----------+------------+------------+

ACCOUNT_USAGE 및 INFORMATION_SCHEMA 스키마 에서 의미 체계 뷰에 대한 뷰를 쿼리할 수도 있습니다.

차원, 정보 및 메트릭 나열하기

뷰, 스키마, 데이터베이스 또는 계정에서 사용할 수 있는 차원, 정보, 메트릭을 나열하기 위해 다음 명령을 실행할 수 있습니다.

기본적으로, 이 명령은 현재 스키마에 정의된 의미 체계 뷰에서 사용할 수 있는 차원, 정보, 메트릭을 나열합니다.

SHOW SEMANTIC DIMENSIONS;

+---------------+-------------+--------------------+------------+---------------+--------------+-------------------+--------------------------------+
| database_name | schema_name | semantic_view_name | table_name | name          | data_type    | synonyms          | comment                        |
|---------------+-------------+--------------------+------------+---------------+--------------+-------------------+--------------------------------|
| MY_DB         | MY_SCHEMA   | TPCH_REV_ANALYSIS  | CUSTOMERS  | CUSTOMER_NAME | VARCHAR(25)  | ["customer name"] | Name of the customer           |
| MY_DB         | MY_SCHEMA   | TPCH_REV_ANALYSIS  | CUSTOMERS  | C_CUSTKEY     | NUMBER(38,0) | NULL              | NULL                           |
...

SHOW SEMANTIC FACTS;

+---------------+-------------+--------------------+------------+------------------+--------------------+----------+-------------------------------+
| database_name | schema_name | semantic_view_name | table_name | name             | data_type          | synonyms | comment                       |
|---------------+-------------+--------------------+------------+------------------+--------------------+----------+-------------------------------|
| MY_DB         | MY_SCHEMA   | TPCH_REV_ANALYSIS  | LINE_ITEMS | DISCOUNTED_PRICE | NUMBER(25,4)       | NULL     | Extended price after discount |
| MY_DB         | MY_SCHEMA   | TPCH_REV_ANALYSIS  | LINE_ITEMS | LINE_ITEM_ID     | VARCHAR(134217728) | NULL     | NULL                          |
...

SHOW SEMANTIC METRICS;

+---------------+-------------+--------------------+------------+------------------------------+--------------+----------+----------------------------------------+
| database_name | schema_name | semantic_view_name | table_name | name                         | data_type    | synonyms | comment                                |
|---------------+-------------+--------------------+------------+------------------------------+--------------+----------+----------------------------------------|
| MY_DB         | MY_SCHEMA   | TPCH_REV_ANALYSIS  | CUSTOMERS  | CUSTOMER_COUNT               | NUMBER(18,0) | NULL     | Count of number of customers           |
| MY_DB         | MY_SCHEMA   | TPCH_REV_ANALYSIS  | ORDERS     | AVERAGE_LINE_ITEMS_PER_ORDER | NUMBER(36,6) | NULL     | Average number of line items per order |
...

다음 예에서는 다양한 범위 내에서 의미 체계 뷰에 대한 차원, 팩트 및 메트릭을 나열하는 방법을 보여줍니다.

  • 현재 데이터베이스의 의미 체계 뷰에 차원, 팩트 및 메트릭을 나열합니다.

    SHOW SEMANTIC DIMENSIONS IN DATABASE;

SHOW SEMANTIC FACTS IN DATABASE;

SHOW SEMANTIC METRICS IN DATABASE;

  • 특정 스키마 또는 데이터베이스의 의미 체계 뷰에 차원, 팩트 및 메트릭을 나열합니다.

    SHOW SEMANTIC DIMENSIONS IN SCHEMA my_db.my_other_schema;

SHOW SEMANTIC DIMENSIONS IN DATABASE my_db;

SHOW SEMANTIC FACTS IN SCHEMA my_db.my_other_schema;

SHOW SEMANTIC FACTS IN DATABASE my_db;

SHOW SEMANTIC METRICS IN SCHEMA my_db.my_other_schema;

SHOW SEMANTIC METRICS IN DATABASE my_db;

  • 계정의 의미 체계 뷰에 차원, 팩트 및 메트릭을 나열합니다.

    SHOW SEMANTIC DIMENSIONS IN ACCOUNT;

SHOW SEMANTIC FACTS IN ACCOUNT;

SHOW SEMANTIC METRICS IN ACCOUNT;

  • 특정 의미 체계 뷰에 차원, 팩트 및 메트릭을 나열합니다.

    SHOW SEMANTIC DIMENSIONS IN my_semantic_view;

SHOW SEMANTIC FACTS IN my_semantic_view;

SHOW SEMANTIC METRICS IN my_semantic_view;

의미 체계 뷰를 쿼리하려는 경우 SHOW SEMANTIC DIMENSIONS FOR METRIC 명령을 사용하여 특정 메트릭을 지정할 때 반환할 수 있는 차원을 결정할 수 있습니다. 자세한 내용은 지정된 메트릭에 대해 반환할 수 있는 차원 선택 섹션을 참조하십시오.

의미 체계 뷰에 대한 SHOW COLUMNS 명령을 실행하는 경우, 출력에는 의미 체계 뷰의 차원, 팩트 및 메트릭이 포함됩니다. kind 열은 행이 차원, 팩트 또는 메트릭을 나타내는지 여부를 나타냅니다.

예:

SHOW COLUMNS IN VIEW my_db.my_schema.tpch_analysis;

+---------------+-------------+------------------------------+-----------------------------------------------------------------------------------------+----------+---------+-----------+------------+---------+---------------+---------------+-------------------------+
| table_name    | schema_name | column_name                  | data_type                                                                               | null?    | default | kind      | expression | comment | database_name | autoincrement | schema_evolution_record |
|---------------+-------------+------------------------------+-----------------------------------------------------------------------------------------+----------+---------+-----------+------------+---------+---------------+---------------+-------------------------|
| TPCH_ANALYSIS | MY_SCHEMA   | CUSTOMER_COUNT               | {"type":"FIXED","precision":18,"scale":0,"nullable":false}                              | NOT_NULL |         | METRIC    |            |         | MY_DB         |               | NULL                    |
| TPCH_ANALYSIS | MY_SCHEMA   | CUSTOMER_COUNTRY_CODE        | {"type":"TEXT","length":15,"byteLength":60,"nullable":true,"fixed":false}               | true     |         | DIMENSION |            |         | MY_DB         |               | NULL                    |
| TPCH_ANALYSIS | MY_SCHEMA   | CUSTOMER_MARKET_SEGMENT      | {"type":"TEXT","length":10,"byteLength":40,"nullable":true,"fixed":false}               | true     |         | DIMENSION |            |         | MY_DB         |               | NULL                    |
| TPCH_ANALYSIS | MY_SCHEMA   | CUSTOMER_NAME                | {"type":"TEXT","length":25,"byteLength":100,"nullable":true,"fixed":false}              | true     |         | DIMENSION |            |         | MY_DB         |               | NULL                    |
| TPCH_ANALYSIS | MY_SCHEMA   | CUSTOMER_NATION_NAME         | {"type":"TEXT","length":25,"byteLength":100,"nullable":true,"fixed":false}              | true     |         | DIMENSION |            |         | MY_DB         |               | NULL                    |
| TPCH_ANALYSIS | MY_SCHEMA   | CUSTOMER_ORDER_COUNT         | {"type":"FIXED","precision":30,"scale":0,"nullable":true}                               | true     |         | METRIC    |            |         | MY_DB         |               | NULL                    |
| TPCH_ANALYSIS | MY_SCHEMA   | CUSTOMER_REGION_NAME         | {"type":"TEXT","length":25,"byteLength":100,"nullable":true,"fixed":false}              | true     |         | DIMENSION |            |         | MY_DB         |               | NULL                    |
| TPCH_ANALYSIS | MY_SCHEMA   | C_CUSTOMER_ORDER_COUNT       | {"type":"FIXED","precision":18,"scale":0,"nullable":false}                              | NOT_NULL |         | FACT      |            |         | MY_DB         |               | NULL                    |
| TPCH_ANALYSIS | MY_SCHEMA   | LINE_ITEM_ID                 | {"type":"TEXT","length":134217728,"byteLength":134217728,"nullable":true,"fixed":false} | true     |         | FACT      |            |         | MY_DB         |               | NULL                    |
| TPCH_ANALYSIS | MY_SCHEMA   | NATION_NAME                  | {"type":"TEXT","length":25,"byteLength":100,"nullable":true,"fixed":false}              | true     |         | DIMENSION |            |         | MY_DB         |               | NULL                    |
| TPCH_ANALYSIS | MY_SCHEMA   | N_NAME                       | {"type":"TEXT","length":25,"byteLength":100,"nullable":true,"fixed":false}              | true     |         | FACT      |            |         | MY_DB         |               | NULL                    |
| TPCH_ANALYSIS | MY_SCHEMA   | AVERAGE_LINE_ITEMS_PER_ORDER | {"type":"FIXED","precision":36,"scale":6,"nullable":true}                               | true     |         | METRIC    |            |         | MY_DB         |               | NULL                    |
| TPCH_ANALYSIS | MY_SCHEMA   | COUNT_LINE_ITEMS             | {"type":"FIXED","precision":18,"scale":0,"nullable":false}                              | NOT_NULL |         | FACT      |            |         | MY_DB         |               | NULL                    |
| TPCH_ANALYSIS | MY_SCHEMA   | ORDER_AVERAGE_VALUE          | {"type":"FIXED","precision":30,"scale":8,"nullable":true}                               | true     |         | METRIC    |            |         | MY_DB         |               | NULL                    |
| TPCH_ANALYSIS | MY_SCHEMA   | ORDER_COUNT                  | {"type":"FIXED","precision":18,"scale":0,"nullable":false}                              | NOT_NULL |         | METRIC    |            |         | MY_DB         |               | NULL                    |
| TPCH_ANALYSIS | MY_SCHEMA   | ORDER_DATE                   | {"type":"DATE","nullable":true}                                                         | true     |         | DIMENSION |            |         | MY_DB         |               | NULL                    |
| TPCH_ANALYSIS | MY_SCHEMA   | O_ORDERKEY                   | {"type":"FIXED","precision":38,"scale":0,"nullable":true}                               | true     |         | FACT      |            |         | MY_DB         |               | NULL                    |
| TPCH_ANALYSIS | MY_SCHEMA   | R_NAME                       | {"type":"TEXT","length":25,"byteLength":100,"nullable":true,"fixed":false}              | true     |         | FACT      |            |         | MY_DB         |               | NULL                    |
| TPCH_ANALYSIS | MY_SCHEMA   | SUPPLIER_COUNT               | {"type":"FIXED","precision":18,"scale":0,"nullable":false}                              | NOT_NULL |         | METRIC    |            |         | MY_DB         |               | NULL                    |
+---------------+-------------+------------------------------+-----------------------------------------------------------------------------------------+----------+---------+-----------+------------+---------+---------------+---------------+-------------------------+

의미 체계 뷰에 대한 세부 정보 보기

의미 체계 뷰의 세부 정보를 보려면 DESCRIBE SEMANTIC VIEW 명령을 실행합니다. 예:

DESCRIBE SEMANTIC VIEW tpch_rev_analysis;

+--------------+------------------------------+---------------+--------------------------+----------------------------------------+
| object_kind  | object_name                  | parent_entity | property                 | property_value                         |
|--------------+------------------------------+---------------+--------------------------+----------------------------------------|
| NULL         | NULL                         | NULL          | COMMENT                  | Semantic view for revenue analysis     |
| TABLE        | CUSTOMERS                    | NULL          | BASE_TABLE_DATABASE_NAME | SNOWFLAKE_SAMPLE_DATA                  |
| TABLE        | CUSTOMERS                    | NULL          | BASE_TABLE_SCHEMA_NAME   | TPCH_SF1                               |
| TABLE        | CUSTOMERS                    | NULL          | BASE_TABLE_NAME          | CUSTOMER                               |
| TABLE        | CUSTOMERS                    | NULL          | PRIMARY_KEY              | ["C_CUSTKEY"]                          |
| TABLE        | CUSTOMERS                    | NULL          | COMMENT                  | Main table for customer data           |
| DIMENSION    | CUSTOMER_NAME                | CUSTOMERS     | TABLE                    | CUSTOMERS                              |
| DIMENSION    | CUSTOMER_NAME                | CUSTOMERS     | EXPRESSION               | customers.c_name                       |
| DIMENSION    | CUSTOMER_NAME                | CUSTOMERS     | DATA_TYPE                | VARCHAR(25)                            |
| DIMENSION    | CUSTOMER_NAME                | CUSTOMERS     | SYNONYMS                 | ["customer name"]                      |
| DIMENSION    | CUSTOMER_NAME                | CUSTOMERS     | COMMENT                  | Name of the customer                   |
| TABLE        | LINE_ITEMS                   | NULL          | BASE_TABLE_DATABASE_NAME | SNOWFLAKE_SAMPLE_DATA                  |
| TABLE        | LINE_ITEMS                   | NULL          | BASE_TABLE_SCHEMA_NAME   | TPCH_SF1                               |
| TABLE        | LINE_ITEMS                   | NULL          | BASE_TABLE_NAME          | LINEITEM                               |
| TABLE        | LINE_ITEMS                   | NULL          | PRIMARY_KEY              | ["L_ORDERKEY","L_LINENUMBER"]          |
| TABLE        | LINE_ITEMS                   | NULL          | COMMENT                  | Line items in orders                   |
| RELATIONSHIP | LINE_ITEM_TO_ORDERS          | LINE_ITEMS    | TABLE                    | LINE_ITEMS                             |
| RELATIONSHIP | LINE_ITEM_TO_ORDERS          | LINE_ITEMS    | REF_TABLE                | ORDERS                                 |
| RELATIONSHIP | LINE_ITEM_TO_ORDERS          | LINE_ITEMS    | FOREIGN_KEY              | ["L_ORDERKEY"]                         |
| RELATIONSHIP | LINE_ITEM_TO_ORDERS          | LINE_ITEMS    | REF_KEY                  | ["O_ORDERKEY"]                         |
| FACT         | DISCOUNTED_PRICE             | LINE_ITEMS    | TABLE                    | LINE_ITEMS                             |
| FACT         | DISCOUNTED_PRICE             | LINE_ITEMS    | EXPRESSION               | l_extendedprice * (1 - l_discount)     |
| FACT         | DISCOUNTED_PRICE             | LINE_ITEMS    | DATA_TYPE                | NUMBER(25,4)                           |
| FACT         | DISCOUNTED_PRICE             | LINE_ITEMS    | COMMENT                  | Extended price after discount          |
| FACT         | LINE_ITEM_ID                 | LINE_ITEMS    | TABLE                    | LINE_ITEMS                             |
| FACT         | LINE_ITEM_ID                 | LINE_ITEMS    | EXPRESSION               | CONCAT(l_orderkey, '-', l_linenumber)  |
| FACT         | LINE_ITEM_ID                 | LINE_ITEMS    | DATA_TYPE                | VARCHAR(134217728)                     |
| TABLE        | ORDERS                       | NULL          | BASE_TABLE_DATABASE_NAME | SNOWFLAKE_SAMPLE_DATA                  |
| TABLE        | ORDERS                       | NULL          | BASE_TABLE_SCHEMA_NAME   | TPCH_SF1                               |
| TABLE        | ORDERS                       | NULL          | BASE_TABLE_NAME          | ORDERS                                 |
| TABLE        | ORDERS                       | NULL          | SYNONYMS                 | ["sales orders"]                       |
| TABLE        | ORDERS                       | NULL          | PRIMARY_KEY              | ["O_ORDERKEY"]                         |
| TABLE        | ORDERS                       | NULL          | COMMENT                  | All orders table for the sales domain  |
| RELATIONSHIP | ORDERS_TO_CUSTOMERS          | ORDERS        | TABLE                    | ORDERS                                 |
| RELATIONSHIP | ORDERS_TO_CUSTOMERS          | ORDERS        | REF_TABLE                | CUSTOMERS                              |
| RELATIONSHIP | ORDERS_TO_CUSTOMERS          | ORDERS        | FOREIGN_KEY              | ["O_CUSTKEY"]                          |
| RELATIONSHIP | ORDERS_TO_CUSTOMERS          | ORDERS        | REF_KEY                  | ["C_CUSTKEY"]                          |
| METRIC       | AVERAGE_LINE_ITEMS_PER_ORDER | ORDERS        | TABLE                    | ORDERS                                 |
| METRIC       | AVERAGE_LINE_ITEMS_PER_ORDER | ORDERS        | EXPRESSION               | AVG(orders.count_line_items)           |
| METRIC       | AVERAGE_LINE_ITEMS_PER_ORDER | ORDERS        | DATA_TYPE                | NUMBER(36,6)                           |
| METRIC       | AVERAGE_LINE_ITEMS_PER_ORDER | ORDERS        | COMMENT                  | Average number of line items per order |
| FACT         | COUNT_LINE_ITEMS             | ORDERS        | TABLE                    | ORDERS                                 |
| FACT         | COUNT_LINE_ITEMS             | ORDERS        | EXPRESSION               | COUNT(line_items.line_item_id)         |
| FACT         | COUNT_LINE_ITEMS             | ORDERS        | DATA_TYPE                | NUMBER(18,0)                           |
| METRIC       | ORDER_AVERAGE_VALUE          | ORDERS        | TABLE                    | ORDERS                                 |
| METRIC       | ORDER_AVERAGE_VALUE          | ORDERS        | EXPRESSION               | AVG(orders.o_totalprice)               |
| METRIC       | ORDER_AVERAGE_VALUE          | ORDERS        | DATA_TYPE                | NUMBER(30,8)                           |
| METRIC       | ORDER_AVERAGE_VALUE          | ORDERS        | COMMENT                  | Average order value across all orders  |
| DIMENSION    | ORDER_DATE                   | ORDERS        | TABLE                    | ORDERS                                 |
| DIMENSION    | ORDER_DATE                   | ORDERS        | EXPRESSION               | o_orderdate                            |
| DIMENSION    | ORDER_DATE                   | ORDERS        | DATA_TYPE                | DATE                                   |
| DIMENSION    | ORDER_DATE                   | ORDERS        | COMMENT                  | Date when the order was placed         |
| DIMENSION    | ORDER_YEAR                   | ORDERS        | TABLE                    | ORDERS                                 |
| DIMENSION    | ORDER_YEAR                   | ORDERS        | EXPRESSION               | YEAR(o_orderdate)                      |
| DIMENSION    | ORDER_YEAR                   | ORDERS        | DATA_TYPE                | NUMBER(4,0)                            |
| DIMENSION    | ORDER_YEAR                   | ORDERS        | COMMENT                  | Year when the order was placed         |
+--------------+------------------------------+---------------+--------------------------+----------------------------------------+

의미 체계 뷰를 위한 SQL 문 가져오기

GET_DDL 함수를 호출하여 의미 체계 뷰를 생성한 DDL 문을 검색할 수 있습니다.

참고

의미 체계 뷰에 대해 이 함수를 호출하려면, 의미 체계 뷰에 대해 REFERENCES 또는 OWNERSHIP 권한이 부여된 역할을 사용해야 합니다.

GET_DDL 을 호출할 때 'SEMANTIC_VIEW' 를 오브젝트 유형으로 전달합니다. 예:

SELECT GET_DDL('SEMANTIC_VIEW', 'tpch_rev_analysis', TRUE);

+-----------------------------------------------------------------------------------+
| GET_DDL('SEMANTIC_VIEW', 'TPCH_REV_ANALYSIS', TRUE)                               |
|-----------------------------------------------------------------------------------|
| create or replace semantic view DYOSHINAGA_DB.DYOSHINAGA_SCHEMA.TPCH_REV_ANALYSIS |
|     tables (                                                                                                                                                                       |
|             ORDERS primary key (O_ORDERKEY) with synonyms=('sales orders') comment='All orders table for the sales domain',                                                                                                                                                                       |
|             CUSTOMERS as CUSTOMER primary key (C_CUSTKEY) comment='Main table for customer data',                                                                                                                                                                       |
|             LINE_ITEMS as LINEITEM primary key (L_ORDERKEY,L_LINENUMBER) comment='Line items in orders'                                                                                                                                                                       |
|     )                                                                                                                                                                       |
|     relationships (                                                                                                                                                                       |
|             ORDERS_TO_CUSTOMERS as ORDERS(O_CUSTKEY) references CUSTOMERS(C_CUSTKEY),                                                                                                                                                                       |
|             LINE_ITEM_TO_ORDERS as LINE_ITEMS(L_ORDERKEY) references ORDERS(O_ORDERKEY)                                                                                                                                                                       |
|     )                                                                                                                                                                       |
|     facts (                                                                                                                                                                       |
|             ORDERS.COUNT_LINE_ITEMS as COUNT(line_items.line_item_id),                                                                                                                                                                       |
|             LINE_ITEMS.DISCOUNTED_PRICE as l_extendedprice * (1 - l_discount) comment='Extended price after discount',                                                                                                                                                                       |
|             LINE_ITEMS.LINE_ITEM_ID as CONCAT(l_orderkey, '-', l_linenumber)                                                                                                                                                                       |
|     )                                                                                                                                                                       |
|     dimensions (                                                                                                                                                                       |
|             ORDERS.ORDER_DATE as o_orderdate comment='Date when the order was placed',                                                                                                                                                                       |
|             ORDERS.ORDER_YEAR as YEAR(o_orderdate) comment='Year when the order was placed',                                                                                                                                                                       |
|             CUSTOMERS.CUSTOMER_NAME as customers.c_name with synonyms=('customer name') comment='Name of the customer'                                                                                                                                                                       |
|     )                                                                                                                                                                       |
|     metrics (                                                                                                                                                                       |
|             ORDERS.AVERAGE_LINE_ITEMS_PER_ORDER as AVG(orders.count_line_items) comment='Average number of line items per order',                                                                                                                                                                       |
|             ORDERS.ORDER_AVERAGE_VALUE as AVG(orders.o_totalprice) comment='Average order value across all orders'                                                                                                                                                                       |
|     );                                                                                                                                                                       |
+-----------------------------------------------------------------------------------+

반환 값에는 비공개 팩트 및 메트릭 (PRIVATE 키워드로 표시된 팩트 및 메트릭)이 포함됩니다.

의미 체계 뷰의 YAML 사양 가져오기

의미 체계 뷰에 대해 YAML 사양 <semantic-view-yaml-spec>`을 가져오려면 :doc:/sql-reference/functions/system_read_yaml_from_semantic_view` 함수를 호출합니다.

다음 예제에서는 데이터베이스 my_db 및 스키마 my_schema 에서 tpch_analysis 이름의 의미 체계 뷰에 대한 YAML 사양을 반환합니다.

SELECT SYSTEM$READ_YAML_FROM_SEMANTIC_VIEW(
  'my_db.my_schema.tpch_rev_analysis'
);

+-------------------------------------------------------------+
| READ_YAML_FROM_SEMANTIC_VIEW                                |
|-------------------------------------------------------------|
| name: TPCH_REV_ANALYSIS                                     |
| description: Semantic view for revenue analysis             |
| tables:                                                     |
|   - name: CUSTOMERS                                         |
|     description: Main table for customer data               |
|     base_table:                                             |
|       database: SNOWFLAKE_SAMPLE_DATA                       |
|       schema: TPCH_SF1                                      |
|       table: CUSTOMER                                       |
|     primary_key:                                            |
|       columns:                                              |
|         - C_CUSTKEY                                         |
|     dimensions:                                             |
|       - name: CUSTOMER_NAME                                 |
|         synonyms:                                           |
|           - customer name                                   |
|         description: Name of the customer                   |
|         expr: customers.c_name                              |
|         data_type: VARCHAR(25)                              |
|       - name: C_CUSTKEY                                     |
|         expr: C_CUSTKEY                                     |
|         data_type: VARCHAR(134217728)                       |
|   - name: LINE_ITEMS                                        |
|     description: Line items in orders                       |
|     base_table:                                             |
|       database: SNOWFLAKE_SAMPLE_DATA                       |
|       schema: TPCH_SF1                                      |
|       table: LINEITEM                                       |
|     primary_key:                                            |
|       columns:                                              |
|         - L_ORDERKEY                                        |
|         - L_LINENUMBER                                      |
|     dimensions:                                             |
|       - name: L_ORDERKEY                                    |
|         expr: L_ORDERKEY                                    |
|         data_type: VARCHAR(134217728)                       |
|       - name: L_LINENUMBER                                  |
|         expr: L_LINENUMBER                                  |
|         data_type: VARCHAR(134217728)                       |
|     facts:                                                  |
|       - name: DISCOUNTED_PRICE                              |
|         description: Extended price after discount          |
|         expr: l_extendedprice * (1 - l_discount)            |
|         data_type: "NUMBER(25,4)"                           |
|       - name: LINE_ITEM_ID                                  |
|         expr: "CONCAT(l_orderkey, '-', l_linenumber)"       |
|         data_type: VARCHAR(134217728)                       |
|   - name: ORDERS                                            |
|     synonyms:                                               |
|       - sales orders                                        |
|     description: All orders table for the sales domain      |
|     base_table:                                             |
|       database: SNOWFLAKE_SAMPLE_DATA                       |
|       schema: TPCH_SF1                                      |
|       table: ORDERS                                         |
|     primary_key:                                            |
|       columns:                                              |
|         - O_ORDERKEY                                        |
|     dimensions:                                             |
|       - name: ORDER_DATE                                    |
|         description: Date when the order was placed         |
|         expr: o_orderdate                                   |
|         data_type: DATE                                     |
|       - name: ORDER_YEAR                                    |
|         description: Year when the order was placed         |
|         expr: YEAR(o_orderdate)                             |
|         data_type: "NUMBER(4,0)"                            |
|       - name: O_ORDERKEY                                    |
|         expr: O_ORDERKEY                                    |
|         data_type: VARCHAR(134217728)                       |
|       - name: O_CUSTKEY                                     |
|         expr: O_CUSTKEY                                     |
|         data_type: VARCHAR(134217728)                       |
|     facts:                                                  |
|       - name: COUNT_LINE_ITEMS                              |
|         expr: COUNT(line_items.line_item_id)                |
|         data_type: "NUMBER(18,0)"                           |
|     metrics:                                                |
|       - name: AVERAGE_LINE_ITEMS_PER_ORDER                  |
|         description: Average number of line items per order |
|         expr: AVG(orders.count_line_items)                  |
|       - name: ORDER_AVERAGE_VALUE                           |
|         description: Average order value across all orders  |
|         expr: AVG(orders.o_totalprice)                      |
| relationships:                                              |
|   - name: LINE_ITEM_TO_ORDERS                               |
|     left_table: LINE_ITEMS                                  |
|     right_table: ORDERS                                     |
|     relationship_columns:                                   |
|       - left_column: L_ORDERKEY                             |
|         right_column: O_ORDERKEY                            |
|   - name: ORDERS_TO_CUSTOMERS                               |
|     left_table: ORDERS                                      |
|     right_table: CUSTOMERS                                  |
|     relationship_columns:                                   |
|       - left_column: O_CUSTKEY                              |
|         right_column: C_CUSTKEY                             |
|                                                             |
+-------------------------------------------------------------+

의미 체계 뷰를 Tableau 데이터 소스(TDS) 파일로 내보내기

의미 체계 뷰를 Tableau 데이터 소스(TDS) 파일<https://help.tableau.com/current/pro/desktop/en-us/export_connection.htm#options-for-saving-a-local-data-source>`_로 내보내려면 :doc:/sql-reference/functions/system_export_tds_from_semantic_view` 함수를 호출합니다.

다음 예제에서는 의미 체계 뷰 ``my_sv_for_export``에 대한 TDS 파일 내용을 반환합니다.

SELECT SYSTEM$EXPORT_TDS_FROM_SEMANTIC_VIEW('my_sv_for_export');

+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| SYSTEM$EXPORT_TDS_FROM_SEMANTIC_VIEW('MY_SV_FOR_EXPORT')                                                                                                                                                                                                              |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| <?xml version="1.0" encoding="UTF-8"?>                                                                                                                                                                                                                                |
| <!--Tableau compatibility notice:                                                                                                                                                                                                                                     |
| - Generated TDS schema version 18.1 is validated against Tableau Desktop 2025.2                                                                                                                                                                                       |
| - Connection customization schema version 1 enables CAP_* settings to take effect.                                                                                                                                                                                    |
| - Update these versions if your Tableau client requires a different schema.-->                                                                                                                                                                                        |
| <!--Dimensions and measures with duplicated names [DUPLICATE_DIM] are not shown in the TDS file-->                                                                                                                                                                    |
| <datasource xmlns:user="http://www.tableausoftware.com/xml/user" formatted-name="federated.0484db64fcbd48d89e8af86a62" inline="true" version="18.1">                                                                                                                  |
|   <document-format-change-manifest>                                                                                                                                                                                                                                   |
| ...                                                                                                                                 |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

XML을 .tds 파일에 복사하고 Tableau Desktop에서 파일을 엽니다.

Tableau Desktop은 왼쪽의 폴더 목록에 각 논리 테이블에 대한 폴더를 표시합니다. 폴더 이름은 밑줄 대신 공백을 사용하며 각 단어는 대문자로 시작합니다. 예를 들어, date_dim 논리 테이블의 폴더 이름은 ``Date Dim``입니다.

각 폴더에는 의미 체계 뷰의 차원, 팩트, 메트릭에 해당하는 Tableau 차원과 측정값이 포함되어 있습니다.

다음 섹션에서는 변환 프로세스에 대한 자세한 내용과 제한 사항을 제공합니다.

변환 정보

이 함수는 의미 체계 뷰의 차원, 팩트 및 메트릭을 Tableau TDS 파일에서 다음과 같은 항목으로 변환합니다.

의미 체계 뷰의 요소

Tableau에 해당하는 항목(차원 또는 측정값)

데이터 집계 방법

차원

차원

  • 숫자 차원 값의 경우 SUM이 사용됩니다.

  • 날짜 차원은 연도별로 집계됩니다.

  • 다른 유형의 차원의 경우 COUNT가 사용됩니다.

숫자 팩트

측정값

SUM

숫자가 아닌 팩트

차원

  • 날짜 차원은 연도별로 집계됩니다.

  • 다른 유형의 차원의 경우 COUNT가 사용됩니다.

숫자 메트릭

측정값

TDS 파일은 메트릭 대신 계산된 필드를 사용합니다. 계산된 필드는 메트릭 값을 Snowflake AGG 함수에 전달합니다.

숫자가 아닌 메트릭

차원

  • 날짜 차원은 연도별로 집계됩니다.

  • 다른 유형의 차원의 경우 COUNT가 사용됩니다.

숫자 파생 메트릭

측정값

TDS 파일은 메트릭 대신 계산된 필드를 사용합니다. 계산된 필드는 메트릭 값을 Snowflake AGG 함수에 전달합니다.

숫자가 아닌 파생 메트릭

차원

  • 날짜 차원은 연도별로 집계됩니다.

  • 다른 유형의 차원의 경우 COUNT가 사용됩니다.

다음 :doc:`Snowflake 데이터 타입 </sql-reference-data-types>`은 해당 Tableau TDS 데이터 타입에 매핑됩니다.

Snowflake 데이터 타입

해당하는 Tableau 데이터 타입

NUMBER/FIXED(소수 자릿수가 0보다 큰 경우)

real

NUMBER/FIXED(소수 자릿수가 0 또는 Null인 경우)

정수

FLOAT 또는 DECFLOAT

real

STRING 또는 BINARY

문자열

BOOLEAN

boolean

TIME

시간

DATE

날짜

DATETIME 또는 TIMESTAMP

날짜/시간

GEOGRAPHY

공간

반정형(VARIANT, OBJECT, ARRAY), 정형(ARRAY, OBJECT, MAP), 비정형(FILE), GEOMETRY, UUID, VECTOR

문자열

TDS 파일에는 Snowflake에 연결하기 위해 사용자 지정된 다음 `기능 <https://help.tableau.com/current/pro/desktop/en-us/odbc_capabilities.htm>`_이 있습니다.

사용자 지정 이름

값

사용자 지정의 효과

CAP_ODBC_METADATA_SUPPRESS_EXECUTED_QUERY

yes

Tableau가 열 이름을 확인하기 위해 :samp:`SELECT * FROM {table} WHERE 1=0`과 같은 쿼리를 실제로 실행하지 못하게 방지합니다.

CAP_ODBC_METADATA_SUPPRESS_PREPARED_QUERY

yes

Tableau가 유형에 대해 알아보기 위해 문을 “준비”(실행하지 않고 구문 분석하도록 Snowflake로 전송)하지 못하게 방지합니다.

CAP_ODBC_METADATA_SUPPRESS_SELECT_STAR

yes

Tableau가 SELECT * 쿼리를 사용하여 메타데이터를 읽지 못하게 합니다.

CAP_ODBC_METADATA_SUPPRESS_SQLCOLUMNS_API

no

Tableau가 표준 ODBC SQLColumns 함수를 활성화하고 사용하여 의미 체계 뷰에 대한 열 정보를 반환하도록 강제합니다. 이 열 정보에는 열의 이름, 데이터 타입, 열의 전체 자릿수가 포함됩니다.

CAP_DISABLE_ESCAPE_UNDERSCORE_IN_CATALOG

yes

데이터베이스 이름을 검색할 때 Tableau가 밑줄을 이스케이프하지 못하게 방지합니다.

Tableau Desktop에서 의미 체계 뷰 사용 시 제한 사항

Tableau Desktop의 의미 체계 뷰에는 다음 제한 사항이 적용됩니다.

  • 의미 체계 뷰에서 추출을 생성할 수 없습니다.

    연결을 :extui:`Live`에서 :extui:`Extract`로 변경하는 경우, Tableau Desktop은 다음 오류와 함께 실패합니다.

    SQL compilation error:
Requested semantic expression 'XXX' in FACTS clause must be one of the following types: (DIMENSION, FACT).
Unable to create extract

  • 의미 체계 뷰에서 Measure Values 필드를 사용할 수 없습니다.

    의미 체계 뷰에서 Measure Values 필드를 선택하는 경우 Tableau Desktop은 다음 오류를 보고합니다.

    Unable to complete action

Error Code: B9F09DDB
SQL compilation error: error line 1 at position 7
Invalid metric expression 'SUM(1)'.

  • 의미 체계 뷰에서 Count 필드를 선택할 수 없습니다.

    :extui:`SemanticViewName(Count)`를 선택하는 경우 Tableau Desktop은 다음 오류를 보고합니다.

    Unable to complete action

Error Code: B9F09DDB
SQL compilation error: error line 1 at position 7
Invalid metric expression 'SUM(1)'.

    행 수는 쿼리에 지정된 차원, 팩트, 메트릭에 따라 다를 수 있으므로 Tableau Desktop은 의미 체계 뷰의 행 수를 보고할 수 없습니다.

  • 측정값 자체를 드래그할 수 없습니다.

    측정값을 드래그하면 Tableau Desktop이 다음 오류를 보고합니다.

    Unable to complete action

Error Code: B9F09DDB
SQL compilation error: error line 3 at position 8
Invalid metric expression 'COUNT(1)'.

  • 숫자가 아닌 메트릭을 직접 사용할 수 없습니다.

    SYSTEM$EXPORT_TDS_FROM_SEMANTIC_VIEW는 숫자가 아닌 메트릭을 Tableau의 차원으로 변환합니다. 이러한 차원 중 하나를 사용하려고 하면 Tableau Desktop에서 다음 오류가 보고됩니다.

    Unable to complete action

Error Code: B9F09DDB
SQL compilation error:
Requested semantic expression 'CUSTOMER.MIN_NAME' in DIMENSIONS clause must be one of the following types: (DIMENSION, FACT).

    이 문제를 해결하려면 차원을 측정값으로 변환합니다.

    1. 차원을 마우스 오른쪽 버튼으로 클릭하고 :extui:`Convert to Measure`를 선택합니다.

      그러면 기본 집계 :extui:`Count (Distinct)`를 사용하여 차원이 측정값으로 변환됩니다.

    2. 다른 집계를 사용하려면 변환된 측정값을 마우스 오른쪽 버튼으로 클릭하고 Default Properties » :extui:`Aggregations`를 선택한 후 사용할 집계를 선택합니다.

의미 체계 뷰 이름 변경하기

의미 체계 뷰의 이름을 변경하려면 :doc:`ALTER SEMANTIC VIEW … RENAME TO … </sql-reference/sql/alter-semantic-view>`를 실행합니다. 예:

ALTER SEMANTIC VIEW sv RENAME TO sv_new_name;

의미 체계 뷰 제거하기

의미 체계 뷰를 제거하려면 DROP SEMANTIC VIEW 명령을 실행합니다. 예:

DROP SEMANTIC VIEW tpch_rev_analysis;

의미 체계 뷰에 권한 부여하기

의미 체계 뷰 권한 에는 의미 체계 뷰에 부여할 수 있는 권한이 목록으로 표시됩니다.

의미 체계 뷰를 사용하려면 해당 뷰에 대한 다음 권한이 필요합니다.

  • 해당 뷰에 DESCRIBE SEMANTIC VIEW 명령을 실행하려면 모든 권한(예: MONITOR, REFERENCES, SELECT)이 필요합니다.

  • SHOW SEMANTIC VIEWS 명령의 출력에 해당 뷰를 표시하려면 뷰에 대한 모든 권한이 필요합니다.

  • 의미 체계 뷰를 쿼리하려면 SELECT 권한이 필요합니다.

참고

의미 체계 뷰를 쿼리하려고 할 때 의미 체계 뷰에서 사용되는 테이블에 대한 SELECT 권한은 필요하지 않습니다. 의미 체계 뷰 자체에 대해서만 SELECT 권한이 필요합니다.

이 동작은 표준 뷰를 쿼리하는 데 필요한 권한 과 일치합니다.

Cortex Analyst 에서 소유하지 않은 의미 체계 뷰를 사용하려면 해당 뷰에 대한 REFERENCES 및 SELECT 권한이 있는 역할을 사용해야 합니다.

의미 체계 뷰에 REFERENCES 및 SELECT 권한을 부여하려면 GRANT <privileges> … TO ROLE 명령을 사용합니다. 예를 들어, my_semantic_view``라는 의미 체계 뷰에 대한 REFERENCES 및 SELECT 권한을 ``my_analyst_role 역할에 부여하려면 다음 문을 실행하면 됩니다.

GRANT REFERENCES, SELECT ON SEMANTIC VIEW my_semantic_view TO ROLE my_analyst_role;

Cortex Analyst 사용자와 공유하려는 의미 체계 뷰가 포함된 스키마가 있는 경우 향후 부여 를 사용하여 해당 스키마에서 생성한 모든 의미 체계 뷰에 대한 권한을 부여할 수 있습니다. 예:

GRANT REFERENCES, SELECT ON FUTURE SEMANTIC VIEWS IN SCHEMA my_schema TO ROLE my_analyst_role;