Gerenciar branches

Crie e gerencie branches para dar suporte a diferentes fluxos de trabalho de desenvolvimento, cenários de teste e ambientes de produção. Os branches permitem que você trabalhe com ambientes de banco de dados isolados sem afetar a produção.

Noções básicas sobre branches

Visão geral do branch

Uma ramificação no Lakebase Postgres é um ambiente de banco de dados independente que compartilha armazenamento com a ramificação pai por copy-on-write. As ramificações permitem que você:

• Criar ambientes de desenvolvimento e teste isolados
• Testar aplicativos em conjuntos de dados realistas
• Implementar fluxos de trabalho de desenvolvimento de banco de dados

Tipos e estratégias de ramificação

Ao criar um branch, você pode escolher entre várias opções, dependendo de suas necessidades específicas. Cada opção cria um branch com diferentes características de dados e casos de uso.

Expiração do branch

O término de ramificação permite definir carimbos de data/hora de exclusão automática nas ramificações. Quando um branch atinge seu tempo de expiração, ele é excluído automaticamente. Esse recurso ajuda a gerenciar ramificações temporárias e reduzir os custos de armazenamento.

Por que usar o término de ramificação

O término de ramificação é ideal para ramificações temporárias com vida útil previsível:

• Ambientes de CI/CD: ramificações de teste que devem ser limpas após a conclusão do pipeline.
• Desenvolvimento de recursos: ramificações de recurso com prazo definido e datas conhecidas.
• Teste automatizado: Ambientes de teste efêmeros criados por scripts.
• Fluxos de trabalho de desenvolvimento: Ambientes temporários que não precisam persistir indefinidamente.

Sem a expiração automática, essas ramificações se acumulam ao longo do tempo, aumentando os custos de armazenamento e a desordem do projeto.

Como funciona o término de ramificação

O término de ramificação usa um modelo de TTL (vida útil). Ao definir uma expiração em um branch, você está definindo quanto tempo o branch deve existir antes da exclusão automática.

Quando você define um carimbo de data/hora de término em uma ramificação:

1. O sistema armazena o timestamp de expiração (a data e hora agendadas em que o branch será deletado) e o intervalo TTL (a duração entre a criação e/ou atualização e a expiração)
2. Um processo em segundo plano monitora os ramos e os exclui depois que o tempo de expiração é atingido
3. Se você redefinir uma ramificação com base no pai, a contagem regressiva do TTL reiniciará usando o intervalo original

Restrições do término de ramificação

Para manter a integridade do sistema, os carimbos de data/hora de expiração não podem ser adicionados a:

• Ramificações protegidas: não é possível expirar ramificações protegidas nem proteger ramificações com término.
• Branches padrão: Não é possível expirar branches padrão nem definir branches com expiração como padrão.
• Ramificações pai: não é possível expirar ramificações que têm filhos nem criar filhos a partir de ramificações em término.

Período máximo de expiração

O período de expiração máximo é de 30 dias a partir da hora atual. Se você precisar que uma ramificação persista por mais de 30 dias, poderá atualizar o carimbo de data/hora de término antes que ele expire para estender sua vida útil.

Criar e gerenciar branches

Criar uma ramificação

Para criar um ramo:

interface do usuário

1. Navegue até a página Branches do projeto no Aplicativo Lakebase.
2. Clique em Criar branch e configure suas opções de branch:
   • Digite um nome de ramificação (obrigatório)
   • Selecione uma opção de ramificação (Dados e esquema da ramificação ou Dados e esquema da ramificação de um ponto anterior no tempo)
   • Opcionalmente, configure a expiração usando a lista suspensa Exclusão automática: escolha uma predefinição (Após 1 hora, Após 1 dia ou Após 7 dias), um valor personalizado (até 30 dias) ou Nunca para sem expiração. Consulte Término de ramificação para obter detalhes.
3. Clique em Criar para criar o branch.

SDK do Python

Especifique uma política de expiração usando uma das seguintes opções em BranchSpec:

• ttl: um Duration objeto (exemplo: Duration(seconds=604800) por 7 dias)
• expire_time: uma data de validade específica datetime
• no_expiry=True: para branches que nunca devem expirar

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Branch, BranchSpec, Duration

w = WorkspaceClient()

# Create branch with 7-day expiration
branch_spec = BranchSpec(
    ttl=Duration(seconds=604800),  # 7 days
    source_branch="projects/my-project/branches/production"
)

branch = Branch(spec=branch_spec)

result = w.postgres.create_branch(
    parent="projects/my-project",
    branch=branch,
    branch_id="development"
).wait()

print(f"Branch created: {result.name}")
print(f"Expires: {result.status.expire_time}")

Para criar um branch permanente sem expiração, defina no_expiry=True no BranchSpec:

# Create a permanent branch (no expiration)
branch_spec = BranchSpec(
    source_branch="projects/my-project/branches/production",
    no_expiry=True
)

branch = Branch(spec=branch_spec)

result = w.postgres.create_branch(
    parent="projects/my-project",
    branch=branch,
    branch_id="staging"
).wait()

print(f"Branch created: {result.name}")

SDK do Java

Especifique uma política de expiração usando uma das seguintes opções em BranchSpec:

• setTtl(Duration): um com.google.protobuf.Duration objeto (exemplo: Duration.newBuilder().setSeconds(604800L).build() por 7 dias)
• setExpireTime(Timestamp): uma data de validade específica com.google.protobuf.Timestamp
• setNoExpiry(true): para branches que nunca devem expirar

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.*;
import com.google.protobuf.Duration;

WorkspaceClient w = new WorkspaceClient();

// Create branch with 7-day expiration
BranchSpec branchSpec = new BranchSpec()
    .setTtl(Duration.newBuilder().setSeconds(604800L).build())  // 7 days
    .setSourceBranch("projects/my-project/branches/production");

Branch branch = new Branch().setSpec(branchSpec);

Branch result = w.postgres().createBranch(
    new CreateBranchRequest()
        .setParent("projects/my-project")
        .setBranch(branch)
        .setBranchId("development")
).waitForCompletion();

System.out.println("Branch created: " + result.getName());
System.out.println("Expires: " + result.getStatus().getExpireTime());

Para criar um branch permanente sem expiração, defina no_expiry=true no BranchSpec:

// Create a permanent branch (no expiration)
BranchSpec branchSpec = new BranchSpec()
    .setSourceBranch("projects/my-project/branches/production")
    .setNoExpiry(true);

Branch branch = new Branch().setSpec(branchSpec);

Branch result = w.postgres().createBranch(
    new CreateBranchRequest()
        .setParent("projects/my-project")
        .setBranch(branch)
        .setBranchId("staging")
).waitForCompletion();

System.out.println("Branch created: " + result.getName());

CLI

Especifique uma política de expiração usando um dos seguintes campos no spec JSON:

• ttl: cadeia de caracteres de duração (exemplo: "604800s" por 7 dias)
• expire_time: carimbo de data/hora ISO 8601 (exemplo: "2025-01-15T10:30:00Z")
• no_expiry: true: para branches que nunca devem expirar

# Create a branch with 7-day expiration
databricks postgres create-branch projects/my-project development \
  --json '{
    "spec": {
      "source_branch": "projects/my-project/branches/production",
      "ttl": "604800s"
    }
  }'

# Create a permanent branch (no expiration)
databricks postgres create-branch projects/my-project staging \
  --json '{
    "spec": {
      "source_branch": "projects/my-project/branches/production",
      "no_expiry": true
    }
  }'

curl

Especifique uma política de expiração usando um dos seguintes campos no JSON do corpo da solicitação:

• ttl: cadeia de caracteres de duração (exemplo: "604800s" por 7 dias)
• expire_time: carimbo de data/hora ISO 8601 (exemplo: "2025-01-15T10:30:00Z")
• no_expiry: true: para branches que nunca devem expirar

# Create a branch with 7-day expiration
curl -X POST "$WORKSPACE/api/2.0/postgres/projects/my-project/branches?branch_id=development" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "spec": {
      "source_branch": "projects/my-project/branches/production",
      "ttl": "604800s"
    }
  }' | jq

# Create a permanent branch (no expiration)
curl -X POST "$WORKSPACE/api/2.0/postgres/projects/my-project/branches?branch_id=staging" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "spec": {
      "source_branch": "projects/my-project/branches/production",
      "no_expiry": true
    }
  }' | jq

Exibir ramificações

Exibir na interface do usuário

Para exibir todas as ramificações em seu projeto lakebase, selecione seu projeto no Aplicativo Lakebase e navegue até Branches na navegação à esquerda.

A tabela de filiais exibe informações importantes sobre cada filial.

A página de ramificações mostra uma tabela abrangente com informações sobre cada ramificação do projeto:

Clique em qualquer branch na tabela para exibir a página de visão geral do branch, que exibe informações detalhadas sobre o branch selecionado:

A página de visão geral do branch exibe informações detalhadas na parte superior, incluindo as principais métricas e metadados:

A página de resumo da ramificação inclui várias abas para gerenciar diferentes aspectos da ramificação.

Obter uma ramificação programaticamente

Para obter detalhes sobre um branch específico usando a API do Postgres:

SDK do Python

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

# Get branch details
branch = w.postgres.get_branch(
    name="projects/my-project/branches/development"
)

print(f"Branch: {branch.name}")
print(f"Protected: {branch.status.is_protected}")
print(f"Default: {branch.status.default}")
print(f"State: {branch.status.current_state}")
print(f"Size: {branch.status.logical_size_bytes} bytes")

SDK do Java

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.Branch;

WorkspaceClient w = new WorkspaceClient();

// Get branch details
Branch branch = w.postgres().getBranch("projects/my-project/branches/development");

System.out.println("Branch: " + branch.getName());
System.out.println("Protected: " + branch.getStatus().getIsProtected());
System.out.println("Default: " + branch.getStatus().getDefault());
System.out.println("State: " + branch.getStatus().getCurrentState());
System.out.println("Size: " + branch.getStatus().getLogicalSizeBytes() + " bytes");

CLI

# Get branch details
databricks postgres get-branch projects/my-project/branches/development --output json | jq

curl

curl "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/development" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq

Listar programaticamente

Para listar todas as ramificações em um projeto usando a API do Postgres:

SDK do Python

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

# List all branches in a project
project_name = "projects/my-project"
branches = list(w.postgres.list_branches(parent=project_name))

for branch in branches:
    print(f"Branch: {branch.name}")
    print(f"  Default: {branch.status.default}")
    print(f"  Protected: {branch.status.is_protected}")

SDK do Java

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.*;

WorkspaceClient w = new WorkspaceClient();

// List all branches in a project
String projectName = "projects/my-project";

for (Branch branch : w.postgres().listBranches(projectName)) {
    System.out.println("Branch: " + branch.getName());
    System.out.println("  Default: " + branch.getStatus().getDefault());
    System.out.println("  Protected: " + branch.getStatus().getIsProtected());
}

CLI

# List all branches in a project
databricks postgres list-branches projects/my-project --output json | jq

curl

curl "$WORKSPACE/api/2.0/postgres/projects/my-project/branches" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" | jq

Comparar esquemas de ramificação

Revisar as diferenças de esquema entre uma ramificação filha e sua ramificação principal antes de mesclar alterações. O diff de esquema mostra uma comparação SQL DDL lado a lado que destaca objetos de banco de dados adicionados, removidos ou modificados, como tabelas, colunas, índices e restrições.

Para comparar esquemas entre branches:

1. Navegue até uma página de visão geral da ramificação filha no Lakebase App.
2. Na seção Ramificação pai, clique em Diff de esquema.
3. Na caixa de diálogo de Diff esquema:
   • Base: Selecione o Branch base para comparação (seleciona por padrão o Branch pai).
   • Banco de dados: selecione o banco de dados a ser comparado.
   • Comparar: selecione a ramificação a ser comparado com a base (o padrão é a ramificação filha atual).
4. Clique em Comparar.

Entender os resultados do diff

Quando os esquemas diferem, o modo de exibição diff exibe uma comparação lado a lado das instruções DDL do SQL:

As linhas vermelhas mostram o que foi removido ou alterado do branch base, as linhas verdes mostram o que foi adicionado ou alterado no branch de comparação. O diff captura mudanças em definições de tabela, colunas, restrições, índices e outros objetos de banco de dados.

Se não houver diferenças entre os branches selecionados, você verá uma mensagem de êxito confirmando que os esquemas estão em sincronia:

Use schema diff para validação pré-merge, acompanhamento do desenvolvimento, detecção de desvio e documentação de alterações. Para ver o diff de esquema em um fluxo de trabalho de desenvolvimento completo, consulte Tutorial: fluxo de trabalho de desenvolvimento baseado em ramificação.

Atualizar configurações de branch

Renomear uma ramificação

No momento, não há suporte para renomeação de um branch da interface do usuário ou da API. A opção Renomear ramificação aparece no menu da ramificação na interface do usuário, mas está desabilitada.

Definir como padrão

Cada projeto do Lakebase é criado com um branch padrão chamado production, mas você pode designar qualquer branch como o padrão. O branch padrão é isento do limite de computação simultaneamente ativo, garantindo que ele permaneça disponível o tempo todo.

Para definir um branch como padrão:

1. Navegue até a página Branches do projeto no Aplicativo Lakebase.
2. Clique no menu ao lado da ramificação que você deseja definir como padrão.
3. Selecione Definir como padrão e confirme a operação.

Definir como protegido

Ramificações protegidas ajudam a salvaguardar ramificações críticas contra modificações ou exclusões acidentais. Ramificações protegidas não podem ser excluídas, redefinidas ou arquivadas por inatividade. Projetos com ramificações protegidas e suas computações associadas também não podem ser excluídos.

Para definir um branch como protegido:

interface do usuário

1. Navegue até Branches no Aplicativo Lakebase e selecione o branch que você deseja proteger.
2. Clique em Proteger e confirme sua seleção.

Seu ramo agora está designado como protegido, indicado pelo ícone de escudo que aparece ao lado do nome do ramo.

SDK do Python

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Branch, BranchSpec, FieldMask

w = WorkspaceClient()

# Set a branch as protected
branch_name = "projects/my-project/branches/production"

updated_spec = BranchSpec(is_protected=True)
updated_branch = Branch(name=branch_name, spec=updated_spec)
update_mask = FieldMask(field_mask=["spec.is_protected"])

update_op = w.postgres.update_branch(
    name=branch_name,
    branch=updated_branch,
    update_mask=update_mask
)

# Wait for the update to complete
result = update_op.wait()
print(f"Branch {result.name} is now protected: {result.status.is_protected}")

Para remover a proteção, defina is_protected=False no BranchSpec.

SDK do Java

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.*;
import com.google.protobuf.FieldMask;

WorkspaceClient w = new WorkspaceClient();

// Set a branch as protected
String branchName = "projects/my-project/branches/production";

BranchSpec updatedSpec = new BranchSpec().setIsProtected(true);
Branch updatedBranch = new Branch()
    .setName(branchName)
    .setSpec(updatedSpec);
FieldMask updateMask = FieldMask.newBuilder()
    .addPaths("spec.is_protected")
    .build();

Branch result = w.postgres().updateBranch(
    new UpdateBranchRequest()
        .setName(branchName)
        .setBranch(updatedBranch)
        .setUpdateMask(updateMask)
).waitForCompletion();

System.out.println("Branch " + result.getName() + " is now protected: " +
    result.getStatus().getIsProtected());

Para remover a proteção, defina setIsProtected(false) no BranchSpec.

CLI

# Set a branch as protected
databricks postgres update-branch projects/my-project/branches/production spec.is_protected \
  --json '{
    "spec": {
      "is_protected": true
    }
  }'

Para remover a proteção, defina "is_protected": false no JSON.

curl

curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production?update_mask=spec.is_protected" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/production",
    "spec": {
      "is_protected": true
    }
  }' | jq

Para remover a proteção, defina "is_protected": false no corpo da solicitação.

Para detalhes completos sobre ramificações protegidas, incluindo o gerenciamento de senhas para ramificações filhas, consulte ramificações protegidas.

Data de expiração da atualização

Você pode definir um timestamp de expiração ao criar um branch ou atualizá-lo mais tarde.

Ao criar uma ramificação

1. Navegue até a página Branches do projeto no Aplicativo Lakebase.
2. Clique em Criar branch, insira um nome de branch (obrigatório), configure suas opções de branch e selecione uma opção de exclusão automática (uma predefinição, um valor personalizado de até 30 dias ou Nunca para nenhuma expiração).
3. Clique em Criar.

Atualizar término da ramificação

Para atualizar ou remover um timestamp de expiração em um branch existente:

interface do usuário

1. Navegue até a página Branches do projeto no Aplicativo Lakebase.
2. Clique no menu ao lado da ramificação e selecione Atualizar término.
3. Selecione uma nova data e hora ou desmarque Término de ramificação em para remover o término; em seguida, clique em Salvar.

SDK do Python

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Branch, BranchSpec, Duration, FieldMask

w = WorkspaceClient()

# Update branch expiration to 14 days
branch_name = "projects/my-project/branches/development"

branch_spec = BranchSpec(
    is_protected=False,
    ttl=Duration(seconds=1209600)  # 14 days
)
branch = Branch(
    name=branch_name,
    spec=branch_spec
)

result = w.postgres.update_branch(
    name=branch_name,
    branch=branch,
    update_mask=FieldMask(field_mask=["spec.is_protected", "spec.expiration"])
).wait()

print(f"Updated expiration: {result.status.expire_time}")

Para remover a expiração, defina no_expiry=True em BranchSpec e inclua "spec.expiration" na máscara de atualização.

SDK do Java

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.*;
import com.google.protobuf.Duration;
import com.google.protobuf.FieldMask;

WorkspaceClient w = new WorkspaceClient();

// Update branch expiration to 14 days
String branchName = "projects/my-project/branches/development";

BranchSpec branchSpec = new BranchSpec()
    .setIsProtected(false)
    .setTtl(Duration.newBuilder().setSeconds(1209600L).build());  // 14 days

Branch branch = new Branch()
    .setName(branchName)
    .setSpec(branchSpec);

Branch result = w.postgres().updateBranch(
    new UpdateBranchRequest()
        .setName(branchName)
        .setBranch(branch)
        .setUpdateMask(FieldMask.newBuilder()
            .addPaths("spec.is_protected")
            .addPaths("spec.expiration")
            .build())
).waitForCompletion();

System.out.println("Updated expiration: " + result.getStatus().getExpireTime());

Para remover a expiração, defina setNoExpiry(true) em BranchSpec e inclua "spec.expiration" na máscara de atualização.

CLI

# Update branch expiration to 14 days
databricks postgres update-branch projects/my-project/branches/development spec.is_protected,spec.expiration \
  --json '{
    "spec": {
      "is_protected": false,
      "ttl": "1209600s"
    }
  }'

Para remover a expiração, defina "no_expiry": true no JSON.

curl

# Update branch expiration to 14 days
curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/development?update_mask=spec.is_protected,spec.expiration" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/development",
    "spec": {
      "is_protected": false,
      "ttl": "1209600s"
    }
  }' | jq

Para remover a expiração, defina "no_expiry": true no corpo da solicitação.

Exibir expiração do branch

Para verificar se um branch tem uma expiração definida, vá para a página Branches do projeto e clique no branch desejado. As informações de término são exibidas nos detalhes da ramificação.

Redefinir ramificação com base no pai

Você pode redefinir uma ramificação para atualizá-la instantaneamente com o esquema e os dados mais recentes da ramificação pai. Isso o ajuda a recuperar-se de problemas, iniciar o desenvolvimento de novos recursos ou manter as diferentes ramificações em seu ambiente em sincronia.

Cenário de exemplo

Ao trabalhar com ramificações, talvez você precise atualizar a ramificação de trabalho com os dados mais recentes da ramificação pai.

Por exemplo, suponha que você tenha duas ramificações filhas, staging e development, bifurcados da ramificação production. Você estava trabalhando na ramificação development e percebeu que ela está muito desatualizada em relação a production.

Você não tem nenhuma alteração de development esquema para considerar ou preservar; você só deseja uma atualização rápida dos dados. Você pode executar uma redefinição limpa e instantânea para os dados mais recentes do pai em uma única operação, evitando a complexidade de criar e restaurar ramificações manualmente.

Como funciona Redefinir com base no pai

Quando você redefine uma ramificação para o pai, os dados e o esquema são completamente substituídos pelos dados e pelo esquema mais recentes do pai.

Pontos principais:

• Você só pode redefinir uma ramificação para os dados mais recentes do pai. Recuperações pontuais com base em carimbo de data/hora são possíveis usando Recuperação Pontual, um recurso semelhante com algumas diferenças: a recuperação pontual cria um nova ramificação e é mais voltada à recuperação de dados do que ao fluxo de trabalho de desenvolvimento.
• Essa reinicialização é uma substituição completa, não uma atualização ou uma mesclagem. Todas as alterações locais feitas na ramificação filha são perdidas durante essa redefinição.
• As conexões existentes são temporariamente interrompidas durante a redefinição. No entanto, os detalhes da conexão não são alterados. Todas as conexões são restabelecidas assim que o reset é feito.
• Ramificações raiz (como a ramificação production do projeto) não podem ser redefinidas porque não têm ramificação pai para redefinir.

Redefinir uma ramificação com base no pai

Para redefinir uma ramificação para o pai:

1. Navegue até a página Branches do projeto no Aplicativo Lakebase.
2. Clique no menu ao lado da ramificação que você deseja redefinir e selecione Redefinir com base no pai.
3. Confirme a operação de redefinição.

Excluir uma ramificação

Para excluir um branch:

interface do usuário

1. Navegue até a página Branches do projeto no Aplicativo Lakebase.
2. Clique no ao lado do branch que você deseja excluir e selecione Excluir branch.
3. Insira o nome do branch para confirmar a exclusão e clique em Excluir.

SDK do Python

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

# Delete branch
w.postgres.delete_branch(
    name="projects/my-project/branches/development"
).wait()

print("Branch deleted")

A operação de exclusão é assíncrona. O .wait() método bloqueia até que a exclusão seja concluída. Todos os recursos do branch (bancos de dados, funções, processamento e dados) serão excluídos permanentemente.

SDK do Java

import com.databricks.sdk.WorkspaceClient;

WorkspaceClient w = new WorkspaceClient();

// Delete branch
w.postgres().deleteBranch("projects/my-project/branches/development")
    .waitForCompletion();

System.out.println("Branch deleted");

A operação de exclusão é assíncrona. O waitForCompletion() método bloqueia até que a exclusão seja concluída. Todos os recursos do branch (bancos de dados, funções, processamento e dados) serão excluídos permanentemente.

CLI

# Delete a branch
databricks postgres delete-branch projects/my-project/branches/development

Esse comando retorna imediatamente. O branch e todos os seus recursos serão excluídos permanentemente.

curl

curl -X DELETE "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/development" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq

Resposta:

{
  "name": "projects/my-project/branches/development/operations/...",
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.protobuf.Empty"
  }
}

Arquivamento automático de ramo

Para otimizar o uso de recursos, o Lakebase arquiva automaticamente ramificações inativas. O arquivamento é gerenciado pelo sistema. Um branch com uma computação em execução nunca é arquivado e um branch sem uma computação em execução pode ser arquivado após um período de inatividade. O arquivamento não afeta os dados ou a configuração do branch.

As ramificações protegidas não são arquivadas. Consulte branches protegidas.

Desarquivando uma ramificação

Você não precisa desarquivar um branch manualmente. O Lakebase retira automaticamente uma ramificação do arquivamento quando você a acessa, por exemplo, quando se conecta a ela, faz consultas nela, visualiza suas tabelas ou cria uma ramificação filha. Quando uma ramificação é desarquivada, suas ramificações pai até a ramificação raiz também são desarquivadas.

Branches com grandes quantidades de dados podem ter tempos de conexão e consulta ligeiramente mais lentos durante a conclusão do unarchiving.