Reflection della struttura
Nette Database mette a disposizione strumenti per ispezionare la struttura del database con la classe Nette\Database\Reflection. Permette di ottenere informazioni su tabelle, colonne, indici e chiavi esterne. La reflection si può sfruttare per generare schemi, creare applicazioni flessibili che lavorano con il database oppure strumenti generici per i database.
L'oggetto reflection si ottiene dall'istanza della connessione al database:
$reflection = $database->getReflection();
Ottenere le tabelle
La proprietà readonly $reflection->tables contiene un array associativo di tutte le tabelle del database:
// elenco dei nomi di tutte le tabelle
foreach ($reflection->tables as $name => $table) {
echo $name . "\n";
}
Sono disponibili altri due metodi:
// verifica dell'esistenza di una tabella
if ($reflection->hasTable('users')) {
echo "La tabella users esiste";
}
// restituisce l'oggetto della tabella; se non esiste lancia un'eccezione
$table = $reflection->getTable('users');
Informazioni sulla tabella
La tabella è rappresentata dall'oggetto Table, che offre queste proprietà readonly:
$name: string– nome della tabella$view: bool– se si tratta di una vista$fullName: ?string– nome completo della tabella compreso lo schema (se esiste)$columns: array<string, Column>– array associativo delle colonne della tabella$indexes: Index[]– array degli indici della tabella$primaryKey: ?Index– chiave primaria della tabella oppure null$foreignKeys: ForeignKey[]– array delle chiavi esterne della tabella$comment: ?string– commento della tabella
Colonne
La proprietà columns della tabella offre un array associativo di colonne, dove la chiave è il nome della colonna
e il valore è un'istanza di Column con
queste proprietà:
$name: string– nome della colonna$table: ?Table– riferimento alla tabella della colonna$nativeType: string– tipo nativo del database$size: ?int– dimensione/lunghezza del tipo$nullable: bool– se la colonna può contenere NULL$default: mixed– valore predefinito della colonna$autoIncrement: bool– se la colonna è auto-increment$primary: bool– se fa parte della chiave primaria$vendor: array– metadati aggiuntivi specifici del sistema di database$comment: ?string– commento della colonna
foreach ($table->columns as $name => $column) {
echo "Colonna: $name\n";
echo "Tipo: {$column->nativeType}\n";
echo "Nullable: " . ($column->nullable ? 'Sì' : 'No') . "\n";
}
Indici
La proprietà indexes della tabella offre un array di indici, dove ogni indice è un'istanza di Index con queste proprietà:
$columns: Column[]– array delle colonne che compongono l'indice$unique: bool– se l'indice è univoco$primary: bool– se si tratta della chiave primaria$name: ?string– nome dell'indice
La chiave primaria della tabella si ottiene con la proprietà primaryKey, che restituisce un oggetto
Index oppure null se la tabella non ha una chiave primaria.
// elenco degli indici
foreach ($table->indexes as $index) {
$columns = implode(', ', array_map(fn($col) => $col->name, $index->columns));
echo "Indice" . ($index->name ? " {$index->name}" : '') . ":\n";
echo " Colonne: $columns\n";
echo " Univoco: " . ($index->unique ? 'Sì' : 'No') . "\n";
}
// elenco della chiave primaria
if ($primaryKey = $table->primaryKey) {
$columns = implode(', ', array_map(fn($col) => $col->name, $primaryKey->columns));
echo "Chiave primaria: $columns\n";
}
Chiavi esterne
La proprietà foreignKeys della tabella offre un array di chiavi esterne, dove ogni chiave esterna è un'istanza
di ForeignKey con queste
proprietà:
$foreignTable: Table– la tabella referenziata$localColumns: Column[]– array delle colonne locali$foreignColumns: Column[]– array delle colonne referenziate$name: string– nome della chiave esterna
// elenco delle chiavi esterne
foreach ($table->foreignKeys as $fk) {
$localCols = implode(', ', array_map(fn($col) => $col->name, $fk->localColumns));
$foreignCols = implode(', ', array_map(fn($col) => $col->name, $fk->foreignColumns));
echo "FK" . ($fk->name ? " {$fk->name}" : '') . ":\n";
echo " $localCols -> {$fk->foreignTable->name}($foreignCols)\n";
}