Порождающий запрос

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

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

ВЫБРАТЬ 0 КАК Х
ПОМЕСТИТЬ Регистр1
ОБЪЕДИНИТЬ
ВЫБРАТЬ 1
;
////////////////////////////////////////////////////////////////////////////////
ВЫБРАТЬ Младшие.Х + 2 * Старшие.Х КАК Х
ПОМЕСТИТЬ Регистр2
ИЗ Регистр1 КАК Младшие, Регистр1 КАК Старшие
;
////////////////////////////////////////////////////////////////////////////////
ВЫБРАТЬ Младшие.Х + 4 * Старшие.Х КАК Х
ПОМЕСТИТЬ Регистр4
ИЗ Регистр2 КАК Младшие, Регистр2 КАК Старшие
;
////////////////////////////////////////////////////////////////////////////////
ВЫБРАТЬ Младшие.Х + 16 * Старшие.Х КАК Х
ПОМЕСТИТЬ Регистр8
ИЗ Регистр4 КАК Младшие, Регистр4 КАК Старшие
;
///////////////////////////////////////////////////////////////////////////////
ВЫБРАТЬ Младшие.Х + 256 * Старшие.Х КАК Х
ПОМЕСТИТЬ Регистр16
ИЗ Регистр8 КАК Младшие, Регистр8 КАК Старшие
;
////////////////////////////////////////////////////////////////////////////////
ВЫБРАТЬ Младшие.Х + 65536 * Старшие.Х КАК Х
ПОМЕСТИТЬ Регистр20
ИЗ Регистр16 КАК Младшие, Регистр4 КАК Старшие

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

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

Текст и его длина передаются в запрос как параметры. Для примера считаем, что длина текста ограничена миллионом символов. Вот текст концовки этого запроса. 

////////////////////////////////////////////////////////////////////////////////
ВЫБРАТЬ ПОДСТРОКА(&Текст, Х, 1) Символ, КОЛИЧЕСТВО(Х) КАК Частота
ИЗ Регистр20
ГДЕ Х МЕЖДУ 1 И &ДлинаТекста
СГРУППИРОВАТЬ ПО ПОДСТРОКА(&Текст, Х, 1)

Его начало такое же как на предыдущем рисунке. Интересно то, что этот метод работает быстрее, чем обработка в оперативной памяти. И сразу дает табличный результат! Например, первый мегабайт романа "Война и мир" обрабатывается в памяти 8,2 сек, а запросом - 4 секунды!

Очевидно, что запрос совсем простой. Проявив некоторую изобретательность, можно построить запрос разбора текста на слова и запросы для решения других задач обработки текста. Аналогично можно строить таблицы вхождений одно, двух, трех и т.п. символов в наименования, артикулы и пр. для ускорения подбора (вместо методов с использованием "подобно").

Определение частоты слов запросом оказалось совсем не тривиальной задачей. Вот решение:

////////////////////////////////////////////////////////////////////////////////
ВЫБРАТЬ Младшие.Х + 256 * 256 * Средние.Х + 256 * 256 * 2 * Старшие.Х КАК Х
ПОМЕСТИТЬ Регистр21
ИЗ Регистр16 КАК Младшие, Регистр4 КАК Средние, Регистр1 КАК Старшие
;
////////////////////////////////////////////////////////////////////////////////
ВЫБРАТЬ Х КАК У
ПОМЕСТИТЬ Разделители
ИЗ Регистр21
ГДЕ (НЕ ПОДСТРОКА(&Текст, Х, 1) ПОДОБНО "[а-я]") И Х МЕЖДУ 1 И &ДлинаТекста
;
////////////////////////////////////////////////////////////////////////////////
ВЫБРАТЬ Х, ВЫБОР КОГДА Х = 0 ТОГДА ИСТИНА КОНЕЦ КАК Нулевой, ВЫБОР КОГДА Х > 0 ТОГДА Х КОНЕЦ КАК Длина
ПОМЕСТИТЬ Интервалы
ИЗ Регистр4
;
////////////////////////////////////////////////////////////////////////////////
ВЫБРАТЬ У - Х КАК Начало, МИНИМУМ(Длина) КАК Длина
ПОМЕСТИТЬ УказателиСлов
ИЗ Разделители, Интервалы
СГРУППИРОВАТЬ ПО У - Х
ИМЕЮЩИЕ МАКСИМУМ(Нулевой) = ИСТИНА И МИНИМУМ(Длина) > 1
;
////////////////////////////////////////////////////////////////////////////////
ВЫБРАТЬ ПОДСТРОКА(ПОДСТРОКА(&Текст, Начало + 1, Длина - 1), 1, 15) КАК Слово, КОЛИЧЕСТВО(Начало) КАК Частота
ИЗ УказателиСлов
СГРУППИРОВАТЬ ПО ПОДСТРОКА(ПОДСТРОКА(&Текст, Начало + 1, Длина - 1), 1, 15)

К статье прилагается файл отчета, содержащий этот запрос. С его помощью в тексте первой части "Войны и мира" была определена частота слов за 24 секунды! А это примерно 1,5 миллиона символов! Правда, если использовать "кодинг", на чистом 1С можно решить ту же задачу примерно в два раза быстрее.

В качестве неочевидного применения предложенного запроса приводится пример расчета в запросе квадратного корня от числа в диапазоне 0 - 1 048 576. Вернее, целой части этого корня.

////////// создается таблица с числами от 0 до 1024 ////////////////////////////
ВЫБРАТЬ 0 КАК Х ПОМЕСТИТЬ Регистр1 ОБЪЕДИНИТЬ ВЫБРАТЬ 1
;
ВЫБРАТЬ Младшие.Х + 2 * Старшие.Х КАК Х ПОМЕСТИТЬ Регистр2
ИЗ  Регистр1 КАК Младшие,   Регистр1 КАК Старшие
;
ВЫБРАТЬ Младшие.Х + 4 * Старшие.Х КАК Х ПОМЕСТИТЬ Регистр4
ИЗ  Регистр2 КАК Младшие, Регистр2 КАК Старшие
;
ВЫБРАТЬ Младшие.Х + 16 * Старшие.Х КАК Х ПОМЕСТИТЬ Регистр8
ИЗ  Регистр4 КАК Младшие, Регистр4 КАК Старшие
;
ВЫБРАТЬ Младшие.Х + 256 * Старшие.Х КАК Х ПОМЕСТИТЬ Регистр10
ИЗ  Регистр8 КАК Младшие, Регистр2 КАК Старшие
;
////////// для проверки создается таблица с различными значениями аргумента ////
ВЫБРАТЬ 123456 КАК У ПОМЕСТИТЬ Аргументы
ОБЪЕДИНИТЬ ВЫБРАТЬ 555555
ОБЪЕДИНИТЬ ВЫБРАТЬ 987654
;
////////// формируется таблица, содержащая аргумент и значение функции /////////
ВЫБРАТЬ У, МАКСИМУМ(Х) КАК Квадратный_корень_Х
ИЗ Аргументы ЛЕВОЕ СОЕДИНЕНИЕ Регистр10 ПО (Х * Х < У)
СГРУППИРОВАТЬ ПО У

 Аналогичным или похожим путем можно рассчитать и другие обратные функции. 

Похожим приемом в запросе можно получить "таблицу хаоса" - таблицу, которая содержит случайные числа. Например, следующая функция возвращает таблицу с заданным числом строк, содержащую случайные числа, равномерно распределенные в диапазоне 0 - 1.

function ChaosTable(N, Name = "СлучайноеЧисло") export

g = new RandomNumberGenerator();

q = new Query("select &r1 as r into t1 union select &r2;

             | select &k * a.r + b.r - cast((&k * a.r + b.r) / &M - 0.5 as number(10,0)) * &M as r into t2 from t1 as a, t1 as b;

             | select &k * a.r + b.r - cast((&k * a.r + b.r) / &M - 0.5 as number(10,0)) * &M as r into t4 from t2 as a, t2 as b;

             | select &k * a.r + b.r - cast((&k * a.r + b.r) / &M - 0.5 as number(10,0)) * &M as r into t8 from t4 as a, t4 as b;

             | select &k * a.r + b.r - cast((&k * a.r + b.r) / &M - 0.5 as number(10,0)) * &M as r into t16 from t8 as a, t8 as b;

             | select top " + Format(N, "NG=") + "

             | (&k * a.r + b.r) / &M - cast((&k * a.r + b.r) / &M - 0.5 as number(10,0)) as " + Name + " from t16 as a, t4 as b");

q.SetParameter("r1", g.RandomNumber()); q.SetParameter("r2", g.RandomNumber());

q.SetParameter("k", 1664525); q.SetParameter("M", 4294967295);

return q.Execute().Unload()

endfunction

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

Конечно, для использования в ответственных применениях потребуется проверка результата тестами NIST. Также было бы интересно исследовать использование для решения той же задачи метода Блюма-Блюма-Шуба. Запись запроса при этом будет еще короче.

Для удобства применения предложенного подхода на практике предлагается функция, которая формирует ТЕКСТ ЗАПРОСА или фрагмент пакетного запроса, выполнение которого приводит к получению временной таблицы, содержащей натуральный ряд чисел заданного размера. Вот текст этой функции

function ProtoText(N, M = 1000000000) export

    return ?(N > 2

    , ProtoText(M - Int(M - Sqrt(N)))

    + strreplace(strreplace(";select top #2 a.X * #1 + b.X X into r#2 from r#1 a, r#1 b; drop r#1", "#2", format(N, "NG=")), "#1", format(M - Int(M - Sqrt(N)), "NG="))

    , "select 0 X into r2 union select 1")

endfunction

Функция рекурсивная, параметр M - служебный (используется для сокращения записи функции). Результирующая временная таблица имеет имя r{ЗаданныйРазмер}.