Bonjour,
Voila nous avons un vieil Unix SCO Open Server avec un outil PROGRESS, et
de temps en temps nous récupérons des requêtes via ODBC et une instruction
OPENQUERY. Si on fait cela c'est parce qu'il n'y a pas de sécurité avec
les drivers que l'on a, et donc comme on ne veut pas que n'importe qui
puisse toucher aux données, on passe par MSSQL qui lui interroge les
données qu'on lui demande en fonction du login.
Ca fonctionne plutôt bien, mais nous recontrons un problème agaçant. Je
pose la situation pour essayer d'être clair :)
On a deux tables A et B avec une clé primaire sur chacune A.cle et b.cle
et dans B on a une clé étrangère : B.a_cle = A.cle
Nous faisons une requête avec une jointure externe
SELECT * FROM A left join B on A.cle = B.a_cle
Comme A.cle et B.cle sont des clés primaires, ODBC nous indique que ces
deux champs sont NOT NULL dans la définition de la requête. Mais comme
c'est une jointure externe potentiellement B.cle peut être NULL, et a ce
moment là on obtient une erreur "Valeur NULL inattendue ...".
Je suppose que OPENQUERY créé une table temporaire pour stocker le
résultat, car quand on fait une interrogation directement en ODBC on a pas
ce problème (sauf si on utilise un système qui vérifie les contraintes).
De plus nous ne sommes pas parvenu à empêcher les drivers ODBC de
retourner cette information NOT NULL (se sont des vieux drivers et nous
n'avons pas le choix car nous avons un vieux SCO :) )
Alors ma question est : Existe-t-il un moyen d'empêcher OPENQUERY de
mettre cette contrainte ou de ne pas la prendre en compte, ou alors
peut-être au niveau du serveur lié ?
Voila j'espère que vous avez tout compris :)
A++
Yanos
Bonjour,
Voila nous avons un vieil Unix SCO Open Server avec un outil PROGRESS, et
de temps en temps nous récupérons des requêtes via ODBC et une instruction
OPENQUERY. Si on fait cela c'est parce qu'il n'y a pas de sécurité avec
les drivers que l'on a, et donc comme on ne veut pas que n'importe qui
puisse toucher aux données, on passe par MSSQL qui lui interroge les
données qu'on lui demande en fonction du login.
Ca fonctionne plutôt bien, mais nous recontrons un problème agaçant. Je
pose la situation pour essayer d'être clair :)
On a deux tables A et B avec une clé primaire sur chacune A.cle et b.cle
et dans B on a une clé étrangère : B.a_cle = A.cle
Nous faisons une requête avec une jointure externe
SELECT * FROM A left join B on A.cle = B.a_cle
Comme A.cle et B.cle sont des clés primaires, ODBC nous indique que ces
deux champs sont NOT NULL dans la définition de la requête. Mais comme
c'est une jointure externe potentiellement B.cle peut être NULL, et a ce
moment là on obtient une erreur "Valeur NULL inattendue ...".
Je suppose que OPENQUERY créé une table temporaire pour stocker le
résultat, car quand on fait une interrogation directement en ODBC on a pas
ce problème (sauf si on utilise un système qui vérifie les contraintes).
De plus nous ne sommes pas parvenu à empêcher les drivers ODBC de
retourner cette information NOT NULL (se sont des vieux drivers et nous
n'avons pas le choix car nous avons un vieux SCO :) )
Alors ma question est : Existe-t-il un moyen d'empêcher OPENQUERY de
mettre cette contrainte ou de ne pas la prendre en compte, ou alors
peut-être au niveau du serveur lié ?
Voila j'espère que vous avez tout compris :)
A++
Yanos
Bonjour,
Voila nous avons un vieil Unix SCO Open Server avec un outil PROGRESS, et
de temps en temps nous récupérons des requêtes via ODBC et une instruction
OPENQUERY. Si on fait cela c'est parce qu'il n'y a pas de sécurité avec
les drivers que l'on a, et donc comme on ne veut pas que n'importe qui
puisse toucher aux données, on passe par MSSQL qui lui interroge les
données qu'on lui demande en fonction du login.
Ca fonctionne plutôt bien, mais nous recontrons un problème agaçant. Je
pose la situation pour essayer d'être clair :)
On a deux tables A et B avec une clé primaire sur chacune A.cle et b.cle
et dans B on a une clé étrangère : B.a_cle = A.cle
Nous faisons une requête avec une jointure externe
SELECT * FROM A left join B on A.cle = B.a_cle
Comme A.cle et B.cle sont des clés primaires, ODBC nous indique que ces
deux champs sont NOT NULL dans la définition de la requête. Mais comme
c'est une jointure externe potentiellement B.cle peut être NULL, et a ce
moment là on obtient une erreur "Valeur NULL inattendue ...".
Je suppose que OPENQUERY créé une table temporaire pour stocker le
résultat, car quand on fait une interrogation directement en ODBC on a pas
ce problème (sauf si on utilise un système qui vérifie les contraintes).
De plus nous ne sommes pas parvenu à empêcher les drivers ODBC de
retourner cette information NOT NULL (se sont des vieux drivers et nous
n'avons pas le choix car nous avons un vieux SCO :) )
Alors ma question est : Existe-t-il un moyen d'empêcher OPENQUERY de
mettre cette contrainte ou de ne pas la prendre en compte, ou alors
peut-être au niveau du serveur lié ?
Voila j'espère que vous avez tout compris :)
A++
Yanos
Si la quantité de données n'est pas excessive, stockez les données de
l'OpenQuery dans une table temporaire (permanente?) et faites vos
manipulations à partir de cette dernière.
S. L.
"Yanos El Guerilleros" wrote in message
news:uuLj93%Bonjour,
Voila nous avons un vieil Unix SCO Open Server avec un outil PROGRESS, et
de temps en temps nous récupérons des requêtes via ODBC et une instruction
OPENQUERY. Si on fait cela c'est parce qu'il n'y a pas de sécurité avec
les drivers que l'on a, et donc comme on ne veut pas que n'importe qui
puisse toucher aux données, on passe par MSSQL qui lui interroge les
données qu'on lui demande en fonction du login.
Ca fonctionne plutôt bien, mais nous recontrons un problème agaçant. Je
pose la situation pour essayer d'être clair :)
On a deux tables A et B avec une clé primaire sur chacune A.cle et b.cle
et dans B on a une clé étrangère : B.a_cle = A.cle
Nous faisons une requête avec une jointure externe
SELECT * FROM A left join B on A.cle = B.a_cle
Comme A.cle et B.cle sont des clés primaires, ODBC nous indique que ces
deux champs sont NOT NULL dans la définition de la requête. Mais comme
c'est une jointure externe potentiellement B.cle peut être NULL, et a ce
moment là on obtient une erreur "Valeur NULL inattendue ...".
Je suppose que OPENQUERY créé une table temporaire pour stocker le
résultat, car quand on fait une interrogation directement en ODBC on a pas
ce problème (sauf si on utilise un système qui vérifie les contraintes).
De plus nous ne sommes pas parvenu à empêcher les drivers ODBC de
retourner cette information NOT NULL (se sont des vieux drivers et nous
n'avons pas le choix car nous avons un vieux SCO :) )
Alors ma question est : Existe-t-il un moyen d'empêcher OPENQUERY de
mettre cette contrainte ou de ne pas la prendre en compte, ou alors
peut-être au niveau du serveur lié ?
Voila j'espère que vous avez tout compris :)
A++
Yanos
Si la quantité de données n'est pas excessive, stockez les données de
l'OpenQuery dans une table temporaire (permanente?) et faites vos
manipulations à partir de cette dernière.
S. L.
"Yanos El Guerilleros" <yeg_NO_@_SPAM_yegounet.net> wrote in message
news:uuLj93%23IFHA.2784@TK2MSFTNGP09.phx.gbl...
Bonjour,
Voila nous avons un vieil Unix SCO Open Server avec un outil PROGRESS, et
de temps en temps nous récupérons des requêtes via ODBC et une instruction
OPENQUERY. Si on fait cela c'est parce qu'il n'y a pas de sécurité avec
les drivers que l'on a, et donc comme on ne veut pas que n'importe qui
puisse toucher aux données, on passe par MSSQL qui lui interroge les
données qu'on lui demande en fonction du login.
Ca fonctionne plutôt bien, mais nous recontrons un problème agaçant. Je
pose la situation pour essayer d'être clair :)
On a deux tables A et B avec une clé primaire sur chacune A.cle et b.cle
et dans B on a une clé étrangère : B.a_cle = A.cle
Nous faisons une requête avec une jointure externe
SELECT * FROM A left join B on A.cle = B.a_cle
Comme A.cle et B.cle sont des clés primaires, ODBC nous indique que ces
deux champs sont NOT NULL dans la définition de la requête. Mais comme
c'est une jointure externe potentiellement B.cle peut être NULL, et a ce
moment là on obtient une erreur "Valeur NULL inattendue ...".
Je suppose que OPENQUERY créé une table temporaire pour stocker le
résultat, car quand on fait une interrogation directement en ODBC on a pas
ce problème (sauf si on utilise un système qui vérifie les contraintes).
De plus nous ne sommes pas parvenu à empêcher les drivers ODBC de
retourner cette information NOT NULL (se sont des vieux drivers et nous
n'avons pas le choix car nous avons un vieux SCO :) )
Alors ma question est : Existe-t-il un moyen d'empêcher OPENQUERY de
mettre cette contrainte ou de ne pas la prendre en compte, ou alors
peut-être au niveau du serveur lié ?
Voila j'espère que vous avez tout compris :)
A++
Yanos
Si la quantité de données n'est pas excessive, stockez les données de
l'OpenQuery dans une table temporaire (permanente?) et faites vos
manipulations à partir de cette dernière.
S. L.
"Yanos El Guerilleros" wrote in message
news:uuLj93%Bonjour,
Voila nous avons un vieil Unix SCO Open Server avec un outil PROGRESS, et
de temps en temps nous récupérons des requêtes via ODBC et une instruction
OPENQUERY. Si on fait cela c'est parce qu'il n'y a pas de sécurité avec
les drivers que l'on a, et donc comme on ne veut pas que n'importe qui
puisse toucher aux données, on passe par MSSQL qui lui interroge les
données qu'on lui demande en fonction du login.
Ca fonctionne plutôt bien, mais nous recontrons un problème agaçant. Je
pose la situation pour essayer d'être clair :)
On a deux tables A et B avec une clé primaire sur chacune A.cle et b.cle
et dans B on a une clé étrangère : B.a_cle = A.cle
Nous faisons une requête avec une jointure externe
SELECT * FROM A left join B on A.cle = B.a_cle
Comme A.cle et B.cle sont des clés primaires, ODBC nous indique que ces
deux champs sont NOT NULL dans la définition de la requête. Mais comme
c'est une jointure externe potentiellement B.cle peut être NULL, et a ce
moment là on obtient une erreur "Valeur NULL inattendue ...".
Je suppose que OPENQUERY créé une table temporaire pour stocker le
résultat, car quand on fait une interrogation directement en ODBC on a pas
ce problème (sauf si on utilise un système qui vérifie les contraintes).
De plus nous ne sommes pas parvenu à empêcher les drivers ODBC de
retourner cette information NOT NULL (se sont des vieux drivers et nous
n'avons pas le choix car nous avons un vieux SCO :) )
Alors ma question est : Existe-t-il un moyen d'empêcher OPENQUERY de
mettre cette contrainte ou de ne pas la prendre en compte, ou alors
peut-être au niveau du serveur lié ?
Voila j'espère que vous avez tout compris :)
A++
Yanos
Je ne peux pas, l'erreur est là dés l'OPENQUERY :)
Après quelques autres essaie il s'avère que l'on a le même problème avec
l'ADO alors ce n'est peut-être pas l'OPENQUERY mais carrément l'ADO (je ne
sais pas trop comment ca se goupille tout ca).
Je crois qu'on ne va pas se battre dix ans avec ca, on va continuer comme
on fait d'habitude, c'est casse-pied mais tant pis.
Merci quand même
A++
Yanos
Sylvain Lafontaine a écrit :Si la quantité de données n'est pas excessive, stockez les données de
l'OpenQuery dans une table temporaire (permanente?) et faites vos
manipulations à partir de cette dernière.
S. L.
"Yanos El Guerilleros" wrote in message
news:uuLj93%Bonjour,
Voila nous avons un vieil Unix SCO Open Server avec un outil PROGRESS, et
de temps en temps nous récupérons des requêtes via ODBC et une
instruction OPENQUERY. Si on fait cela c'est parce qu'il n'y a pas de
sécurité avec les drivers que l'on a, et donc comme on ne veut pas que
n'importe qui puisse toucher aux données, on passe par MSSQL qui lui
interroge les données qu'on lui demande en fonction du login.
Ca fonctionne plutôt bien, mais nous recontrons un problème agaçant. Je
pose la situation pour essayer d'être clair :)
On a deux tables A et B avec une clé primaire sur chacune A.cle et b.cle
et dans B on a une clé étrangère : B.a_cle = A.cle
Nous faisons une requête avec une jointure externe
SELECT * FROM A left join B on A.cle = B.a_cle
Comme A.cle et B.cle sont des clés primaires, ODBC nous indique que ces
deux champs sont NOT NULL dans la définition de la requête. Mais comme
c'est une jointure externe potentiellement B.cle peut être NULL, et a ce
moment là on obtient une erreur "Valeur NULL inattendue ...".
Je suppose que OPENQUERY créé une table temporaire pour stocker le
résultat, car quand on fait une interrogation directement en ODBC on a
pas ce problème (sauf si on utilise un système qui vérifie les
contraintes). De plus nous ne sommes pas parvenu à empêcher les drivers
ODBC de retourner cette information NOT NULL (se sont des vieux drivers
et nous n'avons pas le choix car nous avons un vieux SCO :) )
Alors ma question est : Existe-t-il un moyen d'empêcher OPENQUERY de
mettre cette contrainte ou de ne pas la prendre en compte, ou alors
peut-être au niveau du serveur lié ?
Voila j'espère que vous avez tout compris :)
A++
Yanos
Je ne peux pas, l'erreur est là dés l'OPENQUERY :)
Après quelques autres essaie il s'avère que l'on a le même problème avec
l'ADO alors ce n'est peut-être pas l'OPENQUERY mais carrément l'ADO (je ne
sais pas trop comment ca se goupille tout ca).
Je crois qu'on ne va pas se battre dix ans avec ca, on va continuer comme
on fait d'habitude, c'est casse-pied mais tant pis.
Merci quand même
A++
Yanos
Sylvain Lafontaine a écrit :
Si la quantité de données n'est pas excessive, stockez les données de
l'OpenQuery dans une table temporaire (permanente?) et faites vos
manipulations à partir de cette dernière.
S. L.
"Yanos El Guerilleros" <yeg_NO_@_SPAM_yegounet.net> wrote in message
news:uuLj93%23IFHA.2784@TK2MSFTNGP09.phx.gbl...
Bonjour,
Voila nous avons un vieil Unix SCO Open Server avec un outil PROGRESS, et
de temps en temps nous récupérons des requêtes via ODBC et une
instruction OPENQUERY. Si on fait cela c'est parce qu'il n'y a pas de
sécurité avec les drivers que l'on a, et donc comme on ne veut pas que
n'importe qui puisse toucher aux données, on passe par MSSQL qui lui
interroge les données qu'on lui demande en fonction du login.
Ca fonctionne plutôt bien, mais nous recontrons un problème agaçant. Je
pose la situation pour essayer d'être clair :)
On a deux tables A et B avec une clé primaire sur chacune A.cle et b.cle
et dans B on a une clé étrangère : B.a_cle = A.cle
Nous faisons une requête avec une jointure externe
SELECT * FROM A left join B on A.cle = B.a_cle
Comme A.cle et B.cle sont des clés primaires, ODBC nous indique que ces
deux champs sont NOT NULL dans la définition de la requête. Mais comme
c'est une jointure externe potentiellement B.cle peut être NULL, et a ce
moment là on obtient une erreur "Valeur NULL inattendue ...".
Je suppose que OPENQUERY créé une table temporaire pour stocker le
résultat, car quand on fait une interrogation directement en ODBC on a
pas ce problème (sauf si on utilise un système qui vérifie les
contraintes). De plus nous ne sommes pas parvenu à empêcher les drivers
ODBC de retourner cette information NOT NULL (se sont des vieux drivers
et nous n'avons pas le choix car nous avons un vieux SCO :) )
Alors ma question est : Existe-t-il un moyen d'empêcher OPENQUERY de
mettre cette contrainte ou de ne pas la prendre en compte, ou alors
peut-être au niveau du serveur lié ?
Voila j'espère que vous avez tout compris :)
A++
Yanos
Je ne peux pas, l'erreur est là dés l'OPENQUERY :)
Après quelques autres essaie il s'avère que l'on a le même problème avec
l'ADO alors ce n'est peut-être pas l'OPENQUERY mais carrément l'ADO (je ne
sais pas trop comment ca se goupille tout ca).
Je crois qu'on ne va pas se battre dix ans avec ca, on va continuer comme
on fait d'habitude, c'est casse-pied mais tant pis.
Merci quand même
A++
Yanos
Sylvain Lafontaine a écrit :Si la quantité de données n'est pas excessive, stockez les données de
l'OpenQuery dans une table temporaire (permanente?) et faites vos
manipulations à partir de cette dernière.
S. L.
"Yanos El Guerilleros" wrote in message
news:uuLj93%Bonjour,
Voila nous avons un vieil Unix SCO Open Server avec un outil PROGRESS, et
de temps en temps nous récupérons des requêtes via ODBC et une
instruction OPENQUERY. Si on fait cela c'est parce qu'il n'y a pas de
sécurité avec les drivers que l'on a, et donc comme on ne veut pas que
n'importe qui puisse toucher aux données, on passe par MSSQL qui lui
interroge les données qu'on lui demande en fonction du login.
Ca fonctionne plutôt bien, mais nous recontrons un problème agaçant. Je
pose la situation pour essayer d'être clair :)
On a deux tables A et B avec une clé primaire sur chacune A.cle et b.cle
et dans B on a une clé étrangère : B.a_cle = A.cle
Nous faisons une requête avec une jointure externe
SELECT * FROM A left join B on A.cle = B.a_cle
Comme A.cle et B.cle sont des clés primaires, ODBC nous indique que ces
deux champs sont NOT NULL dans la définition de la requête. Mais comme
c'est une jointure externe potentiellement B.cle peut être NULL, et a ce
moment là on obtient une erreur "Valeur NULL inattendue ...".
Je suppose que OPENQUERY créé une table temporaire pour stocker le
résultat, car quand on fait une interrogation directement en ODBC on a
pas ce problème (sauf si on utilise un système qui vérifie les
contraintes). De plus nous ne sommes pas parvenu à empêcher les drivers
ODBC de retourner cette information NOT NULL (se sont des vieux drivers
et nous n'avons pas le choix car nous avons un vieux SCO :) )
Alors ma question est : Existe-t-il un moyen d'empêcher OPENQUERY de
mettre cette contrainte ou de ne pas la prendre en compte, ou alors
peut-être au niveau du serveur lié ?
Voila j'espère que vous avez tout compris :)
A++
Yanos
Alors peut-être remplacer le Left Join par une UNION et un Not Exists() dans
la deuxième sous-requêtes? Cela vous permettrait de remplacer les valeurs
Nulles par autre chose.
S. L.
"Yanos El Guerilleros" wrote in message
news:u$qq5x$Je ne peux pas, l'erreur est là dés l'OPENQUERY :)
Après quelques autres essaie il s'avère que l'on a le même problème avec
l'ADO alors ce n'est peut-être pas l'OPENQUERY mais carrément l'ADO (je ne
sais pas trop comment ca se goupille tout ca).
Je crois qu'on ne va pas se battre dix ans avec ca, on va continuer comme
on fait d'habitude, c'est casse-pied mais tant pis.
Merci quand même
A++
Yanos
Sylvain Lafontaine a écrit :Si la quantité de données n'est pas excessive, stockez les données de
l'OpenQuery dans une table temporaire (permanente?) et faites vos
manipulations à partir de cette dernière.
S. L.
"Yanos El Guerilleros" wrote in message
news:uuLj93%Bonjour,
Voila nous avons un vieil Unix SCO Open Server avec un outil PROGRESS, et
de temps en temps nous récupérons des requêtes via ODBC et une
instruction OPENQUERY. Si on fait cela c'est parce qu'il n'y a pas de
sécurité avec les drivers que l'on a, et donc comme on ne veut pas que
n'importe qui puisse toucher aux données, on passe par MSSQL qui lui
interroge les données qu'on lui demande en fonction du login.
Ca fonctionne plutôt bien, mais nous recontrons un problème agaçant. Je
pose la situation pour essayer d'être clair :)
On a deux tables A et B avec une clé primaire sur chacune A.cle et b.cle
et dans B on a une clé étrangère : B.a_cle = A.cle
Nous faisons une requête avec une jointure externe
SELECT * FROM A left join B on A.cle = B.a_cle
Comme A.cle et B.cle sont des clés primaires, ODBC nous indique que ces
deux champs sont NOT NULL dans la définition de la requête. Mais comme
c'est une jointure externe potentiellement B.cle peut être NULL, et a ce
moment là on obtient une erreur "Valeur NULL inattendue ...".
Je suppose que OPENQUERY créé une table temporaire pour stocker le
résultat, car quand on fait une interrogation directement en ODBC on a
pas ce problème (sauf si on utilise un système qui vérifie les
contraintes). De plus nous ne sommes pas parvenu à empêcher les drivers
ODBC de retourner cette information NOT NULL (se sont des vieux drivers
et nous n'avons pas le choix car nous avons un vieux SCO :) )
Alors ma question est : Existe-t-il un moyen d'empêcher OPENQUERY de
mettre cette contrainte ou de ne pas la prendre en compte, ou alors
peut-être au niveau du serveur lié ?
Voila j'espère que vous avez tout compris :)
A++
Yanos
Alors peut-être remplacer le Left Join par une UNION et un Not Exists() dans
la deuxième sous-requêtes? Cela vous permettrait de remplacer les valeurs
Nulles par autre chose.
S. L.
"Yanos El Guerilleros" <yeg_NO_@_SPAM_yegounet.net> wrote in message
news:u$qq5x$IFHA.2356@TK2MSFTNGP14.phx.gbl...
Je ne peux pas, l'erreur est là dés l'OPENQUERY :)
Après quelques autres essaie il s'avère que l'on a le même problème avec
l'ADO alors ce n'est peut-être pas l'OPENQUERY mais carrément l'ADO (je ne
sais pas trop comment ca se goupille tout ca).
Je crois qu'on ne va pas se battre dix ans avec ca, on va continuer comme
on fait d'habitude, c'est casse-pied mais tant pis.
Merci quand même
A++
Yanos
Sylvain Lafontaine a écrit :
Si la quantité de données n'est pas excessive, stockez les données de
l'OpenQuery dans une table temporaire (permanente?) et faites vos
manipulations à partir de cette dernière.
S. L.
"Yanos El Guerilleros" <yeg_NO_@_SPAM_yegounet.net> wrote in message
news:uuLj93%23IFHA.2784@TK2MSFTNGP09.phx.gbl...
Bonjour,
Voila nous avons un vieil Unix SCO Open Server avec un outil PROGRESS, et
de temps en temps nous récupérons des requêtes via ODBC et une
instruction OPENQUERY. Si on fait cela c'est parce qu'il n'y a pas de
sécurité avec les drivers que l'on a, et donc comme on ne veut pas que
n'importe qui puisse toucher aux données, on passe par MSSQL qui lui
interroge les données qu'on lui demande en fonction du login.
Ca fonctionne plutôt bien, mais nous recontrons un problème agaçant. Je
pose la situation pour essayer d'être clair :)
On a deux tables A et B avec une clé primaire sur chacune A.cle et b.cle
et dans B on a une clé étrangère : B.a_cle = A.cle
Nous faisons une requête avec une jointure externe
SELECT * FROM A left join B on A.cle = B.a_cle
Comme A.cle et B.cle sont des clés primaires, ODBC nous indique que ces
deux champs sont NOT NULL dans la définition de la requête. Mais comme
c'est une jointure externe potentiellement B.cle peut être NULL, et a ce
moment là on obtient une erreur "Valeur NULL inattendue ...".
Je suppose que OPENQUERY créé une table temporaire pour stocker le
résultat, car quand on fait une interrogation directement en ODBC on a
pas ce problème (sauf si on utilise un système qui vérifie les
contraintes). De plus nous ne sommes pas parvenu à empêcher les drivers
ODBC de retourner cette information NOT NULL (se sont des vieux drivers
et nous n'avons pas le choix car nous avons un vieux SCO :) )
Alors ma question est : Existe-t-il un moyen d'empêcher OPENQUERY de
mettre cette contrainte ou de ne pas la prendre en compte, ou alors
peut-être au niveau du serveur lié ?
Voila j'espère que vous avez tout compris :)
A++
Yanos
Alors peut-être remplacer le Left Join par une UNION et un Not Exists() dans
la deuxième sous-requêtes? Cela vous permettrait de remplacer les valeurs
Nulles par autre chose.
S. L.
"Yanos El Guerilleros" wrote in message
news:u$qq5x$Je ne peux pas, l'erreur est là dés l'OPENQUERY :)
Après quelques autres essaie il s'avère que l'on a le même problème avec
l'ADO alors ce n'est peut-être pas l'OPENQUERY mais carrément l'ADO (je ne
sais pas trop comment ca se goupille tout ca).
Je crois qu'on ne va pas se battre dix ans avec ca, on va continuer comme
on fait d'habitude, c'est casse-pied mais tant pis.
Merci quand même
A++
Yanos
Sylvain Lafontaine a écrit :Si la quantité de données n'est pas excessive, stockez les données de
l'OpenQuery dans une table temporaire (permanente?) et faites vos
manipulations à partir de cette dernière.
S. L.
"Yanos El Guerilleros" wrote in message
news:uuLj93%Bonjour,
Voila nous avons un vieil Unix SCO Open Server avec un outil PROGRESS, et
de temps en temps nous récupérons des requêtes via ODBC et une
instruction OPENQUERY. Si on fait cela c'est parce qu'il n'y a pas de
sécurité avec les drivers que l'on a, et donc comme on ne veut pas que
n'importe qui puisse toucher aux données, on passe par MSSQL qui lui
interroge les données qu'on lui demande en fonction du login.
Ca fonctionne plutôt bien, mais nous recontrons un problème agaçant. Je
pose la situation pour essayer d'être clair :)
On a deux tables A et B avec une clé primaire sur chacune A.cle et b.cle
et dans B on a une clé étrangère : B.a_cle = A.cle
Nous faisons une requête avec une jointure externe
SELECT * FROM A left join B on A.cle = B.a_cle
Comme A.cle et B.cle sont des clés primaires, ODBC nous indique que ces
deux champs sont NOT NULL dans la définition de la requête. Mais comme
c'est une jointure externe potentiellement B.cle peut être NULL, et a ce
moment là on obtient une erreur "Valeur NULL inattendue ...".
Je suppose que OPENQUERY créé une table temporaire pour stocker le
résultat, car quand on fait une interrogation directement en ODBC on a
pas ce problème (sauf si on utilise un système qui vérifie les
contraintes). De plus nous ne sommes pas parvenu à empêcher les drivers
ODBC de retourner cette information NOT NULL (se sont des vieux drivers
et nous n'avons pas le choix car nous avons un vieux SCO :) )
Alors ma question est : Existe-t-il un moyen d'empêcher OPENQUERY de
mettre cette contrainte ou de ne pas la prendre en compte, ou alors
peut-être au niveau du serveur lié ?
Voila j'espère que vous avez tout compris :)
A++
Yanos
Bonjour,
Voila nous avons un vieil Unix SCO Open Server avec un outil PROGRESS, et
de temps en temps nous récupérons des requêtes via ODBC et une instruction
OPENQUERY. Si on fait cela c'est parce qu'il n'y a pas de sécurité avec
les drivers que l'on a, et donc comme on ne veut pas que n'importe qui
puisse toucher aux données, on passe par MSSQL qui lui interroge les
données qu'on lui demande en fonction du login.
Ca fonctionne plutôt bien, mais nous recontrons un problème agaçant. Je
pose la situation pour essayer d'être clair :)
On a deux tables A et B avec une clé primaire sur chacune A.cle et b.cle
et dans B on a une clé étrangère : B.a_cle = A.cle
Nous faisons une requête avec une jointure externe
SELECT * FROM A left join B on A.cle = B.a_cle
Comme A.cle et B.cle sont des clés primaires, ODBC nous indique que ces
deux champs sont NOT NULL dans la définition de la requête. Mais comme
c'est une jointure externe potentiellement B.cle peut être NULL, et a ce
moment là on obtient une erreur "Valeur NULL inattendue ...".
Je suppose que OPENQUERY créé une table temporaire pour stocker le
résultat, car quand on fait une interrogation directement en ODBC on a pas
ce problème (sauf si on utilise un système qui vérifie les contraintes).
De plus nous ne sommes pas parvenu à empêcher les drivers ODBC de
retourner cette information NOT NULL (se sont des vieux drivers et nous
n'avons pas le choix car nous avons un vieux SCO :) )
Alors ma question est : Existe-t-il un moyen d'empêcher OPENQUERY de
mettre cette contrainte ou de ne pas la prendre en compte, ou alors
peut-être au niveau du serveur lié ?
Voila j'espère que vous avez tout compris :)
A++
Yanos
Bonjour,
Voila nous avons un vieil Unix SCO Open Server avec un outil PROGRESS, et
de temps en temps nous récupérons des requêtes via ODBC et une instruction
OPENQUERY. Si on fait cela c'est parce qu'il n'y a pas de sécurité avec
les drivers que l'on a, et donc comme on ne veut pas que n'importe qui
puisse toucher aux données, on passe par MSSQL qui lui interroge les
données qu'on lui demande en fonction du login.
Ca fonctionne plutôt bien, mais nous recontrons un problème agaçant. Je
pose la situation pour essayer d'être clair :)
On a deux tables A et B avec une clé primaire sur chacune A.cle et b.cle
et dans B on a une clé étrangère : B.a_cle = A.cle
Nous faisons une requête avec une jointure externe
SELECT * FROM A left join B on A.cle = B.a_cle
Comme A.cle et B.cle sont des clés primaires, ODBC nous indique que ces
deux champs sont NOT NULL dans la définition de la requête. Mais comme
c'est une jointure externe potentiellement B.cle peut être NULL, et a ce
moment là on obtient une erreur "Valeur NULL inattendue ...".
Je suppose que OPENQUERY créé une table temporaire pour stocker le
résultat, car quand on fait une interrogation directement en ODBC on a pas
ce problème (sauf si on utilise un système qui vérifie les contraintes).
De plus nous ne sommes pas parvenu à empêcher les drivers ODBC de
retourner cette information NOT NULL (se sont des vieux drivers et nous
n'avons pas le choix car nous avons un vieux SCO :) )
Alors ma question est : Existe-t-il un moyen d'empêcher OPENQUERY de
mettre cette contrainte ou de ne pas la prendre en compte, ou alors
peut-être au niveau du serveur lié ?
Voila j'espère que vous avez tout compris :)
A++
Yanos
Bonjour,
Voila nous avons un vieil Unix SCO Open Server avec un outil PROGRESS, et
de temps en temps nous récupérons des requêtes via ODBC et une instruction
OPENQUERY. Si on fait cela c'est parce qu'il n'y a pas de sécurité avec
les drivers que l'on a, et donc comme on ne veut pas que n'importe qui
puisse toucher aux données, on passe par MSSQL qui lui interroge les
données qu'on lui demande en fonction du login.
Ca fonctionne plutôt bien, mais nous recontrons un problème agaçant. Je
pose la situation pour essayer d'être clair :)
On a deux tables A et B avec une clé primaire sur chacune A.cle et b.cle
et dans B on a une clé étrangère : B.a_cle = A.cle
Nous faisons une requête avec une jointure externe
SELECT * FROM A left join B on A.cle = B.a_cle
Comme A.cle et B.cle sont des clés primaires, ODBC nous indique que ces
deux champs sont NOT NULL dans la définition de la requête. Mais comme
c'est une jointure externe potentiellement B.cle peut être NULL, et a ce
moment là on obtient une erreur "Valeur NULL inattendue ...".
Je suppose que OPENQUERY créé une table temporaire pour stocker le
résultat, car quand on fait une interrogation directement en ODBC on a pas
ce problème (sauf si on utilise un système qui vérifie les contraintes).
De plus nous ne sommes pas parvenu à empêcher les drivers ODBC de
retourner cette information NOT NULL (se sont des vieux drivers et nous
n'avons pas le choix car nous avons un vieux SCO :) )
Alors ma question est : Existe-t-il un moyen d'empêcher OPENQUERY de
mettre cette contrainte ou de ne pas la prendre en compte, ou alors
peut-être au niveau du serveur lié ?
Voila j'espère que vous avez tout compris :)
A++
Yanos