Database Laravel Package

Product Decisions This Supports

• Build vs. Buy: Buy – Adopt this package to avoid reinventing a robust, battle-tested database abstraction layer. It eliminates the need to build custom query builders, connection managers, or transaction handling from scratch, reducing technical debt and accelerating development.
• Feature Roadmap:
  • Database Resilience: Leverage granular exception types (e.g., DeadlockException, ConnectionLostException) to implement automatic retry logic for transient failures, improving system reliability.
  • Multi-Database Support: Standardize on a single abstraction layer for MySQL, PostgreSQL, SQLite, MS SQL Server, and Oracle, simplifying migrations or multi-database architectures (e.g., read replicas, analytics databases).
  • Developer Experience (DX):
    • Adopt getExplorer() to enable direct access to the underlying Explorer for advanced use cases (e.g., custom query optimization, debugging).
    • Integrate ConnectionPanel (Tracy integration) for real-time SQL monitoring in development, reducing debugging time.
  • Data Integrity:
    • Use CheckConstraintViolationException to validate business rules at the database layer, reducing application-level validation boilerplate.
    • Implement transaction nesting (Explorer::transaction()) for complex workflows requiring atomicity (e.g., financial systems, inventory management).
• Use Cases:
  • Legacy System Modernization: Replace ad-hoc PDO queries with a type-safe, fluent API to improve maintainability and reduce SQL injection risks.
  • Microservices: Standardize database access across services using a consistent abstraction, easing future refactoring or consolidation.
  • Analytics/Reporting: Leverage advanced joins, aggregations, and fetchList()/fetchPairs() for efficient data retrieval without writing raw SQL.
  • Event-Driven Architectures: Use Selection::refreshData() and GroupedSelection to manage cached or materialized views dynamically.

When to Consider This Package

• Adopt if:

  • Your team uses PHP/Laravel and prioritizes developer productivity over raw performance (this library abstracts away low-level PDO complexity).
  • You need multi-database support (e.g., PostgreSQL for analytics, MySQL for transactions) without writing database-specific code.
  • Your application requires fine-grained error handling for database-specific issues (e.g., deadlocks, lock timeouts) to implement resilient retry logic.
  • You’re building a Nette-based application or want to integrate with the Nette ecosystem (e.g., Tracy debugging tools).
  • Your team lacks database expertise but needs a safe, expressive API for SQL operations (reduces risk of SQL injection or inefficient queries).

• Look elsewhere if:

  • You require ultra-low latency (this library adds a thin abstraction layer; raw PDO or a micro-ORM like CycleORM or Doctrine DBAL may be faster for simple CRUD).
  • Your use case is ORM-heavy (e.g., complex entity relationships, inheritance). Consider Doctrine ORM or Eloquent instead.
  • You need active record patterns (this library favors query builder and table/row APIs over active record).
  • Your team is heavily invested in raw SQL and resists abstraction layers (though the API is PDO-like, it’s not a drop-in replacement).
  • You’re using PHP 7.0 or lower (minimum PHP 7.1 required; PHP 8.1+ recommended for full features).

How to Pitch It (Stakeholders)

For Executives:

"This package lets us build database resilience and developer velocity without sacrificing control. By adopting nette/database, we can:

• Reduce bugs: Granular exceptions (e.g., DeadlockException) let us automate retries for transient failures, improving uptime.
• Cut costs: Standardize on one abstraction layer for all databases (MySQL, PostgreSQL, etc.), simplifying migrations and reducing vendor lock-in.
• Accelerate development: A fluent, type-safe API replaces manual SQL and PDO boilerplate, letting engineers focus on business logic.
• Improve observability: Built-in Tracy integration provides real-time SQL monitoring, reducing debugging time by 30%+. It’s a low-risk, high-reward choice—lightweight enough for startups, scalable enough for enterprise."

For Engineering Teams:

"nette/database gives us:

• A PDO-like API on steroids: Build queries fluently (e.g., $selection->where('active = ?', true)) with advanced features like subqueries, joins, and aggregations—without writing raw SQL.
• Database-agnostic resilience: Catch deadlocks, lock timeouts, or lost connections separately to implement surgical retry logic (e.g., exponential backoff).
• Performance safeguards: Optimized drivers (e.g., SQLite PRAGMA caching, PostgreSQL partitioned table support) and batch operations for bulk inserts/updates.
• Dev tooling: ConnectionPanel in Tracy shows query execution times, parameters, and stack traces—no more guessing why a query is slow.
• Future-proofing: Supports PHP 8.5, generics, and custom drivers (e.g., for MongoDB via PDO_Mongo if needed). It’s not an ORM—so no magic, no impedance mismatch—but it’s 10x more powerful than raw PDO for 90% of use cases."

For Architects:

"Key architectural benefits:

1. Decoupling: Abstracts database logic from business code, making it easier to swap databases or add read replicas later.
2. Transaction safety: Supports nested transactions and atomic operations out of the box (critical for financial or inventory systems).
3. Metadata access: Reflect on tables, columns, foreign keys, and indexes programmatically (e.g., for schema migrations or dynamic query building).
4. Security: Automatic parameter binding and type safety reduce SQL injection risks compared to string interpolation.
5. Testability: Docker Compose setup for local databases and mockable interfaces simplify unit/integration testing. This is a foundation layer—not a silver bullet—but it aligns with clean architecture principles by keeping database concerns isolated."