schemadoc.xml

<!-- $Header: /slony1/slony1-engine/doc/adminguide/schemadoc.xml,v 1.7 2006-07-31 18:56:24 cbbrowne Exp $ -->

<chapter id="schema" xreflabel="schemadoc">
<title>Schéma schemadoc</title>

<section id="table.sl-archive-counter"
  xreflabel="sl_archive_counter">
<title id="table.sl-archive-counter-title">
  Table&nbsp;: <structname>sl_archive_counter</structname>
</title>

<para>
  Table utilisée pour générer le numéro d'archive du log shipping.
</para>

<para>
  <variablelist>
    <title>Structure de <structname>sl_archive_counter</structname></title>

    <varlistentry>
      <term><structfield>ac_num</structfield></term>
      <listitem>
        <para><type>bigint</type></para>

        <para>
          Compteur de l'identifiant SYNC utilisé dans le log shipping comme
	  numéro d'archive
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>ac_timestamp</structfield></term>
      <listitem>
        <para><type>timestamp without time zone</type></para>

        <para>
          Horodatage de la génération du log d'archive sur l'abonné
        </para>
      </listitem>
    </varlistentry>
  </variablelist>
</para>

</section>

<section id="table.sl-config-lock" xreflabel="sl_config_lock">
<title id="table.sl-config-lock-title">
  Table&nbsp;: <structname>sl_config_lock</structname>
</title>

<para>
  Cette table existe seulement pour empêcher l'exécution concurrent de procédure
  de modification de la configuration et des verrous mortels possibles.
</para>

<para>
  <variablelist>
    <title>Structure de <structname>sl_config_lock</structname></title>

    <varlistentry>
      <term><structfield>dummy</structfield></term>
      <listitem>
        <para><type>integer</type></para>
        <para>
          Aucune donnée n'est placée dans cette table, donc son contenu n'a pas
	  d'importance. En fait, cette colonne n'a pas besoin d'exister.
        </para>
      </listitem>
    </varlistentry>
  </variablelist>
</para>

</section>

<section id="table.sl-confirm" xreflabel="sl_confirm">
<title id="table.sl-confirm-title">
  Table&nbsp;: <structname>sl_confirm</structname>
</title>
 
<para>
  Contient la confirmation des événements de réplication. Après une certaine
  période, Slony supprime les anciens événements à partir de cette table et
  de la table sl_event.
</para>

<para>
  <variablelist>
    <title>Structure de <structname>sl_confirm</structname></title>

    <varlistentry>
      <term><structfield>con_origin</structfield></term>
      <listitem>
        <para><type>integer</type></para>
        <para>
          L'identifiant (provenant de sl_node.no_id) du n&oelig;ud source pour
	  cet événement
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>con_received</structfield></term>
      <listitem>
        <para><type>integer</type></para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>con_seqno</structfield></term>
      <listitem>
        <para><type>bigint</type></para>
	
        <para>
          L'identifiant de l'événement
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>con_timestamp</structfield></term>
      <listitem>
        <para>
	  <type>timestamp without time zone</type>
	  <literal>DEFAULT (timeofday())::timestamp without time zone</literal>
	</para>
        <para>
          Horodatage de la confirmation de l'événement
        </para>
      </listitem>
    </varlistentry>
  </variablelist>

  <variablelist>
    <title>Index sur sl_confirm</title>

    <varlistentry>
      <term>sl_confirm_idx1</term>
      <listitem>
        <para>con_origin, con_received, con_seqno</para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term>sl_confirm_idx2</term>
      <listitem><para>con_received, con_seqno</para></listitem>
    </varlistentry>
  </variablelist>
</para>

</section>

<section id="table.sl-event" xreflabel="sl_event">
<title id="table.sl-event-title">
  Table&nbsp;: <structname>sl_event</structname>
</title>
 
<para>
  Contient des informations sur les événements de réplication. Après une période
  de temps, Slony supprime les anciens événements de cette table et de la table
  sl_confirm.
</para>

<para>
  <variablelist>
    <title>
      Structure de <structname>sl_event</structname>
    </title>

    <varlistentry>
      <term><structfield>ev_origin</structfield></term>
      <listitem>
        <para><type>integer</type> <literal>PRIMARY KEY</literal></para>

        <para>
          L'identifiant (provenant de sl_node.no_id) du n&oelig;ud source pour
	  cet événement
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>ev_seqno</structfield></term>
      <listitem>
        <para><type>bigint</type> <literal>PRIMARY KEY</literal></para>

        <para>
          L'identifiant de l'événement
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>ev_timestamp</structfield></term>
      <listitem>
        <para>
          <type>timestamp without time zone</type>
        </para>

        <para>
          Horodatage de la création de l'enregistrement
        </para>

      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>ev_minxid</structfield></term>
      <listitem>
        <para><type>xxid</type></para>

        <para>
          Identifiant de transaction le plus ancien du n&oelig;ud fournisseur
	  pour cet événement
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>ev_maxxid</structfield></term>
      <listitem>
        <para><type>xxid</type></para>

        <para>
          Dernier identifiant de transaction du n&oelig;ud fournisseur pour cet
	  événement
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>ev_xip</structfield></term>
      <listitem>
        <para><type>text</type></para>

        <para>
	  Liste des identifiants de transaction, dans l'ordre, qui font partie
	  de cet événement
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>ev_type</structfield></term>
      <listitem>
	<para><type>text</type></para>

        <para>
          Le type d'événement pour cet enregistrement.
				SYNC				= Synchronise
				STORE_NODE			=
				ENABLE_NODE			=
				DROP_NODE			=
				STORE_PATH			=
				DROP_PATH			=
				STORE_LISTEN		=
				DROP_LISTEN			=
				STORE_SET			=
				DROP_SET			=
				MERGE_SET			=
				SET_ADD_TABLE		=
				SET_ADD_SEQUENCE	=
				STORE_TRIGGER		=
				DROP_TRIGGER		=
				MOVE_SET			=
				ACCEPT_SET			=
				SET_DROP_TABLE			=
				SET_DROP_SEQUENCE		=
				SET_MOVE_TABLE			=
				SET_MOVE_SEQUENCE		=
				FAILOVER_SET		=
				SUBSCRIBE_SET		=
				ENABLE_SUBSCRIPTION	=
				UNSUBSCRIBE_SET		=
				DDL_SCRIPT			=
				ADJUST_SEQ			=
				RESET_CONFIG		=
        </para>
      </listitem>
    </varlistentry>
    
    <varlistentry>
      <term><structfield>ev_data1</structfield></term>
      <listitem>
        <para><type>text</type></para>
	
        <para>
          Champ de données contenant un argument nécessaire pour traiter
	  l'événement
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>ev_data2</structfield></term>
      <listitem>
        <para><type>text</type></para>

        <para>
          Champ de données contenant un argument nécessaire pour traiter
	  l'événement
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>ev_data3</structfield></term>
      <listitem>
        <para><type>text</type></para>

        <para>
          Champ de données contenant un argument nécessaire pour traiter
	  l'événement
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>ev_data4</structfield></term>
      <listitem>
        <para><type>text</type></para>

        <para>
          Champ de données contenant un argument nécessaire pour traiter
	  l'événement
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>ev_data5</structfield></term>
      <listitem>
        <para><type>text</type></para>

        <para>
          Champ de données contenant un argument nécessaire pour traiter
	  l'événement
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>ev_data6</structfield></term>
      <listitem>
        <para><type>text</type></para>

        <para>
          Champ de données contenant un argument nécessaire pour traiter
	  l'événement
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>ev_data7</structfield></term>
      <listitem>
        <para><type>text</type></para>

        <para>
          Champ de données contenant un argument nécessaire pour traiter
	  l'événement
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>ev_data8</structfield></term>
      <listitem>
        <para><type>text</type></para>

        <para>
          Champ de données contenant un argument nécessaire pour traiter
	  l'événement
        </para>
      </listitem>
    </varlistentry>
  </variablelist>
</para>

</section>

<section id="table.sl-listen" xreflabel="sl_listen">
<title id="table.sl-listen-title">
  Table&nbsp;: <structname>sl_listen</structname>
</title>
 
<para>
  Indique comme les n&oelig;uds écoutent aux événements à partir d'autres
  n&oelig;uds dans le réseau Slony-I.
</para>

<para>
  <variablelist>
    <title>Structure de <structname>sl_listen</structname></title>

    <varlistentry>
      <term><structfield>li_origin</structfield></term>
      <listitem>
        <para>
	  <type>integer</type>
	  <literal>PRIMARY KEY</literal>
	  <literal>REFERENCES</literal> <xref linkend="table.sl-node"/>
        </para>

        <para>
          L'identifiant (provenant de sl_node.no_id) du n&oelig;ud sur lequel
	  l'écoute se fait
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>li_provider</structfield></term>
      <listitem>
        <para>
	  <type>integer</type>
	  <literal>PRIMARY KEY</literal>
	  <literal>REFERENCES</literal> <xref linkend="table.sl-path"/>
        </para>

        <para>
          L'identifiant (provenant de sl_node.no_id) du n&oelig;ud source pour
	  cet événement d'écoute
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>li_receiver</structfield></term>
      <listitem>
        <para>
	  <type>integer</type>
          <literal>PRIMARY KEY</literal>
          <literal>REFERENCES</literal> <xref linkend="table.sl-path"/>
        </para>

        <para>
          L'identifiant (provenant de sl_node.no_id) du n&oelig;ud cible pour
	  cet événement d'écoute
        </para>
      </listitem>
    </varlistentry>
  </variablelist>
</para>

</section>

<section id="table.sl-log-1" xreflabel="sl_log_1">
<title id="table.sl-log-1-title">
  Table&nbsp;: <structname>sl_log_1</structname>
</title>
 
<para>
  Enregistre chaque modification à propager aux n&oelig;uds abonnés
</para>

<para>
  <variablelist>
    <title>Structure de <structname>sl_log_1</structname></title>

    <varlistentry>
      <term><structfield>log_origin</structfield></term>
      <listitem>
        <para><type>integer</type></para>

        <para>
          nN&oelig;ud origine d'où la modification est survenue
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>log_xid</structfield></term>
      <listitem>
        <para><type>xxid</type></para>

        <para>
          Identifiant de transaction sur le n&oelig;ud origine
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>log_tableid</structfield></term>
      <listitem>
        <para><type>integer</type></para>

        <para>
          L'identifiant table (provenant de sl_table.tab_id) que cette entrée de
	  journal affecte
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>log_actionseq</structfield></term>
      <listitem>
        <para><type>bigint</type></para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>log_cmdtype</structfield></term>
      <listitem>
        <para><type>character(1)</type></para>

        <para>
          Action de réplication à faire. U = mise à jour, I = insertion,
	  D = suppression
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>log_cmddata</structfield></term>
      <listitem>
        <para><type>text</type></para>

        <para>
          Les données nécessaires pour réaliser l'action du log
        </para>
      </listitem>
    </varlistentry>
  </variablelist>
</para>

</section>

<section id="table.sl-log-2" xreflabel="sl_log_2">
<title id="table.sl-log-2-title">
  Table&nbsp;: <structname>sl_log_2</structname>
</title>
 
<para>
  Enregistre chaque modification à propager dans les n&oelig;uds abonnés
</para>

<para>
  <variablelist>
    <title>Structure de <structname>sl_log_2</structname></title>

    <varlistentry>
      <term><structfield>log_origin</structfield></term>
      <listitem>
        <para><type>integer</type></para>

        <para>
          N&oelig;ud origine d'où provient la modification
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>log_xid</structfield></term>
      <listitem>
        <para><type>xxid</type></para>

        <para>
          Identifiant de transaction sur le n&oelig;ud origine
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>log_tableid</structfield></term>
      <listitem>
        <para><type>integer</type></para>

        <para>
          L'identifiant de table (provenant de sl_table.tab_id) que cette entrée
	  de log affecte
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>log_actionseq</structfield></term>
      <listitem>
        <para><type>bigint</type></para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>log_cmdtype</structfield></term>
      <listitem>
        <para><type>character(1)</type></para>

        <para>
          Action de réplication à réaliser. U = mise à jour, I = insertion,
	  D = suppression
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>log_cmddata</structfield></term>
      <listitem>
        <para><type>text</type></para>

        <para>
          Les données requises pour traiter l'action du log
        </para>
      </listitem>
    </varlistentry>
  </variablelist>
</para>

</section>

<section id="table.sl-node" xreflabel="sl_node">
<title id="table.sl-node-title">
  Table&nbsp;: <structname>sl_node</structname>
</title>
 
<para>
  Contient la liste des n&oelig;uds associés avec ce schéma.
</para>

<para>
  <variablelist>
    <title>Structure de <structname>sl_node</structname></title>

    <varlistentry>
      <term><structfield>no_id</structfield></term>
      <listitem>
        <para><type>integer</type> <literal>PRIMARY KEY</literal></para>

        <para>
          L'identifiant uinique du n&oelig;ud
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>no_active</structfield></term>
      <listitem>
        <para><type>boolean</type></para>

        <para>
          N&oelig;ud actif dans la réplication&nbsp;?
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>no_comment</structfield></term>
      <listitem>
        <para><type>text</type></para>

        <para>
          Une description humaine du n&oelig;ud
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>no_spool</structfield></term>
      <listitem>
        <para><type>boolean</type></para>

        <para>
          N&oelig;ud utilisé pour le log shipping&nbsp;?
        </para>
      </listitem>
    </varlistentry>
  </variablelist>

  <itemizedlist>
    <title>Tables référençant sl_listen via des contraintes de clés étrangères</title>

    <listitem>
      <para><xref linkend="table.sl-listen"/></para>
    </listitem>

    <listitem>
      <para><xref linkend="table.sl-path"/></para>
    </listitem>

    <listitem>
      <para><xref linkend="table.sl-set"/></para>
    </listitem>

    <listitem>
      <para><xref linkend="table.sl-setsync"/></para>
    </listitem>
  </itemizedlist>
</para>

</section>

<section id="table.sl-nodelock" xreflabel="sl_nodelock">
<title id="table.sl-nodelock-title">
  Table&nbsp;: <structname>sl_nodelock</structname>
</title>
 
<para>
  Utilisé pour empêcher plusieurs instances slon et pour identifier les
  processus à tuer dans terminateNodeConnections().
</para>

<para>
  <variablelist>
    <title>Structure de <structname>sl_nodelock</structname></title>

    <varlistentry>
      <term><structfield>nl_nodeid</structfield></term>
      <listitem>
        <para><type>integer</type> <literal>PRIMARY KEY</literal></para>

        <para>
          node_id clients
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>nl_conncnt</structfield></term>
      <listitem>
        <para><type>serial</type> <literal>PRIMARY KEY</literal></para>

        <para>
          Numéro de connexion des clients
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>nl_backendpid</structfield></term>
      <listitem>
        <para><type>integer</type></para>

        <para>
          PID du processus de la base de données, possédant ce verrou
        </para>
      </listitem>
    </varlistentry>
  </variablelist>
</para>

</section>

<section id="table.sl-path" xreflabel="sl_path">
<title id="table.sl-path-title">
  Table&nbsp;: <structname>sl_path</structname>
</title>
 
<para>
  Contient des informations de connexions pour les chemins entre les n&oelig;uds
  ainsi que le délai de synchronisation.
</para>

<para>
  <variablelist>
    <title>Structure de <structname>sl_path</structname></title>

    <varlistentry>
      <term><structfield>pa_server</structfield></term>
      <listitem>
        <para>
	  <type>integer</type>
	  <literal>PRIMARY KEY</literal>
	  <literal>REFERENCES</literal> <xref linkend="table.sl-node"/>
        </para>

        <para>
          L'identifiant du n&oelig;ud (provenant de sl_node.no_id) de la
	  source des données
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>pa_client</structfield></term>
      <listitem>
        <para>
	  <type>integer</type>
	  <literal>PRIMARY KEY</literal>
	  <literal>REFERENCES</literal> <xref linkend="table.sl-node"/>
        </para>

        <para>
          L'identifiant du n&oelig;ud (provenant de sl_node.no_id) de la cible
	  des données
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>pa_conninfo</structfield></term>
      <listitem>
        <para><type>text</type> <literal>NOT NULL</literal></para>

        <para>
          La chaîne de connexion PostgreSQL utilisée pour se connecter au
	  n&oelig;ud source.
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>pa_connretry</structfield></term>
      <listitem>
        <para><type>integer</type></para>

        <para>
          Le délai de synchronisation, en secondes
        </para>
      </listitem>
    </varlistentry>
  </variablelist>

  <itemizedlist>
    <title>Tables référençant sl_listen via des contraintes de clés étrangères</title>

    <listitem>
      <para><xref linkend="table.sl-listen"/></para>
    </listitem>

    <listitem>
      <para><xref linkend="table.sl-subscribe"/></para>
    </listitem>
  </itemizedlist>
</para>

</section>

<section id="table.sl-registry" xreflabel="sl_registry">
<title id="table.sl-registry-title">
  Table&nbsp;: <structname>sl_registry</structname>
</title>
 
<para>
  Enregistre différentes données d'exécution.
</para>

<para>
  <variablelist>
    <title>Structure de <structname>sl_registry</structname></title>

    <varlistentry>
      <term><structfield>reg_key</structfield></term>
      <listitem>
        <para><type>text</type> <literal>PRIMARY KEY</literal></para>

        <para>
          Clé unique de l'option d'exécution
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>reg_int4</structfield></term>
      <listitem>
        <para><type>integer</type></para>

        <para>
          Valeur de l'option si de type int4
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>reg_text</structfield></term>
      <listitem>
        <para><type>text</type></para>

        <para>
          Valeur de l'option si de type text
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>reg_timestamp</structfield></term>
      <listitem>
        <para><type>timestamp without time zone</type></para>

        <para>
          Valeur de l'option si de type timestamp
        </para>
      </listitem>
    </varlistentry>
  </variablelist>
</para>

</section>

<section id="view.sl-seqlastvalue" xreflabel="sl_seqlastvalue">
<title id="view.sl-seqlastvalue-title">
  Vue&nbsp;: <structname>sl_seqlastvalue</structname>
</title>

<para>
  <variablelist>
    <title>Structure de <structname>sl_seqlastvalue</structname></title>

    <varlistentry>
      <term><structfield>seq_id</structfield></term>
      <listitem>
        <para><type>integer</type></para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>seq_set</structfield></term>
      <listitem>
        <para><type>integer</type></para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>seq_reloid</structfield></term>
      <listitem>
        <para><type>oid</type></para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>seq_origin</structfield></term>
      <listitem>
        <para><type>integer</type></para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>seq_last_value</structfield></term>
      <listitem>
        <para><type>bigint</type></para>
      </listitem>
    </varlistentry>
  </variablelist>

  <figure>
    <title>Définition de la vue sl_seqlastvalue</title>
    <programlisting>SELECT sq.seq_id
, sq.seq_set
, sq.seq_reloid
, s.set_origin AS seq_origin
, sequencelastvalue
(
     (
           (quote_ident
                 (
                       (pgn.nspname)::text
                 ) || &apos;.&apos;::text
           ) || quote_ident
           (
                 (pgc.relname)::text
           )
     )
) AS seq_last_value 
FROM sl_sequence sq
, sl_set s
, pg_class pgc
, pg_namespace pgn 
WHERE (
     (
           (s.set_id = sq.seq_set)
         AND (pgc.oid = sq.seq_reloid)
     )
   AND (pgn.oid = pgc.relnamespace)
);</programlisting>
  </figure>
</para>

</section>

<section id="table.sl-seqlog" xreflabel="sl_seqlog">
<title id="table.sl-seqlog-title">
  Table&nbsp;: <structname>sl_seqlog</structname>
</title>
 
<para>
  Log des mises à jour de séquences.
</para>

<para>
  <variablelist>
    <title>Structure de <structname>sl_seqlog</structname></title>

    <varlistentry>
      <term><structfield>seql_seqid</structfield></term>
      <listitem>
        <para><type>integer</type></para>

        <para>
          Identifiant de la séquence
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>seql_origin</structfield></term>
      <listitem>
        <para><type>integer</type></para>

        <para>
          N&oelig;ud d'où vient la séquence
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>seql_ev_seqno</structfield></term>
      <listitem>
        <para><type>bigint</type></para>

        <para>
          Événement Slony-I avec lequel cette mise à jour de la séquence est
	  associée
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>seql_last_value</structfield></term>
      <listitem>
        <para><type>bigint</type></para>

        <para>
          Dernière valeur connue pour cette séquence
        </para>
      </listitem>
    </varlistentry>
  </variablelist>

  <variablelist>
    <title>Index sur sl_seqlog</title>

    <varlistentry>
      <term>sl_seqlog_idx</term>
      <listitem><para>seql_origin, seql_ev_seqno, seql_seqid</para></listitem>
    </varlistentry>
  </variablelist>
</para>

</section>

<section id="table.sl-sequence" xreflabel="sl_sequence">
<title id="table.sl-sequence-title">
  Table&nbsp;: <structname>sl_sequence</structname>
</title>
 
<para>
  Similaire à sl_table. Chaque entrée identifie une séquence à répliquer.
</para>

<para>
  <variablelist>
    <title>Structure de <structname>sl_sequence</structname></title>

    <varlistentry>
      <term><structfield>seq_id</structfield></term>
      <listitem>
        <para><type>integer</type> <literal>PRIMARY KEY</literal></para>

        <para>
          Identifiant interne utilisé par Slony pour sa séquence de mise à jour
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>seq_reloid</structfield></term>
      <listitem>
        <para><type>oid</type> <literal>UNIQUE</literal> <literal>NOT NULL</literal></para>

        <para>
          OID de la séquence
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>seq_relname</structfield></term>
      <listitem>
        <para><type>name</type> <literal>NOT NULL</literal></para>

        <para>
          Nom de la séquence dans pg_catalog.pg_class.relname, utilisé pour être
	  récupéré sur un cycle sauvegarde/restauration
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>seq_nspname</structfield></term>
      <listitem>
        <para><type>name</type> <literal>NOT NULL</literal></para>

        <para>
          Nom du schéma dans pg_catalog.pg_namespace.nspname, utilisé pour être
	  récupéré sur un cycle sauvegarde/restauration
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>seq_set</structfield></term>
      <listitem>
        <para><type>integer</type> <literal>REFERENCES</literal> <xref linkend="table.sl-set"/></para>

        <para>
          Indique dans quel ensemble de réplication se trouve l'objet
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>seq_comment</structfield></term>
      <listitem>
        <para><type>text</type></para>

        <para>
          Un commentaire humain
        </para>
      </listitem>
    </varlistentry>
  </variablelist>
</para>

</section>

<section id="table.sl-set" xreflabel="sl_set">
<title id="table.sl-set-title">
  Table&nbsp;: <structname>sl_set</structname>
</title>
 
<para>
  Contient la définition des ensembles de réplication.
</para>

<para>
  <variablelist>
    <title>Structure de <structname>sl_set</structname></title>

    <varlistentry>
      <term><structfield>set_id</structfield></term>
      <listitem>
        <para><type>integer</type> <literal>PRIMARY KEY</literal></para>

        <para>
          Un identifiant unique pour l'ensemble.
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>set_origin</structfield></term>
      <listitem>
        <para><type>integer</type> <literal>REFERENCES</literal> <xref linkend="table.sl-node"/></para>

        <para>
          Un identifiant du n&oelig;ud source pour l'ensemble de réplication.
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>set_locked</structfield></term>
      <listitem>
        <para><type>xxid</type></para>

        <para>
          Indique si l'ensemble est verrouillé.
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>set_comment</structfield></term>
      <listitem>
        <para><type>text</type></para>

        <para>
          Une description humaine de l'ensemble.
        </para>
      </listitem>
    </varlistentry>
  </variablelist>

  <itemizedlist>
    <title>Tables référençant sl_sequence via des contraintes de clés étrangères</title>

    <listitem>
      <para><xref linkend="table.sl-sequence"/></para>
    </listitem>

    <listitem>
      <para><xref linkend="table.sl-setsync"/></para>
    </listitem>

    <listitem>
      <para><xref linkend="table.sl-subscribe"/></para>
    </listitem>

    <listitem>
      <para><xref linkend="table.sl-table"/></para>
    </listitem>
  </itemizedlist>
</para>

</section>

<section id="table.sl-setsync" xreflabel="sl_setsync">
<title id="table.sl-setsync-title">
  Table&nbsp;: <structname>sl_setsync</structname>
</title>
 
<para>
  Informations de SYNC
</para>

<para>
  <variablelist>
    <title>Structure de <structname>sl_setsync</structname></title>

    <varlistentry>
      <term><structfield>ssy_setid</structfield></term>
      <listitem>
        <para>
	  <type>integer</type>
	  <literal>PRIMARY KEY</literal>
	  <literal>REFERENCES</literal> <xref linkend="table.sl-set"/>
        </para>

        <para>
          Identifiant de l'ensemble de réplication
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>ssy_origin</structfield></term>
      <listitem>
        <para><type>integer</type> <literal>REFERENCES</literal> <xref linkend="table.sl-node"/></para>

        <para>
          Identifiant du n&oelig;ud
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>ssy_seqno</structfield></term>
      <listitem>
        <para><type>bigint</type></para>

        <para>
          Numéro de séquence Slony-I
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>ssy_minxid</structfield></term>
      <listitem>
        <para><type>xxid</type></para>

        <para>
          Identifiant de transaction le plus ancient dans le système affecté
	  par SYNC
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>ssy_maxxid</structfield></term>
      <listitem>
        <para><type>xxid</type></para>

        <para>
          Dernier identifiant de transaction dans le système fournisseur affecté
	  par SYNC
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>ssy_xip</structfield></term>
      <listitem>
        <para><type>text</type></para>

        <para>
          Contient la liste des identifiants de transactions en progression
	  au moment du SYNC
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>ssy_action_list</structfield></term>
      <listitem>
        <para><type>text</type></para>

        <para>
          Liste d'action utilisée lors du traitement de l'abonnement. Au moment
	  où un abonné copie des données à partir de l'origine, il voit toutes
	  les tables dans un état entre deux événements SYNC. Du coup, cette
	  liste doit contenir tous les identifiants de transactions visibles
	  à ce moment, donc les opérations ont déjà été incluses dans les
	  données copiées au moment où la copie initiale des données est faite.
	  Du coup, ces actions peuvent être filtrées du premier SYNC réalisé
	  après l'abonnement.
        </para>
      </listitem>
    </varlistentry>
  </variablelist>
</para>

</section>

<section id="table.sl-subscribe" xreflabel="sl_subscribe">
<title id="table.sl-subscribe-title">
  Table&nbsp;: <structname>sl_subscribe</structname>
</title>
 

<para>
  Contient une liste des abonnements sur les ensembles.
</para>

<para>
  <variablelist>
    <title>Structure de <structname>sl_subscribe</structname></title>

    <varlistentry>
      <term><structfield>sub_set</structfield></term>
      <listitem>
        <para>
	  <type>integer</type>
	  <literal>PRIMARY KEY</literal>
	  <literal>REFERENCES</literal> <xref linkend="table.sl-set"/>
        </para>

        <para>
          Identifiant (provenant de sl_set) de l'ensemble
        </para>

      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>sub_provider</structfield></term>
      <listitem>
        <para><type>integer</type> <literal>REFERENCES</literal> <xref linkend="table.sl-path"/></para>

        <para>
          Identifiant (provenant de sl_node) du n&oelig;ud fournissant les données
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>sub_receiver</structfield></term>
      <listitem>
        <para>
	  <type>integer</type>
	  <literal>PRIMARY KEY</literal>
	  <literal>REFERENCES</literal> <xref linkend="table.sl-path"/>
        </para>

        <para>
          Identifiant (provenant de sl_node) du n&oelig;ud recevant les données
	  à partir du fournisseur
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>sub_forward</structfield></term>
      <listitem>
        <para><type>boolean</type></para>

        <para>
          Le fournisseur doit-il conserver les données dans sl_log_1/sl_log_2
	  pour lui permettre de devenir un fournisseur vers d'autres
	  n&oelig;uds&nbsp;?
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>sub_active</structfield></term>
      <listitem>
        <para><type>boolean</type></para>

        <para>
          L'abonnement a-t-il été activé&nbsp;? ceci n'est pas configuré sur
	  l'abonné jusqu'à APRÈS la réception des données de COPY du fournisseur
	  à l'abonné.
        </para>
      </listitem>
    </varlistentry>
  </variablelist>
</para>

</section>

<section id="table.sl-table" xreflabel="sl_table">
<title id="table.sl-table-title">
  Table&nbsp;: <structname>sl_table</structname>
</title>
 
<para>
  Contient des informations sur les tables à répliquer.
</para>

<para>
  <variablelist>
    <title>Structure de <structname>sl_table</structname></title>

    <varlistentry>
      <term><structfield>tab_id</structfield></term>
      <listitem>
        <para><type>integer</type> <literal>PRIMARY KEY</literal></para>

        <para>
          Clé unique que Slony-I utilise pour identifier la table
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>tab_reloid</structfield></term>
      <listitem>
        <para><type>oid</type> <literal>UNIQUE</literal> <literal>NOT NULL</literal></para>

        <para>
          OID de la table (pg_catalog.pg_class.oid)
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>tab_relname</structfield></term>
      <listitem>
        <para><type>name</type> <literal>NOT NULL</literal></para>

        <para>
          Nom de la table dans pg_catalog.pg_class.relname, utilisé pour être
	  récupéré sur un cycle sauvegarde/restauration
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>tab_nspname</structfield></term>
      <listitem>
        <para><type>name</type><literal>NOT NULL</literal></para>

        <para>
          Nom du schéma dans pg_catalog.pg_namespace.nspname, utilisé pour être
	  récupéré sur un cycle sauvegarde/restauration
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>tab_set</structfield></term>
      <listitem>
        <para><type>integer</type> <literal>REFERENCES</literal> <xref linkend="table.sl-set"/></para>

        <para>
          Identifiant de l'ensemble de réplication
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>tab_idxname</structfield></term>
      <listitem>
        <para><type>name</type> <literal>NOT NULL</literal></para>

        <para>
          Nom de l'index primaire de la table
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>tab_altered</structfield></term>
      <listitem>
        <para><type>boolean</type> <literal>NOT NULL</literal></para>

        <para>
          La table a-t-elle été modifiée pour la réplication&nbsp;?
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>tab_comment</structfield></term>
      <listitem>
        <para><type>text</type></para>

        <para>
          Description humaine de la table
        </para>
      </listitem>
    </varlistentry>
  </variablelist>

  <itemizedlist>
    <title>Tables référençant sl_trigger via des contraintes de clés étrangères</title>

    <listitem>
      <para><xref linkend="table.sl-trigger"/></para>
    </listitem>
  </itemizedlist>
</para>

</section>

<section id="table.sl-trigger" xreflabel="sl_trigger">
<title id="table.sl-trigger-title">
  Table&nbsp;: <structname>sl_trigger</structname>
</title>
 
<para>
  Contient des informations sur les triggers des tables gérées par Slony-I.
</para>

<para>
  <variablelist>
    <title>Structure de <structname>sl_trigger</structname></title>

    <varlistentry>
      <term><structfield>trig_tabid</structfield></term>
      <listitem>
        <para>
	  <type>integer</type><literal>PRIMARY KEY</literal>
	  <literal>REFERENCES</literal> <xref linkend="table.sl-table"/>
        </para>

        <para>
          Identifiant Slony-I de la table où le trigger est activé
        </para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term><structfield>trig_tgname</structfield></term>
      <listitem>
        <para><type>name</type> <literal>PRIMARY KEY</literal></para>

        <para>
          Indique le nom d'un trigger
        </para>
      </listitem>
    </varlistentry>
  </variablelist>
</para>

</section>

<!-- Function add_empty_table_to_replication( integer, integer, text, text, text, text ) -->
<section id="function.add-empty-table-to-replication-integer-integer-text-text-text-text"
  xreflabel="schemadocadd_empty_table_to_replication( integer, integer, text, text, text, text )">
<title id="function.add-empty-table-to-replication-integer-integer-text-text-text-text-title">
  add_empty_table_to_replication( integer, integer, text, text, text, text )
</title>
<titleabbrev id="function.add-empty-table-to-replication-integer-integer-text-text-text-text-titleabbrev">
  add_empty_table_to_replication( integer, integer, text, text, text, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code de retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
 
  Vérifie qu'une table est vide et l'ajoute à la réplication.
  tab_idxname est optionnel. Si cette colonne est NULL, alors la clé primaire
  est utilisée.
  
  <programlisting>declare
  p_set_id alias for $1;
  p_tab_id alias for $2;
  p_nspname alias for $3;
  p_tabname alias for $4;
  p_idxname alias for $5;
  p_comment alias for $6;

  prec record;
  v_origin int4;
  v_isorigin boolean;
  v_fqname text;
  v_query text;
  v_rows integer;
  v_idxname text;

begin
-- Need to validate that the set exists; the set will tell us if this is the origin
  select set_origin into v_origin from sl_set where set_id = p_set_id;
  if not found then
	raise exception &#39;add_empty_table_to_replication: set % not found!&#39;, p_set_id;
  end if;

-- Need to be aware of whether or not this node is origin for the set
   v_isorigin := ( v_origin = getLocalNodeId(&#39;_schemadoc&#39;) );

   v_fqname := &#39;&quot;&#39; || p_nspname || &#39;&quot;.&quot;&#39; || p_tabname || &#39;&quot;&#39;;
-- Take out a lock on the table
   v_query := &#39;lock &#39; || v_fqname || &#39;;&#39;;
   execute v_query;

   if v_isorigin then
	-- On the origin, verify that the table is empty, failing if it has any tuples
        v_query := &#39;select 1 as tuple from &#39; || v_fqname || &#39; limit 1;&#39;;
	execute v_query into prec;
        GET DIAGNOSTICS v_rows = ROW_COUNT;
	if v_rows = 0 then
		raise notice &#39;add_empty_table_to_replication: table % empty on origin - OK&#39;, v_fqname;
	else
		raise exception &#39;add_empty_table_to_replication: table % contained tuples on origin node %&#39;, v_fqname, v_origin;
	end if;
   else
	-- On other nodes, TRUNCATE the table
        v_query := &#39;truncate &#39; || v_fqname || &#39;;&#39;;
	execute v_query;
   end if;
-- If p_idxname is NULL, then look up the PK index, and RAISE EXCEPTION if one does not exist
   if p_idxname is NULL then
	select c2.relname into prec from pg_catalog.pg_index i, pg_catalog.pg_class c1, pg_catalog.pg_class c2, pg_catalog.pg_namespace n where i.indrelid = c1.oid and i.indexrelid = c2.oid and c1.relname = p_tabname and i.indisprimary and n.nspname = p_nspname and n.oid = c1.relnamespace;
	if not found then
		raise exception &#39;add_empty_table_to_replication: table % has no primary key and no candidate specified!&#39;, v_fqname;
	else
		v_idxname := prec.relname;
	end if;
   else
	v_idxname := p_idxname;
   end if;
   perform setAddTable_int(p_set_id, p_tab_id, v_fqname, v_idxname, p_comment);
   return alterTableRestore(p_tab_id);
end
</programlisting>
</para>

</section>

<!-- Function add_empty_table_to_replication( integer, integer, text, text, text, text ) -->
<section id="function.add-empty-table-to-replication-integer-integer-text-text-text-text"
  xreflabel="schemadocadd_empty_table_to_replication( integer, integer, text, text, text, text )">
<title id="function.add-empty-table-to-replication-integer-integer-text-text-text-text-title">
  add_empty_table_to_replication( integer, integer, text, text, text, text )
</title>
<titleabbrev id="function.add-empty-table-to-replication-integer-integer-text-text-text-text-titleabbrev">
  add_empty_table_to_replication( integer, integer, text, text, text, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
 
  Vérifie qu'une table est vide et l'ajoute à la réplication. tab_idxname est
  optionnel. S'il vaut NULL, alors la clé primaire est utilisée.

  <programlisting>declare
  p_set_id alias for $1;
  p_tab_id alias for $2;
  p_nspname alias for $3;
  p_tabname alias for $4;
  p_idxname alias for $5;
  p_comment alias for $6;

  prec record;
  v_origin int4;
  v_isorigin boolean;
  v_fqname text;
  v_query text;
  v_rows integer;
  v_idxname text;

begin
-- Need to validate that the set exists; the set will tell us if this is the origin
  select set_origin into v_origin from sl_set where set_id = p_set_id;
  if not found then
	raise exception &#39;add_empty_table_to_replication: set % not found!&#39;, p_set_id;
  end if;

-- Need to be aware of whether or not this node is origin for the set
   v_isorigin := ( v_origin = getLocalNodeId(&#39;_schemadoc&#39;) );

   v_fqname := &#39;&quot;&#39; || p_nspname || &#39;&quot;.&quot;&#39; || p_tabname || &#39;&quot;&#39;;
-- Take out a lock on the table
   v_query := &#39;lock &#39; || v_fqname || &#39;;&#39;;
   execute v_query;

   if v_isorigin then
	-- On the origin, verify that the table is empty, failing if it has any tuples
        v_query := &#39;select 1 as tuple from &#39; || v_fqname || &#39; limit 1;&#39;;
	execute v_query into prec;
        GET DIAGNOSTICS v_rows = ROW_COUNT;
	if v_rows = 0 then
		raise notice &#39;add_empty_table_to_replication: table % empty on origin - OK&#39;, v_fqname;
	else
		raise exception &#39;add_empty_table_to_replication: table % contained tuples on origin node %&#39;, v_fqname, v_origin;
	end if;
   else
	-- On other nodes, TRUNCATE the table
        v_query := &#39;truncate &#39; || v_fqname || &#39;;&#39;;
	execute v_query;
   end if;
-- If p_idxname is NULL, then look up the PK index, and RAISE EXCEPTION if one does not exist
   if p_idxname is NULL then
	select c2.relname into prec from pg_catalog.pg_index i, pg_catalog.pg_class c1, pg_catalog.pg_class c2, pg_catalog.pg_namespace n where i.indrelid = c1.oid and i.indexrelid = c2.oid and c1.relname = p_tabname and i.indisprimary and n.nspname = p_nspname and n.oid = c1.relnamespace;
	if not found then
		raise exception &#39;add_empty_table_to_replication: table % has no primary key and no candidate specified!&#39;, v_fqname;
	else
		v_idxname := prec.relname;
	end if;
   else
	v_idxname := p_idxname;
   end if;
   perform setAddTable_int(p_set_id, p_tab_id, v_fqname, v_idxname, p_comment);
   return alterTableRestore(p_tab_id);
end</programlisting>
</para>

</section>

<!-- Function add_missing_table_field( text, text, text, text ) -->
<section id="function.add-missing-table-field-text-text-text-text"
  xreflabel="schemadocadd_missing_table_field( text, text, text, text )">
<title id="function.add-missing-table-field-text-text-text-text-title">
  add_missing_table_field( text, text, text, text )
</title>
<titleabbrev id="function.add-missing-table-field-text-text-text-text-titleabbrev">
  add_missing_table_field( text, text, text, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>boolean</seg>
    </seglistitem>
  </segmentedlist>
 
  Ajoute une colonne du type indiqué dans une table si cette colonne est
  manquante

  <programlisting>DECLARE
  p_namespace alias for $1;
  p_table     alias for $2;
  p_field     alias for $3;
  p_type      alias for $4;
  v_row       record;
  v_query     text;
BEGIN
  select 1 into v_row from pg_namespace n, pg_class c, pg_attribute a
     where slon_quote_brute(n.nspname) = p_namespace and 
         c.relnamespace = n.oid and
         slon_quote_brute(c.relname) = p_table and
         a.attrelid = c.oid and
         slon_quote_brute(a.attname) = p_field;
  if not found then
    raise notice &#39;Upgrade table %.% - add field %&#39;, p_namespace, p_table, p_field;
    v_query := &#39;alter table &#39; || p_namespace || &#39;.&#39; || p_table || &#39; add column &#39;;
    v_query := v_query || p_field || &#39; &#39; || p_type || &#39;;&#39;;
    execute v_query;
    return &#39;t&#39;;
  else
    return &#39;f&#39;;
  end if;
END;</programlisting>
</para>

</section>

<!-- Function addpartiallogindices(  ) -->
<section id="function.addpartiallogindices" xreflabel="schemadocaddpartiallogindices(  )">
<title id="function.addpartiallogindices-title">
  addpartiallogindices(  )
</title>
<titleabbrev id="function.addpartiallogindices-titleabbrev">
  addpartiallogindices(  )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Ajoute des index partiels, si possible, dans les tables sl_log_? inutilisées
  pour tous les n&oelig;uds origines, et supprime tous ceux qui ne sont plus
  nécessaires.

  Cette fonction est exécuté à chaque fois que les origines d'ensemble sont
  utilisées (FAILOVER, STORE SET, MOVE SET, DROP SET), ainsi qu'à chaque fois
  que le système bascule entre sl_log_1 et sl_log_2.
  
  <programlisting>DECLARE
	v_current_status	int4;
	v_log			int4;
	v_dummy		record;
	v_dummy2	record;
	idef 		text;
	v_count		int4;
        v_iname         text;
BEGIN
	v_count := 0;
	select last_value into v_current_status from sl_log_status;

	-- If status is 2 or 3 --&gt; in process of cleanup --&gt; unsafe to create indices
	if v_current_status in (2, 3) then
		return 0;
	end if;

	if v_current_status = 0 then   -- Which log should get indices?
		v_log := 2;
	else
		v_log := 1;
	end if;
--                                       PartInd_test_db_sl_log_2-node-1
	-- Add missing indices...
	for v_dummy in select distinct set_origin from sl_set loop
            v_iname := &#39;PartInd_schemadoc_sl_log_&#39; || v_log || &#39;-node-&#39; || v_dummy.set_origin;
	    -- raise notice &#39;Consider adding partial index % on sl_log_%&#39;, v_iname, v_log;
	    -- raise notice &#39;schema: [_schemadoc] tablename:[sl_log_%]&#39;, v_log;
            select * into v_dummy2 from pg_catalog.pg_indexes where tablename = &#39;sl_log_&#39; || v_log and  indexname = v_iname;
            if not found then
		-- raise notice &#39;index was not found - add it!&#39;;
		idef := &#39;create index &quot;PartInd_schemadoc_sl_log_&#39; || v_log || &#39;-node-&#39; || v_dummy.set_origin ||
                        &#39;&quot; on sl_log_&#39; || v_log || &#39; USING btree(log_xid xxid_ops) where (log_origin = &#39; || v_dummy.set_origin || &#39;);&#39;;
		execute idef;
		v_count := v_count + 1;
            else
                -- raise notice &#39;Index % already present - skipping&#39;, v_iname;
            end if;
	end loop;

	-- Remove unneeded indices...
	for v_dummy in select indexname from pg_catalog.pg_indexes i where i.tablename = &#39;sl_log_&#39; || v_log and
                       i.indexname like (&#39;PartInd_schemadoc_sl_log_&#39; || v_log || &#39;-node-%&#39;) and
                       not exists (select 1 from sl_set where
				i.indexname = &#39;PartInd_schemadoc_sl_log_&#39; || v_log || &#39;-node-&#39; || set_origin)
	loop
		-- raise notice &#39;Dropping obsolete index %d&#39;, v_dummy.indexname;
		idef := &#39;drop index &quot;&#39; || v_dummy.indexname || &#39;&quot;;&#39;;
		execute idef;
		v_count := v_count - 1;
	end loop;
	return v_count;
END</programlisting>
</para>

</section>

<!-- Function altertableforreplication( integer ) -->
<section id="function.altertableforreplication-integer"
  xreflabel="schemadocaltertableforreplication( integer )">
<title id="function.altertableforreplication-integer-title">
  altertableforreplication( integer )
</title>
<titleabbrev id="function.altertableforreplication-integer-titleabbrev">
  altertableforreplication( integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Configure une table pour la réplication. Sur l'origine, ceci implique
  d'ajouter le trigger &quot;logTrigger()&quot; sur la table.

  Sur un n&oelig;ud abonné, ceci implique de désactiver les triggers et les
  règles, et d'ajouter le trigger qui interdit l'accès aux tables
  répliquées.
  
  <programlisting>declare
	p_tab_id			alias for $1;
	v_no_id				int4;
	v_tab_row			record;
	v_tab_fqname		text;
	v_tab_attkind		text;
	v_n					int4;
	v_trec	record;
	v_tgbad	boolean;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Get our local node ID
	-- ----
	v_no_id := getLocalNodeId(&#39;_schemadoc&#39;);

	-- ----
	-- Get the sl_table row and the current origin of the table. 
	-- Verify that the table currently is NOT in altered state.
	-- ----
	select T.tab_reloid, T.tab_set, T.tab_idxname, T.tab_altered,
			S.set_origin, PGX.indexrelid,
			slon_quote_brute(PGN.nspname) || &#39;.&#39; ||
			slon_quote_brute(PGC.relname) as tab_fqname
			into v_tab_row
			from sl_table T, sl_set S,
				&quot;pg_catalog&quot;.pg_class PGC, &quot;pg_catalog&quot;.pg_namespace PGN,
				&quot;pg_catalog&quot;.pg_index PGX, &quot;pg_catalog&quot;.pg_class PGXC
			where T.tab_id = p_tab_id
				and T.tab_set = S.set_id
				and T.tab_reloid = PGC.oid
				and PGC.relnamespace = PGN.oid
				and PGX.indrelid = T.tab_reloid
				and PGX.indexrelid = PGXC.oid
				and PGXC.relname = T.tab_idxname
				for update;
	if not found then
		raise exception &#39;Slony-I: alterTableForReplication(): Table with id % not found&#39;, p_tab_id;
	end if;
	v_tab_fqname = v_tab_row.tab_fqname;
	if v_tab_row.tab_altered then
		raise exception &#39;Slony-I: alterTableForReplication(): Table % is already in altered state&#39;,
				v_tab_fqname;
	end if;

	v_tab_attkind := determineAttKindUnique(v_tab_row.tab_fqname, 
						v_tab_row.tab_idxname);

	execute &#39;lock table &#39; || v_tab_fqname || &#39; in access exclusive mode&#39;;

	-- ----
	-- Procedures are different on origin and subscriber
	-- ----
	if v_no_id = v_tab_row.set_origin then
		-- ----
		-- On the Origin we add the log trigger to the table and done
		-- ----
		execute &#39;create trigger &quot;_schemadoc_logtrigger_&#39; || 
				p_tab_id || &#39;&quot; after insert or update or delete on &#39; ||
				v_tab_fqname || &#39; for each row execute procedure
				logTrigger (&#39;&#39;_schemadoc&#39;&#39;, &#39;&#39;&#39; || 
					p_tab_id || &#39;&#39;&#39;, &#39;&#39;&#39; || 
					v_tab_attkind || &#39;&#39;&#39;);&#39;;
	else
		-- ----
		-- On the subscriber the thing is a bit more difficult. We want
		-- to disable all user- and foreign key triggers and rules.
		-- ----


		-- ----
		-- Check to see if there are any trigger conflicts...
		-- ----
		v_tgbad := &#39;false&#39;;
		for v_trec in 
			select pc.relname, tg1.tgname from
			&quot;pg_catalog&quot;.pg_trigger tg1, 
			&quot;pg_catalog&quot;.pg_trigger tg2,
			&quot;pg_catalog&quot;.pg_class pc,
			&quot;pg_catalog&quot;.pg_index pi,
			sl_table tab
			where 
			 tg1.tgname = tg2.tgname and        -- Trigger names match
			 tg1.tgrelid = tab.tab_reloid and   -- trigger 1 is on the table
			 pi.indexrelid = tg2.tgrelid and    -- trigger 2 is on the index
			 pi.indrelid = tab.tab_reloid and   -- indexes table is this table
			 pc.oid = tab.tab_reloid
                loop
			raise notice &#39;Slony-I: alterTableForReplication(): multiple instances of trigger % on table %&#39;,
				v_trec.tgname, v_trec.relname;
			v_tgbad := &#39;true&#39;;
		end loop;
		if v_tgbad then
			raise exception &#39;Slony-I: Unable to disable triggers&#39;;
		end if;  		

		-- ----
		-- Disable all existing triggers
		-- ----
		update &quot;pg_catalog&quot;.pg_trigger
				set tgrelid = v_tab_row.indexrelid
				where tgrelid = v_tab_row.tab_reloid
				and not exists (
						select true from sl_table TAB,
								sl_trigger TRIG
								where TAB.tab_reloid = tgrelid
								and TAB.tab_id = TRIG.trig_tabid
								and TRIG.trig_tgname = tgname
					);
		get diagnostics v_n = row_count;
		if v_n &gt; 0 then
			update &quot;pg_catalog&quot;.pg_class
					set reltriggers = reltriggers - v_n
					where oid = v_tab_row.tab_reloid;
		end if;

		-- ----
		-- Disable all existing rules
		-- ----
		update &quot;pg_catalog&quot;.pg_rewrite
				set ev_class = v_tab_row.indexrelid
				where ev_class = v_tab_row.tab_reloid;
		get diagnostics v_n = row_count;
		if v_n &gt; 0 then
			update &quot;pg_catalog&quot;.pg_class
					set relhasrules = false
					where oid = v_tab_row.tab_reloid;
		end if;

		-- ----
		-- Add the trigger that denies write access to replicated tables
		-- ----
		execute &#39;create trigger &quot;_schemadoc_denyaccess_&#39; || 
				p_tab_id || &#39;&quot; before insert or update or delete on &#39; ||
				v_tab_fqname || &#39; for each row execute procedure
				denyAccess (&#39;&#39;_schemadoc&#39;&#39;);&#39;;
	end if;

	-- ----
	-- Mark the table altered in our configuration
	-- ----
	update sl_table
			set tab_altered = true where tab_id = p_tab_id;

	return p_tab_id;
end;</programlisting>
</para>

</section>

<!-- Function altertablerestore( integer ) -->
<section id="function.altertablerestore-integer"
  xreflabel="schemadocaltertablerestore( integer )">
<title id="function.altertablerestore-integer-title">
  altertablerestore( integer )
</title>
<titleabbrev id="function.altertablerestore-integer-titleabbrev">
  altertablerestore( integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Restaure la table d'identifiant table tab_id. Autrement dit, l'enlève de la
  réplication.

  Sur l'origine, ceci implique la suppression du trigger &quot;logtrigger&quot;.

  Sur les n&oelig;uds abonnés, ceci implique la suppression du trigger
  &quot;denyaccess&quot;, et restaure les triggers et règles utilisateurs.
  
  <programlisting>declare
	p_tab_id			alias for $1;
	v_no_id				int4;
	v_tab_row			record;
	v_tab_fqname		text;
	v_n					int4;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Get our local node ID
	-- ----
	v_no_id := getLocalNodeId(&#39;_schemadoc&#39;);

	-- ----
	-- Get the sl_table row and the current tables origin. Check
	-- that the table currently IS in altered state.
	-- ----
	select T.tab_reloid, T.tab_set, T.tab_altered,
			S.set_origin, PGX.indexrelid,
			slon_quote_brute(PGN.nspname) || &#39;.&#39; ||
			slon_quote_brute(PGC.relname) as tab_fqname
			into v_tab_row
			from sl_table T, sl_set S,
				&quot;pg_catalog&quot;.pg_class PGC, &quot;pg_catalog&quot;.pg_namespace PGN,
				&quot;pg_catalog&quot;.pg_index PGX, &quot;pg_catalog&quot;.pg_class PGXC
			where T.tab_id = p_tab_id
				and T.tab_set = S.set_id
				and T.tab_reloid = PGC.oid
				and PGC.relnamespace = PGN.oid
				and PGX.indrelid = T.tab_reloid
				and PGX.indexrelid = PGXC.oid
				and PGXC.relname = T.tab_idxname
				for update;
	if not found then
		raise exception &#39;Slony-I: alterTableRestore(): Table with id % not found&#39;, p_tab_id;
	end if;
	v_tab_fqname = v_tab_row.tab_fqname;
	if not v_tab_row.tab_altered then
		raise exception &#39;Slony-I: alterTableRestore(): Table % is not in altered state&#39;,
				v_tab_fqname;
	end if;

	execute &#39;lock table &#39; || v_tab_fqname || &#39; in access exclusive mode&#39;;

	-- ----
	-- Procedures are different on origin and subscriber
	-- ----
	if v_no_id = v_tab_row.set_origin then
		-- ----
		-- On the Origin we just drop the trigger we originally added
		-- ----
		execute &#39;drop trigger &quot;_schemadoc_logtrigger_&#39; || 
				p_tab_id || &#39;&quot; on &#39; || v_tab_fqname;
	else
		-- ----
		-- On the subscriber drop the denyAccess trigger
		-- ----
		execute &#39;drop trigger &quot;_schemadoc_denyaccess_&#39; || 
				p_tab_id || &#39;&quot; on &#39; || v_tab_fqname;
				
		-- ----
		-- Restore all original triggers
		-- ----
		update &quot;pg_catalog&quot;.pg_trigger
				set tgrelid = v_tab_row.tab_reloid
				where tgrelid = v_tab_row.indexrelid;
		get diagnostics v_n = row_count;
		if v_n &gt; 0 then
			update &quot;pg_catalog&quot;.pg_class
					set reltriggers = reltriggers + v_n
					where oid = v_tab_row.tab_reloid;
		end if;

		-- ----
		-- Restore all original rewrite rules
		-- ----
		update &quot;pg_catalog&quot;.pg_rewrite
				set ev_class = v_tab_row.tab_reloid
				where ev_class = v_tab_row.indexrelid;
		get diagnostics v_n = row_count;
		if v_n &gt; 0 then
			update &quot;pg_catalog&quot;.pg_class
					set relhasrules = true
					where oid = v_tab_row.tab_reloid;
		end if;

	end if;

	-- ----
	-- Mark the table not altered in our configuration
	-- ----
	update sl_table
			set tab_altered = false where tab_id = p_tab_id;

	return p_tab_id;
end;</programlisting>
</para>

</section>

<!-- Function checkmoduleversion(  ) -->
<section id="function.checkmoduleversion"
  xreflabel="schemadoccheckmoduleversion(  )">
<title id="function.checkmoduleversion-title">
  checkmoduleversion(  )
</title>
<titleabbrev id="function.checkmoduleversion-titleabbrev">
  checkmoduleversion(  )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>text</seg>
    </seglistitem>
  </segmentedlist>
 
  Fonction de test en ligne qui vérifie que la requête slonik pour STORE
  NODE/INIT CLUSTER est bien en cours d'exécution avec un ensemble de
  schémas/fonctions.

  <programlisting>declare
  moduleversion	text;
begin
  select into moduleversion getModuleVersion();
  if moduleversion &lt;&gt; &#39;@MODULEVERSION@&#39; then
      raise exception &#39;Slonik version: @MODULEVERSION@ != Slony-I version in PG build %&#39;,
             moduleversion;
  end if;
  return null;
end;</programlisting>
</para>

</section>

<!-- Function cleanupevent(  ) -->
<section id="function.cleanupevent"
  xreflabel="schemadoccleanupevent(  )">
<title id="function.cleanupevent-title">
  cleanupevent(  )
</title>
<titleabbrev id="function.cleanupevent-titleabbrev">
  cleanupevent(  )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Nettoie les anciennes données de sl_confirm, sl_event. Supprime tout sauf la
  dernière ligne par (origine, abonné), puis supprime tous les événements qui
  sont confirmés par tous les n&oelig;uds du clusyer jusqu'au dernier SYNC.
  
  <programlisting>declare
	v_max_row	record;
	v_min_row	record;
	v_max_sync	int8;
begin
	-- ----
	-- First remove all but the oldest confirm row per origin,receiver pair
	-- ----
	delete from sl_confirm
				where con_origin not in (select no_id from sl_node);
	delete from sl_confirm
				where con_received not in (select no_id from sl_node);
	-- ----
	-- Next remove all but the oldest confirm row per origin,receiver pair.
	-- Ignore confirmations that are younger than 10 minutes. We currently
	-- have an not confirmed suspicion that a possibly lost transaction due
	-- to a server crash might have been visible to another session, and
	-- that this led to log data that is needed again got removed.
	-- ----
	for v_max_row in select con_origin, con_received, max(con_seqno) as con_seqno
				from sl_confirm
				where con_timestamp &lt; (CURRENT_TIMESTAMP - &#39;10 min&#39;::interval)
				group by con_origin, con_received
	loop
		delete from sl_confirm
				where con_origin = v_max_row.con_origin
				and con_received = v_max_row.con_received
				and con_seqno &lt; v_max_row.con_seqno;
	end loop;

	-- ----
	-- Then remove all events that are confirmed by all nodes in the
	-- whole cluster up to the last SYNC
	-- ----
	for v_min_row in select con_origin, min(con_seqno) as con_seqno
				from sl_confirm
				group by con_origin
	loop
		select coalesce(max(ev_seqno), 0) into v_max_sync
				from sl_event
				where ev_origin = v_min_row.con_origin
				and ev_seqno &lt;= v_min_row.con_seqno
				and ev_type = &#39;SYNC&#39;;
		if v_max_sync &gt; 0 then
			delete from sl_event
					where ev_origin = v_min_row.con_origin
					and ev_seqno &lt; v_max_sync;
		end if;
	end loop;

	-- ----
	-- If cluster has only one node, then remove all events up to
	-- the last SYNC - Bug #1538
        -- http://gborg.postgresql.org/project/slony1/bugs/bugupdate.php?1538
	-- ----

	select * into v_min_row from sl_node where
			no_id &lt;&gt; getLocalNodeId(&#39;_schemadoc&#39;) limit 1;
	if not found then
		select ev_origin, ev_seqno into v_min_row from sl_event
		where ev_origin = getLocalNodeId(&#39;_schemadoc&#39;)
		order by ev_origin desc, ev_seqno desc limit 1;
		raise notice &#39;Slony-I: cleanupEvent(): Single node - deleting events &lt; %&#39;, v_min_row.ev_seqno;
			delete from sl_event
			where
				ev_origin = v_min_row.ev_origin and
				ev_seqno &lt; v_min_row.ev_seqno;

        end if;

	if exists (select * from &quot;pg_catalog&quot;.pg_class c, &quot;pg_catalog&quot;.pg_namespace n, &quot;pg_catalog&quot;.pg_attribute a where c.relname = &#39;sl_seqlog&#39; and n.oid = c.relnamespace and a.attrelid = c.oid and a.attname = &#39;oid&#39;) then
                execute &#39;alter table sl_seqlog set without oids;&#39;;
	end if;		
	-- ----
	-- Also remove stale entries from the nodelock table.
	-- ----
	perform cleanupNodelock();

	return 0;
end;</programlisting>
</para>

</section>

<!-- Function cleanupnodelock(  ) -->
<section id="function.cleanupnodelock"
  xreflabel="schemadoccleanupnodelock(  )">
<title id="function.cleanupnodelock-title">
  cleanupnodelock(  )
</title>
<titleabbrev id="function.cleanupnodelock-titleabbrev">
  cleanupnodelock(  )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Nettoie les entrées qui restent lors du redémarrage de slon
  
  <programlisting>declare
	v_row		record;
begin
	for v_row in select nl_nodeid, nl_conncnt, nl_backendpid
			from sl_nodelock
			for update
	loop
		if killBackend(v_row.nl_backendpid, &#39;NULL&#39;) &lt; 0 then
			raise notice &#39;Slony-I: cleanup stale sl_nodelock entry for pid=%&#39;,
					v_row.nl_backendpid;
			delete from sl_nodelock where
					nl_nodeid = v_row.nl_nodeid and
					nl_conncnt = v_row.nl_conncnt;
		end if;
	end loop;

	return 0;
end;</programlisting>
</para>

</section>

<!-- Function copyfields( integer ) -->
<section id="function.copyfields-integer"
  xreflabel="schemadoccopyfields( integer )">
<title id="function.copyfields-integer-title">
  copyfields( integer )
</title>
<titleabbrev id="function.copyfields-integer-titleabbrev">
  copyfields( integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>text</seg>
    </seglistitem>
  </segmentedlist>
 
  Renvoie une chaîne consistant à ce qui doit être ajoutée à une instruction
  COPY pour spécifier les champs pour le tab_id.  

  Dans les versions ultérieurs à PostgreSQL 7.3, cela ressemble à (field1,
  field2,...fieldn)
  
  <programlisting>declare
	result text;
	prefix text;
	prec record;
begin
	result := &#39;&#39;;
	prefix := &#39;(&#39;;   -- Initially, prefix is the opening paren

	for prec in select slon_quote_input(a.attname) as column from sl_table t, pg_catalog.pg_attribute a where t.tab_id = $1 and t.tab_reloid = a.attrelid and a.attnum &gt; 0 and a.attisdropped = false order by attnum
	loop
		result := result || prefix || prec.column;
		prefix := &#39;,&#39;;   -- Subsequently, prepend columns with commas
	end loop;
	result := result || &#39;)&#39;;
	return result;
end;</programlisting>
</para>

</section>

<!-- Function createevent( name, text ) -->
<section id="function.createevent-name-text"
  xreflabel="schemadoccreateevent( name, text )">
<title id="function.createevent-name-text-title">
  createevent( name, text )
</title>
<titleabbrev id="function.createevent-name-text-titleabbrev">
  createevent( name, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>C</seg>
       <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
 
  Crée une entrée dans sl_event.
  
  <programlisting>_Slony_I_createEvent</programlisting>
</para>

</section>

<!-- Function createevent( name, text, text ) -->
<section id="function.createevent-name-text-text"
  xreflabel="schemadoccreateevent( name, text, text )">
<title id="function.createevent-name-text-text-title">
  createevent( name, text, text )
</title>
<titleabbrev id="function.createevent-name-text-text-titleabbrev">
  createevent( name, text, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>C</seg>
       <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
 
  Crée une entrée dans sl_event.
  
  <programlisting>_Slony_I_createEvent</programlisting>
</para>

</section>

<!-- Function createevent( name, text, text, text ) -->
<section id="function.createevent-name-text-text-text"
  xreflabel="schemadoccreateevent( name, text, text, text )">
<title id="function.createevent-name-text-text-text-title">
  createevent( name, text, text, text )
</title>
<titleabbrev id="function.createevent-name-text-text-text-titleabbrev">
  createevent( name, text, text, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>C</seg>
       <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
 
  Crée une entrée dans sl_event.
    
  <programlisting>_Slony_I_createEvent</programlisting>
</para>

</section>

<!-- Function createevent( name, text, text, text, text ) -->
<section id="function.createevent-name-text-text-text-text"
  xreflabel="schemadoccreateevent( name, text, text, text, text )">
<title id="function.createevent-name-text-text-text-text-title">
  createevent( name, text, text, text, text )
</title>
<titleabbrev id="function.createevent-name-text-text-text-text-titleabbrev">
  createevent( name, text, text, text, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>C</seg>
       <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
 
  Crée une entrée dans sl_event.
  
  <programlisting>_Slony_I_createEvent</programlisting>
</para>

</section>

<!-- Function createevent( name, text, text, text, text, text ) -->
<section id="function.createevent-name-text-text-text-text-text"
  xreflabel="schemadoccreateevent( name, text, text, text, text, text )">
<title id="function.createevent-name-text-text-text-text-text-title">
  createevent( name, text, text, text, text, text )
</title>
<titleabbrev id="function.createevent-name-text-text-text-text-text-titleabbrev">
  createevent( name, text, text, text, text, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>C</seg>
       <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
 
  Crée une entrée dans sl_event.
  
  <programlisting>_Slony_I_createEvent</programlisting>
</para>

</section>

<!-- Function createevent( name, text, text, text, text, text, text ) -->
<section id="function.createevent-name-text-text-text-text-text-text"
  xreflabel="schemadoccreateevent( name, text, text, text, text, text, text )">
<title id="function.createevent-name-text-text-text-text-text-text-title">
  createevent( name, text, text, text, text, text, text )
</title>
<titleabbrev id="function.createevent-name-text-text-text-text-text-text-titleabbrev">
  createevent( name, text, text, text, text, text, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>C</seg>
       <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
 
  Crée une entrée dans sl_event.
  
  <programlisting>_Slony_I_createEvent</programlisting>
</para>

</section>

<!-- Function createevent( name, text, text, text, text, text, text, text ) -->
<section id="function.createevent-name-text-text-text-text-text-text-text"
  xreflabel="schemadoccreateevent( name, text, text, text, text, text, text, text )">
<title id="function.createevent-name-text-text-text-text-text-text-text-title">
  createevent( name, text, text, text, text, text, text, text )
</title>
<titleabbrev id="function.createevent-name-text-text-text-text-text-text-text-titleabbrev">
  createevent( name, text, text, text, text, text, text, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>C</seg>
       <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
 
  Crée une entrée dans sl_event.
  
  <programlisting>_Slony_I_createEvent</programlisting>
</para>

</section>

<!-- Function createevent( name, text, text, text, text, text, text, text, text ) -->
<section id="function.createevent-name-text-text-text-text-text-text-text-text"
  xreflabel="schemadoccreateevent( name, text, text, text, text, text, text, text, text )">
<title id="function.createevent-name-text-text-text-text-text-text-text-text-title">
  createevent( name, text, text, text, text, text, text, text, text )
</title>
<titleabbrev id="function.createevent-name-text-text-text-text-text-text-text-text-titleabbrev">
  createevent( name, text, text, text, text, text, text, text, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>C</seg>
       <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
 
  Crée une entrée dans sl_event.
  
  <programlisting>_Slony_I_createEvent</programlisting>
</para>

</section>

<!-- Function createevent( name, text, text, text, text, text, text, text, text, text ) -->
<section id="function.createevent-name-text-text-text-text-text-text-text-text-text"
  xreflabel="schemadoccreateevent( name, text, text, text, text, text, text, text, text, text )">
<title id="function.createevent-name-text-text-text-text-text-text-text-text-text-title">
  createevent( name, text, text, text, text, text, text, text, text, text )
</title>
<titleabbrev id="function.createevent-name-text-text-text-text-text-text-text-text-text-titleabbrev">
  createevent( name, text, text, text, text, text, text, text, text, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>C</seg>
       <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
 
  Crée une entrée dans sl_event.
  
  <programlisting>_Slony_I_createEvent</programlisting>
</para>

</section>

<!-- Function ddlscript_complete( integer, text, integer ) -->
<section id="function.ddlscript-complete-integer-text-integer"
  xreflabel="schemadocddlscript_complete( integer, text, integer )">
<title id="function.ddlscript-complete-integer-text-integer-title">
  ddlscript_complete( integer, text, integer )
</title>
<titleabbrev id="function.ddlscript-complete-integer-text-integer-titleabbrev">
  ddlscript_complete( integer, text, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Après l'exécution du script sur l'origine, ceci corrige les noms des relations,
  restaure les triggers et génère un événement DDL_SCRIPT pour réclamer son
  exécution sur les esclaves répliqués.
  
  <programlisting>declare
	p_set_id			alias for $1;
	p_script			alias for $2;
	p_only_on_node		alias for $3;
	v_set_origin		int4;
begin
	perform updateRelname(p_set_id, p_only_on_node);
	if p_only_on_node = -1 then
		perform alterTableForReplication(tab_id) from sl_table where tab_set in (select set_id from sl_set where set_origin = getLocalNodeId(&#39;_schemadoc&#39;));

		return  createEvent(&#39;_schemadoc&#39;, &#39;DDL_SCRIPT&#39;, 
			p_set_id::text, p_script::text, p_only_on_node::text);
	else
		perform alterTableForReplication(tab_id) from sl_table;
	end if;
	return NULL;
end;</programlisting>
</para>

</section>

<!-- Function ddlscript_complete_int( integer, integer ) -->
<section id="function.ddlscript-complete-int-integer-integer"
  xreflabel="schemadocddlscript_complete_int( integer, integer )">
<title id="function.ddlscript-complete-int-integer-integer-title">
  ddlscript_complete_int( integer, integer )
</title>
<titleabbrev id="function.ddlscript-complete-int-integer-integer-titleabbrev">
  ddlscript_complete_int( integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Termine le traitement de l'événement DDL_SCRIPT. Ceci replace les tables en
  mode répliqué.
  
  <programlisting>declare
	p_set_id			alias for $1;
	p_only_on_node		alias for $2;
	v_row				record;
begin
	-- ----
	-- Put all tables back into replicated mode
	-- ----
	for v_row in select * from sl_table
	loop
		perform alterTableForReplication(v_row.tab_id);
	end loop;

	return p_set_id;
end;</programlisting>
</para>

</section>

<!-- Function ddlscript_prepare( integer, integer ) -->
<section id="function.ddlscript-prepare-integer-integer"
  xreflabel="schemadocddlscript_prepare( integer, integer )">
<title id="function.ddlscript-prepare-integer-integer-title">
  ddlscript_prepare( integer, integer )
</title>
<titleabbrev id="function.ddlscript-prepare-integer-integer-titleabbrev">
  ddlscript_prepare( integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Prépare l'exécution du script DDL sur l'origine.
  
  <programlisting>declare
	p_set_id			alias for $1;
	p_only_on_node		alias for $2;
	v_set_origin		int4;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	
	-- ----
	-- Check that the set exists and originates here
	-- unless only_on_node was specified (then it can be applied to
	-- that node because that is what the user wanted)
	-- ----
	select set_origin into v_set_origin
			from sl_set
			where set_id = p_set_id
			for update;
	if not found then
		raise exception &#39;Slony-I: set % not found&#39;, p_set_id;
	end if;

	if p_only_on_node = -1 then
		if v_set_origin &lt;&gt; getLocalNodeId(&#39;_schemadoc&#39;) then
			raise exception &#39;Slony-I: set % does not originate on local node&#39;,
				p_set_id;
		end if;
		-- ----
		-- Create a SYNC event, run the script and generate the DDL_SCRIPT event
		-- ----
		perform createEvent(&#39;_schemadoc&#39;, &#39;SYNC&#39;, NULL);
		perform alterTableRestore(tab_id) from sl_table where tab_set in (select set_id from sl_set where set_origin = getLocalNodeId(&#39;_schemadoc&#39;));
	else
		-- ----
		-- If doing &quot;only on one node&quot; - restore ALL tables irrespective of set
		-- ----
		perform alterTableRestore(tab_id) from sl_table;
	end if;
	return 1;
end;</programlisting>
</para>

</section>

<!-- Function ddlscript_prepare_int( integer, integer ) -->
<section id="function.ddlscript-prepare-int-integer-integer"
  xreflabel="schemadocddlscript_prepare_int( integer, integer )">
<title id="function.ddlscript-prepare-int-integer-integer-title">
  ddlscript_prepare_int( integer, integer )
</title>
<titleabbrev id="function.ddlscript-prepare-int-integer-integer-titleabbrev">
  ddlscript_prepare_int( integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Fait le travail préparatoire pour un script DDL, restaure les
  triggers/règles dans leur état original.
  
  <programlisting>declare
	p_set_id			alias for $1;
	p_only_on_node		alias for $2;
	v_set_origin		int4;
	v_no_id				int4;
	v_row				record;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Check that we either are the set origin or a current
	-- subscriber of the set.
	-- ----
	v_no_id := getLocalNodeId(&#39;_schemadoc&#39;);
	select set_origin into v_set_origin
			from sl_set
			where set_id = p_set_id
			for update;
	if not found then
		raise exception &#39;Slony-I: set % not found&#39;, p_set_id;
	end if;
	if v_set_origin &lt;&gt; v_no_id
			and not exists (select 1 from sl_subscribe
						where sub_set = p_set_id
						and sub_receiver = v_no_id)
	then
		return 0;
	end if;

	-- ----
	-- If execution on only one node is requested, check that
	-- we are that node.
	-- ----
	if p_only_on_node &gt; 0 and p_only_on_node &lt;&gt; v_no_id then
		return 0;
	end if;

	-- ----
	-- Restore all original triggers and rules of all sets
	-- ----
	for v_row in select * from sl_table
	loop
		perform alterTableRestore(v_row.tab_id);
	end loop;
	return p_set_id;
end;</programlisting>
</para>

</section>

<!-- Function denyaccess(  ) -->
<section id="function.denyaccess"
  xreflabel="schemadocdenyaccess(  )">
<title id="function.denyaccess-title">
  denyaccess(  )
</title>
<titleabbrev id="function.denyaccess-titleabbrev">
  denyaccess(  )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>C</seg>
       <seg>trigger</seg>
    </seglistitem>
  </segmentedlist>
 
  Fonction trigger pour empêcher la modification d'une table sur un abonné.
  
  <programlisting>_Slony_I_denyAccess</programlisting>
</para>

</section>

<!-- Function determineattkindserial( text ) -->
<section id="function.determineattkindserial-text"
  xreflabel="schemadocdetermineattkindserial( text )">
<title id="function.determineattkindserial-text-title">
  determineattkindserial( text )
</title>
<titleabbrev id="function.determineattkindserial-text-titleabbrev">
  determineattkindserial( text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>text</seg>
    </seglistitem>
  </segmentedlist>
 
  Une table indiquée sans clé primaire est ajoutée à la réplication. Suppose que
  tableAddKey() a été appelé avant et termine la création de la colonne de type
  serial. Elle renvoie l'attkind.
  
  <programlisting>declare
	p_tab_fqname	alias for $1;
	v_tab_fqname_quoted	text default &#39;&#39;;
	v_attkind		text default &#39;&#39;;
	v_attrow		record;
	v_have_serial	bool default &#39;f&#39;;
begin
	v_tab_fqname_quoted := slon_quote_input(p_tab_fqname);
	--
	-- Loop over the attributes of this relation
	-- and add a &quot;v&quot; for every user column, and a &quot;k&quot;
	-- if we find the Slony-I special serial column.
	--
	for v_attrow in select PGA.attnum, PGA.attname
			from &quot;pg_catalog&quot;.pg_class PGC,
			    &quot;pg_catalog&quot;.pg_namespace PGN,
				&quot;pg_catalog&quot;.pg_attribute PGA
			where slon_quote_brute(PGN.nspname) || &#39;.&#39; ||
			    slon_quote_brute(PGC.relname) = v_tab_fqname_quoted
				and PGN.oid = PGC.relnamespace
				and PGA.attrelid = PGC.oid
				and not PGA.attisdropped
				and PGA.attnum &gt; 0
			order by attnum
	loop
		if v_attrow.attname = &#39;_Slony-I_schemadoc_rowID&#39; then
		    v_attkind := v_attkind || &#39;k&#39;;
			v_have_serial := &#39;t&#39;;
		else
			v_attkind := v_attkind || &#39;v&#39;;
		end if;
	end loop;
	
	--
	-- A table must have at least one attribute, so not finding
	-- anything means the table does not exist.
	--
	if not found then
		raise exception &#39;Slony-I: table % not found&#39;, v_tab_fqname_quoted;
	end if;

	--
	-- If it does not have the special serial column, we
	-- should not have been called in the first place.
	--
	if not v_have_serial then
		raise exception &#39;Slony-I: table % does not have the serial key&#39;,
				v_tab_fqname_quoted;
	end if;

	execute &#39;update &#39; || v_tab_fqname_quoted ||
		&#39; set &quot;_Slony-I_schemadoc_rowID&quot; =&#39; ||
		&#39; &quot;pg_catalog&quot;.nextval(&#39;&#39;sl_rowid_seq&#39;&#39;);&#39;;
	execute &#39;alter table only &#39; || v_tab_fqname_quoted ||
		&#39; add unique (&quot;_Slony-I_schemadoc_rowID&quot;);&#39;;
	execute &#39;alter table only &#39; || v_tab_fqname_quoted ||
		&#39; alter column &quot;_Slony-I_schemadoc_rowID&quot; &#39; ||
		&#39; set not null;&#39;;

	--
	-- Return the resulting Slony-I attkind
	--
	return v_attkind;
end;</programlisting>
</para>

</section>

<!-- Function determineattkindunique( text, name ) -->
<section id="function.determineattkindunique-text-name"
  xreflabel="schemadocdetermineattkindunique( text, name )">
<title id="function.determineattkindunique-text-name-title">
  determineattkindunique( text, name )
</title>
<titleabbrev id="function.determineattkindunique-text-name-titleabbrev">
  determineattkindunique( text, name )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>text</seg>
    </seglistitem>
  </segmentedlist>
 
  Suivant le nom d'une table, renvoie le attkind spécifique de Slony-I (utilisé
  pour le trigger log) de la table. Utilise l'index unique spécifié ou la clé
  primaire (si indexname vaut NULL).
  
  <programlisting>declare
	p_tab_fqname	alias for $1;
	v_tab_fqname_quoted	text default &#39;&#39;;
	p_idx_name		alias for $2;
	v_idx_name_quoted	text;
	v_idxrow		record;
	v_attrow		record;
	v_i				integer;
	v_attno			int2;
	v_attkind		text default &#39;&#39;;
	v_attfound		bool;
begin
	v_tab_fqname_quoted := slon_quote_input(p_tab_fqname);
	v_idx_name_quoted := slon_quote_brute(p_idx_name);
	--
	-- Ensure that the table exists
	--
	if (select PGC.relname
				from &quot;pg_catalog&quot;.pg_class PGC,
					&quot;pg_catalog&quot;.pg_namespace PGN
				where slon_quote_brute(PGN.nspname) || &#39;.&#39; ||
					slon_quote_brute(PGC.relname) = v_tab_fqname_quoted
					and PGN.oid = PGC.relnamespace) is null then
		raise exception &#39;Slony-I: table % not found&#39;, v_tab_fqname_quoted;
	end if;

	--
	-- Lookup the tables primary key or the specified unique index
	--
	if p_idx_name isnull then
		raise exception &#39;Slony-I: index name must be specified&#39;;
	else
		select PGXC.relname, PGX.indexrelid, PGX.indkey
				into v_idxrow
				from &quot;pg_catalog&quot;.pg_class PGC,
					&quot;pg_catalog&quot;.pg_namespace PGN,
					&quot;pg_catalog&quot;.pg_index PGX,
					&quot;pg_catalog&quot;.pg_class PGXC
				where slon_quote_brute(PGN.nspname) || &#39;.&#39; ||
					slon_quote_brute(PGC.relname) = v_tab_fqname_quoted
					and PGN.oid = PGC.relnamespace
					and PGX.indrelid = PGC.oid
					and PGX.indexrelid = PGXC.oid
					and PGX.indisunique
					and slon_quote_brute(PGXC.relname) = v_idx_name_quoted;
		if not found then
			raise exception &#39;Slony-I: table % has no unique index %&#39;,
					v_tab_fqname_quoted, v_idx_name_quoted;
		end if;
	end if;

	--
	-- Loop over the tables attributes and check if they are
	-- index attributes. If so, add a &quot;k&quot; to the return value,
	-- otherwise add a &quot;v&quot;.
	--
	for v_attrow in select PGA.attnum, PGA.attname
			from &quot;pg_catalog&quot;.pg_class PGC,
			    &quot;pg_catalog&quot;.pg_namespace PGN,
				&quot;pg_catalog&quot;.pg_attribute PGA
			where slon_quote_brute(PGN.nspname) || &#39;.&#39; ||
			    slon_quote_brute(PGC.relname) = v_tab_fqname_quoted
				and PGN.oid = PGC.relnamespace
				and PGA.attrelid = PGC.oid
				and not PGA.attisdropped
				and PGA.attnum &gt; 0
			order by attnum
	loop
		v_attfound = &#39;f&#39;;

		v_i := 0;
		loop
			select indkey[v_i] into v_attno from &quot;pg_catalog&quot;.pg_index
					where indexrelid = v_idxrow.indexrelid;
			if v_attno isnull or v_attno = 0 then
				exit;
			end if;
			if v_attrow.attnum = v_attno then
				v_attfound = &#39;t&#39;;
				exit;
			end if;
			v_i := v_i + 1;
		end loop;

		if v_attfound then
			v_attkind := v_attkind || &#39;k&#39;;
		else
			v_attkind := v_attkind || &#39;v&#39;;
		end if;
	end loop;

	--
	-- Return the resulting attkind
	--
	return v_attkind;
end;</programlisting>
</para>

</section>

<!-- Function determineidxnameserial( text ) -->
<section id="function.determineidxnameserial-text"
  xreflabel="schemadocdetermineidxnameserial( text )">
<title id="function.determineidxnameserial-text-title">
  determineidxnameserial( text )
</title>
<titleabbrev id="function.determineidxnameserial-text-titleabbrev">
  determineidxnameserial( text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>name</seg>
    </seglistitem>
  </segmentedlist>
 
  Suivant le nom d'une table, construit un nom d'index de la colonne de type
  serial.
  
  <programlisting>declare
	p_tab_fqname	alias for $1;
	v_tab_fqname_quoted	text default &#39;&#39;;
	v_row			record;
begin
	v_tab_fqname_quoted := slon_quote_input(p_tab_fqname);
	--
	-- Lookup the table name alone
	--
	select PGC.relname
			into v_row
			from &quot;pg_catalog&quot;.pg_class PGC,
				&quot;pg_catalog&quot;.pg_namespace PGN
			where slon_quote_brute(PGN.nspname) || &#39;.&#39; ||
				slon_quote_brute(PGC.relname) = v_tab_fqname_quoted
				and PGN.oid = PGC.relnamespace;
	if not found then
		raise exception &#39;Slony-I: table % not found&#39;,
				v_tab_fqname_quoted;
	end if;

	--
	-- Return the found index name
	--
	return v_row.relname || &#39;__Slony-I_schemadoc_rowID_key&#39;;
end;</programlisting>
</para>

</section>

<!-- Function determineidxnameunique( text, name ) -->
<section id="function.determineidxnameunique-text-name"
  xreflabel="schemadocdetermineidxnameunique( text, name )">
<title id="function.determineidxnameunique-text-name-title">
  determineidxnameunique( text, name )
</title>
<titleabbrev id="function.determineidxnameunique-text-name-titleabbrev">
  determineidxnameunique( text, name )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>name</seg>
    </seglistitem>
  </segmentedlist>
 
  FUNCTION determineIdxnameUnique (tab_fqname, indexname)

  Suivant un nom de table, tab_fqname, vérifie que l'index unique, indexname,
  existe ou renvoie le nom de l'index de clé primaire pour la table. S'il n'y
  a pas d'index unique, il lève une exception.
  
  <programlisting>declare
	p_tab_fqname	alias for $1;
	v_tab_fqname_quoted	text default &#39;&#39;;
	p_idx_name		alias for $2;
	v_idxrow		record;
begin
	v_tab_fqname_quoted := slon_quote_input(p_tab_fqname);
	--
	-- Ensure that the table exists
	--
	if (select PGC.relname
				from &quot;pg_catalog&quot;.pg_class PGC,
					&quot;pg_catalog&quot;.pg_namespace PGN
				where slon_quote_brute(PGN.nspname) || &#39;.&#39; ||
					slon_quote_brute(PGC.relname) = v_tab_fqname_quoted
					and PGN.oid = PGC.relnamespace) is null then
		raise exception &#39;Slony-I: determineIdxnameUnique(): table % not found&#39;, v_tab_fqname_quoted;
	end if;

	--
	-- Lookup the tables primary key or the specified unique index
	--
	if p_idx_name isnull then
		select PGXC.relname
				into v_idxrow
				from &quot;pg_catalog&quot;.pg_class PGC,
					&quot;pg_catalog&quot;.pg_namespace PGN,
					&quot;pg_catalog&quot;.pg_index PGX,
					&quot;pg_catalog&quot;.pg_class PGXC
				where slon_quote_brute(PGN.nspname) || &#39;.&#39; ||
					slon_quote_brute(PGC.relname) = v_tab_fqname_quoted
					and PGN.oid = PGC.relnamespace
					and PGX.indrelid = PGC.oid
					and PGX.indexrelid = PGXC.oid
					and PGX.indisprimary;
		if not found then
			raise exception &#39;Slony-I: table % has no primary key&#39;,
					v_tab_fqname_quoted;
		end if;
	else
		select PGXC.relname
				into v_idxrow
				from &quot;pg_catalog&quot;.pg_class PGC,
					&quot;pg_catalog&quot;.pg_namespace PGN,
					&quot;pg_catalog&quot;.pg_index PGX,
					&quot;pg_catalog&quot;.pg_class PGXC
				where slon_quote_brute(PGN.nspname) || &#39;.&#39; ||
					slon_quote_brute(PGC.relname) = v_tab_fqname_quoted
					and PGN.oid = PGC.relnamespace
					and PGX.indrelid = PGC.oid
					and PGX.indexrelid = PGXC.oid
					and PGX.indisunique
					and slon_quote_brute(PGXC.relname) = slon_quote_input(p_idx_name);
		if not found then
			raise exception &#39;Slony-I: table % has no unique index %&#39;,
					v_tab_fqname_quoted, p_idx_name;
		end if;
	end if;

	--
	-- Return the found index name
	--
	return v_idxrow.relname;
end;</programlisting>
</para>

</section>

<!-- Function disablenode( integer ) -->
<section id="function.disablenode-integer"
  xreflabel="schemadocdisablenode( integer )">
<title id="function.disablenode-integer-title">
  disablenode( integer )
</title>
<titleabbrev id="function.disablenode-integer-titleabbrev">
  disablenode( integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
 
  Traite l'événement DISABLE_NODE pour le n&oelig;ud no_id.

  Note&nbsp;: ceci n'est pas encore implanté&nbsp;!
  
  <programlisting>declare
	p_no_id			alias for $1;
begin
	-- **** TODO ****
	raise exception &#39;Slony-I: disableNode() not implemented&#39;;
end;</programlisting>
</para>

</section>

<!-- Function disablenode_int( integer ) -->
<section id="function.disablenode-int-integer"
  xreflabel="schemadocdisablenode_int( integer )">
<title id="function.disablenode-int-integer-title">
  disablenode_int( integer )
</title>
<titleabbrev id="function.disablenode-int-integer-titleabbrev">
  disablenode_int( integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  <programlisting>declare
	p_no_id			alias for $1;
begin
	-- **** TODO ****
	raise exception &#39;Slony-I: disableNode_int() not implemented&#39;;
end;</programlisting>
</para>

</section>

<!-- Function droplisten( integer, integer, integer ) -->
<section id="function.droplisten-integer-integer-integer"
  xreflabel="schemadocdroplisten( integer, integer, integer )">
<title id="function.droplisten-integer-integer-integer-title">
  droplisten( integer, integer, integer )
</title>
<titleabbrev id="function.droplisten-integer-integer-integer-titleabbrev">
  droplisten( integer, integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
 
  Génère l'événement DROP_LISTEN.
  
  <programlisting>declare
	p_li_origin		alias for $1;
	p_li_provider	alias for $2;
	p_li_receiver	alias for $3;
begin
	perform dropListen_int(p_li_origin, 
			p_li_provider, p_li_receiver);
	
	return  createEvent (&#39;_schemadoc&#39;, &#39;DROP_LISTEN&#39;,
			p_li_origin::text, p_li_provider::text, p_li_receiver::text);
end;</programlisting>
</para>

</section>

<!-- Function droplisten_int( integer, integer, integer ) -->
<section id="function.droplisten-int-integer-integer-integer"
  xreflabel="schemadocdroplisten_int( integer, integer, integer )">
<title id="function.droplisten-int-integer-integer-integer-title">
  droplisten_int( integer, integer, integer )
</title>
<titleabbrev id="function.droplisten-int-integer-integer-integer-titleabbrev">
  droplisten_int( integer, integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Traite l'événement DROP_LISTEN, supprimant l'entrée sl_listen pour la
  combinaison (origine, fournisseur, récepteur) indiquée.
  
  <programlisting>declare
	p_li_origin		alias for $1;
	p_li_provider	alias for $2;
	p_li_receiver	alias for $3;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	delete from sl_listen
			where li_origin = p_li_origin
			and li_provider = p_li_provider
			and li_receiver = p_li_receiver;
	if found then
		return 1;
	else
		return 0;
	end if;
end;</programlisting>
</para>

</section>

<!-- Function dropnode( integer ) -->
<section id="function.dropnode-integer"
  xreflabel="schemadocdropnode( integer )">
<title id="function.dropnode-integer-title">
  dropnode( integer )
</title>
<titleabbrev id="function.dropnode-integer-titleabbrev">
  dropnode( integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
 
  Génère un événement DROP_NODE pour supprimer le n&oelig;ud node_id de la
  réplication.
  
  <programlisting>declare
	p_no_id			alias for $1;
	v_node_row		record;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Check that this got called on a different node
	-- ----
	if p_no_id = getLocalNodeId(&#39;_schemadoc&#39;) then
		raise exception &#39;Slony-I: DROP_NODE cannot initiate on the dropped node&#39;;
	end if;

	select * into v_node_row from sl_node
			where no_id = p_no_id
			for update;
	if not found then
		raise exception &#39;Slony-I: unknown node ID %&#39;, p_no_id;
	end if;

	-- ----
	-- Make sure we do not break other nodes subscriptions with this
	-- ----
	if exists (select true from sl_subscribe
			where sub_provider = p_no_id)
	then
		raise exception &#39;Slony-I: Node % is still configured as a data provider&#39;,
				p_no_id;
	end if;

	-- ----
	-- Make sure no set originates there any more
	-- ----
	if exists (select true from sl_set
			where set_origin = p_no_id)
	then
		raise exception &#39;Slony-I: Node % is still origin of one or more sets&#39;,
				p_no_id;
	end if;

	-- ----
	-- Call the internal drop functionality and generate the event
	-- ----
	perform dropNode_int(p_no_id);
	return  createEvent(&#39;_schemadoc&#39;, &#39;DROP_NODE&#39;,
									p_no_id::text);
end;</programlisting>
</para>

</section>

<!-- Function dropnode_int( integer ) -->
<section id="function.dropnode-int-integer"
  xreflabel="schemadocdropnode_int( integer )">
<title id="function.dropnode-int-integer-title">
  dropnode_int( integer )
</title>
<titleabbrev id="function.dropnode-int-integer-titleabbrev">
  dropnode_int( integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Fonction interne pour traiter l'événement DROP_NODE, pour supprimer le
  n&oelig;ud node_id de la réplication.
  
  <programlisting>declare
	p_no_id			alias for $1;
	v_tab_row		record;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- If the dropped node is a remote node, clean the configuration
	-- from all traces for it.
	-- ----
	if p_no_id &lt;&gt; getLocalNodeId(&#39;_schemadoc&#39;) then
		delete from sl_subscribe
				where sub_receiver = p_no_id;
		delete from sl_listen
				where li_origin = p_no_id
					or li_provider = p_no_id
					or li_receiver = p_no_id;
		delete from sl_path
				where pa_server = p_no_id
					or pa_client = p_no_id;
		delete from sl_confirm
				where con_origin = p_no_id
					or con_received = p_no_id;
		delete from sl_event
				where ev_origin = p_no_id;
		delete from sl_node
				where no_id = p_no_id;

		return p_no_id;
	end if;

	-- ----
	-- This is us ... deactivate the node for now, the daemon
	-- will call uninstallNode() in a separate transaction.
	-- ----
	update sl_node
			set no_active = false
			where no_id = p_no_id;

	-- Rewrite sl_listen table
	perform RebuildListenEntries();

	return p_no_id;
end;</programlisting>
</para>

</section>

<!-- Function droppath( integer, integer ) -->
<section id="function.droppath-integer-integer"
  xreflabel="schemadocdroppath( integer, integer )">
<title id="function.droppath-integer-integer-title">
  droppath( integer, integer )
</title>
<titleabbrev id="function.droppath-integer-integer-titleabbrev">
  droppath( integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
 
  Génère un événement DROP_PATH pour supprimer le chemin de pa_server à
  pa_client.
  
  <programlisting>declare
	p_pa_server		alias for $1;
	p_pa_client		alias for $2;
	v_row			record;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- There should be no existing subscriptions. Auto unsubscribing
	-- is considered too dangerous. 
	-- ----
	for v_row in select sub_set, sub_provider, sub_receiver
			from sl_subscribe
			where sub_provider = p_pa_server
			and sub_receiver = p_pa_client
	loop
		raise exception 
			&#39;Slony-I: Path cannot be dropped, subscription of set % needs it&#39;,
			v_row.sub_set;
	end loop;

	-- ----
	-- Drop all sl_listen entries that depend on this path
	-- ----
	for v_row in select li_origin, li_provider, li_receiver
			from sl_listen
			where li_provider = p_pa_server
			and li_receiver = p_pa_client
	loop
		perform dropListen(
				v_row.li_origin, v_row.li_provider, v_row.li_receiver);
	end loop;

	-- ----
	-- Now drop the path and create the event
	-- ----
	perform dropPath_int(p_pa_server, p_pa_client);

	-- Rewrite sl_listen table
	perform RebuildListenEntries();

	return  createEvent (&#39;_schemadoc&#39;, &#39;DROP_PATH&#39;,
			p_pa_server::text, p_pa_client::text);
end;</programlisting>
</para>

</section>

<!-- Function droppath_int( integer, integer ) -->
<section id="function.droppath-int-integer-integer"
  xreflabel="schemadocdroppath_int( integer, integer )">
<title id="function.droppath-int-integer-integer-title">
  droppath_int( integer, integer )
</title>
<titleabbrev id="function.droppath-int-integer-integer-titleabbrev">
  droppath_int( integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
       <seg>PLPGSQL</seg>
       <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Traite l'événement DROP_PATH pour supprimer le chemin de pa_server vers
  pa_client.
  
  <programlisting>declare
	p_pa_server		alias for $1;
	p_pa_client		alias for $2;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Remove any dangling sl_listen entries with the server
	-- as provider and the client as receiver. This must have
	-- been cleared out before, but obviously was not.
	-- ----
	delete from sl_listen
			where li_provider = p_pa_server
			and li_receiver = p_pa_client;

	delete from sl_path
			where pa_server = p_pa_server
			and pa_client = p_pa_client;

	if found then
		-- Rewrite sl_listen table
		perform RebuildListenEntries();

		return 1;
	else
		-- Rewrite sl_listen table
		perform RebuildListenEntries();

		return 0;
	end if;
end;</programlisting>
</para>

</section>

<!-- Function dropset( integer ) -->
<section id="function.dropset-integer"
  xreflabel="schemadocdropset( integer )">
<title id="function.dropset-integer-title">
  dropset( integer )
</title>
<titleabbrev> id="function.dropset-integer-titleabbrev">
  dropset( integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
 
  Traite l'événement DROP_SET pour supprimer la réplication de l'ensemble set_id. Ceci implique de&nbsp;:

  <itemizedlist>
    <listitem>
      <para>restaurer les triggers et règles originaux&nbsp;;</para>
    </listitem>
    
    <listitem>
      <para>
        supprimer toutes les traces de la configuration de l'événement, en
	incluant les séquences, tables, abonnés, syncs et l'ensemble lui-même.
      </para>
    </listitem>
  </itemizedlist>

  <programlisting>declare
	p_set_id			alias for $1;
	v_origin			int4;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;
	
	-- ----
	-- Check that the set exists and originates here
	-- ----
	select set_origin into v_origin from sl_set
			where set_id = p_set_id;
	if not found then
		raise exception &#39;Slony-I: set % not found&#39;, p_set_id;
	end if;
	if v_origin != getLocalNodeId(&#39;_schemadoc&#39;) then
		raise exception &#39;Slony-I: set % does not originate on local node&#39;,
				p_set_id;
	end if;

	-- ----
	-- Call the internal drop set functionality and generate the event
	-- ----
	perform dropSet_int(p_set_id);
	return  createEvent(&#39;_schemadoc&#39;, &#39;DROP_SET&#39;, 
			p_set_id::text);
end;</programlisting>
</para>

</section>

<!-- Function dropset_int( integer ) -->
<section id="function.dropset-int-integer"
  xreflabel="schemadocdropset_int( integer )">
<title id="function.dropset-int-integer-title">
  dropset_int( integer )
</title>
<titleabbrev> id="function.dropset-int-integer-titleabbrev">
  dropset_int( integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  <programlisting>declare
	p_set_id			alias for $1;
	v_tab_row			record;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;
	
	-- ----
	-- Restore all tables original triggers and rules and remove
	-- our replication stuff.
	-- ----
	for v_tab_row in select tab_id from sl_table
			where tab_set = p_set_id
			order by tab_id
	loop
		perform alterTableRestore(v_tab_row.tab_id);
		perform tableDropKey(v_tab_row.tab_id);
	end loop;

	-- ----
	-- Remove all traces of the set configuration
	-- ----
	delete from sl_sequence
			where seq_set = p_set_id;
	delete from sl_table
			where tab_set = p_set_id;
	delete from sl_subscribe
			where sub_set = p_set_id;
	delete from sl_setsync
			where ssy_setid = p_set_id;
	delete from sl_set
			where set_id = p_set_id;

	-- Regenerate sl_listen since we revised the subscriptions
	perform RebuildListenEntries();

	-- Run addPartialLogIndices() to try to add indices to unused sl_log_? table
	perform addPartialLogIndices();

	return p_set_id;
end;</programlisting>
</para>

</section>

<!-- Function droptrigger( integer, name ) -->
<section id="function.droptrigger-integer-name"
  xreflabel="schemadocdroptrigger( integer, name )">
<title id="function.droptrigger-integer-name-title">
  droptrigger( integer, name )
</title>
<titleabbrev> id="function.droptrigger-integer-name-titleabbrev">
  droptrigger( integer, name )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>

  Soumet un événement DROP_TRIGGER pour indiquer que le trigger trig_tgname
  sur la table répliquée trig_tabid SERA désactivé.
  
  <programlisting>declare
	p_trig_tabid		alias for $1;
	p_trig_tgname		alias for $2;
begin
	perform dropTrigger_int(p_trig_tabid, p_trig_tgname);
	return  createEvent(&#39;_schemadoc&#39;, &#39;DROP_TRIGGER&#39;,
			p_trig_tabid::text, p_trig_tgname::text);
end;</programlisting>
</para>

</section>

<!-- Function droptrigger_int( integer, name ) -->
<section id="function.droptrigger-int-integer-name"
  xreflabel="schemadocdroptrigger_int( integer, name )">
<title id="function.droptrigger-int-integer-name-title">
  droptrigger_int( integer, name )
</title>
<titleabbrev> id="function.droptrigger-int-integer-name-titleabbrev">
  droptrigger_int( integer, name )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Traite l'événement DROP_TRIGGER pour assurer que le trigger trig_tgname
  sur la table répliquée trig_tabid est désactivé.
  
  <programlisting>declare
	p_trig_tabid		alias for $1;
	p_trig_tgname		alias for $2;
	v_tab_altered		boolean;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Get the current table status (altered or not)
	-- ----
	select tab_altered into v_tab_altered
			from sl_table where tab_id = p_trig_tabid;
	if not found then
		-- ----
		-- Not found is no hard error here, because that might
		-- mean that we are not subscribed to that set
		-- ----
		return 0;
	end if;

	-- ----
	-- If the table is modified for replication, restore the original state
	-- ----
	if v_tab_altered then
		perform alterTableRestore(p_trig_tabid);
	end if;

	-- ----
	-- Remove the entry from sl_trigger
	-- ----
	delete from sl_trigger
			where trig_tabid = p_trig_tabid
			  and trig_tgname = p_trig_tgname;

	-- ----
	-- Put the table back into replicated state if it was
	-- ----
	if v_tab_altered then
		perform alterTableForReplication(p_trig_tabid);
	end if;

	return p_trig_tabid;
end;</programlisting>
</para>

</section>

<!-- Function enablenode( integer ) -->
<section id="function.enablenode-integer"
  xreflabel="schemadocenablenode( integer )">
<title id="function.enablenode-integer-title">
  enablenode( integer )
</title>
<titleabbrev> id="function.enablenode-integer-titleabbrev">
  enablenode( integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
 
  no_id - identifiant du n&oelig;ud

  Génère l'événement ENABLE_NODE pour le n&oelig;ud no_id.
  
  <programlisting>declare
	p_no_id			alias for $1;
	v_local_node_id	int4;
	v_node_row		record;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Check that we are the node to activate and that we are
	-- currently disabled.
	-- ----
	v_local_node_id := getLocalNodeId(&#39;_schemadoc&#39;);
	select * into v_node_row
			from sl_node
			where no_id = p_no_id
			for update;
	if not found then 
		raise exception &#39;Slony-I: node % not found&#39;, p_no_id;
	end if;
	if v_node_row.no_active then
		raise exception &#39;Slony-I: node % is already active&#39;, p_no_id;
	end if;

	-- ----
	-- Activate this node and generate the ENABLE_NODE event
	-- ----
	perform enableNode_int (p_no_id);
	return  createEvent(&#39;_schemadoc&#39;, &#39;ENABLE_NODE&#39;,
									p_no_id::text);
end;</programlisting>
</para>

</section>

<!-- Function enablenode_int( integer ) -->
<section id="function.enablenode-int-integer"
  xreflabel="schemadocenablenode_int( integer )">
<title id="function.enablenode-int-integer-title">
  enablenode_int( integer )
</title>
<titleabbrev> id="function.enablenode-int-integer-titleabbrev">
  enablenode_int( integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  no_id - Identifiant du n&oelig;ud

  Fonction interne pour traiter l'événement ENABLE_NODE pour le n&oelig;ud
  no_id.
  
  <programlisting>declare
	p_no_id			alias for $1;
	v_local_node_id	int4;
	v_node_row		record;
	v_sub_row		record;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Check that the node is inactive
	-- ----
	select * into v_node_row
			from sl_node
			where no_id = p_no_id
			for update;
	if not found then 
		raise exception &#39;Slony-I: node % not found&#39;, p_no_id;
	end if;
	if v_node_row.no_active then
		return p_no_id;
	end if;

	-- ----
	-- Activate the node and generate sl_confirm status rows for it.
	-- ----
	update sl_node
			set no_active = &#39;t&#39;
			where no_id = p_no_id;
	insert into sl_confirm
			(con_origin, con_received, con_seqno)
			select no_id, p_no_id, 0 from sl_node
				where no_id != p_no_id
				and no_active;
	insert into sl_confirm
			(con_origin, con_received, con_seqno)
			select p_no_id, no_id, 0 from sl_node
				where no_id != p_no_id
				and no_active;

	-- ----
	-- Generate ENABLE_SUBSCRIPTION events for all sets that
	-- origin here and are subscribed by the just enabled node.
	-- ----
	v_local_node_id := getLocalNodeId(&#39;_schemadoc&#39;);
	for v_sub_row in select SUB.sub_set, SUB.sub_provider from
			sl_set S,
			sl_subscribe SUB
			where S.set_origin = v_local_node_id
			and S.set_id = SUB.sub_set
			and SUB.sub_receiver = p_no_id
			for update of S
	loop
		perform enableSubscription (v_sub_row.sub_set,
				v_sub_row.sub_provider, p_no_id);
	end loop;

	return p_no_id;
end;</programlisting>
</para>

</section>

<!-- Function enablesubscription( integer, integer, integer ) -->
<section id="function.enablesubscription-integer-integer-integer"
  xreflabel="schemadocenablesubscription( integer, integer, integer )">
<title id="function.enablesubscription-integer-integer-integer-title">
  enablesubscription( integer, integer, integer )
</title>
<titleabbrev> id="function.enablesubscription-integer-integer-integer-titleabbrev">
  enablesubscription( integer, integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Indique que sub_receiver a pout but d'abonner à l'ensemble sub_set à partir
  de sub_provider. Tout le travail est fait par la fonction interne
  enableSubscription_int (sub_set, sub_provider, sub_receiver).
  
  <programlisting>declare
	p_sub_set			alias for $1;
	p_sub_provider		alias for $2;
	p_sub_receiver		alias for $3;
begin
	return  enableSubscription_int (p_sub_set, 
			p_sub_provider, p_sub_receiver);
end;</programlisting>
</para>

</section>

<!-- Function enablesubscription_int( integer, integer, integer ) -->
<section id="function.enablesubscription-int-integer-integer-integer"
  xreflabel="schemadocenablesubscription_int( integer, integer, integer )">
<title id="function.enablesubscription-int-integer-integer-integer-title">
  enablesubscription_int( integer, integer, integer )
</title>
<titleabbrev> id="function.enablesubscription-int-integer-integer-integer-titleabbrev">
  enablesubscription_int( integer, integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Fonction interne pour activer l'abonnement du n&oelig;ud sub_receiver pour
  configurer sub_set via le n&oelig;ud sub_provider.

  slon fait une grosse partie du travail&nbsp;; tout ce que nous avons besoin
  de faire ici est de nous rappeler que cela est survenu. La fonction met à
  jour sl_subscribe, indiquant que l'abonnement est devenu actif.
  
  <programlisting>declare
	p_sub_set			alias for $1;
	p_sub_provider		alias for $2;
	p_sub_receiver		alias for $3;
	v_n					int4;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- The real work is done in the replication engine. All
	-- we have to do here is remembering that it happened.
	-- ----

	-- ----
	-- Well, not only ... we might be missing an important event here
	-- ----
	if not exists (select true from sl_path
			where pa_server = p_sub_provider
			and pa_client = p_sub_receiver)
	then
		insert into sl_path
				(pa_server, pa_client, pa_conninfo, pa_connretry)
				values 
				(p_sub_provider, p_sub_receiver, 
				&#39;&lt;event pending&gt;&#39;, 10);
	end if;

	update sl_subscribe
			set sub_active = &#39;t&#39;
			where sub_set = p_sub_set
			and sub_receiver = p_sub_receiver;
	get diagnostics v_n = row_count;
	if v_n = 0 then
		insert into sl_subscribe
				(sub_set, sub_provider, sub_receiver,
				sub_forward, sub_active)
				values
				(p_sub_set, p_sub_provider, p_sub_receiver,
				false, true);
	end if;

	-- Rewrite sl_listen table
	perform RebuildListenEntries();

	return p_sub_set;
end;</programlisting>
</para>

</section>

<!-- Function failednode( integer, integer ) -->
<section id="function.failednode-integer-integer"
  xreflabel="schemadocfailednode( integer, integer )">
<title id="function.failednode-integer-integer-title">
  failednode( integer, integer )
</title>
<titleabbrev> id="function.failednode-integer-integer-titleabbrev">
  failednode( integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Initie la bascule de failed_node à backup_node. Cette fonction doit être
  appelée sur tous les n&oelig;uds, puis doit attendre le redémarrage de tous
  les démons de n&oelig;ud.
  
  <programlisting>declare
	p_failed_node		alias for $1;
	p_backup_node		alias for $2;
	v_row				record;
	v_row2				record;
	v_n					int4;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- All consistency checks first
	-- Check that every node that has a path to the failed node
	-- also has a path to the backup node.
	-- ----
	for v_row in select P.pa_client
			from sl_path P
			where P.pa_server = p_failed_node
				and P.pa_client &lt;&gt; p_backup_node
				and not exists (select true from sl_path PP
							where PP.pa_server = p_backup_node
								and PP.pa_client = P.pa_client)
	loop
		raise exception &#39;Slony-I: cannot failover - node % has no path to the backup node&#39;,
				v_row.pa_client;
	end loop;

	-- ----
	-- Check all sets originating on the failed node
	-- ----
	for v_row in select set_id
			from sl_set
			where set_origin = p_failed_node
	loop
		-- ----
		-- Check that the backup node is subscribed to all sets
		-- that originate on the failed node
		-- ----
		select into v_row2 sub_forward, sub_active
				from sl_subscribe
				where sub_set = v_row.set_id
					and sub_receiver = p_backup_node;
		if not found then
			raise exception &#39;Slony-I: cannot failover - node % is not subscribed to set %&#39;,
					p_backup_node, v_row.set_id;
		end if;

		-- ----
		-- Check that the subscription is active
		-- ----
		if not v_row2.sub_active then
			raise exception &#39;Slony-I: cannot failover - subscription for set % is not active&#39;,
					v_row.set_id;
		end if;

		-- ----
		-- If there are other subscribers, the backup node needs to
		-- be a forwarder too.
		-- ----
		select into v_n count(*)
				from sl_subscribe
				where sub_set = v_row.set_id
					and sub_receiver &lt;&gt; p_backup_node;
		if v_n &gt; 0 and not v_row2.sub_forward then
			raise exception &#39;Slony-I: cannot failover - node % is not a forwarder of set %&#39;,
					p_backup_node, v_row.set_id;
		end if;
	end loop;

	-- ----
	-- Terminate all connections of the failed node the hard way
	-- ----
	perform terminateNodeConnections(p_failed_node);

	-- ----
	-- Move the sets
	-- ----
	for v_row in select S.set_id, (select count(*)
					from sl_subscribe SUB
					where S.set_id = SUB.sub_set
						and SUB.sub_receiver &lt;&gt; p_backup_node
						and SUB.sub_provider = p_failed_node)
					as num_direct_receivers 
			from sl_set S
			where S.set_origin = p_failed_node
			for update
	loop
		-- ----
		-- If the backup node is the only direct subscriber ...
		-- ----
		if v_row.num_direct_receivers = 0 then
		        raise notice &#39;failedNode: set % has no other direct receivers - move now&#39;, v_row.set_id;
			-- ----
			-- backup_node is the only direct subscriber, move the set
			-- right now. On the backup node itself that includes restoring
			-- all user mode triggers, removing the protection trigger,
			-- adding the log trigger, removing the subscription and the
			-- obsolete setsync status.
			-- ----
			if p_backup_node = getLocalNodeId(&#39;_schemadoc&#39;) then
				for v_row2 in select * from sl_table
						where tab_set = v_row.set_id
				loop
					perform alterTableRestore(v_row2.tab_id);
				end loop;

				update sl_set set set_origin = p_backup_node
						where set_id = v_row.set_id;

				delete from sl_setsync
						where ssy_setid = v_row.set_id;

				for v_row2 in select * from sl_table
						where tab_set = v_row.set_id
				loop
					perform alterTableForReplication(v_row2.tab_id);
				end loop;
			end if;

			delete from sl_subscribe
					where sub_set = v_row.set_id
						and sub_receiver = p_backup_node;
		else
			raise notice &#39;failedNode: set % has other direct receivers - change providers only&#39;, v_row.set_id;
			-- ----
			-- Backup node is not the only direct subscriber. This
			-- means that at this moment, we redirect all direct
			-- subscribers to receive from the backup node, and the
			-- backup node itself to receive from another one.
			-- The admin utility will wait for the slon engine to
			-- restart and then call failedNode2() on the node with
			-- the highest SYNC and redirect this to it on
			-- backup node later.
			-- ----
			update sl_subscribe
					set sub_provider = (select min(SS.sub_receiver)
							from sl_subscribe SS
							where SS.sub_set = v_row.set_id
								and SS.sub_provider = p_failed_node
								and SS.sub_receiver &lt;&gt; p_backup_node
								and SS.sub_forward)
					where sub_set = v_row.set_id
						and sub_receiver = p_backup_node;
			update sl_subscribe
					set sub_provider = p_backup_node
					where sub_set = v_row.set_id
						and sub_provider = p_failed_node
						and sub_receiver &lt;&gt; p_backup_node;
		end if;
	end loop;

	-- Rewrite sl_listen table
	perform RebuildListenEntries();

	-- Run addPartialLogIndices() to try to add indices to unused sl_log_? table
	perform addPartialLogIndices();

	-- ----
	-- Make sure the node daemon will restart
	-- ----
	notify &quot;_schemadoc_Restart&quot;;

	-- ----
	-- That is it - so far.
	-- ----
	return p_failed_node;
end;</programlisting>
</para>

</section>

<!-- Function failednode2( integer, integer, integer, bigint, bigint ) -->
<section id="function.failednode2-integer-integer-integer-bigint-bigint"
  xreflabel="schemadocfailednode2( integer, integer, integer, bigint, bigint )">
<title id="function.failednode2-integer-integer-integer-bigint-bigint-title">
  failednode2( integer, integer, integer, bigint, bigint )
</title>
<titleabbrev> id="function.failednode2-integer-integer-integer-bigint-bigint-titleabbrev">
  failednode2( integer, integer, integer, bigint, bigint )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
 
  Sur le n&oelig;ud qui a le numéro de séquence le plus élevé sur le n&oelig;ud
  en échec, contrefait un événement FAILOVER_SET.
  
  <programlisting>declare
	p_failed_node		alias for $1;
	p_backup_node		alias for $2;
	p_set_id			alias for $3;
	p_ev_seqno			alias for $4;
	p_ev_seqfake		alias for $5;
	v_row				record;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	select * into v_row
			from sl_event
			where ev_origin = p_failed_node
			and ev_seqno = p_ev_seqno;
	if not found then
		raise exception &#39;Slony-I: event %,% not found&#39;,
				p_failed_node, p_ev_seqno;
	end if;

	insert into sl_event
			(ev_origin, ev_seqno, ev_timestamp,
			ev_minxid, ev_maxxid, ev_xip,
			ev_type, ev_data1, ev_data2, ev_data3)
			values 
			(p_failed_node, p_ev_seqfake, CURRENT_TIMESTAMP,
			v_row.ev_minxid, v_row.ev_maxxid, v_row.ev_xip,
			&#39;FAILOVER_SET&#39;, p_failed_node::text, p_backup_node::text,
			p_set_id::text);
	insert into sl_confirm
			(con_origin, con_received, con_seqno, con_timestamp)
			values
			(p_failed_node, getLocalNodeId(&#39;_schemadoc&#39;),
			p_ev_seqfake, CURRENT_TIMESTAMP);
	notify &quot;_schemadoc_Event&quot;;
	notify &quot;_schemadoc_Confirm&quot;;
	notify &quot;_schemadoc_Restart&quot;;

	perform failoverSet_int(p_failed_node,
			p_backup_node, p_set_id, p_ev_seqfake);

	return p_ev_seqfake;
end;</programlisting>
</para>

</section>

<!-- Function failoverset_int( integer, integer, integer, bigint ) -->
<section id="function.failoverset-int-integer-integer-integer-bigint"
  xreflabel="schemadocfailoverset_int( integer, integer, integer, bigint )">
<title id="function.failoverset-int-integer-integer-integer-bigint-title">
  failoverset_int( integer, integer, integer, bigint )
</title>
<titleabbrev id="function.failoverset-int-integer-integer-integer-bigint-titleabbrev">
  failoverset_int( integer, integer, integer, bigint )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Termine la bascule pour un ensemble.
  
  <programlisting>declare
	p_failed_node		alias for $1;
	p_backup_node		alias for $2;
	p_set_id			alias for $3;
	p_wait_seqno		alias for $4;
	v_row				record;
	v_last_sync			int8;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Change the origin of the set now to the backup node.
	-- On the backup node this includes changing all the
	-- trigger and protection stuff
	-- ----
	if p_backup_node = getLocalNodeId(&#39;_schemadoc&#39;) then
		for v_row in select * from sl_table
				where tab_set = p_set_id
		loop
			perform alterTableRestore(v_row.tab_id);
		end loop;

		delete from sl_setsync
				where ssy_setid = p_set_id;
		delete from sl_subscribe
				where sub_set = p_set_id
					and sub_receiver = p_backup_node;
		update sl_set
				set set_origin = p_backup_node
				where set_id = p_set_id;

		for v_row in select * from sl_table
				where tab_set = p_set_id
		loop
			perform alterTableForReplication(v_row.tab_id);
		end loop;
		insert into sl_event
				(ev_origin, ev_seqno, ev_timestamp,
				ev_minxid, ev_maxxid, ev_xip,
				ev_type, ev_data1, ev_data2, ev_data3, ev_data4)
				values
				(p_backup_node, &quot;pg_catalog&quot;.nextval(&#39;sl_event_seq&#39;), CURRENT_TIMESTAMP,
				&#39;0&#39;, &#39;0&#39;, &#39;&#39;,
				&#39;ACCEPT_SET&#39;, p_set_id::text,
				p_failed_node::text, p_backup_node::text,
				p_wait_seqno::text);
	else
		delete from sl_subscribe
				where sub_set = p_set_id
					and sub_receiver = p_backup_node;
		update sl_set
				set set_origin = p_backup_node
				where set_id = p_set_id;
	end if;

	-- Rewrite sl_listen table
	perform RebuildListenEntries();

	-- ----
	-- If we are a subscriber of the set ourself, change our
	-- setsync status to reflect the new set origin.
	-- ----
	if exists (select true from sl_subscribe
			where sub_set = p_set_id
				and sub_receiver = getLocalNodeId(
						&#39;_schemadoc&#39;))
	then
		delete from sl_setsync
				where ssy_setid = p_set_id;

		select coalesce(max(ev_seqno), 0) into v_last_sync
				from sl_event
				where ev_origin = p_backup_node
					and ev_type = &#39;SYNC&#39;;
		if v_last_sync &gt; 0 then
			insert into sl_setsync
					(ssy_setid, ssy_origin, ssy_seqno,
					ssy_minxid, ssy_maxxid, ssy_xip, ssy_action_list)
					select p_set_id, p_backup_node, v_last_sync,
					ev_minxid, ev_maxxid, ev_xip, NULL
					from sl_event
					where ev_origin = p_backup_node
						and ev_seqno = v_last_sync;
		else
			insert into sl_setsync
					(ssy_setid, ssy_origin, ssy_seqno,
					ssy_minxid, ssy_maxxid, ssy_xip, ssy_action_list)
					values (p_set_id, p_backup_node, &#39;0&#39;,
					&#39;0&#39;, &#39;0&#39;, &#39;&#39;, NULL);
		end if;
				
	end if;

	return p_failed_node;
end;</programlisting>
</para>

</section>

<!-- Function forwardconfirm( integer, integer, bigint, timestamp without time zone ) -->
<section id="function.forwardconfirm-integer-integer-bigint-timestamp-without-time-zone"
  xreflabel="schemadocforwardconfirm( integer, integer, bigint, timestamp without time zone )">
<title id="function.forwardconfirm-integer-integer-bigint-timestamp-without-time-zone-title">
  forwardconfirm( integer, integer, bigint, timestamp without time zone )
</title>
<titleabbrev> id="function.forwardconfirm-integer-integer-bigint-timestamp-without-time-zone-titleabbrev">
  forwardconfirm( integer, integer, bigint, timestamp without time zone )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
  
  Confirme (enregistré dans sl_confirm) que les éléments allant de p_con_origin
  à p_con_seqno ont été reçus par le n&oelig;ud p_con_received à
  p_con_timestamp, et ajoute un événement pour envoyer cette confirmation.
  
  <programlisting>declare
	p_con_origin	alias for $1;
	p_con_received	alias for $2;
	p_con_seqno		alias for $3;
	p_con_timestamp	alias for $4;
	v_max_seqno		bigint;
begin
	select into v_max_seqno coalesce(max(con_seqno), 0)
			from sl_confirm
			where con_origin = p_con_origin
			and con_received = p_con_received;
	if v_max_seqno &lt; p_con_seqno then
		insert into sl_confirm 
				(con_origin, con_received, con_seqno, con_timestamp)
				values (p_con_origin, p_con_received, p_con_seqno,
					p_con_timestamp);
		notify &quot;_schemadoc_Confirm&quot;;
		v_max_seqno = p_con_seqno;
	end if;

	return v_max_seqno;
end;</programlisting>
</para>

</section>

<!-- Function generate_sync_event( interval ) -->
<section id="function.generate-sync-event-interval"
  xreflabel="schemadocgenerate_sync_event( interval )">
<title id="function.generate-sync-event-interval-title">
  generate_sync_event( interval )
</title>
<titleabbrev> id="function.generate-sync-event-interval-titleabbrev">
  generate_sync_event( interval )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Génère un événement SYNC si aucun n'a eu lieu dans l'interval requis.
  
  <programlisting>declare
	p_interval     alias for $1;
	v_node_row     record;

BEGIN
	select 1 into v_node_row from sl_event 
       	  where ev_type = &#39;SYNC&#39; and ev_origin = getLocalNodeId(&#39;_schemadoc&#39;)
          and ev_timestamp &gt; now() - p_interval limit 1;
	if not found then
		-- If there has been no SYNC in the last interval, then push one
		perform createEvent(&#39;_schemadoc&#39;, &#39;SYNC&#39;, NULL);
		return 1;
	else
		return 0;
	end if;
end;</programlisting>
</para>

</section>

<!-- Function getlocalnodeid( name ) -->
<section id="function.getlocalnodeid-name"
  xreflabel="schemadocgetlocalnodeid( name )">
<title id="function.getlocalnodeid-name-title">
  getlocalnodeid( name )
</title>
<titleabbrev> id="function.getlocalnodeid-name-titleabbrev">
  getlocalnodeid( name )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>C</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Renvoie l'identifiant du n&oelig;ud en service sur la base de données locale.
  
  <programlisting>_Slony_I_getLocalNodeId</programlisting>
</para>

</section>

<!-- Function getmoduleversion(  ) -->
<section id="function.getmoduleversion"
  xreflabel="schemadocgetmoduleversion(  )">
<title id="function.getmoduleversion-title">
  getmoduleversion(  )
</title>
<titleabbrev> id="function.getmoduleversion-titleabbrev">
  getmoduleversion(  )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>C</seg>
      <seg>text</seg>
    </seglistitem>
  </segmentedlist>
 
  Renvoie le numéro de version (stocké en dur dans la biliothèque partagée)
  de Slony-I.
  
  <programlisting>_Slony_I_getModuleVersion</programlisting>
</para>

</section>

<!-- Function getsessionrole( name ) -->
<section id="function.getsessionrole-name"
  xreflabel="schemadocgetsessionrole( name )">
<title id="function.getsessionrole-name-title">
  getsessionrole( name )
</title>
<titleabbrev> id="function.getsessionrole-name-titleabbrev">
  getsessionrole( name )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>C</seg>
      <seg>text</seg>
    </seglistitem>
  </segmentedlist>
 
  Pas encore documenté.
  
  <programlisting>_Slony_I_getSessionRole</programlisting>
</para>

</section>

<!-- Function initializelocalnode( integer, text ) -->
<section id="function.initializelocalnode-integer-text"
  xreflabel="schemadocinitializelocalnode( integer, text )">
<title id="function.initializelocalnode-integer-text-title">
  initializelocalnode( integer, text )
</title>
<titleabbrev> id="function.initializelocalnode-integer-text-titleabbrev">
  initializelocalnode( integer, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  no_id - Identifiant du n&oelig;ud
  no_comment - Commentaire « humain »

  Initialise le nouveau n&oelig;ud d'identifiant no_id.
  
  <programlisting>declare
	p_local_node_id		alias for $1;
	p_comment			alias for $2;
	v_old_node_id		int4;
	v_first_log_no		int4;
	v_event_seq			int8;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Make sure this node is uninitialized or got reset
	-- ----
	select last_value::int4 into v_old_node_id from sl_local_node_id;
	if v_old_node_id != -1 then
		raise exception &#39;Slony-I: This node is already initialized&#39;;
	end if;

	-- ----
	-- Set sl_local_node_id to the requested value and add our
	-- own system to sl_node.
	-- ----
	perform setval(&#39;sl_local_node_id&#39;, p_local_node_id);
	perform setval(&#39;sl_rowid_seq&#39;, 
			p_local_node_id::int8 * &#39;1000000000000000&#39;::int8);
	perform storeNode_int (p_local_node_id, p_comment, false);
	
	return p_local_node_id;
end;</programlisting>
</para>

</section>

<!-- Function killbackend( integer, text ) -->
<section id="function.killbackend-integer-text"
  xreflabel="schemadockillbackend( integer, text )">
<title id="function.killbackend-integer-text-title">
  killbackend( integer, text )
</title>
<titleabbrev> id="function.killbackend-integer-text-titleabbrev">
  killbackend( integer, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>C</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Envoie un signal à un processus postgres. Nécessite les droits d'un
  super-utilisateur.
  
  <programlisting>_Slony_I_killBackend</programlisting>
</para>

</section>

<!-- Function lockedset(  ) -->
<section id="function.lockedset"
  xreflabel="schemadoclockedset(  )">
<title id="function.lockedset-title">
  lockedset(  )
</title>
<titleabbrev> id="function.lockedset-titleabbrev">
  lockedset(  )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>C</seg>
      <seg>trigger</seg>
    </seglistitem>
  </segmentedlist>
  
  Fonction trigger pour empêcher les modifications sur une table avant et après
  un moveSet().
  
  <programlisting>_Slony_I_lockedSet</programlisting>
</para>

</section>

<!-- Function lockset( integer ) -->
<section id="function.lockset-integer"
  xreflabel="schemadoclockset( integer )">
<title id="function.lockset-integer-title">
  lockset( integer )
</title>
<titleabbrev> id="function.lockset-integer-titleabbrev">
  lockset( integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Ajoute un trigger spécial pour toutes les tables d'un ensemble dont l'accès
  a été désactivé.
  
  <programlisting>declare
	p_set_id			alias for $1;
	v_local_node_id		int4;
	v_set_row			record;
	v_tab_row			record;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Check that the set exists and that we are the origin
	-- and that it is not already locked.
	-- ----
	v_local_node_id := getLocalNodeId(&#39;_schemadoc&#39;);
	select * into v_set_row from sl_set
			where set_id = p_set_id
			for update;
	if not found then
		raise exception &#39;Slony-I: set % not found&#39;, p_set_id;
	end if;
	if v_set_row.set_origin &lt;&gt; v_local_node_id then
		raise exception &#39;Slony-I: set % does not originate on local node&#39;,
				p_set_id;
	end if;
	if v_set_row.set_locked notnull then
		raise exception &#39;Slony-I: set % is already locked&#39;, p_set_id;
	end if;

	-- ----
	-- Place the lockedSet trigger on all tables in the set.
	-- ----
	for v_tab_row in select T.tab_id,
			slon_quote_brute(PGN.nspname) || &#39;.&#39; ||
			slon_quote_brute(PGC.relname) as tab_fqname
			from sl_table T,
				&quot;pg_catalog&quot;.pg_class PGC, &quot;pg_catalog&quot;.pg_namespace PGN
			where T.tab_set = p_set_id
				and T.tab_reloid = PGC.oid
				and PGC.relnamespace = PGN.oid
			order by tab_id
	loop
		execute &#39;create trigger &quot;_schemadoc_lockedset_&#39; || 
				v_tab_row.tab_id || 
				&#39;&quot; before insert or update or delete on &#39; ||
				v_tab_row.tab_fqname || &#39; for each row execute procedure
				lockedSet (&#39;&#39;_schemadoc&#39;&#39;);&#39;;
	end loop;

	-- ----
	-- Remember our snapshots xmax as for the set locking
	-- ----
	update sl_set
			set set_locked = getMaxXid()
			where set_id = p_set_id;

	return p_set_id;
end;</programlisting>
</para>

</section>

<!-- Function logswitch_finish(  ) -->
<section id="function.logswitch-finish"
  xreflabel="schemadoclogswitch_finish(  )">
<title id="function.logswitch-finish-title">
  logswitch_finish(  )
</title>
<titleabbrev> id="function.logswitch-finish-titleabbrev">
  logswitch_finish(  )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>

  Tente de finaliser une bascule de log en progressions.
  
  <programlisting>DECLARE
	v_current_status	int4;
	v_dummy				record;
BEGIN
	-- ----
	-- Grab the central configuration lock to prevent race conditions
	-- while changing the sl_log_status sequence value.
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Get the current log status.
	-- ----
	select last_value into v_current_status from sl_log_status;

	-- ----
	-- status value 0 or 1 means that there is no log switch in progress
	-- ----
	if v_current_status = 0 or v_current_status = 1 then
		return 0;
	end if;

	-- ----
	-- status = 2: sl_log_1 active, cleanup sl_log_2
	-- ----
	if v_current_status = 2 then
		-- ----
		-- The cleanup thread calls us after it did the delete and
		-- vacuum of both log tables. If sl_log_2 is empty now, we
		-- can truncate it and the log switch is done.
		-- ----
		for v_dummy in select 1 from sl_log_2 loop
			-- ----
			-- Found a row ... log switch is still in progress.
			-- ----
			raise notice &#39;Slony-I: log switch to sl_log_1 still in progress - sl_log_2 not truncated&#39;;
			return -1;
		end loop;

		raise notice &#39;Slony-I: log switch to sl_log_1 complete - truncate sl_log_2&#39;;
		truncate sl_log_2;
		if exists (select * from &quot;pg_catalog&quot;.pg_class c, &quot;pg_catalog&quot;.pg_namespace n, &quot;pg_catalog&quot;.pg_attribute a where c.relname = &#39;sl_log_2&#39; and n.oid = c.relnamespace and a.attrelid = c.oid and a.attname = &#39;oid&#39;) then
	                execute &#39;alter table sl_log_2 set without oids;&#39;;
		end if;		
		perform &quot;pg_catalog&quot;.setval(&#39;sl_log_status&#39;, 0);
		-- Run addPartialLogIndices() to try to add indices to unused sl_log_? table
		perform addPartialLogIndices();

		return 1;
	end if;

	-- ----
	-- status = 3: sl_log_2 active, cleanup sl_log_1
	-- ----
	if v_current_status = 3 then
		-- ----
		-- The cleanup thread calls us after it did the delete and
		-- vacuum of both log tables. If sl_log_2 is empty now, we
		-- can truncate it and the log switch is done.
		-- ----
		for v_dummy in select 1 from sl_log_1 loop
			-- ----
			-- Found a row ... log switch is still in progress.
			-- ----
			raise notice &#39;Slony-I: log switch to sl_log_2 still in progress - sl_log_1 not truncated&#39;;
			return -1;
		end loop;

		raise notice &#39;Slony-I: log switch to sl_log_2 complete - truncate sl_log_1&#39;;
		truncate sl_log_1;
		if exists (select * from &quot;pg_catalog&quot;.pg_class c, &quot;pg_catalog&quot;.pg_namespace n, &quot;pg_catalog&quot;.pg_attribute a where c.relname = &#39;sl_log_1&#39; and n.oid = c.relnamespace and a.attrelid = c.oid and a.attname = &#39;oid&#39;) then
	                execute &#39;alter table sl_log_1 set without oids;&#39;;
		end if;		
		perform &quot;pg_catalog&quot;.setval(&#39;sl_log_status&#39;, 1);
		-- Run addPartialLogIndices() to try to add indices to unused sl_log_? table
		perform addPartialLogIndices();
		return 2;
	end if;
END;</programlisting>
</para>

</section>

<!-- Function logswitch_start(  ) -->
<section id="function.logswitch-start"
  xreflabel="schemadoclogswitch_start(  )">
<title id="function.logswitch-start-title">
  logswitch_start(  )
</title>
<titleabbrev> id="function.logswitch-start-titleabbrev">
  logswitch_start(  )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Initie une bascule de log si aucune n'est déjà en cours.
  
  <programlisting>DECLARE
	v_current_status	int4;
BEGIN
	-- ----
	-- Grab the central configuration lock to prevent race conditions
	-- while changing the sl_log_status sequence value.
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Get the current log status.
	-- ----
	select last_value into v_current_status from sl_log_status;

	-- ----
	-- status = 0: sl_log_1 active, sl_log_2 clean
	-- Initiate a switch to sl_log_2.
	-- ----
	if v_current_status = 0 then
		perform &quot;pg_catalog&quot;.setval(&#39;sl_log_status&#39;, 3);
		perform registry_set_timestamp(
				&#39;logswitch.laststart&#39;, now()::timestamp);
		raise notice &#39;Slony-I: Logswitch to sl_log_2 initiated&#39;;
		return 2;
	end if;

	-- ----
	-- status = 1: sl_log_2 active, sl_log_1 clean
	-- Initiate a switch to sl_log_1.
	-- ----
	if v_current_status = 1 then
		perform &quot;pg_catalog&quot;.setval(&#39;sl_log_status&#39;, 2);
		perform registry_set_timestamp(
				&#39;logswitch.laststart&#39;, now()::timestamp);
		raise notice &#39;Slony-I: Logswitch to sl_log_1 initiated&#39;;
		return 1;
	end if;

	raise exception &#39;Previous logswitch still in progress&#39;;
END;</programlisting>
</para>

</section>

<!-- Function logswitch_weekly(  ) -->
<section id="function.logswitch-weekly"
  xreflabel="schemadoclogswitch_weekly(  )">
<title id="function.logswitch-weekly-title">
  logswitch_weekly(  )
</title>
<titleabbrev> id="function.logswitch-weekly-titleabbrev">
  logswitch_weekly(  )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>

  S'assure qu'une bascule de log est réalisée au moins toutes les semaines.
  
  <programlisting>DECLARE
	v_now			timestamp;
	v_now_dow		int4;
	v_auto_dow		int4;
	v_auto_time		time;
	v_auto_ts		timestamp;
	v_lastrun		timestamp;
	v_laststart		timestamp;
	v_days_since	int4;
BEGIN
	-- ----
	-- Check that today is the day to run at all
	-- ----
	v_auto_dow := registry_get_int4(
			&#39;logswitch_weekly.dow&#39;, 0);
	v_now := &quot;pg_catalog&quot;.now();
	v_now_dow := extract (DOW from v_now);
	if v_now_dow &lt;&gt; v_auto_dow then
		perform registry_set_timestamp(
				&#39;logswitch_weekly.lastrun&#39;, v_now);
		return 0;
	end if;

	-- ----
	-- Check that the last run of this procedure was before and now is
	-- after the time we should automatically switch logs.
	-- ----
	v_auto_time := registry_get_text(
			&#39;logswitch_weekly.time&#39;, &#39;02:00&#39;);
	v_auto_ts := current_date + v_auto_time;
	v_lastrun := registry_get_timestamp(
			&#39;logswitch_weekly.lastrun&#39;, &#39;epoch&#39;);
	if v_lastrun &gt;= v_auto_ts or v_now &lt; v_auto_ts then
		perform registry_set_timestamp(
				&#39;logswitch_weekly.lastrun&#39;, v_now);
		return 0;
	end if;

	-- ----
	-- This is the moment configured in dow+time. Check that the
	-- last logswitch was done more than 2 days ago.
	-- ----
	v_laststart := registry_get_timestamp(
			&#39;logswitch.laststart&#39;, &#39;epoch&#39;);
	v_days_since := extract (days from (v_now - v_laststart));
	if v_days_since &lt; 2 then
		perform registry_set_timestamp(
				&#39;logswitch_weekly.lastrun&#39;, v_now);
		return 0;
	end if;

	-- ----
	-- Fire off an automatic logswitch
	-- ----
	perform logswitch_start();
	perform registry_set_timestamp(
			&#39;logswitch_weekly.lastrun&#39;, v_now);
	return 1;
END;</programlisting>
</para>

</section>

<!-- Function logtrigger(  ) -->
<section id="function.logtrigger"
  xreflabel="schemadoc.logtrigger(  )">
<title id="function.logtrigger-title">
  logtrigger(  )
</title>
<titleabbrev> id="function.logtrigger-titleabbrev">
  logtrigger(  )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>C</seg>
      <seg>trigger</seg>
    </seglistitem>
  </segmentedlist>
 
  Ceci est le trigger exécuté sur le n&oelig;ud origine qui fait que les mises
  à jour sont enregistrées dans sl_log_1/sl_log_2.
  
  <programlisting>_Slony_I_logTrigger</programlisting>
</para>

</section>

<!-- Function mergeset( integer, integer ) -->
<section id="function.mergeset-integer-integer"
  xreflabel="schemadocmergeset( integer, integer )">
<title id="function.mergeset-integer-integer-title">
  mergeset( integer, integer )
</title>
<titleabbrev> id="function.mergeset-integer-integer-titleabbrev">
  mergeset( integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
  
  Génère un événement MERGE_SET pour demander que les ensembles soient
  fusionnés.

  Les ensembles doivent exister. L'origine doit correspondre au même n&oelig;ud.
  Le même ensemble de n&oelig;uds doivent être abonnés aux deux ensembles.
  
  <programlisting>declare
	p_set_id			alias for $1;
	p_add_id			alias for $2;
	v_origin			int4;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;
	
	-- ----
	-- Check that both sets exist and originate here
	-- ----
	if p_set_id = p_add_id then
		raise exception &#39;Slony-I: merged set ids cannot be identical&#39;;
	end if;
	select set_origin into v_origin from sl_set
			where set_id = p_set_id;
	if not found then
		raise exception &#39;Slony-I: set % not found&#39;, p_set_id;
	end if;
	if v_origin != getLocalNodeId(&#39;_schemadoc&#39;) then
		raise exception &#39;Slony-I: set % does not originate on local node&#39;,
				p_set_id;
	end if;

	select set_origin into v_origin from sl_set
			where set_id = p_add_id;
	if not found then
		raise exception &#39;Slony-I: set % not found&#39;, p_add_id;
	end if;
	if v_origin != getLocalNodeId(&#39;_schemadoc&#39;) then
		raise exception &#39;Slony-I: set % does not originate on local node&#39;,
				p_add_id;
	end if;

	-- ----
	-- Check that both sets are subscribed by the same set of nodes
	-- ----
	if exists (select true from sl_subscribe SUB1
				where SUB1.sub_set = p_set_id
				and SUB1.sub_receiver not in (select SUB2.sub_receiver
						from sl_subscribe SUB2
						where SUB2.sub_set = p_add_id))
	then
		raise exception &#39;Slony-I: subscriber lists of set % and % are different&#39;,
				p_set_id, p_add_id;
	end if;

	if exists (select true from sl_subscribe SUB1
				where SUB1.sub_set = p_add_id
				and SUB1.sub_receiver not in (select SUB2.sub_receiver
						from sl_subscribe SUB2
						where SUB2.sub_set = p_set_id))
	then
		raise exception &#39;Slony-I: subscriber lists of set % and % are different&#39;,
				p_add_id, p_set_id;
	end if;

	-- ----
	-- Check that all ENABLE_SUBSCRIPTION events for the set are confirmed
	-- ----
	if exists (select true from sl_event
			where ev_type = &#39;ENABLE_SUBSCRIPTION&#39;
			and ev_data1 = p_add_id::text
			and ev_seqno &gt; (select max(con_seqno) from sl_confirm
					where con_origin = ev_origin
					and con_received::text = ev_data3))
	then
		raise exception &#39;Slony-I: set % has subscriptions in progress - cannot merge&#39;,
				p_add_id;
	end if;
			  

	-- ----
	-- Create a SYNC event, merge the sets, create a MERGE_SET event
	-- ----
	perform createEvent(&#39;_schemadoc&#39;, &#39;SYNC&#39;, NULL);
	perform mergeSet_int(p_set_id, p_add_id);
	return  createEvent(&#39;_schemadoc&#39;, &#39;MERGE_SET&#39;, 
			p_set_id::text, p_add_id::text);
end;</programlisting>
</para>

</section>

<!-- Function mergeset_int( integer, integer ) -->
<section id="function.mergeset-int-integer-integer"
  xreflabel="schemadocmergeset_int( integer, integer )">
<title id="function.mergeset-int-integer-integer-title">
  mergeset_int( integer, integer )
</title>
<titleabbrev> id="function.mergeset-int-integer-integer-titleabbrev">
  mergeset_int( integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Exécute un événement MERGE_SET, assemblant tous les objets de l'ensemble
  add_id dans l'ensemble set_id.
  
  <programlisting>declare
	p_set_id			alias for $1;
	p_add_id			alias for $2;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;
	
	update sl_sequence
			set seq_set = p_set_id
			where seq_set = p_add_id;
	update sl_table
			set tab_set = p_set_id
			where tab_set = p_add_id;
	delete from sl_subscribe
			where sub_set = p_add_id;
	delete from sl_setsync
			where ssy_setid = p_add_id;
	delete from sl_set
			where set_id = p_add_id;

	return p_set_id;
end;</programlisting>
</para>

</section>

<!-- Function moveset( integer, integer ) -->
<section id="function.moveset-integer-integer"
  xreflabel="schemadocmoveset( integer, integer )">
<title id="function.moveset-integer-integer-title">
  moveset( integer, integer )
</title>
<titleabbrev> id="function.moveset-integer-integer-titleabbrev">
  moveset( integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
 
  Génère un événement MOVE_SET pour demander que l'origine de l'ensemble set_id
  soit déplacé vers le n&oelig;ud new_origin.
  
  <programlisting>declare
	p_set_id			alias for $1;
	p_new_origin		alias for $2;
	v_local_node_id		int4;
	v_set_row			record;
	v_sub_row			record;
	v_sync_seqno		int8;
	v_lv_row			record;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Check that the set is locked and that this locking
	-- happened long enough ago.
	-- ----
	v_local_node_id := getLocalNodeId(&#39;_schemadoc&#39;);
	select * into v_set_row from sl_set
			where set_id = p_set_id
			for update;
	if not found then
		raise exception &#39;Slony-I: set % not found&#39;, p_set_id;
	end if;
	if v_set_row.set_origin &lt;&gt; v_local_node_id then
		raise exception &#39;Slony-I: set % does not originate on local node&#39;,
				p_set_id;
	end if;
	if v_set_row.set_locked isnull then
		raise exception &#39;Slony-I: set % is not locked&#39;, p_set_id;
	end if;
	if v_set_row.set_locked &gt; getMinXid() then
		raise exception &#39;Slony-I: cannot move set % yet, transactions &lt; % are still in progress&#39;,
				p_set_id, v_set_row.set_locked;
	end if;

	-- ----
	-- Unlock the set
	-- ----
	perform unlockSet(p_set_id);

	-- ----
	-- Check that the new_origin is an active subscriber of the set
	-- ----
	select * into v_sub_row from sl_subscribe
			where sub_set = p_set_id
			and sub_receiver = p_new_origin;
	if not found then
		raise exception &#39;Slony-I: set % is not subscribed by node %&#39;,
				p_set_id, p_new_origin;
	end if;
	if not v_sub_row.sub_active then
		raise exception &#39;Slony-I: subsctiption of node % for set % is inactive&#39;,
				p_new_origin, p_set_id;
	end if;

	-- ----
	-- Reconfigure everything
	-- ----
	perform moveSet_int(p_set_id, v_local_node_id,
			p_new_origin, 0);

	perform RebuildListenEntries();

	-- ----
	-- At this time we hold access exclusive locks for every table
	-- in the set. But we did move the set to the new origin, so the
	-- createEvent() we are doing now will not record the sequences.
	-- ----
	v_sync_seqno := createEvent(&#39;_schemadoc&#39;, &#39;SYNC&#39;);
	insert into sl_seqlog 
			(seql_seqid, seql_origin, seql_ev_seqno, seql_last_value)
			select seq_id, v_local_node_id, v_sync_seqno, seq_last_value
			from sl_seqlastvalue
			where seq_set = p_set_id;
					
	-- ----
	-- Finally we generate the real event
	-- ----
	return createEvent(&#39;_schemadoc&#39;, &#39;MOVE_SET&#39;, 
			p_set_id::text, v_local_node_id::text, p_new_origin::text);
end;</programlisting>
</para>

</section>

<!-- Function moveset_int( integer, integer, integer, bigint ) -->
<section id="function.moveset-int-integer-integer-integer-bigint"
  xreflabel="schemadocmoveset_int( integer, integer, integer, bigint )">
<title id="function.moveset-int-integer-integer-integer-bigint-title">
  moveset_int( integer, integer, integer, bigint )
</title>
<titleabbrev id="function.moveset-int-integer-integer-integer-bigint-titleabbrev">
  moveset_int( integer, integer, integer, bigint )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Traite un événement MOVE_SET pour demander que l'origine de l'ensemble set_id
  soit déplacé du n&oelig;ud old_origin vers le n&oelig;ud new_origin.
  
  <programlisting>declare
	p_set_id			alias for $1;
	p_old_origin		alias for $2;
	p_new_origin		alias for $3;
	p_wait_seqno		alias for $4;
	v_local_node_id		int4;
	v_tab_row			record;
	v_sub_row			record;
	v_sub_node			int4;
	v_sub_last			int4;
	v_sub_next			int4;
	v_last_sync			int8;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Get our local node ID
	-- ----
	v_local_node_id := getLocalNodeId(&#39;_schemadoc&#39;);

	-- ----
	-- If we are the old or new origin of the set, we need to
	-- remove the log trigger from all tables first.
	-- ----
	if v_local_node_id = p_old_origin or v_local_node_id = p_new_origin then
		for v_tab_row in select tab_id from sl_table
				where tab_set = p_set_id
				order by tab_id
		loop
			perform alterTableRestore(v_tab_row.tab_id);
		end loop;
	end if;

	-- On the new origin, raise an event - ACCEPT_SET
	if v_local_node_id = p_new_origin then
		-- Create a SYNC event as well so that the ACCEPT_SET has
		-- the same snapshot as the last SYNC generated by the new
		-- origin. This snapshot will be used by other nodes to
		-- finalize the setsync status.
		perform createEvent(&#39;_schemadoc&#39;, &#39;SYNC&#39;, NULL);
		perform createEvent(&#39;_schemadoc&#39;, &#39;ACCEPT_SET&#39;, 
			p_set_id::text, p_old_origin::text, 
			p_new_origin::text, p_wait_seqno::text);
	end if;

	-- ----
	-- Next we have to reverse the subscription path
	-- ----
	v_sub_last = p_new_origin;
	select sub_provider into v_sub_node
			from sl_subscribe
			where sub_set = p_set_id
			and sub_receiver = p_new_origin;
	if not found then
		raise exception &#39;Slony-I: subscription path broken in moveSet_int&#39;;
	end if;
	while v_sub_node &lt;&gt; p_old_origin loop
		-- ----
		-- Tracing node by node, the old receiver is now in
		-- v_sub_last and the old provider is in v_sub_node.
		-- ----

		-- ----
		-- Get the current provider of this node as next
		-- and change the provider to the previous one in
		-- the reverse chain.
		-- ----
		select sub_provider into v_sub_next
				from sl_subscribe
				where sub_set = p_set_id
					and sub_receiver = v_sub_node
				for update;
		if not found then
			raise exception &#39;Slony-I: subscription path broken in moveSet_int&#39;;
		end if;
		update sl_subscribe
				set sub_provider = v_sub_last
				where sub_set = p_set_id
					and sub_receiver = v_sub_node;

		v_sub_last = v_sub_node;
		v_sub_node = v_sub_next;
	end loop;

	-- ----
	-- This includes creating a subscription for the old origin
	-- ----
	insert into sl_subscribe
			(sub_set, sub_provider, sub_receiver,
			sub_forward, sub_active)
			values (p_set_id, v_sub_last, p_old_origin, true, true);
	if v_local_node_id = p_old_origin then
		select coalesce(max(ev_seqno), 0) into v_last_sync 
				from sl_event
				where ev_origin = p_new_origin
					and ev_type = &#39;SYNC&#39;;
		if v_last_sync &gt; 0 then
			insert into sl_setsync
					(ssy_setid, ssy_origin, ssy_seqno,
					ssy_minxid, ssy_maxxid, ssy_xip, ssy_action_list)
					select p_set_id, p_new_origin, v_last_sync,
					ev_minxid, ev_maxxid, ev_xip, NULL
					from sl_event
					where ev_origin = p_new_origin
						and ev_seqno = v_last_sync;
		else
			insert into sl_setsync
					(ssy_setid, ssy_origin, ssy_seqno,
					ssy_minxid, ssy_maxxid, ssy_xip, ssy_action_list)
					values (p_set_id, p_new_origin, &#39;0&#39;,
					&#39;0&#39;, &#39;0&#39;, &#39;&#39;, NULL);
		end if;
	end if;

	-- ----
	-- Now change the ownership of the set.
	-- ----
	update sl_set
			set set_origin = p_new_origin
			where set_id = p_set_id;

	-- ----
	-- On the new origin, delete the obsolete setsync information
	-- and the subscription.
	-- ----
	if v_local_node_id = p_new_origin then
		delete from sl_setsync
				where ssy_setid = p_set_id;
	else
		if v_local_node_id &lt;&gt; p_old_origin then
			--
			-- On every other node, change the setsync so that it will
			-- pick up from the new origins last known sync.
			--
			delete from sl_setsync
					where ssy_setid = p_set_id;
			select coalesce(max(ev_seqno), 0) into v_last_sync
					from sl_event
					where ev_origin = p_new_origin
						and ev_type = &#39;SYNC&#39;;
			if v_last_sync &gt; 0 then
				insert into sl_setsync
						(ssy_setid, ssy_origin, ssy_seqno,
						ssy_minxid, ssy_maxxid, ssy_xip, ssy_action_list)
						select p_set_id, p_new_origin, v_last_sync,
						ev_minxid, ev_maxxid, ev_xip, NULL
						from sl_event
						where ev_origin = p_new_origin
							and ev_seqno = v_last_sync;
			else
				insert into sl_setsync
						(ssy_setid, ssy_origin, ssy_seqno,
						ssy_minxid, ssy_maxxid, ssy_xip, ssy_action_list)
						values (p_set_id, p_new_origin, &#39;0&#39;,
						&#39;0&#39;, &#39;0&#39;, &#39;&#39;, NULL);
			end if;
		end if;
	end if;
	delete from sl_subscribe
			where sub_set = p_set_id
			and sub_receiver = p_new_origin;

	-- Regenerate sl_listen since we revised the subscriptions
	perform RebuildListenEntries();

	-- Run addPartialLogIndices() to try to add indices to unused sl_log_? table
	perform addPartialLogIndices();

	-- ----
	-- If we are the new or old origin, we have to
	-- put all the tables into altered state again.
	-- ----
	if v_local_node_id = p_old_origin or v_local_node_id = p_new_origin then
		for v_tab_row in select tab_id from sl_table
				where tab_set = p_set_id
				order by tab_id
		loop
			perform alterTableForReplication(v_tab_row.tab_id);
		end loop;
	end if;

	return p_set_id;
end;</programlisting>
</para>

</section>

<!-- Function reachablefromnode( integer, integer[] ) -->
<section id="function.reachablefromnode-integer-integerARRAY"
  xreflabel="schemadocreachablefromnode( integer, integer[] )">
<title id="function.reachablefromnode-integer-integerARRAY-title">
  reachablefromnode( integer, integer[] )
</title>
<titleabbrev> id="function.reachablefromnode-integer-integerARRAY-titleabbrev">
  reachablefromnode( integer, integer[] )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>SET OF integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Trouve tous les n&oelig;uds dont &lt;receiver&gt; peut recevoir des événements
  sans utiliser les n&oelig;uds dans &lt;blacklist&gt; comme relai.
  
  <programlisting>declare
	v_node alias for $1 ;
	v_blacklist alias for $2 ;
	v_ignore int4[] ;
	v_reachable_edge_last int4[] ;
	v_reachable_edge_new int4[] default &#39;{}&#39; ;
	v_server record ;
begin
	v_reachable_edge_last := array[v_node] ;
	v_ignore := v_blacklist || array[v_node] ;
	return next v_node ;
	while v_reachable_edge_last != &#39;{}&#39; loop
		v_reachable_edge_new := &#39;{}&#39; ;
		for v_server in select pa_server as no_id
			from sl_path
			where pa_client = ANY(v_reachable_edge_last) and pa_server != ALL(v_ignore)
		loop
			if v_server.no_id != ALL(v_ignore) then
				v_ignore := v_ignore || array[v_server.no_id] ;
				v_reachable_edge_new := v_reachable_edge_new || array[v_server.no_id] ;
				return next v_server.no_id ;
			end if ;
		end loop ;
		v_reachable_edge_last := v_reachable_edge_new ;
	end loop ;
	return ;
end ;</programlisting>
</para>

</section>

<!-- Function rebuildlistenentries(  ) -->
<section id="function.rebuildlistenentries"
  xreflabel="schemadocrebuildlistenentries(  )">
<title id="function.rebuildlistenentries-title">
  rebuildlistenentries(  )
</title>
<titleabbrev> id="function.rebuildlistenentries-titleabbrev">
  rebuildlistenentries(  )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Appelé par différentes fonctions de modification de l'abonnement et des chemins,
  cette fonction réécrit les entrées sl_listen, ajoutant toutes celles qui
  nécessitent l'autorisation des communications entre les n&oelig;uds du cluster
  Slony-I.
  
  <programlisting>declare
	v_row	record;
	skip    boolean;
begin
	-- First remove the entire configuration
	delete from sl_listen;

	-- Second populate the sl_listen configuration with a full
	-- network of all possible paths.
	insert into sl_listen
				(li_origin, li_provider, li_receiver)
			select pa_server, pa_server, pa_client from sl_path;
	while true loop
		insert into sl_listen
					(li_origin, li_provider, li_receiver)
			select distinct li_origin, pa_server, pa_client
				from sl_listen, sl_path
				where li_receiver = pa_server
				  and li_origin &lt;&gt; pa_client
			except
			select li_origin, li_provider, li_receiver
				from sl_listen;

		if not found then
			exit;
		end if;
	end loop;

	-- We now replace specific event-origin,receiver combinations
	-- with a configuration that tries to avoid events arriving at
	-- a node before the data provider actually has the data ready.

	-- Loop over every possible pair of receiver and event origin
	for v_row in select N1.no_id as receiver, N2.no_id as origin
			from sl_node as N1, sl_node as N2
			where N1.no_id &lt;&gt; N2.no_id
	loop
		skip := &#39;f&#39;;
		-- 1st choice:
		-- If we use the event origin as a data provider for any
		-- set that originates on that very node, we are a direct
		-- subscriber to that origin and listen there only.
		if exists (select true from sl_set, sl_subscribe
				where set_origin = v_row.origin
				  and sub_set = set_id
				  and sub_provider = v_row.origin
				  and sub_receiver = v_row.receiver
				  and sub_active)
		then
			delete from sl_listen
				where li_origin = v_row.origin
				  and li_receiver = v_row.receiver;
			insert into sl_listen (li_origin, li_provider, li_receiver)
				values (v_row.origin, v_row.origin, v_row.receiver);
			skip := &#39;t&#39;;
		end if;

		if skip then
			skip := &#39;f&#39;;
		else
		-- 2nd choice:
		-- If we are subscribed to any set originating on this
		-- event origin, we want to listen on all data providers
		-- we use for this origin. We are a cascaded subscriber
		-- for sets from this node.
			if exists (select true from sl_set, sl_subscribe
						where set_origin = v_row.origin
						  and sub_set = set_id
						  and sub_receiver = v_row.receiver
						  and sub_active)
			then
				delete from sl_listen
					where li_origin = v_row.origin
					  and li_receiver = v_row.receiver;
				insert into sl_listen (li_origin, li_provider, li_receiver)
					select distinct set_origin, sub_provider, v_row.receiver
						from sl_set, sl_subscribe
						where set_origin = v_row.origin
						  and sub_set = set_id
						  and sub_receiver = v_row.receiver
						  and sub_active;
			end if;
		end if;

	end loop ;

	return null ;
end ;</programlisting>
</para>

</section>

<!-- Function registernodeconnection( integer ) -->
<section id="function.registernodeconnection-integer"
  xreflabel="schemadocregisternodeconnection( integer )">
<title id="function.registernodeconnection-integer-title">
  registernodeconnection( integer )
</title>
<titleabbrev> id="function.registernodeconnection-integer-titleabbrev">
  registernodeconnection( integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Enregistre (de façon unique) la connexion du n&oelig;ud de façon à ce qu'un
  slon puisse travailler sur le n&oelig;ud.
  
  <programlisting>declare
	p_nodeid	alias for $1;
begin
	insert into sl_nodelock
		(nl_nodeid, nl_backendpid)
		values
		(p_nodeid, pg_backend_pid());

	return 0;
end;</programlisting>
</para>

</section>

<!-- Function registry_get_int4( text, integer ) -->
<section id="function.registry-get-int4-text-integer"
  xreflabel="schemadocregistry_get_int4( text, integer )">
<title id="function.registry-get-int4-text-integer-title">
  registry_get_int4( text, integer )
</title>
<titleabbrev> id="function.registry-get-int4-text-integer-titleabbrev">
  registry_get_int4( text, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>

  Récupère une valeur du registre. Si la clé est absente, initialise et renvoie
  la valeur par défaut.
  
  <programlisting>DECLARE
	p_key		alias for $1;
	p_default	alias for $2;
	v_value		int4;
BEGIN
	select reg_int4 into v_value from sl_registry
			where reg_key = p_key;
	if not found then 
		v_value = p_default;
		if p_default notnull then
			perform registry_set_int4(p_key, p_default);
		end if;
	else
		if v_value is null then
			raise exception &#39;Slony-I: registry key % is not an int4 value&#39;,
					p_key;
		end if;
	end if;
	return v_value;
END;</programlisting>
</para>

</section>

<!-- Function registry_get_text( text, text ) -->
<section id="function.registry-get-text-text-text"
  xreflabel="schemadocregistry_get_text( text, text )">
<title id="function.registry-get-text-text-text-title">
  registry_get_text( text, text )
</title>
<titleabbrev> id="function.registry-get-text-text-text-titleabbrev">
  registry_get_text( text, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>text</seg>
    </seglistitem>
  </segmentedlist>
  
  Récupère une valeur du registre. Si la clé est absente, initialise et renvoie
  la valeur par défaut.
  
  <programlisting>DECLARE
	p_key		alias for $1;
	p_default	alias for $2;
	v_value		text;
BEGIN
	select reg_text into v_value from sl_registry
			where reg_key = p_key;
	if not found then 
		v_value = p_default;
		if p_default notnull then
			perform registry_set_text(p_key, p_default);
		end if;
	else
		if v_value is null then
			raise exception &#39;Slony-I: registry key % is not a text value&#39;,
					p_key;
		end if;
	end if;
	return v_value;
END;</programlisting>
</para>

</section>

<!-- Function registry_get_timestamp( text, timestamp without time zone ) -->
<section id="function.registry-get-timestamp-text-timestamp-without-time-zone"
  xreflabel="schemadocregistry_get_timestamp( text, timestamp without time zone )">
<title id="function.registry-get-timestamp-text-timestamp-without-time-zone-title">
  registry_get_timestamp( text, timestamp without time zone )
</title>
<titleabbrev> id="function.registry-get-timestamp-text-timestamp-without-time-zone-titleabbrev">
  registry_get_timestamp( text, timestamp without time zone )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>timestamp without time zone</seg>
    </seglistitem>
  </segmentedlist>
  
  Récupère une valeur du registre. Si la clé est absente, initialise et renvoie
  la valeur par défaut.
  
  <programlisting>DECLARE
	p_key		alias for $1;
	p_default	alias for $2;
	v_value		timestamp;
BEGIN
	select reg_timestamp into v_value from sl_registry
			where reg_key = p_key;
	if not found then 
		v_value = p_default;
		if p_default notnull then
			perform registry_set_timestamp(p_key, p_default);
		end if;
	else
		if v_value is null then
			raise exception &#39;Slony-I: registry key % is not an timestamp value&#39;,
					p_key;
		end if;
	end if;
	return v_value;
END;</programlisting>
</para>

</section>

<!-- Function registry_set_int4( text, integer ) -->
<section id="function.registry-set-int4-text-integer"
  xreflabel="schemadocregistry_set_int4( text, integer )">
<title id="function.registry-set-int4-text-integer-title">
  registry_set_int4( text, integer )
</title>
<titleabbrev> id="function.registry-set-int4-text-integer-titleabbrev">
  registry_set_int4( text, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>

  Configure ou supprime une valeur du registre.
  
  <programlisting>DECLARE
	p_key		alias for $1;
	p_value		alias for $2;
BEGIN
	if p_value is null then
		delete from sl_registry
				where reg_key = p_key;
	else
		lock table sl_registry;
		update sl_registry
				set reg_int4 = p_value
				where reg_key = p_key;
		if not found then
			insert into sl_registry (reg_key, reg_int4)
					values (p_key, p_value);
		end if;
	end if;
	return p_value;
END;</programlisting>
</para>

</section>

<!-- Function registry_set_text( text, text ) -->
<section id="function.registry-set-text-text-text"
  xreflabel="schemadocregistry_set_text( text, text )">
<title id="function.registry-set-text-text-text-title">
  registry_set_text( text, text )
</title>
<titleabbrev> id="function.registry-set-text-text-text-titleabbrev">
  registry_set_text( text, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>text</seg>
    </seglistitem>
  </segmentedlist>
  
  Configure ou supprime une valeur du registre.
  
  <programlisting>DECLARE
	p_key		alias for $1;
	p_value		alias for $2;
BEGIN
	if p_value is null then
		delete from sl_registry
				where reg_key = p_key;
	else
		lock table sl_registry;
		update sl_registry
				set reg_text = p_value
				where reg_key = p_key;
		if not found then
			insert into sl_registry (reg_key, reg_text)
					values (p_key, p_value);
		end if;
	end if;
	return p_value;
END;</programlisting>
</para>

</section>

<!-- Function registry_set_timestamp( text, timestamp without time zone ) -->
<section id="function.registry-set-timestamp-text-timestamp-without-time-zone"
  xreflabel="schemadocregistry_set_timestamp( text, timestamp without time zone )">
<title id="function.registry-set-timestamp-text-timestamp-without-time-zone-title">
  registry_set_timestamp( text, timestamp without time zone )
</title>
<titleabbrev> id="function.registry-set-timestamp-text-timestamp-without-time-zone-titleabbrev">
  registry_set_timestamp( text, timestamp without time zone )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>timestamp without time zone</seg>
    </seglistitem>
  </segmentedlist>
  
  Configure ou supprime une valeur du registre.
  
  <programlisting>DECLARE
	p_key		alias for $1;
	p_value		alias for $2;
BEGIN
	if p_value is null then
		delete from sl_registry
				where reg_key = p_key;
	else
		lock table sl_registry;
		update sl_registry
				set reg_timestamp = p_value
				where reg_key = p_key;
		if not found then
			insert into sl_registry (reg_key, reg_timestamp)
					values (p_key, p_value);
		end if;
	end if;
	return p_value;
END;</programlisting>
</para>

</section>

<!-- Function replicate_partition( integer, text, text, text, text ) -->
<section id="function.replicate-partition-integer-text-text-text-text"
  xreflabel="schemadocreplicate_partition( integer, text, text, text, text )">
<title id="function.replicate-partition-integer-text-text-text-text-title">
  replicate_partition( integer, text, text, text, text )
</title>
<titleabbrev> id="function.replicate-partition-integer-text-text-text-text-titleabbrev">
  replicate_partition( integer, text, text, text, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
  
  Ajoute une table partitionnée à la réplication.
  
  tab_idxname est optionel. Si la valeur est NULL, la clé primaire est utilisée.
  Cette fonction recherche la configuration de la réplication via la table
  parente.
  
  <programlisting>declare
  p_tab_id alias for $1;
  p_nspname alias for $2;
  p_tabname alias for $3;
  p_idxname alias for $4;
  p_comment alias for $5;

  prec record;
  prec2 record;
  v_set_id int4;

begin
-- Look up the parent table; fail if it does not exist
   select c1.oid into prec from pg_catalog.pg_class c1, pg_catalog.pg_class c2, pg_catalog.pg_inherits i, pg_catalog.pg_namespace n where c1.oid = i.inhparent  and c2.oid = i.inhrelid and n.oid = c2.relnamespace and n.nspname = p_nspname and c2.relname = p_tabname;
   if not found then
	raise exception &#39;replicate_partition: No parent table found for %.%!&#39;, p_nspname, p_tabname;
   end if;

-- The parent table tells us what replication set to use
   select tab_set into prec2 from sl_table where tab_reloid = prec.oid;
   if not found then
	raise exception &#39;replicate_partition: Parent table % for new partition %.% is not replicated!&#39;, prec.oid, p_nspname, p_tabname;
   end if;

   v_set_id := prec2.tab_set;

-- Now, we have all the parameters necessary to run add_empty_table_to_replication...
   return add_empty_table_to_replication(v_set_id, p_tab_id, p_nspname, p_tabname, p_idxname, p_comment);
end</programlisting>
</para>

</section>

<!-- Function sequencelastvalue( text ) -->
<section id="function.sequencelastvalue-text"
  xreflabel="schemadocsequencelastvalue( text )">
<title id="function.sequencelastvalue-text-title">
  sequencelastvalue( text )
</title>
<titleabbrev> id="function.sequencelastvalue-text-titleabbrev">
  sequencelastvalue( text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
  
  Outil utilisé dans la vue sl_seqlastvalue pour obtenir la dernière valeur
  de la séquence demandée.
  
  <programlisting>declare
	p_seqname	alias for $1;
	v_seq_row	record;
begin
	for v_seq_row in execute &#39;select last_value from &#39; || slon_quote_input(p_seqname)
	loop
		return v_seq_row.last_value;
	end loop;

	-- not reached
end;</programlisting>
</para>

</section>

<!-- Function sequencesetvalue( integer, integer, bigint, bigint ) -->
<section id="function.sequencesetvalue-integer-integer-bigint-bigint"
  xreflabel="schemadocsequencesetvalue( integer, integer, bigint, bigint )">
<title id="function.sequencesetvalue-integer-integer-bigint-bigint-title">
  sequencesetvalue( integer, integer, bigint, bigint )
</title>
<titleabbrev> id="function.sequencesetvalue-integer-integer-bigint-bigint-titleabbrev">
  sequencesetvalue( integer, integer, bigint, bigint )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Initialise la nouvelle valeur last_value pourla séquence seq_id.

  <programlisting>declare
	p_seq_id			alias for $1;
	p_seq_origin		alias for $2;
	p_ev_seqno			alias for $3;
	p_last_value		alias for $4;
	v_fqname			text;
begin
	-- ----
	-- Get the sequences fully qualified name
	-- ----
	select slon_quote_brute(PGN.nspname) || &#39;.&#39; ||
			slon_quote_brute(PGC.relname) into v_fqname
		from sl_sequence SQ,
			&quot;pg_catalog&quot;.pg_class PGC, &quot;pg_catalog&quot;.pg_namespace PGN
		where SQ.seq_id = p_seq_id
			and SQ.seq_reloid = PGC.oid
			and PGC.relnamespace = PGN.oid;
	if not found then
		raise exception &#39;Slony-I: sequenceSetValue(): sequence % not found&#39;, p_seq_id;
	end if;

	-- ----
	-- Update it to the new value
	-- ----
	execute &#39;select setval(&#39;&#39;&#39; || v_fqname ||
			&#39;&#39;&#39;, &#39;&#39;&#39; || p_last_value || &#39;&#39;&#39;)&#39;;

	insert into sl_seqlog
			(seql_seqid, seql_origin, seql_ev_seqno, seql_last_value)
			values (p_seq_id, p_seq_origin, p_ev_seqno, p_last_value);

	return p_seq_id;
end;</programlisting>
</para>

</section>

<!-- Function setaddsequence( integer, integer, text, text ) -->
<section id="function.setaddsequence-integer-integer-text-text"
  xreflabel="schemadocsetaddsequence( integer, integer, text, text )">
<title id="function.setaddsequence-integer-integer-text-text-title">
  setaddsequence( integer, integer, text, text )
</title>
<titleabbrev> id="function.setaddsequence-integer-integer-text-text-titleabbrev">
  setaddsequence( integer, integer, text, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
  
  Sur le n&oelig;ud origine pour l'ensemble set_id, ajoute la séquence
  seq_fqname à l'ensemble de réplication, et ajoute l'événement
  SET_ADD_SEQUENCE pour répliquer cet événement sur les n&oelig;uds
  abonnés.
  
  <programlisting>declare
	p_set_id			alias for $1;
	p_seq_id			alias for $2;
	p_fqname			alias for $3;
	p_seq_comment		alias for $4;
	v_set_origin		int4;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Check that we are the origin of the set
	-- ----
	select set_origin into v_set_origin
			from sl_set
			where set_id = p_set_id;
	if not found then
		raise exception &#39;Slony-I: setAddSequence(): set % not found&#39;, p_set_id;
	end if;
	if v_set_origin != getLocalNodeId(&#39;_schemadoc&#39;) then
		raise exception &#39;Slony-I: setAddSequence(): set % has remote origin - submit to origin node&#39;, p_set_id;
	end if;

	if exists (select true from sl_subscribe
			where sub_set = p_set_id)
	then
		raise exception &#39;Slony-I: cannot add sequence to currently subscribed set %&#39;,
				p_set_id;
	end if;

	-- ----
	-- Add the sequence to the set and generate the SET_ADD_SEQUENCE event
	-- ----
	perform setAddSequence_int(p_set_id, p_seq_id, p_fqname,
			p_seq_comment);
	return  createEvent(&#39;_schemadoc&#39;, &#39;SET_ADD_SEQUENCE&#39;,
						p_set_id::text, p_seq_id::text, 
						p_fqname::text, p_seq_comment::text);
end;</programlisting>
</para>

</section>

<!-- Function setaddsequence_int( integer, integer, text, text ) -->
<section id="function.setaddsequence-int-integer-integer-text-text"
  xreflabel="schemadocsetaddsequence_int( integer, integer, text, text )">
<title id="function.setaddsequence-int-integer-integer-text-text-title">
  setaddsequence_int( integer, integer, text, text )
</title>
<titleabbrev> id="function.setaddsequence-int-integer-integer-text-text-titleabbrev">
  setaddsequence_int( integer, integer, text, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Ceci traite l'événement SET_ADD_SEQUENCE. Sur les n&oelig;uds distants,
  la fonction ajoute la séquence à l'ensemble de réplication.
  
  <programlisting>declare
	p_set_id			alias for $1;
	p_seq_id			alias for $2;
	p_fqname			alias for $3;
	p_seq_comment		alias for $4;
	v_local_node_id		int4;
	v_set_origin		int4;
	v_sub_provider		int4;
	v_relkind			char;
	v_seq_reloid		oid;
	v_seq_relname		name;
	v_seq_nspname		name;
	v_sync_row			record;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- For sets with a remote origin, check that we are subscribed 
	-- to that set. Otherwise we ignore the sequence because it might 
	-- not even exist in our database.
	-- ----
	v_local_node_id := getLocalNodeId(&#39;_schemadoc&#39;);
	select set_origin into v_set_origin
			from sl_set
			where set_id = p_set_id;
	if not found then
		raise exception &#39;Slony-I: setAddSequence_int(): set % not found&#39;,
				p_set_id;
	end if;
	if v_set_origin != v_local_node_id then
		select sub_provider into v_sub_provider
				from sl_subscribe
				where sub_set = p_set_id
				and sub_receiver = getLocalNodeId(&#39;_schemadoc&#39;);
		if not found then
			return 0;
		end if;
	end if;
	
	-- ----
	-- Get the sequences OID and check that it is a sequence
	-- ----
	select PGC.oid, PGC.relkind, PGC.relname, PGN.nspname 
		into v_seq_reloid, v_relkind, v_seq_relname, v_seq_nspname
			from &quot;pg_catalog&quot;.pg_class PGC, &quot;pg_catalog&quot;.pg_namespace PGN
			where PGC.relnamespace = PGN.oid
			and slon_quote_input(p_fqname) = slon_quote_brute(PGN.nspname) ||
					&#39;.&#39; || slon_quote_brute(PGC.relname);
	if not found then
		raise exception &#39;Slony-I: setAddSequence_int(): sequence % not found&#39;, 
				p_fqname;
	end if;
	if v_relkind != &#39;S&#39; then
		raise exception &#39;Slony-I: setAddSequence_int(): % is not a sequence&#39;,
				p_fqname;
	end if;

        select 1 into v_sync_row from sl_sequence where seq_id = p_seq_id;
	if not found then
               v_relkind := &#39;o&#39;;   -- all is OK
        else
                raise exception &#39;Slony-I: setAddSequence_int(): sequence ID % has already been assigned&#39;, p_seq_id;
        end if;

	-- ----
	-- Add the sequence to sl_sequence
	-- ----
	insert into sl_sequence
		(seq_id, seq_reloid, seq_relname, seq_nspname, seq_set, seq_comment) 
		values
		(p_seq_id, v_seq_reloid, v_seq_relname, v_seq_nspname,  p_set_id, p_seq_comment);

	-- ----
	-- On the set origin, fake a sl_seqlog row for the last sync event
	-- ----
	if v_set_origin = v_local_node_id then
		for v_sync_row in select coalesce (max(ev_seqno), 0) as ev_seqno
				from sl_event
				where ev_origin = v_local_node_id
					and ev_type = &#39;SYNC&#39;
		loop
			insert into sl_seqlog
					(seql_seqid, seql_origin, seql_ev_seqno, 
					seql_last_value) values
					(p_seq_id, v_local_node_id, v_sync_row.ev_seqno,
					sequenceLastValue(p_fqname));
		end loop;
	end if;

	return p_seq_id;
end;</programlisting>
</para>

</section>

<!-- Function setaddtable( integer, integer, text, name, text ) -->
<section id="function.setaddtable-integer-integer-text-name-text"
  xreflabel="schemadocsetaddtable( integer, integer, text, name, text )">
<title id="function.setaddtable-integer-integer-text-name-text-title">
  setaddtable( integer, integer, text, name, text )
</title>
<titleabbrev> id="function.setaddtable-integer-integer-text-name-text-titleabbrev">
  setaddtable( integer, integer, text, name, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
  
  Ajoute la table tab_fqname à l'ensemble de réplication sur le n&oelig;ud
  origine, et génère l'événement SET_ADD_TABLE pour permettre à ceci de se
  propager aux autres n&oelig;uds.

  Notez que l'identifiant de la table, tab_id, doit être unique PARMI TOUS
  LES ENSEMBLES.
  
  <programlisting>declare
	p_set_id			alias for $1;
	p_tab_id			alias for $2;
	p_fqname			alias for $3;
	p_tab_idxname		alias for $4;
	p_tab_comment		alias for $5;
	v_set_origin		int4;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Check that we are the origin of the set
	-- ----
	select set_origin into v_set_origin
			from sl_set
			where set_id = p_set_id;
	if not found then
		raise exception &#39;Slony-I: setAddTable(): set % not found&#39;, p_set_id;
	end if;
	if v_set_origin != getLocalNodeId(&#39;_schemadoc&#39;) then
		raise exception &#39;Slony-I: setAddTable(): set % has remote origin&#39;, p_set_id;
	end if;

	if exists (select true from sl_subscribe
			where sub_set = p_set_id)
	then
		raise exception &#39;Slony-I: cannot add table to currently subscribed set %&#39;,
				p_set_id;
	end if;

	-- ----
	-- Add the table to the set and generate the SET_ADD_TABLE event
	-- ----
	perform setAddTable_int(p_set_id, p_tab_id, p_fqname,
			p_tab_idxname, p_tab_comment);
	return  createEvent(&#39;_schemadoc&#39;, &#39;SET_ADD_TABLE&#39;,
			p_set_id::text, p_tab_id::text, p_fqname::text,
			p_tab_idxname::text, p_tab_comment::text);
end;</programlisting>
</para>

</section>

<!-- Function setaddtable_int( integer, integer, text, name, text ) -->
<section id="function.setaddtable-int-integer-integer-text-name-text"
  xreflabel="schemadocsetaddtable_int( integer, integer, text, name, text )">
<title id="function.setaddtable-int-integer-integer-text-name-text-title">
  setaddtable_int( integer, integer, text, name, text )
</title>
<titleabbrev> id="function.setaddtable-int-integer-integer-text-name-text-titleabbrev">
  setaddtable_int( integer, integer, text, name, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  setAddTable_int (set_id, tab_id, tab_fqname, tab_idxname, tab_comment)

  Cette fonction traite l'événement SET_ADD_TABLE sur les n&oelig;uds distants,
  ajouter une table à la réplication si le n&oelig;ud distant est abonné à
  l'ensemble de réplication.
  
  <programlisting>declare

	p_set_id		alias for $1;
	p_tab_id		alias for $2;
	p_fqname		alias for $3;
	p_tab_idxname		alias for $4;
	p_tab_comment		alias for $5;
	v_tab_relname		name;
	v_tab_nspname		name;
	v_local_node_id		int4;
	v_set_origin		int4;
	v_sub_provider		int4;
	v_relkind		char;
	v_tab_reloid		oid;
	v_pkcand_nn		boolean;
	v_prec			record;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- For sets with a remote origin, check that we are subscribed 
	-- to that set. Otherwise we ignore the table because it might 
	-- not even exist in our database.
	-- ----
	v_local_node_id := getLocalNodeId(&#39;_schemadoc&#39;);
	select set_origin into v_set_origin
			from sl_set
			where set_id = p_set_id;
	if not found then
		raise exception &#39;Slony-I: setAddTable_int(): set % not found&#39;,
				p_set_id;
	end if;
	if v_set_origin != v_local_node_id then
		select sub_provider into v_sub_provider
				from sl_subscribe
				where sub_set = p_set_id
				and sub_receiver = getLocalNodeId(&#39;_schemadoc&#39;);
		if not found then
			return 0;
		end if;
	end if;
	
	-- ----
	-- Get the tables OID and check that it is a real table
	-- ----
	select PGC.oid, PGC.relkind, PGC.relname, PGN.nspname into v_tab_reloid, v_relkind, v_tab_relname, v_tab_nspname
			from &quot;pg_catalog&quot;.pg_class PGC, &quot;pg_catalog&quot;.pg_namespace PGN
			where PGC.relnamespace = PGN.oid
			and slon_quote_input(p_fqname) = slon_quote_brute(PGN.nspname) ||
					&#39;.&#39; || slon_quote_brute(PGC.relname);
	if not found then
		raise exception &#39;Slony-I: setAddTable_int(): table % not found&#39;, 
				p_fqname;
	end if;
	if v_relkind != &#39;r&#39; then
		raise exception &#39;Slony-I: setAddTable_int(): % is not a regular table&#39;,
				p_fqname;
	end if;

	if not exists (select indexrelid
			from &quot;pg_catalog&quot;.pg_index PGX, &quot;pg_catalog&quot;.pg_class PGC
			where PGX.indrelid = v_tab_reloid
				and PGX.indexrelid = PGC.oid
				and PGC.relname = p_tab_idxname)
	then
		raise exception &#39;Slony-I: setAddTable_int(): table % has no index %&#39;,
				p_fqname, p_tab_idxname;
	end if;

	-- ----
	-- Verify that the columns in the PK (or candidate) are not NULLABLE
	-- ----

	v_pkcand_nn := &#39;f&#39;;
	for v_prec in select attname from &quot;pg_catalog&quot;.pg_attribute where attrelid = 
                        (select oid from &quot;pg_catalog&quot;.pg_class where oid = v_tab_reloid) 
                    and attname in (select attname from &quot;pg_catalog&quot;.pg_attribute where 
                                    attrelid = (select oid from &quot;pg_catalog&quot;.pg_class PGC, 
                                    &quot;pg_catalog&quot;.pg_index PGX where 
                                    PGC.relname = p_tab_idxname and PGX.indexrelid=PGC.oid and
                                    PGX.indrelid = v_tab_reloid)) and attnotnull &lt;&gt; &#39;t&#39;
	loop
		raise notice &#39;Slony-I: setAddTable_int: table % PK column % nullable&#39;, p_fqname, v_prec.attname;
		v_pkcand_nn := &#39;t&#39;;
	end loop;
	if v_pkcand_nn then
		raise exception &#39;Slony-I: setAddTable_int: table % not replicable!&#39;, p_fqname;
	end if;

	select * into v_prec from sl_table where tab_id = p_tab_id;
	if not found then
		v_pkcand_nn := &#39;t&#39;;  -- No-op -- All is well
	else
		raise exception &#39;Slony-I: setAddTable_int: table id % has already been assigned!&#39;, p_tab_id;
	end if;

	-- ----
	-- Add the table to sl_table and create the trigger on it.
	-- ----
	insert into sl_table
			(tab_id, tab_reloid, tab_relname, tab_nspname, 
			tab_set, tab_idxname, tab_altered, tab_comment) 
			values
			(p_tab_id, v_tab_reloid, v_tab_relname, v_tab_nspname,
			p_set_id, p_tab_idxname, false, p_tab_comment);
	perform alterTableForReplication(p_tab_id);

	return p_tab_id;
end;</programlisting>
</para>

</section>

<!-- Function setdropsequence( integer ) -->
<section id="function.setdropsequence-integer"
  xreflabel="schemadocsetdropsequence( integer )">
<title id="function.setdropsequence-integer-title">
  setdropsequence( integer )
</title>
<titleabbrev> id="function.setdropsequence-integer-titleabbrev">
  setdropsequence( integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
  
  Sur le n&oelig;ud origine pour l'ensemble, supprime la séquence seq_id de
  l'ensemble de réplication, puis ajoute l'événement SET_DROP_SEQUENCE pour
  répliquer cette suppression sur les n&oelig;uds abonnés.
  
  <programlisting>declare
	p_seq_id		alias for $1;
	v_set_id		int4;
	v_set_origin		int4;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Determine set id for this sequence
	-- ----
	select seq_set into v_set_id from sl_sequence where seq_id = p_seq_id;

	-- ----
	-- Ensure sequence exists
	-- ----
	if not found then
		raise exception &#39;Slony-I: setDropSequence_int(): sequence % not found&#39;,
			p_seq_id;
	end if;

	-- ----
	-- Check that we are the origin of the set
	-- ----
	select set_origin into v_set_origin
			from sl_set
			where set_id = v_set_id;
	if not found then
		raise exception &#39;Slony-I: setDropSequence(): set % not found&#39;, v_set_id;
	end if;
	if v_set_origin != getLocalNodeId(&#39;_schemadoc&#39;) then
		raise exception &#39;Slony-I: setDropSequence(): set % has origin at another node - submit this to that node&#39;, v_set_id;
	end if;

	-- ----
	-- Add the sequence to the set and generate the SET_ADD_SEQUENCE event
	-- ----
	perform setDropSequence_int(p_seq_id);
	return  createEvent(&#39;_schemadoc&#39;, &#39;SET_DROP_SEQUENCE&#39;,
			p_seq_id::text);
end;</programlisting>
</para>

</section>

<!-- Function setdropsequence_int( integer ) -->
<section id="function.setdropsequence-int-integer"
  xreflabel="schemadocsetdropsequence_int( integer )">
<title id="function.setdropsequence-int-integer-title">
  setdropsequence_int( integer )
</title>
<titleabbrev> id="function.setdropsequence-int-integer-titleabbrev">
  setdropsequence_int( integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Ceci traite l'événement SET_DROP_SEQUENCE. Sur les n&oelig;uds distants
  qui sont abonnés à l'ensemble contenant la séquence seq_id, supprime la
  séquence de l'ensemble de réplication.
  
  <programlisting>declare
	p_seq_id		alias for $1;
	v_set_id		int4;
	v_local_node_id		int4;
	v_set_origin		int4;
	v_sub_provider		int4;
	v_relkind			char;
	v_sync_row			record;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Determine set id for this sequence
	-- ----
	select seq_set into v_set_id from sl_sequence where seq_id = p_seq_id;

	-- ----
	-- Ensure sequence exists
	-- ----
	if not found then
		return 0;
	end if;

	-- ----
	-- For sets with a remote origin, check that we are subscribed 
	-- to that set. Otherwise we ignore the sequence because it might 
	-- not even exist in our database.
	-- ----
	v_local_node_id := getLocalNodeId(&#39;_schemadoc&#39;);
	select set_origin into v_set_origin
			from sl_set
			where set_id = v_set_id;
	if not found then
		raise exception &#39;Slony-I: setDropSequence_int(): set % not found&#39;,
				v_set_id;
	end if;
	if v_set_origin != v_local_node_id then
		select sub_provider into v_sub_provider
				from sl_subscribe
				where sub_set = v_set_id
				and sub_receiver = getLocalNodeId(&#39;_schemadoc&#39;);
		if not found then
			return 0;
		end if;
	end if;

	-- ----
	-- drop the sequence from sl_sequence, sl_seqlog
	-- ----
	delete from sl_seqlog where seql_seqid = p_seq_id;
	delete from sl_sequence where seq_id = p_seq_id;

	return p_seq_id;
end;</programlisting>
</para>

</section>

<!-- Function setdroptable( integer ) -->
<section id="function.setdroptable-integer"
  xreflabel="schemadocsetdroptable( integer )">
<title id="function.setdroptable-integer-title">
  setdroptable( integer )
</title>
<titleabbrev> id="function.setdroptable-integer-titleabbrev">
  setdroptable( integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>

  Supprime la table tab_id de l'ensemble sur le n&oelig;ud origine, et génère
  un événement SET_DROP_TABLE pour propager cette suppression aux autres
  n&oelig;uds.
  
  <programlisting>declare
	p_tab_id		alias for $1;
	v_set_id		int4;
	v_set_origin		int4;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

        -- ----
	-- Determine the set_id
        -- ----
	select tab_set into v_set_id from sl_table where tab_id = p_tab_id;

	-- ----
	-- Ensure table exists
	-- ----
	if not found then
		raise exception &#39;Slony-I: setDropTable_int(): table % not found&#39;,
			p_tab_id;
	end if;

	-- ----
	-- Check that we are the origin of the set
	-- ----
	select set_origin into v_set_origin
			from sl_set
			where set_id = v_set_id;
	if not found then
		raise exception &#39;Slony-I: setDropTable(): set % not found&#39;, v_set_id;
	end if;
	if v_set_origin != getLocalNodeId(&#39;_schemadoc&#39;) then
		raise exception &#39;Slony-I: setDropTable(): set % has remote origin&#39;, v_set_id;
	end if;

	-- ----
	-- Drop the table from the set and generate the SET_ADD_TABLE event
	-- ----
	perform setDropTable_int(p_tab_id);
	return  createEvent(&#39;_schemadoc&#39;, &#39;SET_DROP_TABLE&#39;, 
				p_tab_id::text);
end;</programlisting>
</para>

</section>

<!-- Function setdroptable_int( integer ) -->
<section id="function.setdroptable-int-integer"
  xreflabel="schemadocsetdroptable_int( integer )">
<title id="function.setdroptable-int-integer-title">
  setdroptable_int( integer )
</title>
<titleabbrev> id="function.setdroptable-int-integer-titleabbrev">
  setdroptable_int( integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Cette fonction traite l'événement SET_DROP_TABLE sur les n&oelig;uds distants.
  pour supprimer une table de la réplication si le n&oelig;ud distant est abonné
  à l'ensemble de réplication de la table.
  
  <programlisting>declare
	p_tab_id		alias for $1;
	v_set_id		int4;
	v_local_node_id		int4;
	v_set_origin		int4;
	v_sub_provider		int4;
	v_tab_reloid		oid;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

        -- ----
	-- Determine the set_id
        -- ----
	select tab_set into v_set_id from sl_table where tab_id = p_tab_id;

	-- ----
	-- Ensure table exists
	-- ----
	if not found then
		return 0;
	end if;

	-- ----
	-- For sets with a remote origin, check that we are subscribed 
	-- to that set. Otherwise we ignore the table because it might 
	-- not even exist in our database.
	-- ----
	v_local_node_id := getLocalNodeId(&#39;_schemadoc&#39;);
	select set_origin into v_set_origin
			from sl_set
			where set_id = v_set_id;
	if not found then
		raise exception &#39;Slony-I: setDropTable_int(): set % not found&#39;,
				v_set_id;
	end if;
	if v_set_origin != v_local_node_id then
		select sub_provider into v_sub_provider
				from sl_subscribe
				where sub_set = v_set_id
				and sub_receiver = getLocalNodeId(&#39;_schemadoc&#39;);
		if not found then
			return 0;
		end if;
	end if;
	
	-- ----
	-- Drop the table from sl_table and drop trigger from it.
	-- ----
	perform alterTableRestore(p_tab_id);
	perform tableDropKey(p_tab_id);
	delete from sl_table where tab_id = p_tab_id;
	return p_tab_id;
end;</programlisting>
</para>

</section>

<!-- Function setmovesequence( integer, integer ) -->
<section id="function.setmovesequence-integer-integer"
  xreflabel="schemadocsetmovesequence( integer, integer )">
<title id="function.setmovesequence-integer-integer-title">
  setmovesequence( integer, integer )
</title>
<titleabbrev> id="function.setmovesequence-integer-integer-titleabbrev">
  setmovesequence( integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
  
  Ceci génère l'événement SET_MOVE_SEQUENCE, après validation (notamment la
  configuration que les deux ensembles existent, sont distincts et ont
  exactement la même liste d'abonnés).
  
  <programlisting>declare
	p_seq_id			alias for $1;
	p_new_set_id		alias for $2;
	v_old_set_id		int4;
	v_origin			int4;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Get the sequences current set
	-- ----
	select seq_set into v_old_set_id from sl_sequence
			where seq_id = p_seq_id;
	if not found then
		raise exception &#39;Slony-I: setMoveSequence(): sequence %d not found&#39;, p_seq_id;
	end if;
	
	-- ----
	-- Check that both sets exist and originate here
	-- ----
	if p_new_set_id = v_old_set_id then
		raise exception &#39;Slony-I: setMoveSequence(): set ids cannot be identical&#39;;
	end if;
	select set_origin into v_origin from sl_set
			where set_id = p_new_set_id;
	if not found then
		raise exception &#39;Slony-I: setMoveSequence(): set % not found&#39;, p_new_set_id;
	end if;
	if v_origin != getLocalNodeId(&#39;_schemadoc&#39;) then
		raise exception &#39;Slony-I: setMoveSequence(): set % does not originate on local node&#39;,
				p_new_set_id;
	end if;

	select set_origin into v_origin from sl_set
			where set_id = v_old_set_id;
	if not found then
		raise exception &#39;Slony-I: set % not found&#39;, v_old_set_id;
	end if;
	if v_origin != getLocalNodeId(&#39;_schemadoc&#39;) then
		raise exception &#39;Slony-I: set % does not originate on local node&#39;,
				v_old_set_id;
	end if;

	-- ----
	-- Check that both sets are subscribed by the same set of nodes
	-- ----
	if exists (select true from sl_subscribe SUB1
				where SUB1.sub_set = p_new_set_id
				and SUB1.sub_receiver not in (select SUB2.sub_receiver
						from sl_subscribe SUB2
						where SUB2.sub_set = v_old_set_id))
	then
		raise exception &#39;Slony-I: subscriber lists of set % and % are different&#39;,
				p_new_set_id, v_old_set_id;
	end if;

	if exists (select true from sl_subscribe SUB1
				where SUB1.sub_set = v_old_set_id
				and SUB1.sub_receiver not in (select SUB2.sub_receiver
						from sl_subscribe SUB2
						where SUB2.sub_set = p_new_set_id))
	then
		raise exception &#39;Slony-I: subscriber lists of set % and % are different&#39;,
				v_old_set_id, p_new_set_id;
	end if;

	-- ----
	-- Change the set the sequence belongs to
	-- ----
	perform setMoveSequence_int(p_seq_id, p_new_set_id);
	return  createEvent(&#39;_schemadoc&#39;, &#39;SET_MOVE_SEQUENCE&#39;, 
			p_seq_id::text, p_new_set_id::text);
end;</programlisting>
</para>

</section>

<!-- Function setmovesequence_int( integer, integer ) -->
<section id="function.setmovesequence-int-integer-integer"
  xreflabel="schemadocsetmovesequence_int( integer, integer )">
<title id="function.setmovesequence-int-integer-integer-title">
  setmovesequence_int( integer, integer )
</title>
<titleabbrev> id="function.setmovesequence-int-integer-integer-titleabbrev">
  setmovesequence_int( integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Traite l'événement SET_MOVE_SEQUENCE, déplaçant une séquence vers un autre
  ensemble de réplication.
  
  <programlisting>declare
	p_seq_id			alias for $1;
	p_new_set_id		alias for $2;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;
	
	-- ----
	-- Move the sequence to the new set
	-- ----
	update sl_sequence
			set seq_set = p_new_set_id
			where seq_id = p_seq_id;

	return p_seq_id;
end;</programlisting>
</para>

</section>

<!-- Function setmovetable( integer, integer ) -->
<section id="function.setmovetable-integer-integer"
  xreflabel="schemadocsetmovetable( integer, integer )">
<title id="function.setmovetable-integer-integer-title">
  setmovetable( integer, integer )
</title>
<titleabbrev> id="function.setmovetable-integer-integer-titleabbrev">
  setmovetable( integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
  
  Cette fonction traite l'événement SET_MOVE_TABLE. La table est déplacée vers
  l'ensemble de destination.
  
  <programlisting>declare
	p_tab_id			alias for $1;
	p_new_set_id		alias for $2;
	v_old_set_id		int4;
	v_origin			int4;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Get the tables current set
	-- ----
	select tab_set into v_old_set_id from sl_table
			where tab_id = p_tab_id;
	if not found then
		raise exception &#39;Slony-I: table %d not found&#39;, p_tab_id;
	end if;
	
	-- ----
	-- Check that both sets exist and originate here
	-- ----
	if p_new_set_id = v_old_set_id then
		raise exception &#39;Slony-I: set ids cannot be identical&#39;;
	end if;
	select set_origin into v_origin from sl_set
			where set_id = p_new_set_id;
	if not found then
		raise exception &#39;Slony-I: set % not found&#39;, p_new_set_id;
	end if;
	if v_origin != getLocalNodeId(&#39;_schemadoc&#39;) then
		raise exception &#39;Slony-I: set % does not originate on local node&#39;,
				p_new_set_id;
	end if;

	select set_origin into v_origin from sl_set
			where set_id = v_old_set_id;
	if not found then
		raise exception &#39;Slony-I: set % not found&#39;, v_old_set_id;
	end if;
	if v_origin != getLocalNodeId(&#39;_schemadoc&#39;) then
		raise exception &#39;Slony-I: set % does not originate on local node&#39;,
				v_old_set_id;
	end if;

	-- ----
	-- Check that both sets are subscribed by the same set of nodes
	-- ----
	if exists (select true from sl_subscribe SUB1
				where SUB1.sub_set = p_new_set_id
				and SUB1.sub_receiver not in (select SUB2.sub_receiver
						from sl_subscribe SUB2
						where SUB2.sub_set = v_old_set_id))
	then
		raise exception &#39;Slony-I: subscriber lists of set % and % are different&#39;,
				p_new_set_id, v_old_set_id;
	end if;

	if exists (select true from sl_subscribe SUB1
				where SUB1.sub_set = v_old_set_id
				and SUB1.sub_receiver not in (select SUB2.sub_receiver
						from sl_subscribe SUB2
						where SUB2.sub_set = p_new_set_id))
	then
		raise exception &#39;Slony-I: subscriber lists of set % and % are different&#39;,
				v_old_set_id, p_new_set_id;
	end if;

	-- ----
	-- Change the set the table belongs to
	-- ----
	perform createEvent(&#39;_schemadoc&#39;, &#39;SYNC&#39;, NULL);
	perform setMoveTable_int(p_tab_id, p_new_set_id);
	return  createEvent(&#39;_schemadoc&#39;, &#39;SET_MOVE_TABLE&#39;, 
			p_tab_id::text, p_new_set_id::text);
end;</programlisting>
</para>

</section>

<!-- Function setmovetable_int( integer, integer ) -->
<section id="function.setmovetable-int-integer-integer"
  xreflabel="schemadocsetmovetable_int( integer, integer )">
<title id="function.setmovetable-int-integer-integer-title">
  setmovetable_int( integer, integer )
</title>
<titleabbrev> id="function.setmovetable-int-integer-integer-titleabbrev">
  setmovetable_int( integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  <programlisting>declare
	p_tab_id			alias for $1;
	p_new_set_id		alias for $2;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;
	
	-- ----
	-- Move the table to the new set
	-- ----
	update sl_table
			set tab_set = p_new_set_id
			where tab_id = p_tab_id;

	return p_tab_id;
end;</programlisting>
</para>

</section>

<!-- Function setsessionrole( name, text ) -->
<section id="function.setsessionrole-name-text"
  xreflabel="schemadocsetsessionrole( name, text )">
<title id="function.setsessionrole-name-text-title">
  setsessionrole( name, text )
</title>
<titleabbrev> id="function.setsessionrole-name-text-titleabbrev">
  setsessionrole( name, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>C</seg>
      <seg>text</seg>
    </seglistitem>
  </segmentedlist>
  
  setSessionRole(username, role) - configure le rôle pour la session.

  Le slon peut être &quot;normal&quot; ou &quot;slon&quot;&nbsp;; configurer
  ce dernier est nécessaire, sur les n&oelig;uds abonnés, pour surcharger le
  trigger denyaccess() attaché aux tables souscrites.
  
  <programlisting>_Slony_I_setSessionRole</programlisting>
</para>

</section>

<!-- Function slon_quote_brute( text ) -->
<section id="function.slon-quote-brute-text"
  xreflabel="schemadocslon_quote_brute( text )">
<title id="function.slon-quote-brute-text-title">
  slon_quote_brute( text )
</title>
<titleabbrev> id="function.slon-quote-brute-text-titleabbrev">
  slon_quote_brute( text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>text</seg>
    </seglistitem>
  </segmentedlist>
  
  Met entre guillemets le texte donné.
  
  <programlisting>declare	
    p_tab_fqname alias for $1;
    v_fqname text default &#39;&#39;;
begin
    v_fqname := &#39;&quot;&#39; || replace(p_tab_fqname,&#39;&quot;&#39;,&#39;&quot;&quot;&#39;) || &#39;&quot;&#39;;
    return v_fqname;
end;</programlisting>
</para>

</section>

<!-- Function slon_quote_input( text ) -->
<section id="function.slon-quote-input-text"
  xreflabel="schemadocslon_quote_input( text )">
<title id="function.slon-quote-input-text-title">
  slon_quote_input( text )
</title>
<titleabbrev> id="function.slon-quote-input-text-titleabbrev">
  slon_quote_input( text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>text</seg>
    </seglistitem>
  </segmentedlist>
  
  Met entre guillemets tous les mots qui ne le sont pas encore.
  
  <programlisting>declare
     p_tab_fqname alias for $1;
     v_nsp_name text;
     v_tab_name text;
	 v_i integer;
	 v_l integer;
     v_pq2 integer;
begin
	v_l := length(p_tab_fqname);

	-- Let us search for the dot
	if p_tab_fqname like &#39;&quot;%&#39; then
		-- if the first part of the ident starts with a double quote, search
		-- for the closing double quote, skipping over double double quotes.
		v_i := 2;
		while v_i &lt;= v_l loop
			if substr(p_tab_fqname, v_i, 1) != &#39;&quot;&#39; then
				v_i := v_i + 1;
			else
				v_i := v_i + 1;
				if substr(p_tab_fqname, v_i, 1) != &#39;&quot;&#39; then
					exit;
				end if;
				v_i := v_i + 1;
			end if;
		end loop;
	else
		-- first part of ident is not quoted, search for the dot directly
		v_i := 1;
		while v_i &lt;= v_l loop
			if substr(p_tab_fqname, v_i, 1) = &#39;.&#39; then
				exit;
			end if;
			v_i := v_i + 1;
		end loop;
	end if;

	-- v_i now points at the dot or behind the string.

	if substr(p_tab_fqname, v_i, 1) = &#39;.&#39; then
		-- There is a dot now, so split the ident into its namespace
		-- and objname parts and make sure each is quoted
		v_nsp_name := substr(p_tab_fqname, 1, v_i - 1);
		v_tab_name := substr(p_tab_fqname, v_i + 1);
		if v_nsp_name not like &#39;&quot;%&#39; then
			v_nsp_name := &#39;&quot;&#39; || replace(v_nsp_name, &#39;&quot;&#39;, &#39;&quot;&quot;&#39;) ||
						  &#39;&quot;&#39;;
		end if;
		if v_tab_name not like &#39;&quot;%&#39; then
			v_tab_name := &#39;&quot;&#39; || replace(v_tab_name, &#39;&quot;&#39;, &#39;&quot;&quot;&#39;) ||
						  &#39;&quot;&#39;;
		end if;

		return v_nsp_name || &#39;.&#39; || v_tab_name;
	else
		-- No dot ... must be just an ident without schema
		if p_tab_fqname like &#39;&quot;%&#39; then
			return p_tab_fqname;
		else
			return &#39;&quot;&#39; || replace(p_tab_fqname, &#39;&quot;&#39;, &#39;&quot;&quot;&#39;) || &#39;&quot;&#39;;
		end if;
	end if;

end;</programlisting>
</para>

</section>

<!-- Function slonyversion(  ) -->
<section id="function.slonyversion"
  xreflabel="schemadocslonyversion(  )">
<title id="function.slonyversion-title">
  slonyversion(  )
</title>
<titleabbrev> id="function.slonyversion-titleabbrev">
  slonyversion(  )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>text</seg>
    </seglistitem>
  </segmentedlist>
  
  Renvoie le numéro de version du schéma slony.
  
  <programlisting>begin
	return &#39;&#39;	|| slonyVersionMajor() || &#39;.&#39;
				|| slonyVersionMinor() || &#39;.&#39;
				|| slonyVersionPatchlevel();
end;</programlisting>
</para>

</section>

<!-- Function slonyversionmajor(  ) -->
<section id="function.slonyversionmajor"
  xreflabel="schemadocslonyversionmajor(  )">
<title id="function.slonyversionmajor-title">
  slonyversionmajor(  )
</title>
<titleabbrev> id="function.slonyversionmajor-titleabbrev">
  slonyversionmajor(  )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Renvoie le numéro de version majeure du schéma slony.
  
  <programlisting>begin
	return 1;
end;</programlisting>
</para>

</section>

<!-- Function slonyversionminor(  ) -->
<section id="function.slonyversionminor"
  xreflabel="schemadocslonyversionminor(  )">
<title id="function.slonyversionminor-title">
  slonyversionminor(  )
</title>
<titleabbrev> id="function.slonyversionminor-titleabbrev">
  slonyversionminor(  )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Renvoie le numéro de version mineure du schéma slony.
  
  <programlisting>begin
	return 2;
end;</programlisting>
</para>

</section>

<!-- Function slonyversionpatchlevel(  ) -->
<section id="function.slonyversionpatchlevel"
  xreflabel="schemadocslonyversionpatchlevel(  )">
<title id="function.slonyversionpatchlevel-title">
  slonyversionpatchlevel(  )
</title>
<titleabbrev> id="function.slonyversionpatchlevel-titleabbrev">
  slonyversionpatchlevel(  )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Renvoie le niveau correctif du schéma slony.
  
  <programlisting>begin
	return 12;
end;</programlisting>
</para>

</section>

<!-- Function storelisten( integer, integer, integer ) -->
<section id="function.storelisten-integer-integer-integer"
  xreflabel="schemadocstorelisten( integer, integer, integer )">
<title id="function.storelisten-integer-integer-integer-title">
  storelisten( integer, integer, integer )
</title>
<titleabbrev> id="function.storelisten-integer-integer-integer-titleabbrev">
  storelisten( integer, integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
  
  Génère un événement STORE_LISTEN, indiquant que le n&oelig;ud abonné,
  d'identifiant li_receiver, écoute le n&oelig;ud li_provider pour obtenir
  les messages provenant du n&oelig;ud li_origin.
  
  <programlisting>declare
	p_origin		alias for $1;
	p_provider	alias for $2;
	p_receiver	alias for $3;
begin
	perform storeListen_int (p_origin, p_provider, p_receiver);
	return  createEvent (&#39;_schemadoc&#39;, &#39;STORE_LISTEN&#39;,
			p_origin::text, p_provider::text, p_receiver::text);
end;</programlisting>
</para>

</section>

<!-- Function storelisten_int( integer, integer, integer ) -->
<section id="function.storelisten-int-integer-integer-integer"
  xreflabel="schemadocstorelisten_int( integer, integer, integer )">
<title id="function.storelisten-int-integer-integer-integer-title">
  storelisten_int( integer, integer, integer )
</title>
<titleabbrev> id="function.storelisten-int-integer-integer-integer-titleabbrev">
  storelisten_int( integer, integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Traite l'événement STORE_LISTEN, indiquant que le n&oelig;ud récepteur li_receiver
  écoute le n&oelig;ud li_provider pour obtenir les messages provenant du n&oelig;ud
  li_origin.
  
  <programlisting>declare
	p_li_origin		alias for $1;
	p_li_provider	alias for $2;
	p_li_receiver	alias for $3;
	v_exists		int4;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	select 1 into v_exists
			from sl_listen
			where li_origin = p_li_origin
			and li_provider = p_li_provider
			and li_receiver = p_li_receiver;
	if not found then
		-- ----
		-- In case we receive STORE_LISTEN events before we know
		-- about the nodes involved in this, we generate those nodes
		-- as pending.
		-- ----
		if not exists (select 1 from sl_node
						where no_id = p_li_origin) then
			perform storeNode_int (p_li_origin, &#39;&lt;event pending&gt;&#39;, &#39;f&#39;);
		end if;
		if not exists (select 1 from sl_node
						where no_id = p_li_provider) then
			perform storeNode_int (p_li_provider, &#39;&lt;event pending&gt;&#39;, &#39;f&#39;);
		end if;
		if not exists (select 1 from sl_node
						where no_id = p_li_receiver) then
			perform storeNode_int (p_li_receiver, &#39;&lt;event pending&gt;&#39;, &#39;f&#39;);
		end if;

		insert into sl_listen
				(li_origin, li_provider, li_receiver) values
				(p_li_origin, p_li_provider, p_li_receiver);
	end if;

	return 0;
end;</programlisting>
</para>

</section>

<!-- Function storenode( integer, text, boolean ) -->
<section id="function.storenode-integer-text-boolean"
  xreflabel="schemadocstorenode( integer, text, boolean )">
<title id="function.storenode-integer-text-boolean-title">
  storenode( integer, text, boolean )
</title>
<titleabbrev> id="function.storenode-integer-text-boolean-titleabbrev">
  storenode( integer, text, boolean )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
  
  no_id - Identifiant du n&oelig;ud
  no_comment - Commentaire « humain »
  no_spool - Drapeau pour les n&oelig;uds virtuels de spool

  Génère l'événement STORE_NODE pour le n&oelig;ud no_id.
  
  <programlisting>declare
	p_no_id			alias for $1;
	p_no_comment	alias for $2;
	p_no_spool		alias for $3;
	v_no_spool_txt	text;
begin
	if p_no_spool then
		v_no_spool_txt = &#39;t&#39;;
	else
		v_no_spool_txt = &#39;f&#39;;
	end if;
	perform storeNode_int (p_no_id, p_no_comment, p_no_spool);
	return  createEvent(&#39;_schemadoc&#39;, &#39;STORE_NODE&#39;,
									p_no_id::text, p_no_comment::text, 
									v_no_spool_txt::text);
end;</programlisting>
</para>

</section>

<!-- Function storenode_int( integer, text, boolean ) -->
<section id="function.storenode-int-integer-text-boolean"
  xreflabel="schemadocstorenode_int( integer, text, boolean )">
<title id="function.storenode-int-integer-text-boolean-title">
  storenode_int( integer, text, boolean )
</title>
<titleabbrev> id="function.storenode-int-integer-text-boolean-titleabbrev">
  storenode_int( integer, text, boolean )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  no_id - Identifiant du n&oelig;ud
  no_comment - Commentaire « humain »
  no_spool - Drapeau pour les n&oelig;uds virtuels de spool

  Fonction interne pour traiter l'événement STORE_NODE pour le n&oelig;ud no_id.
  
  <programlisting>declare
	p_no_id			alias for $1;
	p_no_comment	alias for $2;
	p_no_spool		alias for $3;
	v_old_row		record;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Check if the node exists
	-- ----
	select * into v_old_row
			from sl_node
			where no_id = p_no_id
			for update;
	if found then 
		-- ----
		-- Node exists, update the existing row.
		-- ----
		update sl_node
				set no_comment = p_no_comment,
				no_spool = p_no_spool
				where no_id = p_no_id;
	else
		-- ----
		-- New node, insert the sl_node row
		-- ----
		insert into sl_node
				(no_id, no_active, no_comment, no_spool) values
				(p_no_id, &#39;f&#39;, p_no_comment, p_no_spool);
	end if;

	return p_no_id;
end;</programlisting>
</para>

</section>

<!-- Function storepath( integer, integer, text, integer ) -->
<section id="function.storepath-integer-integer-text-integer"
  xreflabel="schemadocstorepath( integer, integer, text, integer )">
<title id="function.storepath-integer-integer-text-integer-title">
  storepath( integer, integer, text, integer )
</title>
<titleabbrev> id="function.storepath-integer-integer-text-integer-titleabbrev">
  storepath( integer, integer, text, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
  
  Génère l'événement STORE_PATH indiquant que le n&oelig;ud pa_client peut
  accéder au n&oelig;ud pa_server en utilisant le DSN pa_conninfo.
  
  <programlisting>declare
	p_pa_server		alias for $1;
	p_pa_client		alias for $2;
	p_pa_conninfo	alias for $3;
	p_pa_connretry	alias for $4;
begin
	perform storePath_int(p_pa_server, p_pa_client,
			p_pa_conninfo, p_pa_connretry);
	return  createEvent(&#39;_schemadoc&#39;, &#39;STORE_PATH&#39;, 
			p_pa_server::text, p_pa_client::text, 
			p_pa_conninfo::text, p_pa_connretry::text);
end;</programlisting>
</para>

</section>

<!-- Function storepath_int( integer, integer, text, integer ) -->
<section id="function.storepath-int-integer-integer-text-integer"
  xreflabel="schemadocstorepath_int( integer, integer, text, integer )">
<title id="function.storepath-int-integer-integer-text-integer-title">
  storepath_int( integer, integer, text, integer )
</title>
<titleabbrev> id="function.storepath-int-integer-integer-text-integer-titleabbrev">
  storepath_int( integer, integer, text, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Traite l'événement STORE_PATH indiquant que le n&oelig;ud pa_client peut
  accéder au n&oelig;ud pa_server en utilisant le DSN pa_conninfo.
  
  <programlisting>declare
	p_pa_server		alias for $1;
	p_pa_client		alias for $2;
	p_pa_conninfo	alias for $3;
	p_pa_connretry	alias for $4;
	v_dummy			int4;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Check if the path already exists
	-- ----
	select 1 into v_dummy
			from sl_path
			where pa_server = p_pa_server
			and pa_client = p_pa_client
			for update;
	if found then
		-- ----
		-- Path exists, update pa_conninfo
		-- ----
		update sl_path
				set pa_conninfo = p_pa_conninfo,
					pa_connretry = p_pa_connretry
				where pa_server = p_pa_server
				and pa_client = p_pa_client;
	else
		-- ----
		-- New path
		--
		-- In case we receive STORE_PATH events before we know
		-- about the nodes involved in this, we generate those nodes
		-- as pending.
		-- ----
		if not exists (select 1 from sl_node
						where no_id = p_pa_server) then
			perform storeNode_int (p_pa_server, &#39;&lt;event pending&gt;&#39;, &#39;f&#39;);
		end if;
		if not exists (select 1 from sl_node
						where no_id = p_pa_client) then
			perform storeNode_int (p_pa_client, &#39;&lt;event pending&gt;&#39;, &#39;f&#39;);
		end if;
		insert into sl_path
				(pa_server, pa_client, pa_conninfo, pa_connretry) values
				(p_pa_server, p_pa_client, p_pa_conninfo, p_pa_connretry);
	end if;

	-- Rewrite sl_listen table
	perform RebuildListenEntries();

	return 0;
end;</programlisting>
</para>

</section>

<!-- Function storeset( integer, text ) -->
<section id="function.storeset-integer-text"
  xreflabel="schemadocstoreset( integer, text )">
<title id="function.storeset-integer-text-title">
  storeset( integer, text )
</title>
<titleabbrev> id="function.storeset-integer-text-titleabbrev">
  storeset( integer, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
  
  Génère un événement STORE_SET pour l'ensemble set_id avec un commentaire
  set_comment utilisable par un humain.
  
  <programlisting>declare
	p_set_id			alias for $1;
	p_set_comment		alias for $2;
	v_local_node_id		int4;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	v_local_node_id := getLocalNodeId(&#39;_schemadoc&#39;);

	insert into sl_set
			(set_id, set_origin, set_comment) values
			(p_set_id, v_local_node_id, p_set_comment);

	return createEvent(&#39;_schemadoc&#39;, &#39;STORE_SET&#39;, 
			p_set_id::text, v_local_node_id::text, p_set_comment::text);
end;</programlisting>
</para>

</section>

<!-- Function storeset_int( integer, integer, text ) -->
<section id="function.storeset-int-integer-integer-text"
  xreflabel="schemadocstoreset_int( integer, integer, text )">
<title id="function.storeset-int-integer-integer-text-title">
  storeset_int( integer, integer, text )
</title>
<titleabbrev> id="function.storeset-int-integer-integer-text-titleabbrev">
  storeset_int( integer, integer, text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Traite l'événement STORE_SET, indiquant que le nouvel ensemble avec
  l'identifiant donné, le n&oelig;ud origine et un commentaire lisible par un
  humain.
  
  <programlisting>declare
	p_set_id			alias for $1;
	p_set_origin		alias for $2;
	p_set_comment		alias for $3;
	v_dummy				int4;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	select 1 into v_dummy
			from sl_set
			where set_id = p_set_id
			for update;
	if found then 
		update sl_set
				set set_comment = p_set_comment
				where set_id = p_set_id;
	else
		if not exists (select 1 from sl_node
						where no_id = p_set_origin) then
			perform storeNode_int (p_set_origin, &#39;&lt;event pending&gt;&#39;, &#39;f&#39;);
		end if;
		insert into sl_set
				(set_id, set_origin, set_comment) values
				(p_set_id, p_set_origin, p_set_comment);
	end if;

	-- Run addPartialLogIndices() to try to add indices to unused sl_log_? table
	perform addPartialLogIndices();

	return p_set_id;
end;</programlisting>
</para>

</section>

<!-- Function storetrigger( integer, name ) -->
<section id="function.storetrigger-integer-name"
  xreflabel="schemadocstoretrigger( integer, name )">
<title id="function.storetrigger-integer-name-title">
  storetrigger( integer, name )
</title>
<titleabbrev> id="function.storetrigger-integer-name-titleabbrev">
  storetrigger( integer, name )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
  
  Soumet l'événement STORE_TRIGGER pour indiquer que le trigger trig_tgname sur
  la table trig_tabid répliquée ne sera PAS désactivée.
  
  <programlisting>declare
	p_trig_tabid		alias for $1;
	p_trig_tgname		alias for $2;
begin
	perform storeTrigger_int(p_trig_tabid, p_trig_tgname);
	return  createEvent(&#39;_schemadoc&#39;, &#39;STORE_TRIGGER&#39;,
			p_trig_tabid::text, p_trig_tgname::text);
end;</programlisting>
</para>

</section>

<!-- Function storetrigger_int( integer, name ) -->
<section id="function.storetrigger-int-integer-name"
  xreflabel="schemadocstoretrigger_int( integer, name )">
<title id="function.storetrigger-int-integer-name-title">
  storetrigger_int( integer, name )
</title>
<titleabbrev> id="function.storetrigger-int-integer-name-titleabbrev">
  storetrigger_int( integer, name )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Traite l'événement STORE_TRIGGER pour s'assurer que le trigger trig_tgname
  sur la table trig_tabid répliquée n'est PAS désactivé.
  
  <programlisting>declare
	p_trig_tabid		alias for $1;
	p_trig_tgname		alias for $2;
	v_tab_altered		boolean;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Get the current table status (altered or not)
	-- ----
	select tab_altered into v_tab_altered
			from sl_table where tab_id = p_trig_tabid;
	if not found then
		-- ----
		-- Not found is no hard error here, because that might
		-- mean that we are not subscribed to that set
		-- ----
		return 0;
	end if;

	-- ----
	-- If the table is modified for replication, restore the original state
	-- ----
	if v_tab_altered then
		perform alterTableRestore(p_trig_tabid);
	end if;

	-- ----
	-- Make sure that an entry for this trigger exists
	-- ----
	delete from sl_trigger
			where trig_tabid = p_trig_tabid
			  and trig_tgname = p_trig_tgname;
	insert into sl_trigger (
				trig_tabid, trig_tgname
			) values (
				p_trig_tabid, p_trig_tgname
			);

	-- ----
	-- Put the table back into replicated state if it was
	-- ----
	if v_tab_altered then
		perform alterTableForReplication(p_trig_tabid);
	end if;

	return p_trig_tabid;
end;</programlisting>
</para>

</section>

<!-- Function subscribeset( integer, integer, integer, boolean ) -->
<section id="function.subscribeset-integer-integer-integer-boolean"
  xreflabel="schemadocsubscribeset( integer, integer, integer, boolean )">
<title id="function.subscribeset-integer-integer-integer-boolean-title">
  subscribeset( integer, integer, integer, boolean )
</title>
<titleabbrev> id="function.subscribeset-integer-integer-integer-boolean-titleabbrev">
  subscribeset( integer, integer, integer, boolean )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
  
  S'assure que le n&oelig;ud récepteur n'est pas le fournisseur, puis enregistre
  l'abonnement et publie l'événement SUBSCRIBE_SET vers les autres n&oelig;uds.
  
  <programlisting>declare
	p_sub_set			alias for $1;
	p_sub_provider		alias for $2;
	p_sub_receiver		alias for $3;
	p_sub_forward		alias for $4;
	v_set_origin		int4;
	v_ev_seqno			int8;
	v_rec			record;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Check that this is called on the provider node
	-- ----
	if p_sub_provider != getLocalNodeId(&#39;_schemadoc&#39;) then
		raise exception &#39;Slony-I: subscribeSet() must be called on provider&#39;;
	end if;

	-- ----
	-- Check that the origin and provider of the set are remote
	-- ----
	select set_origin into v_set_origin
			from sl_set
			where set_id = p_sub_set;
	if not found then
		raise exception &#39;Slony-I: subscribeSet(): set % not found&#39;, p_sub_set;
	end if;
	if v_set_origin = p_sub_receiver then
		raise exception 
				&#39;Slony-I: subscribeSet(): set origin and receiver cannot be identical&#39;;
	end if;
	if p_sub_receiver = p_sub_provider then
		raise exception 
				&#39;Slony-I: subscribeSet(): set provider and receiver cannot be identical&#39;;
	end if;

	-- ---
	-- Verify that the provider is either the origin or an active subscriber
	-- Bug report #1362
	-- ---
	if v_set_origin &lt;&gt; p_sub_provider then
		if not exists (select 1 from sl_subscribe
			where sub_set = p_sub_set and 
                              sub_receiver = p_sub_provider and
			      sub_forward and sub_active) then
			raise exception &#39;Slony-I: subscribeSet(): provider % is not an active forwarding node for replication set %&#39;, p_sub_provider, p_sub_set;
		end if;
	end if;

	-- ----
	-- Create the SUBSCRIBE_SET event
	-- ----
	v_ev_seqno :=  createEvent(&#39;_schemadoc&#39;, &#39;SUBSCRIBE_SET&#39;, 
			p_sub_set::text, p_sub_provider::text, p_sub_receiver::text, 
			case p_sub_forward when true then &#39;t&#39; else &#39;f&#39; end);

	-- ----
	-- Call the internal procedure to store the subscription
	-- ----
	perform subscribeSet_int(p_sub_set, p_sub_provider,
			p_sub_receiver, p_sub_forward);

	return v_ev_seqno;
end;</programlisting>
</para>

</section>

<!-- Function subscribeset_int( integer, integer, integer, boolean ) -->
<section id="function.subscribeset-int-integer-integer-integer-boolean"
  xreflabel="schemadocsubscribeset_int( integer, integer, integer, boolean )">
<title id="function.subscribeset-int-integer-integer-integer-boolean-title">
  subscribeset_int( integer, integer, integer, boolean )
</title>
<titleabbrev> id="function.subscribeset-int-integer-integer-integer-boolean-titleabbrev">
  subscribeset_int( integer, integer, integer, boolean )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Actions internes pour abonner le récepteur sub_receiver à l'ensemble
  sub_set.
  
  <programlisting>declare
	p_sub_set			alias for $1;
	p_sub_provider		alias for $2;
	p_sub_receiver		alias for $3;
	p_sub_forward		alias for $4;
	v_set_origin		int4;
	v_sub_row			record;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Provider change is only allowed for active sets
	-- ----
	if p_sub_receiver = getLocalNodeId(&#39;_schemadoc&#39;) then
		select sub_active into v_sub_row from sl_subscribe
				where sub_set = p_sub_set
				and sub_receiver = p_sub_receiver;
		if found then
			if not v_sub_row.sub_active then
				raise exception &#39;Slony-I: subscribeSet_int(): set % is not active, cannot change provider&#39;,
						p_sub_set;
			end if;
		end if;
	end if;

	-- ----
	-- Try to change provider and/or forward for an existing subscription
	-- ----
	update sl_subscribe
			set sub_provider = p_sub_provider,
				sub_forward = p_sub_forward
			where sub_set = p_sub_set
			and sub_receiver = p_sub_receiver;
	if found then
		-- ----
		-- Rewrite sl_listen table
		-- ----
		perform RebuildListenEntries();

		return p_sub_set;
	end if;

	-- ----
	-- Not found, insert a new one
	-- ----
	if not exists (select true from sl_path
			where pa_server = p_sub_provider
			and pa_client = p_sub_receiver)
	then
		insert into sl_path
				(pa_server, pa_client, pa_conninfo, pa_connretry)
				values 
				(p_sub_provider, p_sub_receiver, 
				&#39;&lt;event pending&gt;&#39;, 10);
	end if;
	insert into sl_subscribe
			(sub_set, sub_provider, sub_receiver, sub_forward, sub_active)
			values (p_sub_set, p_sub_provider, p_sub_receiver,
				p_sub_forward, false);

	-- ----
	-- If the set origin is here, then enable the subscription
	-- ----
	select set_origin into v_set_origin
			from sl_set
			where set_id = p_sub_set;
	if not found then
		raise exception &#39;Slony-I: subscribeSet_int(): set % not found&#39;, p_sub_set;
	end if;

	if v_set_origin = getLocalNodeId(&#39;_schemadoc&#39;) then
		perform createEvent(&#39;_schemadoc&#39;, &#39;ENABLE_SUBSCRIPTION&#39;, 
				p_sub_set::text, p_sub_provider::text, p_sub_receiver::text, 
				case p_sub_forward when true then &#39;t&#39; else &#39;f&#39; end);
		perform enableSubscription(p_sub_set, 
				p_sub_provider, p_sub_receiver);
	end if;

	-- ----
	-- Rewrite sl_listen table
	-- ----
	perform RebuildListenEntries();

	return p_sub_set;
end;</programlisting>
</para>

</section>

<!-- Function tableaddkey( text ) -->
<section id="function.tableaddkey-text"
  xreflabel="schemadoctableaddkey( text )">
<title id="function.tableaddkey-text-title">
  tableaddkey( text )
</title>
<titleabbrev> id="function.tableaddkey-text-titleabbrev">
  tableaddkey( text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>text</seg>
    </seglistitem>
  </segmentedlist>
  
  Si la table n'a pas obtenu une colonne de la forme
  _Slony-I_&lt;clustername&gt;_rowID, alors l'ajoute avec le type bigint et
  comme valeur par défaut le nextval() d'une séquence créée pour le cluster.
  
  <programlisting>declare
	p_tab_fqname	alias for $1;
	v_tab_fqname_quoted	text default &#39;&#39;;
	v_attkind		text default &#39;&#39;;
	v_attrow		record;
	v_have_serial	bool default &#39;f&#39;;
begin
	v_tab_fqname_quoted := slon_quote_input(p_tab_fqname);
	--
	-- Loop over the attributes of this relation
	-- and add a &quot;v&quot; for every user column, and a &quot;k&quot;
	-- if we find the Slony-I special serial column.
	--
	for v_attrow in select PGA.attnum, PGA.attname
			from &quot;pg_catalog&quot;.pg_class PGC,
			    &quot;pg_catalog&quot;.pg_namespace PGN,
				&quot;pg_catalog&quot;.pg_attribute PGA
			where slon_quote_brute(PGN.nspname) || &#39;.&#39; ||
			    slon_quote_brute(PGC.relname) = v_tab_fqname_quoted
				and PGN.oid = PGC.relnamespace
				and PGA.attrelid = PGC.oid
				and not PGA.attisdropped
				and PGA.attnum &gt; 0
			order by attnum
	loop
		if v_attrow.attname = &#39;_Slony-I_schemadoc_rowID&#39; then
		    v_attkind := v_attkind || &#39;k&#39;;
			v_have_serial := &#39;t&#39;;
		else
			v_attkind := v_attkind || &#39;v&#39;;
		end if;
	end loop;
	
	--
	-- A table must have at least one attribute, so not finding
	-- anything means the table does not exist.
	--
	if not found then
		raise exception &#39;Slony-I: tableAddKey(): table % not found&#39;, v_tab_fqname_quoted;
	end if;

	--
	-- If it does not have the special serial column, we
	-- have to add it. This will be only half way done.
	-- The function to add the table to the set must finish
	-- these definitions with NOT NULL and UNIQUE after
	-- updating all existing rows.
	--
	if not v_have_serial then
		execute &#39;lock table &#39; || v_tab_fqname_quoted ||
			&#39; in access exclusive mode&#39;;
		execute &#39;alter table only &#39; || v_tab_fqname_quoted ||
			&#39; add column &quot;_Slony-I_schemadoc_rowID&quot; bigint;&#39;;
		execute &#39;alter table only &#39; || v_tab_fqname_quoted ||
			&#39; alter column &quot;_Slony-I_schemadoc_rowID&quot; &#39; ||
			&#39; set default &quot;pg_catalog&quot;.nextval(&#39;&#39;sl_rowid_seq&#39;&#39;);&#39;;

		v_attkind := v_attkind || &#39;k&#39;;
	end if;

	--
	-- Return the resulting Slony-I attkind
	--
	return v_attkind;
end;</programlisting>
</para>

</section>

<!-- Function tabledropkey( integer ) -->
<section id="function.tabledropkey-integer"
  xreflabel="schemadoctabledropkey( integer )">
<title id="function.tabledropkey-integer-title">
  tabledropkey( integer )
</title>
<titleabbrev> id="function.tabledropkey-integer-titleabbrev">
  tabledropkey( integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Si la table spécifiée a une colone &quot;_Slony-I_&lt;clustername&gt;_rowID&quot;, la
  supprime.
  
  <programlisting>declare
	p_tab_id		alias for $1;
	v_tab_fqname	text;
	v_tab_oid		oid;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Construct the tables fully qualified name and get its oid
	-- ----
	select slon_quote_brute(PGN.nspname) || &#39;.&#39; ||
				slon_quote_brute(PGC.relname),
				PGC.oid into v_tab_fqname, v_tab_oid
			from sl_table T,
				&quot;pg_catalog&quot;.pg_class PGC,
				&quot;pg_catalog&quot;.pg_namespace PGN
			where T.tab_id = p_tab_id
				and T.tab_reloid = PGC.oid
				and PGC.relnamespace = PGN.oid;
	if not found then
		raise exception &#39;Slony-I: tableDropKey(): table with ID % not found&#39;, p_tab_id;
	end if;

	-- ----
	-- Drop the special serial ID column if the table has it
	-- ----
	if exists (select true from &quot;pg_catalog&quot;.pg_attribute
			where attrelid = v_tab_oid
				and attname = &#39;_Slony-I_schemadoc_rowID&#39;)
	then
		execute &#39;lock table &#39; || v_tab_fqname ||
				&#39; in access exclusive mode&#39;;
		execute &#39;alter table &#39; || v_tab_fqname ||
				&#39; drop column &quot;_Slony-I_schemadoc_rowID&quot;&#39;;
	end if;

	return p_tab_id;
end;</programlisting>
</para>

</section>

<!-- Function tablehasserialkey( text ) -->
<section id="function.tablehasserialkey-text"
  xreflabel="schemadoctablehasserialkey( text )">
<title id="function.tablehasserialkey-text-title">
  tablehasserialkey( text )
</title>
<titleabbrev> id="function.tablehasserialkey-text-titleabbrev">
  tablehasserialkey( text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>boolean</seg>
    </seglistitem>
  </segmentedlist>

  Vérifie que la table a notre colonne spéciale (de type serial) qui est
  utilisée si la table n'a pas de constrainte unique naturelle.
  
  <programlisting>declare
	p_tab_fqname	alias for $1;
	v_tab_fqname_quoted	text default &#39;&#39;;
	v_attnum		int2;
begin
	v_tab_fqname_quoted := slon_quote_input(p_tab_fqname);
	select PGA.attnum into v_attnum
			from &quot;pg_catalog&quot;.pg_class PGC,
				&quot;pg_catalog&quot;.pg_namespace PGN,
				&quot;pg_catalog&quot;.pg_attribute PGA
			where slon_quote_brute(PGN.nspname) || &#39;.&#39; ||
				slon_quote_brute(PGC.relname) = v_tab_fqname_quoted
				and PGC.relnamespace = PGN.oid
				and PGA.attrelid = PGC.oid
				and PGA.attname = &#39;_Slony-I_schemadoc_rowID&#39;
				and not PGA.attisdropped;
	return found;
end;</programlisting>
</para>

</section>

<!-- Function terminatenodeconnections( integer ) -->
<section id="function.terminatenodeconnections-integer"
  xreflabel="schemadocterminatenodeconnections( integer )">
<title id="function.terminatenodeconnections-integer-title">
  terminatenodeconnections( integer )
</title>
<titleabbrev> id="function.terminatenodeconnections-integer-titleabbrev">
  terminatenodeconnections( integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Termine tous les processus serveur qui se sont enregistrés pour le n&oelig;ud
  donné.
  
  <programlisting>declare
	p_failed_node	alias for $1;
	v_row			record;
begin
	for v_row in select nl_nodeid, nl_conncnt,
			nl_backendpid from sl_nodelock
			where nl_nodeid = p_failed_node for update
	loop
		perform killBackend(v_row.nl_backendpid, &#39;TERM&#39;);
		delete from sl_nodelock
			where nl_nodeid = v_row.nl_nodeid
			and nl_conncnt = v_row.nl_conncnt;
	end loop;

	return 0;
end;</programlisting>
</para>

</section>

<!-- Function uninstallnode(  ) -->
<section id="function.uninstallnode"
  xreflabel="schemadocuninstallnode(  )">
<title id="function.uninstallnode-title">
  uninstallnode(  )
</title>
<titleabbrev> id="function.uninstallnode-titleabbrev">
  uninstallnode(  )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Réinitialise la base de données complète en supprimant tout le système de
  réplication.
  
  <programlisting>declare
	v_tab_row		record;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- This is us ... time for suicide! Restore all tables to
	-- their original status.
	-- ----
	for v_tab_row in select * from sl_table loop
		perform alterTableRestore(v_tab_row.tab_id);
		perform tableDropKey(v_tab_row.tab_id);
	end loop;

	raise notice &#39;Slony-I: Please drop schema &quot;_schemadoc&quot;&#39;;
	return 0;
end;</programlisting>
</para>

</section>

<!-- Function unlockset( integer ) -->
<section id="function.unlockset-integer"
  xreflabel="schemadocunlockset( integer )">
<title id="function.unlockset-integer-title">
  unlockset( integer )
</title>
<titleabbrev> id="function.unlockset-integer-titleabbrev">
  unlockset( integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Supprime le trigger spécial pour toutes les tables d'un ensemble dont l'accès
  était verrouillé.
  
  <programlisting>declare
	p_set_id			alias for $1;
	v_local_node_id		int4;
	v_set_row			record;
	v_tab_row			record;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Check that the set exists and that we are the origin
	-- and that it is not already locked.
	-- ----
	v_local_node_id := getLocalNodeId(&#39;_schemadoc&#39;);
	select * into v_set_row from sl_set
			where set_id = p_set_id
			for update;
	if not found then
		raise exception &#39;Slony-I: set % not found&#39;, p_set_id;
	end if;
	if v_set_row.set_origin &lt;&gt; v_local_node_id then
		raise exception &#39;Slony-I: set % does not originate on local node&#39;,
				p_set_id;
	end if;
	if v_set_row.set_locked isnull then
		raise exception &#39;Slony-I: set % is not locked&#39;, p_set_id;
	end if;

	-- ----
	-- Drop the lockedSet trigger from all tables in the set.
	-- ----
	for v_tab_row in select T.tab_id,
			slon_quote_brute(PGN.nspname) || &#39;.&#39; ||
			slon_quote_brute(PGC.relname) as tab_fqname
			from sl_table T,
				&quot;pg_catalog&quot;.pg_class PGC, &quot;pg_catalog&quot;.pg_namespace PGN
			where T.tab_set = p_set_id
				and T.tab_reloid = PGC.oid
				and PGC.relnamespace = PGN.oid
			order by tab_id
	loop
		execute &#39;drop trigger &quot;_schemadoc_lockedset_&#39; || 
				v_tab_row.tab_id || &#39;&quot; on &#39; || v_tab_row.tab_fqname;
	end loop;

	-- ----
	-- Clear out the set_locked field
	-- ----
	update sl_set
			set set_locked = NULL
			where set_id = p_set_id;

	return p_set_id;
end;</programlisting>
</para>

</section>

<!-- Function unsubscribeset( integer, integer ) -->
<section id="function.unsubscribeset-integer-integer"
  xreflabel="schemadocunsubscribeset( integer, integer )">
<title id="function.unsubscribeset-integer-integer-title">
  unsubscribeset( integer, integer )
</title>
<titleabbrev> id="function.unsubscribeset-integer-integer-titleabbrev">
  unsubscribeset( integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>bigint</seg>
    </seglistitem>
  </segmentedlist>
  
  Désabonne le n&oelig;ud sub_receiver de l'ensemble sub_set. Cette fonction
  est appelée sur le n&oelig;ud abonné. Elle vérifie que cela ne casse pas
  les chaînes (c'est-à-dire où sub_receiver est un fournisseur pour d'autres
  n&oelig;uds), puis restaure les tables, supprime les clés spécifiques de
  Slony, supprime les entrées de table pour l'ensemble, supprime l'abonnement
  et génère un événement UNSUBSCRIBE_SET pour publier la suppression du
  n&oelig;ud.
  
  <programlisting>declare
	p_sub_set			alias for $1;
	p_sub_receiver		alias for $2;
	v_tab_row			record;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- Check that this is called on the receiver node
	-- ----
	if p_sub_receiver != getLocalNodeId(&#39;_schemadoc&#39;) then
		raise exception &#39;Slony-I: unsubscribeSet() must be called on receiver&#39;;
	end if;

	-- ----
	-- Check that this does not break any chains
	-- ----
	if exists (select true from sl_subscribe
			where sub_set = p_sub_set
				and sub_provider = p_sub_receiver)
	then
		raise exception &#39;Slony-I: Cannot unsubscribe set % while being provider&#39;,
				p_sub_set;
	end if;

	-- ----
	-- Restore all tables original triggers and rules and remove
	-- our replication stuff.
	-- ----
	for v_tab_row in select tab_id from sl_table
			where tab_set = p_sub_set
			order by tab_id
	loop
		perform alterTableRestore(v_tab_row.tab_id);
		perform tableDropKey(v_tab_row.tab_id);
	end loop;

	-- ----
	-- Remove the setsync status. This will also cause the
	-- worker thread to ignore the set and stop replicating
	-- right now.
	-- ----
	delete from sl_setsync
			where ssy_setid = p_sub_set;

	-- ----
	-- Remove all sl_table and sl_sequence entries for this set.
	-- Should we ever subscribe again, the initial data
	-- copy process will create new ones.
	-- ----
	delete from sl_table
			where tab_set = p_sub_set;
	delete from sl_sequence
			where seq_set = p_sub_set;

	-- ----
	-- Call the internal procedure to drop the subscription
	-- ----
	perform unsubscribeSet_int(p_sub_set, p_sub_receiver);

	-- Rewrite sl_listen table
	perform RebuildListenEntries();

	-- ----
	-- Create the UNSUBSCRIBE_SET event
	-- ----
	return  createEvent(&#39;_schemadoc&#39;, &#39;UNSUBSCRIBE_SET&#39;, 
			p_sub_set::text, p_sub_receiver::text);
end;</programlisting>
</para>

</section>

<!-- Function unsubscribeset_int( integer, integer ) -->
<section id="function.unsubscribeset-int-integer-integer"
  xreflabel="schemadocunsubscribeset_int( integer, integer )">
<title id="function.unsubscribeset-int-integer-integer-title">
  unsubscribeset_int( integer, integer )
</title>
<titleabbrev> id="function.unsubscribeset-int-integer-integer-titleabbrev">
  unsubscribeset_int( integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
 
  Tout le VRAI travail de suppression de l'abonné est fait avant la génération
  de l'événement pour que cette fonction ait seulement à supprimer les
  référence à l'abonnement dans sl_subscribe.
  
  <programlisting>declare
	p_sub_set			alias for $1;
	p_sub_receiver		alias for $2;
begin
	-- ----
	-- Grab the central configuration lock
	-- ----
	lock table sl_config_lock;

	-- ----
	-- All the real work is done before event generation on the
	-- subscriber.
	-- ----
	delete from sl_subscribe
			where sub_set = p_sub_set
				and sub_receiver = p_sub_receiver;

	-- Rewrite sl_listen table
	perform RebuildListenEntries();

	return p_sub_set;
end;</programlisting>
</para>

</section>

<!-- Function updaterelname( integer, integer ) -->
<section id="function.updaterelname-integer-integer"
  xreflabel="schemadocupdaterelname( integer, integer )">
<title id="function.updaterelname-integer-integer-title">
  updaterelname( integer, integer )
</title>
<titleabbrev> id="function.updaterelname-integer-integer-titleabbrev">
  updaterelname( integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  <programlisting>declare
        p_set_id                alias for $1;
        p_only_on_node          alias for $2;
        v_no_id                 int4;
        v_set_origin            int4;
begin
        -- ----
        -- Grab the central configuration lock
        -- ----
        lock table sl_config_lock;

        -- ----
        -- Check that we either are the set origin or a current
        -- subscriber of the set.
        -- ----
        v_no_id := getLocalNodeId(&#39;_schemadoc&#39;);
        select set_origin into v_set_origin
                        from sl_set
                        where set_id = p_set_id
                        for update;
        if not found then
                raise exception &#39;Slony-I: set % not found&#39;, p_set_id;
        end if;
        if v_set_origin &lt;&gt; v_no_id
                and not exists (select 1 from sl_subscribe
                        where sub_set = p_set_id
                        and sub_receiver = v_no_id)
        then
                return 0;
        end if;
    
        -- ----
        -- If execution on only one node is requested, check that
        -- we are that node.
        -- ----
        if p_only_on_node &gt; 0 and p_only_on_node &lt;&gt; v_no_id then
                return 0;
        end if;
        update sl_table set 
                tab_relname = PGC.relname, tab_nspname = PGN.nspname
                from pg_catalog.pg_class PGC, pg_catalog.pg_namespace PGN 
                where sl_table.tab_reloid = PGC.oid
                        and PGC.relnamespace = PGN.oid;
        update sl_sequence set
                seq_relname = PGC.relname, seq_nspname = PGN.nspname
                from pg_catalog.pg_class PGC, pg_catalog.pg_namespace PGN
                where sl_sequence.seq_reloid = PGC.oid
                and PGC.relnamespace = PGN.oid;
        return p_set_id;
end;</programlisting>
</para>

</section>

<!-- Function updatereloid( integer, integer ) -->
<section id="function.updatereloid-integer-integer"
  xreflabel="schemadocupdatereloid( integer, integer )">
<title id="function.updatereloid-integer-integer-title">
  updatereloid( integer, integer )
</title>
<titleabbrev> id="function.updatereloid-integer-integer-titleabbrev">
  updatereloid( integer, integer )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>integer</seg>
    </seglistitem>
  </segmentedlist>
  
  Met à jour les reloids respectifs dans in sl_table et sl_seqeunce en se basant
  sur leur nom complètement qualifié.
  
  <programlisting>declare
        p_set_id                alias for $1;
        p_only_on_node          alias for $2;
        v_no_id                 int4;
        v_set_origin            int4;
begin
        -- ----
        -- Grab the central configuration lock
        -- ----
        lock table sl_config_lock;

        -- ----
        -- Check that we either are the set origin or a current
        -- subscriber of the set.
        -- ----
        v_no_id := getLocalNodeId(&#39;_schemadoc&#39;);
        select set_origin into v_set_origin
                        from sl_set
                        where set_id = p_set_id
                        for update;
        if not found then
                raise exception &#39;Slony-I: set % not found&#39;, p_set_id;
        end if;
        if v_set_origin &lt;&gt; v_no_id
                and not exists (select 1 from sl_subscribe
                        where sub_set = p_set_id
                        and sub_receiver = v_no_id)
        then
                return 0;
        end if;

        -- ----
        -- If execution on only one node is requested, check that
        -- we are that node.
        -- ----
        if p_only_on_node &gt; 0 and p_only_on_node &lt;&gt; v_no_id then
                return 0;
        end if;
        update sl_table set
                tab_reloid = PGC.oid
                from pg_catalog.pg_class PGC, pg_catalog.pg_namespace PGN
                where slon_quote_brute(sl_table.tab_relname) = slon_quote_brute(PGC.relname)
                        and PGC.relnamespace = PGN.oid
			and slon_quote_brute(PGN.nspname) = slon_quote_brute(sl_table.tab_nspname);

        update sl_sequence set
                seq_reloid = PGC.oid
                from pg_catalog.pg_class PGC, pg_catalog.pg_namespace PGN
                where slon_quote_brute(sl_sequence.seq_relname) = slon_quote_brute(PGC.relname)
                	and PGC.relnamespace = PGN.oid
			and slon_quote_brute(PGN.nspname) = slon_quote_brute(sl_sequence.seq_nspname);

        return  createEvent(&#39;_schemadoc&#39;, &#39;RESET_CONFIG&#39;,
                        p_set_id::text, p_only_on_node::text);
end;</programlisting>
</para>

</section>

<!-- Function upgradeschema( text ) -->
<section id="function.upgradeschema-text"
  xreflabel="schemadocupgradeschema( text )">
<title id="function.upgradeschema-text-title">
  upgradeschema( text )
</title>
<titleabbrev> id="function.upgradeschema-text-titleabbrev">
  upgradeschema( text )
</titleabbrev>

<para>
  <segmentedlist>
    <title>Propriétés de la fonction</title>
    <?dbhtml list-presentation="list"?>
    <segtitle>Langage</segtitle>
    <segtitle>Type du code retour</segtitle>
    <seglistitem>
      <seg>PLPGSQL</seg>
      <seg>text</seg>
    </seglistitem>
  </segmentedlist>
  
  Appelé lors des &quot;fonctions de mise à jour&quot; par slonik pour réaliser
  les modifications de schéma.
  
  <programlisting>declare
        p_old   alias for $1;
begin
	-- upgrade sl_table
	if p_old IN (&#39;1.0.2&#39;, &#39;1.0.5&#39;, &#39;1.0.6&#39;) then
		-- Add new column(s) sl_table.tab_relname, sl_table.tab_nspname
		execute &#39;alter table sl_table add column tab_relname name&#39;;
		execute &#39;alter table sl_table add column tab_nspname name&#39;;

		-- populate the colums with data
		update sl_table set
			tab_relname = PGC.relname, tab_nspname = PGN.nspname
			from pg_catalog.pg_class PGC, pg_catalog.pg_namespace PGN
			where sl_table.tab_reloid = PGC.oid
			and PGC.relnamespace = PGN.oid;

		-- constrain the colums
		execute &#39;alter table sl_table alter column tab_relname set NOT NULL&#39;;
		execute &#39;alter table sl_table alter column tab_nspname set NOT NULL&#39;;

	end if;

	-- upgrade sl_sequence
	if p_old IN (&#39;1.0.2&#39;, &#39;1.0.5&#39;, &#39;1.0.6&#39;) then
		-- Add new column(s) sl_sequence.seq_relname, sl_sequence.seq_nspname
		execute &#39;alter table sl_sequence add column seq_relname name&#39;;
		execute &#39;alter table sl_sequence add column seq_nspname name&#39;;

		-- populate the columns with data
		update sl_sequence set
			seq_relname = PGC.relname, seq_nspname = PGN.nspname
			from pg_catalog.pg_class PGC, pg_catalog.pg_namespace PGN
			where sl_sequence.seq_reloid = PGC.oid
			and PGC.relnamespace = PGN.oid;

		-- constrain the data
		execute &#39;alter table sl_sequence alter column seq_relname set NOT NULL&#39;;
		execute &#39;alter table sl_sequence alter column seq_nspname set NOT NULL&#39;;
	end if;

	-- ----
	-- Changes from 1.0.x to 1.1.0
	-- ----
	if p_old IN (&#39;1.0.2&#39;, &#39;1.0.5&#39;, &#39;1.0.6&#39;) then
		-- Add new column sl_node.no_spool for virtual spool nodes
		execute &#39;alter table sl_node add column no_spool boolean&#39;;
		update sl_node set no_spool = false;
	end if;

	-- ----
	-- Changes for 1.1.3
	-- ----
	if p_old IN (&#39;1.0.2&#39;, &#39;1.0.5&#39;, &#39;1.0.6&#39;, &#39;1.1.0&#39;, &#39;1.1.1&#39;, &#39;1.1.2&#39;) then
		-- Add new table sl_nodelock
		execute &#39;create table sl_nodelock (
						nl_nodeid		int4,
						nl_conncnt		serial,
						nl_backendpid	int4,

						CONSTRAINT &quot;sl_nodelock-pkey&quot;
						PRIMARY KEY (nl_nodeid, nl_conncnt)
					)&#39;;
		-- Drop obsolete functions
		execute &#39;drop function terminateNodeConnections(name)&#39;;
		execute &#39;drop function cleanupListener()&#39;;
		execute &#39;drop function truncateTable(text)&#39;;
	end if;

	-- ----
	-- Changes for 1.2
	-- ----
	if p_old IN (&#39;1.0.2&#39;, &#39;1.0.5&#39;, &#39;1.0.6&#39;, &#39;1.1.0&#39;, &#39;1.1.1&#39;, &#39;1.1.2&#39;, &#39;1.1.3&#39;,&#39;1.1.5&#39;, &#39;1.1.6&#39;, &#39;1.1.7&#39;, &#39;1.1.8&#39;, &#39;1.1.9&#39;) then
		-- Add new table sl_registry
		execute &#39;create table sl_registry (
						reg_key			text primary key,
						reg_int4		int4,
						reg_text		text,
						reg_timestamp	timestamp
					) without oids&#39;;
                execute &#39;alter table sl_config_lock set without oids;&#39;;
                execute &#39;alter table sl_confirm set without oids;&#39;;
                execute &#39;alter table sl_event set without oids;&#39;;
                execute &#39;alter table sl_listen set without oids;&#39;;
                execute &#39;alter table sl_node set without oids;&#39;;
                execute &#39;alter table sl_nodelock set without oids;&#39;;
                execute &#39;alter table sl_path set without oids;&#39;;
                execute &#39;alter table sl_sequence set without oids;&#39;;
                execute &#39;alter table sl_set set without oids;&#39;;
                execute &#39;alter table sl_setsync set without oids;&#39;;
                execute &#39;alter table sl_subscribe set without oids;&#39;;
                execute &#39;alter table sl_table set without oids;&#39;;
                execute &#39;alter table sl_trigger set without oids;&#39;;
	end if;

	-- ----
	-- Changes for 1.2.11
	-- ----
	if p_old IN (&#39;1.0.2&#39;, &#39;1.0.5&#39;, &#39;1.0.6&#39;, &#39;1.1.0&#39;, &#39;1.1.1&#39;, &#39;1.1.2&#39;, &#39;1.1.3&#39;,&#39;1.1.5&#39;, &#39;1.1.6&#39;, &#39;1.1.7&#39;, &#39;1.1.8&#39;, &#39;1.1.9&#39;, &#39;1.2.0&#39;, &#39;1.2.1&#39;, &#39;1.2.2&#39;, &#39;1.2.3&#39;, &#39;1.2.4&#39;, &#39;1.2.5&#39;, &#39;1.2.6&#39;, &#39;1.2.7&#39;, &#39;1.2.8&#39;, &#39;1.2.9&#39;, &#39;1.2.10&#39;) then
		-- Add new table sl_archive_counter
		execute &#39;create table sl_archive_counter (
						ac_num			bigint,
						ac_timestamp	timestamp
					) without oids&#39;;
		execute &#39;insert into sl_archive_counter
					(ac_num, ac_timestamp) values (0, &#39;&#39;epoch&#39;&#39;::timestamp)&#39;;
	end if;

	-- In any version, make sure that the xxidin() functions are defined STRICT
	perform make_function_strict (&#39;xxidin&#39;, &#39;(cstring)&#39;);
	return p_old;
end;</programlisting>
</para>

</section>

</chapter>