Вам нравятся запросы в 1С?
Файлы
ВНИМАНИЕ: Файлы из Базы знаний - это исходный код разработки. Это примеры решения задач, шаблоны, заготовки, "строительные материалы" для учетной системы. Файлы ориентированы на специалистов 1С, которые могут разобраться в коде и оптимизировать программу для запуска в базе данных. Гарантии работоспособности нет. Возврата нет. Технической поддержки нет.
Подписка PRO — скачивайте любые файлы со скидкой до 85% из Базы знаний
Оформите подписку на компанию для решения рабочих задач
Оформить подписку и скачать решение со скидкойВы можете заказать платную доработку или адаптацию этой разработки под вашу конфигурацию на «Бирже заказов».
- 0% комиссии — оплата напрямую исполнителю;
- Исполнители любого масштаба — от отдельных специалистов до команд под проект;
- Прямой обмен контактами между заказчиком и исполнителем;
- Безопасная сделка — при необходимости;
- Рейтинги, кейсы и прозрачная система откликов.
С тем, что объект Запрос в 1С выполняет свои функции, спорить сложно. Но одинаково ли хорошо он подходит для всех случаев? Достаточно ли он лаконичен в "простых" случаях? Достаточно ли нагляден в "сложных" случаях? При попытке подойти к объекту Запрос с позиции методологии разработки возникают следующие вопросы:
- Сам язык запросов и его рекомендуемый стиль слишком громоздкий для "простых случаев". Если наплевать на рекомендуемое оформление, то запрос можно упростить до чего-то вроде "Запрос = Новый Запрос("Выбрать Ссылка Из Справочник.Номенклатура Где ВидНоменклатуры = &МойВид")", что вместе с добавлением параметра и получением результата уложится в три строки, но, на секундочку, в рекомендуемом оформлении - это 10 (десять, Карл!) строк кода.
- Нет запросов на изменение данных. Что мешало сделать простое и удобное платформенное средство непонятно: поверх платформы запросы на изменение сделать можно, значит и в слое платформы тоже было можно.
- Обвязка языка (установка параметров, работа с результатом) хоть и хорошо вписываются в стиль процедурного языка 1С, но также заставляют писать много лишних букв. Для "Запрос.УстановитьПараметр(" уже можно отдельную кнопку на клавиатуре делать
- Текст запроса имеет совершенно отвратительный вид: нет подсветки синтаксиса, необходимость в избыточном оформлении (символ | в каждой строке) делают его сложным для восприятия. Да, подсветку синтаксиса можно получить в конструкторе, но это дополнительно усложняет чтение кода, а на очистку комментариев в этом случае не матерился только ленивый.
- В "сложных" случаях длинный запрос затрудняет чтение процедурного модуля (привет ЗУПу). Частично это решают выносом текста запроса в отдельную процедуру. Так делать начали в типовых, что можно считать официальным признанием наличия проблемы.
Таким образом, можно говорить о том, что реализация запросов в 1С в целом оставляет желать лучшего, а в простых случаях, когда смысл можно было уместить в одну строку, вообще превращает код в длинное и не очень содержательное спагетти. У меня черт возьми, ощущение такое, как будто взяли 20% функционала SQL, прикинули как с помощью этого написать средненький по сложности запрос и на этом успокоились.
При этом "простые" случаи являются наиболее востребованными. Например, в типовой УТ слово ВЫБРАТЬ встречается 22 тысячи раз, а слово СОЕДИНЕНИЕ 11 тысяч раз. Если еще учесть 5 тысяч слов ПОМЕСТИТЬ и тот факт, что соединений в одном запросе бывает несколько - можно говорить, что примерно половина всех запросов являются запросами к одной таблице, т.е. теми самыми "простыми случаями". Это все конечно очень прикидочно.
Т.е. половина запросов написана с использованием инструмента, не лучшим образом подходящего для их написания. Казалось бы, в платформе есть инструмены для получения данных из базы в обход объекта Запрос, такие как НайтиПоРеквизиту, но их использование - это издевательство! Упомянутая НайтиПоРеквизиту ищет только по точному совпадению и только по одному реквизиту и то не по каждому. В типовой УТ, на весь миллион строк кода этот вызов встречается 41 раз, что можно приравнять к признанию бесполезности этого метода. Чтение набора записей регистра сведений по отбору, наверно, самый "юзабельный" инструмент получения данных из базы в обход запросов, но и в нем приходится повторять по пять раз Набор.Отбор....Установить, что не лучшим образом сказывается на читаемости и лаконичности.
Ну правда, что мешало хотябы в метод НайтиПоРеквизитам и принимать на вход структуру? Только не надо про поиск в обход индексов: если будет надо - все равно напишут запрос и будут искать в обход индексов. Займет это вместо одной строки 15, но напишут.
Чтобы окончательно проникнуться идеей ограниченности языка запросов для простых случаев - давайте попробуем глянуть на процедуру, получающую организацию по умолчанию (это не я придумал, это код типовой УТ):
Организация = Справочники.Организации.ПустаяСсылка();
Запрос = Новый Запрос();
Запрос.Текст = "
|ВЫБРАТЬ РАЗРЕШЕННЫЕ ПЕРВЫЕ 2
| Организации.Ссылка КАК Организация
|ИЗ
| Справочник.Организации КАК Организации
|ГДЕ
| НЕ Организации.ПометкаУдаления
| И НЕ Организации.Предопределенный";
Запрос.УстановитьПараметр("ИНН", МойИНН);
Выборка = Запрос.Выполнить().Выбрать();
Если Выборка.Следующий() И Выборка.Количество() = 1 Тогда
Организация = Вборка.Организация();
КонецЕсли;
Возврат Организация;
Делов тут на 3 копейки, а кода 16 строк. Препишем эту функцию на русском языке:
Найти первые две не помеченных на удаление, не предопределенных организации. Если нашлась одна - вернуть ее ссылку, иначе вернуть пустую ссылку.
В этом определении нет упущенной логики, непонятных обобщений и прочих хитростей. Тот факт, что на языке простой логики функция получается в трое короче (263 символа против 900) явно свидетельствует, что выбранный для нее инструмент мягко говоря не совсем подходит. А еще можете взглянуть на мрак в Справочники.Организации.ПолучитьРеквизитыОрганизации... Так совсем не годится.
Вообще, чем меньше в том что вы пишете бизнес-логики и больше каких-то языковых условностей, без которых "не обойтись" - тем менее "плотным", лаконичным будет код, тем больше он будет похож на спагетти, тем хуже он будет читаться и дебажиться.
В 1С явно нужен инструмент, позволяющий получить доступ к данным более лаконичным образом чем язык запросов. Естественно, при этом придется поступиться широкоуниверсальностью, но не настолько чтобы получить что-то бесполезное типа НайтиПоРеквизиту. Хорошо бы получить что-то типа такого:
Организация = Справочники.Организации.НайтиПо("НЕ ПометкаУдаления").ИПо("НЕ Предопределенный").ПолучитьСсылку(Истина);
или типа такого:
Организация = Найти.В("Справочник.Организации").По_("НЕ ПометкаУдаления").ИПо("НЕ Предопределенный").ПолучитьСсылку(Истина);
Как вы пониматете, ничего невозможного в этом нет, а разница между первым и вторым только в наличии функции НайтиПо в модуле менеджера, которая делает вызов Найти.В...
Итак, чтобы не писать каждый раз портянку одинаковых букв, план такой:
1. Делаем общий модуль Найти
2. Пишем в нем обёртку над языком запросов, что-то весьма функциональное, но с простым лаконичным АПИ.
3. Встраиваем вызов процедуры в каждый (или в нужные или только в те, что сняты с поддержки) модуль менеджера.
4. ...
5. PROFIT!
Писать такое не долго, весь мой модуль занимает 250 строк. Делать ли вызов процедур "в одну строку" или нет - вопрос дискуссионный, как делать написано тут.
Некоторые сухие подробности реализации:
- Функция НайтиПо(Параметры...) - функция модуля менеджера, объединяющая указание таблицы и первый фильтр
- Функция задания имени таблицы: В(Имя); Имя - указывается имя таблицы. При встраивании в модуль менеджера пишется один раз или, если встраивание невозможно или нежелательно - каждый раз.
- Функции фильтрации: По_() ИПо() ИНе() ИлиПо() ИлиНе() - функции добавления параметров с соответствующей булевой операцией. В параметрах указывается: имя фильтруемого поля (или само выражение его фильтрации, как в примере "дата между") и, при необходимости, параметры фильтрации. Здесь необходимо пояснить, что для достижения максимальной гибкости и естественной простоты функции пришлось сделать три случая ее функционирования:
- без параметров, для обработки случаев типа И("НЕ ПометкаУдаления")
- с одним параметром, для простого добавления простого равенства, например: И("ВидНоменклатуры", МойВид)
- со сложной обработкой параметров, например: И("Дата МЕЖДУ &Дата1 и &Дата2", ДатаНачала, ДатаКонца). В таком варианте можно задать до трех параметров, а их использование в явном виде указывается. Параметры подставляются по порядку, т.е. в данном случае ДатаНачала будет сопоставлена &Дата1, а ДатаКонца - &Дата2".
- Если использована функция отрицания: ИНе() или ИлиНе()- вся добавленная фраза будет завернута в "НЕ (...)"
- Функции получения результата:
- ПолучитьТаблицу() - эквивалентно "ВЫБРАТЬ * " в запросе и "Запрос.Выполнить().Выгрузить()" в обработке результата
- ПолучитьСсылки() - эквивалентно "ВЫБРАТЬ ССЫЛКА" в запросе и "Запрос.Выполнить().Выгрузить().ВыгрузитьКолонку("Ссылка")" в обработке результата
- ПолучитьСсылку(ТолькоУникальную) - возвращает первую попавшуюся ссылку, соответствующую указанным критериям. Если не найдется - будет возвращено Неопределено. Параметр ТолькоУникальную не обязательный, по умолчанию Ложь, если установлен в Истина - ссылка будет возвращена только если нашлась одна ссылка по указанным критериям, если найдется две - будет возвращено неопределено.
- ПолучитьСсылкуИлиЗначение(ЗначениеПоУмолчанию) - тоже что предыдущее, но если не найдется - будет возвращено ЗначениеПоУмолчанию
- ПолучитьСсылкуИлиИсключение(ТекстИсключения) - тоже что предыдущее, но если не найдется будет вызвано исключение
- ПолучитьПараметры(СписокПараметров) - эквивалентно "ВЫБРАТЬ *" в запросе и помещению первой строки результата запроса в структуру, где ключ соответствует имени колонки, а значение - значению этой колонки в первой строке (если строк не будет - Неопределено) СписокПараметров необязательный, если не задан - в структуре будут заполнены все реквизиты, если задан - в структуре будут присутствовать только указанные реквизиты.
- Пара примеров:
- Документ.ПоступлениеТоваровУслуг.НайтиПо("Номер", Номер).И("Дата Между &Дата1 И &Дата2", Дата1, Дата2).ИНе("ПометкаУдаления").ПолучитьТаблицу();
- Справочник.Номенклатура.НайтиПо("ВидНоменклатуры В (&Виды)", МассивВидов).ИЛИ("СтавкаНДС", Перечисления.СтавкиНДС.НДС0).ПолучитьСсылки();
Платформа 8.3.9.2233, код открыт, даунгрейд возможен при реализации функций типа СтрНачинаетсяС.
Удачи!
Вступайте в нашу телеграмм-группу Инфостарт
См. также
Инструментарий разработчика Роли и права Запросы СКД Разработчик Руководитель проекта 1С:Предприятие 8 Платные (руб)
Инструменты для разработчиков 1С 8.3 и 8.5: Infostart Toolkit. Автоматизация и ускорение разработки на управляемых формах. Легкость работы с 1С.
16500 руб.
02.09.2020 286924 1612 423
Кадровый учет Интеграция Запросы Журналы и реестры данных 1С:Предприятие 8 1C:Бухгалтерия 1С:Зарплата и Управление Персоналом 2.5 1С:Управление торговлей 11 1С:Комплексная автоматизация 2.х 1С:Зарплата и Управление Персоналом 3.x 1С:Управление нашей фирмой 3.0 1C:ERP Россия Управленческий учет Платные (руб)
Готовое решение для автоматизации проверки сотрудников, кандидатов и контрагентов по государственным реестрам и официальным источникам прямо из интерфейса 1С. Сократите время на ручные проверки, минимизируйте риски и храните результаты в единой информационной системе.
18300 руб.
17.06.2026 975 2 0
Инструментарий разработчика Запросы Разработчик 1С 8.3 1С:Бухгалтерия 3.0 1С:Зарплата и Управление Персоналом 3.x Абонемент ($m)
Структура запроса. Обработка визуально показывает, из какого количества подзапросов состоит запрос.
2 стартмани
06.07.2026 5057 65 XSlava 20
Запросы Разработчик 1С 8.3 Россия Бесплатно (free)
Визуальный «Конструктор запроса» 1С, встроенный прямо в VS Code, — аналог конструктора из Конфигуратора и EDT, но без запуска платформы. Расширение читает конфигурацию, выгруженную в файлы, позволяет собрать запрос мышью и генерирует корректный текст на языке запросов 1С (SDBL). Открывает уже существующий текст запроса из кода для правки и — что особенно ценно — сохраняет комментарии при цикле «открыть - править - сохранить». Подходит тем, кто пишет код 1С в VS Code, держит под рукой множество проектов и не хочет ради одного запроса запускать тяжёлый Конфигуратор или EDT.
26.06.2026 10775 Alex_YAM 7
Нейросети Инструментарий разработчика Запросы Разработчик 1С:Предприятие 8 Абонемент ($m)
Консоль запросов 1.0: добавлен ИИ-помощник (запрос в DeepSeek), который помогает быстрее получать каркас Запроса 1С Сформулируйте простое описание; нажмите кнопку – получите результат прямо в консоли. Где дальше его можно дорабатывать и тестировать. 28.5.2026 Добавил "Консоль запросов 2.0" (запрос в DeepSeek + Claude) 4.10.2026 Обновил "Консоль запросов 2.0"
3 стартмани
20.05.2026 9694 46 German4739 72
WEB-интеграция Запросы Разработчик 1С 8.3 Абонемент ($m)
Post1C - это внешняя обработка, которая превращает 1С в полноценный инструмент для тестирования REST API. Всё управление сосредоточено в одном окне: настройка запроса, выполнение, просмотр ответа и генерация кода - без переключения между формами. Аналог Postman, но работающий в привычной среде 1С.
1 стартмани
02.04.2026 4867 106 priem_nv 28
Запросы Механизмы типовых конфигураций Разработчик 1С:Предприятие 8 1С:Управление торговлей 11 Россия Бесплатно (free)
Предлагается обзор работы с объектной моделью запроса по схемам запросов типовым функционалом УТ 11.5.
09.10.2025 13505 aximo 18
Инструментарий разработчика Запросы Разработчик 1С:Предприятие 8 1С:Зарплата и кадры государственного учреждения 3 1С:Зарплата и Управление Персоналом 3.x Абонемент ($m)
QueryConsole1C — расширение, включающее консоль запросов с поддержкой исполняемых представлений — аналогов виртуальных таблиц, основанных на методах программного интерфейса ЗУП. Оно позволяет выполнять запросы с учётом встроенной бизнес-логики, отлаживать алгоритмы получения данных и автоматически генерировать код на встроенном языке 1С.
1 стартмани
16.05.2025 13782 168 zup_dev 32
2. да это наоборот плюс что нет запросов которые модифицируют данные! Вы хоть представляете сколько опасных ситуаций могло бы возникнуть из за кривости рук программистов?
4. согласен насчет подсветки - было бы хорошо ее добавить
5. какие проблемы? вы о чем? вы бы писали 5-километровый код строками вместо пары запросов?
Ваши предолжения "найтиПо" и "ИПо" - это просто жесть!
Я рад что вы не работаете в 1С и не развиваете продукты, иначе это стало бы концом фирмы!
2. вот мне в статье про запросы на изменения тоже писали что типа все пропало, теперь все будет плохо, но никто не может сказать почему. чем конкретно опасны запросы на изменения? чем фраза "УДАЛИТЬ ИЗ РегистрСведений.ЦеныНоменклатуры" опаснее фразы "РегистрыСведений.ЦеныНоменклатуры.СоздатьНаборЗаписей().Записать()"
5. имеется ввиду, когда внутри процедуры на 200 строк еще запрос строк на 100
вы привели только частный случай опасного удаления записей.
Вот пример "УДАЛИТЬ * ИЗ Документы.РеализацииТоваровУслуг" - удалиться все документы без проверки ссылочной целостности, и концов не найдешь!
А если объект сам удаляешь, то хоть ЖР остается кто удалил
я не понимаю разницы между Объект.Удалить() и "УДАЛИТЬ ИЗ Документы.РеализацииТоваровУслуг". запись в ЖР можно делать и в обоих случаях. в "не тех руках" оба инструмента приведут к одному результату
1C же все переводит в SQL запрос и потом его просто бахает на выполнение
по поводу удаления могу сформулировать так - чем проще удалить объект без контроля, тем больше рисков.
Какой нибудь криворукий программист напишет вам кривое условие в конструкции "УДАЛИТЬ * ИЗ ... ГДЕ _некоторое условие_" - и все, потом не отладить, ни концов найти.
Все вышесказанное относиться и к "ИЗМЕНИТЬ"
я как 1С программист мало взаимодействую с SQL, поэтому возникает вопрос.
Как оперативно посмотреть кто снес 100 документов? в ЖР это можно увидеть досточно быстро.
В варианте серверной SQL базы - обращаться к админам, что бы развернули копию базы до удаления записей? Это разве выход? Если база гигантская?
Опять же в вашем посте нет ответа - как определить пользователя, который снес документы.
и еще вопрос - как быть с файловой базой?
2. Кривость это плохо, но зачем ограничивать тех, у кого все растет откуда нужно? Или их настолько мало, что не имеет смысла заморачиватся? :)
4. Для 1С это просто текст, учитываю то, что нет качественной подсветки основного кода, то я думаю этого не будет сделано от слова никогда
5. Есть функциональный подход в том же LINQ. И что в этом многокилометровом коде такого плохого? Можно прикрутить и групджоины и т.д. и все это вполне замечательно читается и видно последовательность действий. Поэтому я кстати и не люблю декларативный синтаксис. Простой пример, отбираем записи по условию, сортируем туда обратно и выбираем например 10 записей пропуская первую. Помоему все лаконично и удобочитаемо:
var row = db.table
.Where(x=> x.field == foo)
.OrderBy(p=>p.date)
.OrderByDescending(p=>p.level)
.Skip(1)
.Take(10).
.ToArray(); /// например
(2)
INSERT/DELETE- AddRange/RemoveRange, апдейта прямого нет конечно, т.к. линкю работает с объектной моделью и очень часто проще удалить и вставить новые записи.
Есть декларативный язык, есть флюент апи с лямбда синтаксисом. Т.е. вы хотите сказать, что годы развития данных технологий так - за хлебушком ходили? По поводу "жести" я бы поостерегся, не нужно судить все с колокольни 1С, т.к. она по удобству разработки, языку, среде выполнения находится на задворках вселенной.
4. ну когда я думал на эту тему - я думал, что в каждом серверном модуле можно сделать пару вкладок: для процедурного языка и для языка запросов с соответствующей подсветкой в каждой. но это конечно врядли будет реализовано
5. я начал думать от spring data. там пилятся методы типа findByEmployeeAndDateBetween(Employee emp, Date date1, Date date2) без реализации и движок парсит имя метода и понимает что делать надо
Такой синтаксис:
"var row = db.table
.Where(x=> x.field == foo)
.OrderBy(p=>p.date)
.OrderByDescending(p=>p.level)
.Skip(1)
.Take(10).
.ToArray(); /// например "
Для меня читается намного сложнее, чем запрос, в котором все разложено по полочкам, вот условие, вот сортировка, то что много строк получается - это на любителя, когда читаю код некоторых "экономов" просто офигеваю, с какой целью несколько операторов присваивания умещают в одну строку или запрос вытягиваю в одну длинную строку и тому подобное.
Возможно это все последователи секты "ненавидящих пробелы" и их подмножества "любителей длинных строк".
Кстати, язык LINQ.NET - всё-таки позволяет писать более привычно (но только на C#):
var foo = Getfoo(); //Некая переменная с неким значением, полученном из некой функции
var row = fr om x in db //я написал тут "fr om" - но infostart упорно искажает до "fr om"
.Take(10).Skip(1); //Увы для этих операторов пока нет ключевых слов - вызываем как обычные функции
wh ere x.field == foo //и тут искажает "wh ere" до "wh ere" (даже в комментарии искажает)
orderby x.date descending
orderby x.level
select x;
ПоказатьНо чтобы такое сделать - Мелкомягким пришлось допиливать платформу .NET и язык C# - но оно того стоило (в итоге вышеприведённый код - будет при компиляции развернут в последовательность вызовов методов - как в исходном примере через "."), ну а методы, уже в рантайме сгенерят запрос и выполнят его по необходимости, когда выборка будет открыта.
Главное достоинство такого подхода:
1. Запрос выглядит как набор операторов - подсветка синтаксиса работает, это не вбивается из общего анализа кода как серое бельмо
2. Можно легко ставить комментарии и комментировать такой код
3. Можно легко его синтаксически разбирать при сравнении и слиянии, в т.ч. с модификациями
4. Можно легко его рефакторить в IDE
5. Да и сама IDE может легко выводить тип (и структуру) переменной q ещё на этапе конфигурирования - и давать выплывающие подсказки для работы с её членами (но правда не всегда - тут если работать с неописанными источниками, скажем из СУБД - то их структура может быть не известна на этапе конфигурирования - как , возможно, в примере выше)
6. Можно лекго такой код подвергать макрообработке
7. Можно относительно несложно расширять выражения своими операторами (в C# это делается специальными расширителями классов - они же класс хелперы - очень мощная вещь сама по себе)
8. Можно прямо в коде ссылаться на переменные (не передавая их как параметры), да и вообще - прямо в коде писать выражения: " wh ere ConvertToCoreFoo(x.field) == Getfoo().Core"
9. LINQ в C# - очень мощная вещь - универсально позволяющая обрабатывать не только базы данных, но коллекции со структурированными элементами как таблицы, а так же крайне легко выполнять параллельную обработку коллекций - так что код, может и не знать, какой источник данных он реально обрабатывает
10. А ещё LINQ позволяет делать отложенные вычисления - я могу написать лишь часть в одном месте
var part1 = db.table
.OrderBy(p=>p.date)
.Skip(1)
.Take(10)
в другом дополнить (и порядок операторов будет не особо важен)
var part2 = part1
.Wh ere(x=> x.field == foo)
.OrderByDescending(p=>p.level);
И потом только открыть выборку
var row = part2.Select();
Причём так выборка открывается как генератор - и вычисляться будет отложенно - по мере обхода результата
row.ForEach(x => Console.WriteLine(x.ToString()); //Условно какая-то обработка
А могут тут ещё условие дописать
var f = GetFilterValue()
row.Wh ere(x=>x.f==f).ForEach(x => Console.WriteLine(x.ToString()); //Условно какая-то обработка
В общем LINQ - это очень круто, жаль его нет в 1С
А автор статьи молодец - пусть ещё не LINQ - но уже маленький шажок в светлое будущее!
Но звания операторов всё-таки как-то надо поболагозвучнее пдобрать!
Это в ответ на (83)
можете аргументировать почему фирма 1С движется к своему концу?
Без обид, готов с вами поспорить и ответить на конструктивную критику
вы делаете весьма огрубляющее обобщение. есть векторы направленные как в одну так и в другую стороны:
- если говорить о скорости выпуска "больших" продуктов - тренда на спад не прослеживается:: 2000 - 8.0; 2010 - 8.2; 2016 - EDT; 2018 - месенджер и 8.4. Разработка конфигураций, по моему оценочному мнению, по сравнению с 2010 годом находится на небывалой высоте как по скорости так и по сложности
- выручка также растет (в 18-м году слегка упала, но пока нельзя говорить что это тренд) и, судя по всему, фирма глубоко прибыльна.
- в технологическом смысле фирма проводит двоякую политику: с одной стороны закрытость "внутреннего мира" можно назвать неким изоляционизмом, а изоляционизм всегда приводит к одному результату (и не подумайте что я намекаю на какие-то параллели))) с другой стороны поддержка rest сервисов в обе стороны делает возможными любые интеграции
- также, можно сказать, что очень опасным трендом является пренебрежение к программистам 1С со стороны программистов "взрослых" языков, что приводит к "непристижности" профессии и оттоке тех, кто может "оттечь", что будет приводить к снижению качества прикладных решений.
- и еще один крайне тревожный тренд заключается в том, что все больше и больше ресурсов как фирмы 1С так и всей отрасли в целом уходит (и по всей видимости тренд будет только нарастать) на удовлетворение хотелок гос.органов, а не бизнеса, что само по себе непроизводительные затраты, не приносящие ни прибыли ни технологического развития.
Цитата из статьи.
Вот уже несколько лет с коллегами и друзьями обсуждаю одно профессиональное опасение и противоположный ему вопрос:
Опасение: Хоть бы новые «не нарожались» и я ещё лет десять зарабатывал себе спокойно.
Вопрос: Почему от года к году работы всё больше, а конкурентов всё меньше?
Опасение к настоящему моменту устарело и силу свою утратило, вопрос остался.
2012 год, однако.
Это хороший признак или плохой? Как по вашему?
Т.к. я работаю с 1С прямо сейчас, то для меня на ближайшие 1-3 года это хорошо.
Меньше конкуренции, больше спроса на мои навыки.
Но на перспективу в 10-15 лет признак, конечно, негативный.
Если дефицит специалистов превысит некий пороговый уровень (по времени поиска специалиста, по стоимости работы специалиста и т.п.), то бизнес может для решения проблем, которые сейчас решаются с помощью 1С, использовать что-то еще.
И тогда придется переучиваться на что-то другое. А это всегда затраты времени, сил, денег.
Но сама фирма 1С, судя по всему, видит проблему. Не раз видел новости на эту тему. Например, что где-то в школах начинают продвижение профессии программист 1С.
по строке "Запрос = "
шаблон напишет всё что написано в верхнем запросе :)
так ещё легче
Запрос = Новый Запрос;
ТекстЗапроса = "
|ВЫБРАТЬ
|
|ИЗ
|
|ГДЕ 1=1
|
|";
Запрос.Текст = ТекстЗапроса;
Запрос.УстановитьПараметр("", );
Результат = Запрос.Выполнить();
Выборка = Результат.Выбрать();
Если Выборка.Следующий() Тогда
КонецЕсли;
1. Про избыточность синтаксиса в простых случаях. Нормальный синтаксис и со временем читается очень даже нормально.
2. Про INSERT - запросы отправляются на сервер БД - как работать с обработчиками ПриЗаписи, ПередЗаписью и подписками на события?
3. Про подсветку кода, комментарии и автокомплит - они есть в EDT. Попробуйте, новый конструктор вполне себе торт.
Собственно проблема на с языком запросов, а с культурой программирования. Обычная практика - работа с БД и бизнес логика в одной процедуре, хотя, по-хорошему, надо разделять.
Тут есть люди которым флюент кажется жестью, хотя чтобы привыкнуть к нему требуется пара дней
2. Entity framework прекрасно работает с моделями представления записей таблиц, там есть так нужные вам и при записи и перед и вдоль и отличия старой записи от новой без всяких сохранений в доп свойствах. И все это отлично работает и с декларативными запросами и со флюентом/лямбда.
(17)
Есть такой пример разделения - фрейворк MVC, там и есть разделение самих моделей данных, работа с ними по запросам и собственно сами формы (view).
2. Там просто синтаксический сахар, т.е. если в запросе микс из Выбрать и Изменить - будет несколько запросов, что будет работать некорректно.
3. Проверл - вполне работает (приложил скриншот)
2. это следствие ограничений платформы. внутри платформы можно было бы сделать чтобы корректно отработал микс
3. это текст процедурного модуля или этот редактор надо отдельно открыть?
2. Это в любом случае будет неоптимально
3. В редакторе текста запроса EDT
Несомненный плюс запросов в том, что их достаточно легко прочитать. А читаемость кода важнее экономии места в модуле.
Остальное всё пусть будет, как жираф решил.
Я думаю, что у каждого программиста должна быть своя библиотека подобных "универсальных" функций, ибо зачем и без того монструозный движок перегружать ещё больше.
про монструозный движок вы ошибаетесь: если взглянуть на совокупность технологий (запросы, скд, объекты, формы и пр.) то они действительно представляют весьма монструозное впечатление. но каждая технология по отдельности весьма скудно реализует свой функционал, что я показываю на примере языка запросов
Организация = СправочникиОрганизацииНайтиПо(Ложь, Ложь);
//Функция из шаблона...
Функция СправочникиОрганизацииНайтиПо(ПометкаУдаления, Предопределенный)
// Нужный код...
КонецФункции;такая функция может иметь большую или меньшую вариантивность, и вы привели вариант с меньшей вариативностью (и совсем не факт плохо это или хорошо), но моя общая мысть заключалась именно в необходимости таких оберток. мой вариант обертки - уже частность.
По статье согласен с тем что отборы в 1с устроены не гибко, более менее гибко - в СКД, но к сожалению компановщик настроек нельзя запихнуть как параметр отбора в функцию .Найти( . Ну и комментарии в запросах очень нужны, приходится извращаться для того что бы прокомментировать какие то куски в запросах
ПС: в чем смысл то? уменьшить количество строк кода? ну видел я код вида
Если пр.Стр = тр.Стр Тогда
....
КонецЕсли;Человек экономил буквы) вы то же этим занимаетесь?
Запрос типа ВСТАВИТЬ это конечно просто обертка над объектной моделью, я никогда не пытался утверждать обратного
И классические декларативные запросы
И функциональные текучие
Основной плюс последних я вижу в динамическом формировании текстов и параметров, а также сохранение единой стилистики код
Конструктор с обработкой результата и 2 клика, делов то.
Такая запись,ну ввиде такой Организация = Найти.В("Справочник.Организации").По_("НЕ ПометкаУдаления").ИПо("НЕ Предопределенный").ПолучитьСсылку(Истина); сосиски пом оему наборот читается хуже.
Хотя для поиска по реквизитам одного элемента использовать запрос тоже можно, вместо выборки по условиям отбора, но я не совсем понимаю разницу между запросом и выборкой, в профайлере они что, блокируются по разному?
Но с другой стороны, объектная логика будет ооочень медленной... что не приемлемо...
Так что компромисы неизбежны... и чаще всего побеждает производительность в ущерб удобочитаемости...
Но в одном автор прав... в простых случаях объектная логика была бы вполне приемлема, т.к. внутри все равно выполнялся бы аналогичный запрос... так зачем его самому писать?
Ваш стиль - это лямбда программирование - говорят было модно недавно, но утратило, немного, популярность - из-за сложности кода. Но в плане уменьшения - самое оно
Это функция тащемто.
Много букаф на тему - фе я такой крутой программист, что вадинес ваш провинцияльный и кривой.
Язык запросов это наглядный инструмент, создавался в том числе не только для профессионалов, а для людей далеких от программирования.
Отсюда наглядность.
ВыполнитьЗапрос(
"Справочник.Номенклатура",
"$Ссылка, $Наименование", // поля
, //структура параметров
"$ПометкаУдаления" // условия
);
Где $ заменяет псевдоним источника.
Читать легче, чем запрос. И самое главное - достигается атомарность команды. Удобная абстракция над всеми необходимыми командами.
Рейтинг: 987
Вы можете заказать платную консультацию или разработку у автора. Будет создан приватный заказ на «Бирже заказов» для автора.
№ 1087149
Создание 03.07.19 10:30
Обновление 03.07.19 10:30
Просмотры 38381
Загрузки 7
Рейтинг
21
Комментарии 93
Код открыт Да
Рубрики Запросы
Кому Разработчик
Тип файла Конфигурация (md, cf)
Платформа 1С:Предприятие 8
Конфигурация 1C:Бухгалтерия
Операционная система Не имеет значения
Страна Не имеет значения
Отрасль Не имеет значения
Налоги Не имеет значения
Вид учета Не имеет значения
Доступ к файлу Абонемент ($m)