Criar um instantâneo para uma publicação de mesclagem com filtros com parâmetros

Este tópico descreve como criar um instantâneo para uma publicação de mesclagem com filtros parametrizados no SQL Server 2012 usando SQL Server Management Studio, Transact-SQL ou RMO (Replication Management Objects).

Neste tópico

• Antes de começar:

  Recomendações

• Para criar um instantâneo para uma publicação de mesclagem com filtros com parâmetros, usando:

  SQL Server Management Studio

  Transact-SQL

  RMO (Replication Management Objects)

Antes de começar

Recomendações

• Ao gerar um instantâneo para uma publicação de mesclagem usando filtros com parâmetros, você deve, primeiro, gerar um instantâneo padrão (esquema), que contenha todos os dados publicados e os metadados do Assinante para a assinatura. Para obter mais informações, consulte Criar e aplicar o instantâneo inicial. Após ter criado um instantâneo de esquema, você poderá gerar o instantâneo que contém a partição Assinante específica dos dados publicados.

• Se a filtragem para um ou mais artigos da publicação gerar partições não sobrepostas, exclusivas de cada assinatura, os metadados serão limpos sempre que o Agente de Mesclagem for executado. Isso significa que o instantâneo particionado irá expirar mais rapidamente. Ao usar essa opção, considere permitir que os Assinantes possam iniciar a geração e a entrega do instantâneo. Para obter mais informações sobre as opções de filtragem, consulte a seção "Definindo 'opções de partição" Instantâneos para publicações de mesclagem com filtros com parâmetros.

[Top]

Usando o SQL Server Management Studio

Gere instantâneos para partições na página Partições de Dados da caixa de diálogo Propriedades de Publicação - <Publicação>. Para obter mais informações sobre como acessar essa caixa de diálogo, consulte Visualizar e modificar as propriedades da publicação. É possível permitir que os Assinantes iniciem a geração de instantâneo e entreguem e/ou gerem instantâneos.

Antes de gerar instantâneos para uma ou mais partições, é preciso:

1. Criar uma publicação de mesclagem com o Assistente para Nova Publicação, e especificar um ou mais filtros de linha com parâmetros na página Adicionar Filtro do assistente. Para obter mais informações, consulte Definir e modificar um filtro de linha com parâmetros para um artigo de mesclagem.

2. Gerar um instantâneo de esquema para a publicação. Por padrão, o instantâneo de esquema é gerado quando o Assistente para Nova Publicação é encerrado. Nesse momento é igualmente possível gerar um instantâneo de esquema no SQL Server Management Studio.

Para gerar um instantâneo de esquema

1. Conecte-se ao Publicador no Management Studio e expanda o nó do servidor.

2. Expanda a pasta Replicação e, em seguida, a pasta Publicações.

3. Clique com o botão direito do mouse na publicação para a qual você quer criar um instantâneo e, então, clique em Exibir Status do Agente de Instantâneo.

4. Na caixa de diálogo Exibir Status do Agente de Instantâneo - <Publicação>, clique em Iniciar.

   Quando Agente de Instantâneo terminar de gerar o instantâneo, uma mensagem será exibida, tal como "[100%] Um instantâneo de 17 artigo(s) foi gerado."

Para permitir que os Assinantes iniciem a geração e entrega de instantâneo

1. Na página Partição de dados da caixa de diálogo Propriedades de Publicação - <Publicação>, selecione Definir automaticamente uma partição e gerar um instantâneo, se necessário, quando um novo Assinante tentar sincronizar.

2. Clique em OK.

Para gerar e atualizar instantâneos

1. Na página Partições de Dados da caixa de diálogo Propriedades de Publicação - <Publicação>, clique em Adicionar.

2. Digite um valor para HOST_NAME() e/ou um valor para SUSER_SNAME(), associado à partição para a qual será criado um instantâneo.

3. Especifique, opcionalmente, um cronograma para atualizar instantâneos:

   1. Selecione Agendar o Agente de Instantâneo para que esta partição seja executada no(s) seguinte(s) horário(s):

   2. Aceite o cronograma padrão para atualizar instantâneos ou clique em Alterar para especificar um cronograma diferente.

4. Clique em OK, o que o retornará para a caixa de diálogo Propriedades de Publicação - <Publicação>.

5. Selecione a partição na grade de propriedades, depois clique em Gerar os instantâneos selecionados agora.

6. Clique em OK.

[Top]

Usando Transact-SQL

Ao usar os procedimentos armazenados e o Agente de Instantâneo, será possível realizar o seguinte:

• Permita que os Assinantes solicitem geração e aplicação de instantâneos na primeira vez que eles sincronizarem.

• Gere previamente instantâneos para cada partição.

• Gerar manualmente um instantâneo para cada Assinante.

  Observação sobre segurança
  Quando possível, solicite aos usuários que insiram as credenciais de segurança em tempo de execução. Se for necessário armazenar credenciais em um arquivo de script, você deverá proteger o arquivo para impedir acesso não autorizado.

Para criar uma publicação que permita que os Assinantes inicializem geração e entrega de instantâneo

1. No Publicador do banco de dados de publicação, execute sp_addmergepublication (Transact-SQL). Especifique os seguintes parâmetros:

   • O nome da publicação para @publication.

   • Um valor true para @allow_subscriber_initiated_snapshot, o qual habilita os Assinantes a iniciarem o processo do instantâneo.

   • (Opcional) O número de processos de instantâneo dinâmico que pode executar simultaneamente para @ max_concurrent_dynamic_snapshots. Se o número máximo de processos estiver em execução e o Assinante tentar gerar um instantâneo, o processo será colocado em uma fila. Por padrão não há nenhum limite para o número de processos simultâneos.

2. No Publicador, execute sp_addpublication_snapshot (Transact-SQL). Especifique o nome da publicação usado na etapa 1 para @publication e as credenciais do Windows Microsoft no qual o Replication Snapshot Agent executa para @job_login e @password. Se o agente usar a Autenticação do SQL Server quando se conectar ao Publicador, você também deverá especificar um valor de 0 para @publisher_security_mode e as informações de logon do Microsoft SQL Server para @publisher_login e @publisher_password. Isso cria um trabalho do Agente de Instantâneo para a publicação. Para obter mais informações sobre como gerar um instantâneo inicial e definir uma agenda personalizada para o Agente de Instantâneo, consulte Criar e aplicar o instantâneo inicial.

   Observação sobre segurança

   Quando um Publicador é configurado com um Distribuidor remoto, os valores fornecidos para todos os parâmetros, inclusive job_login e job_password, são enviados ao Distribuidor como texto sem-formatação. Você deve criptografar a conexão entre o Publicador e seu Distribuidor remoto antes de executar esse procedimento armazenado. Para obter mais informações, consulte Habilitar conexões criptografadas no Mecanismo de Banco de Dados (SQL Server Configuration Manager).

3. Execute sp_addmergearticle (Transact-SQL) para adicionar artigos à publicação. Esse procedimento armazenado deve ser executado uma vez para cada artigo na publicação. Ao usar filtros com parâmetros, você deve especificar um filtro de linha com parâmetros para um ou mais artigos que usam o parâmetro @subset_filterclause. Para obter mais informações, consulte Definir e modificar um filtro de linha com parâmetros para um artigo de mesclagem.

4. Se outros artigos forem filtrados com base no filtro de linha com parâmetros, execute sp_addmergefilter (Transact-SQL) para definir as relações de junção ou lógica entre os artigos. Esse procedimento armazenado deve ser executado uma vez para cada artigo sendo definido. Para obter mais informações, consulte Definir e modificar um filtro de junção entre artigos de mesclagem.

5. Quando o Agente de Mesclagem solicita que o instantâneo inicialize o Assinante, o instantâneo para a solicitação de partição de assinatura é gerado automaticamente.

Para criar uma publicação e pré-gerar ou atualizar automaticamente instantâneos

1. Execute sp_addmergepublication (Transact-SQL) para criar a publicação. Para obter mais informações, consulte Crie uma publicação.

2. No Publicador, execute sp_addpublication_snapshot (Transact-SQL). Especifique o nome da publicação usada na etapa 1 para @publication e as credenciais do Windows no qual o Agente de Instantâneo executa para @job_login e @password. Se o agente usar a Autenticação do SQL Server quando se conectar ao Publisher, você também deverá especificar um valor de 0 para @publisher_security_mode e as informações de logon do SQL Server para @publisher_login e @publisher_password. Isso cria um trabalho do Agente de Instantâneo para a publicação. Para obter mais informações sobre como gerar um instantâneo inicial e definir uma agenda personalizada para o Agente de Instantâneo, consulte Criar e aplicar o instantâneo inicial.

   Observação sobre segurança

   Quando um Publicador é configurado com um Distribuidor remoto, os valores fornecidos para todos os parâmetros, inclusive job_login e job_password, são enviados ao Distribuidor como texto sem-formatação. Você deve criptografar a conexão entre o Publicador e seu Distribuidor remoto antes de executar esse procedimento armazenado. Para obter mais informações, consulte Habilitar conexões criptografadas no Mecanismo de Banco de Dados (SQL Server Configuration Manager).

3. Execute sp_addmergearticle (Transact-SQL) para adicionar artigos à publicação. Esse procedimento armazenado deve ser executado uma vez para cada artigo na publicação. Ao usar filtros com parâmetros, você deve especificar um filtro de linha com parâmetros para um artigo usando o parâmetro @subset_filterclause. Para obter mais informações, consulte Definir e modificar um filtro de linha com parâmetros para um artigo de mesclagem.

4. Se outros artigos forem filtrados com base no filtro de linha com parâmetros, execute sp_addmergefilter (Transact-SQL) para definir as relações de junção ou lógica entre os artigos. Esse procedimento armazenado deve ser executado uma vez para cada artigo sendo definido. Para obter mais informações, consulte Definir e modificar um filtro de junção entre artigos de mesclagem.

5. No Publicador do banco de dados de publicação, execute sp_helpmergepublication (Transact-SQL), especificando o valor @publication da etapa 1. Observe o valor snapshot_jobid no conjunto de resultados.

6. Converta o valor do snapshot_jobid obtido na etapa 5 para uniqueidentifier.

7. No Publicador do banco de dados msdb , execute sp_start_job (Transact-SQL), especificando o valor convertido obtido na etapa 6 para @ job_id.

8. No Publicador do banco de dados de publicação, execute sp_addmergepartition (Transact-SQL). Especifique o nome da publicação da etapa 1 para @publication e o valor usado para definir a partição para @suser_sname se SUSER_SNAME (Transact-SQL) é usado na cláusula de filtro ou para @host_name se HOST_NAME (Transact-SQL) é usado na cláusula de filtro.

9. No Publicador do banco de dados de publicação, execute sp_adddynamicsnapshot_job (Transact-SQL). Especifique o nome da publicação da etapa 1 para @publication, o valor @suser_sname ou @host_name da etapa 8, e uma agenda para o trabalho. Isso irá criar o trabalho que gera o instantâneo com parâmetros para a partição especificada. Para obter mais informações, consulte Especificar agendas de sincronização.

   Observação
   Esse trabalho executa, usando a mesma conta Windows do trabalho de instantâneo inicial definido na etapa 2. Para remover o trabalho de instantâneo com parâmetros e a partição de dados relacionada, execute sp_dropdynamicsnapshot_job (Transact-SQL).

10. No Publicador do banco de dados de publicação, execute sp_helpmergepartition (Transact-SQL), especificando o valor @publication da etapa 1 e o valor @suser_sname ou @host_name da etapa 8. Observe o valor dynamic_snapshot_jobid no conjunto de resultados.

11. No Distribuidor, no banco de dados msdb , execute sp_start_job (Transact-SQL), especificando o valor obtido na etapa 9 para @job_id. Isso inicia o trabalho de instantâneo com parâmetros para a partição.

12. Repita as etapas de 8 a11 para gerar um instantâneo particionado para cada assinatura.

Para criar uma publicação e criar manualmente instantâneos para cada partição

1. Execute sp_addmergepublication (Transact-SQL) para criar a publicação. Para obter mais informações, consulte Crie uma publicação.

2. No Publicador, execute sp_addpublication_snapshot (Transact-SQL). Especifique o nome da publicação usada na etapa 1 para @publication e as credenciais do Windows no qual o Agente de Instantâneo executa para @job_login e @password. Se o agente usar a Autenticação do SQL Server quando se conectar ao Publisher, você também deverá especificar um valor de 0 para @publisher_security_mode e as informações de logon do SQL Server para @publisher_login e @publisher_password. Isso cria um trabalho do Agente de Instantâneo para a publicação. Para obter mais informações sobre como gerar um instantâneo inicial e definir uma agenda personalizada para o Agente de Instantâneo, consulte Criar e aplicar o instantâneo inicial.

   Observação sobre segurança

   Quando um Publicador é configurado com um Distribuidor remoto, os valores fornecidos para todos os parâmetros, inclusive job_login e job_password, são enviados ao Distribuidor como texto sem-formatação. Você deve criptografar a conexão entre o Publicador e seu Distribuidor remoto antes de executar esse procedimento armazenado. Para obter mais informações, consulte Habilitar conexões criptografadas no Mecanismo de Banco de Dados (SQL Server Configuration Manager).

3. Execute sp_addmergearticle (Transact-SQL) para adicionar artigos à publicação. Esse procedimento armazenado deve ser executado uma vez para cada artigo na publicação. Ao usar filtros com parâmetros, você deve especificar um filtro de linha com parâmetros para pelo menos um artigo usando o parâmetro @subset_filterclause. Para obter mais informações, consulte Definir e modificar um filtro de linha com parâmetros para um artigo de mesclagem.

4. Se outros artigos forem filtrados com base no filtro de linha com parâmetros, execute sp_addmergefilter (Transact-SQL) para definir as relações de junção ou lógica entre os artigos. Esse procedimento armazenado deve ser executado uma vez para cada artigo sendo definido. Para obter mais informações, consulte Definir e modificar um filtro de junção entre artigos de mesclagem.

5. Inicie o trabalho de instantâneo ou execute o Replication Agente de Instantâneo no prompt de comando para gerar o esquema de instantâneo padrão e outros arquivos. Para obter mais informações, consulte Criar e aplicar o instantâneo inicial.

6. Execute o Replication Agente de Instantâneo novamente no prompt de comando para gerar arquivos (.bcp) para cópia em massa, especificando o local do instantâneo particionado para -DynamicSnapshotLocation e uma ou ambas as seguintes propriedades que definam a partição:

   • -DynamicFilterHostName - o valor se HOST_NAME (Transact-SQL) é usado.

   • -DynamicFilterLogin - o valor se SUSER_SNAME (Transact-SQL) é usado.

7. Repita a etapa 6 para gerar um instantâneo particionado para cada assinatura.

8. Execute o Agente de Mesclagem para cada assinatura para aplicar o instantâneo inicial particionado nos Assinantes, especificando as propriedades a seguir:

   • -Hostname - o valor usado para definir a partição, se o valor atual de HOST_NAME estiver sendo substituído.

   • - DynamicSnapshotLocation - o local do instantâneo dinâmico para esta partição.

Observação
Para obter mais informações sobre como programar agentes de replicação, consulte Conceitos dos executáveis do Replication Agent.

Exemplos (Transact-SQL)

Esse exemplo cria uma publicação de mesclagem com filtros com parâmetros onde Assinantes inicia o processo de geração de instantâneo. Os valores para @job_login e @job_password são passados no uso de valores de script.

-- To avoid storing the login and password in the script file, the value 
-- is passed into SQLCMD as a scripting variable. For information about 
-- how to use scripting variables on the command line and in SQL Server
-- Management Studio, see the "Executing Replication Scripts" section in
-- the topic "Programming Replication Using System Stored Procedures".

--Add a new merge publication.
DECLARE @publicationdb AS sysname;
DECLARE @publication AS sysname;
DECLARE @table1 AS sysname;
DECLARE @table2 AS sysname;
DECLARE @filter AS sysname;
DECLARE @schema_hr AS sysname;
DECLARE @schema_sales AS sysname;

SET @publicationdb = N'AdventureWorks2012';
SET @publication = N'AdvWorksSalesPersonMerge';
SET @table1 = N'Employee';
SET @table2 = N'SalesPerson';
SET @filter = N'SalesPerson_Employee';
SET @schema_hr = N'HumanResources';
SET @schema_sales = N'Sales';

USE [AdventureWorks2012];

-- Enable AdventureWorks2012 for merge replication.
EXEC sp_replicationdboption
  @dbname = @publicationdb,
  @optname = N'merge publish',
  @value = N'true';  

-- Create new merge publication with Subscriber requested snapshot
-- and using the default agent schedule. 
EXEC sp_addmergepublication 
  @publication = @publication, 
  @description = N'Merge publication of AdventureWorks2012.', 
  @allow_subscriber_initiated_snapshot = N'true',
  @publication_compatibility_level = N'90RTM';

-- Create a new snapshot job for the publication, using the default schedule.
-- Pass credentials at runtime using sqlcmd scripting variables.
EXEC sp_addpublication_snapshot 
  @publication = @publication, 
  @job_login = $(login), 
  @job_password = $(password);

-- Add an article for the Employee table, 
-- which is horizontally partitioned using 
-- a parameterized row filter.
EXEC sp_addmergearticle 
  @publication = @publication, 
  @article = @table1, 
  @source_owner = @schema_hr, 
  @source_object = @table1, 
  @type = N'table', 
  @description = 'contains employee information', 
  @subset_filterclause = N'[LoginID] = HOST_NAME()';

-- Add an article for the SalesPerson table, 
-- which is partitioned based on a join filter.
EXEC sp_addmergearticle 
  @publication = @publication, 
  @article = @table2, 
  @source_owner = @schema_sales, 
  @source_object = @table2, 
  @type = N'table', 
  @description = 'contains salesperson information';

-- Add a join filter between the two articles.
EXEC sp_addmergefilter 
  @publication = @publication, 
  @article = @table1, 
  @filtername = @filter, 
  @join_articlename = @table2, 
  @join_filterclause = N'[Employee].[BusinessEntityID] = [SalesPerson].[SalesPersonID]', 
  @join_unique_key = 1, 
  @filter_type = 1;
GO

-- Start the agent job to generate the full snapshot for the publication.
-- The filtered data snapshot is generated automatically the first time 
-- the subscription is synchronized. 
DECLARE @publication AS sysname;
SET @publication = N'AdvWorksSalesPersonMerge';

EXEC sp_startpublication_snapshot 
  @publication = @publication;
GO

Esse exemplo cria uma publicação usando um filtro com parâmetros, onde cada Assinante tem sua partição definida ao executar sp_addmergepartition e o trabalho de instantâneo filtrado criado pela execução sp_adddynamicsnapshot_job passando as informações de particionamento. Os valores para @job_login e @job_password são passados no uso de valores de script.

-- To avoid storing the login and password in the script file, the value 
-- is passed into SQLCMD as a scripting variable. For information about 
-- how to use scripting variables on the command line and in SQL Server
-- Management Studio, see the "Executing Replication Scripts" section in
-- the topic "Programming Replication Using System Stored Procedures".

--Add a new merge publication.
DECLARE @publicationdb AS sysname;
DECLARE @publication AS sysname;
DECLARE @table1 AS sysname;
DECLARE @table2 AS sysname;
DECLARE @filter AS sysname;
DECLARE @schema_hr AS sysname;
DECLARE @schema_sales AS sysname;

SET @publicationdb = N'AdventureWorks2012';
SET @publication = N'AdvWorksSalesPersonMerge';
SET @table1 = N'Employee';
SET @table2 = N'SalesPerson';
SET @filter = N'SalesPerson_Employee';
SET @schema_hr = N'HumanResources';
SET @schema_sales = N'Sales';

USE [AdventureWorks2012];

-- Enable AdventureWorks2012 for merge replication.
EXEC sp_replicationdboption
  @dbname = @publicationdb,
  @optname = N'merge publish',
  @value = N'true';  

-- Create new merge publication.  
EXEC sp_addmergepublication 
  @publication = @publication, 
  @description = N'Merge publication of AdventureWorks2012.', 
  @allow_subscriber_initiated_snapshot = N'false';

-- Create a new snapshot job for the publication, using the 
-- default schedule. Pass credentials at runtime using 
-- sqlcmd scripting variables.
EXEC sp_addpublication_snapshot 
  @publication = @publication, 
  @job_login = $(Login), 
  @job_password = $(password);

-- Add an article for the Employee table, 
-- which is horizontally partitioned using 
-- a parameterized row filter.
EXEC sp_addmergearticle 
  @publication = @publication, 
  @article = @table1, 
  @source_owner = @schema_hr, 
  @source_object = @table1, 
  @type = N'table', 
  @description = 'contains employee information', 
  @subset_filterclause = N'[LoginID] = HOST_NAME()';

-- Add an article for the SalesPerson table, 
-- which is partitioned based on a join filter.
EXEC sp_addmergearticle 
  @publication = @publication, 
  @article = @table2, 
  @source_owner = @schema_sales, 
  @source_object = @table2, 
  @type = N'table', 
  @description = 'contains customer information';

-- Add a join filter between the two articles.
EXEC sp_addmergefilter 
  @publication = @publication, 
  @article = @table1, 
  @filtername = @filter, 
  @join_articlename = @table2, 
  @join_filterclause = N'[Employee].[BusinessEntityID] = [SalesPerson].[SalesPersonID]', 
  @join_unique_key = 1, 
  @filter_type = 1;
GO

-- Start the snapshot agent job.
DECLARE @publication AS sysname;
SET @publication = N'AdvWorksSalesPersonMerge';

EXEC sp_startpublication_snapshot 
  @publication = @publication;
GO

PRINT '*** Waiting for the initial snapshot.';
GO

-- Create a temporary table to store the filtered data snapshot 
-- job information.
CREATE TABLE #temp (id int,
    job_name sysname,
    job_id uniqueidentifier,
    dynamic_filter_login sysname NULL,
    dynamic_filter_hostname sysname NULL,
    dynamic_snapshot_location nvarchar(255),
    frequency_type int, 
    frequency_interval int, 
    frequency_subday_type int,
    frequency_subday_interval int, 
    frequency_relative_interval int, 
    frequency_recurrence_factor int, 
    active_start_date int, 
    active_end_date int, 
    active_start_time int, 
    active_end_time int
)

-- Create each snapshot for a partition 
-- The initial snapshot must already be generated.
DECLARE @publication AS sysname;
DECLARE @jobname AS sysname
DECLARE @hostname AS sysname
SET @publication = N'AdvWorksSalesPersonMerge';
SET @hostname = N'adventure-works\Fernando';

WHILE NOT EXISTS(SELECT * FROM sysmergepublications 
    WHERE [name] = @publication 
    AND snapshot_ready = 1)
BEGIN
    WAITFOR DELAY '00:00:05'
END

-- Create a data partition by overriding HOST_NAME().
EXEC sp_addmergepartition 
  @publication = @publication,
  @host_name = @hostname;

-- Create the filtered data snapshot job, and use the returned 
-- information to start the job.
EXEC sp_adddynamicsnapshot_job 
  @publication = @publication,
  @host_name = @hostname;

INSERT INTO #temp (id, job_name, job_id, dynamic_filter_login,
    dynamic_filter_hostname, dynamic_snapshot_location,
    frequency_type, frequency_interval, frequency_subday_type,
    frequency_subday_interval, frequency_relative_interval, 
    frequency_recurrence_factor, active_start_date, active_end_date, 
    active_start_time,active_end_time)
EXEC sp_helpdynamicsnapshot_job;

SELECT @jobname = (SELECT DISTINCT job_name FROM #temp WHERE dynamic_filter_hostname = @hostname);

EXEC msdb..sp_start_job @job_name = @jobname;
DROP TABLE #temp;
GO

Esse exemplo cria uma publicação usando um filtro com parâmetros, onde cada Assinante deve ter sua própria partição de dados e trabalho de instantâneo criado pelo fornecimento das informações de particionamento. Um Assinante fornece informações de particionamento, usando parâmetros de linha de comando ao executar, manualmente, os agentes de replicação. Esse exemplo assume que também foi criada uma assinatura para a publicação.

-- To avoid storing the login and password in the script file, the value 
-- is passed into SQLCMD as a scripting variable. For information about 
-- how to use scripting variables on the command line and in SQL Server
-- Management Studio, see the "Executing Replication Scripts" section in
-- the topic "Programming Replication Using System Stored Procedures".

--Add a new merge publication.
DECLARE @publicationdb AS sysname;
DECLARE @publication AS sysname;
DECLARE @table1 AS sysname;
DECLARE @table2 AS sysname;
DECLARE @filter AS sysname;
DECLARE @schema_hr AS sysname;
DECLARE @schema_sales AS sysname;

SET @publicationdb = N'AdventureWorks2012';
SET @publication = N'AdvWorksSalesPersonMerge';
SET @table1 = N'Employee';
SET @table2 = N'SalesPerson';
SET @filter = N'SalesPerson_Employee';
SET @schema_hr = N'HumanResources';
SET @schema_sales = N'Sales';

USE [AdventureWorks2012];

-- Enable AdventureWorks2012 for merge replication.
EXEC sp_replicationdboption
  @dbname = @publicationdb,
  @optname = N'merge publish',
  @value = N'true';  

-- Create new merge publication.  
EXEC sp_addmergepublication 
  @publication = @publication, 
  @description = N'Merge publication of AdventureWorks2012.', 
  @allow_subscriber_initiated_snapshot = N'false';

-- Create a new snapshot job for the publication, using the 
-- default schedule. Pass credentials at runtime using 
-- sqlcmd scripting variables.
EXEC sp_addpublication_snapshot 
  @publication = @publication, 
  @job_login = $(Login), 
  @job_password = $(Password);

-- Add an article for the Employee table, 
-- which is horizontally partitioned using 
-- a parameterized row filter.
EXEC sp_addmergearticle 
  @publication = @publication, 
  @article = @table1, 
  @source_owner = @schema_hr, 
  @source_object = @table1, 
  @type = N'table', 
  @description = 'contains employee information', 
  @subset_filterclause = N'[LoginID] = HOST_NAME()';

-- Add an article for the SalesPerson table, 
-- which is partitioned based on a join filter.
EXEC sp_addmergearticle 
  @publication = @publication, 
  @article = @table2, 
  @source_owner = @schema_sales, 
  @source_object = @table2, 
  @type = N'table', 
  @description = 'contains customer information';

-- Add a join filter between the two articles.
EXEC sp_addmergefilter 
  @publication = @publication, 
  @article = @table1, 
  @filtername = @filter, 
  @join_articlename = @table2, 
  @join_filterclause = N'[Employee].[BusinessEntityID] = [SalesPerson].[SalesPersonID]', 
  @join_unique_key = 1, 
  @filter_type = 1;
GO

REM Line breaks are added to improve readability. 
REM In a batch file, commands must be made in a single line.
REM Run the Snapshot agent from the command line to generate the standard snapshot 
REM schema and other files. 
SET DistPub=%computername%
SET PubDB=AdventureWorks2012 
SET PubName=AdvWorksSalesPersonMerge

"C:\Program Files\Microsoft SQL Server\110\COM\SNAPSHOT.EXE" -Publication %PubName%  
-Publisher %DistPub% -Distributor  %DistPub%  -PublisherDB %PubDB%  -ReplicationType 2  
-OutputVerboseLevel 1  -DistributorSecurityMode 1

PAUSE

REM Run the Snapshot agent from the command line, this time to generate 
REM the bulk copy (.bcp) data for each Subscriber partition.  
SET DistPub=%computername%
SET PubDB=AdventureWorks2012 
SET PubName=AdvWorksSalesPersonMerge
SET SnapshotDir=\\%DistPub%\repldata\unc\fernando

MD %SnapshotDir%

"C:\Program Files\Microsoft SQL Server\110\COM\SNAPSHOT.EXE" -Publication %PubName%  
-Publisher %DistPub%  -Distributor  %DistPub%  -PublisherDB %PubDB%  -ReplicationType 2  
-OutputVerboseLevel 1  -DistributorSecurityMode 1  -DynamicFilterHostName "adventure-works\Fernando"  
-DynamicSnapshotLocation %SnapshotDir%

PAUSE

REM Run the Merge Agent for each subscription to apply the partitioned 
REM snapshot for each Subscriber.  
SET Publisher = %computername%
SET Subscriber = %computername%
SET PubDB = AdventureWorks2012 
SET SubDB = AdventureWorks2012Replica 
SET PubName = AdvWorksSalesPersonMerge 
SET SnapshotDir=\\%DistPub%\repldata\unc\fernando

"C:\Program Files\Microsoft SQL Server\110\COM\REPLMERG.EXE" -Publisher  %Publisher%  
-Subscriber  %Subscriber%  -Distributor %Publisher%  -PublisherDB %PubDB%  
-SubscriberDB %SubDB% -Publication %PubName%  -PublisherSecurityMode 1  -OutputVerboseLevel 3  
-Output -SubscriberSecurityMode 1  -SubscriptionType 3 -DistributorSecurityMode 1  
-Hostname "adventure-works\Fernando"  -DynamicSnapshotLocation %SnapshotDir%

PAUSE

[Top]

Usando o RMO (Replication Management Objects)

Você pode usar RMO (Replication Management Objects) para gerar instantâneos particionados programaticamente dos seguintes modos:

• Permita que os Assinantes solicitem geração e aplicação de instantâneos na primeira vez que eles sincronizarem.

• Gere previamente instantâneos para cada partição.

• Gere manualmente um instantâneo para cada Assinante executando o Agente de Instantâneo.

Observação

Quando a filtragem de um artigo gerar partições não sobrepostas, exclusivas de cada assinatura (especificando um valor de NonOverlappingSingleSubscription para PartitionOption ao criar um artigo de mesclagem), metadados são limpos sempre que o Agente de Mesclagem for executado. Isso significa que o instantâneo particionado irá expirar mais rapidamente. Ao usar essa opção, considere permitir que os Assinantes solicitem geração do instantâneo. Para obter mais informações, consulte a seção "Usando as opções de filtragem” apropriadas no tópico Filtros de linha com parâmetros.

Observação sobre segurança
Quando possível, solicite que os usuários insiram as credenciais de segurança em tempo de execução. Se for preciso armazenar credenciais, use os serviços criptográficos fornecidos pelo Microsoft .NET Framework do Windows.

Para criar uma publicação que permita que os Assinantes inicializem geração e entrega de instantâneo

1. Crie uma conexão com o Publicador usando a classe ServerConnection.

2. Crie uma instância da classe ReplicationDatabase para o banco de dados de publicação; defina a propriedade ConnectionContext para a instância de ServerConnection da etapa 1 e chame o método LoadProperties. Se LoadProperties retornar false, confirme a existência do banco de dados.

3. Se a propriedade EnabledMergePublishing for false, defina-a como true e chame CommitPropertyChanges.

4. Crie uma instância da classe MergePublication e defina as propriedades a seguir para esse objeto:

   • O ServerConnection da Etapa 1 para ConnectionContext.

   • Nome do banco de dados publicado para DatabaseName.

   • Um nome para a publicação para Name.

   • O número máximo de trabalhos de instantâneo dinâmicos a serem executados para MaxConcurrentDynamicSnapshots. Uma vez que solicitações de instantâneo iniciado pelo Assinante podem ocorrer a qualquer momento, essa propriedade limita o número de trabalhos do Agente de Instantâneo que podem ser executados simultaneamente quando vários Assinantes solicitam seu instantâneo particionado ao mesmo tempo. Quando o número máximo de trabalhos estiver sendo executado, solicitações de instantâneos particionados adicionais são enfileiradas até que um dos trabalhos que está sendo executado seja concluído.

   • Use o operador lógico bit a bit OR (| no Visual C# e Or no Visual Basic) para adicionar o valor AllowSubscriberInitiatedSnapshot a Attributes.

   • Os campos Login e Password de SnapshotGenerationAgentProcessSecurity para fornecer as credenciais para a conta do Windows Microsoft em que o Agente de Instantâneo é executado.

     Observação
     Recomenda-se definir SnapshotGenerationAgentProcessSecurity quando a publicação é criada por um membro da função de servidor fixa sysadmin. Para obter mais informações, consulte Modelo de segurança do agente de replicação.

5. Chame o método Create para criar a publicação.

   Observação sobre segurança

   Quando um Publicador é configurado com um Distribuidor remoto, os valores fornecidos para todas as propriedades, inclusive SnapshotGenerationAgentProcessSecurity, são enviados ao Distribuidor como texto sem-formatação. É necessário criptografar a conexão entre o Publicador e seu Distribuidor remoto antes de chamar o método Create. Para obter mais informações, consulte Habilitar conexões criptografadas no Mecanismo de Banco de Dados (SQL Server Configuration Manager).

6. Use a propriedade MergeArticle para adicionar artigos à publicação. Especifique a propriedade FilterClause para pelo menos um artigo que defina o filtro com parâmetros. (Opcional) Crie objetos MergeJoinFilter que definam filtros de junção entre artigos. Para obter mais informações, consulte Defina um Artigo.

7. Se o valor de SnapshotAgentExists for false, chame CreateSnapshotAgent para criar o trabalho inicial do Agente de Instantâneo para essa publicação.

8. Chame o método StartSnapshotGenerationAgentJob de objeto MergePublication criado na etapa 4. Isso inicia o trabalho do agente que gera o instantâneo inicial. Para obter mais informações sobre como gerar um instantâneo inicial e definir uma agenda personalizada para o Agente de Instantâneo, consulte Criar e aplicar o instantâneo inicial.

9. (Opcional) Procure um valor de true para a propriedade SnapshotAvailable a fim de determinar quando o instantâneo inicial está pronto para ser usado.

10. Quando o Agente de Mesclagem para um Assinante for conectado pela primeira vez, um instantâneo particionado é gerado automaticamente.

Para criar uma publicação e gerar previamente ou atualizar automaticamente instantâneos

1. Use uma instância da classe MergePublication para definir uma publicação de mesclagem. Para obter mais informações, consulte Crie uma publicação.

2. Use a propriedade MergeArticle para adicionar artigos à publicação. Especifique a propriedade FilterClause para pelo menos um artigo que defina o filtro com parâmetros e crie quaisquer objetos MergeJoinFilter que definam filtros de junção entre artigos. Para obter mais informações, consulte Defina um Artigo.

3. Se o valor de SnapshotAgentExists for false, chame CreateSnapshotAgent para criar o trabalho do Agente de Instantâneo para essa publicação.

4. Chame o método StartSnapshotGenerationAgentJob do objeto MergePublication criado na etapa 1. Esse método inicia o trabalho do agente que gera o instantâneo inicial. Para obter mais informações sobre como gerar um instantâneo inicial e definir uma agenda personalizada para o Agente de Instantâneo, consulte Criar e aplicar o instantâneo inicial.

5. (Opcional) Procure um valor de true para a propriedade SnapshotAvailable a fim de determinar quando o instantâneo inicial está pronto para ser usado.

6. Crie uma instância da classe MergePartitione defina os critérios de filtragem com parâmetros para o Assinante, usando uma ou mais das seguintes propriedades:

   • Se a partição do Assinante estiver definida pelo resultado de SUSER_SNAME (Transact-SQL), use DynamicFilterLogin.

   • Se a partição do Assinante estiver definida pelo resultado de HOST_NAME (Transact-SQL) ou uma sobrecarga dessa função, use DynamicFilterHostName.

7. Crie uma instância da classe MergeDynamicSnapshotJob e defina a mesma propriedade que a da etapa 6.

8. Use a classe ReplicationAgentSchedule para definir uma agenda para gerar o instantâneo filtrado para a partição de Assinante.

9. Usando a instância de MergePublication da etapa 1, chame AddMergePartition. Passe o objeto MergePartition da etapa 6.

10. Usando a instância de MergePublication da etapa 1, chame o método AddMergeDynamicSnapshotJob. Passe o objeto MergeDynamicSnapshotJob da etapa 7 e o objeto ReplicationAgentSchedule da etapa 8.

11. Chame EnumMergeDynamicSnapshotJobs e localize o objeto MergeDynamicSnapshotJob para o trabalho de instantâneo particionado recém-adicionado à matriz retornada.

12. Adquira a propriedade Name para o trabalho.

13. Crie uma conexão com o Distribuidor usando a classe ServerConnection.

14. Crie uma instância da classe Server do SQL Server Management Objects (SMO), passando o objeto ServerConnection da etapa 13.

15. Crie uma instância da classe Job passando a propriedade JobServerdo objeto Server da etapa 14 e o nome do trabalho da etapa 12.

16. Chame o método Start para iniciar o trabalho de instantâneo particionado.

17. Repita as etapas 6-16 para cada Assinante.

Para criar uma publicação e criar manualmente instantâneos para cada partição

1. Use uma instância da classe MergePublication para definir uma publicação de mesclagem. Para obter mais informações, consulte Crie uma publicação.

2. Use a propriedade MergeArticle para adicionar artigos para a publicação. Especifique a propriedade FilterClause para pelo menos um artigo que defina o filtro com parâmetros e crie quaisquer objetos MergeJoinFilter que definam filtros de junção entre artigos. Para obter mais informações, consulte Defina um Artigo.

3. Gere o instantâneo inicial. Para obter mais informações, consulte Criar e aplicar o instantâneo inicial.

4. Crie uma instância da classe SnapshotGenerationAgent e defina as seguintes propriedades necessárias:

   • Publisher - nome do Publicador

   • PublisherDatabase - nome do banco de dados de publicação

   • Publication - nome da publicação

   • Distributor - nome do Distribuidor

   • PublisherSecurityMode - um valor de Integrated para Autenticação integrada do Windows usada ou um valor de Standard para usar o Autenticação do SQL Server.

   • DistributorSecurityMode - um valor de Integrated para Autenticação integrada do Windows usada ou um valor de Standard para usar o Autenticação do SQL Server.

5. Defina um valor de Merge para ReplicationType.

6. Defina uma ou mais das seguintes propriedades a fim de definir os parâmetros de particionamento:

   • Se a partição do Assinante estiver definida pelo resultado de SUSER_SNAME (Transact-SQL), use DynamicFilterLogin.

   • Se a partição do Assinante estiver definida pelo resultado de HOST_NAME (Transact-SQL) ou uma sobrecarga dessa função, use DynamicFilterHostName.

7. Chame o método GenerateSnapshot.

8. Repita as etapas 4-7 para cada Assinante.

Exemplos (RMO)

Esse exemplo cria uma publicação de mesclagem que permite aos Assinantes solicitar geração de instantâneo.

         // Set the Publisher, publication database, and publication names.
            string publisherName = publisherInstance;
            string publicationName = "AdvWorksSalesOrdersMerge";
            string publicationDbName = "AdventureWorks2012";

            ReplicationDatabase publicationDb;
            MergePublication publication;

            // Create a connection to the Publisher.
            ServerConnection conn = new ServerConnection(publisherName);

            try
            {
                // Connect to the Publisher.
                conn.Connect();

                // Enable the database for merge publication.               
                publicationDb = new ReplicationDatabase(publicationDbName, conn);
                if (publicationDb.LoadProperties())
                {
                    if (!publicationDb.EnabledMergePublishing)
                    {
                        publicationDb.EnabledMergePublishing = true;
                    }
                }
                else
                {
                    // Do something here if the database does not exist. 
                    throw new ApplicationException(String.Format(
                        "The {0} database does not exist on {1}.",
                        publicationDb, publisherName));
                }

                // Set the required properties for the merge publication.
                publication = new MergePublication();
                publication.ConnectionContext = conn;
                publication.Name = publicationName;
                publication.DatabaseName = publicationDbName;

                // Enable precomputed partitions.
                publication.PartitionGroupsOption = PartitionGroupsOption.True;

                // Specify the Windows account under which the Snapshot Agent job runs.
                // This account will be used for the local connection to the 
                // Distributor and all agent connections that use Windows Authentication.
                publication.SnapshotGenerationAgentProcessSecurity.Login = winLogin;
                publication.SnapshotGenerationAgentProcessSecurity.Password = winPassword;

                // Explicitly set the security mode for the Publisher connection
                // Windows Authentication (the default).
                publication.SnapshotGenerationAgentPublisherSecurity.WindowsAuthentication = true;

                // Enable Subscribers to request snapshot generation and filtering.
                publication.Attributes |= PublicationAttributes.AllowSubscriberInitiatedSnapshot;
                publication.Attributes |= PublicationAttributes.DynamicFilters;

                // Enable pull and push subscriptions.
                publication.Attributes |= PublicationAttributes.AllowPull;
                publication.Attributes |= PublicationAttributes.AllowPush;

                if (!publication.IsExistingObject)
                {
                    // Create the merge publication.
                    publication.Create();
                    
                    // Create a Snapshot Agent job for the publication.
                    publication.CreateSnapshotAgent();
                }
                else
                {
                    throw new ApplicationException(String.Format(
                        "The {0} publication already exists.", publicationName));
                }
            }

            catch (Exception ex)
            {
                // Implement custom application error handling here.
                throw new ApplicationException(String.Format(
                    "The publication {0} could not be created.", publicationName), ex);
            }
            finally
            {
                conn.Disconnect();
            }

' Set the Publisher, publication database, and publication names.
Dim publisherName As String = publisherInstance
Dim publicationName As String = "AdvWorksSalesOrdersMerge"
Dim publicationDbName As String = "AdventureWorks2012"

Dim publicationDb As ReplicationDatabase
Dim publication As MergePublication

' Create a connection to the Publisher.
Dim conn As ServerConnection = New ServerConnection(publisherName)

Try
    ' Connect to the Publisher.
    conn.Connect()

    ' Enable the database for merge publication.                
    publicationDb = New ReplicationDatabase(publicationDbName, conn)
    If publicationDb.LoadProperties() Then
        If Not publicationDb.EnabledMergePublishing Then
            publicationDb.EnabledMergePublishing = True
        End If
    Else
        ' Do something here if the database does not exist. 
        Throw New ApplicationException(String.Format( _
         "The {0} database does not exist on {1}.", _
         publicationDb, publisherName))
    End If

    ' Set the required properties for the merge publication.
    publication = New MergePublication()
    publication.ConnectionContext = conn
    publication.Name = publicationName
    publication.DatabaseName = publicationDbName

    ' Enable precomputed partitions.
    publication.PartitionGroupsOption = PartitionGroupsOption.True

    ' Specify the Windows account under which the Snapshot Agent job runs.
    ' This account will be used for the local connection to the 
    ' Distributor and all agent connections that use Windows Authentication.
    publication.SnapshotGenerationAgentProcessSecurity.Login = winLogin
    publication.SnapshotGenerationAgentProcessSecurity.Password = winPassword

    ' Explicitly set the security mode for the Publisher connection
    ' Windows Authentication (the default).
    publication.SnapshotGenerationAgentPublisherSecurity.WindowsAuthentication = True

    ' Enable Subscribers to request snapshot generation and filtering.
    publication.Attributes = publication.Attributes Or _
        PublicationAttributes.AllowSubscriberInitiatedSnapshot
    publication.Attributes = publication.Attributes Or _
        PublicationAttributes.DynamicFilters

    ' Enable pull and push subscriptions
    publication.Attributes = publication.Attributes Or _
        PublicationAttributes.AllowPull
    publication.Attributes = publication.Attributes Or _
        PublicationAttributes.AllowPush

    If Not publication.IsExistingObject Then
        ' Create the merge publication.
        publication.Create()

        ' Create a Snapshot Agent job for the publication.
        publication.CreateSnapshotAgent()
    Else
        Throw New ApplicationException(String.Format( _
            "The {0} publication already exists.", publicationName))
    End If
Catch ex As Exception
    ' Implement custom application error handling here.
    Throw New ApplicationException(String.Format( _
        "The publication {0} could not be created.", publicationName), ex)
Finally
    conn.Disconnect()
End Try

Esse exemplo cria a partição de Assinante e o instantâneo filtrado manualmente para uma publicação de mesclagem com filtros de linha com parâmetros.

            // Define the server, database, and publication names
            string publisherName = publisherInstance;
            string publicationName = "AdvWorksSalesOrdersMerge";
            string publicationDbName = "AdventureWorks2012";
            string distributorName = publisherInstance;

            MergePublication publication;
            MergePartition partition;
            MergeDynamicSnapshotJob snapshotAgentJob;
            ReplicationAgentSchedule schedule;
            
            // Create a connection to the Publisher.
            ServerConnection publisherConn = new ServerConnection(publisherName);

            // Create a connection to the Distributor to start the Snapshot Agent.
            ServerConnection distributorConn = new ServerConnection(distributorName);

            try
            {
                // Connect to the Publisher.
                publisherConn.Connect();

                // Set the required properties for the publication.
                publication = new MergePublication();
                publication.ConnectionContext = publisherConn;
                publication.Name = publicationName;
                publication.DatabaseName = publicationDbName;


                // If we can't get the properties for this merge publication, 
                // then throw an application exception.
                if (publication.LoadProperties() || publication.SnapshotAvailable)
                {
                    // Set a weekly schedule for the filtered data snapshot.
                    schedule = new ReplicationAgentSchedule();
                    schedule.FrequencyType = ScheduleFrequencyType.Weekly;
                    schedule.FrequencyRecurrenceFactor = 1;
                    schedule.FrequencyInterval = Convert.ToInt32(0x001);

                    // Set the value of Hostname that defines the data partition. 
                    partition = new MergePartition();
                    partition.DynamicFilterHostName = hostname;
                    snapshotAgentJob = new MergeDynamicSnapshotJob();
                    snapshotAgentJob.DynamicFilterHostName = hostname;

                    // Create the partition for the publication with the defined schedule.
                    publication.AddMergePartition(partition);
                    publication.AddMergeDynamicSnapshotJob(snapshotAgentJob, schedule);
                }
                else
                {
                    throw new ApplicationException(String.Format(
                        "Settings could not be retrieved for the publication, " +
                        " or the initial snapshot has not been generated. " +
                        "Ensure that the publication {0} exists on {1} and " +
                        "that the Snapshot Agent has run successfully.",
                        publicationName, publisherName));
                }
            }
            catch (Exception ex)
            {
                // Do error handling here.
                throw new ApplicationException(string.Format(
                    "The partition for '{0}' in the {1} publication could not be created.",
                    hostname, publicationName), ex);
            }
            finally
            {
                publisherConn.Disconnect();
                if (distributorConn.IsOpen) distributorConn.Disconnect();
            }

' Define the server, database, and publication names
Dim publisherName As String = publisherInstance
Dim publicationName As String = "AdvWorksSalesOrdersMerge"
Dim publicationDbName As String = "AdventureWorks2012"
Dim distributorName As String = publisherInstance

Dim publication As MergePublication
Dim partition As MergePartition
Dim snapshotAgentJob As MergeDynamicSnapshotJob
Dim schedule As ReplicationAgentSchedule

' Create a connection to the Publisher.
Dim publisherConn As ServerConnection = New ServerConnection(publisherName)

' Create a connection to the Distributor to start the Snapshot Agent.
Dim distributorConn As ServerConnection = New ServerConnection(distributorName)

Try
    ' Connect to the Publisher.
    publisherConn.Connect()

    ' Set the required properties for the publication.
    publication = New MergePublication()
    publication.ConnectionContext = publisherConn
    publication.Name = publicationName
    publication.DatabaseName = publicationDbName


    ' If we can't get the properties for this merge publication, 
    ' then throw an application exception.
    If (publication.LoadProperties() Or publication.SnapshotAvailable) Then
        ' Set a weekly schedule for the filtered data snapshot.
        schedule = New ReplicationAgentSchedule()
        schedule.FrequencyType = ScheduleFrequencyType.Weekly
        schedule.FrequencyRecurrenceFactor = 1
        schedule.FrequencyInterval = Convert.ToInt32("0x001", 16)

        ' Set the value of Hostname that defines the data partition. 
        partition = New MergePartition()
        partition.DynamicFilterHostName = hostname
        snapshotAgentJob = New MergeDynamicSnapshotJob()
        snapshotAgentJob.DynamicFilterHostName = hostname

        ' Create the partition for the publication with the defined schedule.
        publication.AddMergePartition(partition)
        publication.AddMergeDynamicSnapshotJob(snapshotAgentJob, schedule)
    Else
        Throw New ApplicationException(String.Format( _
         "Settings could not be retrieved for the publication, " + _
         " or the initial snapshot has not been generated. " + _
         "Ensure that the publication {0} exists on {1} and " + _
         "that the Snapshot Agent has run successfully.", _
         publicationName, publisherName))
    End If
Catch ex As Exception
    ' Do error handling here.
    Throw New ApplicationException(String.Format( _
     "The partition for '{0}' in the {1} publication could not be created.", _
     hostname, publicationName), ex)
Finally
    publisherConn.Disconnect()
    If distributorConn.IsOpen Then
        distributorConn.Disconnect()
    End If
End Try

Esse exemplo inicia manualmente o Agente de Instantâneo para a geração do instantâneo de dados filtrado para um Assinante para uma publicação de mesclagem com filtros de linha com parâmetros.

         // Set the Publisher, publication database, and publication names.
            string publicationName = "AdvWorksSalesOrdersMerge";
            string publicationDbName = "AdventureWorks2012";
            string publisherName = publisherInstance;
            string distributorName = publisherInstance;

            SnapshotGenerationAgent agent;

            try
            {
                // Set the required properties for Snapshot Agent.
                agent = new SnapshotGenerationAgent();
                agent.Distributor = distributorName;
                agent.DistributorSecurityMode = SecurityMode.Integrated;
                agent.Publisher = publisherName;
                agent.PublisherSecurityMode = SecurityMode.Integrated;
                agent.Publication = publicationName;
                agent.PublisherDatabase = publicationDbName;
                agent.ReplicationType = ReplicationType.Merge;

                // Specify the partition information to generate a 
                // filtered snapshot based on Hostname.
                agent.DynamicFilterHostName = hostname;

                // Start the agent synchronously.
                agent.GenerateSnapshot();
            }
            catch (Exception ex)
            {
                // Implement custom application error handling here.
                throw new ApplicationException(String.Format(
                    "A snapshot could not be generated for the {0} publication."
                    , publicationName), ex);
            }

' Set the Publisher, publication database, and publication names.
Dim publicationName As String = "AdvWorksSalesOrdersMerge"
Dim publicationDbName As String = "AdventureWorks2012"
Dim publisherName As String = publisherInstance
Dim distributorName As String = publisherInstance

Dim agent As SnapshotGenerationAgent

Try
    ' Set the required properties for Snapshot Agent.
    agent = New SnapshotGenerationAgent()
    agent.Distributor = distributorName
    agent.DistributorSecurityMode = SecurityMode.Integrated
    agent.Publisher = publisherName
    agent.PublisherSecurityMode = SecurityMode.Integrated
    agent.Publication = publicationName
    agent.PublisherDatabase = publicationDbName
    agent.ReplicationType = ReplicationType.Merge

    ' Specify the partition information to generate a 
    ' filtered snapshot based on Hostname.
    agent.DynamicFilterHostName = hostname

    ' Start the agent synchronously.
    agent.GenerateSnapshot()
Catch ex As Exception
    ' Implement custom application error handling here.
    Throw New ApplicationException(String.Format( _
     "A snapshot could not be generated for the {0} publication." _
     , publicationName), ex)
End Try

[Top]

Consulte também

Conceitos

Filtros de linha com parâmetros

Conceitos dos procedimentos armazenados do sistema de replicação

Instantâneos para publicações de mesclagem com filtros com parâmetros

Práticas recomendadas em relação à segurança de replicação