小编Maj*_*jiy的帖子

我遇到了一个mysql查询的奇怪性能问题.

SELECT
`pricemaster_products`.*,
`products`.*
FROM `pricemaster_products`
LEFT JOIN `products`
ON `pricemaster_products`.`ean` = `products`.`products_ean`

我明确地想要使用左连接.但是查询需要花费更多的时间.

我试图将连接更改为INNER JOIN.查询现在非常快,但结果不是我需要的.

我使用了解释并得出以下结论:

如果我使用"LEFT JOIN",那么查询的EXPLAIN会导致......

type: "ALL"
possible_keys: NULL
key: NULL
key_len: NULL
ref: NULL
rows: 90.000 / 50.000 (the full number of the corresponding table)

......对于两张桌子.

如果我使用"INNER JOIN",那么EXPLAIN会给出:

对于表"产品":

Same result as above.

对于表"pricemaster_products":

type: "ref"
possible_keys: "ean"
key: ean
key_len: 767
ref: func
rows: 1
extra: using where

两个表都在相关列上设置了索引.我想到LEFT JOIN如此缓慢的唯一可能原因是根本不使用索引.但为什么不呢？

表结构如下:

CREATE TABLE IF NOT EXISTS `pricemaster_products` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `provider` …

我有两个php类:TestUK和TestFR,它扩展了TestUK.

这两个类都用于生成对两个不同域的请求.但是继承权出了问题,我不明白为什么.

我有一个名为"get_domain"的方法,它被覆盖以获取实际应该使用的域.如果我直接通过它TestFR::get_domain(),我会收到预期的结果.但是,如果我调用一个未被TestFR覆盖但使用的方法,则会self::get_domain()收到错误的域名.

如果我只是将方法do_stuff从TestUK复制并粘贴到TestFR,那么我得到了预期的结果.但复制粘贴相同(!)代码正是我试图避免的.

这是什么原因？我在PHP中没有那么多类继承的经验,但我希望这可以毫无问题地工作.或者我的approch完全有缺陷？

<?php
class TestUK {

    const DOMAIN_UK = 'http://www.domain.co.uk';
    const DOMAIN_FR = 'http://www.domain.fr';

    static function get_domain(){
        return self::DOMAIN_UK;
    }

    static function do_stuff(){
        echo self::get_domain();
    }

}

class TestFR extends TestUK {

    static function get_domain(){
        return self::DOMAIN_FR;
    }

}

// Works as intended:
// Expected and actual output: http://www.domain.fr
echo TestFR::get_domain();

// Does NOT work as intendes:
// Expected Output: http://www.domain.fr
// Actual Output:   http://www.domain.co.uk
TestFR::do_stuff();
?>

给定一个名为“ orders_products”的mySQL表，其中包含以下相关字段：

• products_id
• orders_id

两个字段都被索引。

我正在运行以下查询：

SELECT products_id, count( products_id ) AS counter
FROM orders_products
WHERE orders_id
IN (
  SELECT DISTINCT orders_id
  FROM orders_products
  WHERE products_id = 85094
)
AND products_id != 85094
GROUP BY products_id
ORDER BY counter DESC
LIMIT 4

该查询耗时极长，大约20秒。否则数据库不是很忙，并且在其他查询上表现良好。

我想知道，是什么原因导致查询如此缓慢？

该表相当大（大约150万行，大小约为210 mb），这可能是内存问题吗？

有没有一种方法可以确切说明花费了这么长时间的mySQL？

解释输出：

id  select_type     table   type    possible_keys   key     key_len     ref     rows    Extra
1   PRIMARY     orders_products     range   products_id     products_id     4   NULL    1577863     Using where; Using temporary; Using filesort
2   DEPENDENT SUBQUERY  orders_products     ref     orders_id,products_id   products_id …

我在第三方代码中看到了一个声明为static的变量,但在任何类之外,只是在"普通"函数中.

<?php
function doStuff(){
    static $something = null;
}
?>

我从未见过static用这种方式,我在PHP文档中找不到任何东西.

这是合法的PHP代码吗？这实际上与全局变量相同吗？如果没有,目的是什么？

在使用关系数据库的第三方软件(mssql,但此问题不限于此特定数据库)中,我看到了以下构造:

有几个表具有整数主键,它们不会自动递增.相反,当前最高的主键(每个表)存储在另一个表中.该表只包含两列:tableName和currentPrimaryKey.

只要在其中一个表中插入新行,就会使用存储过程来锁定主键表,获取下一个要使用的主键,并再次解锁主键表.

我的问题是:与简单地使用自动增量主键相比,这种结构有什么优势吗？

给出以下(非常简化的)mysql表结构:

制品

• ID

产品类别

• ID
• PRODUCT_ID
• 状态(整数)

product_tags

• ID
• PRODUCT_ID
• some_other_numeric_value

我试图找到与某个product_tag有关联的每个产品,并且至少有一个与status-attribute为1的类别的关系.

我尝试了以下查询:

SELECT *

FROM `product` p

JOIN `product_categories` pc
ON p.`product_id` = pc.`product_id`

JOIN `product_tags` pt
ON p.`product_id` = pt.`product_id`

WHERE pt.`some_value` = 'some comparison value'

GROUP BY p.`product_id`

HAVING SUM( pc.`status` ) > 0

ORDER BY SUM( pt.`some_other_numeric_value` ) DESC

现在我的问题是:SUM(pt.some_other_numeric_value)返回意外值.

我意识到,如果有问题的产品有更多然后一个关系到product_categories表,然后每相对于product_tags表计为许多计时因为有关系的product_categories表!

例如:如果id = 1的产品与具有ids = 2,3和4的product_categories的关系,以及与具有ID 5和6的product_tags的关系 - 那么如果我插入a GROUP_CONCAT(pt.id),那么它确实给出了5,6,5 ,6,5,6而不是预期的5,6.

起初我怀疑它是与连接类型(左连接,右连接,内连接,等等)的一个问题,所以我想尽连接类型,我知道的,但无济于事.我还试图在GROUP …

我有两个 SQL 表，“产品”和“标签”。它们具有 n:m 关系，使用第三个表“product_tags”。

我想使用查询来查找具有多个特定标签的每个产品。例如，查找与标签 1、23 和 54 相关的所有产品。

有没有办法只用一个查询来做到这一点？