T-SQL Come creare tabelle dinamicamente nelle stored procedure?

Question

codice come questo, ma è sbagliato:

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

Potrebbe dirmi come trattare con esso? Mi disturba davvero.

Answer 1

Si sta utilizzando una variabile di tabella, vale a dire si dovrebbe dichiarare la tabella. Questo non è un tavolo temporaneo.

si crea una tabella temporanea in questo modo:

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

si dichiara una variabile di tabella in questo modo:

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

Si noti che una tabella temporanea viene dichiarata utilizzando # e una variabile di tabella viene dichiarata utilizzando a @. Leggi la differenza tra le variabili di tabella e le tabelle temporanee.

UPDATE:

Sulla base della sua commento qui sotto in realtà si sta cercando di creare le tabelle in una stored procedure. Per questo è necessario utilizzare SQL dinamico. SQL fondamentalmente dinamico consente di costruire un'istruzione SQL sotto forma di stringa e quindi eseguirla. Questo è l'UNICO modo in cui sarà possibile creare una tabella in una stored procedure. Ti mostrerò come e poi discuterò perché questa non è generalmente una buona idea.

Ora per un semplice esempio (non ho ancora testato questo codice, ma dovrebbe darvi una buona indicazione di come farlo):

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 

Questa stored procedure può essere eseguito in questo modo:

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

Vi sono alcuni problemi importanti con questo tipo di stored procedure.

Sarà difficile gestire tabelle complesse. Immaginate la seguente struttura di tabella:

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 

Questa tabella è un po 'più complessa del primo esempio non molto. La procedura memorizzata sarà molto più complessa da gestire.Quindi, mentre questo approccio potrebbe funzionare per piccoli tavoli, sarà presto ingestibile.

La creazione di tabelle richiede una pianificazione. Quando crei tabelle, dovrebbero essere posizionate strategicamente su filegroup diversi. Questo per garantire che non si verifichi un conflitto di I/O del disco. Come affronterai la scalabilità se tutto è stato creato nel gruppo di file principale.

Potrebbe chiarire perché è necessario creare tabelle dinamicamente?

UPDATE 2:

differita aggiornamento a causa del carico di lavoro. Ho letto il tuo commento sulla necessità di creare un tavolo per ogni negozio e penso che dovresti guardare a farlo come nell'esempio che sto per darti.

In questo esempio effettuare le seguenti ipotesi

1. E 'un sito di e-commerce che ha molti negozi
2. Un negozio può avere molti articoli (merci) da vendere.
3. Un elemento particolare (merci) può essere venduto in molti negozi
4. Un negozio addebiterà prezzi diversi per i diversi articoli (merci)
5. Tutti i prezzi sono in $ (USD)

Let dirlo il sito di e-commerce vende console di gioco (ad esempio Wii, PS3, XBOX360).

Guardando alle mie supposizioni vedo una relazione classica da molti a molti. Un negozio può vendere molti articoli (merci) e articoli (merci) possono essere venduti in molti negozi. Consente di suddividerlo in tabelle.

Per prima cosa avrei bisogno di un tavolo del negozio per memorizzare tutte le informazioni sul negozio.

Una semplice tabella negozio potrebbe assomigliare a questo:

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 

Lets inserire tre negozi nel database da utilizzare durante il nostro esempio. Il codice seguente inserirà tre negozi;

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

Se si esegue un SELECT * FROM Shop probabilmente vedrete il seguente:

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

Proprio così ora lascia spostare sul Items (merci) tavolo. Dato che gli articoli/le merci sono prodotti di varie aziende, chiamerò il prodotto da tavolo. È possibile eseguire il codice seguente per creare una tabella prodotti semplice.

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 

Consente di popolare la tabella prodotti con alcuni prodotti. Esegui il seguente codice per inserire alcuni prodotti.

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

Se si esegue SELECT * FROM Product probabilmente vedrete il seguente:

ProductID ProductDescription 
1   PS3 
2   Wii 
3   XBOX360 

Ok, a questo punto si dispone di prodotti e acquisti le informazioni. Quindi come li mettete insieme.Bene, sappiamo che possiamo identificare il negozio tramite la colonna chiave primaria di ShopID e sappiamo che possiamo identificare un prodotto tramite la sua colonna chiave ProductID primaria. Inoltre, poiché ogni negozio ha un prezzo diverso per ogni prodotto, dobbiamo archiviare il prezzo che il negozio addebita per il prodotto.

Quindi abbiamo una tabella che associa il Negozio al prodotto. Chiameremo questa tabella ShopProduct. Una versione semplice di questa tabella potrebbe assomigliare a questo:

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 

Quindi, consente di assumere il negozio American Games R Us vende solo le console americane, l'esperienza in Europa Gaming vende tutte le console e giochi asiatici Emporium vende solo asiatico avremmo bisogno per mappare le chiavi primarie dal negozio e le tabelle dei prodotti nella tabella ShopProduct.

Ecco come faremo la mappatura. Nel mio esempio, American Games R Us ha un valore ShopID pari a 1 (questo è il valore chiave principale) e posso vedere che XBOX360 ha un valore di 3 e il negozio ha elencato XBOX360 per $ 159,99

Eseguendo il comando seguente codice si completerà la mappatura:

INSERT INTO ShopProduct VALUES(1,3,159.99) 

Ora vogliamo aggiungere tutti i prodotti al negozio di Europa Gaming Experience. In questo esempio sappiamo che il negozio di esperienza di gioco in Europa ha uno ShopID di 3 e dal momento che vende tutte le console sarà necessario inserire il ProductID 1,2 e 3 nella tabella di mapping. Supponiamo che i prezzi delle console (prodotti) nel negozio di Europa Gaming Experience siano i seguenti: 1- La PS3 vende per $ 259,99, 2- La Wii vende per $ 159,99, 3- La XBOX360 vende per $ 199,99.

per ottenere questo mappatura fatto si avrebbe bisogno di eseguire il codice seguente:

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 

A questo punto è stata mappata due negozi e dei loro prodotti nella tabella di mappatura. Ok, ora come faccio a portare tutto questo insieme per mostrare un utente che naviga nel sito. Diciamo che vuoi mostrare tutto il prodotto per la European Gaming Experience a un utente su una pagina web di cui avresti bisogno per eseguire la seguente query.

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 

probabilmente vedrete i seguenti risultati:

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 

Ora, per un ultimo esempio lascia supporre che il vostro sito ha una caratteristica che trova il prezzo più basso per una console. Un utente chiede di trovare i prezzi più economici per XBOX360.

è possibile eseguire la seguente query:

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 

Questa query restituirà un elenco di tutti i negozi che vende la XBOX360 con il negozio più economico prima e così via.

Noterai che non ho aggiunto il negozio di giochi asiatici. Come esercizio aggiungere il negozio di giochi asiatico alla tabella di mappatura con i seguenti prodotti. The Asian Games Emporium vende la console per giochi Wii a $ 99,99 e la console PS3 a $ 159,99. Se segui questo esempio, ora dovresti capire come modellare una relazione molte a molte.

Spero che questo ti aiuti nei tuoi viaggi con la progettazione del Database.

Answer 2

Sarà necessario creare quell'istruzione CREATE TABLE dagli input e quindi eseguirla.

Un semplice esempio:

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

Il primo, ti sembra di essere miscelazione variabili di tabella e le tabelle.

In entrambi i casi, non è possibile passare il nome del tavolo in questo modo. Dovresti usare TSQL dinamico per farlo.

Se si desidera solo per dichiarare una variabile di tabella:

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

Il fatto che si desidera creare una stored procedure per creare dinamicamente le tabelle potrebbero suggerire il disegno è sbagliato.

Answer 4

È possibile scrivere il codice qui sotto: -

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

eseguirlo come: -

exec spCreateTable