x

x

refle

database/cs/reflection.texy

@@ -1,8 +1,8 @@
 Reflexe struktury
 *****************
 
-.{data-version:3.2.4}
-Nette Database poskytuje nástroje pro introspekci databázové struktury pomocí třídy [api:Nette\Database\Reflection\Reflection]. Ta umožňuje získávat informace o tabulkách, sloupcích, indexech a cizích klíčích. Reflexi můžete využít ke generování schémat, vytváření flexibilních aplikací pracujících s databází nebo obecných databázových nástrojů.
+.{data-version:3.2.1}
+Nette Database poskytuje nástroje pro introspekci databázové struktury pomocí třídy [api:Nette\Database\Reflection]. Ta umožňuje získávat informace o tabulkách, sloupcích, indexech a cizích klíčích. Reflexi můžete využít ke generování schémat, vytváření flexibilních aplikací pracujících s databází nebo obecných databázových nástrojů.
 
 Objekt reflexe získáme z instance připojení k databázi:
 
@@ -11,163 +11,115 @@ $reflection = $database->getReflection();
 ```
 
 
-Práce s tabulkami
-=================
+Získání tabulek
+---------------
 
-Pomocí reflexe můžeme procházet všechny tabulky v databázi:
-
-
-getTables(): Nette\Database\Reflection\Table[] .[method]
---------------------------------------------------------
-Vrací asocitivní pole, kde klíčem je název tabulky a hodnotou pole s metadaty tabulky.
+Readonly vlastnost `$reflection->tables` obsahuje asociativní pole všech tabulek v databázi:
 
 ```php
 // Výpis názvů všech tabulek
-foreach ($reflection->getTables() as $table) {
-	echo $table['name'] . "\n";
+foreach ($reflection->tables as $name => $table) {
+	echo $name . "\n";
 }
 ```
 
-
-hasTable(string $name): bool .[method]
---------------------------------------
-Vrací `true`, pokud tabulka existuje, jinak `false`.
+K dispozici jsou ještě dvě metody:
 
 ```php
 // Ověření existence tabulky
 if ($reflection->hasTable('users')) {
 	echo "Tabulka users existuje";
 }
-```
-
-
-getTable(string $name): Nette\Database\Reflection\Table .[method]
------------------------------------------------------------------
-Vrací objekt `Nette\Database\Reflection\Table` reprezentující danou tabulku. Pokud tabulka neexistuje, vyhodí výjimku `Nette\Database\Exception\MissingTableException`.
 
-```php
-// Získání konkrétní tabulky
+// Vrátí objekt tabulky; pokud neexistuje, vyhodí výjimku
 $table = $reflection->getTable('users');
 ```
 
 
-Informace o sloupcích
-=====================
-
-Objekt [api:Nette\Database\Reflection\Table], který získáme voláním `getTable()`, nám umožňuje získat detailní informace o sloupcích tabulky.
+Informace o tabulce
+-------------------
 
+Tabulka je reprezentována objektem [Table|api:Nette\Database\Reflection\Table], který poskytuje následující readonly vlastnosti:
 
-getColumns(): Nette\Database\Reflection\Column[] .[method]
-----------------------------------------------------------
-Vrací pole objektů `Nette\Database\Reflection\Column` reprezentujících sloupce tabulky.
+- `$name: string` – název tabulky
+- `$view: bool` – zda se jedná o pohled
+- `$fullName: ?string` – plný název tabulky včetně schématu (pokud existuje)
+- `$columns: array<string, Column>` – asociativní pole sloupců tabulky
+- `$indexes: Index[]` – pole indexů tabulky
+- `$primaryKey: ?Index` – primární klíč tabulky nebo null
+- `$foreignKeys: ForeignKey[]` – pole cizích klíčů tabulky
 
 
-getColumn(string $name): Nette\Database\Reflection\Column .[method]
--------------------------------------------------------------------
-Vrací objekt [api:Nette\Database\Reflection\Column] reprezentující daný sloupec. Pokud sloupec neexistuje, vyhodí výjimku `Nette\Database\Exception\MissingColumnException`.
+Sloupce
+-------
 
-Objekt `Column` poskytuje tyto vlastnosti:
+Vlastnost `columns` tabulky poskytuje asociativní pole sloupců, kde klíčem je název sloupce a hodnotou instance [Column|api:Nette\Database\Reflection\Column] s těmito vlastnostmi:
 
--   `name`: Název sloupce.
--   `nativeType`: Datový typ sloupce specifický pro danou databázi.
--   `type`: Normalizovaný datový typ sloupce (viz konstanty `Nette\Utils\Type`).
--   `nullable`: `true`, pokud sloupec může obsahovat hodnotu `NULL`, jinak `false`.
--   `primary`: `true`, pokud je sloupec součástí primárního klíče, jinak `false`.
--   `autoIncrement`: `true`, pokud je sloupec auto-increment, jinak `false`.
--   `default`: Výchozí hodnota sloupce, nebo `null`, pokud není definována.
--   `vendor`: Pole s dalšími informacemi specifickými pro danou databázi.
+- `$name: string` – název sloupce
+- `$table: ?Table` – reference na tabulku sloupce
+- `$nativeType: string` – nativní databázový typ
+- `$size: ?int` – velikost/délka typu
+- `$nullable: bool` – zda může sloupec obsahovat NULL
+- `$default: mixed` – výchozí hodnota sloupce
+- `$autoIncrement: bool` – zda je sloupec auto-increment
+- `$primary: bool` – zda je součástí primárního klíče
+- `$vendor: array` – dodatečná metadata specifická pro daný databázový systém
 
 ```php
-// Procházení všech sloupců tabulky users
-$table = $reflection->getTable('users');
-foreach ($table->getColumns() as $column) {
-	echo "Sloupec: " . $column->name . "\n";
-	echo "Typ: " . $column->nativeType . "\n";
-	echo "Může být NULL: " . ($column->nullable ? 'Ano' : 'Ne') . "\n";
-	echo "Výchozí hodnota: " . ($column->default ?? 'Není') . "\n";
-	echo "Je primární klíč: " . ($column->primary ? 'Ano' : 'Ne') . "\n";
-	echo "Je auto-increment: " . ($column->autoIncrement ? 'Ano' : 'Ne') . "\n";
+foreach ($table->columns as $name => $column) {
+	echo "Sloupec: $name\n";
+	echo "Typ: {$column->nativeType}\n";
+	echo "Nullable: " . ($column->nullable ? 'Ano' : 'Ne') . "\n";
 }
-
-// Získání konkrétního sloupce
-$idColumn = $table->getColumn('id');
 ```
 
 
-Indexy a primární klíče
-=======================
-
-
-getIndexes(): Nette\Database\Reflection\Index[] .[method]
----------------------------------------------------------
-Vrací pole objektů `Nette\Database\Reflection\Index` reprezentujících indexy tabulky.
+Indexy
+------
 
+Vlastnost `indexes` tabulky poskytuje pole indexů, kde každý index je instance [Index|api:Nette\Database\Reflection\Index] s těmito vlastnostmi:
 
-getIndex(string $name): Nette\Database\Reflection\Index .[method]
------------------------------------------------------------------
-Vrací objekt [api:Nette\Database\Reflection\Index] reprezentující daný index. Pokud index neexistuje, vyhodí výjimku `Nette\Database\Exception\MissingIndexException`.
+- `$columns: Column[]` – pole sloupců tvořících index
+- `$unique: bool` – zda je index unikátní
+- `$primary: bool` – zda jde o primární klíč
+- `$name: ?string` – název indexu
 
-
-getPrimaryKey(): ?Nette\Database\Reflection\Index .[method]
------------------------------------------------------------
-Vrací objekt `Nette\Database\Reflection\Index` reprezentující primární klíč tabulky, nebo `null`, pokud tabulka nemá primární klíč.
-
-Objekt `Index` poskytuje tyto vlastnosti:
-
--   `name`: Název indexu.
--   `columns`: Pole objektů `Nette\Database\Reflection\Column` reprezentujících sloupce, které jsou součástí indexu.
--   `unique`: `true`, pokud je index unikátní, jinak `false`.
--   `primary`: `true`, pokud je index primárním klíčem, jinak `false`.
+Primární klíč tabulky lze získat pomocí vlastnosti `primaryKey`, která vrací buď objekt `Index`, nebo `null` v případě, že tabulka nemá primární klíč.
 
 ```php
-$table = $reflection->getTable('users');
-
-$vypisNazvySloupcu = fn(array $columns) => implode(', ', array_map(fn($col) => $col->name, $columns));
-
-// Výpis všech indexů
-foreach ($table->getIndexes() as $index) {
-	echo "Index: " . ($index->name ?? 'Nepojmenovaný') . "\n";
-	echo "Sloupce: " . $vypisNazvySloupcu($index->columns) . "\n";
-	echo "Je unikátní: " . ($index->unique ? 'Ano' : 'Ne') . "\n";
-	echo "Je primární klíč: " . ($index->primary ? 'Ano' : 'Ne') . "\n";
+// Výpis indexů
+foreach ($table->indexes as $index) {
+	$columns = implode(', ', array_map(fn($col) => $col->name, $index->columns));
+	echo "Index" . ($index->name ? " {$index->name}" : '') . ":\n";
+	echo "  Sloupce: $columns\n";
+	echo "  Unique: " . ($index->unique ? 'Ano' : 'Ne') . "\n";
 }
 
-// Získání primárního klíče
-if ($primaryKey = $table->getPrimaryKey()) {
-	echo "Primární klíč: " . $vypisNazvySloupcu($primaryKey->columns) . "\n";
+// Výpis primárního klíče
+if ($primaryKey = $table->primaryKey) {
+	$columns = implode(', ', array_map(fn($col) => $col->name, $primaryKey->columns));
+	echo "Primární klíč: $columns\n";
 }
 ```
 
 
 Cizí klíče
-==========
+----------
 
+Vlastnost `foreignKeys` tabulky poskytuje pole cizích klíčů, kde každý cizí klíč je instance [ForeignKey|api:Nette\Database\Reflection\ForeignKey] s těmito vlastnostmi:
 
-getForeignKeys(): Nette\Database\Reflection\ForeignKey[] .[method]
-------------------------------------------------------------------
-Vrací pole objektů `Nette\Database\Reflection\ForeignKey` reprezentujících cizí klíče tabulky.
-
-
-getForeignKey(string $name): Nette\Database\Reflection\ForeignKey .[method]
----------------------------------------------------------------------------
-Vrací objekt [api:Nette\Database\Reflection\ForeignKey] reprezentující daný cizí klíč. Pokud cizí klíč neexistuje, vyhodí výjimku `Nette\Database\Exception\MissingForeignKeyException`.
-
-Objekt `ForeignKey` poskytuje tyto vlastnosti:
-
--   `name`: Název cizího klíče.
--   `localColumns`: Pole objektů `Nette\Database\Reflection\Column` reprezentujících lokální sloupce, které tvoří cizí klíč.
--   `foreignTable`: Objekt `Nette\Database\Reflection\Table` reprezentující cizí tabulku, na kterou cizí klíč odkazuje.
--   `foreignColumns`: Pole objektů `Nette\Database\Reflection\Column` reprezentujících cizí sloupce, na které cizí klíč odkazuje.
+- `$foreignTable: Table` – odkazovaná tabulka
+- `$localColumns: Column[]` – pole lokálních sloupců
+- `$foreignColumns: Column[]` – pole odkazovaných sloupců
+- `$name: ?string` – název cizího klíče
 
 ```php
-$table = $reflection->getTable('books');
-
-$vypisNazvySloupcu = fn(array $columns) => implode(', ', array_map(fn($col) => $col->name, $columns));
+// Výpis cizích klíčů
+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));
 
-foreach ($table->getForeignKeys() as $fk) {
-	echo "Cizí klíč: " . ($fk->name ?? 'Nepojmenovaný') . "\n";
-	echo "Lokální sloupce: " . $vypisNazvySloupcu($fk->localColumns) . "\n";
-	echo "Odkazuje na tabulku: {$fk->foreignTable->name}\n";
-	echo "Odkazuje na sloupce: " . $vypisNazvySloupcu($fk->foreignColumns) . "\n";
+	echo "FK" . ($fk->name ? " {$fk->name}" : '') . ":\n";
+	echo "  $localCols -> {$fk->foreignTable->name}($foreignCols)\n";
 }
 ```