Bonjour,
je souhaite alimenter un datawarehouse à partir de BDD sources
sous sql server 2000. Pour cela je pars du principe que
j'alimente seulement le 'delta' mis à jour dans la source
(enregistrements mis à jour depuis le dernier chargement).
Mon but est de minimiser un quelconque impact sur tous processus
transactionnels dans la base source tout en choisissant une
méthode générique. Mon idée est donc de placer un trigger sur
chaques tables sources qui m'intéressent, et qui sur chaque
UPDATE / INSERT, va modifier un champ dédié de la table
appelé 'date_alim_DW'.
Voici le code du trigger :
------------------------------------------------------------------------
CREATE TRIGGER delta_sales ON [dbo].[sales]
AFTER INSERT, UPDATE
AS
-- blocage du phénomène de récursivité
IF ( (SELECT trigger_nestlevel( object_ID('delta_sales') ) ) > 1) RETURN
-- mis à jour du champ date_alim_DW avec la date de jour
UPDATE [dbo].[sales]
SET date_alim_DW = current_timestamp
FROM INSERTED
INNER JOIN [dbo].[sales] ON [dbo].[sales].sales_id = INSERTED.sales_id
------------------------------------------------------------------------
cela fonctionne très bien, cependant :
je suis obligé d'inactiver la récursivité (sinon le trigger
s'auto-appelle !). De même, il n'est pas possible de faire cela
dans le trigger :
exec sp_dboption 'Philippe Database', 'recursive triggers', 'FALSE';
et éventuellement de le repositionner avec sa valeur initiale.
Ma question est double : est-ce que cette méthode vous semble
intéressante pour détecter le 'delta' dans les sources ? de même
est ce qu'il n'y a pas un code plus simple qui permet de modifier
directement les données (comme avec ':NEW.') sans prendre
le risque d'une récursivité ?
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
bruno reiter [MVP]
ne serait-il pas possible d'utiliser une colonne de type timestamp(rowversion) et de stocker le dernier vu dans chaque table à chaque extraction?
br
"laffilippe" wrote in message news:
Bonjour, je souhaite alimenter un datawarehouse à partir de BDD sources sous sql server 2000. Pour cela je pars du principe que j'alimente seulement le 'delta' mis à jour dans la source (enregistrements mis à jour depuis le dernier chargement).
Mon but est de minimiser un quelconque impact sur tous processus transactionnels dans la base source tout en choisissant une méthode générique. Mon idée est donc de placer un trigger sur chaques tables sources qui m'intéressent, et qui sur chaque UPDATE / INSERT, va modifier un champ dédié de la table appelé 'date_alim_DW'.
Voici le code du trigger : ------------------------------------------------------------------------ CREATE TRIGGER delta_sales ON [dbo].[sales] AFTER INSERT, UPDATE AS
-- blocage du phénomène de récursivité IF ( (SELECT trigger_nestlevel( object_ID('delta_sales') ) ) > 1) RETURN
-- mis à jour du champ date_alim_DW avec la date de jour UPDATE [dbo].[sales] SET date_alim_DW = current_timestamp FROM INSERTED INNER JOIN [dbo].[sales] ON [dbo].[sales].sales_id = INSERTED.sales_id ------------------------------------------------------------------------
cela fonctionne très bien, cependant : je suis obligé d'inactiver la récursivité (sinon le trigger s'auto-appelle !). De même, il n'est pas possible de faire cela dans le trigger : exec sp_dboption 'Philippe Database', 'recursive triggers', 'FALSE'; et éventuellement de le repositionner avec sa valeur initiale.
Ma question est double : est-ce que cette méthode vous semble intéressante pour détecter le 'delta' dans les sources ? de même est ce qu'il n'y a pas un code plus simple qui permet de modifier directement les données (comme avec ':NEW.') sans prendre le risque d'une récursivité ?
Merci d'avance pour vos éclairages ! Philippe
ne serait-il pas possible d'utiliser une colonne de type
timestamp(rowversion) et de stocker le dernier vu dans chaque table à chaque
extraction?
br
"laffilippe" <laffilippe@discussions.microsoft.com> wrote in message
news:D7EA8E2B-C40F-42F3-9D69-D56482B57627@microsoft.com...
Bonjour,
je souhaite alimenter un datawarehouse à partir de BDD sources
sous sql server 2000. Pour cela je pars du principe que
j'alimente seulement le 'delta' mis à jour dans la source
(enregistrements mis à jour depuis le dernier chargement).
Mon but est de minimiser un quelconque impact sur tous processus
transactionnels dans la base source tout en choisissant une
méthode générique. Mon idée est donc de placer un trigger sur
chaques tables sources qui m'intéressent, et qui sur chaque
UPDATE / INSERT, va modifier un champ dédié de la table
appelé 'date_alim_DW'.
Voici le code du trigger :
------------------------------------------------------------------------
CREATE TRIGGER delta_sales ON [dbo].[sales]
AFTER INSERT, UPDATE
AS
-- blocage du phénomène de récursivité
IF ( (SELECT trigger_nestlevel( object_ID('delta_sales') ) ) > 1) RETURN
-- mis à jour du champ date_alim_DW avec la date de jour
UPDATE [dbo].[sales]
SET date_alim_DW = current_timestamp
FROM INSERTED
INNER JOIN [dbo].[sales] ON [dbo].[sales].sales_id = INSERTED.sales_id
------------------------------------------------------------------------
cela fonctionne très bien, cependant :
je suis obligé d'inactiver la récursivité (sinon le trigger
s'auto-appelle !). De même, il n'est pas possible de faire cela
dans le trigger :
exec sp_dboption 'Philippe Database', 'recursive triggers', 'FALSE';
et éventuellement de le repositionner avec sa valeur initiale.
Ma question est double : est-ce que cette méthode vous semble
intéressante pour détecter le 'delta' dans les sources ? de même
est ce qu'il n'y a pas un code plus simple qui permet de modifier
directement les données (comme avec ':NEW.') sans prendre
le risque d'une récursivité ?
ne serait-il pas possible d'utiliser une colonne de type timestamp(rowversion) et de stocker le dernier vu dans chaque table à chaque extraction?
br
"laffilippe" wrote in message news:
Bonjour, je souhaite alimenter un datawarehouse à partir de BDD sources sous sql server 2000. Pour cela je pars du principe que j'alimente seulement le 'delta' mis à jour dans la source (enregistrements mis à jour depuis le dernier chargement).
Mon but est de minimiser un quelconque impact sur tous processus transactionnels dans la base source tout en choisissant une méthode générique. Mon idée est donc de placer un trigger sur chaques tables sources qui m'intéressent, et qui sur chaque UPDATE / INSERT, va modifier un champ dédié de la table appelé 'date_alim_DW'.
Voici le code du trigger : ------------------------------------------------------------------------ CREATE TRIGGER delta_sales ON [dbo].[sales] AFTER INSERT, UPDATE AS
-- blocage du phénomène de récursivité IF ( (SELECT trigger_nestlevel( object_ID('delta_sales') ) ) > 1) RETURN
-- mis à jour du champ date_alim_DW avec la date de jour UPDATE [dbo].[sales] SET date_alim_DW = current_timestamp FROM INSERTED INNER JOIN [dbo].[sales] ON [dbo].[sales].sales_id = INSERTED.sales_id ------------------------------------------------------------------------
cela fonctionne très bien, cependant : je suis obligé d'inactiver la récursivité (sinon le trigger s'auto-appelle !). De même, il n'est pas possible de faire cela dans le trigger : exec sp_dboption 'Philippe Database', 'recursive triggers', 'FALSE'; et éventuellement de le repositionner avec sa valeur initiale.
Ma question est double : est-ce que cette méthode vous semble intéressante pour détecter le 'delta' dans les sources ? de même est ce qu'il n'y a pas un code plus simple qui permet de modifier directement les données (comme avec ':NEW.') sans prendre le risque d'une récursivité ?
Merci d'avance pour vos éclairages ! Philippe
Med Bouchenafa
Ne serait-il pas plus simple de mettre en place une replication transactionnelle ?
Bien cordialement Med Bouchenafa
"laffilippe" wrote in message news:
Bonjour, je souhaite alimenter un datawarehouse à partir de BDD sources sous sql server 2000. Pour cela je pars du principe que j'alimente seulement le 'delta' mis à jour dans la source (enregistrements mis à jour depuis le dernier chargement).
Mon but est de minimiser un quelconque impact sur tous processus transactionnels dans la base source tout en choisissant une méthode générique. Mon idée est donc de placer un trigger sur chaques tables sources qui m'intéressent, et qui sur chaque UPDATE / INSERT, va modifier un champ dédié de la table appelé 'date_alim_DW'.
Voici le code du trigger : ------------------------------------------------------------------------ CREATE TRIGGER delta_sales ON [dbo].[sales] AFTER INSERT, UPDATE AS
-- blocage du phénomène de récursivité IF ( (SELECT trigger_nestlevel( object_ID('delta_sales') ) ) > 1) RETURN
-- mis à jour du champ date_alim_DW avec la date de jour UPDATE [dbo].[sales] SET date_alim_DW = current_timestamp FROM INSERTED INNER JOIN [dbo].[sales] ON [dbo].[sales].sales_id = INSERTED.sales_id ------------------------------------------------------------------------
cela fonctionne très bien, cependant : je suis obligé d'inactiver la récursivité (sinon le trigger s'auto-appelle !). De même, il n'est pas possible de faire cela dans le trigger : exec sp_dboption 'Philippe Database', 'recursive triggers', 'FALSE'; et éventuellement de le repositionner avec sa valeur initiale.
Ma question est double : est-ce que cette méthode vous semble intéressante pour détecter le 'delta' dans les sources ? de même est ce qu'il n'y a pas un code plus simple qui permet de modifier directement les données (comme avec ':NEW.') sans prendre le risque d'une récursivité ?
Merci d'avance pour vos éclairages ! Philippe
Ne serait-il pas plus simple de mettre en place une replication
transactionnelle ?
Bien cordialement
Med Bouchenafa
"laffilippe" <laffilippe@discussions.microsoft.com> wrote in message
news:D7EA8E2B-C40F-42F3-9D69-D56482B57627@microsoft.com...
Bonjour,
je souhaite alimenter un datawarehouse à partir de BDD sources
sous sql server 2000. Pour cela je pars du principe que
j'alimente seulement le 'delta' mis à jour dans la source
(enregistrements mis à jour depuis le dernier chargement).
Mon but est de minimiser un quelconque impact sur tous processus
transactionnels dans la base source tout en choisissant une
méthode générique. Mon idée est donc de placer un trigger sur
chaques tables sources qui m'intéressent, et qui sur chaque
UPDATE / INSERT, va modifier un champ dédié de la table
appelé 'date_alim_DW'.
Voici le code du trigger :
------------------------------------------------------------------------
CREATE TRIGGER delta_sales ON [dbo].[sales]
AFTER INSERT, UPDATE
AS
-- blocage du phénomène de récursivité
IF ( (SELECT trigger_nestlevel( object_ID('delta_sales') ) ) > 1) RETURN
-- mis à jour du champ date_alim_DW avec la date de jour
UPDATE [dbo].[sales]
SET date_alim_DW = current_timestamp
FROM INSERTED
INNER JOIN [dbo].[sales] ON [dbo].[sales].sales_id = INSERTED.sales_id
------------------------------------------------------------------------
cela fonctionne très bien, cependant :
je suis obligé d'inactiver la récursivité (sinon le trigger
s'auto-appelle !). De même, il n'est pas possible de faire cela
dans le trigger :
exec sp_dboption 'Philippe Database', 'recursive triggers', 'FALSE';
et éventuellement de le repositionner avec sa valeur initiale.
Ma question est double : est-ce que cette méthode vous semble
intéressante pour détecter le 'delta' dans les sources ? de même
est ce qu'il n'y a pas un code plus simple qui permet de modifier
directement les données (comme avec ':NEW.') sans prendre
le risque d'une récursivité ?
Ne serait-il pas plus simple de mettre en place une replication transactionnelle ?
Bien cordialement Med Bouchenafa
"laffilippe" wrote in message news:
Bonjour, je souhaite alimenter un datawarehouse à partir de BDD sources sous sql server 2000. Pour cela je pars du principe que j'alimente seulement le 'delta' mis à jour dans la source (enregistrements mis à jour depuis le dernier chargement).
Mon but est de minimiser un quelconque impact sur tous processus transactionnels dans la base source tout en choisissant une méthode générique. Mon idée est donc de placer un trigger sur chaques tables sources qui m'intéressent, et qui sur chaque UPDATE / INSERT, va modifier un champ dédié de la table appelé 'date_alim_DW'.
Voici le code du trigger : ------------------------------------------------------------------------ CREATE TRIGGER delta_sales ON [dbo].[sales] AFTER INSERT, UPDATE AS
-- blocage du phénomène de récursivité IF ( (SELECT trigger_nestlevel( object_ID('delta_sales') ) ) > 1) RETURN
-- mis à jour du champ date_alim_DW avec la date de jour UPDATE [dbo].[sales] SET date_alim_DW = current_timestamp FROM INSERTED INNER JOIN [dbo].[sales] ON [dbo].[sales].sales_id = INSERTED.sales_id ------------------------------------------------------------------------
cela fonctionne très bien, cependant : je suis obligé d'inactiver la récursivité (sinon le trigger s'auto-appelle !). De même, il n'est pas possible de faire cela dans le trigger : exec sp_dboption 'Philippe Database', 'recursive triggers', 'FALSE'; et éventuellement de le repositionner avec sa valeur initiale.
Ma question est double : est-ce que cette méthode vous semble intéressante pour détecter le 'delta' dans les sources ? de même est ce qu'il n'y a pas un code plus simple qui permet de modifier directement les données (comme avec ':NEW.') sans prendre le risque d'une récursivité ?
Merci d'avance pour vos éclairages ! Philippe
laffilippe
Je ne connais pas les 2 solutions proposées, mais je vais les regarder de près, merci pour ces propositions. Philippe
"Med Bouchenafa" a écrit :
Ne serait-il pas plus simple de mettre en place une replication transactionnelle ?
Bien cordialement Med Bouchenafa
"laffilippe" wrote in message news: > Bonjour, > je souhaite alimenter un datawarehouse à partir de BDD sources > sous sql server 2000. Pour cela je pars du principe que > j'alimente seulement le 'delta' mis à jour dans la source > (enregistrements mis à jour depuis le dernier chargement). > > Mon but est de minimiser un quelconque impact sur tous processus > transactionnels dans la base source tout en choisissant une > méthode générique. Mon idée est donc de placer un trigger sur > chaques tables sources qui m'intéressent, et qui sur chaque > UPDATE / INSERT, va modifier un champ dédié de la table > appelé 'date_alim_DW'. > > Voici le code du trigger : > ------------------------------------------------------------------------ > CREATE TRIGGER delta_sales ON [dbo].[sales] > AFTER INSERT, UPDATE > AS > > -- blocage du phénomène de récursivité > IF ( (SELECT trigger_nestlevel( object_ID('delta_sales') ) ) > 1) RETURN > > -- mis à jour du champ date_alim_DW avec la date de jour > UPDATE [dbo].[sales] > SET date_alim_DW = current_timestamp > FROM INSERTED > INNER JOIN [dbo].[sales] ON [dbo].[sales].sales_id = INSERTED.sales_id > ------------------------------------------------------------------------ > > cela fonctionne très bien, cependant : > je suis obligé d'inactiver la récursivité (sinon le trigger > s'auto-appelle !). De même, il n'est pas possible de faire cela > dans le trigger : > exec sp_dboption 'Philippe Database', 'recursive triggers', 'FALSE'; > et éventuellement de le repositionner avec sa valeur initiale. > > Ma question est double : est-ce que cette méthode vous semble > intéressante pour détecter le 'delta' dans les sources ? de même > est ce qu'il n'y a pas un code plus simple qui permet de modifier > directement les données (comme avec ':NEW.') sans prendre > le risque d'une récursivité ? > > Merci d'avance pour vos éclairages ! > Philippe
Je ne connais pas les 2 solutions proposées, mais je vais les regarder
de près, merci pour ces propositions.
Philippe
"Med Bouchenafa" a écrit :
Ne serait-il pas plus simple de mettre en place une replication
transactionnelle ?
Bien cordialement
Med Bouchenafa
"laffilippe" <laffilippe@discussions.microsoft.com> wrote in message
news:D7EA8E2B-C40F-42F3-9D69-D56482B57627@microsoft.com...
> Bonjour,
> je souhaite alimenter un datawarehouse à partir de BDD sources
> sous sql server 2000. Pour cela je pars du principe que
> j'alimente seulement le 'delta' mis à jour dans la source
> (enregistrements mis à jour depuis le dernier chargement).
>
> Mon but est de minimiser un quelconque impact sur tous processus
> transactionnels dans la base source tout en choisissant une
> méthode générique. Mon idée est donc de placer un trigger sur
> chaques tables sources qui m'intéressent, et qui sur chaque
> UPDATE / INSERT, va modifier un champ dédié de la table
> appelé 'date_alim_DW'.
>
> Voici le code du trigger :
> ------------------------------------------------------------------------
> CREATE TRIGGER delta_sales ON [dbo].[sales]
> AFTER INSERT, UPDATE
> AS
>
> -- blocage du phénomène de récursivité
> IF ( (SELECT trigger_nestlevel( object_ID('delta_sales') ) ) > 1) RETURN
>
> -- mis à jour du champ date_alim_DW avec la date de jour
> UPDATE [dbo].[sales]
> SET date_alim_DW = current_timestamp
> FROM INSERTED
> INNER JOIN [dbo].[sales] ON [dbo].[sales].sales_id = INSERTED.sales_id
> ------------------------------------------------------------------------
>
> cela fonctionne très bien, cependant :
> je suis obligé d'inactiver la récursivité (sinon le trigger
> s'auto-appelle !). De même, il n'est pas possible de faire cela
> dans le trigger :
> exec sp_dboption 'Philippe Database', 'recursive triggers', 'FALSE';
> et éventuellement de le repositionner avec sa valeur initiale.
>
> Ma question est double : est-ce que cette méthode vous semble
> intéressante pour détecter le 'delta' dans les sources ? de même
> est ce qu'il n'y a pas un code plus simple qui permet de modifier
> directement les données (comme avec ':NEW.') sans prendre
> le risque d'une récursivité ?
>
> Merci d'avance pour vos éclairages !
> Philippe
Je ne connais pas les 2 solutions proposées, mais je vais les regarder de près, merci pour ces propositions. Philippe
"Med Bouchenafa" a écrit :
Ne serait-il pas plus simple de mettre en place une replication transactionnelle ?
Bien cordialement Med Bouchenafa
"laffilippe" wrote in message news: > Bonjour, > je souhaite alimenter un datawarehouse à partir de BDD sources > sous sql server 2000. Pour cela je pars du principe que > j'alimente seulement le 'delta' mis à jour dans la source > (enregistrements mis à jour depuis le dernier chargement). > > Mon but est de minimiser un quelconque impact sur tous processus > transactionnels dans la base source tout en choisissant une > méthode générique. Mon idée est donc de placer un trigger sur > chaques tables sources qui m'intéressent, et qui sur chaque > UPDATE / INSERT, va modifier un champ dédié de la table > appelé 'date_alim_DW'. > > Voici le code du trigger : > ------------------------------------------------------------------------ > CREATE TRIGGER delta_sales ON [dbo].[sales] > AFTER INSERT, UPDATE > AS > > -- blocage du phénomène de récursivité > IF ( (SELECT trigger_nestlevel( object_ID('delta_sales') ) ) > 1) RETURN > > -- mis à jour du champ date_alim_DW avec la date de jour > UPDATE [dbo].[sales] > SET date_alim_DW = current_timestamp > FROM INSERTED > INNER JOIN [dbo].[sales] ON [dbo].[sales].sales_id = INSERTED.sales_id > ------------------------------------------------------------------------ > > cela fonctionne très bien, cependant : > je suis obligé d'inactiver la récursivité (sinon le trigger > s'auto-appelle !). De même, il n'est pas possible de faire cela > dans le trigger : > exec sp_dboption 'Philippe Database', 'recursive triggers', 'FALSE'; > et éventuellement de le repositionner avec sa valeur initiale. > > Ma question est double : est-ce que cette méthode vous semble > intéressante pour détecter le 'delta' dans les sources ? de même > est ce qu'il n'y a pas un code plus simple qui permet de modifier > directement les données (comme avec ':NEW.') sans prendre > le risque d'une récursivité ? > > Merci d'avance pour vos éclairages ! > Philippe
