T-SQL ¿Cómo crear tablas dinámicamente en procedimientos almacenados?

Question

Código como este, pero que está mal:

CREATE PROC sp_createATable 
    @name  VARCHAR(10), 
    @properties VARCHAR(500) 
AS 
    CREATE TABLE @name 
    (
    id CHAR(10) PRIMARY KEY, 
    --...Properties extracted from @properties 
); 

¿Me podría decir cómo tratar con él? Realmente me preocupa

Answer 1

Está utilizando una variable de tabla, es decir, debe declarar la tabla. Esta no es una tabla temporal.

se crea una tabla temporal de este modo:

CREATE TABLE #customer 
(
    Name varchar(32) not null 
) 

se declara una variable de tabla, así:

DECLARE @Customer TABLE 
(
     Name varchar(32) not null 
) 

Tenga en cuenta que una tabla temporal se declara usando # y una variable de tabla se declara utilizando un @. Lea acerca de la diferencia entre las variables de tabla y las tablas temporales.

ACTUALIZACIÓN:

Basado en su comentario a continuación en realidad se está tratando de crear tablas en un procedimiento almacenado. Para esto, necesitaría usar sql dinámico. Básicamente, SQL dinámico le permite construir una instrucción SQL en forma de cadena y luego ejecutarla. Esta es la ÚNICA forma en que podrá crear una tabla en un procedimiento almacenado. Voy a mostrarte cómo y luego discutir por qué esto generalmente no es una buena idea.

Ahora, para un ejemplo sencillo (no he probado este código, pero debería darle una buena indicación de cómo hacerlo):

CREATE PROCEDURE sproc_BuildTable 
    @TableName NVARCHAR(128) 
    ,@Column1Name NVARCHAR(32) 
    ,@Column1DataType NVARCHAR(32) 
    ,@Column1Nullable NVARCHAR(32) 
AS 

    DECLARE @SQLString NVARCHAR(MAX) 
    SET @SQString = 'CREATE TABLE '+@TableName + '('+@Column1Name+' '+@Column1DataType +' '+@Column1Nullable +') ON PRIMARY ' 

    EXEC (@SQLString) 
    GO 

Este procedimiento almacenado se puede ejecutar la siguiente manera:

sproc_BuildTable 'Customers','CustomerName','VARCHAR(32)','NOT NULL'

Hay algunos problemas importantes con este tipo de procedimiento almacenado.

Va a ser difícil atender mesas complejas. Imagine la siguiente estructura de tabla:

CREATE TABLE [dbo].[Customers] (
    [CustomerID] [int] IDENTITY(1,1) NOT NULL, 
    [CustomerName] [nvarchar](64) NOT NULL, 
    [CustomerSUrname] [nvarchar](64) NOT NULL, 
    [CustomerDateOfBirth] [datetime] NOT NULL, 
    [CustomerApprovedDiscount] [decimal](3, 2) NOT NULL, 
    [CustomerActive] [bit] NOT NULL, 
    CONSTRAINT [PK_Customers] PRIMARY KEY CLUSTERED 
    (
     [CustomerID] ASC 
    ) WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF,  ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY] 
) ON [PRIMARY] 
GO 

ALTER TABLE [dbo].[Customers] ADD CONSTRAINT [DF_Customers_CustomerApprovedDiscount] DEFAULT ((0.00)) FOR [CustomerApprovedDiscount] 
GO 

Esta tabla es un poco más compleja que el primer ejemplo, no mucho. El procedimiento almacenado será mucho más complejo de manejar.Entonces, si bien este enfoque podría funcionar para tablas pequeñas, rápidamente será inmanejable.

tablas Creación requieren una planificación. Cuando creas tablas, deben ubicarse estratégicamente en diferentes grupos de archivos. Esto es para garantizar que no causa discordancia de IO de disco. ¿Cómo abordará la escalabilidad si todo se crea en el grupo de archivos primario?

Podría aclarar por qué se necesitan tablas que se creará de forma dinámica?

ACTUALIZACIÓN 2:

retardada actualización debido a la carga de trabajo. He leído su comentario sobre la necesidad de crear una tabla para cada tienda y creo que usted debe buscar en hacerlo como el ejemplo que voy a dar a usted.

En este ejemplo me hacen las siguientes suposiciones

1. Es un sitio de comercio electrónico que tiene muchas tiendas
2. Una tienda puede tener muchos artículos (bienes) para vender.
3. Un artículo en particular (los bienes) puede ser vendido en muchas tiendas
4. Una tienda será cobrar precios diferentes para diferentes artículos (bienes)
5. Todos los precios están en $ (USD)

Let decir esto sitio de comercio electrónico vende consolas de juegos (es decir, Wii, PS3, XBOX360).

En cuanto a mis supuestos Veo una clásica de muchos a muchos. Una tienda puede vender muchos artículos (bienes) y artículos (bienes) se pueden vender en muchas tiendas. Vamos a dividir esto en tablas.

Primero que necesitaría una mesa tienda para almacenar toda la información sobre la tienda.

Una tabla simple tienda podría tener este aspecto:

CREATE TABLE [dbo].[Shop](
    [ShopID] [int] IDENTITY(1,1) NOT NULL, 
    [ShopName] [nvarchar](128) NOT NULL, 
    CONSTRAINT [PK_Shop] PRIMARY KEY CLUSTERED 
    (
     [ShopID] ASC 
    ) WITH (
       PAD_INDEX = OFF 
       , STATISTICS_NORECOMPUTE = OFF 
       , IGNORE_DUP_KEY = OFF 
       , ALLOW_ROW_LOCKS = ON 
       , ALLOW_PAGE_LOCKS = ON 
    ) ON [PRIMARY] 
    ) ON [PRIMARY] 

    GO 

Permite insertar tres tiendas en la base de datos para su uso durante nuestro ejemplo. El siguiente código insertará tres tiendas;

INSERT INTO Shop 
SELECT 'American Games R US' 
UNION 
SELECT 'Europe Gaming Experience' 
UNION 
SELECT 'Asian Games Emporium' 

Si se ejecuta una SELECT * FROM Shop es probable que vea lo siguiente:

ShopID ShopName 
1   American Games R US 
2   Asian Games Emporium 
3   Europe Gaming Experience 

derecho por lo que ahora vamos a pasar a la (bienes) tabla de artículos. Como los artículos/productos son productos de varias compañías, voy a llamar al producto de la mesa. Puede ejecutar el siguiente código para crear una tabla de Producto simple.

CREATE TABLE [dbo].[Product](
    [ProductID] [int] IDENTITY(1,1) NOT NULL, 
    [ProductDescription] [nvarchar](128) NOT NULL, 
CONSTRAINT [PK_Product] PRIMARY KEY CLUSTERED 
(
    [ProductID] ASC 
)WITH (PAD_INDEX = OFF 
     , STATISTICS_NORECOMPUTE = OFF 
     , IGNORE_DUP_KEY = OFF 
     ,  ALLOW_ROW_LOCKS = ON 
     , ALLOW_PAGE_LOCKS = ON) ON [PRIMARY] 
) ON [PRIMARY] 

GO 

Permite rellenar la tabla productos con algunos productos. Ejecute el siguiente código para insertar algunos productos.

INSERT INTO Product 
SELECT 'Wii' 
UNION 
SELECT 'PS3' 
UNION 
SELECT 'XBOX360' 

Si ejecuta SELECT * FROM Product es probable que vea lo siguiente:

ProductID ProductDescription 
1   PS3 
2   Wii 
3   XBOX360 

Ok en este momento tiene el producto y compras información. Entonces, ¿cómo los reúnes?Bien, sabemos que podemos identificar la tienda por su columna de clave primaria ShopID y sabemos que podemos identificar un producto por su columna de clave primaria ProductID. Además, dado que cada tienda tiene un precio diferente para cada producto, necesitamos almacenar el precio que la tienda cobra por el producto.

Así que tenemos una tabla que asigna la Tienda al producto. Llamaremos a esta tabla ShopProduct. Una versión simple de esta tabla podría tener este aspecto:

CREATE TABLE [dbo].[ShopProduct](
[ShopID] [int] NOT NULL, 
[ProductID] [int] NOT NULL, 
[Price] [money] NOT NULL, 
CONSTRAINT [PK_ShopProduct] PRIMARY KEY CLUSTERED 
(
    [ShopID] ASC, 
     [ProductID] ASC 
)WITH (PAD_INDEX = OFF, 
    STATISTICS_NORECOMPUTE = OFF, 
    IGNORE_DUP_KEY = OFF, 
    ALLOW_ROW_LOCKS = ON, 
    ALLOW_PAGE_LOCKS = ON) ON [PRIMARY] 
) ON [PRIMARY] 

GO 

Así que vamos a asumir la tienda de American Games R Us sólo vende consolas americanas, la experiencia de Europa del juego vende todas las consolas y los juegos asiáticos Emporium sólo vende asiático necesitaríamos mapear las claves principales de la tienda y las tablas de productos en la tabla ShopProduct.

Así es como vamos a hacer el mapeo. En mi ejemplo, American Games R Us tiene un valor ShopID de 1 (este es el valor clave principal) y puedo ver que XBOX360 tiene un valor de 3 y la tienda ha incluido XBOX360 por $ 159.99

Ejecutando el código siguiente completaría la asignación:

INSERT INTO ShopProduct VALUES(1,3,159.99) 

Ahora queremos agregar todos los productos a la tienda de Europa Gaming Experience. En este ejemplo, sabemos que la tienda de Europe Gaming Experience tiene un ShopID de 3 y dado que vende todas las consolas, tendremos que insertar ProductID 1,2 y 3 en la tabla de asignación. Supongamos que los precios de las consolas (productos) en la tienda de Europa Gaming Experience son los siguientes: 1- La PS3 se vende por $ 259.99, 2- La Wii se vende por $ 159.99, 3- La XBOX360 se vende por $ 199.99.

para conseguir este mapeo hacer lo que se necesita para ejecutar el siguiente código:

INSERT INTO ShopProduct VALUES(3,2,159.99) --This will insert the WII console into the mapping table for the Europe Gaming Experience Shop with a price of 159.99 
INSERT INTO ShopProduct VALUES(3,1,259.99) --This will insert the PS3 console into the mapping table for the Europe Gaming Experience Shop with a price of 259.99 
INSERT INTO ShopProduct VALUES(3,3,199.99) --This will insert the XBOX360 console into the mapping table for the Europe Gaming Experience Shop with a price of 199.99 

En este punto ha asignado dos tiendas y sus productos en la tabla de asignación. Ok, entonces ahora ¿cómo puedo juntar todo esto para mostrarle a un usuario que navega por el sitio web? Digamos que quiere mostrar todo el producto para la Experiencia de juego europea a un usuario en una página web que necesitaría para ejecutar la siguiente consulta.

SELECT  Shop.* 
     , ShopProduct.* 
     , Product.* 
FROM   Shop 
INNER JOIN ShopProduct ON Shop.ShopID = ShopProduct.ShopID 
INNER JOIN Product ON ShopProduct.ProductID = Product.ProductID 
WHERE  Shop.ShopID=3 

es probable que vea los siguientes resultados:

ShopID  ShopName     ShopID ProductID Price ProductID ProductDescription 
3   Europe Gaming Experience 3   1  259.99 1   PS3 
3   Europe Gaming Experience 3   2  159.99 2   Wii 
3   Europe Gaming Experience 3   3  199.99 3   XBOX360 

Ahora para un último ejemplo, supongamos que su sitio web tiene una característica que encuentra el precio más barato para una consola. Un usuario pregunta para encontrar los precios más baratos para XBOX360.

puede ejecutar la siguiente consulta:

SELECT  Shop.* 
     , ShopProduct.* 
     , Product.* 
FROM   Shop 
INNER JOIN ShopProduct ON Shop.ShopID = ShopProduct.ShopID 
INNER JOIN Product ON ShopProduct.ProductID = Product.ProductID 
WHERE  Product.ProductID =3 -- You can also use Product.ProductDescription = 'XBOX360' 
ORDER BY Price ASC 

Esta consulta devolverá una lista de todas las tiendas, que vende la XBOX360 con la tienda más barata primero y así sucesivamente.

Notarás que no he añadido la tienda Asian Games. Como ejercicio, agregue la tienda de juegos asiática a la tabla de mapeo con los siguientes productos. Asian Games Emporium vende la consola de juegos Wii por $ 99.99 y la consola PS3 por $ 159.99. Si trabaja con este ejemplo, ahora debe comprender cómo modelar una relación de muchos a muchos.

Espero que esto lo ayude en sus viajes con el diseño de la base de datos.

Answer 2

Deberá compilar esa instrucción CREATE TABLE a partir de las entradas y luego ejecutarla.

Un ejemplo sencillo:

declare @cmd nvarchar(1000), @TableName nvarchar(100); 

set @TableName = 'NewTable'; 

set @cmd = 'CREATE TABLE dbo.' + quotename(@TableName, '[') + '(newCol int not null);'; 

print @cmd; 

--exec(@cmd); 

Answer 3

En primer lugar, usted parece estar mezclando variables y tablas de mesa.

De cualquier manera, No puede pasar el nombre de la tabla así. Tendría que usar un TSQL dinámico para hacer eso.

Si lo que desea es declarar una variable de tabla:

CREATE PROC sp_createATable 
    @name  VARCHAR(10), 
    @properties VARCHAR(500) 
AS 
    declare @tablename TABLE 
    ( 
    id CHAR(10) PRIMARY KEY 
); 

El hecho de que desea crear un procedimiento almacenado para crear dinámicamente tablas podrían sugerir su diseño es erróneo.

Answer 4

Puede escribir el código de abajo: -

create procedure spCreateTable 
    as 
    begin 
     create table testtb(Name varchar(20)) 
    end 

ejecutarlo como: -

ejecutivo spCreateTable