Selecionar colunas do conjunto de resultados do procedimento armazenado

Eu tenho um procedimento armazenado que retorna 80 colunas e 300 linhas. Eu quero escrever um select que recebe 2 dessas colunas. Algo como

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

Quando usei a sintaxe acima, recebo o erro:

"Nome da coluna inválido".

Eu sei que a solução mais fácil seria alterar o procedimento armazenado, mas não o escrevi e não posso alterá-lo.

Existe alguma maneira de fazer o que eu quero?

• Eu poderia criar uma tabela temporária para colocar os resultados, mas como existem 80 colunas, seria necessário criar uma tabela temporária de 80 colunas apenas para obter 2 colunas. Eu queria evitar rastrear todas as colunas retornadas.

• Tentei usar WITH SprocResults AS ....como sugerido por Mark, mas obtive 2 erros
  

  Sintaxe incorreta perto da palavra-chave 'EXEC'.
  Sintaxe incorreta perto de ')'.

• Tentei declarar uma variável de tabela e recebi o seguinte erro
  

  Erro de inserção: o nome da coluna ou o número de valores fornecidos não corresponde à definição da tabela

• Se eu tentar
  SELECT * FROM EXEC MyStoredProc 'param1', 'param2'
  , recebo o erro:
  

  Sintaxe incorreta perto da palavra-chave 'exec'.

Você pode dividir a consulta? Insira os resultados do processo armazenados em uma variável de tabela ou em uma tabela temporária. Em seguida, selecione as 2 colunas da variável da tabela.

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

SELECT col1, col2 FROM @tablevar

Aqui está um link para um documento muito bom, explicando todas as maneiras diferentes de resolver seu problema (embora muitas delas não possam ser usadas, pois você não pode modificar o procedimento armazenado existente).

Como compartilhar dados entre procedimentos armazenados

A resposta do Gulzar funcionará (está documentada no link acima), mas será um incômodo escrever (você precisará especificar todos os 80 nomes de coluna na sua declaração @tablevar (col1, ...). se uma coluna for adicionada ao esquema ou a saída for alterada, ela precisará ser atualizada no seu código ou ocorrerá um erro.

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

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

Isso funciona para mim: (ou seja, eu só preciso de 2 colunas das mais de 30 retornadas por sp_help_job)

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

Antes que isso funcionasse, eu precisava executar o seguinte:

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

.... para atualizar a sys.serverstabela. (por exemplo, o uso de uma referência própria no OPENQUERY parece estar desativado por padrão.)

Por minha simples exigência, não encontrei nenhum dos problemas descritos na seção OPENQUERY do excelente link de Lance.

Rossini, se você precisar definir dinamicamente esses parâmetros de entrada, o uso do OPENQUERY se tornará um pouco mais complicado:

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);

Não tenho certeza das diferenças (se houver) entre usar sp_serveroptionpara atualizar sys.serversdiretamente a auto-referência existente e usar sp_addlinkedserver(como descrito no link de Lance) para criar um duplicado / alias.

Nota 1: Prefiro OPENQUERY sobre OPENROWSET, pois o OPENQUERY não requer a definição da cadeia de conexão no proc.

Nota 2: Tendo dito tudo isso: normalmente eu usaria INSERT ... EXEC :) Sim, são 10 minutos de digitação extra, mas se eu puder ajudá-lo, prefiro não brincar com:
(a) aspas entre aspas dentro cotações e
(b) tabelas sys e / ou configurações de servidor vinculado autorreferenciosamente sorrateiras (ou seja, para essas, preciso defender meu caso com nossos DBAs todo-poderosos):

No entanto, neste caso, eu não poderia usar uma construção INSERT ... EXEC, como sp_help_jobjá está usando uma. ("Uma instrução INSERT EXEC não pode ser aninhada.")

Para conseguir isso, primeiro crie um #test_tablelike abaixo:

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

Agora execute o procedimento e coloque valor em #test_table:

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

Agora você busca o valor de #test_table:

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

Se você conseguir modificar o procedimento armazenado, poderá colocar facilmente as definições de colunas necessárias como parâmetro e usar uma tabela temporária criada automaticamente:

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

Nesse caso, você não precisa criar uma tabela temporária manualmente - ela é criada automaticamente. Espero que isto ajude.

Pode ser útil saber por que isso é tão difícil. Um procedimento armazenado pode retornar apenas texto (imprimir 'texto') ou retornar várias tabelas ou retornar nenhuma tabela.

Então, algo como SELECT * FROM (exec sp_tables) Table1 não vai funcionar

(Assumindo o SQL Server)

A única maneira de trabalhar com os resultados de um procedimento armazenado no T-SQL é usar a INSERT INTO ... EXECsintaxe. Isso oferece a opção de inserir em uma tabela temporária ou variável de tabela e, a partir daí, selecionar os dados necessários.

Um hack rápido seria adicionar um novo parâmetro '@Column_Name'e fazer com que a função de chamada defina o nome da coluna a ser recuperada. Na parte de retorno do seu sproc, você teria instruções if / else e retornaria apenas a coluna especificada ou, se vazia - retornaria tudo.

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

Se você estiver fazendo isso para validação manual dos dados, poderá fazê-lo com o LINQPad.

Crie uma conexão com o banco de dados no LinqPad e crie instruções C # semelhantes à seguinte:

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();

Referência http://www.global-webnet.net/blogengine/post/2008/09/10/LINQPAD-Using-Stored-Procedures-Accessing-a-DataSet.aspx

Para o SQL Server, acho que isso funciona bem:

Crie uma tabela temporária (ou tabela permanente, realmente não importa) e insira uma instrução no procedimento armazenado. O conjunto de resultados do SP deve corresponder às colunas da sua tabela, caso contrário, você receberá um erro.

Aqui está um exemplo:

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;

É isso aí!

Como foi mencionado na pergunta, é difícil definir a tabela temporária de 80 colunas antes de executar o procedimento armazenado.

Portanto, o contrário é preencher a tabela com base no conjunto de resultados do procedimento armazenado.

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

Se você estiver recebendo algum erro, precisará ativar as consultas distribuídas ad hoc executando a consulta a seguir.

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

Para executar sp_configurecom os dois parâmetros para alterar uma opção de configuração ou executar a RECONFIGUREinstrução, você deve receber a ALTER SETTINGSpermissão no nível do servidor

Agora você pode selecionar suas colunas específicas na tabela gerada

SELECT col1, col2
FROM #temp

tente isso

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

Eu sei que executar a partir de sp e inserir na tabela temporária ou variável de tabela seria uma opção, mas não acho que esse seja seu requisito. Conforme sua exigência, esta instrução de consulta abaixo deve funcionar:

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

Se você possui uma conexão confiável, use esta instrução de consulta abaixo:

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

se você estiver recebendo um erro ao executar a instrução acima, basta executar esta instrução abaixo:

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

Espero que isso ajude alguém que enfrentou esse tipo de problema semelhante. Se alguém tentar com a tabela temporária ou variável de tabela que deve ser assim abaixo, mas nesse cenário você deve saber quantas colunas seu sp está retornando, então você deve criar tantas colunas na tabela temp ou na variável de tabela:

--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

Para quem possui o SQL 2012 ou posterior, consegui fazer isso com procedimentos armazenados que não são dinâmicos e têm as mesmas colunas sempre.

A idéia geral é criar a consulta dinâmica para criar, inserir, selecionar e soltar a tabela temporária e executá-la depois de gerada. Giro dinamicamente a tabela temporária, primeiro recuperando nomes e tipos de colunas do procedimento armazenado .

Nota: existem soluções muito melhores e mais universais que funcionarão com menos linhas de código se você estiver disposto / apto a atualizar o SP ou alterar a configuração e o uso OPENROWSET. Use o abaixo se você não tiver outra maneira.

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)

A maneira mais fácil de fazer, se você precisar fazer isso apenas uma vez:

Exporte para o Excel no assistente Importar e Exportar e, em seguida, importe esse excel para uma tabela.

Crie uma visão dinâmica e obtenha resultados dela .......

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

Recortaria e colaria o SP original e excluiria todas as colunas, exceto as 2 desejadas. Ou. Eu traria o conjunto de resultados de volta, mapeá-lo para um objeto de negócios adequado e, em seguida, LINQ fora das duas colunas.