ゼロから実務まで学ぶSnowflake14ステップで、アカウント作成から仕事で使えるところまで

SELECT
    CURRENT_VERSION()   AS version,      -- Snowflakeのバージョン
    CURRENT_USER()      AS me,           -- ログインしている自分
    CURRENT_ROLE()      AS my_role,      -- 今の権限（ロール）
    CURRENT_WAREHOUSE() AS my_wh,        -- 今使っている計算機
    CURRENT_TIMESTAMP() AS now;

-- 顧客テーブルの中身を10行だけ見る
SELECT *
FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.CUSTOMER
LIMIT 10;

-- 注文テーブルは何行あるか
SELECT COUNT(*) AS 行数
FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.ORDERS;

USE ROLE SYSADMIN;   -- 物を作るときのロール（ACCOUNTADMINで作業しない）

-- 学習用の計算機。使い終わったら60秒で自動停止する
CREATE WAREHOUSE IF NOT EXISTS LEARN_WH
    WAREHOUSE_SIZE     = 'XSMALL'
    AUTO_SUSPEND       = 60      -- 60秒アイドルで停止（重要）
    AUTO_RESUME        = TRUE    -- クエリが来たら自動で起動
    INITIALLY_SUSPENDED = TRUE
    COMMENT = '学習用';

-- 学習用のデータベースとスキーマ
CREATE DATABASE IF NOT EXISTS LEARN_DB;
CREATE SCHEMA   IF NOT EXISTS LEARN_DB.SALES;

-- これから使う場所を宣言する（ワークシートの右上でも選べる）
USE WAREHOUSE LEARN_WH;
USE DATABASE  LEARN_DB;
USE SCHEMA    SALES;

SELECT CURRENT_WAREHOUSE(), CURRENT_DATABASE(), CURRENT_SCHEMA();

SHOW ROLES;                    -- どんなロールがあるか
SELECT CURRENT_AVAILABLE_ROLES();  -- 自分が着替えられるロール
USE ROLE SYSADMIN;             -- 着替える

SELECT   欲しい列
FROM     どのテーブルから
WHERE    どんな条件の行だけ
ORDER BY 何の順に並べる
LIMIT    何件まで;

USE WAREHOUSE LEARN_WH;

SELECT
    C_CUSTKEY   AS 顧客番号,
    C_NAME      AS 顧客名,
    C_NATIONKEY AS 国コード,
    C_ACCTBAL   AS 残高
FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.CUSTOMER
WHERE C_ACCTBAL > 9000          -- 残高が9000より大きい行だけ
ORDER BY C_ACCTBAL DESC         -- 残高の大きい順（DESC＝降順）
LIMIT 10;

SELECT
    COALESCE(memo, '（記載なし）')  AS memo,   -- NULLなら代わりの値を返す
    IFNULL(point, 0) + 10           AS point,  -- COALESCEの2引数版
    NVL2(memo, '有', '無')          AS 有無     -- NULLでない/NULLで出し分け
FROM (SELECT NULL AS memo, NULL AS point);

SELECT
    '1234'::NUMBER               AS 文字を数値に,   -- :: が型変換の書き方
    CAST('2026-08-14' AS DATE)   AS 文字を日付に,   -- 標準SQLの書き方（同じ意味）
    TRY_CAST('あ' AS NUMBER)     AS 失敗しても止めない,  -- 変換できなければNULL
    ROUND(1234.567, 1)           AS 四捨五入,
    TO_CHAR(1234567, '999,999,999') AS カンマ区切り;

SELECT
    COUNT(*)                AS 行数,          -- 行の数（NULLも数える）
    COUNT(O_COMMENT)        AS コメント有り,   -- NULLは数えない
    COUNT(DISTINCT O_CUSTKEY) AS 顧客数,      -- 重複を除いた数
    SUM(O_TOTALPRICE)       AS 合計金額,
    AVG(O_TOTALPRICE)       AS 平均金額,
    MIN(O_ORDERDATE)        AS 最初の注文日,
    MAX(O_ORDERDATE)        AS 最後の注文日,
    MEDIAN(O_TOTALPRICE)    AS 中央値
FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.ORDERS;

SELECT
    O_ORDERSTATUS          AS 状態,
    COUNT(*)               AS 件数,
    SUM(O_TOTALPRICE)      AS 合計金額
FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.ORDERS
WHERE O_ORDERDATE >= '1998-01-01'   -- 集計する前に行をしぼる
GROUP BY O_ORDERSTATUS               -- 状態ごとにまとめる
HAVING COUNT(*) > 1000               -- まとめた後の結果をしぼる
ORDER BY 合計金額 DESC;

SELECT
    CASE
        WHEN O_TOTALPRICE >= 300000 THEN '大口'
        WHEN O_TOTALPRICE >= 100000 THEN '中口'
        ELSE '小口'
    END                                              AS 区分,
    COUNT(*)                                         AS 件数,
    -- 条件に合う行だけを数える書き方（実務で頻出）
    COUNT(CASE WHEN O_ORDERSTATUS = 'F' THEN 1 END)  AS 完了件数,
    SUM(IFF(O_ORDERSTATUS = 'F', O_TOTALPRICE, 0))   AS 完了金額
FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.ORDERS
GROUP BY ALL
ORDER BY 件数 DESC;

SELECT
    CURRENT_DATE()                              AS 今日,
    DATE_TRUNC('MONTH', CURRENT_DATE())         AS 今月の1日,   -- 月初に切り下げ
    LAST_DAY(CURRENT_DATE())                    AS 月末,
    DATEADD('DAY', -7, CURRENT_DATE())          AS 7日前,
    DATEDIFF('DAY', '2026-01-01', CURRENT_DATE()) AS 経過日数,
    TO_CHAR(CURRENT_DATE(), 'YYYY-MM')          AS 年月,
    YEAR(CURRENT_DATE())                        AS 年,
    DAYNAME(CURRENT_DATE())                     AS 曜日;

SELECT
    DATE_TRUNC('MONTH', O_ORDERDATE) AS 年月,
    COUNT(*)                         AS 件数,
    ROUND(SUM(O_TOTALPRICE))         AS 売上
FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.ORDERS
WHERE O_ORDERDATE >= '1998-01-01'
GROUP BY ALL
ORDER BY 年月;

-- 方法1: 自分のユーザー既定を日本時間にする（おすすめ）
ALTER USER CURRENT_USER SET TIMEZONE = 'Asia/Tokyo';

-- 方法2: その場だけ変換する
SELECT CONVERT_TIMEZONE('Asia/Tokyo', CURRENT_TIMESTAMP()) AS 日本時間;

-- アカウント全体を変えたいとき（ACCOUNTADMINが必要。影響が大きいので合意のうえで）
-- ALTER ACCOUNT SET TIMEZONE = 'Asia/Tokyo';

SELECT
    o.O_ORDERKEY    AS 注文番号,
    o.O_ORDERDATE   AS 注文日,
    c.C_NAME        AS 顧客名,
    n.N_NAME        AS 国名,
    o.O_TOTALPRICE  AS 金額
FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.ORDERS   AS o
JOIN SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.CUSTOMER AS c
     ON o.O_CUSTKEY = c.C_CUSTKEY            -- 注文の顧客番号 ＝ 顧客の顧客番号
JOIN SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.NATION   AS n
     ON c.C_NATIONKEY = n.N_NATIONKEY        -- さらに国マスタもつなぐ
WHERE o.O_ORDERDATE >= '1998-07-01'
ORDER BY o.O_TOTALPRICE DESC
LIMIT 10;

-- つなぐ相手（マスタ）に、キーの重複が無いかを確認する
SELECT C_CUSTKEY, COUNT(*) AS 件数
FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.CUSTOMER
GROUP BY C_CUSTKEY
HAVING COUNT(*) > 1;    -- 0行なら重複なし＝安心してJOINできる

-- 注文はすべて残しつつ、マスタに無い顧客番号を洗い出す
SELECT
    o.O_ORDERKEY,
    o.O_CUSTKEY,
    c.C_NAME
FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.ORDERS   AS o
LEFT JOIN SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.CUSTOMER AS c
       ON o.O_CUSTKEY = c.C_CUSTKEY
WHERE c.C_CUSTKEY IS NULL     -- つながらなかった行だけ＝マスタ漏れ
LIMIT 20;

WITH 月別 AS (                                   -- ① まず月ごとに集計
    SELECT
        DATE_TRUNC('MONTH', O_ORDERDATE) AS 年月,
        SUM(O_TOTALPRICE)                AS 売上
    FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.ORDERS
    WHERE O_ORDERDATE >= '1998-01-01'
    GROUP BY ALL
),
平均 AS (                                        -- ② ①を使って平均を出す
    SELECT AVG(売上) AS 月平均 FROM 月別
)
SELECT                                           -- ③ ①と②を組み合わせる
    m.年月,
    ROUND(m.売上)                        AS 売上,
    ROUND(a.月平均)                      AS 月平均,
    ROUND(m.売上 / a.月平均 * 100, 1)    AS 平均比パーセント
FROM 月別 AS m
CROSS JOIN 平均 AS a
ORDER BY m.年月;

SELECT '東日本' AS 地域, O_ORDERKEY, O_TOTALPRICE
FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.ORDERS WHERE O_ORDERKEY < 100
UNION ALL              -- 重複を除かない（速い。ふつうはこちら）
SELECT '西日本' AS 地域, O_ORDERKEY, O_TOTALPRICE
FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.ORDERS WHERE O_ORDERKEY BETWEEN 100 AND 200;
-- UNION（ALL無し）は重複行を除くが、その分だけ遅い

USE ROLE SYSADMIN;
USE WAREHOUSE LEARN_WH;
USE SCHEMA LEARN_DB.SALES;

CREATE OR REPLACE TABLE CUSTOMERS (
    CUSTOMER_ID   NUMBER(10,0)  NOT NULL,        -- 必ず値が必要
    CUSTOMER_NAME VARCHAR(100)  NOT NULL,
    PREFECTURE    VARCHAR(20),
    SIGNUP_DATE   DATE,
    IS_ACTIVE     BOOLEAN       DEFAULT TRUE,     -- 省略時の値
    CREATED_AT    TIMESTAMP_NTZ DEFAULT CURRENT_TIMESTAMP()
);

CREATE OR REPLACE TABLE ORDERS (
    ORDER_ID    NUMBER(12,0)  NOT NULL,
    CUSTOMER_ID NUMBER(10,0)  NOT NULL,
    ORDER_DATE  DATE          NOT NULL,
    CHANNEL     VARCHAR(20),                      -- 'WEB' / 'STORE' / 'PHONE'
    AMOUNT      NUMBER(12,2)  NOT NULL,           -- 金額は必ずNUMBER
    STATUS      VARCHAR(10)   DEFAULT 'OPEN'
);

SHOW TABLES;          -- 作られたか確認
DESC TABLE ORDERS;    -- 列の定義を確認

INSERT INTO CUSTOMERS (CUSTOMER_ID, CUSTOMER_NAME, PREFECTURE, SIGNUP_DATE) VALUES
    (1, '山田商店',   '東京都',   '2025-04-01'),
    (2, '佐藤物産',   '大阪府',   '2025-06-15'),
    (3, '鈴木工業',   '愛知県',   '2026-01-20'),
    (4, '田中フーズ', '福岡県',   '2026-03-02'),
    (5, '高橋電機',   '北海道',   '2026-05-11');

INSERT INTO ORDERS (ORDER_ID, CUSTOMER_ID, ORDER_DATE, CHANNEL, AMOUNT, STATUS) VALUES
    (1001, 1, '2026-06-01', 'WEB',   120000, 'PAID'),
    (1002, 1, '2026-06-18', 'STORE',  38000, 'PAID'),
    (1003, 2, '2026-06-20', 'WEB',   256000, 'PAID'),
    (1004, 3, '2026-07-02', 'PHONE',  74000, 'OPEN'),
    (1005, 2, '2026-07-11', 'WEB',    91000, 'PAID'),
    (1006, 4, '2026-07-25', 'WEB',   183000, 'CANCEL'),
    (1007, 5, '2026-08-03', 'STORE', 452000, 'PAID'),
    (1008, 1, '2026-08-09', 'WEB',    65000, 'OPEN');

SELECT COUNT(*) FROM ORDERS;

-- 集計結果をそのままテーブルにする。列の型は自動で決まる
CREATE OR REPLACE TABLE MONTHLY_SALES AS
SELECT
    DATE_TRUNC('MONTH', ORDER_DATE) AS 年月,
    COUNT(*)                        AS 件数,
    SUM(AMOUNT)                     AS 売上
FROM ORDERS
WHERE STATUS <> 'CANCEL'
GROUP BY ALL;

SELECT * FROM MONTHLY_SALES ORDER BY 年月;

-- 更新（WHEREを忘れると全行が書き換わる。必ず先にSELECTで確認）
UPDATE ORDERS SET STATUS = 'PAID' WHERE ORDER_ID = 1004;

-- 削除
DELETE FROM ORDERS WHERE STATUS = 'CANCEL';

-- 中身だけ全部消す（テーブルの定義は残る）
-- TRUNCATE TABLE ORDERS;

-- テーブルごと消す
-- DROP TABLE ORDERS;

-- 今日届いた差分データ（本来はファイルから取り込む）
CREATE OR REPLACE TEMPORARY TABLE ORDERS_DELTA AS
SELECT * FROM ORDERS WHERE FALSE;   -- 同じ形の空テーブルを作る小技

INSERT INTO ORDERS_DELTA VALUES
    (1008, 1, '2026-08-09', 'WEB',  65000, 'PAID'),    -- 既存 → 更新される
    (1009, 3, '2026-08-13', 'WEB', 138000, 'OPEN');    -- 新規 → 追加される

MERGE INTO ORDERS AS t                       -- 対象（target）
USING ORDERS_DELTA AS s                      -- 差分（source）
   ON t.ORDER_ID = s.ORDER_ID                -- 突き合わせるキー
WHEN MATCHED THEN UPDATE SET
    t.STATUS = s.STATUS,
    t.AMOUNT = s.AMOUNT
WHEN NOT MATCHED THEN INSERT
    (ORDER_ID, CUSTOMER_ID, ORDER_DATE, CHANNEL, AMOUNT, STATUS)
    VALUES (s.ORDER_ID, s.CUSTOMER_ID, s.ORDER_DATE, s.CHANNEL, s.AMOUNT, s.STATUS);

USE SCHEMA LEARN_DB.SALES;

-- ① 読み方の説明書を作る
CREATE OR REPLACE FILE FORMAT CSV_JP
    TYPE = 'CSV'
    FIELD_DELIMITER = ','
    SKIP_HEADER = 1                       -- 1行目は見出しなので読み飛ばす
    FIELD_OPTIONALLY_ENCLOSED_BY = '"'    -- 値が " で囲まれている場合に対応
    NULL_IF = ('', 'NULL', 'null', 'NA')  -- 空欄はNULLとして扱う
    EMPTY_FIELD_AS_NULL = TRUE
    ENCODING = 'UTF8'
    DATE_FORMAT = 'YYYY-MM-DD'
    TIMESTAMP_FORMAT = 'YYYY-MM-DD HH24:MI:SS'
    ERROR_ON_COLUMN_COUNT_MISMATCH = FALSE;  -- 列数のズレで即エラーにしない

-- ② 置き場を作る
CREATE OR REPLACE STAGE MY_STAGE
    FILE_FORMAT = CSV_JP
    COMMENT = '取り込み用の一時置き場';

SHOW STAGES;

# 手元のCSVをステージへアップロード（自動で圧縮される）
snow stage copy ./orders_202608.csv @MY_STAGE

# 置かれたファイルの確認は、SQL側から LIST でもできる

-- ③ ステージの中身を確認
LIST @MY_STAGE;

-- ④ 取り込む前に、中身を目で見る（これができるのがSnowflakeの強み）
SELECT $1, $2, $3, $4, $5, $6      -- $1 は1列目という意味
FROM @MY_STAGE/orders_202608.csv
(FILE_FORMAT => CSV_JP)
LIMIT 5;

-- ⑤ 本番の取り込み前に、検証だけ行う（1行も入らない）
COPY INTO ORDERS
FROM @MY_STAGE/orders_202608.csv
FILE_FORMAT = (FORMAT_NAME = CSV_JP)
VALIDATION_MODE = 'RETURN_ERRORS';

-- ⑥ 取り込む
COPY INTO ORDERS
FROM @MY_STAGE/orders_202608.csv
FILE_FORMAT = (FORMAT_NAME = CSV_JP)
ON_ERROR = 'CONTINUE';       -- エラー行は飛ばして続行

-- どの行が、なぜ弾かれたのかを調べる
SELECT *
FROM TABLE(VALIDATE(ORDERS, JOB_ID => '_last'));

-- 過去の取り込み履歴（いつ・何件・エラー数）
SELECT FILE_NAME, ROW_COUNT, ROW_PARSED, ERROR_COUNT, STATUS, LAST_LOAD_TIME
FROM TABLE(INFORMATION_SCHEMA.COPY_HISTORY(
    TABLE_NAME => 'ORDERS',
    START_TIME => DATEADD('DAY', -7, CURRENT_TIMESTAMP())
))
ORDER BY LAST_LOAD_TIME DESC;

-- ファイルから列名と型を自動で推測させ、その形のテーブルを作る
CREATE OR REPLACE TABLE ORDERS_RAW
USING TEMPLATE (
    SELECT ARRAY_AGG(OBJECT_CONSTRUCT(*))
    FROM TABLE(INFER_SCHEMA(
        LOCATION => '@MY_STAGE/orders_202608.csv',
        FILE_FORMAT => 'CSV_JP'
    ))
);

-- 列の順番ではなく「見出しの名前」で対応づけて取り込む
COPY INTO ORDERS_RAW
FROM @MY_STAGE/orders_202608.csv
FILE_FORMAT = (FORMAT_NAME = CSV_JP)
MATCH_BY_COLUMN_NAME = 'CASE_INSENSITIVE';

-- ① 接続情報（ACCOUNTADMINが1回だけ作る。鍵をSQLに書かずに済む）
CREATE OR REPLACE STORAGE INTEGRATION S3_INT
    TYPE = EXTERNAL_STAGE
    STORAGE_PROVIDER = 'S3'
    ENABLED = TRUE
    STORAGE_AWS_ROLE_ARN = 'arn:aws:iam::123456789012:role/snowflake-role'
    STORAGE_ALLOWED_LOCATIONS = ('s3://my-bucket/sales/');

-- ② 外部ステージ
CREATE OR REPLACE STAGE S3_SALES_STAGE
    STORAGE_INTEGRATION = S3_INT
    URL = 's3://my-bucket/sales/'
    FILE_FORMAT = CSV_JP;

-- ③ ファイルが置かれたら自動で取り込む仕掛け（Snowpipe）
CREATE OR REPLACE PIPE SALES_PIPE
    AUTO_INGEST = TRUE
AS
COPY INTO ORDERS FROM @S3_SALES_STAGE FILE_FORMAT = (FORMAT_NAME = CSV_JP);

SELECT SYSTEM$PIPE_STATUS('SALES_PIPE');   -- 動いているかの確認

COPY INTO @MY_STAGE/export/monthly_
FROM (SELECT * FROM MONTHLY_SALES ORDER BY 年月)
FILE_FORMAT = (TYPE = 'CSV' COMPRESSION = 'GZIP' HEADER = TRUE)
SINGLE = FALSE
MAX_FILE_SIZE = 100000000
OVERWRITE = TRUE;

LIST @MY_STAGE/export/;
-- GET でパソコンに落とす（Snowflake CLIから）

USE SCHEMA LEARN_DB.SALES;

CREATE OR REPLACE TABLE EVENTS (
    EVENT_ID  NUMBER,
    PAYLOAD   VARIANT        -- 何が来ても受け止められる型
);

INSERT INTO EVENTS
SELECT 1, PARSE_JSON('{
  "user": {"id": 101, "name": "山田", "pref": "東京都"},
  "action": "purchase",
  "amount": 12800,
  "items": [
    {"sku": "A-01", "qty": 2, "price": 4900},
    {"sku": "B-77", "qty": 1, "price": 3000}
  ],
  "ts": "2026-08-14T10:22:31"
}');

SELECT * FROM EVENTS;

SELECT
    PAYLOAD:action::STRING          AS 行動,       -- コロンで階層をたどる
    PAYLOAD:user.name::STRING       AS 名前,       -- 入れ子はドットでつなぐ
    PAYLOAD:user.id::NUMBER         AS ユーザーID,
    PAYLOAD:amount::NUMBER          AS 金額,
    PAYLOAD:ts::TIMESTAMP_NTZ       AS 時刻,
    PAYLOAD:items[0].sku::STRING    AS 最初の商品,  -- 配列は0から数える
    ARRAY_SIZE(PAYLOAD:items)       AS 商品数
FROM EVENTS;

SELECT
    e.EVENT_ID,
    e.PAYLOAD:user.name::STRING AS 名前,
    f.INDEX                     AS 何番目,
    f.VALUE:sku::STRING         AS 商品コード,
    f.VALUE:qty::NUMBER         AS 数量,
    f.VALUE:price::NUMBER       AS 単価,
    f.VALUE:qty::NUMBER * f.VALUE:price::NUMBER AS 小計
FROM EVENTS AS e,
     LATERAL FLATTEN(INPUT => e.PAYLOAD:items) AS f;

SELECT
    OBJECT_CONSTRUCT(
        'customer_id', CUSTOMER_ID,
        'name',        CUSTOMER_NAME,
        'orders',      ARRAY_AGG(OBJECT_CONSTRUCT('id', ORDER_ID, 'amount', AMOUNT))
    ) AS 顧客JSON
FROM CUSTOMERS
JOIN ORDERS USING (CUSTOMER_ID)     -- 同名の列で結合する短い書き方
GROUP BY CUSTOMER_ID, CUSTOMER_NAME;

関数() OVER (
    PARTITION BY 区切る列      -- 何ごとに計算するか（省略可＝全体）
    ORDER BY     並べる列       -- どの順で見るか
)

SELECT
    ORDER_ID, CUSTOMER_ID, ORDER_DATE, AMOUNT,
    -- 顧客ごとの合計を、明細の横に並べる
    SUM(AMOUNT) OVER (PARTITION BY CUSTOMER_ID)                       AS 顧客合計,
    -- 顧客ごとの、注文順の通し番号
    ROW_NUMBER() OVER (PARTITION BY CUSTOMER_ID ORDER BY ORDER_DATE)  AS 何回目,
    -- 全体での金額順位
    RANK() OVER (ORDER BY AMOUNT DESC)                                AS 金額順位,
    -- その顧客の前回の注文金額
    LAG(AMOUNT) OVER (PARTITION BY CUSTOMER_ID ORDER BY ORDER_DATE)   AS 前回金額
FROM ORDERS
ORDER BY CUSTOMER_ID, ORDER_DATE;

-- 顧客ごとの最新の注文だけを1行ずつ取り出す
SELECT ORDER_ID, CUSTOMER_ID, ORDER_DATE, AMOUNT
FROM ORDERS
QUALIFY ROW_NUMBER() OVER (PARTITION BY CUSTOMER_ID ORDER BY ORDER_DATE DESC) = 1
ORDER BY CUSTOMER_ID;

-- 重複行の除去（同じ注文番号が複数あるとき、いちばん新しい1行を残す）
SELECT *
FROM ORDERS
QUALIFY ROW_NUMBER() OVER (PARTITION BY ORDER_ID ORDER BY ORDER_DATE DESC) = 1;

WITH 月別 AS (
    SELECT DATE_TRUNC('MONTH', O_ORDERDATE) AS 年月, SUM(O_TOTALPRICE) AS 売上
    FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.ORDERS
    WHERE O_ORDERDATE >= '1997-01-01'
    GROUP BY ALL
)
SELECT
    年月,
    ROUND(売上)                                                  AS 売上,
    ROUND(LAG(売上) OVER (ORDER BY 年月))                        AS 前月,
    ROUND((売上 / LAG(売上) OVER (ORDER BY 年月) - 1) * 100, 1)  AS 前月比パーセント,
    ROUND(SUM(売上) OVER (ORDER BY 年月))                        AS 累計,
    -- 3か月移動平均（自分を含む直近3行の平均）
    ROUND(AVG(売上) OVER (ORDER BY 年月 ROWS BETWEEN 2 PRECEDING AND CURRENT ROW)) AS 移動平均3か月
FROM 月別
ORDER BY 年月;

-- 事故を起こしてみる
DELETE FROM ORDERS;             -- 全部消えた！
SELECT COUNT(*) FROM ORDERS;    -- 0

-- 5分前の状態を見る
SELECT COUNT(*) FROM ORDERS AT(OFFSET => -60*5);

-- 特定の時刻の状態を見る
SELECT * FROM ORDERS AT(TIMESTAMP => '2026-08-14 09:00:00'::TIMESTAMP_NTZ);

-- 「あのクエリを実行する直前」の状態を見る（いちばん確実）
SELECT * FROM ORDERS BEFORE(STATEMENT => '01b2c3d4-0000-abcd-0000-000000000001');

-- 復旧する
CREATE OR REPLACE TABLE ORDERS AS
SELECT * FROM ORDERS AT(OFFSET => -60*5);

SELECT COUNT(*) FROM ORDERS;    -- 戻った

DROP TABLE ORDERS;
UNDROP TABLE ORDERS;        -- 消したテーブルを戻す

-- データベースやスキーマごと戻すこともできる
-- UNDROP SCHEMA SALES;
-- UNDROP DATABASE LEARN_DB;

-- 保持期間の設定（Enterprise以上は最大90日）
ALTER TABLE ORDERS SET DATA_RETENTION_TIME_IN_DAYS = 7;

-- 本番のコピーで検証する（データベースまるごと）
CREATE DATABASE DEV_DB CLONE LEARN_DB;

-- テーブル単位でも
CREATE TABLE ORDERS_BACKUP CLONE ORDERS;

-- 「昨日の状態」でクローンする（Time Travelとの合わせ技）
CREATE TABLE ORDERS_YESTERDAY CLONE ORDERS AT(OFFSET => -60*60*24);

-- 権限も引き継ぎたいとき
-- CREATE TABLE ORDERS_BK CLONE ORDERS COPY GRANTS;

-- 同じSQLを2回実行してみる。2回目は一瞬で終わり、ウェアハウスすら起動しない
SELECT COUNT(*) FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.LINEITEM;

-- 検証のためキャッシュを無効にする（性能を測るときだけ）
ALTER SESSION SET USE_CACHED_RESULT = FALSE;

USE SCHEMA LEARN_DB.SALES;

-- ふつうのビュー（実データを持たない。常に最新）
CREATE OR REPLACE VIEW V_MONTHLY_SALES AS
SELECT
    DATE_TRUNC('MONTH', o.ORDER_DATE) AS 年月,
    c.PREFECTURE                      AS 都道府県,
    COUNT(*)                          AS 件数,
    SUM(o.AMOUNT)                     AS 売上
FROM ORDERS AS o
JOIN CUSTOMERS AS c USING (CUSTOMER_ID)
WHERE o.STATUS <> 'CANCEL'
GROUP BY ALL;

SELECT * FROM V_MONTHLY_SALES ORDER BY 年月, 売上 DESC;

CREATE OR REPLACE TASK T_REFRESH_MONTHLY
    SCHEDULE = 'USING CRON 0 6 * * * Asia/Tokyo'   -- 毎朝6時（日本時間）
    USER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE = 'XSMALL'  -- サーバーレスで動かす
AS
    CREATE OR REPLACE TABLE MONTHLY_SALES AS
    SELECT * FROM V_MONTHLY_SALES;

-- 作った直後のタスクは停止状態。明示的に開始する（忘れがち）
ALTER TASK T_REFRESH_MONTHLY RESUME;

-- 手で1回動かして試す
EXECUTE TASK T_REFRESH_MONTHLY;

-- 実行結果の確認
SELECT NAME, STATE, SCHEDULED_TIME, COMPLETED_TIME, ERROR_MESSAGE
FROM TABLE(INFORMATION_SCHEMA.TASK_HISTORY())
ORDER BY SCHEDULED_TIME DESC
LIMIT 10;

-- ORDERSの変更を監視するストリーム
CREATE OR REPLACE STREAM S_ORDERS ON TABLE ORDERS;

-- 変更を起こす
INSERT INTO ORDERS VALUES (1010, 2, '2026-08-14', 'WEB', 77000, 'OPEN');
UPDATE ORDERS SET STATUS = 'PAID' WHERE ORDER_ID = 1004;

-- ストリームには「差分」だけが見える
SELECT ORDER_ID, AMOUNT, STATUS,
       METADATA$ACTION,      -- INSERT / DELETE
       METADATA$ISUPDATE     -- 更新による削除+挿入か
FROM S_ORDERS;

CREATE OR REPLACE TABLE ORDERS_MART LIKE ORDERS;   -- 同じ形の空テーブル

CREATE OR REPLACE TASK T_SYNC_ORDERS
    SCHEDULE = '5 MINUTE'
    WHEN SYSTEM$STREAM_HAS_DATA('S_ORDERS')   -- 差分があるときだけ動く＝無駄な課金なし
AS
    MERGE INTO ORDERS_MART AS t
    USING (SELECT * FROM S_ORDERS WHERE METADATA$ACTION = 'INSERT') AS s
       ON t.ORDER_ID = s.ORDER_ID
    WHEN MATCHED THEN UPDATE SET t.STATUS = s.STATUS, t.AMOUNT = s.AMOUNT
    WHEN NOT MATCHED THEN INSERT (ORDER_ID, CUSTOMER_ID, ORDER_DATE, CHANNEL, AMOUNT, STATUS)
         VALUES (s.ORDER_ID, s.CUSTOMER_ID, s.ORDER_DATE, s.CHANNEL, s.AMOUNT, s.STATUS);

ALTER TASK T_SYNC_ORDERS RESUME;

CREATE OR REPLACE DYNAMIC TABLE DT_MONTHLY_SALES
    TARGET_LAG = '10 minutes'      -- 元データから最大10分遅れまで許す
    WAREHOUSE  = LEARN_WH
AS
SELECT
    DATE_TRUNC('MONTH', o.ORDER_DATE) AS 年月,
    c.PREFECTURE                      AS 都道府県,
    COUNT(*)                          AS 件数,
    SUM(o.AMOUNT)                     AS 売上
FROM ORDERS AS o
JOIN CUSTOMERS AS c USING (CUSTOMER_ID)
WHERE o.STATUS <> 'CANCEL'
GROUP BY ALL;

SELECT * FROM DT_MONTHLY_SALES;               -- ふつうのテーブルとして読める
SHOW DYNAMIC TABLES;                           -- 更新状況の確認

USE ROLE SECURITYADMIN;

CREATE ROLE IF NOT EXISTS SALES_READ;    -- アクセスロール
CREATE ROLE IF NOT EXISTS ANALYST;       -- 機能ロール

-- 参照に必要な3点セット（どれか1つ欠けても読めない）
GRANT USAGE ON DATABASE LEARN_DB              TO ROLE SALES_READ;
GRANT USAGE ON SCHEMA   LEARN_DB.SALES        TO ROLE SALES_READ;
GRANT SELECT ON ALL TABLES IN SCHEMA LEARN_DB.SALES TO ROLE SALES_READ;

-- これから作られるテーブルにも自動で権限を付ける（重要）
GRANT SELECT ON FUTURE TABLES IN SCHEMA LEARN_DB.SALES TO ROLE SALES_READ;
GRANT SELECT ON FUTURE VIEWS  IN SCHEMA LEARN_DB.SALES TO ROLE SALES_READ;

-- 計算機を使う権限も必要
GRANT USAGE ON WAREHOUSE LEARN_WH TO ROLE SALES_READ;

-- 機能ロールに束ねて、人に渡す
GRANT ROLE SALES_READ TO ROLE ANALYST;
GRANT ROLE ANALYST    TO USER "SATO";

-- 管理者から見えるように、SYSADMINの下にもぶら下げる（推奨）
GRANT ROLE ANALYST TO ROLE SYSADMIN;

SHOW GRANTS TO ROLE ANALYST;          -- そのロールが持つ権限
SHOW GRANTS ON TABLE ORDERS;          -- そのテーブルに付いている権限
SHOW GRANTS TO USER "SATO";           -- その人が持つロール

USE ROLE USERADMIN;

CREATE USER IF NOT EXISTS SATO
    LOGIN_NAME = 'sato'
    DEFAULT_ROLE = ANALYST
    DEFAULT_WAREHOUSE = LEARN_WH
    MUST_CHANGE_PASSWORD = TRUE;

-- プログラムから接続する用途では、パスワードではなく鍵を使う
-- ALTER USER BATCH_USER SET RSA_PUBLIC_KEY = 'MIIBIj...';

USE ROLE ACCOUNTADMIN;

CREATE OR REPLACE RESOURCE MONITOR RM_LEARN
    WITH CREDIT_QUOTA = 50              -- 月に50クレジットまで
         FREQUENCY = MONTHLY
         START_TIMESTAMP = IMMEDIATELY
    TRIGGERS
        ON 75  PERCENT DO NOTIFY                    -- 75%で通知
        ON 90  PERCENT DO NOTIFY
        ON 100 PERCENT DO SUSPEND                   -- 到達で新規クエリを止める
        ON 110 PERCENT DO SUSPEND_IMMEDIATE;        -- 実行中のものも止める

ALTER WAREHOUSE LEARN_WH SET RESOURCE_MONITOR = RM_LEARN;

USE ROLE ACCOUNTADMIN;

-- ウェアハウス別の、直近30日のクレジット消費
SELECT
    WAREHOUSE_NAME,
    ROUND(SUM(CREDITS_USED), 2) AS クレジット
FROM SNOWFLAKE.ACCOUNT_USAGE.WAREHOUSE_METERING_HISTORY
WHERE START_TIME >= DATEADD('DAY', -30, CURRENT_TIMESTAMP())
GROUP BY ALL
ORDER BY クレジット DESC;

-- 重いクエリの犯人探し（誰の、どのSQLが時間を使ったか）
SELECT
    USER_NAME, WAREHOUSE_NAME,
    ROUND(TOTAL_ELAPSED_TIME / 1000, 1) AS 秒,
    ROUND(BYTES_SCANNED / POWER(1024, 3), 2) AS 読んだGB,
    LEFT(QUERY_TEXT, 80) AS SQL冒頭
FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY
WHERE START_TIME >= DATEADD('DAY', -7, CURRENT_TIMESTAMP())
  AND TOTAL_ELAPSED_TIME > 60000        -- 60秒以上かかったもの
ORDER BY TOTAL_ELAPSED_TIME DESC
LIMIT 20;

-- テーブルがどう分割されているかを見る
SELECT SYSTEM$CLUSTERING_INFORMATION('ORDERS', '(ORDER_DATE)');

-- 数TB級の巨大テーブルで、特定の列での絞り込みが多い場合のみ検討
-- ALTER TABLE ORDERS CLUSTER BY (ORDER_DATE);

-- 1行を狙って引く検索が多いテーブル向け（別料金）
-- ALTER TABLE ORDERS ADD SEARCH OPTIMIZATION;

# 導入（Pythonが入っていれば1行）
pip install snowflake-cli

# 接続情報を対話形式で登録する
snow connection add

# 1本だけ実行
snow sql -q "SELECT CURRENT_VERSION()"

# ファイルにまとめたSQLを実行（バッチ処理の基本形）
snow sql -f ./daily_batch.sql

# ステージへファイルを上げる
snow stage copy ./orders.csv @MY_STAGE

pip install "snowflake-connector-python[pandas]" python-dotenv

SF_ACCOUNT=xxxxxxx-yyyyyyy
SF_USER=ueki
SF_PASSWORD=************
SF_WAREHOUSE=LEARN_WH
SF_DATABASE=LEARN_DB
SF_SCHEMA=SALES

import os

import snowflake.connector
from dotenv import load_dotenv

load_dotenv()   # .env からアカウント情報を読み込む

conn = snowflake.connector.connect(
    account=os.environ["SF_ACCOUNT"],
    user=os.environ["SF_USER"],
    password=os.environ["SF_PASSWORD"],
    warehouse=os.environ["SF_WAREHOUSE"],
    database=os.environ["SF_DATABASE"],
    schema=os.environ["SF_SCHEMA"],
)

sql = """
    SELECT c.PREFECTURE AS 都道府県, SUM(o.AMOUNT) AS 売上
    FROM ORDERS AS o
    JOIN CUSTOMERS AS c USING (CUSTOMER_ID)
    WHERE o.ORDER_DATE >= %s          -- 値は必ずこの形で渡す（文字列連結しない）
    GROUP BY ALL
    ORDER BY 売上 DESC
"""

try:
    cur = conn.cursor()
    cur.execute(sql, ("2026-06-01",))
    df = cur.fetch_pandas_all()       # 結果をそのままpandasのDataFrameで受け取る
    print(df)
    df.to_excel("売上レポート.xlsx", index=False)
finally:
    conn.close()                      # 接続は必ず閉じる

import pandas as pd
from snowflake.connector.pandas_tools import write_pandas

df = pd.read_csv("results.csv")

# pandasのDataFrameを、そのままテーブルに書き込む
success, nchunks, nrows, _ = write_pandas(
    conn, df, table_name="RESULTS", auto_create_table=True, overwrite=True
)
print(f"{nrows}行を書き込みました")

from snowflake.snowpark import Session
from snowflake.snowpark.functions import col, sum as sum_

session = Session.builder.configs({
    "account": "xxxxxxx-yyyyyyy", "user": "ueki", "password": "****",
    "warehouse": "LEARN_WH", "database": "LEARN_DB", "schema": "SALES",
}).create()

df = (session.table("ORDERS")
      .filter(col("STATUS") != "CANCEL")
      .group_by("CUSTOMER_ID")
      .agg(sum_("AMOUNT").alias("売上"))
      .sort(col("売上").desc()))

df.show()                       # ここで初めてSQLに変換されて実行される
df.write.mode("overwrite").save_as_table("CUSTOMER_SALES")
session.close()

USE ROLE SYSADMIN;

CREATE DATABASE IF NOT EXISTS PROD_DB;   -- 本番（人手で触らない）
CREATE DATABASE IF NOT EXISTS DEV_DB;    -- 開発

-- 本番と同じデータで検証したいとき（数秒・追加費用ほぼゼロ）
CREATE OR REPLACE DATABASE DEV_DB CLONE PROD_DB;

-- 本番への変更は、SQLファイルにして流す（画面で手打ちしない）

USE ROLE ACCOUNTADMIN;

CREATE OR REPLACE API INTEGRATION GIT_API
    API_PROVIDER = GIT_HTTPS_API
    API_ALLOWED_PREFIXES = ('https://github.com/my-org')
    ENABLED = TRUE;

CREATE OR REPLACE GIT REPOSITORY SQL_REPO
    API_INTEGRATION = GIT_API
    ORIGIN = 'https://github.com/my-org/snowflake-sql.git';

ALTER GIT REPOSITORY SQL_REPO FETCH;

-- リポジトリ内のSQLファイルをそのまま実行する
EXECUTE IMMEDIATE FROM @SQL_REPO/branches/main/deploy/create_marts.sql;

CREATE OR REPLACE PROCEDURE SP_DAILY_LOAD(TARGET_DATE DATE)
RETURNS STRING
LANGUAGE SQL
AS
$$
DECLARE
    row_count INTEGER;
BEGIN
    DELETE FROM MART_SALES WHERE 売上日 = :TARGET_DATE;   -- やり直せるように先に消す

    INSERT INTO MART_SALES
    SELECT ORDER_DATE, SUM(AMOUNT)
    FROM ORDERS
    WHERE ORDER_DATE = :TARGET_DATE
    GROUP BY ORDER_DATE;

    row_count := SQLROWCOUNT;
    RETURN :TARGET_DATE::STRING || ' を ' || :row_count || ' 件で更新しました';
EXCEPTION
    WHEN OTHER THEN
        RETURN '失敗: ' || SQLERRM;
END;
$$;

CALL SP_DAILY_LOAD('2026-08-14');

-- ① 主キーの重複がないか
SELECT 'ORDER_IDの重複' AS 検査, COUNT(*) AS 件数
FROM (SELECT ORDER_ID FROM ORDERS GROUP BY ORDER_ID HAVING COUNT(*) > 1)
UNION ALL
-- ② 必須項目のNULL
SELECT 'CUSTOMER_IDがNULL', COUNT(*) FROM ORDERS WHERE CUSTOMER_ID IS NULL
UNION ALL
-- ③ マスタに存在しない顧客
SELECT 'マスタ未登録の顧客', COUNT(*)
FROM ORDERS AS o LEFT JOIN CUSTOMERS AS c USING (CUSTOMER_ID)
WHERE c.CUSTOMER_ID IS NULL
UNION ALL
-- ④ 金額のマイナスや異常値
SELECT '金額が0以下', COUNT(*) FROM ORDERS WHERE AMOUNT <= 0
UNION ALL
-- ⑤ データが今日も届いているか（届いていなければ0件になる）
SELECT '本日の取り込み件数', COUNT(*) FROM ORDERS WHERE ORDER_DATE = CURRENT_DATE();