left join возвращает null, даже если нет строк

Мои таблицы:

Таблица cat имеет id, name

Table user имеет id, uname, catid

Примеры данных:
cat table

1 | Cate one
2 | cate two

user table

1 | sam | 1
2 | dam | 0

мой запрос

SELECT cat.id, cat.name 
FROM cat LEFT JOIN user 
  ON cat.id = user.catid
WHERE user.id = 2

Поскольку нет категории с id 0 I получить ноль строк.

В нашем списке мест, которые мы хотим периодически читать, также указывается, как часто мы хотим их читать. Разрешено читать значение чаще, чем указано, но не реже.

Одна операция чтения может считывать непрерывную последовательность ячеек из массива, поэтому можно вернуть группу из нескольких значений из одной операции чтения . Максимальное количество смежных местоположений, которые могут быть прочитаны за одну операцию, равно M.

Цель состоит в том, чтобы сгруппировать местоположения так, чтобы минимизировать усредненное по времени количество операций чтения. В том случае, если есть более одного способа сделать это, решающим фактором является минимизация усредненного по времени количества считываемых местоположений.

(Бонусные баллы начисляются, если алгоритм для этого допускает постепенные изменения в списке локаций - т.е. добавление или удаление одного местоположения в / из списка не требует пересчета групп с нуля!)

Я попытаюсь прояснить это с помощью некоторых примеров, где M = 6.

На следующей диаграмме показан массив локаций. Числа представляют желаемый период чтения для этого местоположения.

| 1 | 1 |   |   | 1 |   |   |   |   |   | 5 |   | 2 |
\-------------------/                   \-----------/
     group A                               group B

В этом первом примере группа A считывается каждую секунду, а группа B - каждые 2 секунды. Обратите внимание, что местоположение, которое следует читать каждые 5 секунд, на самом деле считывается каждые 2 секунды - и это нормально.

| 1 |   |   |   |   | 1 | 1 |   | 1 |
\-----------------------/\----------/
         group A            group B         (non-optimal!)

Этот пример показывает сбой моего первоначального простодушного алгоритма, который должен был заполнить первую группу до полного заполнения, а затем начать другой. Следующая группировка является более оптимальной, потому что, хотя количество групповых операций чтения в секунду одинаково, количество считываемых местоположений в этих группах меньше:

| 1 |   |   |   |   | 1 | 1 |   | 1 |
\---/               \---------------/
group A                  group B            (optimal)

Наконец, пример, где три группы лучше, чем две:

| 5 |   |   |   |   | 1 | 1 |   |   |   |   | 5 |
\-----------------------/\----------------------/
        group A                  group B    (non-optimal)

Это решение требует двух групповых чтений в секунду. Лучшее решение выглядит следующим образом:

| 5 |   |   |   |   | 1 | 1 |   |   |   |   | 5 |
\---/               \-------/               \---/
group A              group B               group C

Для этого требуется два чтения каждые 5 секунд (группы A и C) плюс одно чтение каждую секунду (группа B): 1,4 чтения группы в секунду.

Изменить: (Есть еще лучшее решение в этом примере, если вы разрешаете считывания быть непериодическими. На 1-й секунде считайте обе группы первого решения. На 2-й, 3-й, 4-й и 5-й секундах считайте группу B второго решения. Повторите. В результате получится группа 1,2 чтения в секунду. Но я собираюсь запретить это, потому что это значительно усложнит код, отвечающий за планирование операций чтения.)

Я просмотрел алгоритмы кластеризации, но это не проблема кластеризации. Я также нашел алгоритм распределения списка номеров по N группам при определенных условиях , что указывало на проблему «упаковки мусорного ведра», но я не думаю, что это и есть она.

Кстати, извините за расплывчатое название. Я не могу придумать краткого описания или даже релевантных ключевых слов для поиска!

Новые примеры добавлены 28 сентября 2010 г .:

Это похоже на предыдущий пример, но все элементы обновляются с одинаковой скоростью. Две группы лучше, чем три:

| 1 |   |   |   |   | 1 | 1 |   |   |   |   | 1 |
\-----------------------/\----------------------/
        group A                  group B          (optimal)

Я начал пытаться понять, как можно реализовать итерационные улучшения. Предположим, был предложен алгоритм группирования:

| 1 |   |   |   |   | 1 | 1 |   |   |   |   | 1 | 1 |   |   |   |   | 1 |
\---/               \-------/               \-------/               \---/
group A              group B                 group C               group D  (non-optimal)
\-----------------------/\----------------------/\----------------------/
        group A                  group B                  group C           (optimal)

Его можно улучшить до трех смежных групп по 6. Рекс предложил (комментарий ниже), что я мог бы попробовать объединить триплеты в пары. Но в этом случае мне пришлось бы объединить квартет в триплет, потому что не существует законной промежуточной договоренности, в которой A + B + C (или B + C + D) можно было бы преобразовать в пару, оставив D как есть.

Первоначально я думал, что это показатель того, что в общем случае нет гарантии, что новое действительное решение может быть создано из существующего действительного решения путем внесения локальной модификации. Это означало бы, что такие алгоритмы, как имитация отжига, генетические алгоритмы и т. Д., Могут быть использованы для попытки усовершенствовать субоптимальное решение.

Но Рекс указал (комментарий ниже), что вы всегда можете разделить существующую группу на две. Несмотря на то, что это всегда увеличивает функцию стоимости, все это означает, что решение должно выйти за пределы своего локального минимума, чтобы достичь глобального минимума.