pg_ lake¶
pg_lake is a Postgres extension that enables selective data movement between Postgres and object storage formats like Parquet and Iceberg. With pg_lake, you can create Iceberg tables directly in Postgres, sync data to Snowflake, and exchange files between Snowflake Postgres and Snowflake.
Snowflake Postgres supports three primary patterns for data movement with pg_lake, each using a different integration type.
- Shared Iceberg: Postgres writes Iceberg tables and Snowflake reads them through a catalog integration. Storage is managed automatically. No external cloud storage is needed.
- Stages: A managed storage area that enables bidirectional file exchange between Snowflake Postgres and Snowflake through Snowflake stages.
- Customer-managed cloud storage: You provide your own S3 bucket or Azure Blob Storage container and configure access through a storage integration. Postgres can write files and Iceberg tables to this location.
| Pattern | Integration type | Writes | Reads | File formats |
|---|---|---|---|---|
| Shared Iceberg | Catalog integration | PG → SF | SF only | Parquet (Iceberg tables) |
| Stages | Postgres internal storage integration | PG → SF, SF → PG | PG and SF | Parquet, CSV, JSON, and other formats supported by pg_lake |
| Customer-managed cloud storage | Postgres external storage integration | PG → SF, SF → PG | PG and SF | Parquet, CSV, JSON, and other formats supported by pg_lake |
Instance requirements¶
Data movement with pg_lake requires a STANDARD or HIGH MEMORY instance tier. BURSTABLE instances aren’t supported.
Warning
Do not downgrade a Postgres instance using pg_lake from a higher tier to BURSTABLE if data movement is still configured. If you do downgrade an instance, you will need to remove the tables in object storage first. Downgrading without cleanup may result in loss of data stored in object storage.
Shared Iceberg¶
With shared Iceberg, Postgres acts as the Iceberg catalog and Snowflake reads the tables through a catalog integration. Storage is handled by Snowflake, so you don’t need to configure a cloud storage bucket, IAM roles, or storage integrations. You also don’t need to create an external volume: Snowflake Postgres catalog integrations use vended credentials to access table data and metadata automatically.
This is the simplest way to make Postgres data available in Snowflake for analytics.
Considerations:
- Tables created through a Snowflake Postgres catalog integration are read-only in Snowflake.
- Auto-refresh uses metadata polling. Change notifications aren’t supported.
ACCESS_DELEGATION_MODEmust be set toVENDED_CREDENTIALS. TheEXTERNAL_VOLUME_CREDENTIALSmode isn’t supported.- Snowflake handles authentication with the Postgres instance automatically. You don’t need to
specify
REST_AUTHENTICATION.
Requirements¶
The role that creates the catalog integration must have CREATE INTEGRATION on the account and
USAGE on the Postgres instance. For full access control details, see
CREATE CATALOG INTEGRATION (Snowflake Postgres).
Set up shared Iceberg¶
-
Connect to your Postgres instance and enable the pg_lake extension:
-
Create an Iceberg table in Postgres or copy data to this Iceberg table:
-
In Snowflake, create a catalog integration that points to your Postgres instance:
-
Create an Iceberg table in Snowflake that references the Postgres table:
You can optionally specify:
CATALOG_NAMESPACE: The Postgres schema containing the table. Defaults to the value set on the catalog integration.CATALOG_NAME: The Postgres database containing the table. Defaults to the value set on the catalog integration.AUTO_REFRESH = TRUE: Enables automatic metadata refresh by polling.
You don’t need to specify an
EXTERNAL_VOLUME. -
Query the data in Snowflake:
Catalog-linked databases¶
Instead of creating individual Iceberg tables, you can create a catalog-linked database that automatically discovers and syncs tables from your Postgres database:
Snowflake automatically discovers namespaces and tables from the Postgres database and creates
corresponding schemas and Iceberg tables. ALLOWED_WRITE_OPERATIONS = NONE is required because
Postgres-managed Iceberg tables are read-only in Snowflake. For more information, see
Use a catalog-linked database for Apache Iceberg™ tables.
Access control¶
To let other roles create Iceberg tables using the catalog integration, grant USAGE on the
integration along with the standard Snowflake privileges for creating tables:
No additional grants on the Postgres instance are required beyond the initial USAGE grant
to the catalog integration owner.
Refresh and auto-refresh¶
Snowflake reads Iceberg metadata from the Postgres catalog. Because the table is externally managed, you can refresh the data manually or enable automatic refresh.
To pull the latest data immediately, run a manual refresh:
To enable continuous automatic refresh:
You can configure how often Snowflake polls for changes on the catalog integration:
For a complete walkthrough, see the guide Sync Data from Snowflake Postgres to Snowflake with Iceberg and pg_lake.
Incremental sync with pg_ incremental¶
The guide above uses pg_incremental, a Postgres extension that tracks a watermark (a sequence
value or timestamp) so that each sync run exports only the rows added since the previous run,
rather than re-exporting the entire table each time. pg_incremental depends on pg_cron,
which provides the periodic scheduler that drives pipeline execution. Both extensions are
available in Snowflake Postgres. For more information, see Extensions.
Warning
Ensure that there is an index on the column that pg_incremental uses as its watermark before creating the
pipeline. Without an index, the pipeline performs a full sequential scan on every run, which
can’t keep up with sustained high-throughput workloads.
BRIN indexes are recommended as they are highly effective in selecting new ranges.
For a sequence pipeline (recommended for append-only event or IoT data):
For a time interval pipeline:
BRIN indexes are very lightweight and particularly effective when rows are inserted in roughly sequential order, which is typical for time-series and IoT workloads.
Stages¶
Postgres stages provide a managed storage area for bidirectional file exchange between Snowflake Postgres and Snowflake. You can copy files from Postgres to a Snowflake stage, or put files in a stage from Snowflake and read them from Postgres.
A Snowflake Postgres internal storage integration allows you to read from and write to the managed storage associated with a Snowflake Postgres instance. This enables seamless data movement between Snowflake and your Postgres instances using an external stage. For the full SQL syntax, see CREATE STORAGE INTEGRATION (Postgres Internal Storage).
Considerations¶
- Stage restrictions: When creating a stage (see CREATE STAGE)
that uses a Postgres internal storage integration, the
URL,ENCRYPTION, andDIRECTORYstage properties are disallowed. - Path configuration: The integration automatically appends a
/filessubpath to the base storage location retrieved from the Postgres instance.
Set up a Postgres stage¶
-
In Snowflake, create a
POSTGRES_INTERNAL_STORAGEstorage integration that references your Postgres instance:Where:
TYPE = POSTGRES_INTERNAL_STORAGE: Specifies the integration type for Postgres managed storage. Required.POSTGRES_INSTANCE = '<instance_name>': Specifies the name of the Snowflake Postgres instance. Required.
-
Create a Snowflake stage that uses the integration. Use the
RELATIVE_URLproperty to specify a user-chosen path prefix under the Postgres managed storage: -
Connect to your Postgres instance and enable the pg_lake extension:
You can now exchange files between Postgres and Snowflake through the stage. Use standard Snowflake stage operations (LIST, GET, PUT) on the Snowflake side, and pg_lake file operations on the Postgres side.
Move data between Snowflake and Postgres¶
You can use the COPY FILES command to move data between Snowflake stages and your Postgres
managed storage. These examples assume you have already created a separate Snowflake stage
in addition to the Postgres stage created above.
Snowflake to Postgres (write)
To move data from an existing Snowflake stage into the Postgres managed storage:
Where <source_stage> refers to a pre-existing Snowflake stage that contains the files you want
to move, and <postgres_stage> is the Postgres stage created in the previous step.
On the Postgres side, you can then load the data:
Where @STAGE is a preconfigured placeholder for the stage location on the Postgres side.
Postgres to Snowflake (read)
To move data written by Postgres back into an existing Snowflake stage:
Where <destination_stage> refers to a pre-existing Snowflake stage where you want to copy
the files, and <postgres_stage> is the Postgres stage created earlier.
Access control for stages¶
- Creating the integration: The role that creates the storage integration must have
OWNERSHIPon the Postgres instance andCREATE INTEGRATIONon the account. - Usage: To use the integration to create a stage, a role must have the
USAGEprivilege on the integration object. - Stage privileges: Users need standard privileges (for example,
READ,WRITE) on the stage itself to perform data movement operations.
For example, to grant another role the ability to create stages using the storage integration:
Customer-managed cloud storage¶
If you need to use your own S3 bucket or Azure Blob Storage container, you can configure pg_lake to read and write files and Iceberg tables to your storage location. Using customer-managed storage requires two storage integrations:
| Integration type | Purpose |
|---|---|
POSTGRES_EXTERNAL_STORAGE | Gives pg_lake (Postgres side) read/write access to your storage |
EXTERNAL_STAGE | Gives Snowflake SQL access to the same storage location |
Both integrations can share the same IAM role (S3) or storage container permissions (Azure), but both must be granted access explicitly.
Jump to setup instructions: Amazon S3 | Azure Blob Storage
Prerequisites¶
Before configuring customer-managed cloud storage for pg_lake, ensure that you have:
- A Snowflake Postgres instance with pg_lake support.
- Privileges to create storage integrations in Snowflake (requires ACCOUNTADMIN role or a role with the CREATE INTEGRATION privilege on the account).
- A storage container or bucket in the same region as your Snowflake account. To determine your Snowflake account region, execute the following query in Snowflake (not on your Postgres instance):
For S3:
- An active AWS account with permissions to create and manage S3 buckets and IAM roles.
- Familiarity with AWS IAM roles and policies.
For Azure Blob Storage:
- An active Azure account with permissions to create storage accounts and containers, and to assign Azure RBAC roles.
- Your Azure tenant ID. To find it, sign in to the Azure portal, select Microsoft Entra ID, then Properties. The tenant ID appears in the Tenant ID field.
Set up S3 storage¶
Create an S3 bucket¶
If you don’t already have one, create an S3 bucket in the same AWS region as your Snowflake account.
For example, if your Snowflake account is in us-west-2, create the S3 bucket in the
us-west-2 region.
See the AWS documentation for instructions on creating an S3 bucket.
Create an IAM policy for S3 access¶
Create an IAM policy that grants the necessary permissions for pg_lake to read from and write to your S3 bucket:
-
Sign in to the AWS Management Console and navigate to the IAM service.
-
From the left-hand navigation pane, select Account settings.
-
Under Security Token Service (STS) in the Endpoints list, find the Snowflake region where your account is located. If the STS status is inactive, move the toggle to Active. For more information, see Activating and deactivating AWS STS in an AWS region.
-
From the left-hand navigation pane, select Policies, then choose Create policy.
-
For Policy editor, select JSON.
-
Add a policy document that allows Snowflake to access the S3 bucket and folder. Replace
bucket_nameandprefixwith your actual bucket name and folder path prefix:This policy provides permissions to:
- Read, write, and delete objects in the specified S3 path
- List bucket contents and retrieve bucket location
- Support pg_lake’s ability to create and manage Iceberg tables
-
Choose Next.
-
Enter a policy name (for example,
snowflake_pg_lake_access) and an optional description. -
Choose Create policy.
Create an IAM role¶
Create an IAM role that Snowflake will assume to access your S3 bucket.
- From the left-hand navigation pane in the Identity and Access Management (IAM) Dashboard, select Roles.
- Select Create role.
- Select AWS account as the trusted entity type.
- Select Another AWS account.
- In the Account ID field, enter your own AWS account ID temporarily. You will modify the trust relationship in a later step to grant access to Snowflake.
- Select the Require external ID option. Enter a placeholder external ID such as
0000. You will update this with the actual external ID generated by Snowflake in a later step. An external ID is used to grant access to your AWS resources (such as S3 buckets) to a third party like Snowflake. For more information, see How to use an external ID when granting access to your AWS resources to a third party. - Select Next.
- Search for and select the policy you created in Create an IAM policy for S3 access.
- Select Next.
- Enter a name and description for the role (for example,
snowflake_pg_lake_role), then select Create role. - On the role summary page, locate and record the Role ARN value. You will need this when creating the storage integration in Snowflake.
- While on the role summary page, select Edit in the summary section and change the
Maximum session duration to
12 hours. Select Save changes. For more information, see Modifying a role maximum session duration (AWS).
Create a storage integration in Snowflake¶
Create a storage integration object in Snowflake that references the IAM role you created. For the full command syntax, see CREATE STORAGE INTEGRATION.
Where:
my_pg_lake_integrationis the name you choose for the storage integration.TYPE = POSTGRES_EXTERNAL_STORAGEspecifies that this integration is for use with Snowflake Postgres.STORAGE_AWS_ROLE_ARNis the Role ARN you recorded in Create an IAM role.STORAGE_ALLOWED_LOCATIONSspecifies the S3 bucket and path prefix. Replacemy-bucketandmy-prefixwith the bucket name and folder path you created in Create an S3 bucket. Note that only one location is allowed for Postgres storage integrations.
Retrieve the Snowflake IAM user ARN and external ID¶
After creating the storage integration, use the DESCRIBE INTEGRATION command to retrieve the AWS IAM user and external ID that Snowflake generated for this integration:
In the output, locate and record the following values:
STORAGE_AWS_IAM_USER_ARN: The IAM user ARN that Snowflake will use to assume the roleSTORAGE_AWS_EXTERNAL_ID: The external ID to use in the trust policy
You will use these values in the next step to configure the IAM role trust policy.
Update the IAM role trust policy¶
Update the trust policy of the IAM role you created in Create an IAM role to allow Snowflake to assume the role:
-
Sign in to the AWS Management Console and navigate to the IAM service.
-
From the left-hand navigation pane, select Roles.
-
Select the role you created in Create an IAM role.
-
Select the Trust relationships tab.
-
Select Edit trust policy.
-
Replace the policy document with the following text:
Replace the placeholder values with the values you recorded in Retrieve the Snowflake IAM user ARN and external ID:
- Replace
storage_aws_iam_user_arnwith theSTORAGE_AWS_IAM_USER_ARNvalue. This is a full ARN in the formarn:aws:iam::<account_id>:user/snowflake-postgres-integration-management, where the username is always the same and only the AWS account ID varies. - Replace
storage_aws_external_idwith theSTORAGE_AWS_EXTERNAL_IDvalue.
- Replace
-
Select Update policy to save the changes.
Set up Azure Blob Storage¶
Create an Azure Blob Storage container¶
If you don’t already have one, create an Azure Blob Storage container in the same Azure region
as your Snowflake account. For example, if your Snowflake account is in eastus, create the
container in the eastus region.
See the Azure documentation for instructions on creating a storage container.
Create a storage integration in Snowflake¶
Create a storage integration object in Snowflake that references your Azure tenant and container. For the full command syntax, see CREATE STORAGE INTEGRATION.
Where:
my_pg_lake_integrationis the name you choose for the storage integration.TYPE = POSTGRES_EXTERNAL_STORAGEspecifies that this integration is for use with Snowflake Postgres.AZURE_TENANT_IDis the tenant ID you located in Prerequisites.STORAGE_ALLOWED_LOCATIONSspecifies your container and path prefix using theazure://scheme. Replacemyaccount,mycontainer, andmypathwith your actual values. Use theblob.core.windows.netendpoint for all Azure Blob Storage account types, including Azure Data Lake Storage Gen2. pg_lake file operations and Iceberg table locations must use this sameazure://form. Snowflake cannot read Iceberg tables whose metadata recordsaz://paths. Note that only one location is allowed for Postgres storage integrations.
Grant Snowflake access to Azure storage¶
After creating the storage integration, you must grant Snowflake’s service principal access to your storage container.
Step 1: Retrieve the consent URL
Use the DESCRIBE INTEGRATION command to retrieve the values you need:
In the output, locate and record:
AZURE_CONSENT_URL: The URL an Azure admin must visit to grant Snowflake access to your tenant.AZURE_MULTI_TENANT_APP_NAME: The name of the Snowflake service principal registered in your tenant after consent is granted. ForPOSTGRES_EXTERNAL_STORAGEintegrations, the name has the form<deployment>-postgres-sp. Use the full name when you search for it in the Azure portal.
Step 2: Grant consent
- Open
AZURE_CONSENT_URLin a browser while signed in as a user who can grant consent to applications in your tenant. Depending on your tenant’s consent settings, this may require a Microsoft Entra ID administrator. - Review the permissions that Snowflake requests and select Accept. This registers the Snowflake service principal in your tenant.
Step 3: Assign the Storage Blob Data Contributor role
Grant the Snowflake service principal read and write access to your storage account. Assign the role on the storage account, not on an individual container. Snowflake Postgres requests a user delegation key from Azure, and Azure only allows that when the role is assigned at the storage account level or higher. With a container-level assignment, pg_lake cannot access the container.
- Sign in to the Azure portal and navigate to your storage account.
- Select Access Control (IAM), then Add role assignment.
- Select the Storage Blob Data Contributor role and select Next.
- Under Assign access to, select User, group, or service principal, then Select members.
- Search for the Snowflake service principal using the full
AZURE_MULTI_TENANT_APP_NAMEvalue. - Select the principal and complete the role assignment.
Attach the storage integration to your Postgres instance¶
Attach the storage integration to your Snowflake Postgres instance. When the storage integration is attached, the storage credentials are automatically synchronized to the Postgres control plane and made available to pg_lake:
You can also specify the storage integration when creating a new Postgres instance:
To remove a storage integration from a Postgres instance:
Connect Snowflake to your storage¶
After attaching the Postgres-side integration, create a second storage integration of type
EXTERNAL_STAGE so that Snowflake SQL can read the files and Iceberg tables that pg_lake writes
to your storage. Both integrations can share the same IAM role (S3) or storage account
permissions (Azure), but each one must be granted access separately. For S3, the
POSTGRES_EXTERNAL_STORAGE integration uses the Snowflake Postgres IAM user, while the
EXTERNAL_STAGE integration (and any external volume) uses your Snowflake account’s IAM user,
each with its own external ID. For Azure, each integration type uses a different Snowflake
application, each with its own service principal.
For Amazon S3¶
Create an EXTERNAL_STAGE integration in Snowflake using the same IAM role as the
POSTGRES_EXTERNAL_STORAGE integration:
Retrieve the IAM principal and external ID for this new integration:
Record the values for STORAGE_AWS_IAM_USER_ARN and STORAGE_AWS_EXTERNAL_ID, then update
the IAM role’s trust policy to include a second statement for this integration alongside the
existing statement for the POSTGRES_EXTERNAL_STORAGE integration:
If you also create an external volume
on the same location so that Snowflake can read Iceberg tables, run DESCRIBE EXTERNAL VOLUME
and add a third statement for its STORAGE_AWS_IAM_USER_ARN and STORAGE_AWS_EXTERNAL_ID. The
external volume has its own external ID, even when it uses the same IAM user as the
EXTERNAL_STAGE integration.
Then create an external stage in Snowflake pointing at the same location:
For Azure Blob Storage¶
Create an EXTERNAL_STAGE integration in Snowflake for the same container:
Retrieve the consent URL and service principal name:
Record the values for AZURE_CONSENT_URL and AZURE_MULTI_TENANT_APP_NAME, then:
-
Open
AZURE_CONSENT_URLin a browser and grant consent. TheEXTERNAL_STAGEintegration registers a different service principal from thePOSTGRES_EXTERNAL_STORAGEintegration, so you must grant consent for this application as well. -
In the Azure portal, assign the Storage Blob Data Contributor role on your storage account to this service principal.
EXTERNAL_STAGEnames typically include an underscore; search for the portion ofAZURE_MULTI_TENANT_APP_NAMEbefore the underscore.This role assignment is in addition to the one for the
POSTGRES_EXTERNAL_STORAGEintegration. If you also create an external volume on the same container so that Snowflake can read Iceberg tables, the volume uses the same service principal as thisEXTERNAL_STAGEintegration, so one consent covers both. Reading Iceberg tables through the external volume requires a user delegation key, which Azure only allows when the role is assigned at the storage account level or higher. A container-level assignment is enough for the stage, but Iceberg reads then fail withAuthorizationPermissionMismatch.
Then create an external stage in Snowflake pointing at the same container:
You can now query files that pg_lake writes to your storage directly from Snowflake SQL using
this stage. To query Iceberg tables from Snowflake, configure an external volume and a
catalog integration for files in object storage
that point at the same container. Iceberg metadata written by pg_lake must use azure://
paths; Snowflake rejects Iceberg tables whose metadata records az:// file paths.
Configure and use pg_ lake¶
After attaching the storage integration, connect to your Postgres instance and configure pg_lake. For a list of available extensions, see Snowflake Postgres Extensions.
-
Create the pg_lake extension:
-
Create Iceberg tables in your customer-managed storage by specifying a location on each table.
Without a location,
CREATE TABLE ... USING icebergwrites to Snowflake-managed storage and does not use your S3 bucket or Azure container, even when a storage integration is attached. This is the case whetherpg_lake_iceberg.default_catalogisobject_store(the Snowflake Postgres default) orpostgres. You cannot changepg_lake_iceberg.default_location_prefixwithSETorALTER DATABASE.Use a path under your storage integration’s
STORAGE_ALLOWED_LOCATIONS, and give each table its own path. The location must be empty when you create the table. For S3:For Azure Blob Storage, use the
azure://scheme and theblob.core.windows.netendpoint. Do not use theaz://short form; Snowflake cannot read Iceberg tables whose metadata recordsaz://paths: -
Verify that the storage integration is configured correctly by listing the contents of your storage location. Use
**to include files in subdirectories. A single*matches only files in that directory, not nested Iceberg table files. For S3:For Azure Blob Storage:
If the configuration is correct, this query returns a list of files at that location. If the storage location is empty, the query returns an empty result set without an error.
-
Verify the end-to-end configuration by creating an Iceberg table in customer-managed storage, inserting data, and querying it back. For S3, use an
s3://location as in step 2. For Azure Blob Storage:If this succeeds, pg_lake can read from and write to your storage location. To confirm, list the table’s location and check that the new files are there:
For a complete walkthrough using customer-managed S3 with pg_lake, see the guide Bidirectional Data Pipelines with pg_lake and Snowflake.
Security considerations¶
S3¶
- Use IAM roles: Snowflake Postgres uses IAM role assumption rather than static credentials, providing better security through temporary credentials and automatic credential rotation.
- Limit IAM permissions: Grant only the minimum necessary permissions to the S3 bucket paths that pg_lake needs to access. The IAM policy should restrict access to specific bucket prefixes.
- Monitor external ID: The external ID in the trust policy ensures that only your Snowflake account can assume the IAM role.
- Review storage integration changes: Any updates to the storage integration’s
STORAGE_AWS_ROLE_ARNorSTORAGE_ALLOWED_LOCATIONSare automatically synchronized to the Postgres instance. - Use bucket policies: Consider using S3 bucket policies in addition to IAM policies for defense in depth.
- Enable S3 access logging: Enable access logging on your S3 bucket to monitor and audit access patterns.
- Regional alignment: Ensure your S3 bucket is in the same AWS region as your Snowflake account for optimal performance and to meet data residency requirements.
Azure Blob Storage¶
- Use RBAC roles: Snowflake Postgres doesn’t use storage account keys. It authenticates to your tenant as a Snowflake multi-tenant application, using the role assigned to its service principal, and gives your instance a short-lived shared access signature (SAS) for the container. The SAS expires within 7 days and is renewed automatically.
- Limit role scope: The
POSTGRES_EXTERNAL_STORAGEservice principal needs the Storage Blob Data Contributor role on the storage account, because Snowflake Postgres requests a user delegation key. TheEXTERNAL_STAGEservice principal needs the same storage account assignment if Snowflake reads Iceberg tables through an external volume; for stage access alone, a container-level assignment is enough. To limit what these principals can reach, keep the data pg_lake uses in a dedicated storage account. - One tenant per integration: A
POSTGRES_EXTERNAL_STORAGEintegration can authenticate to only one Azure tenant. All paths inSTORAGE_ALLOWED_LOCATIONSmust belong to storage accounts in the same tenant. - Review storage integration changes: Any updates to the integration’s
AZURE_TENANT_IDorSTORAGE_ALLOWED_LOCATIONSare automatically synchronized to the Postgres instance. - Use
azure://paths: In pg_lake, list, copy, and Iceberg locations must use theazure://<account>.blob.core.windows.net/<container>/form fromSTORAGE_ALLOWED_LOCATIONS. Iceberg metadata that recordsaz://paths is not readable from Snowflake. - Regional alignment: Ensure your Azure Blob Storage container is in the same Azure region as your Snowflake account for optimal performance and to meet data residency requirements.
Support for spatial types¶
Geometry and geography columns move from Postgres to Iceberg in the form of “well-known binary” BYTE columns. To work with them using Snowflake spatial functionality, once the data is in Iceberg, use the ST_GeometryFromWKB or ST_GeographyFromWKB functions to convert the raw bytes into a Geometry or Geography object Snowflake can use.
Note that if your Postgres Geometry column contains specialized types like CircularString or CurvePolygon, Snowflake will not be able to read them from the Iceberg table, as Snowflake supports Point, LineString, and Polygon only.
Related information¶
- Sync Data from Snowflake Postgres to Snowflake with Iceberg and pg_lake — Step-by-step developer guide with incremental sync using pg_incremental
- Bidirectional Data Movement between SPG and SF with pg_lake - Internal Stage — End-to-end quickstart using internal stages and pg_lake
- Bidirectional Data Movement between SPG and SF with pg_lake - External Stage — End-to-end quickstart using customer-managed S3, pg_lake, and Snowflake Cortex for IoT anomaly detection
- Option 1: Configure a Snowflake storage integration to access Amazon S3 — Similar S3 access workflow to the one described in this topic
- Apache Iceberg™ tables — Overview of Iceberg table support in Snowflake
- Create an Apache Iceberg™ table in Snowflake — Creating Iceberg tables from different catalog sources
- Configure an external volume — Configuring an external volume for Iceberg tables
- Configure a catalog integration for files in object storage — Catalog integration setup for files in object storage
- pg_lake extension documentation