1. Packages
  2. Packages
  3. Databricks Provider
  4. API Docs
  5. PostgresSyncedTable
Viewing docs for Databricks v1.92.0
published on Tuesday, May 12, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-databricks

databricks.PostgresSyncedTable

databricks logo
Viewing docs for Databricks v1.92.0
published on Tuesday, May 12, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-databricks

    Public Beta

    Example Usage

    Basic Synced Table with Snapshot Policy

    import * as pulumi from "@pulumi/pulumi";
import * as databricks from "@pulumi/databricks";

const _this = new databricks.PostgresProject("this", {
    projectId: "my-project",
    spec: {
        pgVersion: 17,
        displayName: "My Project",
    },
});
const main = new databricks.PostgresBranch("main", {
    branchId: "main",
    parent: _this.name,
    spec: {
        noExpiry: true,
    },
});
const thisPostgresCatalog = new databricks.PostgresCatalog("this", {
    catalogId: "app_catalog",
    spec: {
        postgresDatabase: "app_db",
        createDatabaseIfMissing: true,
        branch: main.name,
    },
});
const thisPostgresSyncedTable = new databricks.PostgresSyncedTable("this", {
    syncedTableId: "app_catalog.default.users_synced",
    spec: {
        sourceTableFullName: "main.default.users",
        primaryKeyColumns: ["user_id"],
        schedulingPolicy: "SNAPSHOT",
        postgresDatabase: "app_db",
        branch: main.name,
        createDatabaseObjectsIfMissing: true,
        newPipelineSpec: {
            storageCatalog: "main",
            storageSchema: "default",
        },
    },
});

    import pulumi
import pulumi_databricks as databricks

this = databricks.PostgresProject("this",
    project_id="my-project",
    spec={
        "pg_version": 17,
        "display_name": "My Project",
    })
main = databricks.PostgresBranch("main",
    branch_id="main",
    parent=this.name,
    spec={
        "no_expiry": True,
    })
this_postgres_catalog = databricks.PostgresCatalog("this",
    catalog_id="app_catalog",
    spec={
        "postgres_database": "app_db",
        "create_database_if_missing": True,
        "branch": main.name,
    })
this_postgres_synced_table = databricks.PostgresSyncedTable("this",
    synced_table_id="app_catalog.default.users_synced",
    spec={
        "source_table_full_name": "main.default.users",
        "primary_key_columns": ["user_id"],
        "scheduling_policy": "SNAPSHOT",
        "postgres_database": "app_db",
        "branch": main.name,
        "create_database_objects_if_missing": True,
        "new_pipeline_spec": {
            "storage_catalog": "main",
            "storage_schema": "default",
        },
    })

    package main

import (
	"github.com/pulumi/pulumi-databricks/sdk/go/databricks"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		this, err := databricks.NewPostgresProject(ctx, "this", &databricks.PostgresProjectArgs{
			ProjectId: pulumi.String("my-project"),
			Spec: &databricks.PostgresProjectSpecArgs{
				PgVersion:   pulumi.Int(17),
				DisplayName: pulumi.String("My Project"),
			},
		})
		if err != nil {
			return err
		}
		main, err := databricks.NewPostgresBranch(ctx, "main", &databricks.PostgresBranchArgs{
			BranchId: pulumi.String("main"),
			Parent:   this.Name,
			Spec: &databricks.PostgresBranchSpecArgs{
				NoExpiry: pulumi.Bool(true),
			},
		})
		if err != nil {
			return err
		}
		_, err = databricks.NewPostgresCatalog(ctx, "this", &databricks.PostgresCatalogArgs{
			CatalogId: pulumi.String("app_catalog"),
			Spec: &databricks.PostgresCatalogSpecArgs{
				PostgresDatabase:        pulumi.String("app_db"),
				CreateDatabaseIfMissing: pulumi.Bool(true),
				Branch:                  main.Name,
			},
		})
		if err != nil {
			return err
		}
		_, err = databricks.NewPostgresSyncedTable(ctx, "this", &databricks.PostgresSyncedTableArgs{
			SyncedTableId: pulumi.String("app_catalog.default.users_synced"),
			Spec: &databricks.PostgresSyncedTableSpecArgs{
				SourceTableFullName: pulumi.String("main.default.users"),
				PrimaryKeyColumns: pulumi.StringArray{
					pulumi.String("user_id"),
				},
				SchedulingPolicy:               pulumi.String("SNAPSHOT"),
				PostgresDatabase:               pulumi.String("app_db"),
				Branch:                         main.Name,
				CreateDatabaseObjectsIfMissing: pulumi.Bool(true),
				NewPipelineSpec: &databricks.PostgresSyncedTableSpecNewPipelineSpecArgs{
					StorageCatalog: pulumi.String("main"),
					StorageSchema:  pulumi.String("default"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Databricks = Pulumi.Databricks;

return await Deployment.RunAsync(() => 
{
    var @this = new Databricks.PostgresProject("this", new()
    {
        ProjectId = "my-project",
        Spec = new Databricks.Inputs.PostgresProjectSpecArgs
        {
            PgVersion = 17,
            DisplayName = "My Project",
        },
    });

    var main = new Databricks.PostgresBranch("main", new()
    {
        BranchId = "main",
        Parent = @this.Name,
        Spec = new Databricks.Inputs.PostgresBranchSpecArgs
        {
            NoExpiry = true,
        },
    });

    var thisPostgresCatalog = new Databricks.PostgresCatalog("this", new()
    {
        CatalogId = "app_catalog",
        Spec = new Databricks.Inputs.PostgresCatalogSpecArgs
        {
            PostgresDatabase = "app_db",
            CreateDatabaseIfMissing = true,
            Branch = main.Name,
        },
    });

    var thisPostgresSyncedTable = new Databricks.PostgresSyncedTable("this", new()
    {
        SyncedTableId = "app_catalog.default.users_synced",
        Spec = new Databricks.Inputs.PostgresSyncedTableSpecArgs
        {
            SourceTableFullName = "main.default.users",
            PrimaryKeyColumns = new[]
            {
                "user_id",
            },
            SchedulingPolicy = "SNAPSHOT",
            PostgresDatabase = "app_db",
            Branch = main.Name,
            CreateDatabaseObjectsIfMissing = true,
            NewPipelineSpec = new Databricks.Inputs.PostgresSyncedTableSpecNewPipelineSpecArgs
            {
                StorageCatalog = "main",
                StorageSchema = "default",
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.databricks.PostgresProject;
import com.pulumi.databricks.PostgresProjectArgs;
import com.pulumi.databricks.inputs.PostgresProjectSpecArgs;
import com.pulumi.databricks.PostgresBranch;
import com.pulumi.databricks.PostgresBranchArgs;
import com.pulumi.databricks.inputs.PostgresBranchSpecArgs;
import com.pulumi.databricks.PostgresCatalog;
import com.pulumi.databricks.PostgresCatalogArgs;
import com.pulumi.databricks.inputs.PostgresCatalogSpecArgs;
import com.pulumi.databricks.PostgresSyncedTable;
import com.pulumi.databricks.PostgresSyncedTableArgs;
import com.pulumi.databricks.inputs.PostgresSyncedTableSpecArgs;
import com.pulumi.databricks.inputs.PostgresSyncedTableSpecNewPipelineSpecArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var this_ = new PostgresProject("this", PostgresProjectArgs.builder()
            .projectId("my-project")
            .spec(PostgresProjectSpecArgs.builder()
                .pgVersion(17)
                .displayName("My Project")
                .build())
            .build());

        var main = new PostgresBranch("main", PostgresBranchArgs.builder()
            .branchId("main")
            .parent(this_.name())
            .spec(PostgresBranchSpecArgs.builder()
                .noExpiry(true)
                .build())
            .build());

        var thisPostgresCatalog = new PostgresCatalog("thisPostgresCatalog", PostgresCatalogArgs.builder()
            .catalogId("app_catalog")
            .spec(PostgresCatalogSpecArgs.builder()
                .postgresDatabase("app_db")
                .createDatabaseIfMissing(true)
                .branch(main.name())
                .build())
            .build());

        var thisPostgresSyncedTable = new PostgresSyncedTable("thisPostgresSyncedTable", PostgresSyncedTableArgs.builder()
            .syncedTableId("app_catalog.default.users_synced")
            .spec(PostgresSyncedTableSpecArgs.builder()
                .sourceTableFullName("main.default.users")
                .primaryKeyColumns("user_id")
                .schedulingPolicy("SNAPSHOT")
                .postgresDatabase("app_db")
                .branch(main.name())
                .createDatabaseObjectsIfMissing(true)
                .newPipelineSpec(PostgresSyncedTableSpecNewPipelineSpecArgs.builder()
                    .storageCatalog("main")
                    .storageSchema("default")
                    .build())
                .build())
            .build());

    }
}

    resources:
  this:
    type: databricks:PostgresProject
    properties:
      projectId: my-project
      spec:
        pgVersion: 17
        displayName: My Project
  main:
    type: databricks:PostgresBranch
    properties:
      branchId: main
      parent: ${this.name}
      spec:
        noExpiry: true
  thisPostgresCatalog:
    type: databricks:PostgresCatalog
    name: this
    properties:
      catalogId: app_catalog
      spec:
        postgresDatabase: app_db
        createDatabaseIfMissing: true
        branch: ${main.name}
  thisPostgresSyncedTable:
    type: databricks:PostgresSyncedTable
    name: this
    properties:
      syncedTableId: app_catalog.default.users_synced
      spec:
        sourceTableFullName: main.default.users
        primaryKeyColumns:
          - user_id
        schedulingPolicy: SNAPSHOT
        postgresDatabase: app_db
        branch: ${main.name}
        createDatabaseObjectsIfMissing: true
        newPipelineSpec:
          storageCatalog: main
          storageSchema: default

    Example coming soon!

    Synced Table with Triggered Policy

    Use TRIGGERED for on-demand updates. Requires Change Data Feed (CDF) enabled on the source table.

    import * as pulumi from "@pulumi/pulumi";
import * as databricks from "@pulumi/databricks";

const triggered = new databricks.PostgresSyncedTable("triggered", {
    syncedTableId: "app_catalog.default.orders_synced",
    spec: {
        sourceTableFullName: "main.default.orders",
        primaryKeyColumns: ["order_id"],
        schedulingPolicy: "TRIGGERED",
        postgresDatabase: "app_db",
        branch: main.name,
        createDatabaseObjectsIfMissing: true,
        newPipelineSpec: {
            storageCatalog: "main",
            storageSchema: "default",
        },
    },
});

    import pulumi
import pulumi_databricks as databricks

triggered = databricks.PostgresSyncedTable("triggered",
    synced_table_id="app_catalog.default.orders_synced",
    spec={
        "source_table_full_name": "main.default.orders",
        "primary_key_columns": ["order_id"],
        "scheduling_policy": "TRIGGERED",
        "postgres_database": "app_db",
        "branch": main["name"],
        "create_database_objects_if_missing": True,
        "new_pipeline_spec": {
            "storage_catalog": "main",
            "storage_schema": "default",
        },
    })

    package main

import (
	"github.com/pulumi/pulumi-databricks/sdk/go/databricks"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := databricks.NewPostgresSyncedTable(ctx, "triggered", &databricks.PostgresSyncedTableArgs{
			SyncedTableId: pulumi.String("app_catalog.default.orders_synced"),
			Spec: &databricks.PostgresSyncedTableSpecArgs{
				SourceTableFullName: pulumi.String("main.default.orders"),
				PrimaryKeyColumns: pulumi.StringArray{
					pulumi.String("order_id"),
				},
				SchedulingPolicy:               pulumi.String("TRIGGERED"),
				PostgresDatabase:               pulumi.String("app_db"),
				Branch:                         pulumi.Any(main.Name),
				CreateDatabaseObjectsIfMissing: pulumi.Bool(true),
				NewPipelineSpec: &databricks.PostgresSyncedTableSpecNewPipelineSpecArgs{
					StorageCatalog: pulumi.String("main"),
					StorageSchema:  pulumi.String("default"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Databricks = Pulumi.Databricks;

return await Deployment.RunAsync(() => 
{
    var triggered = new Databricks.PostgresSyncedTable("triggered", new()
    {
        SyncedTableId = "app_catalog.default.orders_synced",
        Spec = new Databricks.Inputs.PostgresSyncedTableSpecArgs
        {
            SourceTableFullName = "main.default.orders",
            PrimaryKeyColumns = new[]
            {
                "order_id",
            },
            SchedulingPolicy = "TRIGGERED",
            PostgresDatabase = "app_db",
            Branch = main.Name,
            CreateDatabaseObjectsIfMissing = true,
            NewPipelineSpec = new Databricks.Inputs.PostgresSyncedTableSpecNewPipelineSpecArgs
            {
                StorageCatalog = "main",
                StorageSchema = "default",
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.databricks.PostgresSyncedTable;
import com.pulumi.databricks.PostgresSyncedTableArgs;
import com.pulumi.databricks.inputs.PostgresSyncedTableSpecArgs;
import com.pulumi.databricks.inputs.PostgresSyncedTableSpecNewPipelineSpecArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var triggered = new PostgresSyncedTable("triggered", PostgresSyncedTableArgs.builder()
            .syncedTableId("app_catalog.default.orders_synced")
            .spec(PostgresSyncedTableSpecArgs.builder()
                .sourceTableFullName("main.default.orders")
                .primaryKeyColumns("order_id")
                .schedulingPolicy("TRIGGERED")
                .postgresDatabase("app_db")
                .branch(main.name())
                .createDatabaseObjectsIfMissing(true)
                .newPipelineSpec(PostgresSyncedTableSpecNewPipelineSpecArgs.builder()
                    .storageCatalog("main")
                    .storageSchema("default")
                    .build())
                .build())
            .build());

    }
}

    resources:
  triggered:
    type: databricks:PostgresSyncedTable
    properties:
      syncedTableId: app_catalog.default.orders_synced
      spec:
        sourceTableFullName: main.default.orders
        primaryKeyColumns:
          - order_id
        schedulingPolicy: TRIGGERED
        postgresDatabase: app_db
        branch: ${main.name}
        createDatabaseObjectsIfMissing: true
        newPipelineSpec:
          storageCatalog: main
          storageSchema: default

    Example coming soon!

    Synced Table with Existing Pipeline

    Bin-pack into an existing pipeline instead of creating a new one:

    import * as pulumi from "@pulumi/pulumi";
import * as databricks from "@pulumi/databricks";

const _this = new databricks.PostgresSyncedTable("this", {
    syncedTableId: "app_catalog.default.products_synced",
    spec: {
        sourceTableFullName: "main.default.products",
        primaryKeyColumns: ["product_id"],
        schedulingPolicy: "SNAPSHOT",
        postgresDatabase: "app_db",
        branch: main.name,
        createDatabaseObjectsIfMissing: true,
        existingPipelineId: "abc123-def456",
    },
});

    import pulumi
import pulumi_databricks as databricks

this = databricks.PostgresSyncedTable("this",
    synced_table_id="app_catalog.default.products_synced",
    spec={
        "source_table_full_name": "main.default.products",
        "primary_key_columns": ["product_id"],
        "scheduling_policy": "SNAPSHOT",
        "postgres_database": "app_db",
        "branch": main["name"],
        "create_database_objects_if_missing": True,
        "existing_pipeline_id": "abc123-def456",
    })

    package main

import (
	"github.com/pulumi/pulumi-databricks/sdk/go/databricks"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := databricks.NewPostgresSyncedTable(ctx, "this", &databricks.PostgresSyncedTableArgs{
			SyncedTableId: pulumi.String("app_catalog.default.products_synced"),
			Spec: &databricks.PostgresSyncedTableSpecArgs{
				SourceTableFullName: pulumi.String("main.default.products"),
				PrimaryKeyColumns: pulumi.StringArray{
					pulumi.String("product_id"),
				},
				SchedulingPolicy:               pulumi.String("SNAPSHOT"),
				PostgresDatabase:               pulumi.String("app_db"),
				Branch:                         pulumi.Any(main.Name),
				CreateDatabaseObjectsIfMissing: pulumi.Bool(true),
				ExistingPipelineId:             pulumi.String("abc123-def456"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Databricks = Pulumi.Databricks;

return await Deployment.RunAsync(() => 
{
    var @this = new Databricks.PostgresSyncedTable("this", new()
    {
        SyncedTableId = "app_catalog.default.products_synced",
        Spec = new Databricks.Inputs.PostgresSyncedTableSpecArgs
        {
            SourceTableFullName = "main.default.products",
            PrimaryKeyColumns = new[]
            {
                "product_id",
            },
            SchedulingPolicy = "SNAPSHOT",
            PostgresDatabase = "app_db",
            Branch = main.Name,
            CreateDatabaseObjectsIfMissing = true,
            ExistingPipelineId = "abc123-def456",
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.databricks.PostgresSyncedTable;
import com.pulumi.databricks.PostgresSyncedTableArgs;
import com.pulumi.databricks.inputs.PostgresSyncedTableSpecArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var this_ = new PostgresSyncedTable("this", PostgresSyncedTableArgs.builder()
            .syncedTableId("app_catalog.default.products_synced")
            .spec(PostgresSyncedTableSpecArgs.builder()
                .sourceTableFullName("main.default.products")
                .primaryKeyColumns("product_id")
                .schedulingPolicy("SNAPSHOT")
                .postgresDatabase("app_db")
                .branch(main.name())
                .createDatabaseObjectsIfMissing(true)
                .existingPipelineId("abc123-def456")
                .build())
            .build());

    }
}

    resources:
  this:
    type: databricks:PostgresSyncedTable
    properties:
      syncedTableId: app_catalog.default.products_synced
      spec:
        sourceTableFullName: main.default.products
        primaryKeyColumns:
          - product_id
        schedulingPolicy: SNAPSHOT
        postgresDatabase: app_db
        branch: ${main.name}
        createDatabaseObjectsIfMissing: true
        existingPipelineId: abc123-def456

    Example coming soon!

    Create PostgresSyncedTable Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new PostgresSyncedTable(name: string, args: PostgresSyncedTableArgs, opts?: CustomResourceOptions);
    @overload
def PostgresSyncedTable(resource_name: str,
                        args: PostgresSyncedTableArgs,
                        opts: Optional[ResourceOptions] = None)

@overload
def PostgresSyncedTable(resource_name: str,
                        opts: Optional[ResourceOptions] = None,
                        synced_table_id: Optional[str] = None,
                        provider_config: Optional[PostgresSyncedTableProviderConfigArgs] = None,
                        spec: Optional[PostgresSyncedTableSpecArgs] = None)
    func NewPostgresSyncedTable(ctx *Context, name string, args PostgresSyncedTableArgs, opts ...ResourceOption) (*PostgresSyncedTable, error)
    public PostgresSyncedTable(string name, PostgresSyncedTableArgs args, CustomResourceOptions? opts = null)
    public PostgresSyncedTable(String name, PostgresSyncedTableArgs args)
public PostgresSyncedTable(String name, PostgresSyncedTableArgs args, CustomResourceOptions options)

    type: databricks:PostgresSyncedTable
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.


    resource "databricks_postgressyncedtable" "name" {
    # resource properties
}

    Parameters

    name string
    The unique name of the resource.
    args PostgresSyncedTableArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args PostgresSyncedTableArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args PostgresSyncedTableArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args PostgresSyncedTableArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args PostgresSyncedTableArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var postgresSyncedTableResource = new Databricks.PostgresSyncedTable("postgresSyncedTableResource", new()
{
    SyncedTableId = "string",
    ProviderConfig = new Databricks.Inputs.PostgresSyncedTableProviderConfigArgs
    {
        WorkspaceId = "string",
    },
    Spec = new Databricks.Inputs.PostgresSyncedTableSpecArgs
    {
        Branch = "string",
        CreateDatabaseObjectsIfMissing = false,
        ExistingPipelineId = "string",
        NewPipelineSpec = new Databricks.Inputs.PostgresSyncedTableSpecNewPipelineSpecArgs
        {
            BudgetPolicyId = "string",
            StorageCatalog = "string",
            StorageSchema = "string",
        },
        PostgresDatabase = "string",
        PrimaryKeyColumns = new[]
        {
            "string",
        },
        SchedulingPolicy = "string",
        SourceTableFullName = "string",
        TimeseriesKey = "string",
    },
});

    example, err := databricks.NewPostgresSyncedTable(ctx, "postgresSyncedTableResource", &databricks.PostgresSyncedTableArgs{
	SyncedTableId: pulumi.String("string"),
	ProviderConfig: &databricks.PostgresSyncedTableProviderConfigArgs{
		WorkspaceId: pulumi.String("string"),
	},
	Spec: &databricks.PostgresSyncedTableSpecArgs{
		Branch:                         pulumi.String("string"),
		CreateDatabaseObjectsIfMissing: pulumi.Bool(false),
		ExistingPipelineId:             pulumi.String("string"),
		NewPipelineSpec: &databricks.PostgresSyncedTableSpecNewPipelineSpecArgs{
			BudgetPolicyId: pulumi.String("string"),
			StorageCatalog: pulumi.String("string"),
			StorageSchema:  pulumi.String("string"),
		},
		PostgresDatabase: pulumi.String("string"),
		PrimaryKeyColumns: pulumi.StringArray{
			pulumi.String("string"),
		},
		SchedulingPolicy:    pulumi.String("string"),
		SourceTableFullName: pulumi.String("string"),
		TimeseriesKey:       pulumi.String("string"),
	},
})

    resource "databricks_postgressyncedtable" "postgresSyncedTableResource" {
  synced_table_id = "string"
  provider_config = {
    workspace_id = "string"
  }
  spec = {
    branch                             = "string"
    create_database_objects_if_missing = false
    existing_pipeline_id               = "string"
    new_pipeline_spec = {
      budget_policy_id = "string"
      storage_catalog  = "string"
      storage_schema   = "string"
    }
    postgres_database      = "string"
    primary_key_columns    = ["string"]
    scheduling_policy      = "string"
    source_table_full_name = "string"
    timeseries_key         = "string"
  }
}

    var postgresSyncedTableResource = new PostgresSyncedTable("postgresSyncedTableResource", PostgresSyncedTableArgs.builder()
    .syncedTableId("string")
    .providerConfig(PostgresSyncedTableProviderConfigArgs.builder()
        .workspaceId("string")
        .build())
    .spec(PostgresSyncedTableSpecArgs.builder()
        .branch("string")
        .createDatabaseObjectsIfMissing(false)
        .existingPipelineId("string")
        .newPipelineSpec(PostgresSyncedTableSpecNewPipelineSpecArgs.builder()
            .budgetPolicyId("string")
            .storageCatalog("string")
            .storageSchema("string")
            .build())
        .postgresDatabase("string")
        .primaryKeyColumns("string")
        .schedulingPolicy("string")
        .sourceTableFullName("string")
        .timeseriesKey("string")
        .build())
    .build());

    postgres_synced_table_resource = databricks.PostgresSyncedTable("postgresSyncedTableResource",
    synced_table_id="string",
    provider_config={
        "workspace_id": "string",
    },
    spec={
        "branch": "string",
        "create_database_objects_if_missing": False,
        "existing_pipeline_id": "string",
        "new_pipeline_spec": {
            "budget_policy_id": "string",
            "storage_catalog": "string",
            "storage_schema": "string",
        },
        "postgres_database": "string",
        "primary_key_columns": ["string"],
        "scheduling_policy": "string",
        "source_table_full_name": "string",
        "timeseries_key": "string",
    })

    const postgresSyncedTableResource = new databricks.PostgresSyncedTable("postgresSyncedTableResource", {
    syncedTableId: "string",
    providerConfig: {
        workspaceId: "string",
    },
    spec: {
        branch: "string",
        createDatabaseObjectsIfMissing: false,
        existingPipelineId: "string",
        newPipelineSpec: {
            budgetPolicyId: "string",
            storageCatalog: "string",
            storageSchema: "string",
        },
        postgresDatabase: "string",
        primaryKeyColumns: ["string"],
        schedulingPolicy: "string",
        sourceTableFullName: "string",
        timeseriesKey: "string",
    },
});

    type: databricks:PostgresSyncedTable
properties:
    providerConfig:
        workspaceId: string
    spec:
        branch: string
        createDatabaseObjectsIfMissing: false
        existingPipelineId: string
        newPipelineSpec:
            budgetPolicyId: string
            storageCatalog: string
            storageSchema: string
        postgresDatabase: string
        primaryKeyColumns:
            - string
        schedulingPolicy: string
        sourceTableFullName: string
        timeseriesKey: string
    syncedTableId: string

    PostgresSyncedTable Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The PostgresSyncedTable resource accepts the following input properties:

    SyncedTableId string

    The ID to use for the Synced Table. This becomes the final component of the SyncedTable's resource name. ID is required and is the synced table name, containing (catalog, schema, table) tuple. Elements of the tuple are the UC entity names.

    Example: "{catalog}.{schema}.{table}"

    syncedTableId represents both of the following:

    1. An online VIEW virtual table in the Unity Catalog accessible via the Lakehouse Federation.
    2. Postgres table named "{table}" in schema "{schema}" in the connected Postgres database
    ProviderConfig PostgresSyncedTableProviderConfig
    Configure the provider for management through account provider.
    Spec PostgresSyncedTableSpec
    Configuration details of the synced table, such as the source table, scheduling policy, etc. This attribute is specified at creation time and most fields are returned as is on subsequent queries
    SyncedTableId string

    The ID to use for the Synced Table. This becomes the final component of the SyncedTable's resource name. ID is required and is the synced table name, containing (catalog, schema, table) tuple. Elements of the tuple are the UC entity names.

    Example: "{catalog}.{schema}.{table}"

    syncedTableId represents both of the following:

    1. An online VIEW virtual table in the Unity Catalog accessible via the Lakehouse Federation.
    2. Postgres table named "{table}" in schema "{schema}" in the connected Postgres database
    ProviderConfig PostgresSyncedTableProviderConfigArgs
    Configure the provider for management through account provider.
    Spec PostgresSyncedTableSpecArgs
    Configuration details of the synced table, such as the source table, scheduling policy, etc. This attribute is specified at creation time and most fields are returned as is on subsequent queries
    synced_table_id string

    The ID to use for the Synced Table. This becomes the final component of the SyncedTable's resource name. ID is required and is the synced table name, containing (catalog, schema, table) tuple. Elements of the tuple are the UC entity names.

    Example: "{catalog}.{schema}.{table}"

    syncedTableId represents both of the following:

    1. An online VIEW virtual table in the Unity Catalog accessible via the Lakehouse Federation.
    2. Postgres table named "{table}" in schema "{schema}" in the connected Postgres database
    provider_config object
    Configure the provider for management through account provider.
    spec object
    Configuration details of the synced table, such as the source table, scheduling policy, etc. This attribute is specified at creation time and most fields are returned as is on subsequent queries
    syncedTableId String

    The ID to use for the Synced Table. This becomes the final component of the SyncedTable's resource name. ID is required and is the synced table name, containing (catalog, schema, table) tuple. Elements of the tuple are the UC entity names.

    Example: "{catalog}.{schema}.{table}"

    syncedTableId represents both of the following:

    1. An online VIEW virtual table in the Unity Catalog accessible via the Lakehouse Federation.
    2. Postgres table named "{table}" in schema "{schema}" in the connected Postgres database
    providerConfig PostgresSyncedTableProviderConfig
    Configure the provider for management through account provider.
    spec PostgresSyncedTableSpec
    Configuration details of the synced table, such as the source table, scheduling policy, etc. This attribute is specified at creation time and most fields are returned as is on subsequent queries
    syncedTableId string

    The ID to use for the Synced Table. This becomes the final component of the SyncedTable's resource name. ID is required and is the synced table name, containing (catalog, schema, table) tuple. Elements of the tuple are the UC entity names.

    Example: "{catalog}.{schema}.{table}"

    syncedTableId represents both of the following:

    1. An online VIEW virtual table in the Unity Catalog accessible via the Lakehouse Federation.
    2. Postgres table named "{table}" in schema "{schema}" in the connected Postgres database
    providerConfig PostgresSyncedTableProviderConfig
    Configure the provider for management through account provider.
    spec PostgresSyncedTableSpec
    Configuration details of the synced table, such as the source table, scheduling policy, etc. This attribute is specified at creation time and most fields are returned as is on subsequent queries
    synced_table_id str

    The ID to use for the Synced Table. This becomes the final component of the SyncedTable's resource name. ID is required and is the synced table name, containing (catalog, schema, table) tuple. Elements of the tuple are the UC entity names.

    Example: "{catalog}.{schema}.{table}"

    syncedTableId represents both of the following:

    1. An online VIEW virtual table in the Unity Catalog accessible via the Lakehouse Federation.
    2. Postgres table named "{table}" in schema "{schema}" in the connected Postgres database
    provider_config PostgresSyncedTableProviderConfigArgs
    Configure the provider for management through account provider.
    spec PostgresSyncedTableSpecArgs
    Configuration details of the synced table, such as the source table, scheduling policy, etc. This attribute is specified at creation time and most fields are returned as is on subsequent queries
    syncedTableId String

    The ID to use for the Synced Table. This becomes the final component of the SyncedTable's resource name. ID is required and is the synced table name, containing (catalog, schema, table) tuple. Elements of the tuple are the UC entity names.

    Example: "{catalog}.{schema}.{table}"

    syncedTableId represents both of the following:

    1. An online VIEW virtual table in the Unity Catalog accessible via the Lakehouse Federation.
    2. Postgres table named "{table}" in schema "{schema}" in the connected Postgres database
    providerConfig Property Map
    Configure the provider for management through account provider.
    spec Property Map
    Configuration details of the synced table, such as the source table, scheduling policy, etc. This attribute is specified at creation time and most fields are returned as is on subsequent queries

    Outputs

    All input properties are implicitly available as output properties. Additionally, the PostgresSyncedTable resource produces the following output properties:

    CreateTime string
    (string)
    Id string
    The provider-assigned unique ID for this managed resource.
    Name string
    (string) - Output only. The Full resource name of the synced table in Postgres where (catalog, schema, table) are the UC entity names.
    Status PostgresSyncedTableStatus
    (SyncedTableSyncedTableStatus) - Synced Table data synchronization status
    Uid string
    (string) - The Unity Catalog table ID for this synced table
    CreateTime string
    (string)
    Id string
    The provider-assigned unique ID for this managed resource.
    Name string
    (string) - Output only. The Full resource name of the synced table in Postgres where (catalog, schema, table) are the UC entity names.
    Status PostgresSyncedTableStatus
    (SyncedTableSyncedTableStatus) - Synced Table data synchronization status
    Uid string
    (string) - The Unity Catalog table ID for this synced table
    create_time string
    (string)
    id string
    The provider-assigned unique ID for this managed resource.
    name string
    (string) - Output only. The Full resource name of the synced table in Postgres where (catalog, schema, table) are the UC entity names.
    status object
    (SyncedTableSyncedTableStatus) - Synced Table data synchronization status
    uid string
    (string) - The Unity Catalog table ID for this synced table
    createTime String
    (string)
    id String
    The provider-assigned unique ID for this managed resource.
    name String
    (string) - Output only. The Full resource name of the synced table in Postgres where (catalog, schema, table) are the UC entity names.
    status PostgresSyncedTableStatus
    (SyncedTableSyncedTableStatus) - Synced Table data synchronization status
    uid String
    (string) - The Unity Catalog table ID for this synced table
    createTime string
    (string)
    id string
    The provider-assigned unique ID for this managed resource.
    name string
    (string) - Output only. The Full resource name of the synced table in Postgres where (catalog, schema, table) are the UC entity names.
    status PostgresSyncedTableStatus
    (SyncedTableSyncedTableStatus) - Synced Table data synchronization status
    uid string
    (string) - The Unity Catalog table ID for this synced table
    create_time str
    (string)
    id str
    The provider-assigned unique ID for this managed resource.
    name str
    (string) - Output only. The Full resource name of the synced table in Postgres where (catalog, schema, table) are the UC entity names.
    status PostgresSyncedTableStatus
    (SyncedTableSyncedTableStatus) - Synced Table data synchronization status
    uid str
    (string) - The Unity Catalog table ID for this synced table
    createTime String
    (string)
    id String
    The provider-assigned unique ID for this managed resource.
    name String
    (string) - Output only. The Full resource name of the synced table in Postgres where (catalog, schema, table) are the UC entity names.
    status Property Map
    (SyncedTableSyncedTableStatus) - Synced Table data synchronization status
    uid String
    (string) - The Unity Catalog table ID for this synced table

    Look up Existing PostgresSyncedTable Resource

    Get an existing PostgresSyncedTable resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: PostgresSyncedTableState, opts?: CustomResourceOptions): PostgresSyncedTable
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        create_time: Optional[str] = None,
        name: Optional[str] = None,
        provider_config: Optional[PostgresSyncedTableProviderConfigArgs] = None,
        spec: Optional[PostgresSyncedTableSpecArgs] = None,
        status: Optional[PostgresSyncedTableStatusArgs] = None,
        synced_table_id: Optional[str] = None,
        uid: Optional[str] = None) -> PostgresSyncedTable
    func GetPostgresSyncedTable(ctx *Context, name string, id IDInput, state *PostgresSyncedTableState, opts ...ResourceOption) (*PostgresSyncedTable, error)
    public static PostgresSyncedTable Get(string name, Input<string> id, PostgresSyncedTableState? state, CustomResourceOptions? opts = null)
    public static PostgresSyncedTable get(String name, Output<String> id, PostgresSyncedTableState state, CustomResourceOptions options)
    resources:  _:    type: databricks:PostgresSyncedTable    get:      id: ${id}
    import {
  to = databricks_postgressyncedtable.example
  id = "${id}"
}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    CreateTime string
    (string)
    Name string
    (string) - Output only. The Full resource name of the synced table in Postgres where (catalog, schema, table) are the UC entity names.
    ProviderConfig PostgresSyncedTableProviderConfig
    Configure the provider for management through account provider.
    Spec PostgresSyncedTableSpec
    Configuration details of the synced table, such as the source table, scheduling policy, etc. This attribute is specified at creation time and most fields are returned as is on subsequent queries
    Status PostgresSyncedTableStatus
    (SyncedTableSyncedTableStatus) - Synced Table data synchronization status
    SyncedTableId string

    The ID to use for the Synced Table. This becomes the final component of the SyncedTable's resource name. ID is required and is the synced table name, containing (catalog, schema, table) tuple. Elements of the tuple are the UC entity names.

    Example: "{catalog}.{schema}.{table}"

    syncedTableId represents both of the following:

    1. An online VIEW virtual table in the Unity Catalog accessible via the Lakehouse Federation.
    2. Postgres table named "{table}" in schema "{schema}" in the connected Postgres database
    Uid string
    (string) - The Unity Catalog table ID for this synced table
    CreateTime string
    (string)
    Name string
    (string) - Output only. The Full resource name of the synced table in Postgres where (catalog, schema, table) are the UC entity names.
    ProviderConfig PostgresSyncedTableProviderConfigArgs
    Configure the provider for management through account provider.
    Spec PostgresSyncedTableSpecArgs
    Configuration details of the synced table, such as the source table, scheduling policy, etc. This attribute is specified at creation time and most fields are returned as is on subsequent queries
    Status PostgresSyncedTableStatusArgs
    (SyncedTableSyncedTableStatus) - Synced Table data synchronization status
    SyncedTableId string

    The ID to use for the Synced Table. This becomes the final component of the SyncedTable's resource name. ID is required and is the synced table name, containing (catalog, schema, table) tuple. Elements of the tuple are the UC entity names.

    Example: "{catalog}.{schema}.{table}"

    syncedTableId represents both of the following:

    1. An online VIEW virtual table in the Unity Catalog accessible via the Lakehouse Federation.
    2. Postgres table named "{table}" in schema "{schema}" in the connected Postgres database
    Uid string
    (string) - The Unity Catalog table ID for this synced table
    create_time string
    (string)
    name string
    (string) - Output only. The Full resource name of the synced table in Postgres where (catalog, schema, table) are the UC entity names.
    provider_config object
    Configure the provider for management through account provider.
    spec object
    Configuration details of the synced table, such as the source table, scheduling policy, etc. This attribute is specified at creation time and most fields are returned as is on subsequent queries
    status object
    (SyncedTableSyncedTableStatus) - Synced Table data synchronization status
    synced_table_id string

    The ID to use for the Synced Table. This becomes the final component of the SyncedTable's resource name. ID is required and is the synced table name, containing (catalog, schema, table) tuple. Elements of the tuple are the UC entity names.

    Example: "{catalog}.{schema}.{table}"

    syncedTableId represents both of the following:

    1. An online VIEW virtual table in the Unity Catalog accessible via the Lakehouse Federation.
    2. Postgres table named "{table}" in schema "{schema}" in the connected Postgres database
    uid string
    (string) - The Unity Catalog table ID for this synced table
    createTime String
    (string)
    name String
    (string) - Output only. The Full resource name of the synced table in Postgres where (catalog, schema, table) are the UC entity names.
    providerConfig PostgresSyncedTableProviderConfig
    Configure the provider for management through account provider.
    spec PostgresSyncedTableSpec
    Configuration details of the synced table, such as the source table, scheduling policy, etc. This attribute is specified at creation time and most fields are returned as is on subsequent queries
    status PostgresSyncedTableStatus
    (SyncedTableSyncedTableStatus) - Synced Table data synchronization status
    syncedTableId String

    The ID to use for the Synced Table. This becomes the final component of the SyncedTable's resource name. ID is required and is the synced table name, containing (catalog, schema, table) tuple. Elements of the tuple are the UC entity names.

    Example: "{catalog}.{schema}.{table}"

    syncedTableId represents both of the following:

    1. An online VIEW virtual table in the Unity Catalog accessible via the Lakehouse Federation.
    2. Postgres table named "{table}" in schema "{schema}" in the connected Postgres database
    uid String
    (string) - The Unity Catalog table ID for this synced table
    createTime string
    (string)
    name string
    (string) - Output only. The Full resource name of the synced table in Postgres where (catalog, schema, table) are the UC entity names.
    providerConfig PostgresSyncedTableProviderConfig
    Configure the provider for management through account provider.
    spec PostgresSyncedTableSpec
    Configuration details of the synced table, such as the source table, scheduling policy, etc. This attribute is specified at creation time and most fields are returned as is on subsequent queries
    status PostgresSyncedTableStatus
    (SyncedTableSyncedTableStatus) - Synced Table data synchronization status
    syncedTableId string

    The ID to use for the Synced Table. This becomes the final component of the SyncedTable's resource name. ID is required and is the synced table name, containing (catalog, schema, table) tuple. Elements of the tuple are the UC entity names.

    Example: "{catalog}.{schema}.{table}"

    syncedTableId represents both of the following:

    1. An online VIEW virtual table in the Unity Catalog accessible via the Lakehouse Federation.
    2. Postgres table named "{table}" in schema "{schema}" in the connected Postgres database
    uid string
    (string) - The Unity Catalog table ID for this synced table
    create_time str
    (string)
    name str
    (string) - Output only. The Full resource name of the synced table in Postgres where (catalog, schema, table) are the UC entity names.
    provider_config PostgresSyncedTableProviderConfigArgs
    Configure the provider for management through account provider.
    spec PostgresSyncedTableSpecArgs
    Configuration details of the synced table, such as the source table, scheduling policy, etc. This attribute is specified at creation time and most fields are returned as is on subsequent queries
    status PostgresSyncedTableStatusArgs
    (SyncedTableSyncedTableStatus) - Synced Table data synchronization status
    synced_table_id str

    The ID to use for the Synced Table. This becomes the final component of the SyncedTable's resource name. ID is required and is the synced table name, containing (catalog, schema, table) tuple. Elements of the tuple are the UC entity names.

    Example: "{catalog}.{schema}.{table}"

    syncedTableId represents both of the following:

    1. An online VIEW virtual table in the Unity Catalog accessible via the Lakehouse Federation.
    2. Postgres table named "{table}" in schema "{schema}" in the connected Postgres database
    uid str
    (string) - The Unity Catalog table ID for this synced table
    createTime String
    (string)
    name String
    (string) - Output only. The Full resource name of the synced table in Postgres where (catalog, schema, table) are the UC entity names.
    providerConfig Property Map
    Configure the provider for management through account provider.
    spec Property Map
    Configuration details of the synced table, such as the source table, scheduling policy, etc. This attribute is specified at creation time and most fields are returned as is on subsequent queries
    status Property Map
    (SyncedTableSyncedTableStatus) - Synced Table data synchronization status
    syncedTableId String

    The ID to use for the Synced Table. This becomes the final component of the SyncedTable's resource name. ID is required and is the synced table name, containing (catalog, schema, table) tuple. Elements of the tuple are the UC entity names.

    Example: "{catalog}.{schema}.{table}"

    syncedTableId represents both of the following:

    1. An online VIEW virtual table in the Unity Catalog accessible via the Lakehouse Federation.
    2. Postgres table named "{table}" in schema "{schema}" in the connected Postgres database
    uid String
    (string) - The Unity Catalog table ID for this synced table

    Supporting Types

    PostgresSyncedTableProviderConfig, PostgresSyncedTableProviderConfigArgs

    WorkspaceId string
    Workspace ID which the resource belongs to. This workspace must be part of the account which the provider is configured with.
    WorkspaceId string
    Workspace ID which the resource belongs to. This workspace must be part of the account which the provider is configured with.
    workspace_id string
    Workspace ID which the resource belongs to. This workspace must be part of the account which the provider is configured with.
    workspaceId String
    Workspace ID which the resource belongs to. This workspace must be part of the account which the provider is configured with.
    workspaceId string
    Workspace ID which the resource belongs to. This workspace must be part of the account which the provider is configured with.
    workspace_id str
    Workspace ID which the resource belongs to. This workspace must be part of the account which the provider is configured with.
    workspaceId String
    Workspace ID which the resource belongs to. This workspace must be part of the account which the provider is configured with.

    PostgresSyncedTableSpec, PostgresSyncedTableSpecArgs

    Branch string

    The full resource name the branch associated with the table.

    Format: "projects/{project_id}/branches/{branch_id}"

    CreateDatabaseObjectsIfMissing bool

    If true, the synced table's logical database and schema resources in PG will be created if they do not already exist. The request will fail if this is false and the database/schema do not exist.

    Defaults to true if omitted

    ExistingPipelineId string

    ID of an existing pipeline to bin-pack this synced table into. At most one of existingPipelineId and newPipelineSpec should be defined.

    The pipeline used for the synced table is returned via the top level pipelineId attribute

    NewPipelineSpec PostgresSyncedTableSpecNewPipelineSpec

    Specification for creating a new pipeline. At most one of existingPipelineId and newPipelineSpec should be defined.

    The pipeline used for the synced table is returned via the top level pipelineId attribute

    PostgresDatabase string

    The Postgres database name where the synced table will be created in.

    If this synced table is created inside a Lakebase Catalog, this attribute can be omitted on creation and is inferred from the postgresDatabase associated with the Lakebase Catalog. If specified when inside a Lakebase Catalog, the value must match.

    A value must be specified when creating a synced table inside a Standard Catalog

    PrimaryKeyColumns List<string>
    Primary Key columns to be used for data insert/update in the destination
    SchedulingPolicy string
    Scheduling policy of the underlying pipeline. Possible values are: CONTINUOUS, SNAPSHOT, TRIGGERED
    SourceTableFullName string

    Three-part (catalog, schema, table) name of the source Delta table.

    For the corresponding destination table, use any of the two:

    • syncedTableId used at the creation of the SyncedTable
    • "name" consisting of "synced_tables/" prefix and the full name of the destination table
    TimeseriesKey string
    Time series key to deduplicate (tie-break) rows with the same primary key
    Branch string

    The full resource name the branch associated with the table.

    Format: "projects/{project_id}/branches/{branch_id}"

    CreateDatabaseObjectsIfMissing bool

    If true, the synced table's logical database and schema resources in PG will be created if they do not already exist. The request will fail if this is false and the database/schema do not exist.

    Defaults to true if omitted

    ExistingPipelineId string

    ID of an existing pipeline to bin-pack this synced table into. At most one of existingPipelineId and newPipelineSpec should be defined.

    The pipeline used for the synced table is returned via the top level pipelineId attribute

    NewPipelineSpec PostgresSyncedTableSpecNewPipelineSpec

    Specification for creating a new pipeline. At most one of existingPipelineId and newPipelineSpec should be defined.

    The pipeline used for the synced table is returned via the top level pipelineId attribute

    PostgresDatabase string

    The Postgres database name where the synced table will be created in.

    If this synced table is created inside a Lakebase Catalog, this attribute can be omitted on creation and is inferred from the postgresDatabase associated with the Lakebase Catalog. If specified when inside a Lakebase Catalog, the value must match.

    A value must be specified when creating a synced table inside a Standard Catalog

    PrimaryKeyColumns []string
    Primary Key columns to be used for data insert/update in the destination
    SchedulingPolicy string
    Scheduling policy of the underlying pipeline. Possible values are: CONTINUOUS, SNAPSHOT, TRIGGERED
    SourceTableFullName string

    Three-part (catalog, schema, table) name of the source Delta table.

    For the corresponding destination table, use any of the two:

    • syncedTableId used at the creation of the SyncedTable
    • "name" consisting of "synced_tables/" prefix and the full name of the destination table
    TimeseriesKey string
    Time series key to deduplicate (tie-break) rows with the same primary key
    branch string

    The full resource name the branch associated with the table.

    Format: "projects/{project_id}/branches/{branch_id}"

    create_database_objects_if_missing bool

    If true, the synced table's logical database and schema resources in PG will be created if they do not already exist. The request will fail if this is false and the database/schema do not exist.

    Defaults to true if omitted

    existing_pipeline_id string

    ID of an existing pipeline to bin-pack this synced table into. At most one of existingPipelineId and newPipelineSpec should be defined.

    The pipeline used for the synced table is returned via the top level pipelineId attribute

    new_pipeline_spec object

    Specification for creating a new pipeline. At most one of existingPipelineId and newPipelineSpec should be defined.

    The pipeline used for the synced table is returned via the top level pipelineId attribute

    postgres_database string

    The Postgres database name where the synced table will be created in.

    If this synced table is created inside a Lakebase Catalog, this attribute can be omitted on creation and is inferred from the postgresDatabase associated with the Lakebase Catalog. If specified when inside a Lakebase Catalog, the value must match.

    A value must be specified when creating a synced table inside a Standard Catalog

    primary_key_columns list(string)
    Primary Key columns to be used for data insert/update in the destination
    scheduling_policy string
    Scheduling policy of the underlying pipeline. Possible values are: CONTINUOUS, SNAPSHOT, TRIGGERED
    source_table_full_name string

    Three-part (catalog, schema, table) name of the source Delta table.

    For the corresponding destination table, use any of the two:

    • syncedTableId used at the creation of the SyncedTable
    • "name" consisting of "synced_tables/" prefix and the full name of the destination table
    timeseries_key string
    Time series key to deduplicate (tie-break) rows with the same primary key
    branch String

    The full resource name the branch associated with the table.

    Format: "projects/{project_id}/branches/{branch_id}"

    createDatabaseObjectsIfMissing Boolean

    If true, the synced table's logical database and schema resources in PG will be created if they do not already exist. The request will fail if this is false and the database/schema do not exist.

    Defaults to true if omitted

    existingPipelineId String

    ID of an existing pipeline to bin-pack this synced table into. At most one of existingPipelineId and newPipelineSpec should be defined.

    The pipeline used for the synced table is returned via the top level pipelineId attribute

    newPipelineSpec PostgresSyncedTableSpecNewPipelineSpec

    Specification for creating a new pipeline. At most one of existingPipelineId and newPipelineSpec should be defined.

    The pipeline used for the synced table is returned via the top level pipelineId attribute

    postgresDatabase String

    The Postgres database name where the synced table will be created in.

    If this synced table is created inside a Lakebase Catalog, this attribute can be omitted on creation and is inferred from the postgresDatabase associated with the Lakebase Catalog. If specified when inside a Lakebase Catalog, the value must match.

    A value must be specified when creating a synced table inside a Standard Catalog

    primaryKeyColumns List<String>
    Primary Key columns to be used for data insert/update in the destination
    schedulingPolicy String
    Scheduling policy of the underlying pipeline. Possible values are: CONTINUOUS, SNAPSHOT, TRIGGERED
    sourceTableFullName String

    Three-part (catalog, schema, table) name of the source Delta table.

    For the corresponding destination table, use any of the two:

    • syncedTableId used at the creation of the SyncedTable
    • "name" consisting of "synced_tables/" prefix and the full name of the destination table
    timeseriesKey String
    Time series key to deduplicate (tie-break) rows with the same primary key
    branch string

    The full resource name the branch associated with the table.

    Format: "projects/{project_id}/branches/{branch_id}"

    createDatabaseObjectsIfMissing boolean

    If true, the synced table's logical database and schema resources in PG will be created if they do not already exist. The request will fail if this is false and the database/schema do not exist.

    Defaults to true if omitted

    existingPipelineId string

    ID of an existing pipeline to bin-pack this synced table into. At most one of existingPipelineId and newPipelineSpec should be defined.

    The pipeline used for the synced table is returned via the top level pipelineId attribute

    newPipelineSpec PostgresSyncedTableSpecNewPipelineSpec

    Specification for creating a new pipeline. At most one of existingPipelineId and newPipelineSpec should be defined.

    The pipeline used for the synced table is returned via the top level pipelineId attribute

    postgresDatabase string

    The Postgres database name where the synced table will be created in.

    If this synced table is created inside a Lakebase Catalog, this attribute can be omitted on creation and is inferred from the postgresDatabase associated with the Lakebase Catalog. If specified when inside a Lakebase Catalog, the value must match.

    A value must be specified when creating a synced table inside a Standard Catalog

    primaryKeyColumns string[]
    Primary Key columns to be used for data insert/update in the destination
    schedulingPolicy string
    Scheduling policy of the underlying pipeline. Possible values are: CONTINUOUS, SNAPSHOT, TRIGGERED
    sourceTableFullName string

    Three-part (catalog, schema, table) name of the source Delta table.

    For the corresponding destination table, use any of the two:

    • syncedTableId used at the creation of the SyncedTable
    • "name" consisting of "synced_tables/" prefix and the full name of the destination table
    timeseriesKey string
    Time series key to deduplicate (tie-break) rows with the same primary key
    branch str

    The full resource name the branch associated with the table.

    Format: "projects/{project_id}/branches/{branch_id}"

    create_database_objects_if_missing bool

    If true, the synced table's logical database and schema resources in PG will be created if they do not already exist. The request will fail if this is false and the database/schema do not exist.

    Defaults to true if omitted

    existing_pipeline_id str

    ID of an existing pipeline to bin-pack this synced table into. At most one of existingPipelineId and newPipelineSpec should be defined.

    The pipeline used for the synced table is returned via the top level pipelineId attribute

    new_pipeline_spec PostgresSyncedTableSpecNewPipelineSpec

    Specification for creating a new pipeline. At most one of existingPipelineId and newPipelineSpec should be defined.

    The pipeline used for the synced table is returned via the top level pipelineId attribute

    postgres_database str

    The Postgres database name where the synced table will be created in.

    If this synced table is created inside a Lakebase Catalog, this attribute can be omitted on creation and is inferred from the postgresDatabase associated with the Lakebase Catalog. If specified when inside a Lakebase Catalog, the value must match.

    A value must be specified when creating a synced table inside a Standard Catalog

    primary_key_columns Sequence[str]
    Primary Key columns to be used for data insert/update in the destination
    scheduling_policy str
    Scheduling policy of the underlying pipeline. Possible values are: CONTINUOUS, SNAPSHOT, TRIGGERED
    source_table_full_name str

    Three-part (catalog, schema, table) name of the source Delta table.

    For the corresponding destination table, use any of the two:

    • syncedTableId used at the creation of the SyncedTable
    • "name" consisting of "synced_tables/" prefix and the full name of the destination table
    timeseries_key str
    Time series key to deduplicate (tie-break) rows with the same primary key
    branch String

    The full resource name the branch associated with the table.

    Format: "projects/{project_id}/branches/{branch_id}"

    createDatabaseObjectsIfMissing Boolean

    If true, the synced table's logical database and schema resources in PG will be created if they do not already exist. The request will fail if this is false and the database/schema do not exist.

    Defaults to true if omitted

    existingPipelineId String

    ID of an existing pipeline to bin-pack this synced table into. At most one of existingPipelineId and newPipelineSpec should be defined.

    The pipeline used for the synced table is returned via the top level pipelineId attribute

    newPipelineSpec Property Map

    Specification for creating a new pipeline. At most one of existingPipelineId and newPipelineSpec should be defined.

    The pipeline used for the synced table is returned via the top level pipelineId attribute

    postgresDatabase String

    The Postgres database name where the synced table will be created in.

    If this synced table is created inside a Lakebase Catalog, this attribute can be omitted on creation and is inferred from the postgresDatabase associated with the Lakebase Catalog. If specified when inside a Lakebase Catalog, the value must match.

    A value must be specified when creating a synced table inside a Standard Catalog

    primaryKeyColumns List<String>
    Primary Key columns to be used for data insert/update in the destination
    schedulingPolicy String
    Scheduling policy of the underlying pipeline. Possible values are: CONTINUOUS, SNAPSHOT, TRIGGERED
    sourceTableFullName String

    Three-part (catalog, schema, table) name of the source Delta table.

    For the corresponding destination table, use any of the two:

    • syncedTableId used at the creation of the SyncedTable
    • "name" consisting of "synced_tables/" prefix and the full name of the destination table
    timeseriesKey String
    Time series key to deduplicate (tie-break) rows with the same primary key

    PostgresSyncedTableSpecNewPipelineSpec, PostgresSyncedTableSpecNewPipelineSpecArgs

    BudgetPolicyId string
    Budget policy to set on the newly created pipeline
    StorageCatalog string
    UC catalog for the pipeline to store intermediate files (checkpoints, event logs etc). This needs to be a standard catalog where the user has permissions to create Delta tables
    StorageSchema string
    UC schema for the pipeline to store intermediate files (checkpoints, event logs etc). This needs to be in the standard catalog where the user has permissions to create Delta tables
    BudgetPolicyId string
    Budget policy to set on the newly created pipeline
    StorageCatalog string
    UC catalog for the pipeline to store intermediate files (checkpoints, event logs etc). This needs to be a standard catalog where the user has permissions to create Delta tables
    StorageSchema string
    UC schema for the pipeline to store intermediate files (checkpoints, event logs etc). This needs to be in the standard catalog where the user has permissions to create Delta tables
    budget_policy_id string
    Budget policy to set on the newly created pipeline
    storage_catalog string
    UC catalog for the pipeline to store intermediate files (checkpoints, event logs etc). This needs to be a standard catalog where the user has permissions to create Delta tables
    storage_schema string
    UC schema for the pipeline to store intermediate files (checkpoints, event logs etc). This needs to be in the standard catalog where the user has permissions to create Delta tables
    budgetPolicyId String
    Budget policy to set on the newly created pipeline
    storageCatalog String
    UC catalog for the pipeline to store intermediate files (checkpoints, event logs etc). This needs to be a standard catalog where the user has permissions to create Delta tables
    storageSchema String
    UC schema for the pipeline to store intermediate files (checkpoints, event logs etc). This needs to be in the standard catalog where the user has permissions to create Delta tables
    budgetPolicyId string
    Budget policy to set on the newly created pipeline
    storageCatalog string
    UC catalog for the pipeline to store intermediate files (checkpoints, event logs etc). This needs to be a standard catalog where the user has permissions to create Delta tables
    storageSchema string
    UC schema for the pipeline to store intermediate files (checkpoints, event logs etc). This needs to be in the standard catalog where the user has permissions to create Delta tables
    budget_policy_id str
    Budget policy to set on the newly created pipeline
    storage_catalog str
    UC catalog for the pipeline to store intermediate files (checkpoints, event logs etc). This needs to be a standard catalog where the user has permissions to create Delta tables
    storage_schema str
    UC schema for the pipeline to store intermediate files (checkpoints, event logs etc). This needs to be in the standard catalog where the user has permissions to create Delta tables
    budgetPolicyId String
    Budget policy to set on the newly created pipeline
    storageCatalog String
    UC catalog for the pipeline to store intermediate files (checkpoints, event logs etc). This needs to be a standard catalog where the user has permissions to create Delta tables
    storageSchema String
    UC schema for the pipeline to store intermediate files (checkpoints, event logs etc). This needs to be in the standard catalog where the user has permissions to create Delta tables

    PostgresSyncedTableStatus, PostgresSyncedTableStatusArgs

    DetailedState string
    (string) - The state of the synced table. Possible values are: SYNCED_TABLE_OFFLINE, SYNCED_TABLE_OFFLINE_FAILED, SYNCED_TABLE_ONLINE, SYNCED_TABLE_ONLINE_CONTINUOUS_UPDATE, SYNCED_TABLE_ONLINE_NO_PENDING_UPDATE, SYNCED_TABLE_ONLINE_PIPELINE_FAILED, SYNCED_TABLE_ONLINE_TRIGGERED_UPDATE, SYNCED_TABLE_ONLINE_UPDATING_PIPELINE_RESOURCES, SYNCED_TABLE_PROVISIONING, SYNCED_TABLE_PROVISIONING_INITIAL_SNAPSHOT, SYNCED_TABLE_PROVISIONING_PIPELINE_RESOURCES
    LastProcessedCommitVersion int
    (integer) - The last source table Delta version that was successfully synced to the synced table
    LastSync PostgresSyncedTableStatusLastSync
    (SyncedTablePosition) - Summary of the last successful synchronization from source to destination
    LastSyncTime string
    (string) - The end timestamp of the last time any data was synchronized from the source table to the synced table. This is when the data is available in the synced table
    Message string
    (string) - A text description of the current state of the synced table
    OngoingSyncProgress PostgresSyncedTableStatusOngoingSyncProgress
    (SyncedTablePipelineProgress)
    PipelineId string
    (string) - ID of the associated pipeline
    Project string
    (string) - The full resource name of the project associated with the table.
    ProvisioningPhase string
    (string) - The current phase of the data synchronization pipeline. Possible values are: PROVISIONING_PHASE_INDEX_SCAN, PROVISIONING_PHASE_INDEX_SORT, PROVISIONING_PHASE_MAIN
    UnityCatalogProvisioningState string
    (string) - The provisioning state of the synced table entity in Unity Catalog. Possible values are: ACTIVE, DEGRADED, DELETING, FAILED, PROVISIONING, UPDATING
    DetailedState string
    (string) - The state of the synced table. Possible values are: SYNCED_TABLE_OFFLINE, SYNCED_TABLE_OFFLINE_FAILED, SYNCED_TABLE_ONLINE, SYNCED_TABLE_ONLINE_CONTINUOUS_UPDATE, SYNCED_TABLE_ONLINE_NO_PENDING_UPDATE, SYNCED_TABLE_ONLINE_PIPELINE_FAILED, SYNCED_TABLE_ONLINE_TRIGGERED_UPDATE, SYNCED_TABLE_ONLINE_UPDATING_PIPELINE_RESOURCES, SYNCED_TABLE_PROVISIONING, SYNCED_TABLE_PROVISIONING_INITIAL_SNAPSHOT, SYNCED_TABLE_PROVISIONING_PIPELINE_RESOURCES
    LastProcessedCommitVersion int
    (integer) - The last source table Delta version that was successfully synced to the synced table
    LastSync PostgresSyncedTableStatusLastSync
    (SyncedTablePosition) - Summary of the last successful synchronization from source to destination
    LastSyncTime string
    (string) - The end timestamp of the last time any data was synchronized from the source table to the synced table. This is when the data is available in the synced table
    Message string
    (string) - A text description of the current state of the synced table
    OngoingSyncProgress PostgresSyncedTableStatusOngoingSyncProgress
    (SyncedTablePipelineProgress)
    PipelineId string
    (string) - ID of the associated pipeline
    Project string
    (string) - The full resource name of the project associated with the table.
    ProvisioningPhase string
    (string) - The current phase of the data synchronization pipeline. Possible values are: PROVISIONING_PHASE_INDEX_SCAN, PROVISIONING_PHASE_INDEX_SORT, PROVISIONING_PHASE_MAIN
    UnityCatalogProvisioningState string
    (string) - The provisioning state of the synced table entity in Unity Catalog. Possible values are: ACTIVE, DEGRADED, DELETING, FAILED, PROVISIONING, UPDATING
    detailed_state string
    (string) - The state of the synced table. Possible values are: SYNCED_TABLE_OFFLINE, SYNCED_TABLE_OFFLINE_FAILED, SYNCED_TABLE_ONLINE, SYNCED_TABLE_ONLINE_CONTINUOUS_UPDATE, SYNCED_TABLE_ONLINE_NO_PENDING_UPDATE, SYNCED_TABLE_ONLINE_PIPELINE_FAILED, SYNCED_TABLE_ONLINE_TRIGGERED_UPDATE, SYNCED_TABLE_ONLINE_UPDATING_PIPELINE_RESOURCES, SYNCED_TABLE_PROVISIONING, SYNCED_TABLE_PROVISIONING_INITIAL_SNAPSHOT, SYNCED_TABLE_PROVISIONING_PIPELINE_RESOURCES
    last_processed_commit_version number
    (integer) - The last source table Delta version that was successfully synced to the synced table
    last_sync object
    (SyncedTablePosition) - Summary of the last successful synchronization from source to destination
    last_sync_time string
    (string) - The end timestamp of the last time any data was synchronized from the source table to the synced table. This is when the data is available in the synced table
    message string
    (string) - A text description of the current state of the synced table
    ongoing_sync_progress object
    (SyncedTablePipelineProgress)
    pipeline_id string
    (string) - ID of the associated pipeline
    project string
    (string) - The full resource name of the project associated with the table.
    provisioning_phase string
    (string) - The current phase of the data synchronization pipeline. Possible values are: PROVISIONING_PHASE_INDEX_SCAN, PROVISIONING_PHASE_INDEX_SORT, PROVISIONING_PHASE_MAIN
    unity_catalog_provisioning_state string
    (string) - The provisioning state of the synced table entity in Unity Catalog. Possible values are: ACTIVE, DEGRADED, DELETING, FAILED, PROVISIONING, UPDATING
    detailedState String
    (string) - The state of the synced table. Possible values are: SYNCED_TABLE_OFFLINE, SYNCED_TABLE_OFFLINE_FAILED, SYNCED_TABLE_ONLINE, SYNCED_TABLE_ONLINE_CONTINUOUS_UPDATE, SYNCED_TABLE_ONLINE_NO_PENDING_UPDATE, SYNCED_TABLE_ONLINE_PIPELINE_FAILED, SYNCED_TABLE_ONLINE_TRIGGERED_UPDATE, SYNCED_TABLE_ONLINE_UPDATING_PIPELINE_RESOURCES, SYNCED_TABLE_PROVISIONING, SYNCED_TABLE_PROVISIONING_INITIAL_SNAPSHOT, SYNCED_TABLE_PROVISIONING_PIPELINE_RESOURCES
    lastProcessedCommitVersion Integer
    (integer) - The last source table Delta version that was successfully synced to the synced table
    lastSync PostgresSyncedTableStatusLastSync
    (SyncedTablePosition) - Summary of the last successful synchronization from source to destination
    lastSyncTime String
    (string) - The end timestamp of the last time any data was synchronized from the source table to the synced table. This is when the data is available in the synced table
    message String
    (string) - A text description of the current state of the synced table
    ongoingSyncProgress PostgresSyncedTableStatusOngoingSyncProgress
    (SyncedTablePipelineProgress)
    pipelineId String
    (string) - ID of the associated pipeline
    project String
    (string) - The full resource name of the project associated with the table.
    provisioningPhase String
    (string) - The current phase of the data synchronization pipeline. Possible values are: PROVISIONING_PHASE_INDEX_SCAN, PROVISIONING_PHASE_INDEX_SORT, PROVISIONING_PHASE_MAIN
    unityCatalogProvisioningState String
    (string) - The provisioning state of the synced table entity in Unity Catalog. Possible values are: ACTIVE, DEGRADED, DELETING, FAILED, PROVISIONING, UPDATING
    detailedState string
    (string) - The state of the synced table. Possible values are: SYNCED_TABLE_OFFLINE, SYNCED_TABLE_OFFLINE_FAILED, SYNCED_TABLE_ONLINE, SYNCED_TABLE_ONLINE_CONTINUOUS_UPDATE, SYNCED_TABLE_ONLINE_NO_PENDING_UPDATE, SYNCED_TABLE_ONLINE_PIPELINE_FAILED, SYNCED_TABLE_ONLINE_TRIGGERED_UPDATE, SYNCED_TABLE_ONLINE_UPDATING_PIPELINE_RESOURCES, SYNCED_TABLE_PROVISIONING, SYNCED_TABLE_PROVISIONING_INITIAL_SNAPSHOT, SYNCED_TABLE_PROVISIONING_PIPELINE_RESOURCES
    lastProcessedCommitVersion number
    (integer) - The last source table Delta version that was successfully synced to the synced table
    lastSync PostgresSyncedTableStatusLastSync
    (SyncedTablePosition) - Summary of the last successful synchronization from source to destination
    lastSyncTime string
    (string) - The end timestamp of the last time any data was synchronized from the source table to the synced table. This is when the data is available in the synced table
    message string
    (string) - A text description of the current state of the synced table
    ongoingSyncProgress PostgresSyncedTableStatusOngoingSyncProgress
    (SyncedTablePipelineProgress)
    pipelineId string
    (string) - ID of the associated pipeline
    project string
    (string) - The full resource name of the project associated with the table.
    provisioningPhase string
    (string) - The current phase of the data synchronization pipeline. Possible values are: PROVISIONING_PHASE_INDEX_SCAN, PROVISIONING_PHASE_INDEX_SORT, PROVISIONING_PHASE_MAIN
    unityCatalogProvisioningState string
    (string) - The provisioning state of the synced table entity in Unity Catalog. Possible values are: ACTIVE, DEGRADED, DELETING, FAILED, PROVISIONING, UPDATING
    detailed_state str
    (string) - The state of the synced table. Possible values are: SYNCED_TABLE_OFFLINE, SYNCED_TABLE_OFFLINE_FAILED, SYNCED_TABLE_ONLINE, SYNCED_TABLE_ONLINE_CONTINUOUS_UPDATE, SYNCED_TABLE_ONLINE_NO_PENDING_UPDATE, SYNCED_TABLE_ONLINE_PIPELINE_FAILED, SYNCED_TABLE_ONLINE_TRIGGERED_UPDATE, SYNCED_TABLE_ONLINE_UPDATING_PIPELINE_RESOURCES, SYNCED_TABLE_PROVISIONING, SYNCED_TABLE_PROVISIONING_INITIAL_SNAPSHOT, SYNCED_TABLE_PROVISIONING_PIPELINE_RESOURCES
    last_processed_commit_version int
    (integer) - The last source table Delta version that was successfully synced to the synced table
    last_sync PostgresSyncedTableStatusLastSync
    (SyncedTablePosition) - Summary of the last successful synchronization from source to destination
    last_sync_time str
    (string) - The end timestamp of the last time any data was synchronized from the source table to the synced table. This is when the data is available in the synced table
    message str
    (string) - A text description of the current state of the synced table
    ongoing_sync_progress PostgresSyncedTableStatusOngoingSyncProgress
    (SyncedTablePipelineProgress)
    pipeline_id str
    (string) - ID of the associated pipeline
    project str
    (string) - The full resource name of the project associated with the table.
    provisioning_phase str
    (string) - The current phase of the data synchronization pipeline. Possible values are: PROVISIONING_PHASE_INDEX_SCAN, PROVISIONING_PHASE_INDEX_SORT, PROVISIONING_PHASE_MAIN
    unity_catalog_provisioning_state str
    (string) - The provisioning state of the synced table entity in Unity Catalog. Possible values are: ACTIVE, DEGRADED, DELETING, FAILED, PROVISIONING, UPDATING
    detailedState String
    (string) - The state of the synced table. Possible values are: SYNCED_TABLE_OFFLINE, SYNCED_TABLE_OFFLINE_FAILED, SYNCED_TABLE_ONLINE, SYNCED_TABLE_ONLINE_CONTINUOUS_UPDATE, SYNCED_TABLE_ONLINE_NO_PENDING_UPDATE, SYNCED_TABLE_ONLINE_PIPELINE_FAILED, SYNCED_TABLE_ONLINE_TRIGGERED_UPDATE, SYNCED_TABLE_ONLINE_UPDATING_PIPELINE_RESOURCES, SYNCED_TABLE_PROVISIONING, SYNCED_TABLE_PROVISIONING_INITIAL_SNAPSHOT, SYNCED_TABLE_PROVISIONING_PIPELINE_RESOURCES
    lastProcessedCommitVersion Number
    (integer) - The last source table Delta version that was successfully synced to the synced table
    lastSync Property Map
    (SyncedTablePosition) - Summary of the last successful synchronization from source to destination
    lastSyncTime String
    (string) - The end timestamp of the last time any data was synchronized from the source table to the synced table. This is when the data is available in the synced table
    message String
    (string) - A text description of the current state of the synced table
    ongoingSyncProgress Property Map
    (SyncedTablePipelineProgress)
    pipelineId String
    (string) - ID of the associated pipeline
    project String
    (string) - The full resource name of the project associated with the table.
    provisioningPhase String
    (string) - The current phase of the data synchronization pipeline. Possible values are: PROVISIONING_PHASE_INDEX_SCAN, PROVISIONING_PHASE_INDEX_SORT, PROVISIONING_PHASE_MAIN
    unityCatalogProvisioningState String
    (string) - The provisioning state of the synced table entity in Unity Catalog. Possible values are: ACTIVE, DEGRADED, DELETING, FAILED, PROVISIONING, UPDATING

    PostgresSyncedTableStatusLastSync, PostgresSyncedTableStatusLastSyncArgs

    DeltaTableSyncInfo PostgresSyncedTableStatusLastSyncDeltaTableSyncInfo
    (DeltaTableSyncInfo)
    SyncEndTime string
    (string) - The end timestamp of the most recent successful synchronization. This is the time when the data is available in the synced table
    SyncStartTime string
    (string) - The starting timestamp of the most recent successful synchronization from the source table to the destination (synced) table. Note this is the starting timestamp of the sync operation, not the end time. E.g., for a batch, this is the time when the sync operation started
    DeltaTableSyncInfo PostgresSyncedTableStatusLastSyncDeltaTableSyncInfo
    (DeltaTableSyncInfo)
    SyncEndTime string
    (string) - The end timestamp of the most recent successful synchronization. This is the time when the data is available in the synced table
    SyncStartTime string
    (string) - The starting timestamp of the most recent successful synchronization from the source table to the destination (synced) table. Note this is the starting timestamp of the sync operation, not the end time. E.g., for a batch, this is the time when the sync operation started
    delta_table_sync_info object
    (DeltaTableSyncInfo)
    sync_end_time string
    (string) - The end timestamp of the most recent successful synchronization. This is the time when the data is available in the synced table
    sync_start_time string
    (string) - The starting timestamp of the most recent successful synchronization from the source table to the destination (synced) table. Note this is the starting timestamp of the sync operation, not the end time. E.g., for a batch, this is the time when the sync operation started
    deltaTableSyncInfo PostgresSyncedTableStatusLastSyncDeltaTableSyncInfo
    (DeltaTableSyncInfo)
    syncEndTime String
    (string) - The end timestamp of the most recent successful synchronization. This is the time when the data is available in the synced table
    syncStartTime String
    (string) - The starting timestamp of the most recent successful synchronization from the source table to the destination (synced) table. Note this is the starting timestamp of the sync operation, not the end time. E.g., for a batch, this is the time when the sync operation started
    deltaTableSyncInfo PostgresSyncedTableStatusLastSyncDeltaTableSyncInfo
    (DeltaTableSyncInfo)
    syncEndTime string
    (string) - The end timestamp of the most recent successful synchronization. This is the time when the data is available in the synced table
    syncStartTime string
    (string) - The starting timestamp of the most recent successful synchronization from the source table to the destination (synced) table. Note this is the starting timestamp of the sync operation, not the end time. E.g., for a batch, this is the time when the sync operation started
    delta_table_sync_info PostgresSyncedTableStatusLastSyncDeltaTableSyncInfo
    (DeltaTableSyncInfo)
    sync_end_time str
    (string) - The end timestamp of the most recent successful synchronization. This is the time when the data is available in the synced table
    sync_start_time str
    (string) - The starting timestamp of the most recent successful synchronization from the source table to the destination (synced) table. Note this is the starting timestamp of the sync operation, not the end time. E.g., for a batch, this is the time when the sync operation started
    deltaTableSyncInfo Property Map
    (DeltaTableSyncInfo)
    syncEndTime String
    (string) - The end timestamp of the most recent successful synchronization. This is the time when the data is available in the synced table
    syncStartTime String
    (string) - The starting timestamp of the most recent successful synchronization from the source table to the destination (synced) table. Note this is the starting timestamp of the sync operation, not the end time. E.g., for a batch, this is the time when the sync operation started

    PostgresSyncedTableStatusLastSyncDeltaTableSyncInfo, PostgresSyncedTableStatusLastSyncDeltaTableSyncInfoArgs

    DeltaCommitTime string
    (string) - The timestamp when the above Delta version was committed in the source Delta table. Note: This is the Delta commit time, not the time the data was written to the synced table
    DeltaCommitVersion int
    (integer) - The Delta Lake commit version that was last successfully synced
    DeltaCommitTime string
    (string) - The timestamp when the above Delta version was committed in the source Delta table. Note: This is the Delta commit time, not the time the data was written to the synced table
    DeltaCommitVersion int
    (integer) - The Delta Lake commit version that was last successfully synced
    delta_commit_time string
    (string) - The timestamp when the above Delta version was committed in the source Delta table. Note: This is the Delta commit time, not the time the data was written to the synced table
    delta_commit_version number
    (integer) - The Delta Lake commit version that was last successfully synced
    deltaCommitTime String
    (string) - The timestamp when the above Delta version was committed in the source Delta table. Note: This is the Delta commit time, not the time the data was written to the synced table
    deltaCommitVersion Integer
    (integer) - The Delta Lake commit version that was last successfully synced
    deltaCommitTime string
    (string) - The timestamp when the above Delta version was committed in the source Delta table. Note: This is the Delta commit time, not the time the data was written to the synced table
    deltaCommitVersion number
    (integer) - The Delta Lake commit version that was last successfully synced
    delta_commit_time str
    (string) - The timestamp when the above Delta version was committed in the source Delta table. Note: This is the Delta commit time, not the time the data was written to the synced table
    delta_commit_version int
    (integer) - The Delta Lake commit version that was last successfully synced
    deltaCommitTime String
    (string) - The timestamp when the above Delta version was committed in the source Delta table. Note: This is the Delta commit time, not the time the data was written to the synced table
    deltaCommitVersion Number
    (integer) - The Delta Lake commit version that was last successfully synced

    PostgresSyncedTableStatusOngoingSyncProgress, PostgresSyncedTableStatusOngoingSyncProgressArgs

    EstimatedCompletionTimeSeconds double
    (number) - The estimated time remaining to complete this update in seconds
    LatestVersionCurrentlyProcessing int
    (integer) - The source table Delta version that was last processed by the pipeline. The pipeline may not have completely processed this version yet
    SyncProgressCompletion double
    (number) - The completion ratio of this update. This is a number between 0 and 1
    SyncedRowCount int
    (integer) - The number of rows that have been synced in this update
    TotalRowCount int
    (integer) - The total number of rows that need to be synced in this update. This number may be an estimate
    EstimatedCompletionTimeSeconds float64
    (number) - The estimated time remaining to complete this update in seconds
    LatestVersionCurrentlyProcessing int
    (integer) - The source table Delta version that was last processed by the pipeline. The pipeline may not have completely processed this version yet
    SyncProgressCompletion float64
    (number) - The completion ratio of this update. This is a number between 0 and 1
    SyncedRowCount int
    (integer) - The number of rows that have been synced in this update
    TotalRowCount int
    (integer) - The total number of rows that need to be synced in this update. This number may be an estimate
    estimated_completion_time_seconds number
    (number) - The estimated time remaining to complete this update in seconds
    latest_version_currently_processing number
    (integer) - The source table Delta version that was last processed by the pipeline. The pipeline may not have completely processed this version yet
    sync_progress_completion number
    (number) - The completion ratio of this update. This is a number between 0 and 1
    synced_row_count number
    (integer) - The number of rows that have been synced in this update
    total_row_count number
    (integer) - The total number of rows that need to be synced in this update. This number may be an estimate
    estimatedCompletionTimeSeconds Double
    (number) - The estimated time remaining to complete this update in seconds
    latestVersionCurrentlyProcessing Integer
    (integer) - The source table Delta version that was last processed by the pipeline. The pipeline may not have completely processed this version yet
    syncProgressCompletion Double
    (number) - The completion ratio of this update. This is a number between 0 and 1
    syncedRowCount Integer
    (integer) - The number of rows that have been synced in this update
    totalRowCount Integer
    (integer) - The total number of rows that need to be synced in this update. This number may be an estimate
    estimatedCompletionTimeSeconds number
    (number) - The estimated time remaining to complete this update in seconds
    latestVersionCurrentlyProcessing number
    (integer) - The source table Delta version that was last processed by the pipeline. The pipeline may not have completely processed this version yet
    syncProgressCompletion number
    (number) - The completion ratio of this update. This is a number between 0 and 1
    syncedRowCount number
    (integer) - The number of rows that have been synced in this update
    totalRowCount number
    (integer) - The total number of rows that need to be synced in this update. This number may be an estimate
    estimated_completion_time_seconds float
    (number) - The estimated time remaining to complete this update in seconds
    latest_version_currently_processing int
    (integer) - The source table Delta version that was last processed by the pipeline. The pipeline may not have completely processed this version yet
    sync_progress_completion float
    (number) - The completion ratio of this update. This is a number between 0 and 1
    synced_row_count int
    (integer) - The number of rows that have been synced in this update
    total_row_count int
    (integer) - The total number of rows that need to be synced in this update. This number may be an estimate
    estimatedCompletionTimeSeconds Number
    (number) - The estimated time remaining to complete this update in seconds
    latestVersionCurrentlyProcessing Number
    (integer) - The source table Delta version that was last processed by the pipeline. The pipeline may not have completely processed this version yet
    syncProgressCompletion Number
    (number) - The completion ratio of this update. This is a number between 0 and 1
    syncedRowCount Number
    (integer) - The number of rows that have been synced in this update
    totalRowCount Number
    (integer) - The total number of rows that need to be synced in this update. This number may be an estimate

    Package Details

    Repository
    databricks pulumi/pulumi-databricks
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the databricks Terraform Provider.
    databricks logo
    Viewing docs for Databricks v1.92.0
    published on Tuesday, May 12, 2026 by Pulumi
    Schema (JSON)
    pulumi/pulumi-databricks
      Try Pulumi Cloud free. Your team will thank you.