Je viens une nouvelle fois solliciter votre aide.
J'ai créé un procédure stockée qui accepte différents paramètres dont l'un
est de type nvarchar(50).
Il contient un ensemble de codes que je souhaiterais utiliser comme filtre
dans une requête.
Ma requête problématique ressemble à cela :
Declare @Param1 as nvarchar(50)
Set @Param1 = '48,49,50,51'
Select * From Table Where Id in (@Param1)
J'obtiens le message d'erreur suivant :
Erreur de syntaxe lors de la conversion de la valeur nvarchar '48,49,50,51'
vers une colonne de type de données int.
Ceci semble logique puisque je souhaite exécuter la requête suivante :
Select * From Table Where Id in (48,49,50,51)
et non pas
Select * From Table Where Id in ('48,49,50,51')
Auriez vous une idée sur le moyen d'exécuter cette requête sans que je sois
obligée de m'arracher tous les cheveux de ma tête?
La solution doit vous paraitre évidente, mais pas pour moi
malheureusement...
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
Philippe T [MS]
Bonjour,
Bon, je sais ce n'est pas optimal mais cela fonctionne !!! :-)
Declare @Param1 as nvarchar(50) Set @Param1 = '48,49,50,51' SELECT * FROM Table WHERE Id in (SELECT MY_VALUE FROM dbo.cf_GetSplitTable(@Param1, ','))
avec << /*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- <UserFunction name="cf_GetSplitTable">
<Object> Return the result of a String split as a table </Object>
-- Insert all other occurence WHILE ( 1 = 1 ) BEGIN SET @Val_Next_1 = CHARINDEX(@sDelim, @sText) SET @Val_Next_2 = CHARINDEX(@sDelim, SUBSTRING(@sText, @Val_Next_1 + 1, 4000))
SET @sText = SUBSTRING(@sText, @Val_Next_1 + 1, 4000)
IF @Val_Next_2 <> 0 BEGIN SET @OccurenceNumber = @OccurenceNumber + 1
INSERT INTO @MySplitTable( MY_VALUE, MY_ORDER ) VALUES( SUBSTRING(@sText, 1, @Val_Next_2 - 1), @OccurenceNumber ) END ELSE BEGIN IF @sText <> '' BEGIN SET @OccurenceNumber = @OccurenceNumber + 1
INSERT INTO @MySplitTable( MY_VALUE, MY_ORDER ) VALUES( @sText, @OccurenceNumber ) END BREAK END END
RETURN END
---------------------------------------------------------------------- Philippe TROTIN - Microsoft Service France
"C. Vidal" wrote in message news:%
Bonsoir à tous,
Je viens une nouvelle fois solliciter votre aide. J'ai créé un procédure stockée qui accepte différents paramètres dont l'un est de type nvarchar(50). Il contient un ensemble de codes que je souhaiterais utiliser comme filtre dans une requête.
Ma requête problématique ressemble à cela :
Declare @Param1 as nvarchar(50) Set @Param1 = '48,49,50,51' Select * From Table Where Id in (@Param1)
J'obtiens le message d'erreur suivant : Erreur de syntaxe lors de la conversion de la valeur nvarchar '48,49,50,51' vers une colonne de type de données int.
Ceci semble logique puisque je souhaite exécuter la requête suivante : Select * From Table Where Id in (48,49,50,51)
et non pas
Select * From Table Where Id in ('48,49,50,51')
Auriez vous une idée sur le moyen d'exécuter cette requête sans que je sois obligée de m'arracher tous les cheveux de ma tête? La solution doit vous paraitre évidente, mais pas pour moi malheureusement...
Merci d'avance pour votre aide.
C. Vidal
Bonjour,
Bon, je sais ce n'est pas optimal mais cela fonctionne !!! :-)
Declare @Param1 as nvarchar(50)
Set @Param1 = '48,49,50,51'
SELECT * FROM Table WHERE Id in (SELECT MY_VALUE FROM
dbo.cf_GetSplitTable(@Param1, ','))
avec
<<
/*-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
<UserFunction name="cf_GetSplitTable">
<Object> Return the result of a String split as a table
</Object>
-- Insert all other occurence
WHILE ( 1 = 1 )
BEGIN
SET @Val_Next_1 = CHARINDEX(@sDelim, @sText)
SET @Val_Next_2 = CHARINDEX(@sDelim, SUBSTRING(@sText, @Val_Next_1 + 1,
4000))
SET @sText = SUBSTRING(@sText, @Val_Next_1 + 1, 4000)
IF @Val_Next_2 <> 0
BEGIN
SET @OccurenceNumber = @OccurenceNumber + 1
INSERT INTO @MySplitTable( MY_VALUE, MY_ORDER )
VALUES( SUBSTRING(@sText, 1, @Val_Next_2 - 1), @OccurenceNumber )
END
ELSE
BEGIN
IF @sText <> ''
BEGIN
SET @OccurenceNumber = @OccurenceNumber + 1
INSERT INTO @MySplitTable( MY_VALUE, MY_ORDER )
VALUES( @sText, @OccurenceNumber )
END
BREAK
END
END
RETURN
END
----------------------------------------------------------------------
Philippe TROTIN - Microsoft Service France
"C. Vidal" <cvidal_nospam@univer-com.com> wrote in message
news:%23hZbZH10FHA.1132@TK2MSFTNGP10.phx.gbl...
Bonsoir à tous,
Je viens une nouvelle fois solliciter votre aide.
J'ai créé un procédure stockée qui accepte différents paramètres dont l'un
est de type nvarchar(50).
Il contient un ensemble de codes que je souhaiterais utiliser comme filtre
dans une requête.
Ma requête problématique ressemble à cela :
Declare @Param1 as nvarchar(50)
Set @Param1 = '48,49,50,51'
Select * From Table Where Id in (@Param1)
J'obtiens le message d'erreur suivant :
Erreur de syntaxe lors de la conversion de la valeur nvarchar
'48,49,50,51' vers une colonne de type de données int.
Ceci semble logique puisque je souhaite exécuter la requête suivante :
Select * From Table Where Id in (48,49,50,51)
et non pas
Select * From Table Where Id in ('48,49,50,51')
Auriez vous une idée sur le moyen d'exécuter cette requête sans que je
sois obligée de m'arracher tous les cheveux de ma tête?
La solution doit vous paraitre évidente, mais pas pour moi
malheureusement...
Bon, je sais ce n'est pas optimal mais cela fonctionne !!! :-)
Declare @Param1 as nvarchar(50) Set @Param1 = '48,49,50,51' SELECT * FROM Table WHERE Id in (SELECT MY_VALUE FROM dbo.cf_GetSplitTable(@Param1, ','))
avec << /*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- <UserFunction name="cf_GetSplitTable">
<Object> Return the result of a String split as a table </Object>
-- Insert all other occurence WHILE ( 1 = 1 ) BEGIN SET @Val_Next_1 = CHARINDEX(@sDelim, @sText) SET @Val_Next_2 = CHARINDEX(@sDelim, SUBSTRING(@sText, @Val_Next_1 + 1, 4000))
SET @sText = SUBSTRING(@sText, @Val_Next_1 + 1, 4000)
IF @Val_Next_2 <> 0 BEGIN SET @OccurenceNumber = @OccurenceNumber + 1
INSERT INTO @MySplitTable( MY_VALUE, MY_ORDER ) VALUES( SUBSTRING(@sText, 1, @Val_Next_2 - 1), @OccurenceNumber ) END ELSE BEGIN IF @sText <> '' BEGIN SET @OccurenceNumber = @OccurenceNumber + 1
INSERT INTO @MySplitTable( MY_VALUE, MY_ORDER ) VALUES( @sText, @OccurenceNumber ) END BREAK END END
RETURN END
---------------------------------------------------------------------- Philippe TROTIN - Microsoft Service France
"C. Vidal" wrote in message news:%
Bonsoir à tous,
Je viens une nouvelle fois solliciter votre aide. J'ai créé un procédure stockée qui accepte différents paramètres dont l'un est de type nvarchar(50). Il contient un ensemble de codes que je souhaiterais utiliser comme filtre dans une requête.
Ma requête problématique ressemble à cela :
Declare @Param1 as nvarchar(50) Set @Param1 = '48,49,50,51' Select * From Table Where Id in (@Param1)
J'obtiens le message d'erreur suivant : Erreur de syntaxe lors de la conversion de la valeur nvarchar '48,49,50,51' vers une colonne de type de données int.
Ceci semble logique puisque je souhaite exécuter la requête suivante : Select * From Table Where Id in (48,49,50,51)
et non pas
Select * From Table Where Id in ('48,49,50,51')
Auriez vous une idée sur le moyen d'exécuter cette requête sans que je sois obligée de m'arracher tous les cheveux de ma tête? La solution doit vous paraitre évidente, mais pas pour moi malheureusement...
Merci d'avance pour votre aide.
C. Vidal
Thierry
Declare @Param1 as nvarchar(50) Set @Param1 = '48,49,50,51' EXEC('Select * From Table Where Id in ('+ @Param1+ ')' )
-- Thierry
"C. Vidal" a écrit dans le message de news: %
Bonsoir à tous,
Je viens une nouvelle fois solliciter votre aide. J'ai créé un procédure stockée qui accepte différents paramètres dont l'un est de type nvarchar(50). Il contient un ensemble de codes que je souhaiterais utiliser comme filtre dans une requête.
Ma requête problématique ressemble à cela :
Declare @Param1 as nvarchar(50) Set @Param1 = '48,49,50,51' Select * From Table Where Id in (@Param1)
J'obtiens le message d'erreur suivant : Erreur de syntaxe lors de la conversion de la valeur nvarchar '48,49,50,51' vers une colonne de type de données int.
Ceci semble logique puisque je souhaite exécuter la requête suivante : Select * From Table Where Id in (48,49,50,51)
et non pas
Select * From Table Where Id in ('48,49,50,51')
Auriez vous une idée sur le moyen d'exécuter cette requête sans que je sois obligée de m'arracher tous les cheveux de ma tête? La solution doit vous paraitre évidente, mais pas pour moi malheureusement...
Merci d'avance pour votre aide.
C. Vidal
Declare @Param1 as nvarchar(50)
Set @Param1 = '48,49,50,51'
EXEC('Select * From Table Where Id in ('+ @Param1+ ')' )
--
Thierry
"C. Vidal" <cvidal_nospam@univer-com.com> a écrit dans le message de news:
%23hZbZH10FHA.1132@TK2MSFTNGP10.phx.gbl...
Bonsoir à tous,
Je viens une nouvelle fois solliciter votre aide.
J'ai créé un procédure stockée qui accepte différents paramètres dont l'un
est de type nvarchar(50).
Il contient un ensemble de codes que je souhaiterais utiliser comme filtre
dans une requête.
Ma requête problématique ressemble à cela :
Declare @Param1 as nvarchar(50)
Set @Param1 = '48,49,50,51'
Select * From Table Where Id in (@Param1)
J'obtiens le message d'erreur suivant :
Erreur de syntaxe lors de la conversion de la valeur nvarchar
'48,49,50,51' vers une colonne de type de données int.
Ceci semble logique puisque je souhaite exécuter la requête suivante :
Select * From Table Where Id in (48,49,50,51)
et non pas
Select * From Table Where Id in ('48,49,50,51')
Auriez vous une idée sur le moyen d'exécuter cette requête sans que je
sois obligée de m'arracher tous les cheveux de ma tête?
La solution doit vous paraitre évidente, mais pas pour moi
malheureusement...
Declare @Param1 as nvarchar(50) Set @Param1 = '48,49,50,51' EXEC('Select * From Table Where Id in ('+ @Param1+ ')' )
-- Thierry
"C. Vidal" a écrit dans le message de news: %
Bonsoir à tous,
Je viens une nouvelle fois solliciter votre aide. J'ai créé un procédure stockée qui accepte différents paramètres dont l'un est de type nvarchar(50). Il contient un ensemble de codes que je souhaiterais utiliser comme filtre dans une requête.
Ma requête problématique ressemble à cela :
Declare @Param1 as nvarchar(50) Set @Param1 = '48,49,50,51' Select * From Table Where Id in (@Param1)
J'obtiens le message d'erreur suivant : Erreur de syntaxe lors de la conversion de la valeur nvarchar '48,49,50,51' vers une colonne de type de données int.
Ceci semble logique puisque je souhaite exécuter la requête suivante : Select * From Table Where Id in (48,49,50,51)
et non pas
Select * From Table Where Id in ('48,49,50,51')
Auriez vous une idée sur le moyen d'exécuter cette requête sans que je sois obligée de m'arracher tous les cheveux de ma tête? La solution doit vous paraitre évidente, mais pas pour moi malheureusement...
Merci d'avance pour votre aide.
C. Vidal
Thierry
Par mesure de sécurité, il convient de vérifier que Param1 ne contient bien que des chiffres et des virgules. Car on peut imaginer un utilisateur qui s' "amuse" à envoyer le paramètre suivant :
49,50,51) delete from Table --
-- Thierry
"Thierry" a écrit dans le message de news:
Declare @Param1 as nvarchar(50) Set @Param1 = '48,49,50,51' EXEC('Select * From Table Where Id in ('+ @Param1+ ')' )
-- Thierry
"C. Vidal" a écrit dans le message de news: %
Bonsoir à tous,
Je viens une nouvelle fois solliciter votre aide. J'ai créé un procédure stockée qui accepte différents paramètres dont l'un est de type nvarchar(50). Il contient un ensemble de codes que je souhaiterais utiliser comme filtre dans une requête.
Ma requête problématique ressemble à cela :
Declare @Param1 as nvarchar(50) Set @Param1 = '48,49,50,51' Select * From Table Where Id in (@Param1)
J'obtiens le message d'erreur suivant : Erreur de syntaxe lors de la conversion de la valeur nvarchar '48,49,50,51' vers une colonne de type de données int.
Ceci semble logique puisque je souhaite exécuter la requête suivante : Select * From Table Where Id in (48,49,50,51)
et non pas
Select * From Table Where Id in ('48,49,50,51')
Auriez vous une idée sur le moyen d'exécuter cette requête sans que je sois obligée de m'arracher tous les cheveux de ma tête? La solution doit vous paraitre évidente, mais pas pour moi malheureusement...
Merci d'avance pour votre aide.
C. Vidal
Par mesure de sécurité, il convient de vérifier que Param1 ne contient bien
que des chiffres et des virgules.
Car on peut imaginer un utilisateur qui s' "amuse" à envoyer le paramètre
suivant :
49,50,51) delete from Table --
--
Thierry
"Thierry" <tper_NOSPAM@vfemail.net> a écrit dans le message de news:
eUxhGS20FHA.2312@TK2MSFTNGP14.phx.gbl...
Declare @Param1 as nvarchar(50)
Set @Param1 = '48,49,50,51'
EXEC('Select * From Table Where Id in ('+ @Param1+ ')' )
--
Thierry
"C. Vidal" <cvidal_nospam@univer-com.com> a écrit dans le message de news:
%23hZbZH10FHA.1132@TK2MSFTNGP10.phx.gbl...
Bonsoir à tous,
Je viens une nouvelle fois solliciter votre aide.
J'ai créé un procédure stockée qui accepte différents paramètres dont
l'un est de type nvarchar(50).
Il contient un ensemble de codes que je souhaiterais utiliser comme
filtre dans une requête.
Ma requête problématique ressemble à cela :
Declare @Param1 as nvarchar(50)
Set @Param1 = '48,49,50,51'
Select * From Table Where Id in (@Param1)
J'obtiens le message d'erreur suivant :
Erreur de syntaxe lors de la conversion de la valeur nvarchar
'48,49,50,51' vers une colonne de type de données int.
Ceci semble logique puisque je souhaite exécuter la requête suivante :
Select * From Table Where Id in (48,49,50,51)
et non pas
Select * From Table Where Id in ('48,49,50,51')
Auriez vous une idée sur le moyen d'exécuter cette requête sans que je
sois obligée de m'arracher tous les cheveux de ma tête?
La solution doit vous paraitre évidente, mais pas pour moi
malheureusement...
Par mesure de sécurité, il convient de vérifier que Param1 ne contient bien que des chiffres et des virgules. Car on peut imaginer un utilisateur qui s' "amuse" à envoyer le paramètre suivant :
49,50,51) delete from Table --
-- Thierry
"Thierry" a écrit dans le message de news:
Declare @Param1 as nvarchar(50) Set @Param1 = '48,49,50,51' EXEC('Select * From Table Where Id in ('+ @Param1+ ')' )
-- Thierry
"C. Vidal" a écrit dans le message de news: %
Bonsoir à tous,
Je viens une nouvelle fois solliciter votre aide. J'ai créé un procédure stockée qui accepte différents paramètres dont l'un est de type nvarchar(50). Il contient un ensemble de codes que je souhaiterais utiliser comme filtre dans une requête.
Ma requête problématique ressemble à cela :
Declare @Param1 as nvarchar(50) Set @Param1 = '48,49,50,51' Select * From Table Where Id in (@Param1)
J'obtiens le message d'erreur suivant : Erreur de syntaxe lors de la conversion de la valeur nvarchar '48,49,50,51' vers une colonne de type de données int.
Ceci semble logique puisque je souhaite exécuter la requête suivante : Select * From Table Where Id in (48,49,50,51)
et non pas
Select * From Table Where Id in ('48,49,50,51')
Auriez vous une idée sur le moyen d'exécuter cette requête sans que je sois obligée de m'arracher tous les cheveux de ma tête? La solution doit vous paraitre évidente, mais pas pour moi malheureusement...
Merci d'avance pour votre aide.
C. Vidal
Fred BROUARD
Je vais écrire une article prochainement sur l'injection de SQL sur mon site SQLpro car ce problème devient de nouveau "à la mode" depuis : 1) le dev web 2) l'utilisation massive du SQL dynamique.
A +
Thierry a écrit:
Par mesure de sécurité, il convient de vérifier que Param1 ne contient bien que des chiffres et des virgules. Car on peut imaginer un utilisateur qui s' "amuse" à envoyer le paramètre suivant :
49,50,51) delete from Table --
-- Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com Audit, conseil, expertise, formation, modélisation, tuning, optimisation ********************* http://www.datasapiens.com ***********************
Je vais écrire une article prochainement sur l'injection de SQL sur mon site
SQLpro car ce problème devient de nouveau "à la mode" depuis :
1) le dev web
2) l'utilisation massive du SQL dynamique.
A +
Thierry a écrit:
Par mesure de sécurité, il convient de vérifier que Param1 ne contient bien
que des chiffres et des virgules.
Car on peut imaginer un utilisateur qui s' "amuse" à envoyer le paramètre
suivant :
49,50,51) delete from Table --
--
Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL
Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com
Audit, conseil, expertise, formation, modélisation, tuning, optimisation
********************* http://www.datasapiens.com ***********************
Je vais écrire une article prochainement sur l'injection de SQL sur mon site SQLpro car ce problème devient de nouveau "à la mode" depuis : 1) le dev web 2) l'utilisation massive du SQL dynamique.
A +
Thierry a écrit:
Par mesure de sécurité, il convient de vérifier que Param1 ne contient bien que des chiffres et des virgules. Car on peut imaginer un utilisateur qui s' "amuse" à envoyer le paramètre suivant :
49,50,51) delete from Table --
-- Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com Audit, conseil, expertise, formation, modélisation, tuning, optimisation ********************* http://www.datasapiens.com ***********************
C. Vidal
Bonjour à tous,
Juste un petit mot pour vous remrcier pour vos différents conseils. Cela fonctionne parfaitement, et grâce à vous je ne vais pas devenir chauve...
"C. Vidal" a écrit dans le message de news: %
Bonsoir à tous,
Je viens une nouvelle fois solliciter votre aide. J'ai créé un procédure stockée qui accepte différents paramètres dont l'un est de type nvarchar(50). Il contient un ensemble de codes que je souhaiterais utiliser comme filtre dans une requête.
Ma requête problématique ressemble à cela :
Declare @Param1 as nvarchar(50) Set @Param1 = '48,49,50,51' Select * From Table Where Id in (@Param1)
J'obtiens le message d'erreur suivant : Erreur de syntaxe lors de la conversion de la valeur nvarchar '48,49,50,51' vers une colonne de type de données int.
Ceci semble logique puisque je souhaite exécuter la requête suivante : Select * From Table Where Id in (48,49,50,51)
et non pas
Select * From Table Where Id in ('48,49,50,51')
Auriez vous une idée sur le moyen d'exécuter cette requête sans que je sois obligée de m'arracher tous les cheveux de ma tête? La solution doit vous paraitre évidente, mais pas pour moi malheureusement...
Merci d'avance pour votre aide.
C. Vidal
Bonjour à tous,
Juste un petit mot pour vous remrcier pour vos différents conseils.
Cela fonctionne parfaitement, et grâce à vous je ne vais pas devenir
chauve...
"C. Vidal" <cvidal_nospam@univer-com.com> a écrit dans le message de news:
%23hZbZH10FHA.1132@TK2MSFTNGP10.phx.gbl...
Bonsoir à tous,
Je viens une nouvelle fois solliciter votre aide.
J'ai créé un procédure stockée qui accepte différents paramètres dont l'un
est de type nvarchar(50).
Il contient un ensemble de codes que je souhaiterais utiliser comme filtre
dans une requête.
Ma requête problématique ressemble à cela :
Declare @Param1 as nvarchar(50)
Set @Param1 = '48,49,50,51'
Select * From Table Where Id in (@Param1)
J'obtiens le message d'erreur suivant :
Erreur de syntaxe lors de la conversion de la valeur nvarchar
'48,49,50,51' vers une colonne de type de données int.
Ceci semble logique puisque je souhaite exécuter la requête suivante :
Select * From Table Where Id in (48,49,50,51)
et non pas
Select * From Table Where Id in ('48,49,50,51')
Auriez vous une idée sur le moyen d'exécuter cette requête sans que je
sois obligée de m'arracher tous les cheveux de ma tête?
La solution doit vous paraitre évidente, mais pas pour moi
malheureusement...
Juste un petit mot pour vous remrcier pour vos différents conseils. Cela fonctionne parfaitement, et grâce à vous je ne vais pas devenir chauve...
"C. Vidal" a écrit dans le message de news: %
Bonsoir à tous,
Je viens une nouvelle fois solliciter votre aide. J'ai créé un procédure stockée qui accepte différents paramètres dont l'un est de type nvarchar(50). Il contient un ensemble de codes que je souhaiterais utiliser comme filtre dans une requête.
Ma requête problématique ressemble à cela :
Declare @Param1 as nvarchar(50) Set @Param1 = '48,49,50,51' Select * From Table Where Id in (@Param1)
J'obtiens le message d'erreur suivant : Erreur de syntaxe lors de la conversion de la valeur nvarchar '48,49,50,51' vers une colonne de type de données int.
Ceci semble logique puisque je souhaite exécuter la requête suivante : Select * From Table Where Id in (48,49,50,51)
et non pas
Select * From Table Where Id in ('48,49,50,51')
Auriez vous une idée sur le moyen d'exécuter cette requête sans que je sois obligée de m'arracher tous les cheveux de ma tête? La solution doit vous paraitre évidente, mais pas pour moi malheureusement...