Am găsi că cele mai multe dintre clienții mei nu sunt de documentare bazele lor de date, la toate și mi se pare că destul de înfricoșător. Pentru a introduce unele mai bună practică, aș dori să știu ce instrumente/proces de oameni sunt folosind.
Eu nu vorbesc despre inginerie inversă / document de o bază de date existentă, dar mai ales pe documentația cele mai bune practici în timp ce dezvolta sistemul/baza de date.
Am fost folosind proprietățile extinse, deoarece acestea sunt foarte flexibile. Cele mai multe documentația standard instrumente pot fi conduse pe MS_Description
, și apoi puteți folosi propria dvs. cu personalizat-a construit instrumente.
Vezi aceasta prezentare: #41-Obține o Pârghie și Alege Orice broasca Testoasa: Ridicare cu Metadate
Și acest cod: http://code.google.com/p/caderoux/wiki/LeversAndTurtles
Microsoft's Visio Pro (până la Visio 2010) pot inversa unei baze de date după cum se poate CA's ERwin. Visio este o opțiune mai ieftină, dar ERwin este mai detaliată, cât mai completă opțiune. Proprietăți extinse sunt frumos, dacă oamenii te obosi să se uite la ei. De asemenea, ai putea folosi ceva de genul Red Gate's SQL Doc pentru ieșire documentație în format HTML.
Am găsit convențiile de denumire și stabilirea în mod corespunzător până chei externe duce la o aproape auto-documentarea bazei de date. Totusi ar fi trebuit externe docs pentru o mai bună înțelegere a scopului.
Pentru SQL Server am'm folosind proprietățile extinse.
Cu următoarele PowerShell Script pot genera o Tabelul Crea script-uri pentru un singur tabel sau pentru toate tabelele în dbo.
Scenariul conține o create table
comanda, chei primare și indici. Chei externe sunt adăugate sub formă de comentarii.
Extins proprietăți de tabele și coloane de tabel sunt adăugate sub formă de comentarii. Da multi linia de proprietăți sunt acceptate.
Script-ul este reglat de a mea personală, stil de codificare.
nici un individ nu colaționări pentru un singur coloane.
în prezent, este nevoie de Sql Server De autentificare.
Aici este codul complet pentru a transforma proprietățile extinse într-un simplu bun vechi document ASCII (BTW este valabil sql pentru a recrea tabele):
function Get-ScriptForTable
{
param (
$server,
$dbname,
$user,
$password,
$filter
)
[System.reflection.assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo") | out-null
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.ConnectionInfo") | out-null
$conn = new-object "Microsoft.SqlServer.Management.Common.ServerConnection"
$conn.ServerInstance = $server
$conn.LoginSecure = $false
$conn.Login = $user
$conn.Password = $password
$conn.ConnectAsUser = $false
$srv = New-Object "Microsoft.SqlServer.Management.Smo.Server" $conn
$Scripter = new-object ("Microsoft.SqlServer.Management.Smo.Scripter")
#$Scripter.Options.DriAll = $false
$Scripter.Options.NoCollation = $True
$Scripter.Options.NoFileGroup = $true
$scripter.Options.DriAll = $True
$Scripter.Options.IncludeIfNotExists = $False
$Scripter.Options.ExtendedProperties = $false
$Scripter.Server = $srv
$database = $srv.databases[$dbname]
$obj = $database.tables
$cnt = 1
$obj | % {
if (! $filter -or $_.Name -match $filter)
{
$lines = @()
$header = "---------- {0, 3} {1, -30} ----------" -f $cnt, $_.Name
Write-Host $header
"/* ----------------- {0, 3} {1, -30} -----------------" -f $cnt, $_.Name
foreach( $i in $_.ExtendedProperties)
{
"{0}: {1}" -f $i.Name, $i.value
}
""
$colinfo = @{}
foreach( $i in $_.columns)
{
$info = ""
foreach ($ep in $i.ExtendedProperties)
{
if ($ep.value -match "`n")
{
"----- Column: {0} {1} -----" -f $i.name, $ep.name
$ep.value
}
else
{
$info += "{0}:{1} " -f $ep.name, $ep.value
}
}
if ($info)
{
$colinfo[$i.name] = $info
}
}
""
"SELECT COUNT(*) FROM {0}" -f $_.Name
"SELECT * FROM {0} ORDER BY 1" -f $_.Name
"--------------------- {0, 3} {1, -30} ----------------- */" -f $cnt, $_.Name
""
$raw = $Scripter.Script($_)
#Write-host $raw
$cont = 0
$skip = $false
foreach ($line in $raw -split "\r\n")
{
if ($cont -gt 0)
{
if ($line -match "^\)WITH ")
{
$line = ")"
}
$linebuf += ' ' + $line -replace " ASC", ""
$cont--
if ($cont -gt 0) { continue }
}
elseif ($line -match "^ CONSTRAINT ")
{
$cont = 3
$linebuf = $line
continue
}
elseif ($line -match "^UNIQUE ")
{
$cont = 3
$linebuf = $line
$skip = $true
continue
}
elseif ($line -match "^ALTER TABLE.*WITH CHECK ")
{
$cont = 1
$linebuf = "-- " + $line
continue
}
elseif ($line -match "^ALTER TABLE.* CHECK ")
{
continue
}
else
{
$linebuf = $line
}
if ($linebuf -notmatch "^SET ")
{
if ($linebuf -match "^\)WITH ")
{
$lines += ")"
}
elseif ($skip)
{
$skip = $false
}
elseif ($linebuf -notmatch "^\s*$")
{
$linebuf = $linebuf -replace "\]|\[", ""
$comment = $colinfo[($linebuf.Trim() -split " ")[0]]
if ($comment) { $comment = ' -- ' + $comment }
$lines += $linebuf + $comment
}
}
}
$lines += "go"
$lines += ""
$block = $lines -join "`r`n"
$block
$cnt++
$used = $false
foreach( $i in $_.Indexes)
{
$out = ''
$raw = $Scripter.Script($i)
#Write-host $raw
foreach ($line in $raw -split "\r\n")
{
if ($line -match "^\)WITH ")
{
$out += ")"
}
elseif ($line -match "^ALTER TABLE.* PRIMARY KEY")
{
break
}
elseif ($line -match "^ALTER TABLE.* ADD UNIQUE")
{
$out += $line -replace "\]|\[", "" -replace " NONCLUSTERED", ""
}
elseif ($line -notmatch "^\s*$")
{
$out += $line -replace "\]|\[", "" -replace "^\s*", "" `
-replace " ASC,", ", " -replace " ASC$", "" `
<#-replace "\bdbo\.\b", "" #> `
-replace " NONCLUSTERED", ""
}
$used = $true
}
$block = "$out;`r`ngo`r`n"
$out
}
if ($used)
{
"go"
}
}
}
}
Puteți fie script thecomplete dbo de o bază de date
Get-ScriptForTable 'localhost' 'MyDB' 'sa' 'toipsecret' | Out-File "C:\temp\Create_commented_tables.sql"
Sau filtru pentru un singur tabel
Get-ScriptForTable 'localhost' 'MyDB' 'sa' 'toipsecret' 'OnlyThisTable'
Uită-te la SchemaCrawler - este gratuit, instrumentul de linie de comandă care l-am conceput pentru a face ceea ce sunteți în căutarea pentru. SchemaCrawler produce un fișier text cu toate de schema bazei de date de obiecte. Acest text de ieșire este proiectat pentru a fi atât de lecturat, precum și diff-măsură împotriva similare de ieșire de pe un alt server.
În practică, ceea ce am descoperit este că scoate un fișier text de schema bazei de date este util, atunci când ați terminat, ca parte a construi. În acest fel, puteți verifica fișier text în codul sursă sistem de control, și au o istorie versiune de cum schemă a evoluat de-a lungul timpului. SchemaCrawler este proiectat pentru a automatiza acest lucru de asemenea, de la linia de comandă.
Dacă este scris vreodată, documentația constă dintr-un document word. Un cuplu de relație diagrame vor fi incluse. Listele de tabele și o scurtă descriere a ceea ce fiecare masa deține și cum se referă la alte mese. Un capitol din documentația include setări de securitate: ce permisiuni are "de utilizare" că cererea trebuie?
În general, în societățile am'am lucrat pentru, baze de date de documentare devine doar scris atunci când clientul este cel care efectuează audituri, care tinde să limiteze utilizarea acestuia financiare și clienți guvernamentali.
Disclaimer: prea mulți dezvoltatori să ia atitudinea pe care codul este documentația, și m-am'am fost vinovați de asta.
Amuzant, mă întrebam cum alți oameni fac acest lucru la fel de bine..
În timp ce în curs de dezvoltare prima mea mare baza de date a proiectului, am descoperit că Microsoft SQL Server Management Studio 10.0.1600.22 sprijină diagrame de baze de date pe care le puteți exporta la un document word sau alte documentația software-ul în cazul în care puteți adăuga la fel de mult documentației de detaliu, după cum doriți. Doar extinde baza de date conectat la SQL Management Studio și dați clic dreapta pe "baza de date diagrame" în obiect explorer și selectați "New Database Diagram" pentru a genera un interactiv diagramă care vă va arăta toate relațiile între tabele diferite. Puteți specifica chiar tabele care doriți să le includeți în diagrame, astfel încât imaginea nu se unweildly dacă sunt doar încercarea de a documenta bucată cu bucată. Exporta imaginea la orice alt software de editare și comentariu la fel de mult, după cum doriți.
Am recomanda, de asemenea, o multime de /comentariu/ în script care generează baza de date.
În general, este o mulțime de muncă scriind ceea ce este pentru toate, dar o idee buna pe termen lung, cum ar fi atunci când tu sau un alt biet suflet vine înapoi pentru a actualiza crearea un cuplu de ani mai târziu! :)
Am setat MS_description extins de proprietate pentru toate obiectele și apoi documentul întreaga bază de date folosind ApexSQL Doc. Am folosit pentru a crea documente HTML de mai devreme, dar in ultima vreme prefer PDF
Eu folosesc date instrumente de modelare pentru că-mi permite să documenteze informații importante despre altă bază de date decât ce "dedicat" într-o bază de date. Meta date, cum ar fi de confidențialitate/de securitate/de sensibilitate se referă, de administrare, guvernare, etc.
Care pot trece dincolo de ceea ce unii au nevoie în documentarea unei baze de date, dar aceste lucruri sunt importante pentru afaceri și de a ajuta ei de a gestiona datele lor.
Formale de instrumente, de asemenea, să mă ajute în gestionarea de date care este stocat în mai multe baze de date/exemplu/server. Acest lucru nu a fost niciodată mai adevărat decât în aplicație ambalate lume.
este o bază de date open source instrument de documentare cu decent GUI și opțiuni de export / import. Acesta utilizează proprietățile Extinse pentru a stoca documente. L'll generează, de asemenea, descrieri automate pentru coloane și cheia primară cheie externă coloane.
Pentru Documentarea sql server, am foarte recomanda doar recent lansat :
SQL Server & Documentația Windows Utilizând Windows PowerShell scris de Kendal Van Dyke
Scurtă descriere de la link-ul :
SQL Putere Doc este o colecție de Windows PowerShell script-uri și module care descoperi, document, și diagnostica instanțe de SQL Server și lor de fond al sistemului de OPERARE Windows & configurații de mașini. SQL Putere Doc funcționează cu toate versiunile de SQL Server SQL Server 2000 până în 2012, și toate versiunile de Windows Server și de consum Sistemele de Operare Windows de la Windows 2000 și Windows XP prin Windows Server 2012 și Windows 8. SQL Putere Doc este, de asemenea, capabil de documentare Windows Azure SQL Baze de date.
Într-adevăr, Proprietăți Extinse (MS_Description) este calea de a merge. Având aceste descrieri disponibile ca o parte din metadatele ar putea fi utilizate nu numai de documente generatoare, dar, de asemenea, (să sperăm că într-o zi) de instrumente care să ofere "intellisense", de exemplu, oferă Softtree's SQL Assistant http://www.softtreetech.com/isql.htm (ultima dată când am verificat-au n't) sau construit în SQL Sever Management Studio's Intellisense (din sql2008)
De asemenea, cred că ar trebui să fie ușor pentru dezvoltatori și DBA's a adăuga aceste note, pentru ca Tangurena și Nick Chammas subliniat în mod corect - devs sunt foarte reticente în a păstra documente actualizate și ură duplicat de muncă, care este destul de corect, mai ales pentru o persoană care a învățat pentru a optimiza lucruri în timpul întregii lor vieți profesionale. Deci, dacă nu's foarte ușor de a actualiza documente într-un singur loc aproape de cod sursă - e't va funcționa. La un moment dat am căutat pe internet și am't găsi o soluție pentru acest lucru așa că am scris LiveDoco (nu gratuit, scuze), în încercarea de a face mai ușor. Mai multe informatii aici daca sunteti interesati: http://www.livedoco.com/why-livedoco
Ai putea, de asemenea, să ia o privire la wsSqlSrvDoc. L's un mic instrument care funcționează cu SQL Server extended proprietăți și creează un document MS Word.
Print-out de toate column properties (cu cheie străină relații) funcționează afară de la cutie. Pentru mai multe descrieri pe fiecare domeniu trebuie să configurați proprietățile extinse de cei coloanelor în SQL Server Management Studio.
L's nu gratuit, dar destul de accesibil. Dacă aveți nevoie doar pentru a crea o documentație pentru un "nu funcționează în curs" DB care's mai mult sau mai puțin finit decât ar fi suficient pentru a utiliza de încercare gratuită.
Vom folosi Dataedo pentru a crea dicționar de date, documente, proceduri stocate și funcții. Am inserați codul ERDs creat în Visio. Toate documentele sunt stocate în Dataedo repository-ul de metadate (text formatat) și pentru export în HTML pentru uz intern sau export în format PDF pentru documente tipărite.
Am atribui fiecare obiect la un modul și atribui fiecare modul pentru o persoană. Dataedo vine cu documentația stare de raportare astfel încât să putem spune dacă există o nouă coloană sau tabel care trebuie să fie documentate.
Puteți folosi regulat --
-prefixate comentarii în .sql
de fișier.
Printre avantaje se numără faptul că documentația este cu codul pentru schema bazei de date și puteți cu ușurință să-l angajeze la un sistem de control al versiunii, cum ar fi Git.
Exemplu:
-- Table to store details about people.
-- See also: The customer table.
-- Note: Keep this data safe!
-- Todo: Add a email column.
CREATE TABLE Persons ( -- People in the registry
PersonID int,
LastName varchar(255), -- The person's last name
FirstName varchar(255), -- The person's first name
Address varchar(255), -- Address of residence
City varchar(255) -- City of residence
);
Poate ai putea folosi XML prea.
-- <summary>
-- Table to store details about people.
-- </summary>
-- <column name="PersonID">The id column.</column>
-- <column name="LastName">The person's last name.</column>
-- <column name="FirstName">The person's first name.</column>
-- <column name="Address">Address of residence.</column>
-- <column name="City">City of residence.</column>
CREATE TABLE Persons (
PersonID int,
LastName varchar(255),
FirstName varchar(255),
Address varchar(255),
City varchar(255)
);
Ai putea folosi, de asemenea, unele sintaxa cu asemănare de jsDoc/phpDoc.
-- Table to store details about people.
-- @column {int} PersonID - The id column.
-- @column {varchar} LastName - The person's last name.
-- @column {varchar} FirstName - The person's first name.
-- @column {varchar} Address - Address of residence.
-- @column {varchar} City - City of residence.
-- @see {@link https://example.com/|Example}
-- @author Jane Smith <[email protected]>
-- @copyright Acme 2018
-- @license BSD-2-Clause
-- @todo Add a column for email address.
-- @since 1.0.1
-- @version 1.2.3
CREATE TABLE Persons (
PersonID int,
LastName varchar(255),
FirstName varchar(255),
Address varchar(255),
City varchar(255)
);
Sau ai putea folosi sintaxa MarkDown.
-- # Persons
-- Table to store details about **people**.
-- * `PersonID` - The id column.
-- * `LastName` - The person's _last_ name.
-- * `FirstName` - The person's _first_ name.
-- * `Address` - Address of residence.
-- * `City` - City of residence.
--
-- [I'm an inline-style link](https://www.example.com/)
--
-- | PersonID | LastName | FirstName | Address | City |
-- | ---------| -------- | --------- | ------- | ---- |
-- | 1 | Smith | Jane | N/A | N/A |
CREATE TABLE Persons (
PersonID int,
LastName varchar(255),
FirstName varchar(255),
Address varchar(255),
City varchar(255)
);
Diagrame ERD (baze de Date, Diagrame) au fost întotdeauna cele mai utile pentru echipa mea
Dar există regula de a scrie "Descrierea" în Proprietăți de fiecare masă și coloană care ne-am crea.
Apoi vom folosi un software numesc Enterprise Arhitect pentru a documenta Tabele
cu de toate Indicii
, Chei Străine " Și "Coloane" cu " Tip
și Descriere.
Pentru MySQL în special, vom folosi întotdeauna MySQL Workbench. Vom crea baza noastră de date modele în designer, apoi de export-l ca un runnable script SQL. Aplicarea tuturor modificărilor în proiectare și apoi rularea script-ul generat asigură proiectarea și bazei de date reale sunt perfect în sincronizare cu fiecare alte, și că documentația nu va deveni depășite cu ușurință.