temporales - tabla temporal sql server ejemplo

TSQL selecciona en tabla Temp desde sql dinámico

Question

Esto parece relativamente simple, pero aparentemente no lo es.

Necesito crear una tabla temporal basada en una tabla existente a través de la sintaxis select into:

SELECT * INTO #TEMPTABLE FROM EXISTING_TABLE

El problema es que el nombre de la tabla existente se acepta a través de un parámetro ...

Puedo obtener los datos de la tabla a través de:

execute (''SELECT * FROM '' + @tableName)

pero ¿cómo casarme con los dos para poder poner los resultados de la ejecución directamente en la tabla temporal?

Las columnas para cada tabla para la que se va a utilizar no son las mismas, por lo que construir la tabla temporal antes de obtener los datos no es práctico.

Estoy abierto a cualquier sugerencia, excepto el uso de una tabla global de temperatura.

Actualizar:

Esto es completamente ridículo, PERO mis reservas con la tabla temporal global es que esta es una plataforma multiusuario que se presta a problemas si la tabla persiste por largos períodos de tiempo ...

Entonces ... solo para pasar esta parte comencé usando la ejecución para generar una tabla global de temperatura.

execute(''select * into ##globalDynamicFormTable from '' + @tsFormTable) 

Luego uso la tabla global de temperatura para cargar la tabla temporal local:

select * into #tempTable from ##globalDynamicFormTable

Luego dejo caer la tabla global.

drop table ##globalDynamicFormTable

esto es sucio y no me gusta, pero por el momento, hasta que tenga una mejor solución, tendrá que funcionar.

En el final:

Supongo que no hay forma de evitarlo.

La mejor respuesta parece ser cualquiera;

Cree una vista en el comando de ejecución y utilícela para cargar la tabla temporal local en el procedimiento almacenado.

Cree una tabla temporal global en el comando de ejecución y utilícela para cargar la tabla temporal local.

Dicho esto, probablemente me quedo con la tabla temporal global porque la creación y caída de vistas se audita en mi organización, y estoy seguro de que van a cuestionar eso si comienza a suceder todo el tiempo.

¡Gracias!

Answer 1

Un ejemplo de trabajo.

DECLARE @TableName AS VARCHAR(100)
SELECT @TableName = ''YourTableName''

EXECUTE (''SELECT * INTO #TEMP  FROM '' + @TableName +''; SELECT * FROM #TEMP;'')

Segunda solución con tabla de temperatura accesible

DECLARE @TableName AS VARCHAR(100)
SELECT @TableName = ''YOUR_TABLE_NAME''

EXECUTE (''CREATE VIEW vTemp AS
        SELECT *
        FROM '' + @TableName)
SELECT * INTO #TEMP  FROM vTemp 

--DROP THE VIEW HERE      
DROP VIEW vTemp

/*START USING TEMP TABLE
************************/
--EX:
SELECT * FROM #TEMP


--DROP YOUR TEMP TABLE HERE
DROP TABLE #TEMP

Answer 2

Eche un vistazo a OPENROWSET y haga algo como:

SELECT * INTO #TEMPTABLE FROM OPENROWSET(''SQLNCLI''
     , ''Server=(local)/SQL2008;Trusted_Connection=yes;'',
     ''SELECT * FROM '' + @tableName)

Answer 3

declare @sql varchar(100);

declare @tablename as varchar(100);

select @tablename = ''your_table_name'';

create table #tmp 
    (col1 int, col2 int, col3 int);

set @sql = ''select aa, bb, cc from '' + @tablename;

insert into #tmp(col1, col2, col3) exec @sql;

select * from #tmp;

Answer 4

Cómo lo hice con un pivote en sql dinámico (#AccPurch se creó antes de esto)

DECLARE @sql AS nvarchar(MAX)
declare @Month Nvarchar(1000)

--DROP TABLE #temp
select distinct YYYYMM into #temp from #AccPurch AS ap
SELECT  @Month = COALESCE(@Month, '''') + ''['' + CAST(YYYYMM AS VarChar(8)) + ''],'' FROM    #temp

SELECT   @Month= LEFT(@Month,len(@Month)-1)


SET @sql = N''SELECT UserID, ''+ @Month + N'' into ##final_Donovan_12345 FROM (
Select ap.AccPurch ,
       ap.YYYYMM ,
       ap.UserID ,
       ap.AccountNumber
FROM #AccPurch AS ap 
) p
Pivot (SUM(AccPurch) FOR YYYYMM IN (''+@Month+ N'')) as pvt''


EXEC sp_executesql @sql

Select * INTO #final From ##final_Donovan_12345

DROP TABLE  ##final_Donovan_12345

Select * From #final AS f

Answer 5

Puedo pensar en algunas formas de seleccionar datos de una tabla cuyo nombre se generó dinámicamente, sin usar tablas temporales globales.

Solución 1

Construya la cadena que contiene el nombre de su tabla fuente y haga que toda su consulta sea dinámica.

Solución 2

Esta solución, que implica una variable de tabla, funcionará, siempre que sepa ...

• ... el número, nombre y tipo de las columnas ...
• ... el nombre de la columna de la clave principal EDITAR : (vale, aparentemente esto no es estrictamente cierto, ya que se puede generar dinámicamente ) ...

en tu tabla fuente.

-- Number of rows in your source table
DECLARE @RowCount INT;
SELECT @RowCount = SUM(st.row_count) FROM sys.dm_db_partition_stats st WHERE object_name(object_id) = EmployeesWeek_ + CONVERT( VARCHAR(10),WEEK(GETDATE()) ) AND (index_id < 2);

-- All columns from your source table
DECLARE @col1 int;
DECLARE @col2 varchar(50);
DECLARE @col3 varchar(5);
DECLARE @col4 int;
DECLARE @col5 smalldatetime;
DECLARE @col6 bit;

-- This table variable will store the data
DECLARE @Dump TABLE (
    col1 int,
    col2 varchar(50),
    col3 varchar(5),
    col4 int,
    col5 smalldatetime,
    col6 bit
)

DECLARE @RowIter INT = 1;
WHILE @RowIter <= @RowCount
BEGIN
    DECLARE @QueryString NVARCHAR(MAX) = CONCAT(N''
            SELECT
                @col1 = ID,
                @col2 = Name,
                @col3 = NameAbbr,
                @col4 = UpdatedBy,
                @col5 = DateUpdated,
                @col6 = Active

            FROM (
                SELECT
                    ROW_NUMBER() OVER (ORDER BY PKArea ASC) AS RowNum,
                    *
                FROM
                    EmployeesWeek_'',WEEK(GETDATE()),''
            ) sq

            WHERE
                RowNum = '', @RowIter , ''
            ;
        '');
    EXEC dbo.sp_executesql
        @QueryString,
        -- OUTPUT VARIABLE DECLARATION
        N''
            @col1 int out,
            @col2 varchar(50) out,
            @col3 varchar(5) out,
            @col4 int out,
            @col5 smalldatetime out,
            @col6 bit out
        '',
        -- ALL OUTPUT VARIABLES
        @col1 out,
        @col2 out,
        @col3 out,
        @col4 out,
        @col5 out,
        @col6 out
    ;

    INSERT INTO @Dump values(@col1, @col2, @col3, @col4, @col5, @col6);

    SET @RowIter = @RowIter + 1;

END

SELECT * FROM @Dump;

Mi intuición dice que esto es potencialmente lento en grandes conjuntos de datos, y no sé si se puede hacer esta consulta dinámica (debería ser posible consultando la lista de nombres de columnas, usando hacks sucios para construir la cadena que contiene la lista de columnas , etc., pero por ahora no puedo dedicarle más tiempo a esto ...), lo que le permite seleccionar datos de una tabla con cualquier cantidad de columnas; pero de nuevo, esto es SQL ...