Seleccionar columnas del conjunto de resultados del procedimiento almacenado

Tengo un procedimiento almacenado que devuelve 80 columnas y 300 filas. Quiero escribir una selección que obtenga 2 de esas columnas. Algo como

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

Cuando utilicé la sintaxis anterior obtengo el error:

"Nombre de columna inválido".

Sé que la solución más fácil sería cambiar el procedimiento almacenado, pero no lo escribí y no puedo cambiarlo.

¿Hay alguna forma de hacer lo que quiero?

• Podría hacer una tabla temporal para poner los resultados, pero debido a que hay 80 columnas, necesitaría hacer una tabla temporal de 80 columnas solo para obtener 2 columnas. Quería evitar rastrear todas las columnas que se devuelven.

• Intenté usar WITH SprocResults AS ....como lo sugirió Mark, pero obtuve 2 errores
  

  Sintaxis incorrecta cerca de la palabra clave 'EXEC'.
  Sintaxis incorrecta cerca ')'.

• Intenté declarar una variable de tabla y recibí el siguiente error
  

  Error de inserción: el nombre de la columna o el número de valores proporcionados no coincide con la definición de la tabla

• Si lo intento
  SELECT * FROM EXEC MyStoredProc 'param1', 'param2'
  me sale el error:
  

  Sintaxis incorrecta cerca de la palabra clave 'exec'.

¿Puedes dividir la consulta? Inserte los resultados de proceso almacenados en una variable de tabla o una tabla temporal. Luego, seleccione las 2 columnas de la variable de tabla.

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

SELECT col1, col2 FROM @tablevar

Aquí hay un enlace a un documento bastante bueno que explica todas las diferentes formas de resolver su problema (aunque muchas de ellas no se pueden usar ya que no puede modificar el procedimiento almacenado existente).

Cómo compartir datos entre procedimientos almacenados

La respuesta de Gulzar funcionará (está documentada en el enlace de arriba) pero será una molestia escribirla (necesitará especificar los 80 nombres de columna en su declaración @tablevar (col1, ...). Y en el futuro Si se agrega una columna al esquema o se cambia la salida, deberá actualizarse en su código o se producirá un error.

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

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

Esto funciona para mí: (es decir, solo necesito 2 columnas de las más de 30 devueltas 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 de que esto funcionara, necesitaba ejecutar esto:

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

.... para actualizar la sys.serverstabla. (es decir, el uso de una autorreferencia dentro de OPENQUERY parece estar deshabilitado de forma predeterminada).

Por mi simple requisito, no encontré ninguno de los problemas descritos en la sección OPENQUERY del excelente enlace de Lance.

Rossini, si necesita establecer dinámicamente esos parámetros de entrada, el uso de OPENQUERY se vuelve un poco más 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);

No estoy seguro de las diferencias (si las hay) entre usar sp_serveroptionpara actualizar la sys.serversautorreferencia existente directamente, versus usar sp_addlinkedserver(como se describe en el enlace de Lance) para crear un duplicado / alias.

Nota 1: Prefiero OPENQUERY sobre OPENROWSET, dado que OPENQUERY no requiere la definición de la cadena de conexión dentro del proceso.

Nota 2: Habiendo dicho todo esto: normalmente solo usaría INSERT ... EXEC :) Sí, son 10 minutos más de tipeo, pero si puedo evitarlo, prefiero no moverme con:
(a) comillas dentro de comillas dentro de citas, y
(b) tablas del sistema y / o configuraciones de servidor vinculado autorreferenciadas y escurridizas (es decir, para esto, necesito defender mi caso ante nuestros poderosos DBA :)

Sin embargo, en este caso, no pude usar una construcción INSERT ... EXEC, como sp_help_jobya estoy usando una. ("No se puede anidar una instrucción INSERT EXEC").

Para lograr esto, primero debe crear un me #test_tablegusta a continuación:

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

Ahora ejecute el procedimiento y ponga valor en #test_table:

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

Ahora obtiene el valor de #test_table:

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

Si puede modificar su procedimiento almacenado, puede poner fácilmente las definiciones de columnas necesarias como parámetro y utilizar una tabla temporal creada automáticamente:

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

En este caso, no necesita crear una tabla temporal manualmente, se crea automáticamente. Espero que esto ayude.

Puede ser útil saber por qué esto es tan difícil. Un procedimiento almacenado solo puede devolver texto (imprimir 'texto'), o puede devolver varias tablas, o puede no devolver ninguna tabla.

Entonces algo como SELECT * FROM (exec sp_tables) Table1 no funcionará

(Suponiendo SQL Server)

La única forma de trabajar con los resultados de un procedimiento almacenado en T-SQL es usar la INSERT INTO ... EXECsintaxis. Eso le da la opción de insertar en una tabla temporal o una variable de tabla y desde allí seleccionar los datos que necesita.

Un truco rápido sería agregar un nuevo parámetro '@Column_Name'y hacer que la función de llamada defina el nombre de la columna que se va a recuperar. En la parte de devolución de su sproc, tendría sentencias if / else y devolvería solo la columna especificada, o si está vacío, devuelva todo.

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 está haciendo esto para la validación manual de los datos, puede hacerlo con LINQPad.

Cree una conexión a la base de datos en LinqPad y luego cree declaraciones C # similares a las siguientes:

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

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

Para SQL Server, encuentro que esto funciona bien:

Cree una tabla temporal (o una tabla permanente, en realidad no importa) y realice una inserción en la declaración con el procedimiento almacenado. El conjunto de resultados del SP debe coincidir con las columnas de su tabla, de lo contrario obtendrá un error.

Aquí hay un ejemplo:

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;

¡Eso es!

Como se mencionó en la pregunta, es difícil definir la tabla temporal de 80 columnas antes de ejecutar el procedimiento almacenado.

Por lo tanto, al revés, debe completar la tabla en función del conjunto de resultados del procedimiento almacenado.

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

Si recibe algún error, debe habilitar consultas distribuidas ad hoc ejecutando la siguiente consulta.

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

Para ejecutar sp_configurecon ambos parámetros para cambiar una opción de configuración o para ejecutar la RECONFIGUREinstrucción, se le debe otorgar el ALTER SETTINGSpermiso de nivel de servidor

Ahora puede seleccionar sus columnas específicas de la tabla generada

SELECT col1, col2
FROM #temp

prueba esto

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

Sé que ejecutar desde sp e insertar en la tabla temporal o variable de tabla sería una opción, pero no creo que sea su requisito. Según su requisito, esta declaración de consulta a continuación debería 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)

si tiene conexión de confianza, use esta declaración de consulta a continuación:

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

si obtiene un error al ejecutar la declaración anterior, simplemente ejecute esta declaración a continuación:

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

Espero que esto ayude a alguien que haya enfrentado este tipo de problema similar. Si alguien intentara con una tabla temporal o variable de tabla que debería ser así a continuación, pero en este escenario debe saber cuántas columnas está devolviendo su sp, entonces debe crear esa cantidad de columnas en la tabla temporal o variable de tabla:

--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 cualquiera que tenga SQL 2012 o posterior, pude lograr esto con procedimientos almacenados que no son dinámicos y tienen la misma salida de columnas cada vez.

La idea general es que construyo la consulta dinámica para crear, insertar, seleccionar y soltar la tabla temporal, y ejecutar esto después de que todo se haya generado. Genero dinámicamente la tabla temporal recuperando primero los nombres y tipos de columna del procedimiento almacenado .

Nota: existen soluciones mucho mejores y más universales que funcionarán con menos líneas de código si desea / puede actualizar el SP o cambiar la configuración y el uso OPENROWSET. Use el siguiente si no tiene otra manera.

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)

La forma más fácil de hacerlo si solo necesita hacer esto una vez:

Exportar a Excel en el asistente Importar y Exportar y luego importar este Excel a una tabla.

Cree una vista dinámica y obtenga resultados de ella .......

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

Cortaría y pegaría el SP original y eliminaría todas las columnas excepto las 2 que desee. O. Traería el resultado establecido, lo mapearía a un objeto comercial apropiado, luego LINQ fuera de las dos columnas.