README

Wydajna biblioteka PHP do zarządzania operacjami bazodanowymi. Wspiera MySQL i SQLite, oferując wysoką wydajność oraz czytelny interfejs.

Wymagania

PHP 8.1 lub nowszy
Rozszerzenie PDO
MySQL lub SQLite

Instalacja

composer require krzysztofzylka/database-manager

Podstawowe użycie

Nawiązywanie połączenia

$databaseManager = new \krzysztofzylka\DatabaseManager\DatabaseManager();

try {
    $connect = \krzysztofzylka\DatabaseManager\DatabaseConnect::create()
        ->setType(\krzysztofzylka\DatabaseManager\Enum\DatabaseType::mysql)
        ->setDatabaseName('database')
        ->setUsername('username')
        ->setPassword('password');

    $databaseManager->connect($connect);
} catch (\krzysztofzylka\DatabaseManager\Exception\DatabaseManagerException $exception) {
    die($exception->getHiddenMessage());
}

Operacje CRUD

Pobieranie danych

// Pobranie jednego rekordu
$table = new \krzysztofzylka\DatabaseManager\Table('users');
$user = $table->find(['id' => 1]);

// Pobranie wszystkich rekordów
$users = $table->findAll();

// Liczenie rekordów
$count = $table->findCount(['status' => 'active']);

// Sprawdzenie istnienia
$exists = $table->findIsset(['email' => 'example@domain.com']);

Dodawanie rekordów

$table = new \krzysztofzylka\DatabaseManager\Table('users');
$table->insert([
    'username' => 'john_doe',
    'email' => 'john@example.com',
    'created_at' => date('Y-m-d H:i:s')
]);

// Pobranie ID nowo utworzonego rekordu
$newId = $table->getId();

Aktualizacja rekordów

$table = new \krzysztofzylka\DatabaseManager\Table('users');
$table->setId(1)->update([
    'username' => 'updated_username',
    'last_login' => date('Y-m-d H:i:s')
]);

// Aktualizacja pojedynczej kolumny
$table->setId(1)->updateValue('status', 'inactive');

Usuwanie rekordów

$table = new \krzysztofzylka\DatabaseManager\Table('users');
$table->delete(1); // Usunięcie po ID

// Usuwanie według warunków
$table->deleteByConditions(['status' => 'deleted']);

Zaawansowane zapytania

Złożone warunki wyszukiwania

// Proste warunki z operatorami
$conditions = [
    new \krzysztofzylka\DatabaseManager\Condition('age', '>', 18),
    new \krzysztofzylka\DatabaseManager\Condition('status', 'IN', ['active', 'pending']),
    'is_verified' => true
];

$results = $table->findAll($conditions);

Złączenia tabel

$table = new \krzysztofzylka\DatabaseManager\Table('users');

// Podstawowe złączenie
$table->bind(
    \krzysztofzylka\DatabaseManager\Enum\BindType::leftJoin,
    'orders',
    'users.id',
    'orders.user_id'
);

// Złączenie z aliasem tabeli
$table->bind(
    \krzysztofzylka\DatabaseManager\Enum\BindType::leftJoin,
    'orders',
    'users.id',
    'orders.user_id',
    null,
    'o'  // Alias tabeli
);

// Złączenie z warunkiem
$table->bind(
    \krzysztofzylka\DatabaseManager\Enum\BindType::leftJoin,
    'orders',
    'users.id',
    'orders.user_id',
    ['status' => 'completed']  // Warunek w JOIN
);

// Złączenie z aliasem i warunkiem
$table->bind(
    \krzysztofzylka\DatabaseManager\Enum\BindType::leftJoin,
    'orders',
    'users.id',
    'orders.user_id',
    ['status' => 'completed'],
    'completed_orders'
);

$userWithOrders = $table->findAll();

Typy złączeń

// INNER JOIN - tylko pasujące rekordy
$table->bind(BindType::innerJoin, 'orders', 'users.id', 'orders.user_id');

// LEFT JOIN - wszystkie użytkowniki, nawet bez zamówień
$table->bind(BindType::leftJoin, 'orders', 'users.id', 'orders.user_id');

// RIGHT JOIN - wszystkie zamówienia, nawet bez użytkowników
$table->bind(BindType::rightJoin, 'orders', 'users.id', 'orders.user_id');

// CROSS JOIN - iloczyn kartezjański
$table->bind(BindType::crossJoin, 'categories', null, null);

// FULL OUTER JOIN - wszystkie rekordy z obu tabel
$table->bind(BindType::fullJoin, 'orders', 'users.id', 'orders.user_id');

Relacje

// Relacja hasOne - jeden do jednego
$table->bind(BindType::hasOne, 'profiles', 'users.id', 'profiles.user_id');

// Relacja hasMany - jeden do wielu
$table->bind(BindType::hasMany, 'orders', 'users.id', 'orders.user_id');

Złożone złączenia

// Wielokrotne złączenia
$table->bind(BindType::leftJoin, 'orders', 'users.id', 'orders.user_id', null, 'o');
$table->bind(BindType::leftJoin, 'order_items', 'o.id', 'order_items.order_id', null, 'oi');
$table->bind(BindType::leftJoin, 'products', 'oi.product_id', 'products.id', null, 'p');

// Złączenie z warunkami AND/OR
$table->bind(
    BindType::leftJoin,
    'orders',
    'users.id',
    'orders.user_id',
    [
        'status' => 'completed',
        'OR' => [
            'total' => ['>', 100],
            'priority' => 'high'
        ]
    ],
    'completed_orders'
);

Transakcje

$transaction = new \krzysztofzylka\DatabaseManager\Transaction();

try {
    $transaction->begin();

    // Operacje bazodanowe
    $table->insert(['name' => 'Product 1']);
    $table->setId(5)->update(['stock' => 10]);

    $transaction->commit();
} catch (\Exception $e) {
    $transaction->rollback();
    echo "Błąd: " . $e->getMessage();
}

Schemat bazy danych

Tworzenie tabel

$createTable = new \krzysztofzylka\DatabaseManager\CreateTable();
$createTable->setName('products');
$createTable->addIdColumn()
    ->addSimpleVarcharColumn('name', 255, false)
    ->addSimpleDecimalColumn('price', '10,2', 0.00)
    ->addSimpleIntColumn('stock', false, true)
    ->addDateCreatedColumn()
    ->addDateModifyColumn();

$createTable->execute();

Modyfikacja struktury tabeli

$alterTable = new \krzysztofzylka\DatabaseManager\AlterTable('products');

// Dodawanie nowej kolumny
$column = new \krzysztofzylka\DatabaseManager\Column();
$column->setName('description')
    ->setType(\krzysztofzylka\DatabaseManager\Enum\ColumnType::text)
    ->setNull(true);

$alterTable->addColumn($column);

// Modyfikacja typu kolumny
$alterTable->modifyColumn('name', \krzysztofzylka\DatabaseManager\Enum\ColumnType::varchar, 100);

// Usunięcie kolumny
$alterTable->removeColumn('old_column');

$alterTable->execute();

Zaawansowane funkcje

Cache zapytań

// Zapisanie danych w cache
\krzysztofzylka\DatabaseManager\Cache::saveData('key', $value);

// Odczytanie danych z cache
$data = \krzysztofzylka\DatabaseManager\Cache::getData('key');

Blokady bazodanowe

$lock = new \krzysztofzylka\DatabaseManager\DatabaseLock();

// Zablokowanie zasobu
if ($lock->lock('import_process', 300)) {
    // Wykonaj operację wymagającą wyłącznego dostępu

    // Zwolnienie blokady
    $lock->unlock('import_process');
}

Struktura Zwracanych Danych

DatabaseManager zwraca dane w ustrukturyzowanym formacie z prefiksem nazwy tabeli. To zapewnia bezpieczeństwo i jasność źródła danych, szczególnie w złożonych zapytaniach z JOIN.

Pojedynczy Rekord

$user = $table->find(['id' => 1]);

// Struktura zwracanych danych:
[
    'users' => [
        'id' => 1,
        'name' => 'Jan Kowalski',
        'email' => 'jan@example.com',
        'age' => 30,
        'date_created' => '2024-01-15 10:30:00'
    ]
]

// Dostęp do danych:
echo $user['users']['name']; // Jan Kowalski
echo $user['users']['email']; // jan@example.com

Wiele Rekordów

$users = $table->findAll();

// Struktura zwracanych danych:
[
    0 => [
        'users' => [
            'id' => 1,
            'name' => 'Jan Kowalski',
            'email' => 'jan@example.com'
        ]
    ],
    1 => [
        'users' => [
            'id' => 2,
            'name' => 'Anna Nowak',
            'email' => 'anna@example.com'
        ]
    ]
]

// Iteracja po danych:
foreach ($users as $user) {
    echo $user['users']['name'] . ' - ' . $user['users']['email'] . "\n";
}

Złączenia (JOIN) z Prefiksami

$table->bind(
    \krzysztofzylka\DatabaseManager\Enum\BindType::leftJoin,
    'orders',
    'users.id',
    'orders.user_id'
);

$usersWithOrders = $table->findAll();

// Struktura zwracanych danych:
[
    0 => [
        'users' => [
            'id' => 1,
            'name' => 'Jan Kowalski',
            'email' => 'jan@example.com'
        ],
        'orders' => [
            'id' => 1,
            'order_number' => 'ORD001',
            'user_id' => 1,
            'total' => 150.00
        ]
    ],
    1 => [
        'users' => [
            'id' => 1,
            'name' => 'Jan Kowalski',
            'email' => 'jan@example.com'
        ],
        'orders' => [
            'id' => 2,
            'order_number' => 'ORD002',
            'user_id' => 1,
            'total' => 75.50
        ]
    ]
]

// Dostęp do danych z różnych tabel:
foreach ($usersWithOrders as $record) {
    echo "Użytkownik: " . $record['users']['name'] . "\n";
    echo "Zamówienie: " . $record['orders']['order_number'] . "\n";
    echo "Kwota: " . $record['orders']['total'] . "\n";
}

Złączenia z Warunkami

$table->bind(
    \krzysztofzylka\DatabaseManager\Enum\BindType::leftJoin,
    'orders',
    'users.id',
    'orders.user_id',
    ['status' => 'completed'] // Warunek w JOIN
);

$completedOrders = $table->findAll();

Praktyczne Wskazówki

1. Bezpieczny Dostęp do Danych

// Zawsze sprawdzaj czy klucz istnieje
$user = $table->find(['id' => 1]);

if (isset($user['users']['name'])) {
    echo $user['users']['name'];
} else {
    echo 'Użytkownik nie znaleziony';
}

2. Iteracja z Bezpieczeństwem

$users = $table->findAll();

foreach ($users as $user) {
    $userData = $user['users'] ?? [];
    echo $userData['name'] ?? 'Brak nazwy';
    echo $userData['email'] ?? 'Brak email';
}

3. Praca z JOIN

$table->bind(BindType::leftJoin, 'orders', 'users.id', 'orders.user_id');
$results = $table->findAll();

foreach ($results as $record) {
    $userData = $record['users'] ?? [];
    $orderData = $record['orders'] ?? [];

    if (!empty($orderData)) {
        echo "Użytkownik {$userData['name']} ma zamówienie {$orderData['order_number']}\n";
    } else {
        echo "Użytkownik {$userData['name']} nie ma zamówień\n";
    }
}

4. Filtrowanie Wyników

$users = $table->findAll();

// Filtrowanie użytkowników z określonym wiekiem
$adultUsers = array_filter($users, function($user) {
    return ($user['users']['age'] ?? 0) >= 18;
});

// Mapowanie do prostszej struktury
$userNames = array_map(function($user) {
    return $user['users']['name'];
}, $users);

Korzyści Struktury z Prefiksami

Bezpieczeństwo JOIN-ów - Unika konfliktów nazw kolumn między tabelami
Jasność źródła - Zawsze wiadomo z której tabeli pochodzą dane
Skalowalność - Łatwo dodawać kolejne tabele do złączeń
Konsystencja - Jednolita struktura dla wszystkich zapytań
Debugowanie - Łatwiejsze śledzenie problemów z danymi

Obsługa błędów

Biblioteka wykorzystuje dedykowane klasy wyjątków:

try {
    // Kod korzystający z DatabaseManager
} catch (\krzysztofzylka\DatabaseManager\Exception\ConnectException $e) {
    // Błąd połączenia
    echo "Nie można połączyć z bazą danych: " . $e->getHiddenMessage();
} catch (\krzysztofzylka\DatabaseManager\Exception\TransactionException $e) {
    // Błąd transakcji
    echo "Błąd transakcji: " . $e->getHiddenMessage();
} catch (\krzysztofzylka\DatabaseManager\Exception\DatabaseManagerException $e) {
    // Ogólny błąd
    echo "Błąd bazy danych: " . $e->getHiddenMessage();
}

Licencja

MIT License. Pełna treść w pliku LICENSE.

krzysztofzylka/database-manager

包简介

README 文档