标签: query-performance

有没有更快的方法来执行这个最简单的服务器负载查询？我不认为我曾尝试过除此方法之外的任何其他方法:

$sql = 'SELECT thing FROM table WHERE id="' . $id . '" ';
$res = mysql_query($sql);
$row = mysql_fetch_array($res);
$thing = $row[0];

有什么方法可以改善吗？

我有以下数据库架构:

table courses:
id
tutor_id
title



table course_categories:
    id
    category_id
    course_id

table categories:
    id
    name

table tutors:
    id
    name

table subscribers:
    id
    course_id
    user_id

我需要制作1个sql来获得所有类别的课程,以及该课程的导师和该课程的订阅者数量.这可以在1个查询中完成吗？应该使用存储过程吗？

我有512行要插入数据库.我想知道在一个大插件上提交多个插件是否有任何优势.例如

1x 512行插入 -

INSERT INTO mydb.mytable (id, phonenumber)
VALUES (1, 555-555-5555) , (2, 555-555-5555) , (3, 555-555-5555), //repeat to id = 512

VS 4x 128行插入

INSERT INTO mydb.mytable (id, phonenumber)
VALUES (1, 555-555-5555) , (2, 555-555-5555) , (3, 555-555-5555), //repeat to id = 128
INSERT INTO mydb.mytable (id, phonenumber)
VALUES (129, 555-555-5555) , (130, 555-555-5555) , (131, 555-555-5555), //repeat to id = 256, then next 128, then next 128.

VS 512x 1行插入

INSERT INTO mydb.mytable (id, phonenumber)
VALUES (1, …

以下是一个需要30多秒才能运行的查询.根据我运行的类似查询,我无法看到保持在这里的位置.我唯一的想法是将作业用户ID加入job_applicants用户ID,但是需要对它们进行映射.

SELECT DISTINCT u.user_id, u.first_name, u.last_name FROM users u
LEFT OUTER JOIN employee_access ea ON ea.user_id = u.user_id
LEFT OUTER JOIN confirmation c ON c.user_id = u.user_id
LEFT OUTER JOIN job_applicants a ON a.user_id = u.user_id
LEFT OUTER JOIN job j ON j.job_id = a.job_id
WHERE ea.access_id = 4 OR c.access_id = 4 OR (a.process_level = 0 AND j.access_id = 4) 
ORDER BY u.last_name asc

根据文档：

使用 COUNT(*) 的 SELECT 表达式返回与查询匹配的行数。或者，您可以使用 COUNT(1) 来获得相同的结果。

使用后一种方法是否有任何性能优势（如在 RDBMS 中）？

举一个简单的例子,假设我有两个表

  T1                      T2
=======                 =======
  Val                     Val
=======                 =======
   1                       1
   2                       3
   4                       4
   5                       5
                           6

我想要的结果集是

2
3
6

因为那些是包含在一个而不是另一个中的数字.我知道可以用类似的东西来完成

WITH cte1 (Val) AS (
    SELECT Val
    FROM T1
    LEFT JOIN T2
    ON T1.Val = T2.Val
    WHERE Val IS NOT NULL
),
cte2 (Val) AS (
    SELECT Val
    FROM T2
    LEFT JOIN T1
    ON T1.Val = T2.Val
    WHERE Val IS NOT NULL
)
SELECT *
FROM cte1
UNION WITH cte2

但有更紧凑和/或更有效的方法吗？

我有一个包含数百万行的理论表:

Person table
ID             int
first_name     varchar(50)
last_name      varchar(50)
date_inserted  datetime
middle_name    varchar(50)
nick_name      varchar(50)
favorite_color varchar(50)
birth_date     datetime
last_edited    datetime

我的查询如下:

SELECT * FROM PERSON WHERE last_edited > subdate(now(), 2)

返回数万行.

该查询与运行之间是否存在任何重大的运行时差异

SELECT 
    ID, 
    first_name, 
    last_name, 
    date_inserted, 
    middle_name, 
    nick_name, 
    favorite_color, 
    birth_date, 
    last_edited 
FROM Person
    WHERE last_edited > subdate(now(), 2);

我正在尝试使用扩展来加速Postgres 中的一些文本匹配pg_trgm：

CREATE TABLE test3 (id bigint, key text, value text);

insert into test3 values (1, 'first 1', 'second 3');
insert into test3 values (2, 'first 1', 'second 2');
insert into test3 values (2, 'first 2', 'second 3');
insert into test3 values (3, 'first 1', 'second 2');
insert into test3 values (3, 'first 1', 'second 3');
insert into test3 values (4, 'first 2', 'second 3');
insert into test3 values (4, 'first 2', 'second 3');
insert into …

它们之间在性能或任何方面有什么区别吗？

$a = ['a' => 1, 'b' => 2, 'c' => 3];
$b = ['d' => 4, 'e' => 5, 'f' => 6];
$c = array_merge($a, $b);

VS

$a = [];
$a['a'] = 1;
$a['b'] = 2;
$a['c'] = 3;

$b = [];
$b['d'] = 4;
$b['e'] = 5;
$b['f'] = 6;
$c = array_merge($a, $b);

VS

$a = [];
$a = ['a' => 1, 'b' => 2, 'c' => 3];
$a['d'] = 4;
$a['e'] = 5;
$a['f'] = 6;

我想找到一种方法来改进查询，但似乎我已经完成了这一切。让我给你一些细节。

以下是我的查询：

SELECT 
    `u`.`id` AS `id`,
    `p`.`lastname` AS `lastname`,
    `p`.`firstname` AS `firstname`,
    COALESCE(`r`.`value`, 0) AS `rvalue`,
    SUM(`rat`.`category` = 'A') AS `count_a`,
    SUM(`rat`.`category` = 'B') AS `count_b`,
    SUM(`rat`.`category` = 'C') AS `count_c`
FROM
    `user` `u`
    JOIN `user_customer` `uc` ON (`u`.`id` = `uc`.`user_id`)
    JOIN `profile` `p` ON (`p`.`id` = `u`.`profile_id`)
    JOIN `ad` FORCE INDEX (fk_ad_customer_idx) ON (`uc`.`customer_id` = `ad`.`customer_id`)
    JOIN `ac` ON (`ac`.`id` = `ad`.`ac_id`)
    JOIN `a` ON (`a`.`id` = `ac`.`a_id`)
    JOIN `rat` ON (`rat`.`code` = `a`.`rat_code`)
    LEFT JOIN `r` ON (`r`.`id` …