La console de requête 1s 8.3 est une application standard. Travailler avec la console de requête
Alors, commençons par quelque chose de simple : créez un nouveau traitement dans le configurateur, nommez-le Query Console ou Query Builder, comme vous le souhaitez.
Nous pouvons immédiatement ajouter un tableau dans « Données » pour les futurs paramètres dont nous avons besoin, de sorte que dans notre console nous n'exécutions pas la requête la plus primitive, mais avec des paramètres et des liens, par exemple, pour notre travail, nous créerons une requête vers des registres périodiques. , mais ici sans Parameter instructions=&Date nulle part.
Pour créer notre table Paramètres, sur l'onglet « Données » dans sa « Partie tabulaire » nous ajouterons une nouvelle table, appelons-la Paramètres de requête, ici nous ajouterons les colonnes de cette table : 1) ParameterName, tapez string = 25 caractères ; ParameterValue, voici un type de données composite, voir Fig :
Par conséquent, comme le montre l'image, nous sélectionnons un type composite pour la colonne Valeur du paramètre : dans le menu de type qui s'ouvre, cochez la case "Type composite", sélectionnez un nombre, une chaîne (précisez 20 caractères), une date, un booléen et cochez la case à cocher du bas - AnyLink - cela signifie ce qui suit, en spécifiant les paramètres de notre demande, nous pouvons faire référence à n'importe quel objet de notre configuration, par exemple des répertoires ou des documents.
Nous devons maintenant créer le formulaire de notre future console de requêtes. En cours de traitement, allons dans l'onglet "Formulaires" et ajoutons-en un nouveau. Nous entrons dans ce formulaire et il y a déjà un champ de créativité illimité - vous pouvez organiser les deux détails que vous venez de créer et une plaque avec des paramètres comme vous le souhaitez ! Pour ce faire, vous pouvez utiliser des éléments de formulaire standard comme un groupe ou une page avec des pages (si vous préférez retourner les pages.
L'essentiel ici est une chose : après avoir fait glisser l'attribut « TextValues » dans le champ gauche de l'édition du formulaire, assurez-vous de définir « View »=Text Document Field dans ses propriétés.
Dans les propriétés de l'attribut « Query Table », vous pouvez éventuellement spécifier « Display Grid » et « Display Headers ».
Ensuite, dans la fenêtre d'édition de formulaire de droite, allez dans l'onglet « Commandes » et ajoutez un nouveau bouton, lorsque vous cliquez dessus, notre console effectuera une certaine action. Créons un bouton "Constructeur de requête", si vous le souhaitez, vous pouvez ajouter une icône au bouton, l'essentiel est de placer le bouton lui-même dans la fenêtre d'édition du formulaire de gauche - afin que nous puissions le voir ensuite dans le formulaire de droite. fenêtre d'édition, faites un clic droit sur notre bouton et sélectionnez les propriétés - dans les propriétés, cliquez sur l'élément "Action", une fenêtre modale apparaîtra avec une question - où exactement notre code de programme, que nous attribuerons au bouton - sélectionnez "Sur le client".
Le module de formulaire s'ouvrira avec une procédure vide prête à l'emploi « Constructeur de requête de procédure (commande) ». Dans cette procédure, nous décrirons l'appel au générateur de requêtes 1c8 standard. C'est très simple : Constructeur = Nouveau constructeur de requête ; Mais il y a ici des pièges : le constructeur de requêtes intégré à la plateforme fonctionne UNIQUEMENT sous un client lourd ! Par conséquent, nous insérerons la condition de l'instruction du préprocesseur #Si, mais ici vous décidez vous-même, en fonction de votre plateforme, ou si vous avez des formulaires ordinaires, alors sélectionnez " FatClientRegularApp"ou vous avez une plateforme basée sur des formulaires gérés, alors" ThickClientManagedApplication".voir fig.
Il reste maintenant à ajouter à cette procédure une condition d'enregistrement du texte de la requête, que le Query Builder générera pour nous dans les détails de notre formulaire « Texte de la demande » :
Si Constructor.OpenModal()=True Then Object.RequestText=Constructor.Text;
endIf;
Mais nous pouvons modifier manuellement quelque chose dans le texte de la requête (en mode utilisateur - dans la fenêtre d'attribut "Texte de la requête") afin que nos modifications parviennent au constructeur de requête lorsqu'il est à nouveau appelé - nous ajouterons ici une condition simple :
Sinon EmptyString(Object.QueryText) Then Constructor.Text = Object.QueryText;
endIf;
Nous avons donc le constructeur de requête en cours d'exécution, nous pouvons commencer à y créer notre future requête, mais nous sommes intéressés de voir comment la requête que nous avons créée fonctionnera ! Et pour ce faire, nous devons créer un autre bouton dans le configurateur lors de l'édition de notre formulaire console, appelons-le « Run Query ». Dans les propriétés du bouton « Run Query », cliquez sur « Action », un menu apparaît à nouveau dans lequel il nous est demandé où sera traité notre code de programme, dans dans ce cas sélectionnez « À la fois sur le client et sur le serveur », nous entrons à nouveau dans le module Forms.
Dans la procédure Execute Query(), que nous avons sur le client, nous écrirons une condition si l'utilisateur n'a pas saisi le texte de la requête, mais demande à l'exécuter :
If EmptyString(Object.QueryText) Then report("Entrez le texte de la requête !");
endIf;
Le système a déjà généré automatiquement un lien vers la procédure Execute RequestOnServer() ; - c'est bien, passons à cette procédure qui s'exécute sur le serveur, et écrivons ici le code pour exécuter notre requête saisie. Il existe des options ici : vous pouvez écrire vous-même toutes les expressions liées à la création de requêtes, c'est-à-dire manuellement, mais il y a plus option plus simple
- à l'intérieur de la procédure, faites un clic droit et dans le menu déroulant sélectionnez « Générateur de requêtes avec traitement des résultats, voir figure. » :
Si vous avez cliqué sur l'élément « Concepteur de requêtes avec traitement des résultats », alors une fenêtre modale « Le texte de la requête n'a pas été trouvé en créer un nouveau ? » apparaîtra, cliquez sur Oui. Le concepteur de requêtes intégré s'ouvrira, dans lequel. sur son premier onglet "Traitement du résultat" - sélectionnez le premier élément " Contourner le résultat." Ça y est, nous n'avons besoin de rien d'autre de ce constructeur, cliquez sur le bouton "Ok" - une fenêtre modale apparaîtra : "Non les champs sont sélectionnés dans la requête, cliquez sur "OK".
Après cela, le modèle prêt à l'emploi suivant apparaîtra dans notre procédure ExecuteRequestOnServer() :
Passons à l'expression construite par le constructeur :
Requête.Texte = "" ;
C'est tellement simple, notre bouton « Exécuter la demande » sur le formulaire de traitement est déjà pratiquement opérationnel, pour l'instant il ne peut traiter que des demandes simples sans paramètres, mais l'essentiel est que ça marche ! Il ne reste plus qu'à afficher visuellement les résultats de notre demande dans l'attribut « Table des valeurs » du formulaire de traitement. Je vous rappelle que notre attribut « Table de valeurs » est de type « Document tabulaire », car sinon nous ne verrons pas nos résultats en mode utilisateur. La sortie des données tabulaires vers l'utilisateur est toujours gérée soit par un document tabulaire, soit par une mise en page. J'aimerais vraiment qu'il soit possible d'afficher les données via un tableau de valeurs - car il est très simple à utiliser et familier, mais. , malheureusement, une table de valeurs n'est qu'un outil dont un développeur a besoin, vous ne pouvez pas afficher de données à l'écran en l'utilisant...
Examinons de plus près ce qu'est une feuille de calcul - c'est comme une feuille Excel - vous pouvez accéder à un enregistrement dans une cellule spécifique uniquement en utilisant les cellules du tableau, nous les appelons ici une zone, mais nous pouvons nous-mêmes sélectionner la plage de cette zone dans une cellule spécifique :
Nous avons donc compris ce qu'est une feuille de calcul et déterminé nous-mêmes que nous devrons définir les données de notre requête dans une cellule spécifique de cette feuille de calcul. Mais réfléchissons : quel est le « résultat de la requête » que le concepteur a généré si rapidement pour nous ? Ouvrez l'aide - Le résultat de la requête est une table qui possède les propriétés appropriées ! voir fig.
Et si nous écrivons maintenant après l'expression Query Result = Query.Execute(); (créée par le constructeur), voici un cycle si simple pour les collections :
Pour chaque nom de colonne de la requête Result.Columns Loop report (ColumnName.Name) ;
Fin du cycle ;
Après ce cycle, pour l'instant, notez toutes les expressions construites automatiquement par le constructeur. Et exécutez 1C:Enterprise8 sous le client lourd. Créez n'importe quelle requête simple (vous pouvez utiliser le Query Builder - cela fonctionne déjà pour nous) et cliquez sur le bouton « Exécuter la requête » :
Ensuite, vous verrez au bas de la fenêtre de message - que la table des résultats de la requête stocke les noms des champs que nous venons de sélectionner en créant une simple requête.
Affichons maintenant ces noms des domaines de notre souffrance dans un tableur :
Pour afficher les détails des données de la requête, analysons les expressions créées automatiquement par le concepteur et insérons dans la boucle de tri « SelectionDetailedRecords » de la requête elle-même exactement la même boucle que celle que nous avons utilisée pour afficher les noms de colonnes, seulement maintenant nous devons passer pas les données du tableau « Résultat de la requête » dans le texte de la cellule et les données de la sélection elle-même, voyons dans l'aide comment accéder au champ Sélection détaillée de la requête :
SelectionDetailRecords = QueryResult.Select();
Tandis que SelectionDetailedRecords.Next() Loop //dans la première ligne, nous avons déjà écrit les noms des colonnes du tableau, nous chargeons donc les données sous la première ligneDocRowNumber=Object.QueryTable.TableHeight+1;
Pour chaque nom de colonne de la requête Result.Columns Cycle Cell=Object.QueryTable.Area(DocRowNumber,QueryResult.Columns.Index(ColumnName)+1);
Cell.Text = SelectionDetailedRecords[ColumnName.Name] ;
Fin du cycle ; Fin du cycle ;Ça y est, on peut vérifier, charger l'entreprise sous un client lourd, saisir une requête simple sans paramètres, cliquer sur le bouton "Run Query", voir figure :
Hourra, tout fonctionne !!!
C'est très pratique lorsque, lors de l'ouverture/fermeture de notre console de requête, notre texte de requête, avec lequel nous avons travaillé avant de fermer la console, est à nouveau écrit dans le champ « Texte de requête ». Pour cela, il vous suffit d'activer la propriété form = Autosave, voir fig :
Ça y est, notre console fonctionne. Afin que nous puissions écrire des requêtes plus complexes avec des paramètres spécifiés, nous devons créer un autre bouton "Rechercher les paramètres", ainsi que le code du bouton "Exécuter la requête" - le code du bouton "Rechercher les paramètres" sera exécuté sur le client et sur le serveur. Ensuite, dans la procédure serveur, nous lançons la requête exactement de la même manière avec le texte qui y est passé depuis la fenêtre « Request Text », en utilisant l'expression « Request.FindParameters() » nous trouvons les paramètres passés et les saisissons simplement dans la boucle
Le téléchargement contient un exemple de la console de requête que nous venons de créer.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Mise à niveau de la console de requête :
1) Désormais, notre console de requêtes maison avec un générateur de requêtes intégré fonctionnera sous n'importe quel client : sous un client lourd de formulaires réguliers et gérés et sous un client léger et Web.
p.s. La forme et l'apparence du Query Builder intégré sont différentes - selon le client sous lequel nous avons lancé notre console (personnellement, je suis plus familier et plus pratique avec la forme du Query Builder sous un client lourd).
&Sur le constructeur de requête de procédure client (commande) //l'appel du constructeur de requête standard n'est possible que sous un client lourd #If ThickClientManagedApplication ou ThickClientNormalApplication Then Constructor=Nouveau constructeur de requête ;
Sinon EmptyString(Object.QueryText) Then Constructor.Text = Object.QueryText;
endIf;
Si Constructor.OpenModal()=True Then Object.RequestText=Constructor.Text;
SELECT ExternalData.Product, ExternalData.Quantity PLACE ExternalData FROM &ExternalData AS ExternalData; ///////////////////////////////////////////// // /////////////////////////// SELECT ExternalData.Product, ExternalData.Quantity, ISNULL (RemainingProductRemaining.QuantityRemaining, 0) AS Field1, ISNULL (RemainingProductRemaining.QuantityRemaining, 0) AS Field1, ISNULL (Remaining ProductsRemainings.QuantityRemaining, 0) - ExternalData.Quantity AS Remaining FROM ExternalData AS ExternalData LEFT JOIN Registre Accumulations.Remaining Products.Remainings(&Date, Product IN (SELECT ExternalData.Product FROM ExternalData AS ExternalData)) AS Remaining ProductsRemaining ki software ExternalData.Product = Produit restantProduit restant.
Sur la base de l'exemple et de la similitude du code de requête ci-dessus, vous pouvez créer votre propre requête complexe, en tenant compte de vos objets de données.
Ainsi, dans le concepteur de requêtes, nous avons créé la requête ci-dessus, en fermant le constructeur - le texte de la requête ira dans notre champ de console "Texte de requête", cliquez sur le bouton "Rechercher les paramètres", nous voyons qu'une ligne est apparue dans le tableau Paramètres = "Données externes", Type de valeur="Tableau des valeurs", voir fig.
Dans ce tableau de paramètres - entrez le paramètre Date, par exemple la date du jour, puis cliquez pour essayer de modifier notre paramètre de table temporaire "Données externes", cliquez dans le champ avec "Tableau des valeurs" sur trois points - une sélection de types apparaîtra apparaît, cliquez sur Row, notre mécanisme nous fait tourner la page du formulaire, où nous devons saisir manuellement ce tableau très temporaire.
Notez ici que dans ce cas, sur la page « Horaires » en bas dans le champ « Nom de la table temporaire dans les paramètres », le nom de notre table temporaire apparaîtra (il est copié de la table Paramètres).
Jusqu'à présent, sur la page « Tables horaires », nous ne voyons qu'une seule table vide - c'est la table des types de notre future table temporaire. À l'aide du bouton « Ajouter », nous ajouterons le nom de l'attribut et le type de la future table. . Attention : le nom et le type doivent correspondre à ce que nous avons spécifié dans la demande de &ExternalData :
Maintenant, nous appuyons sur le bouton « Mettre à jour la table temporaire » - et nous aurons ici une deuxième table - nous la remplirons directement avec les données de la table temporaire via le bouton « Ajouter ».
Ça y est, nous pouvons vérifier à nouveau si nous avons saisi les données primitives des paramètres de requête dans le tableau des paramètres sur la 1ère page de traitement, et cliquer sur le bouton "Exécuter la requête" - tout est calculé et sélectionné en conséquence avec le limitation des données passées en paramètre de notre table temporaire
p.s. Si vous avez fait une erreur en tapant le nom des détails et leurs types (dans le premier tableau) - fermez simplement la console et rouvrez-la - la table de données temporaire sera effacée - et la table Types pourra à nouveau être modifiée et un une nouvelle table de données peut être à nouveau créée.
C'est tout, nous pouvons créer de nos propres mains un outil de travail très puissant, de plus, notre console est toujours très rapide par rapport aux consoles professionnelles - et c'est un très gros plus pour les développeurs ! Et bien sûr, notre console fonctionne désormais sous n'importe quel client ! Bonne chance dans vos développements créatifs !!!
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Je travaille constamment avec ma console de requêtes, et récemment je suis tombé sur une requête très intéressante dans laquelle les tables temporaires n'étaient pas dans le premier package de requêtes, mais dans les suivants - et ici ma console est devenue un peu déprimée... J'ai dû faire une autre mise à niveau.
Ainsi, le gestionnaire de tables temporaires dans une requête ne comprend pas toujours qu'il travaille avec)) Par conséquent, vous devez définir explicitement ce même gestionnaire de tables temporaires :
&Sur le serveur Procédure Exécuter une requête sur le serveur () //upgrade2 - définition explicite du gestionnaire de tables temporaires !
ManagerVT=Nouveau TemporaryTablesManager ;
Demande = Nouvelle demande ;
//upgrade2 - définition explicite du gestionnaire de tables temporaires !
Query.TemporaryTableManager = VTManager ;
Request.Text = Objet.RequestText ;
Cette version de la console en est au troisième téléchargement. Et obtenez rapidement des informations. Dans cet article, je vais essayer de décrire comment utiliser la console de requête et de fournir un lien pour télécharger la console de requête. Regardons de plus près cet outil. Télécharger la console de requêtes 1C).
Tout d'abord, pour commencer à travailler avec la console de requêtes, vous devez la télécharger quelque part. Le traitement est généralement divisé en deux types : les formes contrôlées et les formes conventionnelles (ou parfois appelées 8.1 et 8.2/8.3).
J'ai essayé de combiner ces deux types en un seul traitement - en
mode souhaité
le travail ouvre le formulaire requis (
en mode géré la console ne fonctionne qu'en mode épais
Le premier groupe de boutons de la barre de commandes est chargé d'enregistrer les requêtes en cours dans un fichier externe. C'est très pratique ; vous pouvez toujours revenir à la rédaction d'une demande complexe. Ou, par exemple, stockez une liste d'exemples typiques de certaines conceptions.
A gauche, dans le champ « Demande », vous pouvez créer de nouvelles demandes et les enregistrer dans une arborescence. Le deuxième groupe de boutons est chargé de gérer la liste des demandes. Grâce à lui, vous pouvez créer, copier, supprimer, déplacer une demande.
Obtenez 267 leçons vidéo sur 1C gratuitement :
- Exécuter la demande— une exécution simple et l'obtention de résultats ;
- Exécuter le package— permet de visualiser toutes les demandes intermédiaires dans
- Affichage des tables temporaires— vous permet de voir les résultats renvoyés par les requêtes temporaires dans le tableau.
Paramètres de la requête :
Vous permet de définir les paramètres actuels de la demande.
Dans la fenêtre des paramètres de requête, ce qui suit est intéressant :
- Bouton Récupérer à partir d'une demande trouve automatiquement tous les paramètres dans la demande pour la commodité du développeur.
- Drapeau Paramètres communs à toutes les requêtes— une fois installé, son traitement n'efface pas les paramètres lors du passage de requête en requête dans la liste générale des requêtes.
Définir un paramètre avec une liste de valeurs C'est très simple, juste au moment de choisir une valeur de paramètre, cliquez sur le bouton d'effacement de la valeur (croix), le système vous demandera de sélectionner le type de données, où vous devrez sélectionner « Liste de valeurs » :
Dans le panneau supérieur se trouve également un bouton permettant d'appeler les paramètres de la console de requête :
Où vous pouvez spécifier les paramètres d’enregistrement automatique des requêtes et les paramètres d’exécution des requêtes.
Le texte de la demande est saisi dans le champ de demande de la console. Cela peut être fait en tapant simplement un test de requête ou en appelant un outil spécial - le concepteur de requêtes.
Appelé depuis le menu contextuel ( bouton droit souris) en cliquant sur le champ de saisie :
Également dans ce menu, il y a de tels fonctionnalités utiles, comme effacer ou ajouter des tirets (« | ») à la requête, ou obtenir le code de la requête sous cette forme pratique :
Demande = Nouvelle demande ; Demande. Text = " |SELECT | Devises.Lien |FROM| Annuaire.Devises AS Devises"
;
RequestResult = Demande. Courir() ;
Le champ inférieur de la console de requête affiche le champ résultat de la requête, c'est pourquoi ce traitement a été créé :
Vous pouvez trouver de nombreuses consoles différentes sur Internet. Pour les formulaires standards et gérés, il s'agit généralement de consoles complètement différentes. Grâce à cela, vous pouvez télécharger la console de requête universelle 1C 8.3 et 8.2, qui fonctionnera dans les deux cas. Gardez simplement à l’esprit que la console de l’interface gérée ne s’ouvrira que dans le client lourd.
Travailler avec la console de requête
Dans le programme 1C, la console de requêtes s'ouvre de la même manière que tout traitement externe : menu « Fichier » - « Ouvrir », ou à l'aide de la combinaison de touches de raccourci « Ctrl + O ». S'il est utilisé fréquemment, il peut être ajouté au traitement externe de l'infobase elle-même.
Le côté gauche de la console de requêtes affiche la liste de vos requêtes. Cela vous permet de stocker non pas une seule demande, mais plusieurs à la fois. L'arborescence des requêtes a une structure hiérarchique, ce qui est très pratique pour les regrouper.
En cliquant sur le bouton « Ajouter », vous pouvez ajouter une nouvelle demande en lui donnant vous-même un nom. De plus, la fonctionnalité intégrée vous permet de créer des requêtes avec copie, de monter ou descendre dans la liste et bien plus encore.
Le texte de la demande lui-même est affiché sur le côté droit du formulaire de traitement. Il peut être écrit manuellement ou à l'aide d'un générateur de requêtes. Le générateur de requêtes ne fonctionne que dans le client lourd.
À droite du bouton du concepteur se trouve le bouton « Insérer des instructions de requête ». Il ajoutera immédiatement une structure de requête vide avec condition, regroupement, ordre et totaux.
À droite se trouvent des boutons très utiles qui vous aideront si cette demande vous utilisez lors du développement de solutions sur 1C.
Le bouton vous permet de convertir votre demande écrite en texte. Dans notre cas, cela ressemblera à la figure ci-dessous.
Vous pouvez enregistrer les demandes elles-mêmes dans un fichier ou les charger à partir de celui-ci. C'est très pratique pour une utilisation future.
Avant d'exécuter directement la requête, vous devez définir ses paramètres d'entrée (le cas échéant), puis cliquer sur le bouton « Exécuter la requête ». Il est également possible d'exécuter des requêtes non pas dans leur ensemble, mais séparément en tant que package.
Le mode d'affichage détermine la manière dont le résultat de la requête sera affiché : sous forme de liste, de liste hiérarchique ou d'arborescence.
Le résultat de l'exécution sera affiché tout en bas de la console de requête. Il affiche également le nombre de lignes reçues et le temps d'exécution. Vous pouvez déplacer les lignes de résultats de la requête si nécessaire.
Très souvent, les utilisateurs demandent de sélectionner certaines données et de les enregistrer dans Excel. Vous pourriez en avoir besoin aussi. Pour terminer la tâche, il vous suffit de sélectionner « Afficher la liste » dans le menu « Plus ». Le programme vous demandera de marquer les colonnes requises.
En plus de spécifier une liste de colonnes pour la sortie, vous pouvez également spécifier ici des lignes spécifiques. Ceci est implémenté en mettant en évidence les lignes dans la requête elle-même. Ensuite, dans le formulaire de sélection de colonne, définissez simplement le drapeau dans le paramètre « Sélectionné uniquement ».
Dans notre exemple, nous avons affiché toutes les données des résultats de la requête. Enregistrez-les dans fichier externe, peut être copié à partir de la feuille de calcul ouverte ou à l'aide de la combinaison de touches de raccourci « Ctrl+O ». Il existe de nombreuses options pour enregistrer les formats ; nous avons choisi « *. xlsx".
Comme vous pouvez le constater, travailler dans la console de requêtes est très pratique et utile, nous vous recommandons donc fortement de la télécharger et de la mettre en pratique.
L'un des plus des outils puissants 1C Enterprise 8 est, sans aucun doute, un générateur de requêtes. Le constructeur est un outil visuel pour travailler avec des requêtes dans le langage 1C. Mais le constructeur a un gros inconvénient : il n'affiche pas le résultat de l'exécution des requêtes. Cet inconvénient est particulièrement ressenti par les développeurs novices de solutions applicatives sur la plateforme 1C:Enterprise 8.3 et 8.2.
De plus, même les programmeurs 1C expérimentés sont souvent confrontés à une situation où il est nécessaire de faire une analyse « ponctuelle » des données de la base d'informations dans diverses sections, mais ils ne veulent pas rédiger un rapport à part entière pour le plaisir. d’une telle « conclusion unique ».
Pour tous ces cas et bien d’autres, nous sommes heureux de vous proposer un traitement externe Console de requête avec la possibilité de traiter les résultats pour 1C 8.3 et 1C 8.2!
Principales fonctionnalités de la console de requête pour 1C 8.3 et 1C 8.2:
Traitement universel, fonctionne sur n'importe quelle configuration de plates-formes 1C : Enterprise 8.1 – 8.3 ;
- fonctionne en mode 1C:Entreprise ;
- la requête peut être écrite manuellement, ou vous pouvez appeler le Query Builder ;
- affiche le résultat de la demande ;
- vous pouvez spécifier les paramètres du rapport directement dans la console de requête ;
- peut enregistrer et charger des fichiers de demande.
Pour lancer la Query Console, vous devez lancer votre configuration en mode 1C:Enterprise et ouvrir le traitement externe Query Console comme n'importe quel autre fichier stocké sur le disque. Ce traitement fonctionnera exactement de la même manière que s’il faisait partie d’une solution applicative.
Traitement externe La console de requête se répète interface familière et la majorité fonctionnalité outils standards pour l'élaboration des requêtes du système 1C:Enterprise 8.3 et 8.2. Il vous permet également de récupérer les résultats des requêtes, des requêtes batch et des tables temporaires.
La console de requêtes est exécutée dans les modes de fonctionnement client-serveur et serveur de fichiers du système, à la fois sous les clients lourds et légers ! La console de requête intègre un générateur de requêtes standard, appelé via menu contextuel dans le champ de texte de la demande.
IMPORTANT! Le concepteur de requêtes dans le client léger ne fonctionne pas ; cet élément du menu d'ouverture du concepteur n'est pas disponible. Dans le client lourd, le Query Builder est disponible !
Dans le client léger, nous ne pouvons écrire des requêtes qu'à la main ; toutes les autres fonctions fonctionnent sans modifications.
