СокрЛП() в запросе или что все-таки возможно получить с помощью запросов

21.12.15

Разработка - Запросы

Показано, как в запросе можно удалить конечные и начальные пробелы у строки произвольной длины.
Разбиение строки на слова, решето Эратосфена и еще несколько примеров использования запросов 1С.

Недавно понадобилось в запросе получить значение строковых кодов справочника без концевых пробелов. Как вы знаете, в языке запросов нет ничего похожего на функцию СокрЛП(), как же быть?

Можно, конечно, предварительно выполнить вспомогательный запрос, выгрузить его в таблицу значений, перебрать ее в цикле выполняя СокрЛП(), и затем передать обратно в нужный запрос в виде параметра (создать временную таблицу).

Или, если максимальная длина строки, как в случае кода справочника, фиксирована можно написать в запросе громоздкую конструкцию из вложенных конструкций ВЫБОР КОГДА...

Но это неинтересно. Благо на глаза попалась статья ildarovich-а //infostart.ru/public/90367/. Оказалось, что с помощью временой таблицы с числами 0,1,2,3... можно получить много нетривиальных вещей в запросах.

Далее несколько примеров.

Сначала удаление начальных и конечных пробелов, аналог функции СокрЛП(). Заодно мы попутно получаем длину обрезанных строк.

Идея очень простая: ищем первый пробельный символ после которого идет не пробел (учитываем, что первый же символ может быть не пробелом) и последний не пробел после которого идет пробел.

Дополнительно тут используется, что выражение ПОДСТРОКА(СтрокаСПробелами, ЗначениеБольшеДлиныСтроки, 1) возвращает пустую строку, а при сравнении cтандарт SQL говорит, что строки, отличающиеся незначащими символами в хвосте не различаются. В языке запросов 1С сравнение происходит точно так-же. Т.е. для запроса "" = " ".

// Вспомогательный порождающий запрос
ВЫБРАТЬ 0 КАК Х ПОМЕСТИТЬ Регистр1 ОБЪЕДИНИТЬ ВЫБРАТЬ 1;
ВЫБРАТЬ Младшие.Х + 2 * Старшие.Х КАК Х ПОМЕСТИТЬ Регистр2
ИЗ Регистр1 КАК Старшие, Регистр1 КАК Младшие;
ВЫБРАТЬ Младшие.Х + 4 * Старшие.Х КАК Х ПОМЕСТИТЬ Регистр4
ИЗ Регистр2 КАК Старшие, Регистр2 КАК Младшие;
ВЫБРАТЬ Младшие.Х + 16 * Старшие.Х КАК Х ПОМЕСТИТЬ Регистр8
ИЗ Регистр4 КАК Старшие, Регистр4 КАК Младшие;
ВЫБРАТЬ Младшие.Х + 256 * Старшие.Х КАК Х ПОМЕСТИТЬ Регистр16
ИЗ Регистр8 КАК Старшие, Регистр8 КАК Младшие;

// Создание таблицы с исходными строками, для тестирования
ВЫБРАТЬ "1 " КАК СтрокаСПробелами ПОМЕСТИТЬ ИсходнаяТаблица
ОБЪЕДИНИТЬ ВСЕ ВЫБРАТЬ "22 "
ОБЪЕДИНИТЬ ВСЕ ВЫБРАТЬ "333 "
ОБЪЕДИНИТЬ ВСЕ ВЫБРАТЬ " 4 4 "
ОБЪЕДИНИТЬ ВСЕ ВЫБРАТЬ "5 555 "
ОБЪЕДИНИТЬ ВСЕ ВЫБРАТЬ " 666666 "
ОБЪЕДИНИТЬ ВСЕ ВЫБРАТЬ "7777777 "
ОБЪЕДИНИТЬ ВСЕ ВЫБРАТЬ " 88888888 "
ОБЪЕДИНИТЬ ВСЕ ВЫБРАТЬ "999999999";

// Непосредственно запрос обрезающий начальные и конечные пробелы и попутно получающий реальную длину строки
ВЫБРАТЬ
    СтрокаСПробелами КАК СтрокаСПробелами,
    МАКСИМУМ(Цикл_2.Х + 1) КАК ПоследнийЗначащийСимвол,
    МИНИМУМ(Цикл_1.Х + 1) КАК ПервыйЗначащийСимвол
ПОМЕСТИТЬ
    ПромежуточнаяТаблица
ИЗ
    ИсходнаяТаблица
ЛЕВОЕ СОЕДИНЕНИЕ
    Регистр16 КАК Цикл_1
ПО
    (ПОДСТРОКА(СтрокаСПробелами, Цикл_1.Х, 1) = " " И ПОДСТРОКА(СтрокаСПробелами, Цикл_1.Х + 1, 1) <> " ")
    ИЛИ (Цикл_1.Х = 0 И ПОДСТРОКА(СтрокаСПробелами, Цикл_1.Х + 1, 1) <> " ")
ЛЕВОЕ СОЕДИНЕНИЕ
    Регистр16 КАК Цикл_2
ПО
    ПОДСТРОКА(СтрокаСПробелами, Цикл_2.Х + 1, 1) <> " " И ПОДСТРОКА(СтрокаСПробелами, Цикл_2.Х + 2, 1) = " "
СГРУППИРОВАТЬ ПО
    СтрокаСПробелами
;

ВЫБРАТЬ
    ПОДСТРОКА(СтрокаСПробелами, ПервыйЗначащийСимвол, ПоследнийЗначащийСимвол - ПервыйЗначащийСимвол + 1) КАК СтрокаОбрезанная,
    ПоследнийЗначащийСимвол - ПервыйЗначащийСимвол + 1 КАК ДлинаСтроки
ИЗ
    ПромежуточнаяТаблица 

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

Здесь в качестве "пробельных" символов введена вспомогательная таблица с несколькими разделителями. Т.е. мы выполняем разложение строки не по пробелам, а по заданным разделителям.

// Вспомогательный порождающий запрос
ВЫБРАТЬ 0 КАК Х ПОМЕСТИТЬ Регистр1
ОБЪЕДИНИТЬ ВЫБРАТЬ 1;
ВЫБРАТЬ Младшие.Х + 2 * Старшие.Х КАК Х ПОМЕСТИТЬ Регистр2
ИЗ Регистр1 КАК Старшие, Регистр1 КАК Младшие;
ВЫБРАТЬ Младшие.Х + 4 * Старшие.Х КАК Х ПОМЕСТИТЬ Регистр4
ИЗ Регистр2 КАК Старшие, Регистр2 КАК Младшие;
ВЫБРАТЬ Младшие.Х + 16 * Старшие.Х КАК Х ПОМЕСТИТЬ Регистр8
ИЗ Регистр4 КАК Старшие, Регистр4 КАК Младшие;
ВЫБРАТЬ Младшие.Х + 256 * Старшие.Х КАК Х ПОМЕСТИТЬ Регистр16
ИЗ Регистр8 КАК Старшие, Регистр8 КАК Младшие;

// Таблица разделителей слов
ВЫБРАТЬ " " КАК Разделитель ПОМЕСТИТЬ Разделители
ОБЪЕДИНИТЬ ВСЕ ВЫБРАТЬ " "
ОБЪЕДИНИТЬ ВСЕ ВЫБРАТЬ ";"
ОБЪЕДИНИТЬ ВСЕ ВЫБРАТЬ ",";

// Создание таблицы с исходной строкой для разложения
ВЫБРАТЬ "Съешь еще этих французских булок" КАК СтрокаДляРазложения ПОМЕСТИТЬ ИсходнаяТаблица;

// Получаем границы слов
ВЫБРАТЬ
	Цикл_1.Х + 1 КАК НачалоСлова,
    МИНИМУМ(Цикл_2.Х + 1) КАК КонецСлова
ПОМЕСТИТЬ
    ГраницыСлов
ИЗ
    ИсходнаяТаблица
ЛЕВОЕ СОЕДИНЕНИЕ
    Регистр16 КАК Цикл_1
ПО
    (ПОДСТРОКА(СтрокаДляРазложения, Цикл_1.Х, 1) В (ВЫБРАТЬ Разделитель ИЗ Разделители) ИЛИ Цикл_1.Х = 0)
    И ПОДСТРОКА(СтрокаДляРазложения, Цикл_1.Х + 1, 1) НЕ В (ВЫБРАТЬ Разделитель ИЗ Разделители)
ЛЕВОЕ СОЕДИНЕНИЕ
    Регистр16 КАК Цикл_2
ПО
    ПОДСТРОКА(СтрокаДляРазложения, Цикл_2.Х + 1, 1) НЕ В (ВЫБРАТЬ Разделитель ИЗ Разделители)
    И ПОДСТРОКА(СтрокаДляРазложения, Цикл_2.Х + 2, 1) В (ВЫБРАТЬ Разделитель ИЗ Разделители)
    И Цикл_2.Х >= Цикл_1.Х
СГРУППИРОВАТЬ ПО
    Цикл_1.Х
;

// Исходя из полученных границ слов выполняем разложение строки
ВЫБРАТЬ
	ПОДСТРОКА(СтрокаДляРазложения, НачалоСлова, КонецСлова - НачалоСлова + 1)
ИЗ
	ИсходнаяТаблица, ГраницыСлов

Решето Эратосфена, выдающее таблицу простых чисел

// Вспомогательный порождающий запрос
ВЫБРАТЬ 0 КАК Х ПОМЕСТИТЬ Регистр1 ОБЪЕДИНИТЬ ВЫБРАТЬ 1;
ВЫБРАТЬ Младшие.Х + 2 * Старшие.Х КАК Х ПОМЕСТИТЬ Регистр2
ИЗ Регистр1 КАК Старшие, Регистр1 КАК Младшие;
ВЫБРАТЬ Младшие.Х + 4 * Старшие.Х КАК Х ПОМЕСТИТЬ Регистр4
ИЗ Регистр2 КАК Старшие, Регистр2 КАК Младшие;
ВЫБРАТЬ Младшие.Х + 16 * Старшие.Х КАК Х ПОМЕСТИТЬ Регистр8
ИЗ Регистр4 КАК Старшие, Регистр4 КАК Младшие;
ВЫБРАТЬ Младшие.Х + 256 * Старшие.Х КАК Х ПОМЕСТИТЬ Регистр16
ИЗ Регистр8 КАК Старшие, Регистр8 КАК Младшие;

// Решето Эратосфена, на выходе получаем таблицу всех простых чисел меньших 65536 + 2
ВЫБРАТЬ Регистр4.Х + 2 КАК Х ПОМЕСТИТЬ Решето4
ИЗ Регистр4 ЛЕВОЕ СОЕДИНЕНИЕ Регистр2
ПО Регистр4.Х > Регистр2.Х + 1 И (Регистр4.Х + 2) / (Регистр2.Х + 2) = ВЫРАЗИТЬ((Регистр4.Х + 2) / (Регистр2.Х + 2) КАК Число(32))
ГДЕ Регистр2.Х ЕСТЬ NULL
;

ВЫБРАТЬ Регистр8.Х + 2 КАК Х ПОМЕСТИТЬ Решето8
ИЗ Регистр8 ЛЕВОЕ СОЕДИНЕНИЕ Решето4
ПО Регистр8.Х + 1 > Решето4.Х И (Регистр8.Х + 2) / Решето4.Х = ВЫРАЗИТЬ((Регистр8.Х + 2) / Решето4.Х КАК Число(32))
ГДЕ Решето4.Х ЕСТЬ NULL
;

ВЫБРАТЬ Регистр16.Х + 2 ПростоеЧисло
ИЗ Регистр16 ЛЕВОЕ СОЕДИНЕНИЕ Решето8
ПО Регистр16.Х + 1 > Решето8.Х И (Регистр16.Х + 2) / Решето8.Х = ВЫРАЗИТЬ((Регистр16.Х + 2) / Решето8.Х КАК Число(32))
ГДЕ Решето8.Х ЕСТЬ NULL

Степени двойки до 2^106, большие степени не помещаются в 32 знака (не разряда!) числа, которыми оперирует 1С

ВЫБРАТЬ 0 КАК Степень, 1 КАК Результат ПОМЕСТИТЬ Регистр1
ОБЪЕДИНИТЬ ВСЕ ВЫБРАТЬ 1, 2;

ВЫБРАТЬ РАЗЛИЧНЫЕ
	ПервыйСомножитель.Степень + ВторойСомножитель.Степень КАК Степень,
	ПервыйСомножитель.Результат * ВторойСомножитель.Результат КАК Результат
ПОМЕСТИТЬ Регистр2
ИЗ Регистр1 КАК ПервыйСомножитель, Регистр1 КАК ВторойСомножитель;

ВЫБРАТЬ РАЗЛИЧНЫЕ
	ПервыйСомножитель.Степень + ВторойСомножитель.Степень КАК Степень,
	ПервыйСомножитель.Результат * ВторойСомножитель.Результат КАК Результат
ПОМЕСТИТЬ Регистр4
ИЗ Регистр2 КАК ПервыйСомножитель, Регистр2 КАК ВторойСомножитель;

ВЫБРАТЬ РАЗЛИЧНЫЕ
	ПервыйСомножитель.Степень + ВторойСомножитель.Степень КАК Степень,
	ПервыйСомножитель.Результат * ВторойСомножитель.Результат КАК Результат
ПОМЕСТИТЬ Регистр8
ИЗ Регистр4 КАК ПервыйСомножитель, Регистр4 КАК ВторойСомножитель;

ВЫБРАТЬ РАЗЛИЧНЫЕ
	ПервыйСомножитель.Степень + ВторойСомножитель.Степень КАК Степень,
	ПервыйСомножитель.Результат * ВторойСомножитель.Результат КАК Результат
ПОМЕСТИТЬ Регистр16
ИЗ Регистр8 КАК ПервыйСомножитель, Регистр8 КАК ВторойСомножитель;

ВЫБРАТЬ РАЗЛИЧНЫЕ
	ПервыйСомножитель.Степень + ВторойСомножитель.Степень КАК Степень,
	ПервыйСомножитель.Результат * ВторойСомножитель.Результат КАК Результат
ПОМЕСТИТЬ Регистр32
ИЗ Регистр16 КАК ПервыйСомножитель, Регистр16 КАК ВторойСомножитель;

ВЫБРАТЬ РАЗЛИЧНЫЕ
	ПервыйСомножитель.Степень + ВторойСомножитель.Степень КАК Степень,
	ПервыйСомножитель.Результат * ВторойСомножитель.Результат КАК Результат
ПОМЕСТИТЬ Регистр64
ИЗ Регистр32 КАК ПервыйСомножитель, Регистр32 КАК ВторойСомножитель;

ВЫБРАТЬ РАЗЛИЧНЫЕ
	ПервыйСомножитель.Степень + ВторойСомножитель.Степень КАК Степень,
	ПервыйСомножитель.Результат * ВторойСомножитель.Результат КАК Результат
ИЗ Регистр64 КАК ПервыйСомножитель, Регистр64 КАК ВторойСомножитель
ГДЕ ПервыйСомножитель.Степень + ВторойСомножитель.Степень < 107

Запрос, выполняющий точное вычисление квадратного корня числа в диапазоне 0 - 1 048 576, развитие запроса из статьи ildarovich-а (см. ссылку в начале), который вычислял целое значение квадратного корня.

// Вспомогательный порождающий запрос
ВЫБРАТЬ 0 КАК Х ПОМЕСТИТЬ Регистр1 ОБЪЕДИНИТЬ ВЫБРАТЬ 1;
ВЫБРАТЬ Младшие.Х + 2 * Старшие.Х КАК Х ПОМЕСТИТЬ Регистр2
ИЗ Регистр1 КАК Старшие, Регистр1 КАК Младшие;
ВЫБРАТЬ Младшие.Х + 4 * Старшие.Х КАК Х ПОМЕСТИТЬ Регистр4
ИЗ Регистр2 КАК Старшие, Регистр2 КАК Младшие;
ВЫБРАТЬ Младшие.Х + 16 * Старшие.Х КАК Х ПОМЕСТИТЬ Регистр8
ИЗ Регистр4 КАК Старшие, Регистр4 КАК Младшие;
ВЫБРАТЬ Младшие.Х + 256 * Старшие.Х КАК Х ПОМЕСТИТЬ Регистр16
ИЗ Регистр8 КАК Старшие, Регистр8 КАК Младшие;

// Для проверки создается таблица с различными значениями аргумента
ВЫБРАТЬ 123456 КАК У ПОМЕСТИТЬ Аргументы
ОБЪЕДИНИТЬ ВЫБРАТЬ 555555
ОБЪЕДИНИТЬ ВЫБРАТЬ 987654;

// Вычисляем сначала целую часть (решение ildarovich-а)
ВЫБРАТЬ У КАК У, МАКСИМУМ(Х) КАК Квадратный_корень_У, У - МАКСИМУМ(Х) * МАКСИМУМ(Х) КАК Дельта
ПОМЕСТИТЬ ЦелаяЧастьКорня
ИЗ Аргументы ЛЕВОЕ СОЕДИНЕНИЕ Регистр16 ПО* Х <= У)
СГРУППИРОВАТЬ ПО У;

// Продолжение запроса, вычисляющее дополнительные знаки после запятой

// Вспомогательная таблица для уменьшения количества делений
ВЫБРАТЬ Х КАК Х, Х/65536 КАК Дробь ПОМЕСТИТЬ Дроби16 ИЗ Регистр16;

// Теперь уточним значение с точностью до 1/65536
ВЫБРАТЬ У КАК У, Квадратный_корень_У + МАКСИМУМ(Дробь) КАК Квадратный_корень_У, У - (Квадратный_корень_У + МАКСИМУМ(Дробь)) * (Квадратный_корень_У + МАКСИМУМ(Дробь)) КАК Дельта
ПОМЕСТИТЬ Приближение1
ИЗ ЦелаяЧастьКорня ЛЕВОЕ СОЕДИНЕНИЕ Дроби16 ПО ((Квадратный_корень_У + Дробь) * (Квадратный_корень_У + Дробь) <= У)
СГРУППИРОВАТЬ ПО У, Квадратный_корень_У;

// Вспомогательная таблица для уменьшения количества делений
ВЫБРАТЬ Х КАК Х, Дробь/65536 КАК Дробь ПОМЕСТИТЬ Дроби32 ИЗ Дроби16;

// С точностью до 1/4294967296
ВЫБРАТЬ У КАК У, Квадратный_корень_У + МАКСИМУМ(Дробь) КАК Квадратный_корень_У, У - (Квадратный_корень_У + МАКСИМУМ(Дробь)) * (Квадратный_корень_У + МАКСИМУМ(Дробь)) КАК Дельта
ПОМЕСТИТЬ Приближение2
ИЗ Приближение1 ЛЕВОЕ СОЕДИНЕНИЕ Дроби32 ПО ((Квадратный_корень_У + Дробь) * (Квадратный_корень_У + Дробь) <= У)
СГРУППИРОВАТЬ ПО У, Квадратный_корень_У;

// Вспомогательная таблица для уменьшения количества делений
ВЫБРАТЬ Х КАК Х, Дробь/65536 КАК Дробь ПОМЕСТИТЬ Дроби48 ИЗ Дроби32;

// С точностью до 1/281474976710656
ВЫБРАТЬ У КАК У, Квадратный_корень_У + МАКСИМУМ(Дробь) КАК Квадратный_корень_У, У - (Квадратный_корень_У + МАКСИМУМ(Дробь)) * (Квадратный_корень_У + МАКСИМУМ(Дробь)) КАК Дельта
ПОМЕСТИТЬ Приближение3
ИЗ Приближение2 ЛЕВОЕ СОЕДИНЕНИЕ Дроби48 ПО ((Квадратный_корень_У + Дробь) * (Квадратный_корень_У + Дробь) <= У)
СГРУППИРОВАТЬ ПО У, Квадратный_корень_У;

// Вспомогательная таблица для уменьшения количества делений
ВЫБРАТЬ Х КАК Х, Дробь/65536 КАК Дробь ПОМЕСТИТЬ Дроби64 ИЗ Дроби48;

// С точностью до 1/18446744073709551616
ВЫБРАТЬ У КАК У, Квадратный_корень_У + МАКСИМУМ(Дробь) КАК Квадратный_корень_У, У - (Квадратный_корень_У + МАКСИМУМ(Дробь)) * (Квадратный_корень_У + МАКСИМУМ(Дробь)) КАК Дельта
ИЗ Приближение3 ЛЕВОЕ СОЕДИНЕНИЕ Дроби64 ПО ((Квадратный_корень_У + Дробь) * (Квадратный_корень_У + Дробь) <= У)
СГРУППИРОВАТЬ ПО У, Квадратный_корень_У
 

Запрос СокрЛП

См. также

Инструментарий разработчика Роли и права Запросы СКД Программист Руководитель проекта Платформа 1С v8.3 Управляемые формы Запросы Система компоновки данных Платные (руб)

Инструменты для разработчиков 1С 8.3: Infostart Toolkit. Автоматизация и ускорение разработки на управляемых формах. Легкость работы с 1С.

12000 руб.

02.09.2020    169274    937    403    

905

Запросы Программист Бесплатно (free)

Увидел cheatsheet по SQL и захотелось нарисовать подобное, но про запросы.

18.10.2024    11394    sergey279    18    

65

Запросы Программист Платформа 1С v8.3 Запросы Конфигурации 1cv8 Бесплатно (free)

Столкнулся с интересной ситуацией, которую хотел бы разобрать, ввиду её неочевидности. Речь пойдёт про использование функции запроса АВТОНОМЕРЗАПИСИ() и проблемы, которые могут возникнуть.

11.10.2024    6338    XilDen    36    

83

Запросы Программист Запросы Бесплатно (free)

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

16.08.2024    9068    user1840182    5    

28

Математика и алгоритмы Запросы Программист Платформа 1С v8.3 Запросы Бесплатно (free)

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

08.07.2024    2727    ivanov660    9    

22

Запросы СКД Программист Стажер Система компоновки данных Россия Бесплатно (free)

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

15.05.2024    10219    implecs_team    6    

48

Запросы Программист Стажер Платформа 1С v8.3 Конфигурации 1cv8 Бесплатно (free)

Часто поступают задачи по произвольному распределению общих сумм. После распределения иногда пропадают копейки. Суть решения добавить АвтоНомерЗаписи() в ВТ распределения, и далее используя функции МАКСИМУМ или МИНИМУМ можем положить разницу копеек в первую или последнюю строку знаменателя распределения.

11.04.2024    3623    andrey_sag    10    

38
Комментарии
Подписаться на ответы Инфостарт бот Сортировка: Древо развёрнутое
Свернуть все
1. kosmo0 111 23.12.15 11:06 Сейчас в теме
Вместо самого первого запроса можно использовать типа такого (в принципе давно известного)

ВЫБРАТЬ 0 КАК ф
ПОМЕСТИТЬ Цифры
ОБЪЕДИНИТЬ ВЫБРАТЬ 1
ОБЪЕДИНИТЬ ВЫБРАТЬ 2
ОБЪЕДИНИТЬ ВЫБРАТЬ 3
ОБЪЕДИНИТЬ ВЫБРАТЬ 4
ОБЪЕДИНИТЬ ВЫБРАТЬ 5
ОБЪЕДИНИТЬ ВЫБРАТЬ 6
ОБЪЕДИНИТЬ ВЫБРАТЬ 7
ОБЪЕДИНИТЬ ВЫБРАТЬ 8
ОБЪЕДИНИТЬ ВЫБРАТЬ 9
;
ВЫБРАТЬ
Цифры2.ф+Цифры3.ф*10+Цифры4.ф*100+Цифры5.ф*1000+Цифры1.ф*10000
ИЗ
Цифры КАК Цифры1, Цифры КАК Цифры2, Цифры КАК Цифры3, Цифры КАК Цифры4, Цифры КАК Цифры5
4. PetrPan 62 23.12.15 22:46 Сейчас в теме
(1) kosmo0,
Да, конечно, можно и так. Вообще, в запросах к реляционным БД вряд-ли уже возможно изобрести что-то новое ;)
simuljakr; +1 Ответить
2. AzagTot 41 23.12.15 18:25 Сейчас в теме
Интересный материал. Спасибо!

В первом пакете запросов, скорее всего, предполагалось использовать ВТ Регистр16, а не Регистр8.
Иначе не обрежутся строки, длиной более 256 символов.

...
// Непосредственно запрос обрезающий начальные и конечные пробелы и попутно получающий реальную длину строки
ВЫБРАТЬ
СтрокаСПробелами КАК СтрокаСПробелами,
МАКСИМУМ(Цикл_2.Х + 1) КАК ПоследнийЗначащийСимвол,
МИНИМУМ(Цикл_1.Х + 1) КАК ПервыйЗначащийСимвол
ПОМЕСТИТЬ
ПромежуточнаяТаблица
ИЗ
ИсходнаяТаблица
ЛЕВОЕ СОЕДИНЕНИЕ
Регистр16 КАК Цикл_1
...
3. PetrPan 62 23.12.15 22:44 Сейчас в теме
(2) AzagTot,
Да, верно. Спасибо, заменил в запросах №№ 1 и 2 'Регистр8' на 'Регистр16'. Просто опечатался.
На самом деле, если заведомо известно, что длина строки не превышает 256 символов, то лучше ограничиться в запросе №1 соединением с таблицей 'Регистр8',
а таблицу 'Регистр16' и не создавать вовсе. Если 'ИсходнаяТаблица' будет содержать много строк, то разница по времени выполнения будет существенной.
Для остальных запросов, честно говоря, реального применения не вижу ))
5. Anesk 17 24.12.15 14:47 Сейчас в теме
Разработать будет быстрее выгрузив в таблицу значений.
А в плане оптимизации кода, что будет работать быстрее
этот сложный запрос
или
"выполнить вспомогательный запрос, выгрузить его в таблицу значений, перебрать ее в цикле выполняя СокрЛП(), и затем передать обратно в нужный запрос в виде параметра (создать временную таблицу)"?
user1393556; savostin.alex; +2 Ответить
6. PetrPan 62 27.12.15 18:33 Сейчас в теме
(5) Anesk,
Если возвращаемое строковое значение нужно использовать потом уже в коде 1С, то однозначно никакого смысла в использовании сложного запроса нет.
Встроенная функция СокрЛП() в цикле по выборке результата запроса отработает на порядок быстрее.
"Выполнить вспомогательный запрос, выгрузить его в таблица и потом передать обратно в нужный запрос в виде параметра" - не могу ответить.
Вообще, сложно представить зачем в запросе строка с обрезанными концевыми пробелами: при сравнении они все равно не учитываются.
Мне в конкретной задаче нужно было получить 3 последних символа кода справочника и в зависимости от них вернуть из запроса те или иные данные.
Код было чужой. Некая процедура в качестве параметра получала текст запроса (нескольких различных запросов), выполняла его и производила унифицированные действия над результатами выборки. Чтобы не вставлять заплатки в эту процедуру обработчик посчитал более простым изменить код одного из передаваемых ей запросов.

Подытожив: в плане оптимизации лучше не использовать без необходимости ничего сложного.
Быстрее по выполнению использовать встроенные функции. За сложный запрос всегда придется заплатить временем выполнения и отсутствием масштабирования.

Прошу смотреть на эту статью только как на иллюстрацию приемов, которые МОЖНО, но не вовсе не обязательно НУЖНО использовать в запросах ))
7. kiruha 388 30.12.15 17:45 Сейчас в теме
Публикация круть ) Но на практике использую не выгрузку в ТЗ как тут упоминают , а СКД с собственной функцией СокрЛП из общего модуля. Думаю это самый быстрый вариант
9. German_Tagil 43 16.01.19 14:24 Сейчас в теме
(7) Обьясните пожалуйста как это работает - по шагам
СКД с собственной функцией СокрЛП из общего модуля
8. пользователь 18.07.17 10:29
Сообщение было скрыто модератором.
...
10. Serge_ASB 10.04.19 13:05 Сейчас в теме
В СКД:
Вычисляемое поле:
СтроковыеФункцииКлиентСервер.УдалитьПовторяющиесяСимволы(<Нужное_Поле_из_СКД>, " ", "справа")
Это - для ЗУП. Возьмем значение из поля, поищем пробелы (или другие символы), "справа" (а можно "слева").
11. SanchoD 333 20.12.21 11:58 Сейчас в теме
Теперь есть такая возможность в запросе
Прикрепленные файлы:
improg; Yan_Malyakov; dr2c; +3 Ответить
12. user858604 24.01.24 23:06 Сейчас в теме
(11)Откуда такую консоль скачать, подскажите пожалуйста
13. SanchoD 333 25.01.24 09:36 Сейчас в теме
(12) Встроена в платформу
14. user858604 26.01.24 15:28 Сейчас в теме
(13) Какая версия платформы, уточните пожалуйста?
15. SanchoD 333 26.01.24 17:42 Сейчас в теме
(14) Сейчас юзаю 24-ю. В тот момент (п.11) старше 20-й не было еще.
16. Исключение 41 24.04.24 13:49 Сейчас в теме
Оставьте свое сообщение