Home / Guides
Comparison

Snowflake vs Redshift vs BigQuery for Migrated Data

By · November 8, 2026 · 15 min read

The short version

Snowflake vs BigQuery vs Redshift, for data you have just migrated, comes down to two things: what you are billed for, and how much of your SQL survives the move. Snowflake bills credits for the time a warehouse runs, per second with a 60-second minimum. Redshift bills node-hours, or RPU-hours on Serverless with the same 60-second minimum. BigQuery on-demand bills the bytes each query reads: $6.25 per TiB after a free TiB a month (us-central1, as of October 2026). All three keep storage apart from compute, and none of them enforces a primary key or a unique constraint. When I put one PostgreSQL table through sqlglot, every dialect needed hand fixes, and the worst one was silent: numeric with no precision means three different things on the three platforms.

Snowflake vs BigQuery vs Redshift at a glance

Snowflake Redshift BigQuery
Storage and compute Separate; virtual warehouses over shared storage Separate on RA3 and RG nodes and Serverless (managed storage) Separate, columnar
Query billing Credits: warehouse size x run time Node-hours, or RPU-hours on Serverless Bytes read (on-demand), or slot-hours (editions)
Smallest charge 60 s each time a warehouse starts 60 s (Serverless) 10 MB per table referenced and per query
Bulk load PUT to a stage, then COPY INTO COPY from S3, EMR, DynamoDB or an SSH host Load job from Cloud Storage or a local file, or LOAD DATA
Exact decimal NUMBER, 38 digits, scale up to 37 DECIMAL, 38 digits, scale up to 37 NUMERIC (38, 9) or BIGNUMERIC (about 76.8, 38)
DECIMAL with no precision NUMBER(38,0) DECIMAL(18,0) NUMERIC, scale 9
Timestamp with time zone TIMESTAMP_LTZ or TIMESTAMP_TZ TIMESTAMPTZ, stored as UTC TIMESTAMP, an absolute instant
JSON VARIANT, up to 128 MB SUPER, up to 16 MB JSON
Arrays ARRAY (elements are VARIANT) Not supported; use SUPER ARRAY, no arrays of arrays
PK / UNIQUE enforced No (NOT NULL is) No (NOT NULL is) No

Sources for the rows: Snowflake architecture, Snowflake warehouses, Redshift clusters and managed storage, Redshift Serverless billing, BigQuery storage, BigQuery pricing, Snowflake NUMBER, Redshift numeric types, BigQuery data types, Snowflake semi-structured types, Redshift SUPER, Snowflake constraints, Redshift constraints, BigQuery keys.

How each one charges you

Snowflake: a credit is a unit of measure, and a warehouse burns credits for as long as it runs. An X-Small Standard warehouse uses 1 credit an hour, Small 2, Medium 4, Large 8, billed per second with a 60-second minimum each time it starts. A suspended warehouse uses no credits. The dollar price of a credit is not in Snowflake's documentation, which points to its pricing guide, so I quote none here. Storage is a flat rate per TB of compressed data.

Redshift: provisioned clusters bill per node. Serverless bills RPU-hours per second with a 60-second minimum, and storage separately by GB-month. Two traps from that page: a cancelled query is still billed for the time it ran, and connection-pool health checks such as SELECT 1 count as billable activity. The Redshift pricing page says base capacity runs from 4 to 1024 RPUs, and its worked example for US East (N. Virginia) uses $0.375 per RPU-hour (as of October 2026).

BigQuery on-demand: you pay for the data processed in the columns you select, even with a LIMIT, rounded up to the MB, with a 10 MB minimum per table referenced. Errors and cached results are free. The first TiB a month is free, then $6.25 per TiB in us-central1; Standard edition slots are $0.04 per slot-hour there, billed per second with a 1-minute minimum (both as of October 2026). Size is counted in logical bytes per type: 8 for INT64 and TIMESTAMP, 16 for NUMERIC, 1 for BOOL.

Loading the data

Snowflake loads from a stage: PUT the files into an internal stage, then COPY INTO the table. COPY INTO reads CSV, JSON, Avro, ORC, Parquet and XML, and by default aborts the whole statement when a file has an error.

Redshift's COPY loads from S3, EMR, DynamoDB or a host over SSH, and needs an IAM role. Two of its data conversion parameters matter for migrated money. By default COPY truncates extra decimal places, so 20.259 loads into DECIMAL(8,2) as 20.25, while INSERT rounds; add ROUNDEC to get INSERT's behaviour. And if you keep your source ids in an IDENTITY column, you need EXPLICIT_IDS, or Redshift generates new ones.

BigQuery runs a load job from Cloud Storage or a local file, in Avro, CSV, JSON, ORC or Parquet, or the LOAD DATA statement.

For the PostgreSQL side of this, export, file formats and the values that break a load, see PostgreSQL to Snowflake: Replication and Type Mapping.

One migrated table through sqlglot

A table that looks like what I get out of an order system: a bigserial key, money in numeric(12,2), an exchange rate in numeric with no precision, timestamptz, jsonb and a text[]. First I checked that the source DDL and the three queries run on PostgreSQL 16.14, with three test rows:

CREATE TABLE orders (
  id bigserial PRIMARY KEY,
  order_no varchar(20) NOT NULL UNIQUE,
  customer_id integer NOT NULL,
  amount numeric(12,2) NOT NULL,
  fx_rate numeric,
  created_at timestamptz NOT NULL DEFAULT now(),
  shipped_on date,
  is_paid boolean DEFAULT false,
  attrs jsonb,
  tags text[]
);
-- q1: monthly revenue
SELECT date_trunc('month', created_at) AS month, count(*) AS orders, sum(amount) AS revenue
FROM orders WHERE created_at >= now() - interval '90 days' AND is_paid
GROUP BY 1 ORDER BY 1;
-- q2: JSON fields
SELECT attrs->>'channel' AS channel, (attrs->'shipping'->>'cost')::numeric(10,2) AS ship_cost
FROM orders WHERE attrs ? 'coupon' AND order_no ILIKE 'web-%';
-- q3: latest order per customer
SELECT DISTINCT ON (customer_id) customer_id, order_no, amount, created_at
FROM orders ORDER BY customer_id, created_at DESC;
PostgreSQL 16.14 (Debian 16.14-1.pgdg13+1) on aarch64-unknown-linux-gnu ...
['channel', 'ship_cost']
('web', Decimal('4.99'))
('web', None)

The second q2 row is WEB-1002, whose attrs is {"channel":"web","coupon":null}. The ? operator asks whether the key exists, so a key holding JSON null counts. Keep that in mind for the rewrites.

Then the transpile, with sqlglot 30.17.0:

sqlglot.transpile(sql, read="postgres", write=d, pretty=True)  # d in snowflake, redshift, bigquery

The DDL, as it came out:

===== ddl -> snowflake
  id BIGSERIAL PRIMARY KEY,
  amount DECIMAL(12, 2) NOT NULL,
  fx_rate DECIMAL,
  created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP(),
  attrs JSONB,
  tags ARRAY
===== ddl -> redshift
  id BIGINT IDENTITY(1, 1) NOT NULL PRIMARY KEY,
  amount DECIMAL(12, 2) NOT NULL,
  fx_rate DECIMAL,
  created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT GETDATE(),
  attrs JSONB,
  tags VARCHAR(MAX)[]
===== ddl -> bigquery
  id BIGSERIAL PRIMARY KEY,
  order_no STRING(20) NOT NULL UNIQUE,
  amount NUMERIC(12, 2) NOT NULL,
  fx_rate NUMERIC,
  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP(),
  attrs JSONB,
  tags ARRAY<STRING>

(Unchanged columns trimmed.) Read against the docs:

The three queries after transpiling

q1 came through clean on Snowflake and Redshift (DATE_TRUNC('MONTH', created_at), INTERVAL '90 DAYS'). BigQuery's version:

SELECT
  TIMESTAMP_TRUNC(created_at, MONTH) AS month,
  ...
WHERE
  created_at >= CURRENT_TIMESTAMP() - INTERVAL '90' DAY AND is_paid
...
ORDER BY
  1 NULLS LAST

The NULLS LAST is sqlglot being careful: PostgreSQL sorts nulls last ascending, BigQuery sorts them first. What it cannot fix is the month boundary: TIMESTAMP_TRUNC uses UTC unless you pass a time zone, while PostgreSQL truncates in the session's zone. Orders placed late on the last evening of a month in New York land in the next month. Pass the zone as the third argument.

q2 is where all three broke:

===== q2 -> snowflake
  JSON_EXTRACT_PATH_TEXT(attrs, 'channel') AS channel,
  CAST((
    JSON_EXTRACT_PATH_TEXT(GET_PATH(PARSE_JSON(attrs), 'shipping'), 'cost')
  ) AS DECIMAL(10, 2)) AS ship_cost
WHERE
  JSONB_CONTAINS(attrs, 'coupon') AND order_no ILIKE 'web-%'
===== q2 -> redshift
  JSON_EXTRACT_PATH_TEXT(attrs, 'channel') AS channel,
  ...
WHERE
  attrs ? 'coupon' AND order_no ILIKE 'web-%'
===== q2 -> bigquery
  JSON_EXTRACT_SCALAR(attrs, '$.channel') AS channel,
  CAST((
    JSON_EXTRACT_SCALAR(JSON_EXTRACT(attrs, '$.shipping'), '$.cost')
  ) AS NUMERIC) AS ship_cost
WHERE
  JSONB_CONTAINS(attrs, 'coupon') AND LOWER(order_no) LIKE LOWER('web-%')

JSONB_CONTAINS exists on neither side: Snowflake's function reference returns 404 for it, and it is not in BigQuery's JSON function list. Redshift kept PostgreSQL's ? and used the text JSON functions, which take VARCHAR; with no JSON type, attrs has to become SUPER, and for SUPER AWS recommends path navigation over those functions. BigQuery got JSON_EXTRACT_SCALAR, which its docs mark deprecated in favour of JSON_VALUE. sqlglot also dropped the (10,2) from BigQuery's CAST, correctly: parameterized types are allowed only on columns and script variables.

q3 became the same ROW_NUMBER() subquery on all three, which works but is longer than it needs to be, since all three have QUALIFY:

    ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY customer_id, created_at DESC) AS _row_number
  FROM orders
) AS _t
WHERE
  _row_number = 1

The hand-fixed versions

These parse in sqlglot under each target dialect. I had no cloud accounts for this, so they have not run on the warehouses themselves; each line is backed by the page linked above or below.

-- Snowflake
CREATE TABLE orders (id NUMBER(19,0) NOT NULL PRIMARY KEY, order_no VARCHAR(20) NOT NULL UNIQUE,
  customer_id INT NOT NULL, amount NUMBER(12,2) NOT NULL, fx_rate NUMBER(38,12),
  created_at TIMESTAMP_LTZ NOT NULL DEFAULT CURRENT_TIMESTAMP(), shipped_on DATE,
  is_paid BOOLEAN DEFAULT FALSE, attrs VARIANT, tags ARRAY);
SELECT attrs:channel::VARCHAR AS channel, attrs:shipping.cost::NUMBER(10,2) AS ship_cost
FROM orders WHERE attrs:coupon IS NOT NULL AND order_no ILIKE 'web-%';
SELECT customer_id, order_no, amount, created_at FROM orders
QUALIFY ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY created_at DESC) = 1;

-- Redshift
CREATE TABLE orders (id BIGINT NOT NULL PRIMARY KEY, ..., fx_rate DECIMAL(38,12),
  created_at TIMESTAMPTZ NOT NULL DEFAULT GETDATE(), ..., attrs SUPER, tags SUPER);
SELECT o.attrs.channel::VARCHAR AS channel, o.attrs.shipping.cost::VARCHAR::DECIMAL(10,2) AS ship_cost
FROM orders o WHERE o.attrs.coupon IS NOT NULL AND o.order_no ILIKE 'web-%';
SELECT customer_id, order_no, amount, created_at FROM orders o
QUALIFY ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY created_at DESC) = 1;

-- BigQuery
CREATE TABLE mydataset.orders (id INT64 NOT NULL PRIMARY KEY NOT ENFORCED, order_no STRING(20) NOT NULL,
  ..., fx_rate BIGNUMERIC, created_at TIMESTAMP NOT NULL, ..., attrs JSON, tags ARRAY<STRING>)
PARTITION BY DATE(created_at);
SELECT JSON_VALUE(attrs, '$.channel') AS channel,
  CAST(JSON_VALUE(attrs, '$.shipping.cost') AS NUMERIC) AS ship_cost
FROM mydataset.orders WHERE JSON_QUERY(attrs, '$.coupon') IS NOT NULL AND LOWER(order_no) LIKE 'web-%';
SELECT customer_id, order_no, amount, created_at FROM mydataset.orders
QUALIFY ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY created_at DESC) = 1;

Why each choice:

Is Snowflake worth it? A cost-shape calculation

This is illustrative, not a quote. It shows how the billing units react to one workload: q1 refreshing a dashboard every 5 minutes for 30 days on a 50-million-row table, each run alone in its minute. BigQuery reads 25 bytes a row for q1's three columns. For the partitioned case I assumed five years of evenly spread rows, so 90 days is about 5% of the table. The Snowflake numbers are credits because the docs do not give a credit price.

q1 full scan: 1,250,000,000 bytes = 1.16 GiB
BigQuery on-demand: 8640 runs x 1.16 GiB = 9.82 TiB, billed 8.82 TiB after the free 1 TiB = $55.14
  partitioned by DATE(created_at): 0.057 GiB per run, 0.48 TiB, $0.00
Snowflake X-Small, resumes for every run (60 s minimum): 144 credits
Snowflake X-Small, never suspends: 720 credits
Redshift Serverless 4 RPU base, 60 s minimum per run: 576 RPU-hours = $216.00

The shape is what matters. On BigQuery, the bill follows bytes, so partitioning took this workload from $55 to inside the free tier while the run time did not change. On Snowflake and Redshift Serverless, the bill follows time, so the 60-second minimum dominates short, frequent queries, and table size barely moves it. A heavy query that runs for an hour once a month inverts all of this.

Which one for migrated data

If your queries are frequent, small and predictable, the time-billed platforms are easier to cap: a fixed warehouse or a base RPU setting is a ceiling you choose. If they are occasional and you can partition, BigQuery on-demand can cost very little; one careless SELECT * on a wide table is billed in full. If your SQL is PostgreSQL and you want the least rewriting, Redshift's dialect is the closest of the three, minus arrays and JSON. Snowflake and BigQuery both have a JSON type and real arrays; Redshift folds both into SUPER. For the Snowflake route, the type mapping and load steps are in the PostgreSQL to Snowflake guide, and if you would rather hand it over, see PostgreSQL to Snowflake migration.

Sources