Newsgroup: it.comp.software.database
Titolo: LISTA TABELLE DB SQL SERVER

come posso ottenere da script sql la lista di tutte le tabelle di un
database in ordine di gerarchia , devo lanciare dei dts da riga di comando
ed ho un dts per ogni tabella e quindi devo lanciarli in ordine
grazie
ciao
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 grazie
Prego.
Ciao!
-- 
Lorenzo Benaglia
Microsoft MVP - SQL Server
http://mvp.support.microsoft.com
http://italy.mvps.org

 ha
scritto:

--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

GO
Se sei su MS SQL 7.0 non mi sembra ci siano le tabelle
INFORMATION_SCHEMA.* (ma non sono sicuro)
Puo' andare anche una 
select * from sysobjects where type='U'
fatta dal database del quale ti interessa la lista, che funziona sia
su SQL 7.0 sia sul 2000
Stefano "HappyMan" (Lago Maggiore - NO)
--
Personal Web 
http://www.sgr.info
Email happyman69 (at) 
libero.it

 su SQL 7.0 sia sul 2000
Esatto, ma sarebbe opportuno "perdere il vizio" di interrogare le tabelle di
sistema se esistono delle valide alternative. :-)
Ogni upgrade (ad esempio un service pack, una security fix, ecc.) può
apportare modifiche alla struttura delle tabelle di sistema, quindi
eventuali clients che fanno un accesso diretto a tali tabelle potrebbero
smettere di funzionare.



ha scritto:

--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

ottengo anche un ordine padre-figlio?
Non è chiaro cosa intendi per "ordine padre-figlio"
Se intendi quelle tabelle tipo "Testata ordine" e "Dettaglio ordine"
sicuramente no, perché questa è una tua organizzazione logica, se
invece intendi ordinare le tabelle del tuo database in base alla
dipendenza delle chiavi primarie/foreign keys...direttamente non puoi
farlo, ma ti puoi creare una stored che in modo ricorsivo analizza le
dipendenze e ti restituisce le tabelle nel giusto ordine per (esempio
) una eventuale copia.
Un mio ex collega, veramente in gamba con T-SQL, lo aveva fatto:
lanciavi questa stored e ti restituiva un result set con tutte le
tabelle ordinate in base alle varie dipendenze.


 ottengo anche un ordine padre-figlio?
Ciao Alberto,
non e' molto intuitiva ma eccone una versione.
Nota questa ordina le tabelle dalle foglie alle radici,
se ti serve fare il contrario rimuovi la keyword DESC
alla fine.
Adattandola alle tabelle di sistema si puo' semplificare
(solo perche' il catalogo di sistema espone una chiave
artificiale numerica per indentificare univocamente le
tabelle, utilizzando le information schema view dobbiamo
utilizzare la chiave naturale che e' composta dai tre
attributi catalogo, schema e nome).
Tieni conto che ci sono molti altri metodi per costrutire
la gerarchia (materialized paths, nested sets), ed alcuni
sono piu' efficienti se poi devi fare una ricerca nella
gerarchia, questo e' un esempio di come farlo con la
tecnica della "chiusura transitiva" (in pratica costruisci
una relazione che dice solo se tra due nodi c'e' un percorso)
Anche a questa tecnica possono essere applicate alcune
ottimizzazioni, ad esempio si puo' effettuare una
denormalizzazione in fase di costruzione della
"transitive closure" calcolando direttamente il
livello e salvandoloo nella tabella (ti evita l'operazione
di aggregazione nella select per derivare il livello)
Ciao,
--
Gianluca Hotz - SQL Server MVP
http://italy.mvps.org
 - 
http://www.ghotz.com
http://www.ugiss.org
  - 
http://www.ugidotnet.org
--<CUT HERE>--
/*
** find_table_dependencies.sql
**
** Gianluca Hotz (
gh...@alphasys.it
)
*/
-- Create the transitive closure table
DECLARE @TransitiveClosure TABLE (
 TABLE_CATALOG_PARENT nvarchar(128) NOT NULL
, TABLE_SCHEMA_PARENT nvarchar(128) NOT NULL
, TABLE_NAME_PARENT nvarchar(128) NOT NULL
, TABLE_CATALOG_CHILD nvarchar(128) NOT NULL
, TABLE_SCHEMA_CHILD nvarchar(128) NOT NULL
, TABLE_NAME_CHILD nvarchar(128) NOT NULL
)
INSERT @TransitiveClosure
SELECT
 T2.TABLE_CATALOG AS TABLE_CATALOG_PARENT
, T2.TABLE_SCHEMA AS TABLE_SCHEMA_PARENT
, T2.TABLE_NAME AS TABLE_NAME_PARENT
, T1.TABLE_CATALOG AS TABLE_CATALOG_CHILD
, T1.TABLE_SCHEMA AS TABLE_SCHEMA_CHILD
, T1.TABLE_NAME AS TABLE_NAME_CHILD
FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS AS RC
JOIN INFORMATION_SCHEMA.CONSTRAINT_TABLE_USAGE AS T1
  ON T1.CONSTRAINT_CATALOG = RC.CONSTRAINT_CATALOG
 AND T1.CONSTRAINT_SCHEMA = RC.CONSTRAINT_SCHEMA
 AND T1.CONSTRAINT_NAME = RC.CONSTRAINT_NAME
JOIN INFORMATION_SCHEMA.CONSTRAINT_TABLE_USAGE AS T2
  ON T2.CONSTRAINT_CATALOG = RC.UNIQUE_CONSTRAINT_CATALOG
 AND T2.CONSTRAINT_SCHEMA = RC.UNIQUE_CONSTRAINT_SCHEMA
 AND T2.CONSTRAINT_NAME = RC.UNIQUE_CONSTRAINT_NAME
WHILE (@@ROWCOUNT > 0)
BEGIN
 INSERT @TransitiveClosure
 SELECT
  P.TABLE_CATALOG_PARENT
 , P.TABLE_SCHEMA_PARENT
 , P.TABLE_NAME_PARENT
 , C.TABLE_CATALOG_CHILD
 , C.TABLE_SCHEMA_CHILD
 , C.TABLE_NAME_CHILD
 FROM @TransitiveClosure AS P
 JOIN @TransitiveClosure AS C
   ON P.TABLE_CATALOG_CHILD = C.TABLE_CATALOG_PARENT
  AND P.TABLE_SCHEMA_CHILD = C.TABLE_SCHEMA_PARENT
  AND P.TABLE_NAME_CHILD = C.TABLE_NAME_PARENT
 WHERE NOT EXISTS (
  SELECT *
  FROM @TransitiveClosure AS T
  WHERE T.TABLE_CATALOG_PARENT = P.TABLE_CATALOG_PARENT
    AND T.TABLE_SCHEMA_PARENT = P.TABLE_SCHEMA_PARENT
    AND T.TABLE_NAME_PARENT = P.TABLE_NAME_PARENT
    AND T.TABLE_CATALOG_CHILD = C.TABLE_CATALOG_CHILD
    AND T.TABLE_SCHEMA_CHILD = C.TABLE_SCHEMA_CHILD
    AND T.TABLE_NAME_CHILD = C.TABLE_NAME_CHILD
  )
END
-- Childs with level
SELECT
 T.TABLE_CATALOG_CHILD
, T.TABLE_SCHEMA_CHILD
, T.TABLE_NAME_CHILD
, COUNT(T.TABLE_NAME_PARENT) AS NodeLevel
FROM @TransitiveClosure AS T
GROUP BY
 T.TABLE_CATALOG_CHILD
, T.TABLE_SCHEMA_CHILD
, T.TABLE_NAME_CHILD
-- Roots with level 0
UNION
SELECT
 TP.TABLE_CATALOG_PARENT
, TP.TABLE_SCHEMA_PARENT
, TP.TABLE_NAME_PARENT
, 0 AS NodeLevel
FROM @TransitiveClosure AS TP
WHERE NOT EXISTS (
 SELECT *
 FROM @TransitiveClosure AS TC
 WHERE TP.TABLE_CATALOG_PARENT = TC.TABLE_CATALOG_CHILD
   AND TP.TABLE_SCHEMA_PARENT = TC.TABLE_SCHEMA_CHILD
   AND TP.TABLE_NAME_PARENT = TC.TABLE_NAME_CHILD
 )
-- This is just to get tables never referenced by other
-- tables, can be omitted if not needed
UNION
SELECT
 T.TABLE_CATALOG
, T.TABLE_SCHEMA
, T.TABLE_NAME
, -1 AS NodeLevel
FROM INFORMATION_SCHEMA.TABLES AS T
WHERE NOT EXISTS (
 SELECT *
 FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS AS RC
 JOIN INFORMATION_SCHEMA.CONSTRAINT_TABLE_USAGE AS T1
   ON T1.CONSTRAINT_CATALOG = RC.CONSTRAINT_CATALOG
  AND T1.CONSTRAINT_SCHEMA = RC.CONSTRAINT_SCHEMA
  AND T1.CONSTRAINT_NAME = RC.CONSTRAINT_NAME
 JOIN INFORMATION_SCHEMA.CONSTRAINT_TABLE_USAGE AS T2
   ON T2.CONSTRAINT_CATALOG = RC.UNIQUE_CONSTRAINT_CATALOG
  AND T2.CONSTRAINT_SCHEMA = RC.UNIQUE_CONSTRAINT_SCHEMA
  AND T2.CONSTRAINT_NAME = RC.UNIQUE_CONSTRAINT_NAME
 WHERE (
  T2.TABLE_CATALOG = T.TABLE_CATALOG
  AND T2.TABLE_SCHEMA = T.TABLE_SCHEMA
  AND T2.TABLE_NAME = T.TABLE_NAME
  )
  OR
  (
  T1.TABLE_CATALOG = T.TABLE_CATALOG
  AND T1.TABLE_SCHEMA = T.TABLE_SCHEMA
  AND T1.TABLE_NAME = T.TABLE_NAME
  )
 )
  AND T.TABLE_TYPE = 'BASE TABLE'
ORDER BY 4 DESC
--<CUT HERE>--

Ci sono un paio di errorini:
, COUNT(T.TABLE_NAME_PARENT) AS NodeLevel
 dovrebbe essere
, COUNT(*) AS NodeLevel
(anche se non cambia nulla)
Inoltre il nome della colonna NodeLevel non e'
proprio preciso... si tratta del numero di nodi
attraversati per giungere dalle radici a quella
foglia (e in questo caso il valore -1 assegnato
con l'ultima select sarebbe piu' congruente se
fosse messo a 0)


grazie gianluca lo testo e ti faccio sapere

--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 grazie gianluca lo testo e ti faccio sapere
Ciao Alberto,
Prendila con le pinze perche' c'e' qualcosa che
non mi convince fino in fondo, ma non ho potuto
ancora verificare bene...
Ciao,
