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 |
| 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:
fx_rate DECIMALis the silent one. In Snowflake that is NUMBER(38,0), in Redshift DECIMAL(18,0), in BigQuery NUMERIC with scale 9. PostgreSQL's barenumericis unconstrained. A rate of 1.0837512 loses all its decimals on two platforms, and through a default Redshift COPY it is truncated rather than rounded. Measure the real scale and write it out.JSONBandBIGSERIALare not types on Snowflake or BigQuery, and Redshift lists JSON, arrays and BIGSERIAL as unsupported PostgreSQL types, soVARCHAR(MAX)[]fails too.- Snowflake's
TIMESTAMPTZis an alias of TIMESTAMP_TZ, which keeps the offset. For PostgreSQLtimestamptzI use TIMESTAMP_LTZ, stored as UTC and shown in the session zone. - BigQuery kept
UNIQUEand a barePRIMARY KEY. Its docs show keys declaredNOT ENFORCEDand say BigQuery does not enforce them; the page says nothing about UNIQUE.
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:
- The id is a plain integer everywhere. Migrated rows keep their source ids, and Snowflake's AUTOINCREMENT or Redshift's IDENTITY only matter for rows created after the move.
- Snowflake walks VARIANT with colon and dot paths and casts with
::; element names are case-sensitive. A missing key comes back as SQL NULL, while a JSON null is stored as a VARIANT "null", soIS NOT NULLmatches PostgreSQL's?on theWEB-1002row. - BigQuery's
JSON_QUERYbehaves the same way: JSON null for a present key, SQL NULL for a missing one. - Redshift SUPER navigation returns NULL for a missing attribute instead of failing, and a cast to the wrong type also returns NULL. That is why I go through VARCHAR before DECIMAL. Whether a JSON null counts as present I could not confirm from the docs; test it on your data.
- Redshift's QUALIFY needs an alias on the table when it follows FROM directly. Snowflake and BigQuery need none.
DISTINCT ONitself is a PostgreSQL extension. - BigQuery's
PARTITION BY DATE(created_at)is there for cost: a filter on the partitioning column prunes partitions and cuts bytes read.
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
- Snowflake: key concepts and architecture
- Snowflake: overview of warehouses
- Snowflake: understanding compute cost
- Snowflake: understanding storage cost
- Snowflake: loading from a local file system
- Snowflake: COPY INTO table
- Snowflake: numeric data types
- Snowflake: date and time data types
- Snowflake: semi-structured data types
- Snowflake: summary of data types
- Snowflake: CREATE TABLE
- Snowflake: constraints
- Snowflake: querying semi-structured data
- Snowflake: semi-structured data considerations
- Snowflake: QUALIFY
- Amazon Redshift provisioned clusters
- Billing for Amazon Redshift Serverless
- Amazon Redshift pricing
- Redshift: COPY
- Redshift: COPY data conversion parameters
- Redshift: numeric types
- Redshift: SUPER type
- Redshift: querying semi-structured data
- Redshift: JSON functions
- Redshift: unsupported PostgreSQL data types
- Redshift: table constraints
- Redshift: QUALIFY clause
- BigQuery pricing
- BigQuery: storage overview
- BigQuery: data types
- BigQuery: JSON functions
- BigQuery: query syntax
- BigQuery: timestamp functions
- BigQuery: primary and foreign keys
- BigQuery: introduction to loading data
- BigQuery: partitioned tables
- PostgreSQL: numeric types
- PostgreSQL: JSON functions and operators
- PostgreSQL: sorting rows
- PostgreSQL: SELECT