Реализация грида для работы с большими таблицами. Часть 114.03.2016 11:33

Таблица (грид) с вертикальной полосой прокрутки — наиболее распространённый элемент пользовательского интерфейса для работы с данными реляционной БД. Однако известны сложности, с которыми приходится сталкиваться, когда таблица содержит так много записей, что тактика их полной вычитки и сохранения в оперативной памяти становится неразумной.

Какие-то приложения на большие таблицы не рассчитаны и «зависают» при попытке открыть на просмотр/редактирование таблицу с миллионами записей. Иные отказываются от использования грида с вертикальной полосой прокрутки в пользу постраничного отображения или предлагают пользователю лишь иллюзию, что при помощи полосы прокрутки можно быстро перейти к нужной (хотя бы к самой последней) записи.

Мы расскажем об одном из возможных методов реализации табличного элемента управления, обладающего свойствами Log (N)-быстрого 1) первоначального отображения 2) прокрутки на всём диапазоне записей 3) перехода к записи с заданным уникальным ключом. Всё это — при двух ограничениях: 1) записи могут быть отсортированы только по индексированному набору полей и 2) collation-правила базы данных должны быть известны алгоритму.

Изложенные в статье принципы были реализованы автором в проекте с его участием на языке Java.

Основной принцип

Двумя ключевыми функциональными возможностями табличного элемента управления (грида) являются

прокрутка — отображение записей, соответствующих положению бегунка полосы прокрутки,
переход к записи, заданной по комбинации ключевых полей.

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

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

Другой подход заключается в «перекладывании» вычислений на СУБД: выборку записей для отображения в окне прокрутки осуществлять при помощи конструкций вида select… limit… offset …, позиционирование — сводить к select… и count (*). Однако и offset, и count (*) связаны с перебором записей внутри сервера, они имеют в общем случае скорость выполнения O (N), и потому неэффективны при большом числе записей. Частый их вызов приводит к перегрузке сервера БД.

Итак, нам нужно реализовать систему, которая не требовала бы полной закачки данных в память и при этом не перегружала бы сервер неэффективно выполняющимися запросами. Для этого поймём, какие запросы являются эффективными, а какие — нет.

При условии, что по полю k построен индекс, быстрыми являются следующие запросы (они используют index lookup и выполняются за время Log (N)):

Запрос A. Найти первую и последнюю запись в наборе данныx:
```
select ... order by k [desc] limit 1
```
Запрос B. Найти h первых записей с ключом, большим или равным данному значению K:
```
select ... order by k where k >= K limit h
```

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

Не являются быстрыми следующие запросы:

Запрос C Подсчитать общее количество записей в наборе данных:
```
select count(*) ...
```
Запрос D. Подсчитать число записей, предшествующих записи с ключом, большим или равным данному:
```
select count(*) ... where key < K
```

Запросы B и D можно обобщить на случай сортировки по набору из нескольких полей order by k1, k2, k3… при условии, что на этих полях построен составной индекс. Условие k >= K должно быть обобщено на логическое условие сравнения нескольких значений в лексикографическом порядке:

where k1 >=  K1 and (k1 > K1 or (k2 >= K_2  and (k2 > K2 or ...)))

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

«Угадывание» зависимости первичного ключа от номера записи

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

Пусть каждому положению бегунка полосы прокрутки соответствует целое число от 0 до $%5Cinline%20N-h$ , где $%5Cinline%20N$ — общее число записей в таблице, $%5Cinline%20h$ — число строк, умещающихся на одной странице в гриде. Если бегунок полосы прокрутки выставлен в положение $%5Cinline%20%5Clambda$ , то это означает, что при отрисовке грида необходимо пропустить $%5Cinline%20%5Clambda$ первых записей в таблице, а затем вывести $%5Cinline%20h$ записей. Это как раз то, за что отвечают ключевые слова offset и limit в PostgreSQL, и при большом числе записей мы не можем ими пользоваться. Но если бы некоторым «волшебным» образом мы бы могли за быстрое время уметь вычислять функцию $%5Cinline%20%5Clambda%3Df%28k%29$ и обратную ей функцию $%5Cinline%20k%3Df%5E%7B-1%7D%28%5Clambda$ , связывающую первичный ключ и число записей с ключом, меньшим данного, то тогда при помощи запроса B, подставляя туда значение $%5Cinline%20f%5E%7B-1%7D%28%5Clambda%29$ , мы могли бы быстро получать набор записей для отображения пользователю. Задача перехода к нужной записи решалась бы таким образом: т. к. первичный ключ заранее известен, его сразу можно использовать в качестве параметра быстрого запроса B, а полосу прокрутки следовало бы установить в положение $%5Cinline%20%5Clambda%3Df%28k%29$ . Поставленная задача была бы решена!

(Заметим, что запрос D, вызываемый с параметром k, как раз возвращает значение $%5Cinlinef%28k%29$ , но 1) он медленный и 2) нам нужно уметь вычислять как $%5Cinlinef%28k%29$ , так и обратную ей.)

Естественно, функция $%5Cinline%20f$ целиком определяется данными в таблице, поэтому, чтобы точно восстановить взаимозависимость значений ключа и номера записи, необходимо прочесть из базы в оперативную память все ключи через одного: для корректного срабатывания запроса B в промежуточных точках можно считать, что $%5Cinline%20f%5E%7B-1%7D%282n%2B1%29%20%$ (вспомним замечательное свойство запроса B). Это уже лучше, чем запоминать все подряд ключи, но всё ещё недостаточно хорошо, т. к. требует O (N) времени и оперативной памяти для первоначального отображения таблицы. К счастью, можно обойтись гораздо меньшим значением точно известных точек для функции $%5Cinline%20f$ , и чтобы понять это, нам потребуется небольшой комбинаторный анализ возможных значений $%5Cinline%20f$ .

Пусть мы выполнили запрос

select min(k), max(k), count(*) from foo

и получили результаты: 0, 60, 7. Т. е. теперь мы знаем, что в нашей таблице всего 7 записей (и значит, максимальное значение $%5Cinline%20%5Clambda$ равно 6), первая из записей имеет ключ 0, а последняя — ключ 60. Одним таким запросом мы фактически узнали значения $%5Cinline%20f$ в трёх точках: $%5Cinline%20f%280%29%20%3D%200$ , $%5Cinline%20f%281%29%20%3D%201$ и $%5Cinline%20f%2860%29%3D6$ . И это ещё не всё, ведь из самого определения $%5Cinline%20f$ следует, что:

$%5Cinline%20f%28k%29$ монотонно растёт,
при увеличении $%5Cinline%20k$ на единицу, $%5Cinline%20%5Clambda$ увеличивается на единицу или не увеличивается, поэтому график функции $%5Cinline%20f$ , кроме точки $%5Cinline%20%28k_%7B%5Cmin%7D%2C%200%29$ , целиком лежит в параллелограмме $%5Cinline%20%28k_%7B%5Cmin%7D%20%2B%201%$ , $%5Cinline%20%28k_%7B%5Cmin%7D%2B%5Clambd$ , $%5Cinline%20%28k_%7B%5Cmax%7D%2C%20%5Cla$ , $%5Cinline%20%28k_%7B%5Cmax%7D%20-%20%5Cl$ ,
общее число возможных функций $%5Cinline%20f$ равно числу способов распределения $%5Cinline%20%5Clambda_%7B%5Cmax%7D%20-%2$ записей по $%5Cinline%20k_%7B%5Cmax%7D%20-%20k_%7B%5$ значениям ключа (позиции первой и последней записи фиксированы), т. е.
$%20%5Clabel%7Beq%3Atotalfuncnum%7DF%20%3$
число возможных функций $%5Cinline%20f$ , которые в точке $%5Cinline%20k$ принимают значение $%5Cinline%20%5Clambda$ , определяется произведением количества комбинаций записей с ключом, меньшим $%5Cinline%20k$ , и большим или равным $%5Cinline%20k$ :
$F_%7Bk%2C%5Clambda%7D%3D%5Cbinom%7Bk%20-$

Таким образом, если каждый из возможных вариантов считать равновероятным, то вероятность того, что для заданного значения $inline_formula$ имеется ровно $inline_formula$ записей с ключом, строго меньшим $inline_formula$ , задаётся отношением $inline_formula$ , известным как гипергеометрическое распределение. Для $inline_formula$ , $inline_formula$ картина выглядит вот таким образом:

Свойства гипергеометрического распределения хорошо известны. В случае $inline_formula$ всегда $inline_formula$ , а на отрезке $inline_formula$ среднее значение $inline_formula$ линейно зависит от k:

$%0A%5Coverline%7B%5Clambda%7D%20%3D%20%5$

Дисперсия значения $%5Cinline%20%5Clambda$ имеет форму перевернутой параболы с нулями на краях отрезка $%5Cinline%20%28k_%7B%5Cmin%7D%20%2B%201%$ и максимумом посередине

некрасивая формула

$%0AD_%5Clambda%20%3D%20%5Cfrac%7B%28%5Cl$

(Грубо можно считать, что средняя ошибка меньше, чем $inline_formula$ .)

Расчёт значений по вышеприведённым формулам для $%5Cinline%20k_%7B%5Cmax%7D%3D60$ , $%5Cinline%20%5Clambda_%7B%5Cmax%7D%3D6$ показывает такую картину для возможных минимальных и максимальных (красные линии), среднего (голубая линия) значений $%5Cinline%20f$ , а также границ среднеквадратичного отклонения (серая область):

Итак, ломаная, построенная между точками $%5Cinline%20%28k_%7B%5Cmin%7D%2C%200%29$ , $%5Cinline%20%28k_%7B%5Cmin%7D%20%2B%201%$ , и $%5Cinline%20%28k_%7B%5Cmax%7D%2C%20%5Cla$ является статистически обоснованным приближением для вычисления функции $%5Cinline%20f$ и обратной $%5Cinline%20f%5E%7B-1%7D$ , и это приближение даёт нам возможность довольно точно «угадать» значения функции даже если всё, что мы о ней знаем — это её значения в трёх точках, полученные при помощи одного запроса. По сути, мы для «угадывания» выполняем первую итерацию алгоритма интерполяционного поиска, только аккуратно определив граничные значения.

Если теперь для какого-то $%5Cinline%20k%27$ , $%5Cinline%20k_%7B%5Cmin%7D%20%3C%20k%27%$ станет известно новое точное значение $%5Cinline%200%20%3C%20%5Clambda%27%20%3C$ , мы можем добавить пару $%5Cinline%20%28k%27%2C%20%5Clambda%27%29$ к интерполяционной таблице и при помощи кусочной интерполяции получить уточнённый расчёт значения $%5Cinline%20k%28%5Clambda%29$ для решения задачи прокрутки, а применяя обратную кусочную интерполяцию, вычислять уточнённое значение $%5Cinline%20%5Clambda%28k%29$ при решении задачи позиционирования. С каждой накопленной точкой дипазон возможных расхождений будет сужаться, и мы будем получать всё более и более точную картину для функции $%5Cinline%20f$ .

Если ключевых полей несколько и типы данных не INT

На практике дело не ограничивается единственным целочисленным полем для сортировки набора данных. Во-первых, тип данных может быть другим: строка, дата и прочее. Во-вторых, сортируемых полей может быть несколько. Это затруднение устраняется, если мы умеем вычислять

функцию-нумератор $inline_formula$ , переводящую набор значений полей произвольных типов в натуральное число,
обратную ей функцию $inline_formula$ , переводящую натуральное число обратно в набор значений полей, $inline_formula$ .

Функция-нумератор должна обладать тем свойством, что если набор $inline_formula$ меньше набора $inline_formula$ в смысле лексикографического порядка, то должно быть $%5Cinline%20g%28K_1%2C%5Cldots%20K_n%29%$ .

Говоря языком математики, биекция $inline_formula$ должна устанавливать изоморфизм порядка между множеством возможных значений наборов полей и множеством натуральных чисел. Заметим: для того, чтобы задача поиска подходящей $inline_formula$ была математически разрешима, важно, чтобы множества возможных значений полей $inline_formula$ были конечными. К примеру, между множеством всех лексикографически упорядоченных пар натуральных (пар действительных) чисел и множеством натуральных (действительных) чисел невозможно построить изоморфизм порядка. Разумеется, множество всех возможных значений любого машинного типа данных является конечным, хотя и очень большим.

Для представления значений $inline_formula$ не подходят стандартные 32- и 64-битовые целочисленные типы: так, чтобы перенумеровать одни лишь всевозможные 10-байтовые строки, уже не хватит 64-битового (8-байтового) целого. В своей реализации мы использовали класс java.math.BigInteger, способный представлять целые числа произвольной величины. При этом объём оперативной памяти, занимаемой значением $inline_formula$ , примерно равен объёму, занимаемому набором значений $%5Cinline%20K_1%2C%5Cldots%20K_n$ .

При наличии обратимой функции-нумератора $inline_formula$ и обратимой функции-интерполятора $inline_formula$ ,

Схема взаимодействия процедур

На этом этапе мы можем отвлечься от математики и разобраться собственно с алгоритмической частью. Общая схема взаимодействия процедур системы показана на рисунке ниже. Использована «приблизительная UML Activity» нотация, при этом сплошной стрелкой показана последовательность выполнения процедур, а пунктирной стрелкой — асинхронный вызов в отдельном потоке выполнения:

Допустим, что пользователь изменил положение бегунка вертикальной полосы прокрутки (см. в левый нижний угол диаграммы). Интерполятор вычисляет значение номера комбинации значений ключевых полей ( $%5Cinline%20%5Ckappa%3Df%5E%7B-1%7D%28%5$ ) с типом BigInteger. На основе этого значения нумератор восстанавливает комбинацию ключевых полей $%5Cinline%20%28K_1%2C%5Cldots%20K_n%29%3$ .

Здесь важно понимать, что на данном этапе в полях $%5Cinline%20K_1%2C%5Cldots%20K_n$ не обязательно будут находиться значения, действительно присутствующие в базе данных: там будут лишь приближения. В строковых полях, например, будет бессмысленный набор символов. Тем не менее, благодаря замечательному свойству запроса B, вывод из базы данных $%5Cinline%20h$ строк с ключами, большими или равными набору $%5Cinline%20K_1%2C%5Cldots%20K_n$ , окажется приблизительно верным результатом для данного положения полосы прокрутки.

Если пользователь отпустил полосу прокрутки и какое-то время не трогал её, асинхронно (в отдельном потоке выполнения) запускается запрос D, определяющий порядковый номер записи, а значит, и точное положение полосы прокрутки, которое соответствует тому, что отображено пользователю. Когда запрос будет завершён, на основе полученных данных будет пополнена интерполяционная таблица. Если к этому моменту пользователь не начал снова прокручивать таблицу, вертикальный бегунок «отскочит» на новое, уточнённое положение.

При переходе к записи последовательность вызовов процедур происходит в обратную сторону. Т. к. значения ключевых полей уже известны, для пользователя запросом B сразу извлекаются данные из базы. Нумератор вычисляет $%5Cinline%20%5Ckappa%20%20%3D%20g%28K_1%$ , и затем интерполятор определяет приблизительное положение полосы прокрутки как $%5Cinline%20%5Clambda%20%3D%20f%28%5Ckap$ . Параллельно, в асинхронном потоке выполнения, выполняется уточняющий запрос, по результатам которого в интерполяционную таблицу добавляется новая точка. Через секунду-другую бегунок полосы прокрутки «отскочит» на новое, уточнённое положение.

Чем больше пользователь будет «бродить» по данным вертикальным бегунком, тем больше точек будет собираться в интерполяционной таблице и тем меньше будут «отскоки». Практика показывает, что достаточно всего 4–5 удачных точек в интерполяционной таблице, чтобы «отскоки» стали очень малы.

Экземпляр класса-интерполятора должен хранить в себе промежуточные точки монотонно растущей функции между множеством 32-битных целых чисел (номеров записей в таблице) и множеством объектов типа BigInteger (порядковых номеров комбинаций значений ключевых полей).

Сразу же после инициализации грида необходимо в отдельном потоке выполнения запросить общее количество записей в таблице, чтобы получить корректное значение $%5Cinline%20%5Clambda_%7B%5Cmax%7D$ . До того момента, как это значение будет получено при помощи выполняющегося в параллельном потоке запроса, можно использовать некоторое значение по умолчанию (например, 1000) — это не повлияет на корректность работы.

Интерполятор должен уметь за быстрое по количеству интерполяционных точек время вычислять значение как в одну, так и в другую сторону. Однако заметим, что чаще требуется вычислять значение порядкового номера комбинации по номеру записи: такие вычисления производятся много раз за секунду в процессе прокрутки грида пользователем. Поэтому за основу реализации модуля интерполятора удобно взять словарь на основе бинарного дерева, ключами которого являются номера записей, а значениями — порядковые номера комбинаций (класс TreeMap в языке Java).

Ясно, что по заданному номеру $%5Cinline%20%5Clambda$ такой словарь за логарифмическое время находит две точки ( $%5Cinline%20%5Cunderline%7B%5Clambda%7D%$ ), между которыми строит прямую интерполяцию функции $%5Cinline%20f$ . Но тот факт, что $%5Cinline%20f$ растёт монотонно, позволяет за быстрое время производить и обратное вычисление. В самом деле: если дан номер комбинации $%5Cinline%20%5Ckappa$ , $%5Cinline%20%5Ckappa_%7B%5Cmin%7D%20%5Cl$ , поиск кусочного сегмента, в котором лежит $%5Cinline%20%5Ckappa$ , можно произвести в словаре методом дихотомии. Отыскав нужный сегмент, мы производим обратную интерполяцию $%5Cinline%20f$ и находим номер $%5Cinline%20%5Clambda$ , соответствующий $%5Cinline%20%5Ckappa$ .

При пополнении словаря интерполяционными точками необходимо следить за тем, чтобы интерполируемая функция оставалась монотонной. Так как другие пользователи могут удалять и добавлять записи в просматриваемую таблицу, актуальность известных словарю интерполяционных точек может утратиться, а вновь добавляемая точка может нарушить монотонность. Поэтому метод добавления новой интерполяционной точки должен проверять, что «точке слева» от только что добавленной соответствует меньшее, а «точке справа» — большее значение. Если оказывается, что это не так, следует исходить из предположения, что последняя добавленная точка соответствует актуальному положению вещей, а некоторые из старых точек утратили свою актуальность. По отношению к вновь добавленной точке следует удалять все точки слева, содержащие большее значение, и все точки справа, содержащие меньшее значение. Процесс «срезания выбивающейся точки» показан на рисунке:

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

Заключение к первой части

Итак, мы разобрались, как в целом устроена наша система: основными её частями являются интерполятор и нумератор, а также полностью обсудили реализацию интерполятора. Чтобы завершить решение задачи, необходимо теперь реализовать нумератор — биекцию $inline_formula$ , увязывающую наборы значений ключевых полей, возможно, состоящих из дат, строки, отсортированных при помощи Unicode collation rules и т. п. с растущими в том же порядке числами.

Этому будет посвящена вторая часть статьи.

Ещё я готовлю научную публикацию, и вы можете также ознакомиться с препринтом научной версии этой статьи на arxiv.org.