Snowflake wrapper does not quote identifiers, causing failures with mixed-case column names

[mattgranado]

Bug Description

The Snowflake wrapper does not quote column identifiers when generating SQL queries, which causes query failures when Snowflake tables/views have mixed-case column names.

Current Behavior

When I query a foreign table mapped to a Snowflake view with mixed-case columns like "PK_Well" or "API Number", I get this error:

ERROR: HV000: guest fdw error: HTTP status error (422 Unprocessable Entity)

Checking Snowflake's query history shows:
SQL compilation error: error line 1 at position 7 invalid identifier 'PK_WELL'

The wrapper is generating unquoted SQL:

SELECT PK_Well FROM TABLE

Which Snowflake uppercases to:
SELECT PK_WELL FROM TABLE  -- Error: column is actually "PK_Well"

Expected Behavior

The wrapper should quote identifiers to preserve case:
SELECT "PK_Well" FROM TABLE

This is how Snowflake handles mixed-case identifiers: https://docs.snowflake.com/en/sql-reference/identifiers-syntax

Reproduction

  1. Create Snowflake view with mixed-case columns:
  CREATE VIEW SCHEMA.VIEW AS
  SELECT COLUMN1 as "PK_Well", COLUMN2 as "API Number" FROM SOURCE;

  2. Create foreign table in Supabase:
  CREATE FOREIGN TABLE snowflake.my_view (
    "PK_Well" bigint,
    "API Number" text
  ) SERVER snowflake_server OPTIONS (table 'SCHEMA.VIEW');

  3. Query fails:
  SELECT * FROM snowflake.my_view LIMIT 1;
  -- ERROR: invalid identifier 'PK_WELL'

Root Cause

In wasm-wrappers/fdw/snowflake_fdw/src/lib.rs, the deparse() method doesn't quote identifiers:

  columns.iter()
      .map(|c| c.name())  // ← No quotes
      .collect::<Vec<String>>()
      .join(", ")

Proposed Fix

  Quote column identifiers:
  columns.iter()
      .map(|c| format!("\"{}\"", c.name()))
      .collect::<Vec<String>>()
      .join(", ")

Also quote table names, WHERE clause columns, and ORDER BY columns.

Impact

This affects Snowflake shared databases and data marketplace providers that use mixed-case column names (very common). Currently unusable for these cases.

Workaround

Create uppercase views in Snowflake, but this is impractical for 100+ column tables from third-party data providers.

Environment

• Supabase Wrappers: Latest (Wasm FDW)
• Snowflake: SQL API v2
• Auth: JWT key-pair

I'm willing to submit a PR to fix this if the maintainers agree with the approach. The fix would involve:

1. Quoting column identifiers in the deparse() method
2. Quoting table names in the OPTIONS
3. Quoting identifiers in WHERE/ORDER BY pushdown logic
4. Adding tests for mixed-case identifiers

[pragatidh]

From what I can tell the problem comes down to one core issue
the wrapper never quotes identifiers so Snowflake automatically uppercases them and the query fails whenever the original column names use mixed case to fix this cleanly here’s the approach I’d follow:

1. Quote every identifier during SQL generation

Snowflake only preserves case when identifiers are wrapped in double quotes
so the deparser should output "PK_Well" instead of PK_Well.
This applies to:
column lists, table names, aliases
this alone prevents Snowflake from silently uppercasing everything

2. Apply the same quoting logic in WHERE, ORDER BY, and any pushdowns

Even if the SELECT list is quoted queries will still break if WHERE or ORDER BY references appear unquoted
so the wrapper needs consistent quoting across all SQL fragments to avoid “invalid identifier” errors

3. Add a test case using a Snowflake view with mixed case columns

just create a simple view like "PK_Well" and "API Number" and confirm the generated SQL stays valid
this ensures the fix doesn’t regress in future updates

4. It's optional: also quote table names defined in OPTIONS

some Snowflake schemas or providers use mixed case table or view names too so quoting these avoids edge case failures

[mattgranado]

Thanks for the detailed breakdown! That matches exactly what I found in the source code.

I checked wasm-wrappers/fdw/snowflake_fdw/src/lib.rs and confirmed the deparse() method doesn't quote any identifiers. This is especially problematic with Snowflake shared databases and data
marketplace providers that commonly use mixed-case column names.

Your approach makes perfect sense:

1. ✅ Quote column identifiers - Essential fix
2. ✅ Quote in WHERE/ORDER BY - I can confirm WHERE clauses are also failing with "invalid identifier" errors
3. ✅ Add test case - I have a real-world example with 170 mixed-case columns from a data share
4. ✅ Quote table names - Good catch, some schemas do use mixed-case table/view names

Current workaround: I'm creating a duplicate view in Snowflake with all columns aliased to UPPERCASE, but this is impractical for large third-party datasets and defeats the purpose of the FDW.

Real-world impact: This affects any Snowflake Secure Share or Data Marketplace dataset with mixed-case columns, which is very common in the Snowflake ecosystem.

Would the maintainers be open to a PR implementing this fix? I've done 'hello_world' in Rust, but that's it ha. Happy to try and contribute if it helps move this forward.