Poradnik optymalizacji zapytań produktów na dużych sklepach

Wprowadzenie – Wyzwania optymalizacji zapytań w dużych sklepach

Optymalizacja zapytań produktów to kluczowy element wydajności dużych sklepów WooCommerce. Sklepy z tysiącami produktów, setkami kategorii i dziesiątkami atrybutów generują złożone zapytania do bazy danych, które mogą znacząco spowolnić działanie strony.

Statystyki pokazują, że każda sekunda opóźnienia zmniejsza konwersje o 7%, a sklepy z dużą liczbą produktów są szczególnie narażone na problemy z wydajnością. Typowy listing produktów w dużym sklepie może generować nawet 50-100 zapytań SQL, co przy dużym ruchu prowadzi do przeciążenia bazy danych.

W tym przewodniku szczegółowo omówię kompleksowy proces optymalizacji zapytań produktów. Poznasz metody analizy wydajności, techniki optymalizacji bazy danych, zaawansowane mechanizmy cache oraz sposoby redukcji liczby zapytań. Dowiesz się, jak zoptymalizować zarówno frontend, jak i backend dużego sklepu WooCommerce.

Analiza wolnych zapytań produktów w WooCommerce

Przed przystąpieniem do optymalizacji, musisz dokładnie zdiagnozować istniejące problemy z wydajnością zapytań.

Diagnostyka wydajności zapytań

Narzędzia do analizy zapytań:

• Query Monitor: Wtyczka do monitorowania zapytań SQL
• Query Monitor Debug: Rozszerzenie z zaawansowaną analizą
• Debug Bar: Podstawowe narzędzie debugowania
• MySQL Slow Query Log: Logi powolnych zapytań na serwerze

Analiza zapytań WooCommerce

Typowe problemy z zapytaniami produktów:

Problem 1: Brak indeksów

Objawy: Zapytania typu "SELECT * FROM wp_posts WHERE ..."

Rozwiązanie: Dodanie odpowiednich indeksów do kolumn

Problem 2: Zbyt dużo JOIN-ów

Objawy: Zapytania łączące 5-10 tabel

Rozwiązanie: Optymalizacja struktury zapytań, cache wyników

Problem 3: Niewłaściwe użycie meta_query

Objawy: Zapytania z wieloma warunkami meta

Rozwiązanie: Denormalizacja danych, cache zapytań

Przykład analizy zapytania

-- Typowe zapytanie produktów z filtry
SELECT p.* FROM wp_posts p
INNER JOIN wp_term_relationships tr ON p.ID = tr.object_id
INNER JOIN wp_term_taxonomy tt ON tr.term_taxonomy_id = tt.term_taxonomy_id
INNER JOIN wp_terms t ON tt.term_id = t.term_id
LEFT JOIN wp_postmeta pm1 ON p.ID = pm1.post_id AND pm1.meta_key = '_price'
LEFT JOIN wp_postmeta pm2 ON p.ID = pm2.post_id AND pm2.meta_key = '_stock_status'
WHERE p.post_type = 'product'
AND p.post_status = 'publish'
AND tt.taxonomy = 'product_cat'
AND t.slug IN ('elektronika', 'smartfony')
AND pm1.meta_value BETWEEN 1000 AND 5000
AND pm2.meta_value = 'instock'
ORDER BY pm1.meta_value DESC
LIMIT 12;

Problemy:

• Brak indeksów na kluczowych kolumnach
• Zbyt dużo LEFT JOIN-ów
• Użycie ORDER BY na kolumnie z JOIN
• Filtrowanie po meta_value bez indeksu

Optymalizacja struktury bazy danych dla produktów

Optymalna struktura bazy danych to fundament szybkich zapytań produktów.

Indeksy dla produktów

Kluczowe indeksy dla WooCommerce:

-- Indeksy dla produktów
CREATE INDEX idx_posts_type_status ON wp_posts (post_type, post_status);
CREATE INDEX idx_posts_type_date ON wp_posts (post_type, post_date);
CREATE INDEX idx_posts_parent ON wp_posts (post_parent);

-- Indeksy dla relacji taxonomii
CREATE INDEX idx_term_relationships_object_id ON wp_term_relationships (object_id);
CREATE INDEX idx_term_relationships_taxonomy ON wp_term_taxonomy (taxonomy, term_id);
CREATE INDEX idx_term_taxonomy_count ON wp_term_taxonomy (count DESC);

-- Indeksy dla meta produktów
CREATE INDEX idx_postmeta_post_id ON wp_postmeta (post_id);
CREATE INDEX idx_postmeta_meta_key ON wp_postmeta (meta_key);
CREATE INDEX idx_postmeta_meta_value ON wp_postmeta (meta_value(50));

-- Indeksy dla zamówień
CREATE INDEX idx_posts_order_status ON wp_posts (post_type, post_status, post_date);
CREATE INDEX idx_order_items_order_id ON wp_woocommerce_order_items (order_id);

Denormalizacja danych produktów

Denormalizacja dla szybszych zapytań:

-- Tabela z denormalizowanymi danymi produktów
CREATE TABLE wp_wc_product_cache (
    product_id BIGINT PRIMARY KEY,
    price DECIMAL(10,2),
    regular_price DECIMAL(10,2),
    sale_price DECIMAL(10,2),
    stock_quantity INT,
    stock_status VARCHAR(20),
    average_rating DECIMAL(3,2),
    review_count INT,
    category_ids TEXT,
    tag_ids TEXT,
    attribute_data TEXT,
    last_updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    
    INDEX idx_price (price),
    INDEX idx_stock_status (stock_status),
    INDEX idx_rating (average_rating),
    INDEX idx_last_updated (last_updated)
);

Optymalizacja struktury meta

Ulepszona struktura dla meta produktów:

-- Tabela z zoptymalizowanymi meta dla produktów
CREATE TABLE wp_wc_product_meta_lookup (
    product_id BIGINT PRIMARY KEY,
    min_price DECIMAL(10,2),
    max_price DECIMAL(10,2),
    onsale TINYINT(1),
    stock_status VARCHAR(20),
    featured TINYINT(1),
    rating_count INT,
    average_rating DECIMAL(3,2),
    total_sales INT,
    
    INDEX idx_min_price (min_price),
    INDEX idx_max_price (max_price),
    INDEX idx_onsale (onsale),
    INDEX idx_stock_status (stock_status),
    INDEX idx_featured (featured),
    INDEX idx_rating_count (rating_count),
    INDEX idx_average_rating (average_rating),
    INDEX idx_total_sales (total_sales)
);

Partycjonowanie tabel

Partycjonowanie dla bardzo dużych sklepów:

-- Partycjonowanie tabeli zamówień po dacie
ALTER TABLE wp_posts 
PARTITION BY RANGE (YEAR(post_date)) (
    PARTITION p2023 VALUES LESS THAN (2024),
    PARTITION p2024 VALUES LESS THAN (2025),
    PARTITION p2025 VALUES LESS THAN (2026),
    PARTITION p_future VALUES LESS THAN MAXVALUE
);

Implementacja zaawansowanych mechanizmów cache

Cache to jedno z najskuteczniejszych rozwiązań dla dużych sklepów WooCommerce.

Cache zapytań produktów

Implementacja cache dla wyników zapytań:

class ProductQueryCache {
    private $cache_group = 'wc_product_queries';
    private $cache_time = 300; // 5 minut
    
    public function get_cached_query($query_hash, $callback) {
        $cached = wp_cache_get($query_hash, $this->cache_group);
        
        if ($cached !== false) {
            return $cached;
        }
        
        // Wykonaj zapytanie
        $result = call_user_func($callback);
        
        // Zapisz w cache
        wp_cache_set($query_hash, $result, $this->cache_group, $this->cache_time);
        
        return $result;
    }
    
    public function invalidate_category_cache($category_id) {
        // Usuń cache dla kategorii
        $cache_keys = $this->get_category_cache_keys($category_id);
        
        foreach ($cache_keys as $key) {
            wp_cache_delete($key, $this->cache_group);
        }
    }
}

Object Cache dla produktów

Użycie Redis lub Memcached:

class ProductObjectCache {
    private $redis;
    
    public function __construct() {
        $this->redis = new Redis();
        $this->redis->connect('127.0.0.1', 6379);
    }
    
    public function get_product($product_id) {
        $cache_key = "product:{$product_id}";
        $cached = $this->redis->get($cache_key);
        
        if ($cached) {
            return unserialize($cached);
        }
        
        // Pobierz z bazy
        $product = $this->get_product_from_db($product_id);
        
        // Zapisz w Redis
        $this->redis->setex($cache_key, 3600, serialize($product));
        
        return $product;
    }
    
    public function update_product_cache($product_id, $data) {
        $cache_key = "product:{$product_id}";
        $this->redis->setex($cache_key, 3600, serialize($data));
    }
}

Cache wyników filtrowania

Cache dla popularnych kombinacji filtrów:

class FilterCache {
    public function get_filtered_products($filters) {
        $cache_key = $this->generate_filter_key($filters);
        
        $cached = wp_cache_get($cache_key, 'product_filters');
        
        if ($cached !== false) {
            return $cached;
        }
        
        // Wykonaj filtrowanie
        $results = $this->apply_filters($filters);
        
        // Cache wyników
        wp_cache_set($cache_key, $results, 'product_filters', 600); // 10 minut
        
        return $results;
    }
    
    private function generate_filter_key($filters) {
        ksort($filters);
        return 'filter_' . md5(serialize($filters));
    }
}

Używanie indeksów dla przyspieszenia zapytań

Indeksy to fundament szybkich zapytań do bazy danych.

Analiza istniejących indeksów

-- Sprawdź istniejące indeksy
SHOW INDEXES FROM wp_posts;
SHOW INDEXES FROM wp_postmeta;
SHOW INDEXES FROM wp_term_relationships;

-- Sprawdź użycie indeksów w zapytaniach
EXPLAIN SELECT * FROM wp_posts WHERE post_type = 'product' AND post_status = 'publish';

Indeksy dla popularnych zapytań

-- Indeksy dla zapytań produktów
CREATE INDEX idx_products_main ON wp_posts (post_type, post_status, post_date, ID);

-- Indeksy dla cen
CREATE INDEX idx_price_lookup ON wp_postmeta (meta_key, meta_value(10), post_id);

-- Indeksy dla stanu magazynowego
CREATE INDEX idx_stock_lookup ON wp_postmeta (meta_key, meta_value, post_id);

-- Indeksy dla relacji produktów
CREATE INDEX idx_term_rel_composite ON wp_term_relationships (object_id, term_taxonomy_id);

Indeksy FULLTEXT dla wyszukiwania

-- Indeks FULLTEXT dla wyszukiwania produktów
ALTER TABLE wp_posts ADD FULLTEXT ft_products (post_title, post_content, post_excerpt);

-- Przykładowe zapytanie z FULLTEXT
SELECT p.*, 
       MATCH(post_title, post_content) AGAINST ('szukany produkt' IN NATURAL LANGUAGE MODE) as relevance
FROM wp_posts p
WHERE p.post_type = 'product'
AND MATCH(post_title, post_content) AGAINST ('szukany produkt' IN NATURAL LANGUAGE MODE)
ORDER BY relevance DESC;

Monitorowanie efektywności indeksów

-- Sprawdź nieużywane indeksy
SELECT 
    TABLE_SCHEMA,
    TABLE_NAME,
    INDEX_NAME,
    CARDINALITY
FROM information_schema.STATISTICS
WHERE TABLE_SCHEMA = 'twoja_baza'
AND TABLE_NAME LIKE 'wp_%'
ORDER BY TABLE_NAME, INDEX_NAME;

-- Sprawdź często używane indeksy
SELECT 
    OBJECT_NAME(i.object_id) AS TableName,
    i.name AS IndexName,
    i.index_id,
    dm_ius.user_seeks,
    dm_ius.user_scans,
    dm_ius.user_lookups
FROM sys.dm_db_index_usage_stats dm_ius
INNER JOIN sys.indexes i
    ON dm_ius.object_id = i.object_id
    AND dm_ius.index_id = i.index_id
WHERE dm_ius.database_id = DB_ID('twoja_baza')
AND OBJECTPROPERTY(i.object_id,'IsUserTable') = 1
ORDER BY dm_ius.user_seeks DESC;

Redukcja liczby zapytań na stronach produktów

Redukcja liczby zapytań to klucz do szybkiego działania sklepu.

Łączenie zapytań

Techniki łączenia wielu zapytań w jedno:

class QueryOptimizer {
    public function get_products_with_data($product_ids) {
        global $wpdb;
        
        $placeholders = implode(',', array_fill(0, count($product_ids), '%d'));
        
        // Pojedyncze zapytanie zamiast wielu
        $query = $wpdb->prepare("
            SELECT 
                p.ID,
                p.post_title,
                p.post_content,
                pm.meta_key,
                pm.meta_value
            FROM {$wpdb->posts} p
            LEFT JOIN {$wpdb->postmeta} pm ON p.ID = pm.post_id
            WHERE p.ID IN ($placeholders)
            AND p.post_type = 'product'
            AND p.post_status = 'publish'
        ", $product_ids);
        
        $results = $wpdb->get_results($query);
        
        return $this->group_results_by_product($results);
    }
    
    private function group_results_by_product($results) {
        $grouped = [];
        
        foreach ($results as $row) {
            if (!isset($grouped[$row->ID])) {
                $grouped[$row->ID] = [
                    'ID' => $row->ID,
                    'title' => $row->post_title,
                    'content' => $row->post_content,
                    'meta' => []
                ];
            }
            
            if ($row->meta_key) {
                $grouped[$row->ID]['meta'][$row->meta_key] = $row->meta_value;
            }
        }
        
        return array_values($grouped);
    }
}

Cache relacji produktów

Cache dla relacji między produktami:

class ProductRelationsCache {
    public function get_related_products($product_id) {
        $cache_key = "related_products_{$product_id}";
        
        $related = wp_cache_get($cache_key, 'product_relations');
        
        if ($related === false) {
            $related = $this->calculate_related_products($product_id);
            
            wp_cache_set($cache_key, $related, 'product_relations', 1800); // 30 minut
        }
        
        return $related;
    }
    
    private function calculate_related_products($product_id) {
        global $wpdb;
        
        // Zapytanie o produkty z tych samych kategorii i tagów
        $query = $wpdb->prepare("
            SELECT DISTINCT p.ID
            FROM {$wpdb->posts} p
            INNER JOIN {$wpdb->term_relationships} tr ON p.ID = tr.object_id
            INNER JOIN {$wpdb->term_taxonomy} tt ON tr.term_taxonomy_id = tt.term_taxonomy_id
            WHERE p.ID != %d
            AND p.post_type = 'product'
            AND p.post_status = 'publish'
            AND tt.term_taxonomy_id IN (
                SELECT tr2.term_taxonomy_id
                FROM {$wpdb->term_relationships} tr2
                WHERE tr2.object_id = %d
            )
            LIMIT 4
        ", $product_id, $product_id);
        
        return $wpdb->get_col($query);
    }
}

Optymalizacja ładowania miniatur

Ładowanie miniatur w jednym zapytaniu:

class ProductImagesOptimizer {
    public function get_products_with_images($product_ids) {
        global $wpdb;
        
        $placeholders = implode(',', array_fill(0, count($product_ids), '%d'));
        
        // Zapytanie łączące produkty z ich miniaturami
        $query = $wpdb->prepare("
            SELECT 
                p.ID as product_id,
                p.post_title,
                pm.meta_value as featured_image_id,
                pi.guid as image_url,
                pi.post_mime_type
            FROM {$wpdb->posts} p
            LEFT JOIN {$wpdb->postmeta} pm ON p.ID = pm.post_id AND pm.meta_key = '_thumbnail_id'
            LEFT JOIN {$wpdb->posts} pi ON pm.meta_value = pi.ID
            WHERE p.ID IN ($placeholders)
            AND p.post_type = 'product'
            AND p.post_status = 'publish'
        ", $product_ids);
        
        return $wpdb->get_results($query);
    }
}

Optymalizacja zapytań dla wariantów i atrybutów

Warianty produktów to jedno z największych wyzwań wydajnościowych.

Optymalizacja zapytań wariantów

class ProductVariationsOptimizer {
    public function get_product_variations_with_pricing($product_id) {
        global $wpdb;
        
        // Zoptymalizowane zapytanie dla wariantów
        $query = $wpdb->prepare("
            SELECT 
                v.ID as variation_id,
                v.post_title as variation_title,
                pm_price.meta_value as price,
                pm_regular_price.meta_value as regular_price,
                pm_sale_price.meta_value as sale_price,
                pm_stock.meta_value as stock_quantity,
                pm_stock_status.meta_value as stock_status
            FROM {$wpdb->posts} v
            LEFT JOIN {$wpdb->postmeta} pm_price ON v.ID = pm_price.post_id AND pm_price.meta_key = '_price'
            LEFT JOIN {$wpdb->postmeta} pm_regular_price ON v.ID = pm_regular_price.post_id AND pm_regular_price.meta_key = '_regular_price'
            LEFT JOIN {$wpdb->postmeta} pm_sale_price ON v.ID = pm_sale_price.post_id AND pm_sale_price.meta_key = '_sale_price'
            LEFT JOIN {$wpdb->postmeta} pm_stock ON v.ID = pm_stock.post_id AND pm_stock.meta_key = '_stock'
            LEFT JOIN {$wpdb->postmeta} pm_stock_status ON v.ID = pm_stock_status.post_id AND pm_stock_status.meta_key = '_stock_status'
            WHERE v.post_type = 'product_variation'
            AND v.post_status = 'publish'
            AND v.post_parent = %d
            ORDER BY CAST(pm_price.meta_value AS DECIMAL(10,2))
        ", $product_id);
        
        return $wpdb->get_results($query);
    }
}

Cache atrybutów produktów

class ProductAttributesCache {
    public function get_product_attributes($product_id) {
        $cache_key = "product_attributes_{$product_id}";
        
        $attributes = wp_cache_get($cache_key, 'product_data');
        
        if ($attributes === false) {
            $attributes = $this->load_attributes_from_db($product_id);
            
            wp_cache_set($cache_key, $attributes, 'product_data', 3600);
        }
        
        return $attributes;
    }
    
    private function load_attributes_from_db($product_id) {
        $product = wc_get_product($product_id);
        
        if (!$product) {
            return [];
        }
        
        $attributes = [];
        
        // Pobierz atrybuty globalne
        foreach ($product->get_attributes() as $attribute) {
            if ($attribute->is_taxonomy()) {
                $terms = wp_get_post_terms($product_id, $attribute->get_name());
                $attributes[$attribute->get_name()] = wp_list_pluck($terms, 'slug');
            } else {
                $attributes[$attribute->get_name()] = $attribute->get_options();
            }
        }
        
        return $attributes;
    }
}

Indeksy dla wariantów

-- Indeksy dla wariantów produktów
CREATE INDEX idx_variations_parent_status ON wp_posts (post_parent, post_status, post_type, ID);
CREATE INDEX idx_variations_price ON wp_postmeta (post_id, meta_key, meta_value) WHERE meta_key IN ('_price', '_regular_price', '_sale_price');
CREATE INDEX idx_variations_stock ON wp_postmeta (post_id, meta_key, meta_value) WHERE meta_key IN ('_stock', '_stock_status');

Implementacja lazy loading dla danych produktów

Lazy loading znacząco zmniejsza liczbę początkowych zapytań.

Lazy loading opisów produktów

class LazyProductLoading {
    public function init() {
        add_action('wp_ajax_load_product_description', [$this, 'load_description']);
        add_action('wp_ajax_nopriv_load_product_description', [$this, 'load_description']);
    }
    
    public function load_description() {
        $product_id = $_POST['product_id'];
        
        if (!wp_verify_nonce($_POST['nonce'], 'load_description')) {
            wp_die('Invalid nonce');
        }
        
        $product = wc_get_product($product_id);
        
        if (!$product) {
            wp_die('Product not found');
        }
        
        $description = $product->get_description();
        
        wp_send_json_success([
            'description' => $description,
            'product_id' => $product_id
        ]);
    }
}

Lazy loading opinii o produktach

class LazyReviewsLoading {
    public function load_product_reviews() {
        $product_id = $_POST['product_id'];
        $page = $_POST['page'] ?? 1;
        
        $args = [
            'post_id' => $product_id,
            'status' => 'approve',
            'number' => 5,
            'paged' => $page,
            'meta_query' => [
                [
                    'key' => 'rating',
                    'value' => [1, 2, 3, 4, 5],
                    'compare' => 'IN'
                ]
            ]
        ];
        
        $comments = get_comments($args);
        
        $html = '';
        foreach ($comments as $comment) {
            $rating = get_comment_meta($comment->comment_ID, 'rating', true);
            $html .= $this->render_review($comment, $rating);
        }
        
        wp_send_json_success([
            'html' => $html,
            'has_more' => count($comments) === 5
        ]);
    }
    
    private function render_review($comment, $rating) {
        return "
        

            
" . str_repeat('★', $rating) . "
            
{$comment->comment_content}
        
        ";
    }
}

Lazy loading powiązanych produktów

class LazyRelatedProducts {
    public function load_related_products() {
        $product_id = $_POST['product_id'];
        $limit = $_POST['limit'] ?? 8;
        
        $related = wc_get_related_products($product_id, $limit);
        
        $products_data = [];
        foreach ($related as $related_id) {
            $product = wc_get_product($related_id);
            
            if ($product) {
                $products_data[] = [
                    'id' => $product->get_id(),
                    'name' => $product->get_name(),
                    'price' => $product->get_price_html(),
                    'image' => wp_get_attachment_image_src($product->get_image_id(), 'woocommerce_thumbnail')[0],
                    'url' => $product->get_permalink()
                ];
            }
        }
        
        wp_send_json_success([
            'products' => $products_data
        ]);
    }
}

Monitorowanie wydajności zapytań produktów

Stałe monitorowanie to klucz do utrzymania optymalnej wydajności.

Monitorowanie zapytań SQL

class QueryPerformanceMonitor {
    private $slow_query_threshold = 1.0; // 1 sekunda
    
    public function init() {
        add_action('shutdown', [$this, 'log_slow_queries']);
    }
    
    public function log_slow_queries() {
        global $wpdb;
        
        $slow_queries = [];
        
        foreach ($wpdb->queries as $query) {
            $sql = $query[0];
            $time = $query[1];
            
            if ($time > $this->slow_query_threshold) {
                $slow_queries[] = [
                    'query' => $sql,
                    'time' => $time,
                    'backtrace' => debug_backtrace()
                ];
            }
        }
        
        if (!empty($slow_queries)) {
            $this->save_slow_queries($slow_queries);
        }
    }
    
    private function save_slow_queries($queries) {
        $log_file = WP_CONTENT_DIR . '/slow-queries.log';
        
        foreach ($queries as $query) {
            $log_entry = sprintf(
                "[%s] Slow Query (%.3f sec):\n%s\n\n",
                date('Y-m-d H:i:s'),
                $query['time'],
                $query['query']
            );
            
            error_log($log_entry, 3, $log_file);
        }
    }
}

Monitorowanie cache hit ratio

class CachePerformanceMonitor {
    public function get_cache_stats() {
        $stats = [
            'object_cache_enabled' => wp_using_ext_object_cache(),
            'cache_hits' => wp_cache_get_stats()['hits'] ?? 0,
            'cache_misses' => wp_cache_get_stats()['misses'] ?? 0,
            'memory_usage' => memory_get_usage(true),
            'memory_peak' => memory_get_peak_usage(true)
        ];
        
        $stats['hit_ratio'] = ($stats['cache_hits'] + $stats['cache_misses']) > 0 
            ? $stats['cache_hits'] / ($stats['cache_hits'] + $stats['cache_misses']) 
            : 0;
        
        return $stats;
    }
    
    public function log_cache_performance() {
        $stats = $this->get_cache_stats();
        
        error_log(sprintf(
            'Cache Performance: Hit Ratio: %.2f%%, Memory: %.2fMB/%.2fMB',
            $stats['hit_ratio'] * 100,
            $stats['memory_usage'] / 1024 / 1024,
            $stats['memory_peak'] / 1024 / 1024
        ));
    }
}

Dashboard wydajności

class PerformanceDashboard {
    public function render_dashboard() {
        $monitor = new QueryPerformanceMonitor();
        $cache_monitor = new CachePerformanceMonitor();
        
        $stats = [
            'queries_count' => get_num_queries(),
            'page_load_time' => timer_stop(0),
            'cache_stats' => $cache_monitor->get_cache_stats(),
            'memory_usage' => memory_get_usage(true),
            'memory_peak' => memory_get_peak_usage(true)
        ];
        
        echo '
';
        echo '
Performance Stats
';
        echo '
';
        echo '
Queries: ' . $stats['queries_count'] . '
';
        echo '
Load Time: ' . $stats['page_load_time'] . 's
';
        echo '
Memory Usage: ' . round($stats['memory_usage'] / 1024 / 1024, 2) . 'MB
';
        echo '
Cache Hit Ratio: ' . round($stats['cache_stats']['hit_ratio'] * 100, 2) . '%
';
        echo '
';
        echo '
';
    }
}

Podsumowanie – Wpływ optymalizacji na konwersje i UX

Optymalizacja zapytań produktów to inwestycja w wydajność i przychody sklepu.

Kluczowe techniki optymalizacji:

1. Optymalizacja bazy danych

• Indeksy na kluczowych kolumnach
• Denormalizacja często używanych danych
• Optymalna struktura tabel
• Partycjonowanie dla bardzo dużych tabel

2. Zaawansowany cache

• Object cache (Redis/Memcached)
• Cache wyników zapytań
• Cache relacji produktów
• Cache filtrowania

3. Optymalizacja zapytań

• Łączenie wielu zapytań w jedno
• Unikanie zbędnych JOIN-ów
• Używanie odpowiednich indeksów
• Lazy loading danych

4. Monitorowanie i analiza

• Stałe monitorowanie wydajności
• Analiza powolnych zapytań
• Statystyki cache hit ratio
• Dashboard wydajności

Korzyści z optymalizacji:

Techniczne:

• Szybsze ładowanie stron produktów
• Mniejsze obciążenie serwera baz danych
• Lepsza skalowalność sklepu
• Stabilniejsza praca w szczytach ruchu

Biznesowe:

• Wyższe konwersje (każda sekunda = -7% konwersji)
• Lepsze SEO (szybsze strony = lepsze pozycje)
• Zadowoleni klienci (szybki dostęp do produktów)
• Mniejsze koszty infrastruktury (efektywniejsze zapytania)

Najlepsze praktyki:

• Regularna analiza: Monitoruj wydajność co najmniej raz w miesiącu
• Testowanie zmian: Zawsze testuj optymalizacje na środowisku staging
• Cache invalidation: Implementuj inteligentne unieważnianie cache
• Skalowanie: Planuj optymalizację z myślą o wzroście sklepu
• Zespół: Zaangażuj administratora bazy danych do optymalizacji

Optymalizacja zapytań produktów to proces ciągły, który wymaga regularnego monitorowania i dostosowywania do zmieniających się potrzeb sklepu. Prawidłowione zastosowanie prezentowanych technik może przyspieszyć Twój sklep nawet o 300%, co przełoży się na wyższe konwersje i zadowolenie klientów.