O console de consulta 1s 8.3 é um aplicativo normal. Trabalhando com o Console de Consultas

Então, vamos começar com algo simples: crie um Novo Processamento no configurador, chame-o de Query Console ou Query Builder, como desejar.

Podemos adicionar imediatamente uma tabela em “Dados” para parâmetros futuros que necessitamos, para que em nosso Console executemos não a solicitação mais primitiva, mas com parâmetros e links, por exemplo, para o nosso trabalho criaremos uma solicitação para registros periódicos , mas aqui sem Parameter instruções=&Date em lugar nenhum.

Para criar nossa tabela de Parâmetros, na aba “Dados” em sua “parte Tabular” adicionaremos uma nova tabela, chamaremos de Parâmetros de Consulta, aqui adicionaremos as colunas desta tabela: 1) ParameterName, tipo string = 25 caracteres; ParameterValue, aqui está um tipo de dados composto, veja a Fig:

Portanto, conforme mostrado na imagem, selecionamos um tipo composto para a coluna Valor do Parâmetro: no menu de tipo que se abre, marque a caixa de seleção “Tipo Composto”, selecione número, string (especifique 20 caracteres), data, Booleano e marque a caixa de seleção inferior - AnyLink - significa o que segue, ao especificar os Parâmetros da nossa solicitação, podemos nos referir a qualquer objeto da nossa configuração, por exemplo, diretórios ou documentos.

Agora precisamos criar o formulário do nosso futuro Query Console. No processamento, vamos até a aba “Formulários” e adicionamos um novo. Entramos neste formulário e já existe um campo ilimitado para criatividade - você pode organizar os dois detalhes que acabou de criar e uma placa com parâmetros como quiser! Para fazer isso, você pode usar elementos de formulário padrão, como um Grupo ou uma Página com páginas (se preferir virar as páginas).

O principal aqui é uma coisa: após arrastar o atributo “TextValues” para o campo esquerdo da edição do formulário, certifique-se de definir “View”=Text Document Field em suas propriedades.

Nas propriedades do atributo “Query Table”, você pode opcionalmente especificar “Display Grid” e “Display Headers”.

A seguir, na janela direita de edição do formulário, vá até a aba “Comandos” e adicione um novo botão, ao clicar, nosso Console realizará uma determinada ação. Vamos criar um botão "Construtor de consulta", se desejar, você pode adicionar um ícone ao botão, o principal é colocar o próprio botão na janela de edição do formulário esquerdo - para que possamos vê-lo no formulário direito. janela de edição, clique com o botão direito em nosso botão e selecione propriedades - nas propriedades, clique no item "Ação", aparecerá uma janela modal com uma pergunta - onde exatamente nosso código do programa, que atribuiremos ao botão - selecione “No cliente”.

O Módulo de Formulário será aberto com um procedimento vazio pronto “Procedure Query Constructor (Command)”. Dentro deste procedimento descreveremos a chamada ao Query Builder 1c8 padrão. É muito fácil: Construtor = Construtor de Nova Solicitação; Mas há armadilhas aqui - o Query Construtor integrado à plataforma funciona no modo de usuário SOMENTE em um cliente grosso! Portanto, inseriremos a condição da instrução do pré-processador #If, mas aqui você decide por si mesmo, com base na sua plataforma, ou possui formulários comuns, então selecione " FatClientRegularApp"ou você tem uma plataforma baseada em formulários gerenciados, então" Aplicativo ThickClientManaged".veja a fig.

Agora resta adicionar a este procedimento uma condição para registrar o texto da solicitação, que o Query Builder irá gerar para nós nos detalhes do formulário “Texto da Solicitação”:

Se Constructor.OpenModal()=True Então Object.RequestText=Constructor.Text;

fimSe;

Mas podemos alterar manualmente algo no texto da solicitação (no modo de usuário - na janela de atributos "Texto da solicitação") para que nossas alterações cheguem ao Construtor de Consulta quando ele for chamado novamente - adicionaremos uma condição simples aqui:

Se não for EmptyString(Object.QueryText) Então Constructor.Text = Object.QueryText;

fimSe;

Então, estamos com o Query Constructor rodando, podemos começar a montar nele nossa futura query, mas estamos interessados ​​em ver como vai funcionar a query que criamos! E para isso, precisamos criar outro botão no configurador ao editar nosso formulário do console, vamos chamá-lo de “Executar Consulta”. Nas propriedades do botão “Executar Consulta”, clique em “Ação”, aparece novamente um menu no qual nos é perguntado onde será processado o código do nosso programa, em nesse caso selecione “Tanto no cliente quanto no servidor”, novamente entramos no Módulo Formulários.

No procedimento Execute Query(), que temos no cliente, escreveremos uma condição caso o usuário não tenha inserido o texto da consulta, mas peça para executá-lo:

If EmptyString(Object.QueryText) Then report("Digite o texto da consulta!");

fimSe;

O sistema já gerou automaticamente um link para o procedimento Execute RequestOnServer(); - isso é bom, vamos para esse procedimento, que é executado no servidor, e escrever aqui o código para executar nossa solicitação inserida. Existem opções aqui: Você mesmo pode escrever todas as expressões relacionadas à construção de consultas, ou seja, manualmente, mas há mais opção mais simples

- dentro do procedimento, clique com o botão direito e no menu suspenso selecione “Construtor de consultas com processamento de resultados, veja figura.”:

Se você clicou no item “Designer de consulta com processamento de resultados”, aparecerá uma janela modal “O texto da consulta não foi encontrado, clique em sim. em sua primeira aba “Processando o resultado” - selecione o primeiro item " Ignorando o resultado." É isso, não precisamos de mais nada deste construtor, clique no botão "Ok" - aparecerá uma janela modal: "Não campos estiverem selecionados na solicitação, clique em "OK".

Depois disso, o seguinte modelo pronto aparecerá dentro do nosso procedimento ExecuteRequestOnServer():

Vamos passar para a expressão construída pelo construtor:

Solicitação.Text = "";

É tão simples, nosso botão “Executar Solicitação” no formulário de processamento já está praticamente operacional, até o momento só consegue processar solicitações simples sem parâmetros, mas o principal é que funciona! Resta exibir visualmente os resultados da nossa solicitação no atributo “Tabela de Valores” do formulário de processamento. Deixe-me lembrar que nosso atributo “Tabela de Valores” é do tipo “Documento Tabular”, pois caso contrário não veremos nossos resultados no modo usuário. A saída de dados tabulares para o usuário é sempre feita por um Documento Tabular ou por um Layout. Gostaria muito que fosse possível exibir os dados através de uma tabela de valores - já que é muito fácil de usar e familiar, mas. , infelizmente, uma tabela de valores é apenas uma ferramenta que um desenvolvedor precisa, você não pode exibir dados na tela usando ela...

Vamos dar uma olhada mais de perto no que é um Documento de Planilha - é como uma planilha Excel - você pode chegar a um registro em uma célula específica apenas usando Células de Tabela, aqui as chamamos de área, mas nós mesmos podemos selecionar o intervalo desta área em uma célula específica:

Então, descobrimos o que é um documento de planilha e determinamos por nós mesmos que precisaremos definir os dados de nossa consulta em uma célula específica deste documento de planilha. Mas vamos pensar: qual é o “Resultado da Consulta” que o designer gerou tão rapidamente para nós? Abra a ajuda - O resultado da consulta é uma tabela que possui as propriedades apropriadas! veja a fig.

E se agora escrevermos após a expressão Query Result = Query.Execute(); (criada pelo construtor), aqui está um ciclo simples para Coleções:

Para cada ColumnName da consulta Result.Columns Loop report(ColumnName.Name);

Fim do Ciclo;

Após este ciclo, por enquanto, anote todas as expressões construídas automaticamente pelo construtor. E execute 1C:Enterprise8 no cliente grosso. Crie qualquer consulta simples (você pode usar o Query Builder - já funciona para nós) e clique no botão “Executar consulta”:

Então você verá na parte inferior da janela da mensagem que a tabela Resultado da Consulta armazena os nomes dos campos que acabamos de selecionar criando uma consulta simples.

Agora vamos exibir estes nomes dos campos do nosso sofrimento em uma planilha:

Para exibir os detalhes dos dados da consulta, vamos analisar as expressões criadas automaticamente pelo designer e inserir no loop de classificação “SelectionDetailedRecords” da própria consulta exatamente o mesmo loop que usamos para exibir os nomes das colunas, só que agora precisamos passar não os dados da tabela “Resultado da Consulta” no texto da Célula e os dados da Seleção em si, vamos ver na ajuda como você pode acessar o campo Seleção Detalhada da solicitação:

SelectionDetailRecords = QueryResult.Select();

Enquanto SelectionDetailedRecords.Next() Loop //na primeira linha já temos os nomes das colunas da tabela anotados, então carregamos os dados abaixo da primeira linhaDocRowNumber=Object.QueryTable.TableHeight+1;

Para cada ColumnName da consulta Result.Columns Cycle Cell=Object.QueryTable.Area(DocRowNumber,QueryResult.Columns.Index(ColumnName)+1);

Cell.Text = SelectionDetailedRecords[ColumnName.Name];

Fim do Ciclo; Fim do Ciclo;É isso, podemos verificar, carregar o empreendimento em um cliente grosso, inserir uma solicitação simples sem parâmetros, clicar no botão “Executar Consulta”, veja a figura:

Viva, tudo funciona!!!

É muito conveniente quando, ao abrir/fechar nosso Query Console, nosso texto de consulta, com o qual trabalhamos antes de fechar o console, é novamente escrito no campo “Query Text”. Para fazer isso, basta habilitar a propriedade do formulário = Autosave, veja a fig:

É isso, nosso console está funcionando. Para que possamos escrever consultas mais complexas com os parâmetros especificados nelas, precisamos criar outro botão “Find Parameters”, bem como o código do botão “Run Query” - o código do botão “Find Parameters” será executado no cliente e no servidor. A seguir, no procedimento do servidor, lançamos a solicitação exatamente da mesma forma com o texto passado para ela a partir da janela “Request Text”, usando a expressão “Request.FindParameters()” encontramos os parâmetros passados ​​​​e simplesmente inseri-los em o laço

O download contém uma amostra do Query Console que acabamos de criar.

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Atualização do Console de Consultas:

1) Agora, nosso Query Console caseiro com um Query Builder integrado será executado em qualquer cliente: em um cliente espesso de formulários regulares e gerenciados e em um cliente thin e web.

p.s. A forma e a aparência do Query Builder integrado são diferentes - dependendo de qual cliente lançamos nosso Console (eu pessoalmente estou mais familiarizado e mais conveniente com a forma do Query Builder em um cliente grosso).

&No Construtor de Consulta de Procedimento do Cliente (Comando) //chamar o Construtor de Consulta padrão só é possível em um cliente espesso #If ThickClientManagedApplication ou ThickClientNormalApplication Then Constructor=Novo Construtor de Consulta;

Se não for EmptyString(Object.QueryText) Então Constructor.Text = Object.QueryText;

fimSe;

Se Constructor.OpenModal()=True Então Object.RequestText=Constructor.Text;

SELECIONE Dados Externos.Produto, Dados Externos.Quantidade COLOQUE Dados Externos FROM &DadosExternos COMO DadosExternos; //////////////////////////////////////////// // ///////////////////////// SELECT ExternalData.Product, ExternalData.Quantity, ISNULL(RemainingProductRemaining.QuantityRemaining, 0) AS Field1, ISNULL(Remaining ProductsRemainings.QuantityRemaining, 0) - ExternalData.Quantity AS Remaining FROM ExternalData AS ExternalData LEFT JOIN Registrar Acumulações.Remaining Products.Remainings(&Data, Produto IN (SELECT ExternalData.Product FROM ExternalData AS ExternalData)) AS Remaining ProductsRemaining ki software ExternalData.Product = Produto RestanteProduto Restante.

Com base no exemplo e na semelhança do código de consulta acima, você pode criar sua própria consulta complexa, levando em consideração seus objetos de dados.

Assim, no Query Designer criamos a consulta acima, fechando o Construtor - o texto da consulta irá para o campo “Query Text” do nosso console, clique no botão “Find Parameters”, vemos que na tabela Parameters uma linha apareceu = "Dados Externos", Tipo de Valor = "Tabela de Valores", veja a fig.

Nesta tabela de Parâmetros - insira o parâmetro Data, por exemplo, a data de hoje, depois clique para tentar editar nossa tabela temporária parâmetro "Dados Externos", clique no campo com "Tabela de Valores" em três pontos - uma seleção de tipos irá aparecer, clique em Linha, nosso mecanismo nos vira a página do formulário, onde precisamos inserir manualmente esta tabela muito temporária.

Observe aqui que neste caso, na página “TimeTables” na parte inferior do campo “Nome da tabela temporária nos parâmetros”, aparecerá o nome da nossa tabela temporária (ela é copiada da tabela Parâmetros).

Até agora, na página “Tabelas de Tempo” vemos apenas uma tabela vazia - esta é a tabela de Tipos da nossa futura tabela temporária. Usando o botão “Adicionar”, adicionaremos o nome do atributo e o tipo da futura tabela. . Tenha cuidado - o nome e o tipo devem corresponder ao que especificamos na solicitação de &ExternalData:

Agora pressionamos o botão “Atualizar Tabela Temporária” - e teremos aqui uma segunda tabela - iremos preenchê-la diretamente com os dados da tabela temporária através do botão “Adicionar”.

É isso, podemos verificar mais uma vez se inserimos os dados primitivos dos parâmetros de consulta na tabela de parâmetros da 1ª página de processamento e clicar no botão "Executar Consulta" - tudo é calculado e selecionado de acordo com o limitação dos dados passados ​​no parâmetro da nossa tabela temporária

p.s. Se você cometeu um erro ao digitar o nome dos detalhes e seus tipos (na primeira tabela) - basta fechar o Console e abri-lo novamente - a tabela de dados temporária será apagada - e a tabela de Tipos poderá ser editada novamente e um nova tabela de dados pode ser criada novamente.

Só isso, podemos criar uma ferramenta de trabalho muito poderosa com nossas próprias mãos, além disso, nosso console ainda é muito rápido se comparado aos profissionais - e isso é uma grande vantagem para os desenvolvedores! E, claro, agora nosso console funciona em qualquer cliente! Boa sorte em seus desenvolvimentos criativos!!!

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Trabalho constantemente com meu Query Console, e recentemente me deparei com uma consulta muito interessante em que as tabelas temporárias não estavam no primeiro pacote de consultas, mas sim nos seguintes - e aqui meu console ficou um pouco deprimido... Tive que fazer outra atualização.

Portanto, o Gerenciador de Tabelas Temporárias em uma consulta nem sempre entende que está trabalhando com ele)) Portanto, você precisa definir explicitamente este mesmo Gerenciador de Tabelas Temporárias:

&No Servidor Procedimento Executar Consulta no Servidor () //upgrade2 - definição explícita do gerenciador de Tabelas Temporárias!

ManagerVT=Novo TemporaryTablesManager;

Solicitação = Nova Solicitação;

//upgrade2 - definição explícita do gerenciador de Tabela Temporária!

Query.TemporaryTableManager = VTManager;

Request.Text = Object.RequestText;

Esta versão do console está no terceiro download. E obtenha informações rapidamente. Neste artigo, tentarei descrever como usar o Query Console e fornecer um link para fazer download do Query Console. Vamos dar uma olhada mais de perto nesta ferramenta. Baixe o console de consulta 1C).

Primeiro de tudo, para começar a trabalhar com o console de consulta, você precisa baixá-lo de algum lugar. O processamento é geralmente dividido em dois tipos – formas controladas e convencionais (ou às vezes chamadas de 8.1 e 8.2/8.3).

Tentei combinar esses dois tipos em um tratamento - em

modo desejado

trabalho abre o formulário necessário (

no modo gerenciado o console só funciona no modo grosso

O primeiro grupo de botões da barra de comandos é responsável por salvar as consultas atuais em um arquivo externo. Isso é muito conveniente; você sempre pode voltar a escrever uma solicitação complexa. Ou, por exemplo, armazene uma lista de exemplos típicos de determinados designs.

À esquerda, no campo “Solicitação”, você pode criar novas solicitações e salvá-las em uma estrutura em árvore. O segundo grupo de botões é responsável por gerenciar a lista de solicitações. Com ele você pode criar, copiar, excluir e mover uma solicitação.

Obtenha 267 videoaulas em 1C gratuitamente:

• Executar solicitação— simples execução e obtenção de resultados;
• Executar pacote— permite visualizar todas as solicitações intermediárias em
• Visualizando tabelas temporárias— permite ver os resultados retornados por consultas temporárias na tabela.

Parâmetros de solicitação:

Permite definir os parâmetros atuais da solicitação.

Na janela de parâmetros de consulta, é interessante o seguinte:

• Botão Obter da solicitação encontra automaticamente todos os parâmetros da solicitação para conveniência do desenvolvedor.
• Bandeira Parâmetros comuns para todas as solicitações— quando instalado, seu processamento não limpa os parâmetros ao passar de solicitação em solicitação na lista geral de solicitações.

Defina um parâmetro com uma lista de valoresÉ muito simples, basta ao escolher um valor de parâmetro, clicar no botão limpar valor (cruz), o sistema solicitará que você selecione o tipo de dado, onde você precisa selecionar “Lista de Valores”:

Também no painel superior há um botão para acessar as configurações do console de consulta:

Onde você pode especificar parâmetros de salvamento automático de consulta e parâmetros de execução de consulta.

O texto da solicitação é inserido no campo de solicitação do console. Isso pode ser feito simplesmente digitando um teste de consulta ou chamando uma ferramenta especial - o designer de consulta.

Chamado a partir do menu de contexto ( botão direito mouse) ao clicar no campo de entrada:

Também neste menu existem tais recursos úteis, como limpar ou adicionar hífens (“|”) à solicitação ou obter o código da solicitação neste formato conveniente:

Solicitação = Nova Solicitação; Solicitar. Text = " |SELECIONE | Moedas.Link |FROM| Directory.Currencies AS Moedas"

;

RequestResult = Solicitação. Correr() ;

O campo inferior do console de consulta exibe o campo de resultado da consulta, por isso este processamento foi criado:

Você pode encontrar muitos consoles diferentes na Internet. Para formulários regulares e gerenciados, geralmente são consoles completamente diferentes. Usando isso você pode baixar o console de consulta universal 1C 8.3 e 8.2, que funcionará em ambos os casos. Lembre-se de que o console na interface gerenciada só abrirá no cliente grosso.

Trabalhando com o Console de Consultas

No programa 1C, o console de consulta abre da mesma forma que qualquer processamento externo: menu “Arquivo” - “Abrir”, ou usando a combinação de teclas de atalho “Ctrl + O”. Se usado com frequência, pode ser adicionado ao processamento externo da própria infobase.

O lado esquerdo do console de solicitações exibe a lista de suas solicitações. Isso permite armazenar não apenas uma solicitação, mas várias de uma vez. A árvore de consulta possui uma estrutura hierárquica, o que é muito conveniente para agrupá-los.

Ao clicar no botão “Adicionar”, você pode adicionar uma nova solicitação, dando-lhe você mesmo um nome. Além disso, a funcionalidade integrada permite criar consultas com cópia, mover para cima ou para baixo na lista e muito mais.

O próprio texto da solicitação é exibido no lado direito do formulário de processamento. Ele pode ser escrito manualmente ou usando um construtor de consultas. O construtor de consultas funciona apenas no cliente grosso.

À direita do botão do designer está o botão “Inserir instruções de consulta”. Ele adicionará imediatamente uma estrutura de consulta vazia com condição, agrupamento, ordem e totais.

À direita estão botões muito úteis que ajudarão se este pedido você usa ao desenvolver soluções em 1C.

O botão permite converter sua solicitação escrita em texto. No nosso caso, será semelhante à figura abaixo.

Você pode salvar as próprias solicitações em um arquivo ou carregá-las dele. Isto é muito conveniente para uso futuro.

Antes de executar diretamente a solicitação, você deve definir seus parâmetros de entrada (se houver) e clicar no botão “Executar solicitação”. Também é possível executar solicitações não como um todo, mas separadamente como um pacote.

O modo de visualização determina como o resultado da consulta será exibido: como lista, lista hierárquica ou árvore.

O resultado da execução será exibido na parte inferior do console de solicitação. Também exibe o número de linhas recebidas e o tempo de execução. Você pode mover as linhas de resultados da consulta, se necessário.

Muitas vezes, os usuários pedem para selecionar alguns dados e salvá-los no Excel. Você pode precisar disso também. Para completar a tarefa, basta selecionar “Exibir lista” no menu “Mais”. O programa solicitará que você marque as colunas obrigatórias.

Além de especificar uma lista de colunas para saída, você também pode especificar linhas específicas aqui. Isso é implementado destacando as linhas na própria consulta. A seguir, no formulário de seleção de colunas, basta definir o sinalizador na configuração “Somente selecionados”.

Em nosso exemplo, exibimos todos os dados do resultado da consulta. Salve-os em arquivo externo, pode ser copiado do documento de planilha aberto ou usando a combinação de teclas de atalho “Ctrl+O”. Existem muitas opções para salvar formatos; escolhemos “*. xlsx".

Como você pode ver, trabalhar no console de consulta é muito conveniente e útil, por isso recomendamos baixá-lo e colocá-lo em prática.

Um dos mais ferramentas poderosas 1C Enterprise 8 é, sem dúvida, um Query Builder. O construtor é uma ferramenta visual para trabalhar com consultas na linguagem 1C. Mas o construtor tem uma grande desvantagem - ele não mostra o resultado da execução de consultas. Esta desvantagem é sentida especialmente por desenvolvedores novatos de soluções de aplicativos na plataforma 1C:Enterprise 8.3 e 8.2.

Além disso, mesmo programadores 1C experientes muitas vezes se deparam com uma situação em que é necessário fazer uma análise “única” dos dados da base de informações em várias seções, mas não querem escrever um relatório completo por causa de tal “conclusão única”.

Para todos estes e muitos outros casos, temos o prazer de lhe oferecer processamento externo Console de consulta com capacidade de processar resultados para 1C 8.3 e 1C 8.2!

Principais recursos do Query Console para 1C 8.3 e 1C 8.2:

Processamento universal, executado em qualquer configuração de plataformas 1C: Enterprise 8.1 – 8.3;
- funciona no modo 1C:Enterprise;
- a consulta pode ser escrita manualmente ou você pode chamar o Query Builder;
- mostra o resultado da solicitação;
- você pode especificar parâmetros de relatório diretamente no Query Console;
- pode salvar e carregar arquivos de solicitação.

Para iniciar o Query Console, você precisa iniciar sua configuração no modo 1C:Enterprise e abrir o processamento externo do Query Console como qualquer outro arquivo armazenado no disco. Esse processamento funcionará exatamente como se fizesse parte de uma solução de aplicativo.

Processamento externo O console de consultas se repete interface familiar e a maioria funcionalidade ferramentas padrão para elaboração de consultas do sistema 1C:Enterprise 8.3 e 8.2. Também permite recuperar os resultados de consultas, consultas em lote e tabelas temporárias.

O console de consulta é executado nos modos operacional cliente-servidor e servidor de arquivos do sistema, tanto em clientes grossos quanto em clientes finos! O Query Console integra um Query Builder padrão, chamado via menu de contexto no campo de texto da solicitação.

IMPORTANTE! O designer de consultas no thin client não funciona; este item no menu de abertura do designer não está disponível. No cliente grosso, o Query Builder está disponível!

No thin client, só podemos escrever solicitações manualmente; todas as outras funções funcionam sem alterações.