Synchronizace pushového předplatného

platí pro:SQL Server azure SQL Database

Toto téma popisuje, jak synchronizovat odběr nabízených oznámení v SQL Serveru pomocí aplikace SQL Server Management Studio, agentů replikace nebo objektů RMO (Replication Management Object).

Poznámka:

Spravovaná instance Azure SQL může být vydavatelem, distributorem a předplatitelem pro snímkovou a transakční replikaci. Databáze ve službě Azure SQL Database můžou být nabízeny pouze předplatitelům pro snímkovou a transakční replikaci. Další informace najdete v tématu Transakční replikace se službou Azure SQL Database a službou Azure SQL Managed Instance.

Použití aplikace SQL Server Management Studio

Předplatná se synchronizují pomocí distribučního agenta (pro snímkovou a transakční replikaci) nebo slučovacího agenta (pro slučovací replikaci). Agenti můžou běžet nepřetržitě, běžet na vyžádání nebo běžet podle plánu. Další informace o určení plánů synchronizace naleznete v tématu Určení plánů synchronizace.

Synchronizujte předplatné na vyžádání ze složek Místní publikace a Místní předplatná v aplikaci Microsoft SQL Server Management Studio a na kartě Všechna předplatná v nástroji Sledování replikace. Odběry publikací Oracle nelze synchronizovat na vyžádání od odběratele. Informace o spuštění služby Replication Monitor naleznete v tématu Spuštění monitorování replikace.

Synchronizovat push předplatné na vyžádání ve studiu Managementu na straně Publisheru

Připojte se k Publisher v Management Studiu a potom rozbalte uzel serveru.
Rozbalte složku Replikace a potom rozbalte složku Místní publikace .
Rozbalte publikaci, pro kterou chcete synchronizovat odběry.
Klikněte pravým tlačítkem myši na předplatné, které chcete synchronizovat, a potom klepněte na příkaz Zobrazit stav synchronizace.
V zobrazení stav synchronizace - <Odběratel>:<SubscriptionDatabase> dialogové okno, klepněte na tlačítko Start. Po dokončení synchronizace se zobrazí zpráva Synchronizace byla dokončena .
Klepněte na tlačítko Zavřít.

Synchronizace push předplatného na vyžádání v prostředí Management Studio (u odběratele)

Připojte se k odběrateli v prostředí Management Studio a pak rozbalte uzel serveru.
Rozbalte složku Replikace a potom rozbalte složku Místní předplatná .
Klikněte pravým tlačítkem myši na předplatné, které chcete synchronizovat, a potom klepněte na příkaz Zobrazit stav synchronizace.
Zobrazí se zpráva o navázání připojení k distributoru. Klikněte na OK.
V zobrazení stav synchronizace - <Odběratel>:<SubscriptionDatabase> dialogové okno, klepněte na tlačítko Start. Po dokončení synchronizace se zobrazí zpráva Synchronizace byla dokončena .
Klepněte na tlačítko Zavřít.

Chcete-li na vyžádání synchronizovat push předplatné ve službě Replication Monitor

V nástroji Sledování replikace rozbalte skupinu vydavatele v levém podokně, rozbalte položku Publisher a klikněte na publikaci.
Klikněte na kartu Všechna předplatná .
Klikněte pravým tlačítkem myši na předplatné, které chcete synchronizovat, a potom klepněte na tlačítko Spustit synchronizaci.
Chcete-li zobrazit průběh synchronizace, klikněte pravým tlačítkem myši na předplatné a potom klepněte na tlačítko Zobrazit podrobnosti.

Použití agentů replikace

Push předplatná je možné synchronizovat programově a na vyžádání vyvoláním příslušného spustitelného souboru agenta replikace z příkazového řádku. Spustitelný soubor agenta replikace, který je vyvolán, bude záviset na typu publikace, do které patří nabízené předplatné.

Spuštění distribučního agenta pro synchronizaci odběru nabízených oznámení do transakční publikace

Z příkazového řádku nebo v dávkovém souboru na Distributorovi spusťte distrib.exe. Zadejte následující argumenty příkazového řádku:
- -Vydavatel
- -PublisherDB
- -Distributor
- -Předplatitel
- -SubscriberDB
- -SubscriptionType = 0
Pokud používáte ověřování SQL Serveru, musíte také zadat následující argumenty:
- -DistributorLogin
- -DistributorPassword
- -DistributorSecurityMode = 0
- -PublisherLogin
- -PublisherPassword
- -PublisherSecurityMode = 0
- -SubscriberLogin
- -SubscriberPassword
- -SubscriberSecurityMode = 0
  
  Důležité
  
  Pokud je to možné, použijte ověřování systému Windows.

Spuštění agenta sloučení pro synchronizaci push odběru do sloučené publikace

Z příkazového řádku nebo v dávkovém souboru na distributoru spusťte replmerg.exe. Zadejte následující argumenty příkazového řádku:
- -Vydavatel
- -PublisherDB
- -Publikace
- -Distributor
- -Předplatitel
- -SubscriberDB
- -SubscriptionType = 0
Pokud používáte ověřování SQL Serveru, musíte také zadat následující argumenty:
- -DistributorLogin
- -DistributorPassword
- -DistributorSecurityMode = 0
- -PublisherLogin
- -PublisherPassword
- -PublisherSecurityMode = 0
- -SubscriberLogin
- -SubscriberPassword
- -SubscriberSecurityMode = 0
  
  Důležité
  
  Pokud je to možné, použijte ověřování systému Windows.

Příklady (agenti replikace)

Následující příklad spustí Distribučního agenta pro synchronizaci push předplatného.

  
REM -- Declare the variables.  
SET Publisher=%instancename%  
SET Subscriber=%instancename%  
SET PublicationDB=AdventureWorks2022  
SET SubscriptionDB=AdventureWorks2022Replica   
SET Publication=AdvWorksProductsTran  
  
REM -- Start the Distribution Agent with four subscription streams.  
REM -- The following command must be supplied without line breaks.  
"C:\Program Files\Microsoft SQL Server\120\COM\DISTRIB.EXE" -Subscriber %Subscriber%   
-SubscriberDB %SubscriptionDB% -SubscriberSecurityMode 1 -Publication %Publication%   
-Publisher %Publisher% -PublisherDB %PublicationDB% -Distributor %Publisher%   
-DistributorSecurityMode 1 -Continuous -SubscriptionType 0 -SubscriptionStreams 4

Následující příklad spustí slučovací agent pro synchronizaci push předplatného.

  
REM -- Declare the variables.  
SET Publisher=%instancename%  
SET Subscriber=%instancename%  
SET PublicationDB=AdventureWorks2022  
SET SubscriptionDB=AdventureWorks2022Replica   
SET Publication=AdvWorksSalesOrdersMerge  
  
REM -- Start the Merge Agent.  
REM -- The following command must be supplied without line breaks.  
"C:\Program Files\Microsoft SQL Server\120\COM\REPLMERG.EXE"  -Publisher %Publisher%   
-Subscriber  %Subscriber%  -Distributor %Publisher% -PublisherDB  %PublicationDB%   
-SubscriberDB %SubscriptionDB% -Publication %Publication% -PublisherSecurityMode 1   
-OutputVerboseLevel 3  -Output -SubscriberSecurityMode 1  -SubscriptionType 0   
-DistributorSecurityMode 1

Použití objektů správy replikace (RMO)

Pushová předplatná můžete synchronizovat programově pomocí objektů RMO (Replication Management Objects) a spravovaným kódem a přístupem k funkcionalitám agenta replikace. Třídy, které používáte k synchronizaci push předplatného, závisí na typu publikace, ke kterému předplatné patří.

Poznámka:

Pokud chcete spustit synchronizaci, která běží samostatně, aniž by to ovlivnilo vaši aplikaci, spusťte agenta asynchronně. Pokud ale chcete monitorovat výsledek synchronizace a přijímat zpětná volání z agenta během procesu synchronizace (například pokud chcete zobrazit indikátor průběhu), měli byste agenta spustit synchronně. Pro předplatitele edice Microsoft SQL Server 2005 Express je nutné spustit agent synchronně.

Synchronizace nabízeného předplatného se snímkem nebo transakční publikací

Vytvořte připojení k distributoru pomocí ServerConnection třídy.
Vytvořte instanci TransSubscription třídy a nastavte následující vlastnosti:
- Název databáze publikace pro DatabaseName.
- Název publikace, do které předplatné patří PublicationName.
- Název databáze předplatného pro SubscriptionDBName.
- Jméno odběratele pro SubscriberName.
- Připojení vytvořené v kroku 1 pro ConnectionContext.
Voláním LoadProperties metody získejte zbývající vlastnosti předplatného. Pokud tato metoda vrátí hodnotu false, ověřte, že předplatné existuje.
Na Distribučním serveru spusťte distribučního agenta jedním z následujících způsobů:
- Zavolejte metodu SynchronizeWithJob na instanci TransSubscription z kroku 2. Tato metoda spustí agenta distribuce asynchronně a řízení se okamžitě vrátí do vaší aplikace, zatímco je spuštěna úloha agenta. Tuto metodu nelze volat, pokud bylo předplatné vytvořeno s hodnotou false pro CreateSyncAgentByDefault.
- Získejte instanci třídy TransSynchronizationAgent pomocí vlastnosti SynchronizationAgent a zavolejte metodu Synchronize. Tato metoda spustí agenta synchronně a řízení zůstane se spuštěnou úlohou agenta. Během synchronního spuštění můžete zpracovat Status událost, když je agent spuštěn.

Pro synchronizaci odesílaného odběru se slučovací publikací

Vytvořte připojení k distributoru pomocí ServerConnection třídy.
Vytvořte instanci MergeSubscription třídy a nastavte následující vlastnosti:
- Název databáze publikace pro DatabaseName.
- Název publikace, do které předplatné patří PublicationName.
- Název databáze předplatného pro SubscriptionDBName.
- Jméno odběratele pro SubscriberName.
- Připojení vytvořené v kroku 1 pro ConnectionContext.
Voláním LoadProperties metody získejte zbývající vlastnosti předplatného. Pokud tato metoda vrátí hodnotu false, ověřte, že předplatné existuje.
Spusťte agenta sloučení u distributora jedním z následujících způsobů:
- Zavolejte metodu SynchronizeWithJob na instanci MergeSubscription z kroku 2. Tato metoda spustí slučovacího agenta asynchronně, a řídicí funkce se okamžitě vrátí vaší aplikaci, zatímco běží úloha agenta. Tuto metodu nelze volat, pokud bylo předplatné vytvořeno s hodnotou false pro CreateSyncAgentByDefault.
- Získejte instanci třídy MergeSynchronizationAgent pomocí vlastnosti SynchronizationAgent a zavolejte metodu Synchronize. Tato metoda spustí agenta sloučení synchronně a ovládací prvek zůstane se spuštěnou úlohou agenta. Během synchronního spouštění můžete zpracovat Status událost během spuštění agenta.

Příklady (RMO)

Tento příklad synchronizuje odběr nabízených oznámení do transakční publikace, kde je agent spuštěn asynchronně pomocí úlohy agenta.

// Define the server, publication, and database names.
string subscriberName = subscriberInstance;
string publisherName = publisherInstance;
string publicationName = "AdvWorksProductTran";
string subscriptionDbName = "AdventureWorks2022Replica";
string publicationDbName = "AdventureWorks2022";

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

TransSubscription subscription;

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

    // Instantiate the push subscription.
    subscription = new TransSubscription();
    subscription.ConnectionContext = conn;
    subscription.DatabaseName = publicationDbName;
    subscription.PublicationName = publicationName;
    subscription.SubscriptionDBName = subscriptionDbName;
    subscription.SubscriberName = subscriberName;

    // If the push subscription and the job exists, start the agent job.
    if (subscription.LoadProperties() && subscription.AgentJobId != null)
    {
        // Start the Distribution Agent asynchronously.
        subscription.SynchronizeWithJob();
    }
    else
    {
        // Do something here if the subscription does not exist.
        throw new ApplicationException(String.Format(
            "A subscription to '{0}' does not exists on {1}",
            publicationName, subscriberName));
    }
}
catch (Exception ex)
{
    // Implement appropriate error handling here.
    throw new ApplicationException("The subscription could not be synchronized.", ex);
}
finally
{
    conn.Disconnect();
}

' Define the server, publication, and database names.
Dim subscriberName As String = subscriberInstance
Dim publisherName As String = publisherInstance
Dim publicationName As String = "AdvWorksProductTran"
Dim subscriptionDbName As String = "AdventureWorks2022Replica"
Dim publicationDbName As String = "AdventureWorks2022"

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

Dim subscription As TransSubscription

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

    ' Instantiate the push subscription.
    subscription = New TransSubscription()
    subscription.ConnectionContext = conn
    subscription.DatabaseName = publicationDbName
    subscription.PublicationName = publicationName
    subscription.SubscriptionDBName = subscriptionDbName
    subscription.SubscriberName = subscriberName

    ' If the push subscription and the job exists, start the agent job.
    If subscription.LoadProperties() And Not subscription.AgentJobId Is Nothing Then
        ' Start the Distribution Agent asynchronously.
        subscription.SynchronizeWithJob()
    Else
        ' Do something here if the subscription does not exist.
        Throw New ApplicationException(String.Format( _
         "A subscription to '{0}' does not exists on {1}", _
         publicationName, subscriberName))
    End If
Catch ex As Exception
    ' Implement appropriate error handling here.
    Throw New ApplicationException("The subscription could not be synchronized.", ex)
Finally
    conn.Disconnect()
End Try

Tento příklad synchronizuje push odběr s transakční publikací, kde je agent spuštěn synchronním způsobem.

// Define the server, publication, and database names.
string subscriberName = subscriberInstance;
string publisherName = publisherInstance;
string publicationName = "AdvWorksProductTran";
string subscriptionDbName = "AdventureWorks2022Replica";
string publicationDbName = "AdventureWorks2022";

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

TransSubscription subscription;

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

    // Define the push subscription.
    subscription = new TransSubscription();
    subscription.ConnectionContext = conn;
    subscription.DatabaseName = publicationDbName;
    subscription.PublicationName = publicationName;
    subscription.SubscriptionDBName = subscriptionDbName;
    subscription.SubscriberName = subscriberName;

    // If the push subscription exists, start the synchronization.
    if (subscription.LoadProperties())
    {
        // Check that we have enough metadata to start the agent.
        if (subscription.SubscriberSecurity != null)
        {
            // Synchronously start the Distribution Agent for the subscription.
            subscription.SynchronizationAgent.Synchronize();
        }
        else
        {
            throw new ApplicationException("There is insufficent metadata to " +
                "synchronize the subscription. Recreate the subscription with " +
                "the agent job or supply the required agent properties at run time.");
        }
    }
    else
    {
        // Do something here if the push subscription does not exist.
        throw new ApplicationException(String.Format(
            "The subscription to '{0}' does not exist on {1}",
            publicationName, subscriberName));
    }
}
catch (Exception ex)
{
    // Implement appropriate error handling here.
    throw new ApplicationException("The subscription could not be synchronized.", ex);
}
finally
{
    conn.Disconnect();
}

' Define the server, publication, and database names.
Dim subscriberName As String = subscriberInstance
Dim publisherName As String = publisherInstance
Dim publicationName As String = "AdvWorksProductTran"
Dim subscriptionDbName As String = "AdventureWorks2022Replica"
Dim publicationDbName As String = "AdventureWorks2022"

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

Dim subscription As TransSubscription

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

    ' Define the push subscription.
    subscription = New TransSubscription()
    subscription.ConnectionContext = conn
    subscription.DatabaseName = publicationDbName
    subscription.PublicationName = publicationName
    subscription.SubscriptionDBName = subscriptionDbName
    subscription.SubscriberName = subscriberName

    ' If the push subscription exists, start the synchronization.
    If subscription.LoadProperties() Then
        ' Check that we have enough metadata to start the agent.
        If Not subscription.SubscriberSecurity Is Nothing Then

            ' Synchronously start the Distribution Agent for the subscription.
            subscription.SynchronizationAgent.Synchronize()
        Else
            Throw New ApplicationException("There is insufficent metadata to " + _
             "synchronize the subscription. Recreate the subscription with " + _
             "the agent job or supply the required agent properties at run time.")
        End If
    Else
        ' Do something here if the push subscription does not exist.
        Throw New ApplicationException(String.Format( _
         "The subscription to '{0}' does not exist on {1}", _
         publicationName, subscriberName))
    End If
Catch ex As Exception
    ' Implement appropriate error handling here.
    Throw New ApplicationException("The subscription could not be synchronized.", ex)
Finally
    conn.Disconnect()
End Try

Tento příklad synchronizuje nabízené předplatné s slučovací publikací, kde se agent spouští asynchronně pomocí úlohy agenta.

// Define the server, publication, and database names.
string subscriberName = subscriberInstance;
string publisherName = publisherInstance;
string publicationName = "AdvWorksSalesOrdersMerge";
string subscriptionDbName = "AdventureWorks2022Replica";
string publicationDbName = "AdventureWorks2022";

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

MergeSubscription subscription;

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

    // Define push subscription.
    subscription = new MergeSubscription();
    subscription.ConnectionContext = conn;
    subscription.DatabaseName = publicationDbName;
    subscription.PublicationName = publicationName;
    subscription.SubscriptionDBName = subscriptionDbName;
    subscription.SubscriberName = subscriberName;

    // If the push subscription and the job exists, start the agent job.
    if (subscription.LoadProperties() && subscription.AgentJobId != null)
    {
        // Start the Merge Agent asynchronously.
        subscription.SynchronizeWithJob();
    }
    else
    {
        // Do something here if the subscription does not exist.
        throw new ApplicationException(String.Format(
            "A subscription to '{0}' does not exists on {1}",
            publicationName, subscriberName));
    }
}
catch (Exception ex)
{
    // Implement appropriate error handling here.
    throw new ApplicationException("The subscription could not be synchronized.", ex);
}
finally
{
    conn.Disconnect();
}

' Define the server, publication, and database names.
Dim subscriberName As String = subscriberInstance
Dim publisherName As String = publisherInstance
Dim publicationName As String = "AdvWorksSalesOrdersMerge"
Dim subscriptionDbName As String = "AdventureWorks2022Replica"
Dim publicationDbName As String = "AdventureWorks2022"

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

Dim subscription As MergeSubscription

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

    ' Define push subscription.
    subscription = New MergeSubscription()
    subscription.ConnectionContext = conn
    subscription.DatabaseName = publicationDbName
    subscription.PublicationName = publicationName
    subscription.SubscriptionDBName = subscriptionDbName
    subscription.SubscriberName = subscriberName

    ' If the push subscription and the job exists, start the agent job.
    If subscription.LoadProperties() And Not subscription.AgentJobId Is Nothing Then
        ' Start the Merge Agent asynchronously.
        subscription.SynchronizeWithJob()
    Else
        ' Do something here if the subscription does not exist.
        Throw New ApplicationException(String.Format( _
            "A subscription to '{0}' does not exists on {1}", _
            publicationName, subscriberName))
    End If
Catch ex As Exception
    ' Implement appropriate error handling here.
    Throw New ApplicationException("The subscription could not be synchronized.", ex)
Finally
    conn.Disconnect()
End Try

Tento příklad synchronizuje push odběr se slučovací publikací, kde je agent spuštěn synchronně.

// Define the server, publication, and database names.
string subscriberName = subscriberInstance;
string publisherName = publisherInstance;
string publicationName = "AdvWorksSalesOrdersMerge";
string subscriptionDbName = "AdventureWorks2022Replica";
string publicationDbName = "AdventureWorks2022";

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

MergeSubscription subscription;

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

    // Define the subscription.
    subscription = new MergeSubscription();
    subscription.ConnectionContext = conn;
    subscription.DatabaseName = publicationDbName;
    subscription.PublicationName = publicationName;
    subscription.SubscriptionDBName = subscriptionDbName;
    subscription.SubscriberName = subscriberName;

    // If the push subscription exists, start the synchronization.
    if (subscription.LoadProperties())
    {
        // Check that we have enough metadata to start the agent.
        if (subscription.SubscriberSecurity != null)
        {
            // Synchronously start the Merge Agent for the subscription.
            subscription.SynchronizationAgent.Synchronize();
        }
        else
        {
            throw new ApplicationException("There is insufficent metadata to " +
                "synchronize the subscription. Recreate the subscription with " +
                "the agent job or supply the required agent properties at run time.");
        }
    }
    else
    {
        // Do something here if the push subscription does not exist.
        throw new ApplicationException(String.Format(
            "The subscription to '{0}' does not exist on {1}",
            publicationName, subscriberName));
    }
}
catch (Exception ex)
{
    // Implement appropriate error handling here.
    throw new ApplicationException("The subscription could not be synchronized.", ex);
}
finally
{
    conn.Disconnect();
}

' Define the server, publication, and database names.
Dim subscriberName As String = subscriberInstance
Dim publisherName As String = publisherInstance
Dim publicationName As String = "AdvWorksSalesOrdersMerge"
Dim subscriptionDbName As String = "AdventureWorks2022Replica"
Dim publicationDbName As String = "AdventureWorks2022"

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

Dim subscription As MergeSubscription

Try
    ' Connect to the Publisher
    conn.Connect()

    ' Define the subscription.
    subscription = New MergeSubscription()
    subscription.ConnectionContext = conn
    subscription.DatabaseName = publicationDbName
    subscription.PublicationName = publicationName
    subscription.SubscriptionDBName = subscriptionDbName
    subscription.SubscriberName = subscriberName

    ' If the push subscription exists, start the synchronization.
    If subscription.LoadProperties() Then
        ' Check that we have enough metadata to start the agent.
        If Not subscription.SubscriberSecurity Is Nothing Then
            ' Synchronously start the Merge Agent for the subscription.
            ' Log agent messages to an output file.
            subscription.SynchronizationAgent.Output = "mergeagent.log"
            subscription.SynchronizationAgent.OutputVerboseLevel = 2
            subscription.SynchronizationAgent.Synchronize()
        Else
            Throw New ApplicationException("There is insufficent metadata to " + _
             "synchronize the subscription. Recreate the subscription with " + _
             "the agent job or supply the required agent properties at run time.")
        End If
    Else
        ' Do something here if the push subscription does not exist.
        Throw New ApplicationException(String.Format( _
         "The subscription to '{0}' does not exist on {1}", _
         publicationName, subscriberName))
    End If
Catch ex As Exception
    ' Implement appropriate error handling here.
    Throw New ApplicationException("The subscription could not be synchronized.", ex)
Finally
    conn.Disconnect()
End Try

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-12-08