Performance

use Glueful\Cache\CacheStore;

$cache = app($context, CacheStore::class);

$posts = $cache->remember('posts:published', function () use ($context) {
    return db($context)->table('posts')
        ->where('status', 'published')
        ->get();
}, 3600);

// In a migration
$schema->alterTable('posts', function ($table) {
    $table->index('author_uuid');
    $table->index('status');
    $table->index(['status', 'created_at']);
});

use Glueful\Queue\QueueManager;

// Don't process inline
$queue = app($context, QueueManager::class);
$queue->push(\App\Jobs\ProcessImageJob::class, ['path' => $path]);
$queue->push(\App\Jobs\SendEmailJob::class, ['user_uuid' => $userUuid]);

// Good - specific columns
$posts = db($context)->table('posts')
    ->select(['uuid', 'title', 'published_at'])
    ->get();

// Bad - all columns
$posts = db($context)->table('posts')->get();

// Bad - one query per post
$posts = db($context)->table('posts')->get();
foreach ($posts as $i => $post) {
    $posts[$i]['author'] = db($context)->table('authors')
        ->where('uuid', $post['author_uuid'])
        ->first();
}

// Good - one query with a join
$posts = db($context)->table('posts')
    ->join('authors', 'posts.author_uuid', '=', 'authors.uuid')
    ->select(['posts.*', 'authors.name AS author_name'])
    ->get();

// Bad - one INSERT per row
foreach ($rows as $row) {
    db($context)->table('events')->insert($row);
}

// Good - one batched INSERT (returns affected rows)
db($context)->table('events')->insertBatch($rows);

// Insert one row, or update the listed columns on a key conflict
db($context)->table('counters')->upsert(['key' => 'home', 'hits' => 1], ['hits']);

// paginate() runs the page query plus a count query
$page = db($context)->table('posts')
    ->where('status', 'published')
    ->orderBy(['published_at' => 'DESC'])
    ->paginate(page: 1, perPage: 20);

// ['data' => [...], 'current_page' => 1, 'per_page' => 20, 'total' => ..., 'last_page' => ...,
//  'has_more' => true, 'from' => 1, 'to' => 20, 'execution_time_ms' => ...]

// Good - database count
$count = db($context)->table('posts')->count();

// Bad - load everything, then count
$count = count(db($context)->table('posts')->get());

// Sums and averages
$row = db($context)->table('orders')
    ->selectRaw('SUM(total) AS revenue, AVG(total) AS average')
    ->where('status', 'paid')
    ->first();

use Glueful\Performance\ChunkedDatabaseProcessor;

$processor = new ChunkedDatabaseProcessor(db($context), 1000);

// processTableInChunks(table, callback, idColumn = 'id', conditions = [], chunkSize = null)
$results = $processor->processTableInChunks('events', function (array $rows) {
    foreach ($rows as $row) {
        // Process...
    }
    return count($rows);
}, 'id', ['status' => 'pending']);

// Default TTL (database.query_cache.default_ttl, 3600s)
$featured = db($context)->table('products')
    ->where('featured', true)
    ->cache()
    ->get();

// Custom TTL and extra invalidation tags
$recent = db($context)->table('articles')
    ->where('status', 'published')
    ->orderBy(['published_at' => 'DESC'])
    ->limit(5)
    ->cache(300, ['homepage'])
    ->get();

use Glueful\Database\QueryCacheService;

app($context, QueryCacheService::class)->invalidateTable('products');

use Glueful\Database\Attributes\CacheResult;
use Glueful\Repository\BaseRepository;

class ProductRepository extends BaseRepository
{
    public function getTableName(): string
    {
        return 'products';
    }

    #[CacheResult(ttl: 7200, keyPrefix: 'products.featured', tags: ['products', 'catalog'])]
    public function featured(): array
    {
        return $this->db->table($this->table)->where('featured', true)->get();
    }
}

// In a service
$products = $this->queryCache->cacheRepositoryMethod($this->products, 'featured');
$byCategory = $this->queryCache->cacheRepositoryMethod($this->products, 'byCategory', [$category]);

php glueful db:profile "SELECT * FROM posts WHERE status = ?" --params='["published"]'

# With execution plan and pattern analysis
php glueful db:profile "SELECT * FROM posts WHERE status = 'published'" --explain --patterns

# From a file, as JSON
php glueful db:profile --file=slow-query.sql --output=json

# Run it 50 times, or compare against another query file
php glueful db:profile --file=a.sql --benchmark=50
php glueful db:profile --file=a.sql --compare=b.sql

use Glueful\Database\QueryAnalyzer;

$analyzer = new QueryAnalyzer($context);
$report = $analyzer->analyzeQuery(
    'SELECT * FROM orders WHERE customer_uuid = ? ORDER BY created_at DESC',
    [$customerUuid]
);

$report['execution_plan'];          // normalized EXPLAIN output (MySQL, PostgreSQL, SQLite)
$report['potential_issues'];        // detected anti-patterns
$report['optimization_suggestions'];
$report['index_recommendations'];

use Glueful\Database\QueryOptimizer;

$optimizer = (new QueryOptimizer())->setConnection(db($context));
$result = $optimizer->optimizeQuery($sql, $bindings);

$result['original_query'];
$result['optimized_query'];
$result['suggestions'];             // each: type, description, solution, ...
$result['estimated_improvement'];   // execution_time, resource_usage, confidence

use Glueful\Database\Tools\ExecutionPlanAnalyzer;
use Glueful\Database\Tools\QueryPatternRecognizer;

$plans = new ExecutionPlanAnalyzer(db($context), $context);
$plan = $plans->getExecutionPlan($sql, $bindings);
$analysis = $plans->analyzeExecutionPlan($plan);

$recognizer = new QueryPatternRecognizer();
$recognizer->addPattern(
    'leading_wildcard',
    '/LIKE\s+[\'"]%/i',
    'LIKE with a leading wildcard cannot use an index',
    'Use full-text search or an index-friendly prefix match'
);
$matches = $recognizer->recognizePatterns($sql);
// ['leading_wildcard' => ['description' => ..., 'recommendation' => ...]]

use Glueful\Database\Tools\QueryProfilerService;

$profiler = new QueryProfilerService(context: $context);

$rows = $profiler->profile($sql, $bindings, function () use ($context) {
    return db($context)->table('orders')->where('status', 'open')->get();
});

$slow = $profiler->getRecentProfiles(10, 100.0);  // last 10 at or above 100ms
$stats = $profiler->getStatistics();

use Glueful\Http\Response;

return Response::success($config)
    ->withCacheHeaders(3600, true)        // public, max-age=3600
    ->withETag(md5(json_encode($config)));

// Private, short-lived data
return Response::success($profile)->withCacheHeaders(300, false);

$router->get('/catalog', [CatalogController::class, 'index'])
    ->middleware('conditional_cache:etag,1');

public function index(): Response
{
    $products = $this->cacheResponse('products.index', function () {
        return $this->products->featured();
    }, 600);

    return Response::success($products);
}

use Psr\Log\LoggerInterface;

$start = microtime(true);
$memoryBefore = memory_get_usage();

// Code to profile

app($context, LoggerInterface::class)->info('Profiled block', [
    'ms' => round((microtime(true) - $start) * 1000, 2),
    'memory_mb' => round((memory_get_usage() - $memoryBefore) / 1048576, 2),
    'peak_mb' => round(memory_get_peak_usage(true) / 1048576, 2),
]);

opcache.enable=1
opcache.memory_consumption=256
opcache.max_accelerated_files=20000
opcache.validate_timestamps=0

composer dump-autoload --optimize --classmap-authoritative

php glueful di:container:compile      # precompile the container
php glueful commands:cache            # cache the console command manifest
php glueful extensions:cache          # cache the enabled extension list
php glueful system:production         # production readiness checks

php glueful queue:restart

pm = dynamic
pm.max_children = 50
pm.start_servers = 5
pm.min_spare_servers = 5
pm.max_spare_servers = 35

# Apache Bench
ab -n 1000 -c 10 http://localhost:8000/api/v1/posts

# wrk
wrk -t12 -c400 -d30s http://localhost:8000/api/v1/posts