chore: prepare release 2.7.0

Complete changelog with all features added since 2.6.2:
- Full-text search with cross-database support
- Schema introspection (indexes, foreign keys, constraints)
- Query result caching (PSR-16) for 10-1000x speedup
- Advanced pagination (full, simple, cursor-based)
- Export helpers (JSON, CSV, XML)
- JSON file loading (JSON, JSONL)
- Enhanced orderBy with array and string syntax
- Read/Write connection splitting with load balancing
- 57 comprehensive documentation files
- Memory-efficient generators for file loading
- Code architecture improvements

Technical: 533 tests (+55), 2397 assertions, 93 examples

Author: tommyknocker

CHANGELOG.md

@@ -9,6 +9,177 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [2.7.0] - 2025-10-28
+
+### Added
+- **Full-Text Search** - Cross-database full-text search with `Db::fulltextMatch()` helper:
+  - **MySQL**: `MATCH AGAINST` with FULLTEXT indexes
+  - **PostgreSQL**: `@@` operator with `to_tsquery()` and text search vectors
+  - **SQLite**: FTS5 virtual tables support
+  - Support for multiple columns, search modes (natural language, boolean), and query expansion
+  - `FulltextMatchValue` class and `FulltextSearchHelpersTrait` for implementation
+  - Complete documentation in `documentation/03-query-builder/fulltext-search.md`
+  - Examples in `examples/12-fulltext-search/` working on all three dialects
+  - 12 new tests across MySQL, PostgreSQL, and SQLite
+
+- **Schema Introspection** - Query database structure programmatically:
+  - `PdoDb::getIndexes(string $table)` - Get all indexes for a table
+  - `PdoDb::getForeignKeys(string $table)` - Get foreign key constraints
+  - `PdoDb::getConstraints(string $table)` - Get all constraints (PRIMARY KEY, UNIQUE, FOREIGN KEY, CHECK)
+  - `QueryBuilder::getIndexes()`, `getForeignKeys()`, `getConstraints()` - Same methods via QueryBuilder
+  - Cross-database compatible across MySQL, PostgreSQL, and SQLite
+  - Complete documentation in `documentation/03-query-builder/schema-introspection.md`
+  - Tests in all dialect-specific test files
+
+- **Query Result Caching** - PSR-16 (Simple Cache) integration for dramatic performance improvements:
+  - **10-1000x faster** for repeated queries with caching enabled
+  - `QueryBuilder::cache(?int $ttl = null, ?string $key = null)` - Enable caching for query
+  - `QueryBuilder::noCache()` - Disable caching for specific query
+  - `PdoDb::enableCache(CacheInterface $cache, ?CacheConfig $config = null)` - Enable caching globally
+  - `PdoDb::disableCache()` - Disable caching globally
+  - Support for all PSR-16 compatible cache implementations:
+    - Symfony Cache, Redis, APCu, Memcached, Filesystem adapters
+    - Built-in `ArrayCache` for testing
+  - Automatic cache key generation based on SQL and parameters
+  - Custom cache keys and TTL support
+  - `CacheManager`, `CacheConfig`, `QueryCacheKey` infrastructure classes
+  - Complete documentation in `documentation/05-advanced-features/query-caching.md`
+  - Examples in `examples/14-caching/` demonstrating real-world usage
+  - Comprehensive test coverage in `SharedCoverageTest`
+
+- **Advanced Pagination** - Three pagination types for different use cases:
+  - **Full pagination** (`paginate(int $page, int $perPage)`): Complete pagination with total count and page numbers
+    - Returns `PaginationResult` with items, total, current page, last page, per page
+    - Best for UI with page numbers and "showing X of Y results"
+  - **Simple pagination** (`simplePaginate(int $page, int $perPage)`): Fast pagination without total count
+    - Returns `SimplePaginationResult` with items, has more pages flag
+    - No COUNT query overhead - ideal for large datasets
+  - **Cursor-based pagination** (`cursorPaginate(?string $cursor, int $perPage, string $column = 'id')`): Scalable pagination for real-time feeds
+    - Returns `CursorPaginationResult` with items, next cursor, previous cursor
+    - Consistent results even with new data
+    - Perfect for infinite scroll and API endpoints
+  - All results implement `JsonSerializable` for easy API responses
+  - URL generation support with query parameters
+  - Complete documentation in `documentation/05-advanced-features/pagination.md`
+  - Examples in `examples/13-pagination/` working on all dialects
+  - Comprehensive test coverage for all pagination types
+
+- **Export Helpers** - Export query results to various formats:
+  - `Db::toJson($data, int $options = 0)` - Export to JSON with customizable encoding options
+    - Support for pretty printing, unescaped unicode, unescaped slashes
+  - `Db::toCsv($data, string $delimiter = ',', string $enclosure = '"')` - Export to CSV format
+    - Custom delimiter and enclosure character support
+  - `Db::toXml($data, string $rootElement = 'root', string $itemElement = 'item')` - Export to XML format
+    - Customizable root and item element names
+    - Support for nested arrays and complex data structures
+  - SOLID architecture with separate exporter classes (`JsonExporter`, `CsvExporter`, `XmlExporter`)
+  - Complete documentation in `documentation/07-helper-functions/export-helpers.md`
+  - Examples in `examples/11-export-helpers/` demonstrating all export formats
+  - Comprehensive test coverage in `SharedCoverageTest`
+
+- **JSON File Loading** - Bulk load JSON data directly into database tables:
+  - `QueryBuilder::loadJson(string $filename, bool $update = false, ?array $updateFields = null)` - Load JSON array of objects
+  - `QueryBuilder::loadJsonLines(string $filename, bool $update = false, ?array $updateFields = null)` - Load newline-delimited JSON (JSONL/NDJSON)
+  - Support for nested JSON with automatic encoding
+  - Memory-efficient batch processing for large files
+  - Works across all three database dialects (MySQL, PostgreSQL, SQLite)
+  - UPSERT support with optional update fields
+  - Complete documentation in `documentation/05-advanced-features/file-loading.md`
+  - Examples in `examples/05-file-loading/` with practical scenarios
+
+- **Enhanced orderBy()** - Flexible sorting with multiple syntax options:
+  - **Array syntax with directions**: `orderBy(['name' => 'ASC', 'created_at' => 'DESC'])`
+  - **Array with default direction**: `orderBy(['name', 'email'], 'DESC')`
+  - **Comma-separated string**: `orderBy('name ASC, email DESC, id')`
+  - **Original syntax still works**: `orderBy('name', 'DESC')`
+  - Full backward compatibility with existing code
+  - Complete documentation and examples in `documentation/03-query-builder/ordering-pagination.md`
+  - New example file `examples/01-basic/05-ordering.php` demonstrating all syntax variants
+  - Comprehensive test coverage in `SharedCoverageTest`
+
+- **Read/Write Connection Splitting** - Master-replica architecture for horizontal scaling:
+  - **Automatic query routing**: SELECT queries → read replicas, DML operations → write master
+  - **Three load balancing strategies**:
+    - `RoundRobinLoadBalancer` - Even distribution across replicas
+    - `RandomLoadBalancer` - Random replica selection
+    - `WeightedLoadBalancer` - Weight-based distribution (e.g., 70% replica-1, 30% replica-2)
+  - **Sticky writes**: Read-after-write consistency (reads from master for N seconds after write)
+  - **Force write mode**: `QueryBuilder::forceWrite()` to explicitly read from master
+  - **Transaction support**: All operations in transactions use write connection
+  - **Health checks and failover**: Automatic exclusion of failed connections
+  - Type-safe with `ConnectionType` enum (`READ`, `WRITE`)
+  - New classes: `ConnectionRouter`, `LoadBalancerInterface` + 3 implementations
+  - New methods: `enableReadWriteSplitting()`, `disableReadWriteSplitting()`, `enableStickyWrites()`, `disableStickyWrites()`, `getConnectionRouter()`
+  - Complete documentation in `documentation/05-advanced-features/read-write-splitting.md`
+  - Three examples in `examples/15-read-write-splitting/` demonstrating all features
+  - 13 new tests with 24 assertions in `SharedCoverageTest`
+
+- **Comprehensive Documentation** - 57 new documentation files (~12,600 lines):
+  - **Getting Started**: Installation, configuration, first connection, hello world
+  - **Core Concepts**: Connection management, dialect support, parameter binding, query builder basics
+  - **Query Builder**: All operations (SELECT, INSERT, UPDATE, DELETE, JOINs, aggregations, subqueries, etc.)
+  - **JSON Operations**: Complete JSON support across all dialects
+  - **Advanced Features**: Transactions, bulk operations, batch processing, file loading, pagination, query caching, connection retry, read/write splitting
+  - **Error Handling**: Exception hierarchy, error codes, logging, monitoring, retry logic
+  - **Helper Functions**: 80+ helpers organized by category (string, math, date, JSON, aggregate, comparison, etc.)
+  - **Best Practices**: Security, performance, memory management, common pitfalls, code organization
+  - **Reference**: Complete API reference, dialect differences, method documentation
+  - **Cookbook**: Real-world examples, migration guide, troubleshooting, common patterns
+  - README.md files added to all example subdirectories for better navigation
+
+### Changed
+- **Memory-efficient file loading**: Refactored `loadCsv()` and `loadXml()` to use PHP generators
+  - Dramatically reduced memory consumption for large files
+  - Added `loadFromCsvGenerator()` and `loadFromXmlGenerator()` in `FileLoader` class
+  - Batched processing to handle files larger than available RAM
+  - MySQL and PostgreSQL keep native commands but wrapped as generators
+  - All 478+ tests passing with improved performance
+
+- **Code architecture improvements**:
+  - Removed `ParameterManager` class (functionality integrated into other components)
+  - Changed method/property visibility from `private` to `protected` for better extensibility
+  - Renamed schema introspection methods for consistency
+  - Updated return types in `TableManagementTrait` from `static` to `self`
+
+- **Test refactoring for best practices**:
+  - Replaced direct `$db->connection` calls with public API methods
+  - Use `$db->rawQuery()` instead of `$db->connection->query()`
+  - Use `$db->startTransaction()`, `$db->commit()`, `$db->rollback()` instead of direct connection calls
+  - Direct connection access only in tests specifically testing `ConnectionInterface`
+
+- **Enhanced README.md**:
+  - Restructured feature list with bold categories and detailed descriptions
+  - Added all new features with performance metrics (e.g., "10-1000x faster queries")
+  - More scannable and impressive presentation
+  - Complete table of contents with all sections
+
+- **QueryBuilder enhancements**:
+  - Dynamic connection switching for read/write splitting
+  - Cache-aware query execution
+  - Enhanced ordering with multiple syntax options
+
+### Fixed
+- **Invalid release date**: Fixed incorrect date in CHANGELOG.md for v2.6.1
+- **Cross-dialect compatibility**: Exception handling examples now work correctly on MySQL, PostgreSQL, and SQLite
+  - Added dialect-specific CREATE TABLE statements
+  - Added DROP TABLE IF EXISTS for idempotency
+  - All examples pass on all three dialects
+
+### Technical Details
+- **All tests passing**: 533 tests, 2397 assertions (+55 tests from 2.6.2)
+- **All examples passing**: 93/93 examples (31 files × 3 dialects each)
+  - SQLite: 31/31 ✅
+  - MySQL: 31/31 ✅
+  - PostgreSQL: 31/31 ✅
+- **PHPStan Level 8**: Zero errors across entire codebase
+- **PHP-CS-Fixer**: All code complies with PSR-12 standards
+- **Full backward compatibility**: 100% maintained - all existing code continues to work
+- **Code quality**: Follows KISS, SOLID, DRY, YAGNI principles
+- **Documentation**: 57 comprehensive documentation files covering all features
+- **Performance**: Memory-efficient generators, optional query caching for 10-1000x speedup
+
+---
+
 ## [2.6.2] - 2025-10-25
 
 ### Added
@@ -542,7 +713,8 @@ Initial tagged release with basic PDO database abstraction functionality.
 
 ---
 
-[Unreleased]: https://github.com/tommyknocker/pdo-database-class/compare/v2.6.2...HEAD
+[Unreleased]: https://github.com/tommyknocker/pdo-database-class/compare/v2.7.0...HEAD
+[2.7.0]: https://github.com/tommyknocker/pdo-database-class/compare/v2.6.2...v2.7.0
 [2.6.2]: https://github.com/tommyknocker/pdo-database-class/compare/v2.6.1...v2.6.2
 [2.6.1]: https://github.com/tommyknocker/pdo-database-class/compare/v2.6.0...v2.6.1
 [2.6.0]: https://github.com/tommyknocker/pdo-database-class/compare/v2.5.1...v2.6.0

tests/SharedCoverageTest.php

@@ -15,6 +15,10 @@
 use RuntimeException;
 use tommyknocker\pdodb\connection\Connection;
 use tommyknocker\pdodb\connection\ConnectionInterface;
+use tommyknocker\pdodb\connection\ConnectionType;
+use tommyknocker\pdodb\connection\loadbalancer\RandomLoadBalancer;
+use tommyknocker\pdodb\connection\loadbalancer\RoundRobinLoadBalancer;
+use tommyknocker\pdodb\connection\loadbalancer\WeightedLoadBalancer;
 use tommyknocker\pdodb\connection\RetryableConnection;
 use tommyknocker\pdodb\dialects\DialectInterface;
 use tommyknocker\pdodb\exceptions\AuthenticationException;
@@ -3375,32 +3379,32 @@ public function testLoadBalancers(): void
         $db = new PdoDb();
 
         // Test with RoundRobin
-        $db->enableReadWriteSplitting(new \tommyknocker\pdodb\connection\loadbalancer\RoundRobinLoadBalancer());
+        $db->enableReadWriteSplitting(new RoundRobinLoadBalancer());
         $this->assertInstanceOf(
-            \tommyknocker\pdodb\connection\loadbalancer\RoundRobinLoadBalancer::class,
+            RoundRobinLoadBalancer::class,
             $db->getConnectionRouter()->getLoadBalancer()
         );
 
         // Test with Random
-        $db->enableReadWriteSplitting(new \tommyknocker\pdodb\connection\loadbalancer\RandomLoadBalancer());
+        $db->enableReadWriteSplitting(new RandomLoadBalancer());
         $this->assertInstanceOf(
-            \tommyknocker\pdodb\connection\loadbalancer\RandomLoadBalancer::class,
+            RandomLoadBalancer::class,
             $db->getConnectionRouter()->getLoadBalancer()
         );
 
         // Test with Weighted
-        $weighted = new \tommyknocker\pdodb\connection\loadbalancer\WeightedLoadBalancer();
+        $weighted = new WeightedLoadBalancer();
         $weighted->setWeights(['read-1' => 2, 'read-2' => 1]);
         $db->enableReadWriteSplitting($weighted);
         $this->assertInstanceOf(
-            \tommyknocker\pdodb\connection\loadbalancer\WeightedLoadBalancer::class,
+            WeightedLoadBalancer::class,
             $db->getConnectionRouter()->getLoadBalancer()
         );
     }
 
     public function testLoadBalancerMarkFailedAndHealthy(): void
     {
-        $balancer = new \tommyknocker\pdodb\connection\loadbalancer\RoundRobinLoadBalancer();
+        $balancer = new RoundRobinLoadBalancer();
 
         $balancer->markFailed('read-1');
         $balancer->markHealthy('read-1');
@@ -3411,7 +3415,7 @@ public function testLoadBalancerMarkFailedAndHealthy(): void
 
     public function testLoadBalancerReset(): void
     {
-        $balancer = new \tommyknocker\pdodb\connection\loadbalancer\RoundRobinLoadBalancer();
+        $balancer = new RoundRobinLoadBalancer();
 
         $balancer->markFailed('read-1');
         $balancer->reset();
@@ -3422,8 +3426,8 @@ public function testLoadBalancerReset(): void
 
     public function testConnectionTypeEnum(): void
     {
-        $readType = \tommyknocker\pdodb\connection\ConnectionType::READ;
-        $writeType = \tommyknocker\pdodb\connection\ConnectionType::WRITE;
+        $readType = ConnectionType::READ;
+        $writeType = ConnectionType::WRITE;
 
         $this->assertEquals('read', $readType->value);
         $this->assertEquals('write', $writeType->value);