Criando e trabalhando com solicitações (para iniciantes). Criando e trabalhando com consultas (para iniciantes) tipo 1c de documento em uma consulta

Klyuev V.V.

http://prof1c.kklab.ru

Criação etrabalhando com solicitações. Operações mais simplespara iniciantes(Aplicação regular)

Boa tarde

Hoje quero falar para vocês como começar a trabalhar com consultas e aprender (aos poucos, claro) como trabalhar com consultas em 1C. Para aqueles familiarizados com consultas MS
É claro que o SQL será muito mais simples.

Então vamos abrir o configurador e criar um novo processamento externo.

Após isso receberemos uma janela com nosso processamento. Vamos prosseguir diretamente para os experimentos nas solicitações, para isso criaremos um novo formulário em nosso processamento - e para isso, na lista (campo branco), selecione Formulários - e clique em (+) Adicionar, concorde com todos os parâmetros de formulário padrão propostos e clique em Concluído.

Então criamos um formulário vazio para você, com botões e. Na janela com o formulário, selecione as abas e vá diretamente para a escrita do código que será executado ao clicar no botão executar. Para fazer isso, encontre o procedimento ButtonExecutePress(Button)

e escreva o seguinte código:

Procedimento ButtonExecutePress(Button) Request = New Request() ; Solicitar. Texto = " SELECIONE | * | DE| Documento . Fatura para pagamento ao comprador" ; Resultado = Consulta. Executar (). Descarregar (); Fim do procedimento

Vamos comentar o que escrevemos aqui. Selecionamos todos os documentos “Fatura para Pagamento ao Comprador” junto com a solicitação. Gostaria de ressaltar desde já que, dependendo da configuração que você está experimentando, observe a composição dos documentos da sua configuração e ao invés da “Fatura para Pagamento ao Comprador” que indiquei, substitua qualquer objeto Documento do lista de documentos em sua configuração, preferencialmente para que documentos deste tipo sejam criados na infobase, para evitar obter um resultado de consulta vazio. Quero também destacar um ponto importante - se houver muitos desses documentos, a execução do pedido poderá demorar algum tempo - devido ao facto de não limitarmos o pedido a condições e selecionarmos todos os campos - que o asterisco ( *) diga-nos.

Com a palavra-chave “Selecionar” ordenamos o nosso pedido para selecionar todos os campos (*) (dados do documento) do documento “Fatura para Pagamento ao Comprador”.

Importante:
Gostaria também de observar que, ao escrever uma linguagem de consulta, os objetos de configuração devem ser abordados no singular e não no plural. Nisso
caso, o objeto Documentos na configuração (ramificação Documentos) - a solicitação contém um Documento. Também à composição dos documentos – passamos pelo ponto (.) – e ao nome do documento.

Recebemos o resultado da solicitação em forma de tabela de valores, conforme evidenciado pelo método (parâmetro) que utilizamos - Upload, ou seja, primeiro executamos
request (Run), e só então carregou o resultado da consulta na tabela de valores e a tabela de valores fica localizada na variável Result.

A seguir salvamos nosso processamento em um arquivo, para isso, clique em Arquivo->Salvar como e escreva o nome do arquivo, para o meu processamento defini o nome “ExternalProcessing1Demo”, para não procurar o processamento por muito tempo, você pode salvá-lo na área de trabalho, então teremos que abri-lo)).

Agora vamos aprender algumas noções básicas de depuração. Para fazer isso, agora no campo ao lado do texto Resultado = ... clique duas vezes com o botão esquerdo do mouse para que apareça um círculo vermelho, você deverá obter algo como o seguinte:

Então, agora definimos um ponto de interrupção na linha com o resultado, agora vamos executar a configuração para depuração pressionando a tecla (F 5) ou o botão
na barra de ferramentas:

Agora, no modo 1C:Enterprise que lançamos, vamos abrir nosso processamento salvo Arquivo->Abrir e encontrar o local onde você salvou o arquivo de processamento, selecione-o e clique em abrir. Clique no botão “Executar” em nosso processamento. Se você fez tudo corretamente, você mudará automaticamente para o modo configurador e verá o seguinte no local onde nosso breakpoint foi instalado:

Uma seta apareceu em nosso círculo - passamos para a execução passo a passo do nosso código e então veremos o que há de mais interessante. Se você fez tudo corretamente, agora poderá obter o resultado da solicitação.

Para visualizar a solicitação faça o seguinte: No menu superior do configurador, encontre o menu Depuração e selecione o comando Tableau.

Uma janela vazia -> Tableau será aberta na parte inferior da janela do configurador. Existem linhas vazias nesta janela. Clique duas vezes na linha vazia destacada e escreva a palavra Resultado. Você deve obter o seguinte:

Assim, na janela que especificamos, devemos receber o resultado da execução do nosso código, nomeadamente agora - a variável “Resultado”, visto que ainda não executamos esta linha de código - temos um valor vazio e o tipo de dados da variável é “Indefinido”.

Vamos dar um passo - para executar a linha de código especificada. Para isso pressione a tecla , ou no menu Debug->Step through... (F 10).

E o que vemos em nosso Tableau:

Vemos com você - o valor da variável e o tipo da variável. Agora também podemos visualizar o conteúdo da nossa tabela de valores, para isso, mova o cursor do mouse até o campo de resultados, clique com o botão direito e selecione “Mostrar valor em uma janela separada”

Obtemos uma janela com os documentos que selecionamos, que estão localizados na variável Resultado

Para resumir:

Você aprendeu a criar uma solicitação simples, também participou da depuração do seu código e ainda conferiu o resultado da nossa solicitação no configurador.

Resolvi dar minha contribuição e descrever aquelas características da linguagem que não foram discutidas nos artigos acima. O artigo é direcionado a desenvolvedores iniciantes.

1. Projeto “IZ”.

Para obter dados do banco de dados não é necessário utilizar a construção “FROM”.
Exemplo: Precisamos selecionar todas as informações sobre bancos no diretório de bancos.
Solicitar:

SELECIONE Diretório.Bancos.*

Seleciona todos os campos do diretório Bancos. E é semelhante ao pedido:

SELECIONE Bancos.* FROM Directory.Banks AS Bancos

2. Ordenação de dados por campo de referência

Quando precisamos organizar os dados da consulta por tipos primitivos: "String", "Número", "Data", etc., então tudo se resolve usando a construção "ORDER BY" se precisar ordenar os dados por um campo de referência? O campo de referência é um link, um identificador único, ou seja, Grosso modo, algum conjunto arbitrário de caracteres e uma ordem comum podem produzir um resultado que não é totalmente esperado. Para ordenar os campos de referência, utiliza-se a construção "AUTO ORDER". Para fazer isso, primeiro você deve ordenar os dados diretamente pelo tipo de referência usando a construção "ORDER BY" e depois a construção "AUTO ORDER".

Neste caso, para documentos a ordenação ocorrerá na ordem “Data->Número”, para livros de referência na “Visualização Principal”. Caso a ordenação não ocorra por campos de referência, então não é recomendado utilizar a construção "AUTO ORDER".

Em alguns casos, a construção "AUTO ORDER" pode retardar o processo de seleção. Da mesma forma, você pode reescrever sem ordenação automática de documentos:

3.Obter uma representação textual de um tipo de referência. Projeto "APRESENTAÇÃO".

Quando você precisar exibir um campo do tipo referência, por exemplo, o campo "Banco", que é um link para um elemento do diretório "Bancos", você precisa entender que ao exibir este campo, uma subconsulta para o " Banks" será executado automaticamente para obter uma visualização do diretório. Isso tornará a saída de dados mais lenta. Para evitar isso, é necessário utilizar a construção “PREPRESENTATION” na solicitação para obter imediatamente uma representação do objeto e depois exibi-lo para visualização.

No sistema de composição de dados, esse mecanismo é utilizado por padrão, mas ao criar layouts em células, deve-se especificar a representação do campo de referência e, por exemplo, colocar o próprio link na transcrição.

4. Condição para amostragem de dados de acordo com um modelo.

Por exemplo, você precisa obter telefones celulares de funcionários no formato (8 -123-456-78-912). Para fazer isso, você precisa definir a seguinte condição na solicitação:

SELECIONE Employee.Name, Employee.Phone AS Phone FROM Directory.Employees AS Employees WHERE Phone LIKE "_-___-___-__-__"

O caractere "_" é um caractere de serviço e substitui qualquer caractere.

5. Utilização simultânea de totais e agrupamentos.

Os totais são frequentemente usados em conjunto com agrupamentos; neste caso, as funções agregadas podem não ser especificadas nos totais.

SELECIONE Prestação de Serviços.Organização AS Organização, Prestação de Serviços.Nomenclatura AS Nomenclatura, SOMA(Prestação de Serviços.Quantidade do Documento) AS Soma do Documento DO Documento.Prestação de Serviços AS Prestação de Serviços GRUPO POR Prestação de Serviços.Organização, Prestação de Serviços.Nomenclatura RESULTADOS POR GERAL, Organização, Nomen klatura

Nesse caso, a consulta retornará quase o mesmo que a seguinte consulta:

SELECIONE Prestação de Serviços.Organização AS Organização, Prestação de Serviços.Nomenclatura AS Nomenclatura, Prestação de Serviços.Quantidade do Documento AS Quantidade do Documento DO Documento.Prestação de Serviços AS Prestação de Serviços VALOR DOS RESULTADOS (Quantidade do Documento) POR GERAL, Organização, Nomenclatura

Somente a primeira consulta recolherá registros com a mesma nomenclatura.

6. Desreferenciação de campos.

A referência a campos por meio de um ponto é chamada de operação de desreferenciação de campo de referência. Por exemplo Unidade.Organização.Administrativa de Pagamento. Neste caso, no campo de referência “Organização” do documento “Pagamento”, refere-se a outra tabela “Organizações”, na qual será obtido o valor do atributo “Unidade Administrativa”. É importante entender que ao acessar os campos através de um ponto, a plataforma cria implicitamente uma subconsulta e une essas tabelas.

Solicitar:

Pode ser representado como:

SELECIONE Pagamento.Link, Pagamento.Organização, Pagamento.Organização, Organizações. Unidade Administrativa FROM Documento.Pagamento AS Pagamento ESQUERDA JOIN Diretório.Organizações AS Software Organizações Pagamento.Organização = Organizações.Link

Ao desreferenciar campos de referência de um tipo composto, a estrutura tenta criar junções implícitas para todas as tabelas que fazem parte do tipo desse campo. Neste caso, a consulta não será ótima. Se for claramente conhecido que tipo de campo é, é necessário limitar tais campos por tipo com uma construção EXPRESSAR().

Por exemplo, existe um registro de acumulação “Pagamentos não distribuídos”, onde vários documentos podem atuar como registradores. Nesse caso, é incorreto obter os valores dos detalhes do registrador desta forma:

SELECIONE UnallocatedPayments.Register.Date, ..... DE RegisterAccumulation.UnallocatedPayments AS UnallocatedPayments

você deve restringir o tipo do campo composto ao logger:

SELECIONE EXPRESS(UnallocatedPayments.Register AS Document.Payment).Data, ..... FROM RegisterAccumulation.UnallocatedPayments AS UnallocatedPayments

7. Construção "ONDE"

Com uma junção esquerda de duas tabelas, ao impor uma condição “WHERE” na tabela direita, obteremos um resultado semelhante ao resultado de uma junção interna de tabelas.

Exemplo. É necessário selecionar todos os Clientes do Diretório de Clientes e para aqueles clientes que possuem um documento de pagamento com o valor do atributo "Organização" = &Organização, exibir o documento "Pagamento", para aqueles que não possuem, não exibi-lo.

O resultado da consulta retornará registros apenas dos clientes que tiveram pagamento por organização no parâmetro e filtrará os demais clientes. Portanto, você deve primeiro receber todos os pagamentos da organização “tal e tal” em uma tabela temporária e, em seguida, conectá-la ao diretório “Clientes” usando um left join.

SELECIONE Pagamento.Link COMO Pagamento, Pagamento.Acionista COMO Cliente LUGAR paraPagamentos DO Documento.Pagamento COMO Pagamento ONDE Pagamento.Filial = &Filial; /////////////////////////////////////////// // ///////////////////////// SELECT Clients.Link AS Client, ISNULL(tPayment.Payment, "") AS Payment FROM Directory .Clients AS Clientes ESQUERRAM CONEXÃO topayments AS topayments SOFTWARE Clients.Link = topayments.Client

Você pode contornar essa condição de outra maneira. É necessário impor uma condição “WHERE” diretamente no relacionamento entre as duas tabelas. Exemplo:

SELECIONE Clients.Link, Payment.Link FROM Directory.US_Subscribers AS US_Subscribers LEFT CONNECTION Document.Payment AS Payment Software (Clients.Link = Payment.Client AND Payment.Client.Name LIKE "Sugar Packet") GROUP BY Clients.Link, Pagamento. Link

8. Junções com tabelas aninhadas e virtuais

Consultas aninhadas muitas vezes necessário para recuperar dados com base em alguma condição. Se você usá-las em conjunto com outras tabelas, isso poderá retardar criticamente a execução da consulta.

Por exemplo, precisamos obter o valor do saldo na data atual para alguns clientes.

SELECT UnallocatedPaymentsRemains.Customer, UnallocatedPaymentsRemains.AmountRemaining FROM (SELECT Clients.Link AS Link FROM Directory.Clients AS Clients WHERE Clients.Link IN(&Clients)) AS NestedQuery LEFT JOIN RegisterAccumulations.UnallocatedPayments.Balances AS UnallocatedPayments BY Nested Request.Link = UnallocatedPaymentsBalances. Cliente

Ao executar tal consulta, o otimizador DBMS pode cometer erros ao escolher um plano, o que levará a uma execução abaixo do ideal da consulta. Ao unir duas tabelas, o otimizador DBMS seleciona um algoritmo de união de tabelas com base no número de registros em ambas as tabelas. Se houver uma consulta aninhada, será extremamente difícil determinar o número de registros que a consulta aninhada retornará. Portanto, você deve sempre usar tabelas temporárias em vez de consultas aninhadas. Então, vamos reescrever a solicitação.

SELECIONE Clientes.Link AS Link PLACE tClients FROM Directory.Clients AS Clientes ONDE
Clientes.Link B (&Clientes) ; /////////////////////////////////////////// // ///////////////////////// SELECT tClients.Link, UnallocatedPaymentsRemains.AmountRemaining, FROM tClients AS tClients LEFT JOIN RegisterAccumulations.UnallocatedPayments.Balances (, Cliente IN (SELECT tClients.Link FROM tClients)) AS UnallocatedPaymentsBalances tClients.Link = UnallocatedPaymentsBalances.Clients

Nesse caso, o otimizador será capaz de determinar quantos registros a tabela temporária tClients usa e poderá selecionar o algoritmo ideal para unir tabelas.

Mesas virtuais , permitem obter dados praticamente prontos para a maioria das tarefas aplicadas (Fatia da Primeira, Fatia da Última, Restos, Turnovers, Restos e Turnovers) A palavra-chave aqui é virtual. Essas tabelas não são físicas, mas são compiladas pelo sistema em tempo real, ou seja, Ao receber dados de tabelas virtuais, o sistema coleta dados das tabelas de cadastro final, monta, agrupa e emite ao usuário.

Aqueles. Ao conectar-se a uma tabela virtual, é feita uma conexão com uma subconsulta. Neste caso, o otimizador DBMS também pode escolher um plano de conexão não ideal. Se a consulta não for gerada com rapidez suficiente e usar joins em tabelas virtuais, é recomendável mover o acesso às tabelas virtuais para uma tabela temporária e, em seguida, fazer uma join entre duas tabelas temporárias. Vamos reescrever a solicitação anterior.

SELECIONE Clientes.Link AS Link COLOQUE tClients FROM Directory.Clients AS Clientes INDEX POR Link WHERE
Clientes.Link B (&Clientes) ; /////////////////////////////////////////// // ///////////////////////// SELECT UnallocatedPayments.AmountBalance, UnallocatedPayments.Client AS Cliente PLACE saldos FROM RegisterAccumulations.UnallocatedPayments.Balances(, Cliente B ( SELECIONE tClients. Link FROM tClients)) AS UnallocatedPaymentsBalances; /////////////////////////////////////////// // ///////////////////////// SELECT tClients.Link, toRemainders.AmountRemaining AS AmountRemaining FROM tClients AS tClients LEFT JOIN toRemainders AS Remainders BY tClients.Link = tRemanescentes.Cliente

9.Verificando o resultado da solicitação.

O resultado da consulta pode estar vazio; para verificar valores vazios, use a seguinte construção:

ResRequest = Request.Execute(); Se resQuery.Empty() então retornar; fim se;

Método Vazio() deve ser usado antes dos métodos Escolher() ou Descarregar(), pois a recuperação da coleção leva tempo.

Não é uma revelação para ninguém que é extremamente indesejável usar consultas em loop. Isto pode afetar criticamente o tempo de operação de uma função específica. É altamente desejável receber todos os dados da solicitação e depois processá-los em loop. Mas às vezes há casos em que se torna impossível mover a solicitação para fora do loop. Neste caso, para otimização, você pode mover a criação da consulta para fora do loop, e no loop substituir os parâmetros necessários e executar a consulta.

Solicitação = Nova Solicitação; Query.Text = "SELECIONE | Clientes.Link, | Clientes.Data de Nascimento |FROM | Diretório.Clientes AS Clientes |ONDE | Clientes.Link = &Cliente"; Para cada linha FROM TableClients Loop Query.SetParameter("Client", Client); QueryResult = Query.Execute().Select(); Fim do Ciclo;

Isso evitará que o sistema verifique a sintaxe da solicitação em um loop.

11. Construção "TER".

Um design bastante raro em solicitações. Permite impor condições aos valores das funções agregadas (SOMA, MÍNIMO, MÉDIA, etc.). Por exemplo, você precisa selecionar apenas os clientes cujo valor do pagamento em setembro foi superior a 13.000 rublos. Se você usar a condição “WHERE”, primeiro terá que criar uma tabela temporária ou uma consulta aninhada, agrupar os registros por valor do pagamento e depois aplicar a condição. A construção “TER” ajudará a evitar isso.

SELECIONE Pagamento.Cliente, VALOR(Pagamento.Valor) COMO Valor DO Documento.Pagamento COMO Pagamento ONDE MÊS(Data.Pagamento) = 9 GRUPO POR Pagamento.Cliente TENDO VALOR(Pagamento.Valor) > 13000

No construtor, para isso, basta ir até a aba “Condições”, adicionar uma nova condição e marcar a caixa de seleção “Personalizado”. Depois é só escrever Valor(Pagamento.Valor) > 13.000

12. Valor NULO

Não descreverei aqui os princípios da lógica de três valores no banco de dados; existem muitos artigos sobre esse assunto. Apenas brevemente sobre como NULO pode afetar o resultado da consulta. O valor NULL não é realmente um valor e o fato de o valor ser indefinido é desconhecido. Portanto, qualquer operação com NULL retorna NULL, seja adição, subtração, divisão ou comparação. Um valor NULL não pode ser comparado a um valor NULL porque não sabemos o que comparar. Aqueles. ambas as comparações são: NULL = NULL, NULL<>NULL não é verdadeiro ou falso, é desconhecido.

Vejamos um exemplo.

Para aqueles clientes que não possuem pagamentos, precisamos exibir o campo “Assinar” com o valor “Sem pagamentos”. Além disso, sabemos com certeza que temos esses clientes. E para refletir a essência do que escrevi acima, vamos fazer assim.

SELECIONE "Sem pagamentos" AS Atributo, NULL AS Documento PLACE para pagamentos; /////////////////////////////////////////// // ///////////////////////// SELECT Clients.Link AS Client, Payment.Link HOW Payment PUT tClientPayment FROM Directory.Clients AS Clients LEFT CONNECTION Documento. Pagamento AS Software de Pagamento Clientes.Link = Pagamento.Acionista; /////////////////////////////////////////// // ///////////////////////// SELECT tClientPayment.Client FROM tClientPayment AS tClientPayment INTERNAL JOIN tPayment AS tTopay BY tClientPayment.Payment = tPayment.

Preste atenção na segunda tabela temporária tClientPayment. Com o join esquerdo seleciono todos os clientes e todos os pagamentos desses clientes. Para os clientes que não possuem pagamentos, o campo “Pagamento” será NULO. Seguindo a lógica, na primeira tabela temporária “tPayments” designei 2 campos, um deles NULL, a segunda linha “Não possui pagamentos”. Na terceira tabela, conecto as tabelas “tClientPayment” e “tPayment” utilizando os campos “Pagamento” e “Documento” com join interno. Sabemos que na primeira tabela o campo “Documento” é NULO, e na segunda tabela quem não possui pagamentos no campo “Pagamento” também é NULO. O que essa conexão retornará para nós? Mas não retornará nada. Porque a comparação NULL = NULL não é avaliada como True.

Para que a requisição retorne o resultado esperado, vamos reescrevê-la:

SELECIONE "Sem pagamentos" AS Atributo, VALUE(Document.Payment.EmptyLink) AS Documento PLACE toPayments; /////////////////////////////////////////// // ///////////////////////// SELECT Clients.Link AS Client, ISNULL(Payment.Link, VALUE(Document.Payment.EmptyLink )) COMO Pagamento PUT tClientPayment FROM Directory.Clientes AS Clientes ESQUERDA CONEXÃO Documento.Pagamento AS Pagamento BY Clientes.Link = Pagamento.Acionista; /////////////////////////////////////////// // ///////////////////////// SELECT tClientPayment.Client FROM tClientPayment AS tClientPayment INTERNAL JOIN tPayment AS tTopay BY tClientPayment.Payment = tPayment.

Agora, na segunda tabela temporária, indicamos que se o campo “Pagamento” for NULO, então este campo = um link vazio para o documento de pagamento. Na Primeira tabela também substituímos NULL por uma referência vazia. Agora a conexão envolve campos não NULL e a solicitação retornará o resultado esperado.

Todas as solicitações contidas no artigo refletem as situações que gostaria de considerar e nada mais. SOBRE Eles podem não ser delirantes ou abaixo do ideal, o principal é que reflitam a essência do exemplo.

13. Uma característica não documentada do design "CHOICE WHEN...THEN...END".

Caso seja necessário descrever a construção de “Condições” na solicitação, utilizamos a sintaxe padrão:

SELECT SELECTION WHEN Users.Name = "Vasya Pupkin" THEN "Nosso funcionário favorito" ELSE "Não sabemos disso" END AS Field1 FROM Directory.Users AS Users

Mas e se, por exemplo, precisarmos obter o nome do mês em uma solicitação? Escrever uma construção enorme em uma solicitação é feio e demorado, então esta forma de escrita acima pode nos ajudar:

SELECIONE MÊS (US_CalculationConsumption_ScheduleTurnover.CalculationPeriod) QUANDO 1 ENTÃO "janeiro" QUANDO 2 ENTÃO "fevereiro" QUANDO 3 ENTÃO "março" QUANDO 4 ENTÃO "abril" QUANDO 5 ENTÃO "maio" QUANDO 6 ENTÃO "junho" QUANDO 7 ENTÃO "julho" K QUANDO 8 ENTÃO "Agosto" QUANDO 9 ENTÃO "Setembro" QUANDO 10 ENTÃO "Outubro" QUANDO 11 ENTÃO "Novembro" QUANDO 12 ENTÃO "Dezembro" TERMINA COMO MÊS

Agora o design parece menos complicado e é fácil de entender.

14. Execução de consulta em lote.

Para não multiplicar as solicitações, você pode criar uma solicitação grande, dividi-la em pacotes e trabalhar com ela.
Por exemplo, preciso obter os seguintes campos do diretório "Usuários": "Data de Nascimento" e as funções disponíveis para cada usuário. carregue isso em diferentes partes tabulares do formulário. Claro, você pode fazer isso em uma solicitação, então você terá que iterar pelos registros ou recolhê-los, ou você pode fazer isto:

SELECT Users.Link AS Nome Completo, Users.Data de Nascimento, Users.Role PUT vtUsers FROM Directory.Users AS Users; /////////////////////////////////////////// // ////////////////////////// SELECT tueUsers.Full name, tueUsers.Date of Birth FROM tueUsers AS tueUsers GROUP BY tueUsers.full name, tueUsers . Data de nascimento; /////////////////////////////////////////// // ///////////////////////// SELECT wUsers.Full Name, wUsers.Role FROM wUsers AS wUsers GROUP BY wUsers.Full Name, wUsers. Data de Aniversário

tPackage = Request.ExecutePackage();

TP_BirthDate = tPackage.Upload();
TP_Roles = tPackage.Unload();

Como podemos ver, a consulta pode ser executada em lote e o resultado pode ser processado como um array. Em alguns casos é muito conveniente.

15. Condições em uma solicitação em lote

Por exemplo, temos uma solicitação em lote, onde primeiro obtemos os campos: “Nome, Data de Nascimento, Código” do diretório “Usuários” e queremos obter registros com condições para estes campos do diretório “Pessoas Físicas”.

SELECT Users.Individual.Name AS Nome, Users.Individual.Date of Birth AS Data de Nascimento, Users.Individual.Code AS Code PLACE vtUsers FROM Directory.Users AS Users; /////////////////////////////////////////// // ////////////////////////// SELECT Indivíduos. Link AS Individual FROM Directory. Indivíduos AS Indivíduos

Você pode impor condições como esta:

ONDE Individuals.Code IN (SELECT vtUsers.Code FROM vtUsers) E Individuals.Name IN (SELECT vtUsers.Code FROM vtUsers) E Individuals.BirthDate IN (SELECT vtUsers.DateBirth FROM tvUsers)

E você pode fazer assim:

WHERE (Individuals.Code, Individuals.Name, Individuals.Date of Birth) IN (SELECT tueUsers.Code, tueUsers.Name, tueUsers.Date of Birth FROM tueUsers)

Além disso, é necessário manter a ordem.

16. Chamando o construtor de consultas para “condição” em uma solicitação em lote

Quando for necessário impor uma condição, como no exemplo acima, você pode esquecer como este ou aquele campo é chamado na tabela virtual.
Por exemplo, você precisa impor uma condição no campo “Data de Nascimento”, e na tabela virtual esse campo se chama “Data de Nascimento do Devedor”, e caso esqueça o nome terá que sair editando a condição sem salvando e veja o nome do campo. Para evitar isso, você pode usar a seguinte técnica.

É necessário colocar colchetes após a Construção “B” e deixar um espaço vazio (espaço) entre os colchetes, selecionar este espaço e chamar o construtor da consulta. O designer terá acesso a todas as tabelas da consulta em lote. A técnica funciona tanto em tabelas de cadastros virtuais quanto na aba “Condições”. Neste último caso, é necessário marcar a caixa “P (condição arbitrária)” e entrar no modo de edição “F4”.

As perguntas muitas vezes foram feitas na hora e servem simplesmente para ilustrar as “técnicas” que eu estava considerando.

Eu queria analisar o uso de índices em consultas, mas este é um tópico muito amplo. Colocarei isso em um artigo separado ou adicionarei aqui mais tarde.

atualização1. Pontos 11,12
atualização2. Pontos 13,14,15,16

Livros usados:
Linguagem de consulta "1C:Enterprise 8" - E.Yu. Khrustaleva
Desenvolvimento profissional no sistema 1C:Enterprise 8."

Neste artigo queremos discutir tudo com você Funções de linguagem de consulta 1C, e construções de linguagem de consulta. Qual é a diferença entre função e design? A função é chamada com parênteses e possíveis parâmetros neles, e a construção é escrita sem parênteses. Sem dúvida todas as estruturas e funções da linguagem de consulta 1C tornar o processo de aquisição de dados flexível e multifuncional. Essas funções e construções se aplicam a campos de solicitação e algumas também se aplicam a condições.

Funções da linguagem de consulta 1C

Porque uma descrição clara Funções de linguagem de consulta 1Cé muito menos comum que descrições de estruturas, decidimos começar a examinar funções. Agora vamos analisar cada um separadamente, descrevendo sua finalidade, sintaxe e exemplo de uso, então:

1. Função DATA HORA- esta função cria um campo constante do tipo "Data".

Sintaxe: DATA HORA(<Год>,<Месяц>,<День>,<Час>,<Минута>,<Секунда>)

Exemplo de uso:

2. Função DIFERENÇA DE DATA- retorna a diferença entre duas datas em uma das dimensões (ano, mês, dia, hora, minuto, segundo). A medição é passada como parâmetro.

Sintaxe: DATADIFERENÇA(<Дата1>, <Дата2>, <Тип>)

Exemplo de uso:

Query.Text = "SELECT | DIFFERENCEDATE(DATETIME(2015, 4, 17), DATETIME(2015, 2, 1), DAY) | AS Qty.Days";

3. Função VALOR- define um campo constante com um registro predefinido do banco de dados; você também pode obter um link vazio de qualquer tipo.

Sintaxe: VALOR(<Имя>)

Exemplo de uso:

Request.Text = "SELECT //elemento predefinido | VALUE(Diretório.Moedas.Dollar) AS Dólar, //link vazio | VALUE(Documento.Recebimento de Mercadorias e Serviços.EmptyLink) AS Recibo, //valor de transferência | VALUE(Transferência . Pessoa Jurídica. Pessoa Física) AS Pessoa Física, //conta predefinida | VALOR(Plano de Contas. Autossustentável. Materiais) AS Conta_10" ;

4. Função SELECIONAR- temos diante de nós um análogo da construção IF, que é utilizada no código, apenas esta é utilizada nas consultas 1C.

Sintaxe: ESCOLHA QUANDO<Выражение>ENTÃO<Выражение>DE OUTRA FORMA<Выражение>FIM

Exemplo de uso:

Request.Text = //se o valor for superior a 7.500, então deve haver um desconto de 300 rublos, //então se a condição for acionada então a função //retorna Soma - 300 //caso contrário a solicitação retornará simplesmente Soma "SELECT | SELECT | WHEN TCReceipts.Amount > 7500 | THEN TCReceipts.Amount - 300 | ELSE TCReceipts.Amount | END AS AmountWithDiscount |FROM | Documento.Recebimento de MercadoriasServiços.Mercadorias AS TCReceipts";

5. Função EXPRESSA- permite expressar um campo constante com um tipo específico.

Sintaxe: EXPRESS(NomeCampo AS NomeTipo)

Exemplo de uso:

Existe outra opção de utilização da função EXPRESS em campos de tipos mistos, onde eles ocorrem? O exemplo mais simples é o “Registrador” de qualquer registro. Então, por que precisaríamos qualificar o tipo no registrador? Vamos considerar a situação quando selecionamos o campo “Número” do registrador, de qual tabela o número será selecionado? A resposta correta de todas! Portanto, para que nossa consulta funcione rapidamente, devemos especificar um tipo explícito usando a função EXPRESS

Exemplo de uso:

Query.Text = "SELECT | EXPRESS(Nomenclature.Comment AS Line(300)) AS Comment, | EXPRESS(Nomenclature.Sum AS Number(15,2)) AS Sum |FROM | Directory.Nomenclature AS Nomenclature";

6. Função ÉNULO(ortografia alternativa ISNULL) - se o campo for do tipo NULL, ele será substituído pelo segundo parâmetro da função.

Sintaxe: É NULO(<Поле>, <ПодставляемоеЗначение>)

Exemplo de uso:

Observe também que é aconselhável SEMPRE substituir o tipo NULL por algum valor, pois a comparação com o tipo NULL sempre retorna FALSE mesmo se você comparar NULL com NULL. Na maioria das vezes, os valores NULL são formados como resultado da união de tabelas (todos os tipos de junções, exceto as internas).

Query.Text = //Selecione todo o item e seus saldos //se não houver saldo em algum item, então haverá um campo //NULL que será substituído pelo valor 0 "SELECT | No. Link, | ISNULL (ProdutosInStockRemains.InStockRemaining, 0) AS Restante | FROM | Diretório.Nomenclatura AS Nº | CONEXÃO ESQUERDA Registrar Acumulações. MercadoriasEmArmazéns. Restos AS MercadoriasEmArmazénsRestos | ON (MercadoriasEmArmazénsRestos. Nomenclatura = Nº Link)";

7. Função REPRESENTAÇÃO- permite obter uma representação do campo de solicitação.

Sintaxe: DESEMPENHO(<НаименованиеПоля>)

Exemplo de uso:

Query.Text = "SELECT | REPRESENTATION(FreeRemainingRemains.Nomenclature) AS Nomenclature, | REPRESENTATION(FreeRemainingRemaining.Warehouse) AS Warehouse, | FreeRemainingRemaining.InStockRemaining |FROM |Accumulation Register.FreeRemaining.Remaining AS FreeRemainingRemaining";

Construções na linguagem de consulta 1C

Discutimos com você acima Funções de linguagem de consulta 1C, agora é hora de considerar construções na linguagem de consulta 1C, eles não são menos importantes e úteis, vamos começar.

1. Construção LINK- é um operador lógico para verificar um tipo de referência. Encontrado com mais frequência ao verificar um campo de um tipo complexo em relação a um tipo específico. Sintaxe: LINK<Имя таблицы>

Exemplo de uso:

Request.Text = //se o tipo de valor do registrador for Recebimento de documento, //então a consulta retornará "Recebimento de mercadorias", caso contrário "Vendas de mercadorias" "SELECT | SELECT | WHEN Remanescentes.Registrar LINK Documento.Recebimento de mercadorias e Serviços | ENTÃO ""Recebimento"" | ELSE ""Consumo"" | TERMINAR COMO Tipo de Movimento | DE | Registo de Acumulação. Restantes Produtos em Armazéns COMO Restos" ;

2. Projetar ENTRE- este operador verifica se o valor está dentro do intervalo especificado.

Sintaxe: ENTRE<Выражение>E<Выражение>

Exemplo de uso:

3. HIERARQUIA DE CONSTRUÇÃO B E B- verificar se o valor está na lista transferida (matrizes, tabelas de valores, etc. podem ser transferidas como uma lista). O operador IN HIERARCHY permite visualizar a hierarquia (um exemplo de utilização do Plano de Contas).

Sintaxe: EM(<СписокЗначений>), NA HIERARQUIA(<СписокЗначений>)

Exemplo de uso:

4. Projeto SEMELHANTE- Esta função nos permite comparar uma string com um padrão de string.

Sintaxe: COMO "<ТекстШаблона>"

Opções de padrão de linha:

% - uma sequência contendo qualquer número de caracteres arbitrários.

Um caractere arbitrário.

[...] - qualquer caractere único ou sequência de caracteres listados entre colchetes. A enumeração pode especificar intervalos, por exemplo a-z, significando um caractere arbitrário incluído no intervalo, incluindo os finais do intervalo.

[^...] - qualquer caractere único ou sequência de caracteres listados entre colchetes, exceto aqueles listados após o sinal de negação.

Exemplo de uso:

5. Projeto PERMITIDO- este operador permite selecionar apenas os registros do banco de dados para os quais o chamador tem permissão de leitura. Esses direitos são configurados no nível do registro (RLS).

Sintaxe: ALLOWED é escrito após a palavra-chave SELECT

Exemplo de uso:

Request.Text = "SELECIONE PERMITIDO | Contrapartes. Link | FROM | Diretório. Contrapartes AS Contrapartes";

6. Projeto VÁRIOS- permite selecionar registros nos quais não há registros duplicados.

Sintaxe: VARIOUS é escrito após a palavra-chave SELECT

Exemplo de uso:

Request.Text = //seleciona registros aos quais o leitor tem direitos "SELECT VARIOUS | Counterparties.Name |FROM | Directory. Counterparties AS Counterparties" ;

Além disso, a construção VÁRIAS pode ser usada com o operador PERMITIDO e outros operadores.

Exemplo de uso:

Request.Text = //seleciona vários registros aos quais o leitor tem direitos "SELECT ALLOWED VARIOUS | Counterparties.Name |FROM | Directory. Counterparties AS Counterparties";

7. Projete PRIMEIRO- seleciona o número de registros especificados no parâmetro do resultado da consulta.

Sintaxe: PRIMEIRO<число>

Exemplo de uso:

Request.Text = //selecione os 4 primeiros números CCD do diretório "SELECT FIRST 4 | CCD Numbers. Link | FROM | Directory. CCD Numbers AS CCD Numbers";

8. Design PARA MUDANÇA- permite bloquear uma tabela, funciona apenas em transações (relevante apenas para bloqueios automáticos).

Sintaxe: PARA MUDAR<НаименованиеТаблицы>

Exemplo de uso:

9. Projeto ORDENAR POR- organiza os dados por um campo específico. Se o campo for um link, ao definir o sinalizador PEDIDO AUTOMÁTICO A classificação ocorrerá pela representação do link; se o sinalizador estiver desativado, os links serão classificados pela antiguidade do endereço do link na memória.

Sintaxe: ORDENAR POR<НаименованиеПоля>PEDIDO AUTOMÁTICO

Exemplo de uso:

10. Projeto GRUPO POR- usado para agrupar strings de consulta por campos específicos. Os campos numéricos devem ser usados com qualquer função agregada.

Sintaxe: Agrupar por<НаименованиеПоля1>, .... , <НаименованиеПоляN>

Exemplo de uso:

11. Projeto TENDO- permite aplicar uma função agregada a uma condição de seleção de dados, semelhante à construção WHERE.

Sintaxe: TENDO<агрегатная функция с условием>

Exemplo de uso:

12. Construção ÍNDICE POR- usado para indexar o campo de consulta. Uma consulta com indexação leva mais tempo para ser concluída, mas acelera a pesquisa nos campos indexados. Só pode ser usado em tabelas virtuais.

Sintaxe: ÍNDICE POR<Поле1, ... , ПолеN>

Exemplo de uso:

13. Projete ONDE- permite impor uma condição a qualquer campo de seleção. O resultado incluirá apenas registros que satisfaçam a condição.

Sintaxe: ONDE<Условие1 ОператорЛогСоединения УсловиеN>

Exemplo de uso:

Query.Text = //todos os registros com CompensationRemaining são selecionados<>0 e //AmountForCalcCompRemaining > 100 "SELECT | CompensationRPORemains.Counterparty, |CompensationRPORemains.Child, | CompensationRPORemains.CompensationRemaining, | CompensationRPORemains.AmountForCalcCompRemains |Place DataTz |FROM | Registro de acumulação.CompensationRP.Remains AS CompensationRPRemains | WHERE |CompensationRPORemaining. Compensação Restante<>0 | E CompensationRPORemains.AmountForCalcCompRemaining> 100" ;

14. RESULTADOS DO PROJETO... GERAL- usado para calcular totais; o design especifica os campos pelos quais os totais serão calculados e funções agregadas aplicadas aos campos de total. Ao usar totais para cada campo seguindo a construção TOTAL, os dados são agrupados. Existe uma construção GENERAL opcional; seu uso também fornece agrupamento adicional. Você verá um exemplo do resultado da solicitação abaixo.

Sintaxe: RESULTADOS<АгрегатнаяФункция1, ... , АгрегатнаяФункцияN>POR<ОБЩИЕ> <Поле1, ... , ПолеN>

Exemplo de uso:

A figura descreve os agrupamentos que foram formados durante a execução da solicitação, o superior refere-se à seção GERAL e o segundo ao campo Tipo de Acordo de Contraparte.

Uma consulta é uma ferramenta poderosa que serve para obter e processar rapidamente (em comparação com todos os outros métodos) dados contidos em vários objetos da base de informações 1C.

Crie uma solicitação

A solicitação é criada como um objeto separado que possui um atributo obrigatório Texto, onde a solicitação em si é realmente colocada. Além disso, diversos parâmetros necessários à sua execução podem ser passados para a requisição. Após o preenchimento do texto e dos parâmetros da solicitação, a solicitação deve ser executada e o resultado da execução colocado em uma seleção ou tabela de valores. Tudo se parece com isto:

//Cria uma solicitação
Solicitação = nova Solicitação;

//Preencha o texto da solicitação
Solicitar. Texto= “Aqui escrevemos o texto do pedido”;

//Passa parâmetros para a requisição
Solicitar. SetParameter("NomeParâmetro", ParameterValue);

//Executa a requisição
Resultado = Consulta. Correr() ;

//Carrega o resultado da consulta para a seleção
Amostra = Resultado. Escolher() ;

//Carrega o resultado da consulta na tabela de valores
Tabela = Resultado. Descarregar() ;

//Últimas ações podem ser combinadas
Buscar = Consultar. Correr() . Escolher() ;
//ou
Tabela = Consulta. Correr() . Descarregar() ;

Noções básicas da linguagem de consulta 1C

As consultas mais simples e usadas com mais frequência são usadas para obter dados de alguma fonte. A fonte pode ser quase todos os objetos contendo quaisquer dados: diretórios, documentos, registros, constantes, enumerações, planos para tipos de características, etc.

A partir desses objetos, por meio de uma consulta, você pode obter os valores de detalhes, partes da tabela, detalhes das partes da tabela, alterações, recursos, etc.

Para obter o texto da solicitação, muitas vezes é conveniente usar Solicitar construtor.É chamado quando você clica com o botão direito em qualquer lugar do módulo do programa.

Por exemplo, se você precisar obter os valores de todos os detalhes do diretório Contrapartes, então a solicitação ficará assim:

Solicitar. Texto = "ESCOLHER
| *
|DE
| Diretório. Contrapartes";

Se você precisar obter apenas detalhes individuais, faça o seguinte:

Para receber esse texto de solicitação em Construtor de consulta você precisa selecionar os campos apropriados na guia Tabelas e campos.

Você pode atribuir aliases aos elementos e fontes selecionados na consulta e utilizá-los posteriormente na própria consulta e ao trabalhar com o resultado. Além disso, a solicitação pode conter campos com valor específico predefinido ou com valor calculado:

Solicitar. Texto = "ESCOLHER
| Clientes.Code AS Número,

| 1000 AS CampoComValor
|DE
;

Buscar = Consultar. Correr() . Escolher() ;

Tchau Seleção. Próximo() Loop
NúmeroCliente = Amostra. Número;
NomeCliente = Seleção. Nome;
Valor = Amostra. CampoComValor;
Fim do Ciclo;

Use a guia para definir aliases Uniões/aliases V Construtor de consultas.

Um campo com valor fixo ou calculado é criado manualmente na aba Tabelas e campos, em uma coluna Campos.

Todos os elementos selecionados podem ser organizados em ordem direta ou inversa. Você pode selecionar um ou mais campos para pedido. Junto com a organização, às vezes pode ser útil selecionar apenas um ou alguns dos primeiros itens.

Você pode limitar a seleção de itens àqueles aos quais o usuário tem direitos de acesso. Ou remova linhas duplicadas do resultado da consulta.

A ordem é definida na guia Ordem V Construtor de consultas o número de elementos selecionados, parâmetros de resolução e repetibilidade estão na guia Adicionalmente.

Continua…

Tudo sobre tuning de carros

Criando e trabalhando com solicitações (para iniciantes). Criando e trabalhando com consultas (para iniciantes) tipo 1c de documento em uma consulta

Funções da linguagem de consulta 1C

Construções na linguagem de consulta 1C

Crie uma solicitação

Noções básicas da linguagem de consulta 1C