Synchronizuj dane z tabel Unity Catalog z instancją bazy danych

Ważne

Ta funkcja jest dostępna w wersji próbnej w następujących regionach: westus, westus2, eastus, eastus2, centralus, southcentralus, northeurope, westeurope, australiaeast, brazilsouth, canadacentral, centralindia, southeastasia, uksouth.

Na tej stronie opisano sposób tworzenia zsynchronizowanej tabeli i zarządzania nią. Zsynchronizowana tabela to tabela typu Postgres tylko do odczytu w ramach Unity Catalog, która automatycznie synchronizuje dane z tabeli Unity Catalog do twojego wystąpienia bazy danych Lakebase. Synchronizowanie tabeli katalogu Unity z bazą PostgreSQL umożliwia wykonywanie zapytań odczytu o niskich opóźnieniach i obsługuje łączenia w czasie wykonywania zapytania z innymi tabelami PostgreSQL.

Synchronizacja jest obsługiwana przez deklaratywne potoki Lakeflow Spark. Potok zarządzany stale aktualizuje tabelę Postgres zmianami z tabeli źródłowej. Po utworzeniu, synchronizowane tabele można zapytaniać bezpośrednio przy użyciu narzędzi Postgres.

Kluczowe cechy zsynchronizowanych tabel są następujące:

Tylko do odczytu w usłudze Postgres w celu zachowania integralności danych ze źródłem
Automatyczna synchronizacja przy użyciu zarządzanych potoków deklaratywnych platformy Spark w usłudze Lakeflow
Wykonywanie zapytań za pomocą standardowych interfejsów PostgreSQL
Zarządzana za pośrednictwem Unity Catalog w celu zarządzania danymi i cyklem życia.

Zanim rozpoczniesz

Masz tabelę Unity Catalog w dowolnym katalogu.
Masz CAN USE uprawnienia do instancji bazy danych.

Tworzenie zsynchronizowanej tabeli

interfejs użytkownika

Aby zsynchronizować tabelę z Unity Catalog w bazie danych Postgres, wykonaj następujące czynności:

Kliknij pozycję Wykaz na pasku bocznym obszaru roboczego.
Znajdź i wybierz tabelę Katalogu Unity, na której chcesz utworzyć zsynchronizowaną tabelę.
Kliknij pozycję Utwórz>zsynchronizowaną tabelę.
Wybierz katalog, schemat i wprowadź nazwę tabeli dla nowej zsynchronizowanej tabeli.
- Zsynchronizowane tabele można również tworzyć w standardowych katalogach, przy pewnej dodatkowej konfiguracji. Wybierz katalog standardowy, schemat i wprowadź nazwę tabeli dla nowo utworzonej zsynchronizowanej tabeli.
Wybierz wystąpienie bazy danych i wprowadź nazwę bazy danych Postgres, w której ma zostać utworzona zsynchronizowana tabela. Pole bazy danych Postgres jest domyślnie domyślne dla aktualnie wybranego katalogu docelowego. Jeśli baza danych Postgres nie istnieje pod tą nazwą, usługa Azure Databricks utworzy nową bazę danych.
Wybierz klucz podstawowy. Klucz podstawowy jest wymagany , ponieważ umożliwia wydajny dostęp do wierszy dla operacji odczytu, aktualizacji i usuwania.

Ważne

Kolumny w kluczu podstawowym nie mogą zawierać wartości null w zsynchronizowanej tabeli. W związku z tym wiersze z wartościami null w kolumnach klucza podstawowego są wykluczone z synchronizacji.
Jeśli dwa wiersze mają ten sam klucz podstawowy w tabeli źródłowej, wybierz klucz timeseries , aby skonfigurować deduplikację. Po określeniu klucza szeregów czasowych zsynchronizowane tabele zawierają tylko te wiersze, które mają najnowszą wartość klucza szeregów czasowych dla każdego klucza podstawowego.
Wybierz tryb synchronizacji: Migawka, Wyzwalany lub Ciągły. Aby uzyskać więcej informacji na temat poszczególnych trybów synchronizacji, zobacz Objaśnione tryby synchronizacji.
Wybierz, czy chcesz utworzyć tę zsynchronizowaną tabelę z nowego lub istniejącego pola.
- Jeśli tworzysz nowy rurociąg i używasz zarządzanego katalogu, wybierz lokalizację miejsca przechowywania dla tabeli przejściowej. W przypadku korzystania ze standardowego wykazu tabela przejściowa jest automatycznie przechowywana w wykazie.
- Jeśli używasz istniejącego pipeline'u, sprawdź, czy nowy tryb synchronizacji jest zgodny z trybem pipeline'u.
(Opcjonalnie) Wybierz zasady budżetu bezserwerowego. Aby utworzyć bezserwerowe zasady budżetu, zobacz Użycie atrybutów z bezserwerowymi zasadami budżetu. Dzięki temu można przypisywać użycie rozliczeń do określonych zasad użycia.
- W przypadku zsynchronizowanych tabel rozliczaną jednostką jest bazowy potok deklaratywny Lakeflow Spark. Aby zmodyfikować politykę budżetową, zmodyfikuj obiekt potoku bazowego. Zobacz Jak skonfigurować potok bezserwerowy.
Gdy stan zsynchronizowanej tabeli to Online, zaloguj się do wystąpienia bazy danych i wykonaj zapytanie dotyczące nowo utworzonej tabeli. Wykonywanie zapytań względem tabeli przy użyciu edytora SQL, narzędzi zewnętrznych lub notesów.

Zestaw SDK dla języka Python

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.database import SyncedDatabaseTable, SyncedTableSpec, NewPipelineSpec, SyncedTableSchedulingPolicy

# Initialize the Workspace client
w = WorkspaceClient()

# Create a synced table in a database catalog
synced_table = w.database.create_synced_database_table(
    SyncedDatabaseTable(
        name="database_catalog.schema.synced_table",  # Full three-part name
        spec=SyncedTableSpec(
            source_table_full_name="source_catalog.source_schema.source_table",
            primary_key_columns=["id"],  # Primary key columns
            scheduling_policy=SyncedTableSchedulingPolicy.TRIGGERED,  # SNAPSHOT, TRIGGERED, or CONTINUOUS
            # Optional: timeseries_key="timestamp"  # For deduplication
            new_pipeline_spec=NewPipelineSpec(
                storage_catalog="storage_catalog",
                storage_schema="storage_schema"
            )
        ),
    )
)
print(f"Created synced table: {synced_table.name}")

# Create a synced table in a standard UC catalog
synced_table = w.database.create_synced_database_table(
    SyncedDatabaseTable(
        name="standard_catalog.schema.synced_table",  # Full three-part name
        database_instance_name="my-database-instance",  # Required for standard catalogs
        logical_database_name="postgres_database",  # Required for standard catalogs
        spec=SyncedTableSpec(
            source_table_full_name="source_catalog.source_schema.source_table",
            primary_key_columns=["id"],
            scheduling_policy=SyncedTableSchedulingPolicy.CONTINUOUS,
            create_database_objects_if_missing=True,  # Create database/schema if needed
            new_pipeline_spec=NewPipelineSpec(
                storage_catalog="storage_catalog",
                storage_schema="storage_schema"
            )
        ),
    )
)
print(f"Created synced table: {synced_table.name}")

# Check the status of a synced table
synced_table_name = "database_catalog.schema.synced_table"
status = w.database.get_synced_database_table(name=synced_table_name)
print(f"Synced table status: {status.data_synchronization_status.detailed_state}")
print(f"Status message: {status.data_synchronization_status.message}")

CLI

# Create a synced table in a database catalog
databricks database create-synced-database-table  \
  --json '{
    "spec": {
      "name": "database_catalog.schema.synced_table",
      "source_table_full_name": "source_catalog.source_schema.source_table",
      "primary_key_columns": ["id"],
      "scheduling_policy": "TRIGGERED"
    },
    "new_pipeline_spec": {
      "storage_catalog": "storage_catalog",
      "storage_schema": "storage_schema"
    }
  }'

# Create a synced table in a standard UC catalog
# new_pipeline_spec, storage_catalog, and storage_schema are optional
databricks database create-synced-database-table \
  --database-instance-name "my-database-instance" \
  --logical-database-name "databricks_postgres" \
  --json '{
    "name": "standard_catalog.schema.synced_table",
    "spec": {
      "source_table_full_name": "source_catalog.source_schema.source_table",
      "primary_key_columns": ["id"],
      "scheduling_policy": "CONTINUOUS",
      "create_database_objects_if_missing": true
    }
  }'

# Check the status of a synced table
databricks database get-synced-database-table "database_catalog.schema.synced_table"

skręt

Utwórz zsynchronizowaną tabelę w wykazie baz danych.

export CATALOG_NAME=<Database catalog>
export SRC_TBL="source_catalog.source_schema.source_table"
export DEST_TBL="$CATALOG_NAME.some_schema.synced_table"
export PKS='["id"]'
export ST_CATALOG = "storage_catalog"
export ST_SCHEMA = "storage_schema"

curl -X POST https://$WORKSPACE/api/2.0/database/synced_tables \
-H "Content-Type: text/json" \
-H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
--data-binary @- << EOF
{
  "name": "$DEST_TBL",
  "spec": {
    "source_table_full_name": "$SRC_TBL",
    "primary_key_columns": $PKS,
    "scheduling_policy": "TRIGGERED",
  },
  "new_pipeline_spec": {
    "storage_catalog": "$ST_CATALOG",
    "storage_schema": "$ST_SCHEMA",
  }
}
EOF

Utwórz zsynchronizowaną tabelę w standardowym katalogu Unity Catalog.

export CATALOG_NAME=<Standard catalog>
export DATABASE_INSTANCE=<database instance>
export POSTGRES_DATABASE=$CATALOG_NAME
export SRC_TBL="source_catalog.source_schema.source_table"
export DEST_TBL="$CATALOG_NAME.some_schema.sync_table"
export PKS='["id"]'
export ST_CATALOG = "storage_catalog"
export ST_SCHEMA = "storage_schema"

curl -X POST https://$WORKSPACE/api/2.0/database/synced_tables \
-H "Content-Type: text/json" \
-H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
--data-binary @- << EOF
{
  "name": "$DEST_TBL",
  "database_instance_name": "$DATABASE_INSTANCE",
  "logical_database_name": "$POSTGRES_DATABASE",
  "spec": {
    "source_table_full_name": "$SRC_TBL",
    "primary_key_columns": $PKS,
    "scheduling_policy": "TRIGGERED",
  },
  "new_pipeline_spec": {
    "storage_catalog": "$ST_CATALOG",
    "storage_schema": "$ST_SCHEMA",
  }
}
EOF

Sprawdź stan zsynchronizowanej tabeli.

export SYNCEDTABLE='pg_db.silver.sbtest1_online'

curl --request GET \
  "https://e2-dogfood.staging.cloud.databricks.com/api/2.0/database/synced_tables/$SYNCEDTABLE" \
  --header "Authorization: Bearer dapi..."

Objaśnione tryby synchronizacji

Zsynchronizowana tabela może zostać utworzona przy użyciu jednego z następujących trybów synchronizacji, który określa, jak dane są synchronizowane ze źródła do zsynchronizowanej tabeli w usłudze Postgres:

Tryb synchronizacji	Description	Performance
Migawka	Pipeline jest uruchamiana raz, aby utworzyć migawkę tabeli źródłowej i skopiować ją do zsynchronizowanej tabeli. Kolejne uruchomienia potoku kopiują całe dane źródłowe do miejsca docelowego i zastępują je atomowo. "Pipeline można wyzwalać ręcznie, za pośrednictwem API lub zgodnie z harmonogramem."	Ten tryb jest 10 razy bardziej wydajny niż tryby wyzwalania lub ciągłej synchronizacji, ponieważ odtwarza dane od podstaw. Jeśli modyfikujesz więcej niż 10% tabeli źródłowej, rozważ użycie tego trybu.
Wywołany	Pipeline jest uruchamiana raz, aby utworzyć migawkę tabeli źródłowej i skopiować ją do zsynchronizowanej tabeli. W przeciwieństwie do trybu synchronizacji migawki, gdy zsynchronizowana tabela jest odświeżona, tylko zmiany od czasu ostatniego wykonania potoku są pobierane i stosowane do zsynchronizowanej tabeli. Odświeżanie przyrostowe można wyzwalać ręcznie za pośrednictwem interfejsu API lub zgodnie z harmonogramem.	Ten tryb jest dobrym kompromisem między opóźnieniem a kosztem, ponieważ działa na żądanie i stosuje tylko zmiany od ostatniego uruchomienia. Aby zminimalizować opóźnienie, uruchom ten potok natychmiast po zaktualizowaniu tabeli źródłowej. Jeśli uruchamiasz to częściej niż co 5 minut, może to być droższe niż tryb ciągły ze względu na koszt uruchamiania i zatrzymywania potoku za każdym razem.
Ciągły	Pipeline jest uruchamiany raz, aby utworzyć migawkę tabeli źródłowej i skopiować ją do zsynchronizowanej tabeli, a następnie działa w sposób ciągły. Kolejne zmiany w tabeli źródłowej są przyrostowo stosowane do zsynchronizowanej tabeli w czasie rzeczywistym. Nie jest konieczne ręczne odświeżanie.	Ten tryb ma najniższe opóźnienie, ale wyższe koszty, ponieważ jest stale uruchomiony.

Uwaga / Notatka

Aby obsługiwać tryb wyzwalania lub ciągłej synchronizacji, tabela źródłowa musi mieć włączoną opcję Zmień źródło danych. Niektóre źródła (takie jak widoki) nie obsługują zestawienia zmian danych, dzięki czemu mogą być synchronizowane tylko w trybie migawki.

Obsługiwane operacje

Usługa Databricks zaleca wykonywanie tylko następujących operacji w usłudze Postgres dla zsynchronizowanych tabel, aby zapobiec przypadkowemu zastąpieniu lub niespójności danych:

Zapytania tylko do odczytu
Tworzenie indeksów
Usuwanie tabeli (aby zwolnić miejsce po usunięciu zsynchronizowanej tabeli z Unity Catalog)

Chociaż możesz zmodyfikować tę tabelę na inny sposób, zakłóca ona potok synchronizacji.

Usuwanie zsynchronizowanej tabeli

Aby usunąć zsynchronizowaną tabelę, musisz ją usunąć z Unity Catalog, a następnie upuścić tabelę w instancji bazy danych. Usunięcie zsynchronizowanej tabeli z katalogu Unity powoduje wyrejestrowanie tabeli i zatrzymanie wszelkich odświeżeń danych. Jednak tabela pozostaje w bazowej bazie danych Postgres. Aby zwolnić miejsce w instancji bazy danych, połącz się z nią i użyj polecenia DROP TABLE.

interfejs użytkownika

Kliknij pozycję Wykaz na pasku bocznym obszaru roboczego.
Znajdź i wybierz zsynchronizowaną tabelę, którą chcesz usunąć.
Kliknij >Usuń.
Nawiąż połączenie z wystąpieniem za pomocą psql, edytora SQL lub notesu.

Usuń tabelę w PostgreSQL.

DROP TABLE synced_table_database.synced_table_schema.synced_table

Zestaw SDK dla języka Python

from databricks.sdk import WorkspaceClient

# Initialize the Workspace client
w = WorkspaceClient()

# Delete a synced table from UC
synced_table_name = "catalog.schema.synced_table"
w.database.delete_synced_database_table(name=synced_table_name)
print(f"Deleted synced table from UC: {synced_table_name}")

# To free up space in your database instance, you need to connect to the
# instance and drop the table using PostgreSQL:
#
# DROP TABLE synced_table_database.synced_table_schema.synced_table;

CLI

# Delete a synced table from UC
databricks database delete-synced-database-table "catalog.schema.synced_table"

# To free up space in your database instance, you need to connect to the
# instance and drop the table using PostgreSQL:
#
# DROP TABLE synced_table_database.synced_table_schema.synced_table;

skręt

# Delete a synced table from UC
curl -X DELETE --header "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  https://$WORKSPACE/api/2.0/database/synced_tables/$SYNCED_TABLE_NAME

# To free up space in your database instance, you need to connect to the
# instance and drop the table using PostgreSQL:
#
# DROP TABLE synced_table_database.synced_table_schema.synced_table;

Własność i uprawnienia

W przypadku utworzenia nowej bazy danych Postgres, schematu lub tabeli własność bazy danych Postgres jest ustawiona w następujący sposób:

Własność jest przypisywana użytkownikowi tworzącemu bazę danych, schemat lub tabelę, pod warunkiem że jego identyfikator logowania Azure Databricks istnieje jako rola w Postgresie. Aby dodać rolę tożsamości usługi Azure Databricks w usłudze Postgres, zobacz Zarządzanie rolami Postgres.
W przeciwnym razie własność jest przypisywana właścicielowi obiektu nadrzędnego w systemie Postgres (zazwyczaj databricks_superuser).

Zarządzanie dostępem do zsynchronizowanej tabeli

Po utworzeniu databricks_superuser zsynchronizowanej tabeli można zsynchronizować READ tabelę z bazy danych Postgres. databricks_superuser ma pg_read_all_data, co pozwala tej roli na odczytywanie z wszystkich tabel. Ma również uprawnienie pg_write_all_data, które pozwala tej roli zapisywać we wszystkich tabelach. Oznacza to, że databricks_superuser obiekt może również zapisywać w zsynchronizowanej tabeli w usłudze Postgres. Lakebase obsługuje ten proces zapisu w przypadku konieczności wprowadzenia pilnych zmian w tabeli docelowej. Jednak Databricks zaleca wprowadzanie poprawek w waszej tabeli źródłowej.

Program databricks_superuser może również przyznać te uprawnienia innym użytkownikom:

GRANT USAGE ON SCHEMA synced_table_schema TO user;

GRANT SELECT ON synced_table_name TO user;

databricks_superuser może odwołać te uprawnienia:

REVOKE USAGE ON SCHEMA synced_table_schema FROM user;

REVOKE {SELECT | INSERT | UPDATE | DELETE} ON synced_table_name FROM user;

Zarządzanie operacjami synchronizowanej tabeli

Narzędzie databricks_superuser może zarządzać użytkownikami autoryzowanymi do wykonywania określonych operacji w zsynchronizowanej tabeli. Obsługiwane operacje dla zsynchronizowanych tabel to:

CREATE INDEX
ALTER INDEX
DROP INDEX
DROP TABLE

Wszystkie inne operacje DDL są odrzucane w przypadku zsynchronizowanych tabel.

Aby udzielić tych uprawnień dodatkowym użytkownikom, databricks_superuser należy najpierw utworzyć rozszerzenie w systemie databricks_auth:

CREATE EXTENSION IF NOT EXISTS databricks_auth;

databricks_superuser może następnie dodać użytkownika do zarządzania zsynchronizowaną tabelą.

SELECT databricks_synced_table_add_manager('"synced_table_schema"."synced_table"'::regclass, '[user]');

databricks_superuser może usunąć użytkownika z zarządzania zsynchronizowaną tabelą.

SELECT databricks_synced_table_remove_manager('[table]', '[user]');

databricks_superuser może wyświetlać wszystkich menedżerów.

SELECT * FROM databricks_synced_table_managers;

Mapowanie typu danych

Ta tabela mapowania typów definiuje mapowanie poszczególnych typów danych w źródłowej tabeli Unity Catalog na docelową tabelę synchronizacji w bazie danych Postgres.

Typ kolumny źródłowej	Typ kolumny Postgres
BIGINT	BIGINT
DWÓJKOWY	BYTEA
BOOLOWSKI	BOOLEAN
DATA	DATE
DECIMALNY (p, s)	Liczbowy
DOUBLE	PODWÓJNA PRECYZJA
SPŁAWIK	PRAWDZIWY
INT	INTEGER
Interwał interwałuQualifier	INTERWAŁ
SMALLINT	SMALLINT
STRUNA	TEKST
ZNAZNIK CZASU	SYGNATURA CZASOWA ZE STREFĄ CZASOWĄ
TIMESTAMP_NTZ	ZNACZNIK CZASU BEZ STREFY CZASOWEJ
TINYINT	SMALLINT
GEOGRAPHY (srid)	NIE OBSŁUGIWANE
GEOMETRY(srid)	NIE OBSŁUGIWANE
ARRAY < , typ elementu >	JSONB
MAP < keyType,valueType >	JSONB
< Struktura [fieldName: fieldType [NOT NULL][COMMENT str][, ...]] >	JSONB
WARIANT	JSONB
OBIEKT	NIE OBSŁUGIWANE

Uwaga / Notatka

Mapowanie typów ARRAY, MAP i STRUCT zostało zmienione w maju 2025 r. Zsynchronizuj tabele utworzone wcześniej, aby nadal mapować te typy na dane JSON.
Mapowanie dla ZNACZNIKA CZASU zostało zmienione w sierpniu 2025 r. Synchronizuj tabele utworzone wcześniej, aby nadal mapować je na ZNACZNIK CZASU BEZ STREFY CZASOWEJ.

Obsługa nieprawidłowych znaków

Niektóre znaki, takie jak bajt o wartości null (0x00), są dozwolone w STRING kolumnach, ARRAY, MAP lub STRUCT w tabelach Delta, ale nie są obsługiwane w kolumnach Postgres TEXT lub JSONB. W związku z tym synchronizowanie takich danych z Delta do bazy danych Postgres może prowadzić do niepowodzeń wstawiania z powodu błędów:

org.postgresql.util.PSQLException: ERROR: invalid byte sequence for encoding "UTF8": 0x00

org.postgresql.util.PSQLException: ERROR: unsupported Unicode escape sequence DETAIL: \u0000 cannot be converted to text.

Pierwszy błąd występuje, gdy bajt null pojawia się w kolumnie ciągu najwyższego poziomu, która mapuje się bezpośrednio na Postgres TEXT.
Drugi błąd występuje, gdy bajt null pojawia się w ciągu zagnieżdżonym wewnątrz typu złożonego (STRUCT, ARRAYlub MAP), który usługa Azure Databricks serializuje jako JSONB. Podczas serializacji wszystkie ciągi są rzutowane na Postgres TEXT, gdzie \u0000 jest niedozwolone.

Jak rozwiązać problem:

Ten problem można rozwiązać w jeden z następujących sposobów:

Oczyszczanie pól ciągów znaków

Usuń lub zastąp nieobsługiwane znaki ze wszystkich pól tekstowych, w tym także wewnątrz typów złożonych, przed zsynchronizowaniem z bazą danych Postgres.

Aby usunąć bajty null z kolumny najwyższego poziomu STRING , użyj REPLACE funkcji :
```
SELECT REPLACE(column_name, CAST(CHAR(0) AS STRING), '') AS cleaned_column FROM your_table;
```
Konwertowanie na dane binarne (tylko dla STRING kolumn)

Jeśli zachowanie nieprzetworzonej zawartości bajtów jest konieczne, przekonwertuj kolumny, których dotyczy problem STRING , na BINARY.

Ograniczenia i zagadnienia

Obsługiwane tabele źródłowe

W zależności od trybu synchronizacji zsynchronizowanej tabeli obsługiwane są różne typy tabel źródłowych:

W przypadku trybu migawki tabela źródłowa musi obsługiwać wartość SELECT *. Przykłady obejmują tabele delty, tabele góry lodowej, widoki, zmaterializowane widoki i inne podobne typy.
W przypadku trybów wyzwalanej lub ciągłej synchronizacji tabela źródłowa musi również mieć włączone zestawienie danych zmian .

Ograniczenia nazewnictwa i identyfikatora

Dozwolone znaki: Nazwy baz danych, schematu i tabeli bazy danych Postgres dla zsynchronizowanych tabel mogą zawierać tylko znaki alfanumeryczne i podkreślenia ([A-Za-z0-9_]+). Łączniki (-) i inne znaki specjalne nie są obsługiwane.
Identyfikatory kolumn i tabel: Unikaj używania wielkich liter lub znaków specjalnych w nazwach kolumn lub tabel w tabeli katalogu Unity. Jeśli są przechowywane, należy zacytować te identyfikatory podczas odwoływania się do nich w usłudze Postgres.

Wydajność a synchronizacja

Szybkość synchronizacji: Synchronizowanie danych z zsynchronizowanymi tabelami może być wolniejsze niż zapisywanie danych bezpośrednio w wystąpieniu bazy danych przy użyciu natywnego klienta PostgreSQL z powodu dodatkowego przetwarzania. Tryb ciągłej synchronizacji odświeża dane z tabeli zarządzanej przez Unity Catalog do zsynchronizowanej tabeli z minimalnym interwałem 15 sekund.
Użycie połączenia: Każda synchronizacja tabel może używać maksymalnie 16 połączeń z wystąpieniem bazy danych, które wliczają się do limitu połączeń wystąpienia.
Idempotentność interfejsu API: Zsynchronizowane interfejsy API tabeli są idempotentne i może być konieczne ponowienie prób w przypadku wystąpienia błędów w celu zapewnienia terminowego wykonania operacji.
Zmiany schematu: W przypadku zsynchronizowanych tabel w trybie Triggered lub Continuous, tylko zmiany schematu dodawane (np. dodanie nowej kolumny) z tabel katalogu Unity są odzwierciedlane w zsynchronizowanych tabelach.
Zduplikowane klucze: Jeśli dwa wiersze mają ten sam klucz podstawowy w tabeli źródłowej, potok synchronizacji zakończy się niepowodzeniem, chyba że skonfigurowano deduplikację przy użyciu klucza timeseries. Jednak użycie timeseries Key wiąże się z karą za wydajność.
Częstotliwość aktualizacji: Potok synchronizacji obsługuje operacje zapisu ciągłego na około 1200 wierszy na sekundę na jednostkę pojemności (CU) i operacje zapisu zbiorczego na maksymalnie 15 000 wierszy na sekundę na jednostkę cu.

Pojemność i limity

Limity stołu:
- Limit 20 zsynchronizowanych tabel na tabelę źródłową.
- Każda synchronizacja tabel może używać maksymalnie 16 połączeń bazy danych.
Limity rozmiaru i pełne odświeżanie:
- Jeśli odświeżysz pełną zsynchronizowaną tabelę, stara wersja w usłudze Postgres nie zostanie usunięta, dopóki nowa tabela nie zostanie zsynchronizowana. Obie wersje tymczasowo są uwzględniane w limicie rozmiaru logicznej bazy danych podczas odświeżania.
- Pojedyncze zsynchronizowane tabele nie mają limitu, ale łączny limit rozmiaru danych logicznych we wszystkich tabelach w wystąpieniu wynosi 2 TB. Jeśli jednak potrzebujesz odświeżeń zamiast pełnego odtworzenia tabeli, Databricks zaleca, aby nie przekraczać 1 TB.
- Jeśli nieskompresowany rozmiar tabeli Unity Catalog w formacie wiersza przekracza limit rozmiaru instancji bazy danych (2 TB), synchronizacja się nie powiedzie. Przed zapisaniem dalej w wystąpieniu należy usunąć zsynchronizowaną tabelę w usłudze Postgres.

Integracja katalogu

Duplikowanie katalogu: Utworzenie zsynchronizowanej tabeli w standardowym katalogu przeznaczonym dla bazy danych Postgres, która jest również zarejestrowana jako oddzielny katalog baz danych, powoduje, że zsynchronizowana tabela będzie wyświetlana w Unity Catalog zarówno w katalogu standardowym, jak i katalogach baz danych.

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-10-23

Udostępnij przez

Synchronizuj dane z tabel Unity Catalog z instancją bazy danych

Zanim rozpoczniesz

Tworzenie zsynchronizowanej tabeli

interfejs użytkownika

Zestaw SDK dla języka Python

CLI

skręt

Objaśnione tryby synchronizacji

Obsługiwane operacje

Usuwanie zsynchronizowanej tabeli

interfejs użytkownika

Zestaw SDK dla języka Python

CLI

skręt

Własność i uprawnienia

Zarządzanie dostępem do zsynchronizowanej tabeli

Zarządzanie operacjami synchronizowanej tabeli

Mapowanie typu danych

Obsługa nieprawidłowych znaków

Ograniczenia i zagadnienia

Obsługiwane tabele źródłowe

Ograniczenia nazewnictwa i identyfikatora

Wydajność a synchronizacja

Pojemność i limity

Integracja katalogu

Sprzężenie zwrotne

Dodatkowe źródła