Rsa97

Как-то так:

SELECT DISTINCT `a`.`attribute_id`, `a`.`text`
  FROM (
    SELECT DISTINCT `p`.`id`
      FROM `product` AS `p`
      JOIN `product_category` AS `c` ON `c`.`product_id` = `p`.`id` 
        AND `c`.`category_id` = :categoryId
      JOIN `product_attribute` AS `a1` ON `a1`.`product_id` = `p`.`id`
        AND `a1`.`attribute_id` = :attribute1 AND `a1`.`text` = :attrValue1
      JOIN `product_attribute` AS `a2` ON `a2`.`product_id` = `p`.`id`
        AND `a2`.`attribute_id` = :attribute2 AND `a2`.`text` = :attrValue2
      ...
      JOIN `product_attribute` AS `aN` ON `aN`.`product_id` = `p`.`id`
        AND `aN`.`attribute_id` = :attributeN AND `aN`.`text` = :attrValueN
  ) AS `pr`
  JOIN `product_attribute` AS `a` ON `a`.`product_id` = `p`.`id`
  WHERE `a`.`attribute_id` NOT IN (:attribute1, :attribute2,... attributeN)
  ORDER BY `a`.`attribute_id, `a`.`text`

SELECT `t`.* 
    FROM (
        SELECT DATE(MAX(`created`)) AS `date`
            FROM `table`
    ) AS `d`
    JOIN `table` AS `t` ON `t`.`created` >= `d`.`date`

Для MySQL будет как-то так:

SELECT `client_id`
    FROM (
        SELECT `client_id`, `country_id`
            FROM `orders`
            GROUP BY `client_id`, `country_id`
            HAVING COUNT(*) > 1
    ) AS `t1`
    GROUP BY `client_id`
    HAVING COUNT(*) > 1

В MSSQL принцип будет тем же, но могут быть свои особенности.

Для создания ключа в таблице `payment_types` должны существовать записи со всеми `id`, соответствующими всем имеющимся `payments`.`type_id`.

SELECT `u1`.`name`, `u2`.`name`, COUNT(*) AS `count`
    FROM `users_groups` AS `ug1` 
    JOIN `users_groups` AS `ug2` 
        ON `ug2`.`group_id` = `ug1`.`group_id`
            AND `ug2`.`user_id` > `ug1`.`user_id`
    JOIN `users` AS `u1`
        ON `u1`.`id` = `ug1`.`user_id`
    JOIN `users` AS `u2`
        ON `u2`.`id` = `ug2`.`user_id`
    GROUP BY `ug1`.`user_id`, `ug2`.`user_id`
    ORDER BY `count` DESC
    LIMIT 1

SELECT `p`.`title`, GROUP_CONCAT(`t`.`tag` SEPARATOR ',')
    FROM `page_tag` AS `pt`
    JOIN `tag` AS `t` ON `t`.`id` = `pt`.`tag_id`
    JOIN `pages` AS `p` ON `p`.`id` = `pt`.`page_id`
    GROUP BY `p`.`id`

Если пара (iPageID, iCityID) уникальная, то

SELECT * 
    FROM (
        SELECT `iPageID`
            FROM `page_city`
            WHERE `iCityID` IN (101, 102)
            GROUP BY `iPageID`
            HAVING COUNT(*) = 2
    ) AS `t1`
    JOIN (
        SELECT `iPageID`
            FROM `page_city`
            GROUP BY `iPageID`
            HAVING COUNT(*) = 2
    ) AS `t2` USING (`iPageID`)

(Поправил, сначала второе условие не заметил).

Стандартный алгоритм для интервалов:
Пусть на каждый случай большего рейтинга противника приходится два случая равного и три случая меньшего.
Больший: 1
Равный: 2
Меньший: 3
Просуммируем, 1+2+3 = 6.

Найдём граничные значения:
Больший: [0, (0+1)] = [0, 1)
Равный: [1, 1+2) = [1, 3)
Меньший: [3, 3+3) = [3, 6)

Генерируем случайное число X от 0 до 6.
Если X < 1, то выбираем противника с большим рейтингом
Иначе если X < 3, то выбираем противника с равным рейтингом
Иначе выбираем противника с равным рейтингом

Если id_product уникальные (PRIMARY KEY или UNIQUE)

INSERT INTO `table_price` (`id_product`, `price`) 
    VALUES (22, 22), (33, 33), ...
    ON DUPLICATE KEY UPDATE `price` = VALUES(`price`)