Sélectionnez les colonnes de l'ensemble de résultats de la procédure stockée

J'ai une procédure stockée qui renvoie 80 colonnes et 300 lignes. Je veux écrire une sélection qui obtient 2 de ces colonnes. Quelque chose comme

SELECT col1, col2 FROM EXEC MyStoredProc 'param1', 'param2'

Lorsque j'ai utilisé la syntaxe ci-dessus, j'obtiens l'erreur:

"Nom de colonne invalide".

Je sais que la solution la plus simple serait de changer la procédure stockée, mais je ne l'ai pas écrite et je ne peux pas la changer.

Existe-t-il un moyen de faire ce que je veux?

• Je pourrais faire une table temporaire pour y mettre les résultats, mais parce qu'il y a 80 colonnes, je devrais donc faire une table temporaire de 80 colonnes juste pour obtenir 2 colonnes. Je voulais éviter de retrouver toutes les colonnes retournées.

• J'ai essayé d'utiliser WITH SprocResults AS ....comme suggéré par Mark, mais j'ai eu 2 erreurs
  

  Syntaxe incorrecte près du mot clé "EXEC".
  Syntaxe incorrecte près de ')'.

• J'ai essayé de déclarer une variable de table et j'ai eu l'erreur suivante
  

  Erreur d'insertion: le nom de la colonne ou le nombre de valeurs fournies ne correspond pas à la définition de la table

• Si j'essaye
  SELECT * FROM EXEC MyStoredProc 'param1', 'param2'
  j'obtiens l'erreur:
  

  Syntaxe incorrecte près du mot clé 'exec'.

Pouvez-vous diviser la requête? Insérez les résultats de proc stockés dans une variable de table ou une table temporaire. Ensuite, sélectionnez les 2 colonnes de la variable de table.

Declare @tablevar table(col1 col1Type,..
insert into @tablevar(col1,..) exec MyStoredProc 'param1', 'param2'

SELECT col1, col2 FROM @tablevar

Voici un lien vers un très bon document expliquant toutes les différentes façons de résoudre votre problème (bien que beaucoup d'entre elles ne puissent pas être utilisées car vous ne pouvez pas modifier la procédure stockée existante.)

Comment partager des données entre des procédures stockées

La réponse de Gulzar fonctionnera (elle est documentée dans le lien ci-dessus) mais ça va être compliqué à écrire (vous devrez spécifier les 80 noms de colonne dans votre instruction @tablevar (col1, ...). Et à l'avenir si une colonne est ajoutée au schéma ou si la sortie est modifiée, elle devra être mise à jour dans votre code ou elle entraînera une erreur.

CREATE TABLE #Result
(
  ID int,  Name varchar(500), Revenue money
)
INSERT #Result EXEC RevenueByAdvertiser '1/1/10', '2/1/10'
SELECT * FROM #Result ORDER BY Name
DROP TABLE #Result

Source:
http://stevesmithblog.com/blog/select-from-a-stored-procedure/

Cela fonctionne pour moi: (c'est-à-dire que je n'ai besoin que de 2 colonnes des 30+ retournées par sp_help_job)

SELECT name, current_execution_status 
FROM OPENQUERY (MYSERVER, 
  'EXEC msdb.dbo.sp_help_job @job_name = ''My Job'', @job_aspect = ''JOB''');  

Avant que cela ne fonctionne, je devais exécuter ceci:

sp_serveroption 'MYSERVER', 'DATA ACCESS', TRUE;

.... pour mettre à jour le sys.serverstableau. (Par exemple, l'utilisation d'une auto-référence dans OPENQUERY semble être désactivée par défaut.)

Pour ma simple exigence, je n'ai rencontré aucun des problèmes décrits dans la section OPENQUERY de l'excellent lien de Lance.

Rossini, si vous avez besoin de définir dynamiquement ces paramètres d'entrée, alors l'utilisation de OPENQUERY devient un peu plus compliquée:

DECLARE @innerSql varchar(1000);
DECLARE @outerSql varchar(1000);

-- Set up the original stored proc definition.
SET @innerSql = 
'EXEC msdb.dbo.sp_help_job @job_name = '''+@param1+''', @job_aspect = N'''+@param2+'''' ;

-- Handle quotes.
SET @innerSql = REPLACE(@innerSql, '''', '''''');

-- Set up the OPENQUERY definition.
SET @outerSql = 
'SELECT name, current_execution_status 
FROM OPENQUERY (MYSERVER, ''' + @innerSql + ''');';

-- Execute.
EXEC (@outerSql);

Je ne suis pas sûr des différences (le cas échéant) entre l'utilisation sp_serveroptionpour mettre à jour sys.serversdirectement l'auto-référence existante et l'utilisation sp_addlinkedserver(comme décrit dans le lien de Lance) pour créer un doublon / alias.

Remarque 1: je préfère OPENQUERY à OPENROWSET, étant donné que OPENQUERY ne nécessite pas la définition de chaîne de connexion dans le proc.

Remarque 2: Cela dit: normalement, j'utiliserais simplement INSERT ... EXEC :) Oui, c'est 10 minutes de frappe supplémentaire, mais si je peux l'aider, je préfère ne pas bouger avec:
(a) les guillemets entre guillemets dans citations, et
(b) tables sys, et / ou configurations sournoises auto-référencées de serveur lié (c'est-à-dire pour celles-ci, je dois plaider ma cause auprès de nos DBA tout-puissants :)

Cependant, dans ce cas, je ne pouvais pas utiliser une construction INSERT ... EXEC, comme sp_help_jobc'est déjà le cas. ("Une instruction INSERT EXEC ne peut pas être imbriquée.")

Pour ce faire, vous devez d'abord créer un #test_tablecomme ci-dessous:

create table #test_table(
    col1 int,
    col2 int,
   .
   .
   .
    col80 int
)

Maintenant, exécutez la procédure et mettez de la valeur dans #test_table:

insert into #test_table
EXEC MyStoredProc 'param1', 'param2'

Maintenant, vous récupérez la valeur de #test_table:

select col1,col2....,col80 from #test_table

Si vous pouvez modifier votre procédure stockée, vous pouvez facilement mettre les définitions de colonnes requises en tant que paramètre et utiliser une table temporaire créée automatiquement:

CREATE PROCEDURE sp_GetDiffDataExample
      @columnsStatement NVARCHAR(MAX) -- required columns statement (e.g. "field1, field2")
AS
BEGIN
    DECLARE @query NVARCHAR(MAX)
    SET @query = N'SELECT ' + @columnsStatement + N' INTO ##TempTable FROM dbo.TestTable'
    EXEC sp_executeSql @query
    SELECT * FROM ##TempTable
    DROP TABLE ##TempTable
END

Dans ce cas, vous n'avez pas besoin de créer une table temporaire manuellement - elle est créée automatiquement. J'espère que cela t'aides.

Il pourrait être utile de savoir pourquoi cela est si difficile. Une procédure stockée peut uniquement renvoyer du texte («texte» imprimé), ou renvoyer plusieurs tableaux, ou ne renvoyer aucun tableau du tout.

Donc, quelque chose comme ça SELECT * FROM (exec sp_tables) Table1 ne fonctionnera pas

(En supposant que SQL Server)

La seule façon de travailler avec les résultats d'une procédure stockée dans T-SQL est d'utiliser la INSERT INTO ... EXECsyntaxe. Cela vous donne la possibilité d'insérer dans une table temporaire ou une variable de table et de sélectionner les données dont vous avez besoin.

Un hack rapide serait d'ajouter un nouveau paramètre '@Column_Name'et de faire définir par la fonction appelante le nom de la colonne à récupérer. Dans la partie de retour de votre sproc, vous auriez des instructions if / else et ne renverriez que la colonne spécifiée, ou si vide - renvoyez tout.

CREATE PROCEDURE [dbo].[MySproc]
        @Column_Name AS VARCHAR(50)
AS
BEGIN
    IF (@Column_Name = 'ColumnName1')
        BEGIN
            SELECT @ColumnItem1 as 'ColumnName1'
        END
    ELSE
        BEGIN
            SELECT @ColumnItem1 as 'ColumnName1', @ColumnItem2 as 'ColumnName2', @ColumnItem3 as 'ColumnName3'
        END
END

Si vous faites cela pour une validation manuelle des données, vous pouvez le faire avec LINQPad.

Créez une connexion à la base de données dans LinqPad, puis créez des instructions C # similaires aux suivantes:

DataTable table = MyStoredProc (param1, param2).Tables[0];
(from row in table.AsEnumerable()
 select new
 {
  Col1 = row.Field<string>("col1"),
  Col2 = row.Field<string>("col2"),
 }).Dump();

Référence http://www.global-webnet.net/blogengine/post/2008/09/10/LINQPAD-Using-Stored-Procedures-Accessing-a-DataSet.aspx

Pour SQL Server, je trouve que cela fonctionne bien:

Créez une table temporaire (ou une table permanente, cela n'a pas vraiment d'importance) et effectuez une insertion dans l'instruction par rapport à la procédure stockée. Le jeu de résultats du SP doit correspondre aux colonnes de votre table, sinon vous obtiendrez une erreur.

Voici un exemple:

DECLARE @temp TABLE (firstname NVARCHAR(30), lastname nvarchar(50));

INSERT INTO @temp EXEC dbo.GetPersonName @param1,@param2;
-- assumption is that dbo.GetPersonName returns a table with firstname / lastname columns

SELECT * FROM @temp;

C'est ça!

Comme cela a été mentionné dans la question, il est difficile de définir la table temporaire de 80 colonnes avant d'exécuter la procédure stockée.

Donc, l'inverse consiste à remplir la table en fonction de l'ensemble de résultats de la procédure stockée.

SELECT * INTO #temp FROM OPENROWSET('SQLNCLI', 'Server=localhost;Trusted_Connection=yes;'
                                   ,'EXEC MyStoredProc')

Si vous obtenez une erreur, vous devez activer les requêtes distribuées ad hoc en exécutant la requête suivante.

sp_configure 'Show Advanced Options', 1
GO
RECONFIGURE
GO
sp_configure 'Ad Hoc Distributed Queries', 1
GO
RECONFIGURE
GO

Pour exécuter sp_configureavec les deux paramètres afin de modifier une option de configuration ou d'exécuter l' RECONFIGUREinstruction, vous devez disposer de l' ALTER SETTINGSautorisation au niveau du serveur

Vous pouvez maintenant sélectionner vos colonnes spécifiques dans le tableau généré

SELECT col1, col2
FROM #temp

essaye ça

use mydatabase
create procedure sp_onetwothree as
select 1 as '1', 2 as '2', 3 as '3'
go
SELECT a.[1], a.[2]
FROM OPENROWSET('SQLOLEDB','myserver';'sa';'mysapass',
    'exec mydatabase.dbo.sp_onetwothree') AS a
GO

Je sais que l'exécution depuis sp et l'insertion dans une table temporaire ou une variable de table serait une option, mais je ne pense pas que ce soit votre exigence. Selon vos besoins, cette déclaration de requête ci-dessous devrait fonctionner:

Declare @sql nvarchar(max)
Set @sql='SELECT   col1, col2 FROM OPENROWSET(''SQLNCLI'', ''Server=(local);uid=test;pwd=test'',
     ''EXEC MyStoredProc ''''param1'''', ''''param2'''''')'
 Exec(@sql)

si vous avez une connexion de confiance, utilisez cette instruction de requête ci-dessous:

Declare @sql nvarchar(max)
Set @sql='SELECT   col1, col2 FROM OPENROWSET(''SQLNCLI'', ''Server=(local);Trusted_Connection=yes;'',
     ''EXEC MyStoredProc ''''param1'''', ''''param2'''''')'
 Exec(@sql)

si vous obtenez une erreur lors de l'exécution de l'instruction ci-dessus, exécutez simplement cette instruction ci-dessous:

sp_configure 'Show Advanced Options', 1
GO
RECONFIGURE
GO
sp_configure 'Ad Hoc Distributed Queries', 1
GO
RECONFIGURE
GO

J'espère que cela aidera quelqu'un qui aura fait face à ce genre de problème similaire. Si quelqu'un veut essayer avec une table temporaire ou une variable de table qui devrait ressembler à ceci ci-dessous, mais dans ce scénario, vous devez savoir combien de colonnes votre sp renvoie, alors vous devez créer autant de colonnes dans la table temporaire ou la variable de table:

--for table variable 
Declare @t table(col1 col1Type, col2 col2Type)
insert into @t exec MyStoredProc 'param1', 'param2'
SELECT col1, col2 FROM @t

--for temp table
create table #t(col1 col1Type, col2 col2Type)
insert into #t exec MyStoredProc 'param1', 'param2'
SELECT col1, col2 FROM #t

Pour tous ceux qui ont SQL 2012 ou version ultérieure, j'ai pu accomplir cela avec des procédures stockées qui ne sont pas dynamiques et ont les mêmes colonnes de sortie à chaque fois.

L'idée générale est que je construis la requête dynamique pour créer, insérer, sélectionner et supprimer la table temporaire, et l'exécuter une fois qu'elle est entièrement générée. Je génère dynamiquement la table temporaire en récupérant d' abord les noms et types de colonnes de la procédure stockée .

Remarque: il existe des solutions bien meilleures et plus universelles qui fonctionneront avec moins de lignes de code si vous souhaitez / pouvez mettre à jour le SP ou modifier la configuration et l'utilisation OPENROWSET. Utilisez ce qui suit si vous n'avez pas d'autre moyen.

DECLARE @spName VARCHAR(MAX) = 'MyStoredProc'
DECLARE @tempTableName VARCHAR(MAX) = '#tempTable'

-- might need to update this if your param value is a string and you need to escape quotes
DECLARE @insertCommand VARCHAR(MAX) = 'INSERT INTO ' + @tempTableName + ' EXEC MyStoredProc @param=value'

DECLARE @createTableCommand VARCHAR(MAX)

-- update this to select the columns you want
DECLARE @selectCommand VARCHAR(MAX) = 'SELECT col1, col2 FROM ' + @tempTableName

DECLARE @dropCommand VARCHAR(MAX) = 'DROP TABLE ' + @tempTableName

-- Generate command to create temp table
SELECT @createTableCommand = 'CREATE TABLE ' + @tempTableName + ' (' +
    STUFF
    (
        (
            SELECT ', ' + CONCAT('[', name, ']', ' ', system_type_name)
            FROM sys.dm_exec_describe_first_result_set_for_object
            (
              OBJECT_ID(@spName), 
              NULL
            )
            FOR XML PATH('')
        )
        ,1
        ,1
        ,''
    ) + ')'

EXEC( @createTableCommand + ' '+ @insertCommand + ' ' + @selectCommand + ' ' + @dropCommand)

Le moyen le plus simple de le faire si vous n'en avez besoin qu'une fois:

Exportez vers Excel dans l'assistant d'importation et d'exportation, puis importez cet Excel dans une table.

Créez une vue dynamique et obtenez-en des résultats .......

CREATE PROCEDURE dbo.usp_userwise_columns_value
(
    @userid BIGINT
)
AS 
BEGIN
        DECLARE @maincmd NVARCHAR(max);
        DECLARE @columnlist NVARCHAR(max);
        DECLARE @columnname VARCHAR(150);
        DECLARE @nickname VARCHAR(50);

        SET @maincmd = '';
        SET @columnname = '';
        SET @columnlist = '';
        SET @nickname = '';

        DECLARE CUR_COLUMNLIST CURSOR FAST_FORWARD
        FOR
            SELECT columnname , nickname
            FROM dbo.v_userwise_columns 
            WHERE userid = @userid

        OPEN CUR_COLUMNLIST
        IF @@ERROR <> 0
            BEGIN
                ROLLBACK
                RETURN
            END   

        FETCH NEXT FROM CUR_COLUMNLIST
        INTO @columnname, @nickname

        WHILE @@FETCH_STATUS = 0
            BEGIN
                SET @columnlist = @columnlist + @columnname + ','

                FETCH NEXT FROM CUR_COLUMNLIST
                INTO @columnname, @nickname
            END
        CLOSE CUR_COLUMNLIST
        DEALLOCATE CUR_COLUMNLIST  

        IF NOT EXISTS (SELECT * FROM sys.views WHERE name = 'v_userwise_columns_value')
            BEGIN
                SET @maincmd = 'CREATE VIEW dbo.v_userwise_columns_value AS SELECT sjoid, CONVERT(BIGINT, ' + CONVERT(VARCHAR(10), @userid) + ') as userid , ' 
                            + CHAR(39) + @nickname + CHAR(39) + ' as nickname, ' 
                            + @columnlist + ' compcode FROM dbo.SJOTran '
            END
        ELSE
            BEGIN
                SET @maincmd = 'ALTER VIEW dbo.v_userwise_columns_value AS SELECT sjoid, CONVERT(BIGINT, ' + CONVERT(VARCHAR(10), @userid) + ') as userid , ' 
                            + CHAR(39) + @nickname + CHAR(39) + ' as nickname, ' 
                            + @columnlist + ' compcode FROM dbo.SJOTran '
            END

        --PRINT @maincmd
        EXECUTE sp_executesql @maincmd
END

-----------------------------------------------
SELECT * FROM dbo.v_userwise_columns_value

Je voudrais couper et coller le SP d'origine et supprimer toutes les colonnes sauf les 2 que vous voulez. Ou. Je ramènerais l'ensemble de résultats, le mapperais à un objet métier approprié, puis LINQ sur les deux colonnes.