PennyDreadfulMTG / perf-reports

2 stars 2 forks source link

Exceeded slow_query limit (179.2 > 60.0) in mysql: ``` #58804

Open vorpal-buildbot opened 2 years ago

vorpal-buildbot commented 2 years ago
    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 179.2, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (172.6 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 172.6, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (217.0 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 217.0, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (154.9 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 154.9, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (224.9 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 224.9, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (158.7 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 158.7, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (160.1 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 160.1, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (195.1 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 195.1, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (164.1 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 164.1, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (218.5 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 218.5, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (294.1 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 294.1, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (185.1 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 185.1, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (183.5 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 183.5, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (180.0 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 180.0, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (182.8 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 182.8, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (175.4 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 175.4, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (198.4 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 198.4, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (184.7 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 184.7, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (163.2 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 163.2, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (161.3 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 161.3, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (176.9 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 176.9, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (167.0 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 167.0, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (139.7 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 139.7, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (261.6 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 261.6, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (149.8 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 149.8, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (150.3 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 150.3, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (224.7 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 224.7, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (159.3 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 159.3, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (153.2 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 153.2, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (241.8 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 241.8, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (171.2 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 171.2, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (212.1 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 212.1, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (147.4 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 147.4, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (139.5 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 139.5, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (147.2 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 147.2, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (216.6 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 216.6, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (150.7 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 150.7, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (161.9 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 161.9, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (195.9 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 195.9, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (162.1 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 162.1, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (153.3 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 153.3, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (176.6 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 176.6, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (218.9 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 218.9, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (191.4 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 191.4, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (234.7 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 234.7, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (206.8 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 206.8, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (316.9 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 316.9, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (202.2 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 202.2, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (151.2 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 151.2, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (174.2 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 174.2, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite

vorpal-buildbot commented 2 years ago

Exceeded slow_query limit (177.9 > 60.0) in mysql: ```

    CREATE TABLE IF NOT EXISTS _new_card_person_stats (
        name VARCHAR(190) NOT NULL,
        season_id INT NOT NULL,
        person_id INT NOT NULL,
        wins INT NOT NULL,
        losses INT NOT NULL,
        draws INT NOT NULL,
        perfect_runs INT NOT NULL,
        tournament_wins INT NOT NULL,
        tournament_top8s INT NOT NULL,
        deck_type ENUM('league', 'tournament', 'other') NOT NULL,
        PRIMARY KEY (season_id, person_id, name, deck_type),
        FOREIGN KEY (season_id) REFERENCES season (id) ON UPDATE CASCADE ON DELETE CASCADE,
        FOREIGN KEY (person_id) REFERENCES person (id)  ON UPDATE CASCADE ON DELETE CASCADE,
        INDEX idx_person_id_name (person_id, name)
    ) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci AS
    SELECT
        card AS name,
        season.season_id,
        d.person_id,
        SUM(CASE WHEN d.id IS NOT NULL THEN 1 ELSE 0 END) AS num_decks,
        IFNULL(SUM(dsum.wins), 0) AS wins,
        IFNULL(SUM(dsum.losses), 0) AS losses,
        IFNULL(SUM(dsum.draws), 0) AS draws,
        SUM(CASE WHEN dsum.wins >= 5 AND dsum.losses = 0 AND d.source_id IN (SELECT id FROM source WHERE name = 'League') THEN 1 ELSE 0 END) AS perfect_runs,
        SUM(CASE WHEN dsum.finish = 1 THEN 1 ELSE 0 END) AS tournament_wins,
        SUM(CASE WHEN dsum.finish <= 8 THEN 1 ELSE 0 END) AS tournament_top8s,
        (CASE WHEN ct.name = 'League' THEN 'league' WHEN ct.name = 'Gatherling' THEN 'tournament' ELSE 'other' END) AS deck_type
    FROM
        deck AS d
    INNER JOIN
        -- Eliminate maindeck/sideboard double-counting with DISTINCT. See #5493.
        (SELECT DISTINCT card, deck_id FROM deck_card) AS dc ON d.id = dc.deck_id

    LEFT JOIN
        competition AS c ON d.competition_id = c.id
    LEFT JOIN
        competition_series AS cs ON cs.id = c.competition_series_id
    LEFT JOIN
        competition_type AS ct ON ct.id = cs.competition_type_id

    LEFT JOIN deck_cache AS season ON d.id = season.deck_id

    LEFT JOIN
        (
            SELECT
                d.id,
                d.created_date,
                d.finish,
                SUM(CASE WHEN dm.games > IFNULL(odm.games, 0) THEN 1 ELSE 0 END) AS wins, -- IFNULL so we still count byes as wins.
                SUM(CASE WHEN dm.games < odm.games THEN 1 ELSE 0 END) AS losses,
                SUM(CASE WHEN dm.games = odm.games THEN 1 ELSE 0 END) AS draws
            FROM
                deck_match AS dm
            INNER JOIN
                deck_match AS odm ON dm.match_id = odm.match_id AND dm.deck_id <> odm.deck_id
            INNER JOIN
                deck AS d ON d.id = dm.deck_id
            GROUP BY
                d.id
        ) AS dsum ON d.id = dsum.id

    GROUP BY
        card,
        d.person_id,
        season.season_id,
        ct.name
```

[] (slow_query, 177.9, mysql)

Reported on decksite by mysql-perf

Location Hash: 69a4302ff184b4104128cd1ead1193723a956a48

Labels: decksite