Langage de requête 1C Entreprise. Créer et utiliser des requêtes (pour les débutants)

Objectif du cours : donner aux étudiants une compréhension globale du langage de requête de la plate-forme 1C:Enterprise 8 - l'un des mécanismes les plus importants du langage intégré du système. Le cours examine les constructions du langage : le but de chaque construction et sa syntaxe. Chaque dessin est utilisé dans une tâche pédagogique et pratique. Ceci, à son tour, dans les travaux pratiques futurs, permettra au développeur de choisir raisonnablement certaines constructions de langage de requête, augmentant ainsi l'efficacité du code du programme.

Ainsi, ce cours est destiné aux développeurs qui souhaitent maîtriser le langage de requête de la plateforme 1C:Enterprise 8.

Une connaissance sûre du langage de requête est requise par un développeur 1C dans pratiquement toutes les tâches rencontrées dans sa pratique : programmation du traitement de documents de différentes classes, solution associée de problèmes de comptabilité et de calcul, etc., et est également absolument nécessaire lors de l'élaboration de rapports. en utilisant les données du système de mise en page (SKD).

Le cours est calculé pour les étudiants familiarisés avec les bases du langage intégré de la plateforme 1C:Enterprise 8, des objets programme et des objets métadonnées.

Le coût d'un cours de jour à temps plein comprend :

• 3 jours de 10h00 à 17h00
• matériel pédagogique
• déjeuners, pauses café

Le coût du cours du soir à temps plein comprend :

• 6 soirées de 18h40 à 21h40
• matériel pédagogique
• pauses café
• certificat du 1C-Centre de formation n°3

Le prix du cours WEB comprend :

• 6 semaines de cours, 5 webinaires avec un professeur
• attestation du Centre de Formation 1C n°3 (sous réserve d'une formation pratique)

Le coût du cours d’immersion à temps plein comprend :

• 5 jours de 10h00 à 17h00 ou 9 soirs de 18h30 à 21h30
• notes, écouteurs
• déjeuners, pauses café
• accès au matériel vidéo mis à jour pendant 2 ans après avoir terminé le cours
• certificat du 1C-Centre de formation n°3

Le prix de la diffusion en ligne comprend :

• diffusion en ligne du cours à temps plein en mode webinaire, 3 jours de 10h00 à 17h00, heure de Moscou
• manuel méthodologique sous forme imprimée (envoyé à l'avance par la poste russe)
• certificat du 1C-Centre de formation n°3

Formats de formation

Journée à temps plein

À qui s'adresse ce format :Pour ceux qui peuvent suivre une formation en dehors de leur travail et préfèrent une formation classique à temps plein.

Durée:24 heures académiques

Formation WEB

Quel est ce format :Le format proposé combine de nombreux avantages de l'enseignement à distance avec une composante en présentiel représentée par du matériel vidéo et des consultations en ligne.
Le cours WEB se compose de vidéos, de travaux pratiques et de webinaires avec des enseignants. Tous les supports de cours sont disponibles 24h/24 et 7j/7 via Internet afin que vous puissiez étudier au moment qui vous convient. Le cours est divisé en classes. Pendant la leçon, du matériel sur le sujet d'actualité est étudié, des ateliers sont organisés et des questions sont posées à l'enseignant. A la fin de chaque cours, un webinaire est organisé, au cours duquel l'enseignant examine toutes les questions reçues, les erreurs typiques et explique la bonne solution. Les enregistrements des webinaires sont disponibles sur le portail. De cette manière, plusieurs cours se succèdent. À la fin, il y a un travail indépendant final et un webinaire final.

Durée: 6 semaines

Quel est ce format :

Durée:40 heures académiques

Traduction en ligne

Quel est ce format :La diffusion en ligne est une formation sous la forme d'un webinaire en ligne, qui gagne rapidement en popularité dans notre pays. Au lieu de didacticiels vidéo spéciaux, vous bénéficiez d'une conférence « en direct » diffusée via Internet. Cela garantit un maximum de naturel dans la présentation du matériel, similaire à une formation en présentiel conventionnelle - mais le problème de la nécessité d'une présence personnelle dans le centre de formation disparaît. La seule différence avec la formation présentielle est l’absence d’interaction directe avec le public et l’enseignant.

À qui s'adresse ce format :Pour ceux qui trouvent la diffusion d’un cours traditionnel plus facile et plus pratique que les didacticiels vidéo. Pour les personnes qui souhaitent avoir le sentiment d'être personnellement présentes dans un centre de formation, où qu'elles soient dans le monde.

Durée:24 heures académiques

Quel est ce format :Un cours en immersion à temps plein est un format qui combine tous les avantages de la formation à temps plein, de l’enseignement à distance et de la formation individuelle. Les cours se déroulent dans une salle de classe équipée, vous étudiez en toute autonomie les supports de cours (vidéos pas à pas) et réalisez des ateliers. Dans le même temps, il y a un enseignant dans le public, prêt à tout moment à répondre aux questions et à aider à résoudre des problèmes pratiques, ainsi qu'à vérifier l'exactitude de leur mise en œuvre.
Avantages – consultations individuelles de l'enseignant sur vos questions, le rythme de réalisation du matériel vous convient personnellement.
Tout cela permet une étude plus approfondie du matériel de cours.
Ce cours peut être suivi depuis votre lieu de travail avec le plein effet de la présence du professeur là où se trouve l'élève ! Si cette opportunité vous intéresse, appelez-nous !

Durée:40 heures académiques

Programme de cours

1. Structures de base du langage de requête de la plateforme 1C:Enterprise 8
   • Pourquoi avons-nous besoin d’un langage de requête ?
   • Représentation de collections d'objets de base d'informations sous forme de tableaux bidimensionnels
   • Types de données des champs de table du langage de requête
   • Base d'informations pédagogiques
   • Traitement de la "Console de requêtes"
   • Création d'un fichier de stockage de liste de demandes
   • Caractéristiques générales du langage de requête Platform
   • La première demande est la plus simple
   • Quels objets d'application sont représentés par des tables de langage de requête
   • Spécifier explicitement une liste de champs de sélection
   • Commentaires en langage de requête
   • Alias ​​de champs et de tables
   • Expressions en langage de requête
     • Expressions dans la liste des champs de sélection
     • Expressions conditionnelles dans un langage de requête. Opérateur SELECT
     • Filtrage des résultats de requête. Opération OÙ
     • Expressions booléennes en langage de requête
     • Paramètres du langage de requête
     • Fonctions intégrées dans les expressions du langage de requête
     • Spécification des valeurs de données de configuration prédéfinies dans la demande. Fonction VALEUR()
   • Opérations de groupe dans un langage de requête
     • Regroupement par valeur de champ et fonctions d'agrégation
     • Sélection par la valeur du résultat d'une fonction d'agrégation : opération HAVING
   • Classement des enregistrements de résultats de requête
   • Ordre automatique des résultats de requête
   • Obtenir les N premiers enregistrements du résultat de la requête. Opération PREMIER
   • Obtention de combinaisons non répétitives de valeurs de champ de résultat de requête. Opération DIVERS
2. Échantillonnage à partir de plusieurs sources de données
   • Tâche simple : récupérer les données stockées dans les tables de différents objets de configuration
   • Produit cartésien (ou "Cartésien") d'ensembles d'enregistrements de table - sources de données
   • Résoudre le problème en imposant une condition au cartésien
   • Opération INNER JOIN de tables - sources de données
     • L'opération INNER JOIN comme forme moderne d'enregistrement des conditions de formation d'une relation
     • Commutativité de l'opération INNER JOIN
     • Jointures dans une requête multi-tables
   • Opération LEFT JOIN du langage de requête
     • Tâche : trouver les justificatifs de réception pour lesquels il n'y a aucun paiement
     • La différence entre l'opération LEFT JOIN et l'opération INNER JOIN
     • Type de données du langage de requête NULL - absence de valeur dans le champ de résultat de la requête
     • Opérateur IS NULL et fonction ISNULL()
   • Opération RIGHT JOIN du langage de requête
   • Opération langage de requête FULL JOIN
   • Opération de déréférencement d'un champ d'un type référence
   • Se référant à la partie tabulaire d'un objet en tant que tableau - une source de données. Champ Lien du tableau représentant la partie tabulaire
   • Accéder à la partie tabulaire d'un objet dans la liste des champs de sélection
   • Requêtes imbriquées
   • Combiner les résultats de plusieurs requêtes
     • Requête-jointure. Opération COMBINER
     • Talon VIDETABLE
   • Quelques opérateurs de langage de requête supplémentaires
     • Opérateur EXPRESS
     • Opérateur logique LIEN
     • Opérateur logique B() avec une sous-requête comme paramètre
3. Calculer des totaux dans une requête
   • Obtention d'enregistrements récapitulatifs à la suite d'une requête - l'opération TOTAL
   • Résumé sur plusieurs dimensions
   • Présentation du résultat de la requête avec les totaux sous la forme d'une structure (arborescente) à plusieurs niveaux
   • Résultats généraux
   • Résumé de la hiérarchie
4. Travaux pratiques avec le langage de requête
   • Tables de registre virtuel
     • Tables de langage de requête pour les registres - table physique et tables virtuelles
     • Syntaxe d'accès aux tables virtuelles. Options de table virtuelle
     • Tables de registre d'accumulation virtuelle
     • Tableaux du registre comptable virtuel
     • Quelques erreurs courantes lors de l'accès aux tables virtuelles
     • Tableaux virtuels du registre périodique des informations - Tranche du Premier et Tranche du Dernier
     • Caractéristiques de définition des conditions pour les valeurs de champ pour la table virtuelle du registre d'informations
   • Travailler avec des requêtes dans le langage intégré de Platform 8
     • Aperçu du modèle objet pour développer et exécuter des requêtes dans un langage embarqué
     • Traitement externe DevelopmentRequests.epf
     • Demande d'objet
     • Objet de résultat de requête
     • Objet SelectFromQueryResult
     • Deuxième paramètre de la méthode Select()
     • Troisième paramètre de la méthode Select()
     • Tables temporaires et requêtes par lots
5. Sources externes (bases de données externes) de données
   • Caractéristiques du travail avec des sources de données externes
   • Travail préparatoire
   • Infologie de la base de données dBase "Fournitures de jouets pour enfants"
   • Création d'une description de source de données ODBC sur le système d'exploitation Windows
   • Création et configuration d'un objet source de données externe
   • Établir une connexion et visualiser les tableaux d'une source de données externe en mode 1C:Entreprise
   • Configuration de la connexion interactive
   • Configuration de la connexion logicielle
   • Établir des connexions informationnelles (relations) sur les tables d'une source de données externe. Transformer une source externe en base de données externe
   • La définition de relations sur les tables fait de la source de données une base de données
   • Configuration des tables d'objets - déclaration des tables d'une source de données externe en tant que tables de formation de type (de référence)
   • Récupérer des données d'une base de données externe à l'aide d'une requête
   • Bases de données externes basées sur des livres MS Excel
6. Quelques techniques de requête pratiques
   • Porte logique. Possibilité de désactiver la vérification des conditions dans une requête si la valeur du paramètre est vide
   • Requête corrélée. La tâche d'obtenir les N derniers taux de change
   • Connexion thêta. La tâche d'obtenir le taux de change pour de nombreuses dates différentes
   • Obtention de résultats hiérarchiques à partir de tableaux d'objets non hiérarchiques. La tâche de construire un arbre complet de dépendances des types de calcul
   • Sélection de données à partir d'un objet de type...Liste par sélections établies à l'aide de l'objet Query Builder
7. Aide rapide sur l'utilisation du générateur de requêtes

Lire l'intégralité du programme

Contenu du cours

	Ressources totales (pages Web et pages vidéo)	Matériel vidéo (minutes totales)	Ateliers à votre rythme
Leçon 1. Capacités initiales du langage de requête, fonctions, agrégation, tri			8 (difficulté moyenne)
Leçon 2.Échantillonnage à partir de plusieurs sources de données			6 (difficulté moyenne)
Lecon 3. Calcul des totaux dans une requête, tables de registres virtuels			3 (difficulté moyenne)
Leçon 4. Travailler avec des requêtes dans le langage intégré, des sources externes (bases de données externes) de données			4 (difficulté moyenne)
Leçon 5. Quelques techniques de requête pratiques			2 (difficile)

Les pré-requis techniques:
- Accès Internet(vous pouvez vérifier votre canal de communication en vous connectant à ),
- disponibilité de la plateforme 1C:Enterprise 8.2 pour pratiquer les tâches pratiques du cours.
Assez de version "1C:Enterprise 8.2" pour apprendre la programmation.

J'ai décidé d'apporter ma contribution et de décrire les caractéristiques du langage qui n'ont pas été abordées dans les articles ci-dessus. L'article s'adresse aux développeurs débutants.

1. Conception « IZ ».

Pour obtenir des données de la base de données, il n'est pas du tout nécessaire d'utiliser la construction « FROM ».
Exemple : nous devons sélectionner toutes les informations sur les banques dans l'annuaire des banques.
Demande:

SELECT Répertoire.Banques.*

Sélectionne tous les champs du répertoire des banques. Et est similaire à la demande :

SELECT Banques.* FROM Répertoire.Banques AS Banques

2. Classement des données par champ de référence

Lorsque nous devons organiser les données de requête par types primitifs : « Chaîne », « Numéro », « Date », etc., alors tout est résolu en utilisant la construction « ORDER BY » si vous devez trier les données par un champ de référence ? Le champ de référence est un lien, un identifiant unique, c'est à dire En gros, un ensemble arbitraire de caractères et un ordre ordinaire peuvent produire un résultat qui n'est pas entièrement attendu. Pour commander les champs de référence, la construction "AUTO ORDER" est utilisée. Pour ce faire, vous devez d'abord trier les données directement par type de référence à l'aide de la construction "ORDER BY", puis de la construction "AUTO ORDER".

Dans ce cas, pour les documents, le classement se fera dans l'ordre "Date->Numéro", pour les ouvrages de référence dans la "Vue principale". Si le classement ne s'effectue pas par champs de référence, alors l'utilisation de la construction "AUTO ORDER" n'est pas recommandée.

Dans certains cas, la construction « AUTO ORDER » peut ralentir le processus de sélection. De même, vous pouvez réécrire sans commande automatique des documents :

3.Obtention d'une représentation textuelle d'un type référence. Conception "PRÉSENTATION".

Lorsque vous devez afficher un champ de type référence, par exemple le champ "Banque", qui est un lien vers un élément du répertoire "Banques", vous devez comprendre que lors de l'affichage de ce champ, une sous-requête vers le " Banques" sera automatiquement exécuté pour obtenir une vue du répertoire. Cela ralentira la sortie des données. Afin d'éviter cela, vous devez utiliser la construction « PRÉPRESENTATION » dans la requête afin d'obtenir immédiatement une représentation de l'objet puis de l'afficher pour la visualisation.

Dans le système de composition de données, ce mécanisme est utilisé par défaut, mais lors de la création de dispositions en cellules, vous devez spécifier la représentation du champ de référence et, par exemple, placer le lien lui-même dans la transcription.

4. Condition d'échantillonnage des données selon un modèle.

Par exemple, vous devez vous procurer les téléphones portables des employés du formulaire (8 -123-456-78-912). Pour ce faire, vous devez définir la condition suivante dans la requête :

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

Le caractère "_" est un caractère de service et remplace n'importe quel caractère.

5. Utilisation simultanée de totaux et de regroupements.

Les totaux sont souvent utilisés conjointement avec des regroupements ; dans ce cas, les fonctions d'agrégation peuvent ne pas être spécifiées dans les totaux.

SELECT Prestation de services.Organisation AS Organisation, Prestation de services.Nomenclature AS Nomenclature, SUM(Prestation de services.Montant du document) AS Somme du document FROM Document.Prestation de services AS Prestation de services GROUP BY Prestation de services.Organisation, Prestation des Services.Nomenclature RÉSULTATS PAR GÉNÉRAL, Organisation, nomenklatura

Dans ce cas, la requête renverra presque la même chose que la requête suivante :

SELECT Prestation de services.Organisation AS Organisation, Prestation de services.Nomenclature AS Nomenclature, Prestation de services.Montant du document AS Montant du document FROM Document.Prestation de services AS Prestation de services RÉSULTATS MONTANT (Montant du document) PAR GÉNÉRAL, Organisation, Nomenclature

Seule la première requête réduira les enregistrements ayant la même nomenclature.

6. Champs de déréférencement.

Faire référence à des champs par un point est appelé opération de déréférencement de champ de référence. Par exemple Paiement.Organisation.Unité administrative. Dans ce cas, dans le champ de référence « Organisation » du document « Paiement », il fait référence à une autre table « Organisations », dans laquelle sera obtenue la valeur de l'attribut « Unité administrative ». Il est important de comprendre que lors de l'accès aux champs via un point, la plateforme crée implicitement une sous-requête et joint ces tables.

Demande:

Peut être représenté comme :

SÉLECTIONNEZ Paiement.Lien, Paiement.Organisation, Paiement.Organisation, Organisations. AdministrativeUnit FROM Document.Payment AS Paiement LEFT JOIN Directory.Organizations AS Logiciel Organisations Payment.Organization = Organizations.Link

Lors du déréférencement de champs de référence d'un type composite, l'infrastructure tente de créer des jointures implicites à toutes les tables qui font partie du type de ce champ. Dans ce cas, la requête ne sera pas optimale. Si l'on sait clairement de quel type de champ il s'agit, il est nécessaire de limiter ces champs par type avec une construction. EXPRIMER().

Par exemple, il existe un registre d'accumulation « Paiements non distribués », où plusieurs documents peuvent faire office de conservateur. Dans ce cas, il est incorrect d'obtenir les valeurs des coordonnées du registraire de cette manière :

SELECT UnallocatedPayments.Register.Date, ..... FROM RegisterAccumulation.UnallocatedPayments AS UnallocatedPayments

vous devez restreindre le type du champ composite à logger :

SELECT EXPRESS (UnallocatedPayments.Register AS Document.Payment).Date, ..... FROM RegisterAccumulation.UnallocatedPayments AS UnallocatedPayments

7. Construction "OÙ"

Avec une jointure gauche de deux tables, lorsque vous imposez une condition « WHERE » sur la table de droite, nous obtiendrons un résultat similaire au résultat avec une jointure interne de tables.

Exemple. Il faut sélectionner tous les Clients dans l'Annuaire Clients et pour les clients qui ont un titre de paiement avec la valeur de l'attribut "Organisation" = &Organisation, afficher le document "Paiement", pour ceux qui n'en ont pas, ne pas l'afficher.

Le résultat de la requête renverra les enregistrements uniquement pour les clients pour lesquels le paiement par organisation était défini dans le paramètre et filtrera les autres clients. Il faut donc d'abord recevoir tous les paiements de « telle ou telle » organisation dans une table temporaire, puis la connecter au répertoire « Clients » à l'aide d'une jointure gauche.

SELECT Payment.Link AS Payment, Payment.Shareholder AS Client PLACE toPayments FROM Document.Payment AS Payment WHERE Payment.Branch = &Branch; ///////////////////////////////////////////// // /////////////////////////// SELECT Clients.Link AS Client, ISNULL(tPayment.Payment, "") AS Paiement FROM Annuaire .Clients AS Clients CONNEXION GAUCHE topayments AS topayments LOGICIEL Clients.Link = topayments.Client

Vous pouvez contourner cette condition d'une autre manière. Il faut imposer une condition "WHERE" directement sur la relation entre les deux tables. Exemple:

SELECT Clients.Link, Payment.Link FROM Directory.US_Subscribers AS US_Subscribers GAUCHE CONNEXION Document.Payment AS Payment Software (Clients.Link = Payment.Client AND Payment.Client.Name LIKE "Sugar Packet") GROUP BY Clients.Link, Paiement. Lien

8. Jointures avec des tables imbriquées et virtuelles

Requêtes imbriquées souvent nécessaire pour récupérer des données en fonction de certaines conditions. Si vous les utilisez ensuite avec d'autres tables, cela peut ralentir considérablement l'exécution de la requête.

Par exemple, nous devons obtenir le montant du solde à la date du jour pour certains clients.

SELECT UnallocatedPaymentsBalances.Customer, UnallocatedPaymentsBalances.AmountBalance 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 nyRequest.Link = UnallocatedPaymentsBalances. Client

Lors de l'exécution d'une telle requête, l'optimiseur du SGBD peut commettre des erreurs lors du choix d'un plan, ce qui entraînera une exécution sous-optimale de la requête. Lors de la jointure de deux tables, l'optimiseur de SGBD sélectionne un algorithme de jointure de table en fonction du nombre d'enregistrements dans les deux tables. S'il existe une requête imbriquée, il est extrêmement difficile de déterminer le nombre d'enregistrements que la requête imbriquée renverra. Par conséquent, vous devez toujours utiliser des tables temporaires au lieu de requêtes imbriquées. Alors réécrivons la demande.

SELECT Clients.Link AS Link PLACE tClients FROM Directory.Clients AS Clients OÙ
Clients.Lien B (&Clients) ; ///////////////////////////////////////////// // /////////////////////////// SELECT tClients.Link, UnallocatedPaymentsRemains.AmountRemaining, FROM tClients AS tClients LEFT JOIN RegisterAccumulations.UnallocatedPayments.Balances (, Client IN (SELECT tClients.Link FROM tClients)) AS UnallocatedPaymentsBalances tClients.Link = UnallocatedPaymentsBalances.Clients

Dans ce cas, l'optimiseur pourra déterminer le nombre d'enregistrements utilisés par la table temporaire tClients et pourra sélectionner l'algorithme optimal pour joindre les tables.

Tables virtuelles , permettent d'obtenir des données pratiquement toutes faites pour la plupart des tâches appliquées (Tranche du Premier, Tranche du Dernier, Restes, Chiffres d'affaires, Restes et Chiffres d'affaires). Le mot clé ici est virtuel. Ces tableaux ne sont pas physiques, mais sont compilés par le système à la volée, c'est-à-dire Lors de la réception des données des tables virtuelles, le système collecte les données des tables du registre final, les assemble, les regroupe et les transmet à l'utilisateur.

Ceux. Lors de la connexion à une table virtuelle, une connexion est établie à une sous-requête. Dans ce cas, l'optimiseur de SGBD peut également choisir un plan de connexion non optimal. Si la requête n'est pas générée assez rapidement et qu'elle utilise des jointures dans des tables virtuelles, alors il est recommandé de déplacer l'accès aux tables virtuelles vers une table temporaire, puis de réaliser une jointure entre deux tables temporaires. Réécrivons la requête précédente.

SELECT Clients.Link AS Link PLACER les tClients FROM Directory.Clients AS Clients INDEX BY Link OÙ
Clients.Lien B (&Clients) ; ///////////////////////////////////////////// // /////////////////////////// SELECT UnallocatedPayments.AmountBalance, UnallocatedPayments.Client AS Client PLACER les soldes FROM RegisterAccumulations.UnallocatedPayments.Balances(, Client B ( SELECT 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 = tRemainings.Client

9.Vérification du résultat de la demande.

Le résultat de la requête peut être vide ; pour vérifier les valeurs vides, utilisez la construction suivante :

ResRequest = Request.Execute(); Si resQuery.Empty() Then Return; fin si;

Méthode Vide() doit être utilisé avant les méthodes Choisir() ou Décharger(), car la récupération de la collection prend du temps.

Ce n'est une révélation pour personne qu'il est extrêmement indésirable d'utiliser des requêtes en boucle. Cela peut affecter de manière critique la durée de fonctionnement d’une fonction particulière. Il est hautement souhaitable de recevoir toutes les données de la requête, puis de traiter les données en boucle. Mais il arrive parfois qu'il devienne impossible de déplacer la requête en dehors de la boucle. Dans ce cas, pour optimiser, vous pouvez déplacer la création de la requête en dehors de la boucle, et dans la boucle, substituer les paramètres nécessaires et exécuter la requête.

Demande = Nouvelle demande ; Query.Text = "SELECT | Clients.Link, | Clients.Birthdate |FROM | Directory.Clients AS Clients |WHERE | Clients.Link = &Client"; Pour chaque ligne FROM TableClients Boucle Query.SetParameter("Client", Client); QueryResult = Query.Execute().Select(); Fin du cycle ;

Cela évitera au système de vérifier la syntaxe de la requête en boucle.

11. Construction « AVOIR ».

Un design assez rare dans les demandes. Permet d'imposer des conditions sur les valeurs des fonctions d'agrégation (SOMME, MINIMUM, MOYENNE, etc.). Par exemple, vous devez sélectionner uniquement les clients dont le montant du paiement en septembre était supérieur à 13 000 roubles. Si vous utilisez la condition « WHERE », vous devrez d'abord créer une table temporaire ou une requête imbriquée, y regrouper les enregistrements par montant de paiement puis appliquer la condition. La conception « HAVING » aidera à éviter cela.

SELECT Payment.Customer, AMOUNT(Payment.Amount) AS Montant FROM Document.Payment AS Payment WHERE MOIS(Payment.Date) = 9 GROUP BY Payment.Customer HAVING AMOUNT(Payment.Amount) > 13000

Dans le constructeur, pour cela, il suffit d'aller dans l'onglet « Conditions », d'ajouter une nouvelle condition et de cocher la case « Personnalisé ». Alors écris simplement Montant(Paiement.Montant) > 13000

12. Valeur NULLE

Je ne décrirai pas ici les principes de la logique à trois valeurs dans la base de données ; il existe de nombreux articles sur ce sujet ; Juste brièvement sur la façon dont NUL peut affecter le résultat de la requête. La valeur NULL n'est pas réellement une valeur et le fait que la valeur soit indéfinie est inconnu. Par conséquent, toute opération avec NULL renvoie NULL, qu'il s'agisse d'une addition, d'une soustraction, d'une division ou d'une comparaison. Une valeur NULL ne peut pas être comparée à une valeur NULL car nous ne savons pas quoi comparer. Ceux. ces deux comparaisons sont : NULL = NULL, NULL<>NULL n'est ni vrai ni faux, c'est inconnu.

Regardons un exemple.

Pour les clients qui n'ont pas de paiement, nous devons afficher le champ « Signer » avec la valeur « Aucun paiement ». De plus, nous savons avec certitude que nous avons de tels clients. Et afin de refléter l’essence de ce que j’ai écrit ci-dessus, procédons de cette façon.

SELECT "Aucun paiement" AS Attribut, NULL AS Document PLACE topayments ; ///////////////////////////////////////////// // ////////////////////////// SELECT Clients.Link AS Client, Payment.Link COMMENT Paiement PUT tClientPayment FROM Directory.Clients AS Clients GAUCHE CONNEXION Document. Paiement AS Logiciel de paiement Clients.Link = Payment.Shareholder; ///////////////////////////////////////////// // ////////////////////////// SELECT tClientPayment.Client FROM tClientPayment AS tClientPayment INTERNAL JOIN tPayment AS tTopay BY tClientPayment.Payment = tPayment Document.

Faites attention à la deuxième table temporaire tClientPayment. Avec la jointure de gauche, je sélectionne tous les clients et tous les paiements pour ces clients. Pour les clients qui n'ont pas de paiement, le champ « Paiement » sera NULL. Suivant la logique, dans la première table temporaire « tPayments » j'ai désigné 2 champs, l'un d'eux NULL, la deuxième ligne « N'a pas de paiements ». Dans le troisième tableau, je connecte les tables « tClientPayment » et « tPayment » en utilisant les champs « Payment » et « Document » avec une jointure interne. On sait que dans le premier tableau le champ « Document » est NULL, et dans le deuxième tableau, ceux qui n'ont pas de paiement dans le champ « Paiement » sont également NULL. Que nous rapportera une telle connexion ? Mais cela ne retournera rien. Parce que la comparaison NULL = NULL n’est pas évaluée à True.

Pour que la requête renvoie le résultat attendu, réécrivons-la :

SELECT "Aucun paiement" AS Attribut, VALUE (Document.Payment.EmptyLink) AS Document PLACE toPayments ; ///////////////////////////////////////////// // ////////////////////////// SELECT Clients.Link AS Client, ISNULL(Payment.Link, VALUE(Document.Payment.EmptyLink )) COMMENT Paiement PUT tClientPayment FROM Directory.Clients AS Clients LEFT CONNECTION Document.Payment AS Payment BY Clients.Link = Payment.Shareholder; ///////////////////////////////////////////// // ////////////////////////// SELECT tClientPayment.Client FROM tClientPayment AS tClientPayment INTERNAL JOIN tPayment AS tTopay BY tClientPayment.Payment = tPayment Document.

Maintenant, dans la deuxième table temporaire, nous avons indiqué que si le champ « Paiement » est NULL, alors ce champ = un lien vide vers le document de paiement. Dans le premier tableau, nous avons également remplacé NULL par une référence vide. Désormais, la connexion implique des champs non NULL et la requête renverra le résultat attendu.

Toutes les demandes contenues dans l'article reflètent les situations que je voudrais considérer et rien de plus. À PROPOS Ils ne peuvent pas être illusoires ou sous-optimaux, l'essentiel est qu'ils reflètent l'essence de l'exemple.

13. Une fonctionnalité non documentée de la conception "CHOIX WHEN...THEN...END".

Dans le cas où il est nécessaire de décrire la construction « Conditions » dans la requête, nous utilisons la syntaxe standard :

SELECTION WHEN Users.Name = "Vasya Pupkin" ALORS "Notre employé préféré" ELSE "Nous ne le savons pas" END AS Field1 FROM Directory.Users AS Users

Mais que se passe-t-il si, par exemple, nous avons besoin d’obtenir le nom du mois dans une requête ? Écrire une énorme construction dans une requête est laid et prend du temps, donc cette forme d'écriture ci-dessus peut nous aider :

SELECT MOIS(US_CalculationConsumption_TurnoverSchedule.CalculationPeriod) QUAND 1 PUIS "Janvier" QUAND 2 PUIS "Février" QUAND 3 PUIS "Mars" QUAND 4 PUIS "Avril" QUAND 5 PUIS "Mai" QUAND 6 PUIS "Juin" QUAND 7 PUIS "Juillet" QUAND 8 PUIS "Août" QUAND 9 PUIS "Septembre" QUAND 10 PUIS "Octobre" QUAND 11 PUIS "Novembre" QUAND 12 PUIS "Décembre" FINIR COMME UN MOIS

Désormais, le design semble moins encombrant et facile à comprendre.

14. Exécution de requêtes par lots.

Afin de ne pas multiplier les demandes, vous pouvez créer une seule demande volumineuse, la diviser en packages et travailler avec elle.
Par exemple, j'ai besoin d'obtenir les champs suivants du répertoire « Utilisateurs » : « Date de naissance » et les rôles disponibles pour chaque utilisateur. téléchargez-le dans différentes parties tabulaires du formulaire. Bien sûr, vous pouvez le faire en une seule requête, vous devrez alors parcourir les enregistrements ou les réduire, ou vous pouvez faire ceci :

SELECT Users.Link AS Nom complet, Users.Date of Birth, Users.Role PUT vtUsers FROM Directory.Users AS Users ; ///////////////////////////////////////////// // /////////////////////////// SELECT tueUsers.Nom complet, tueUsers.Date de naissance FROM tueUsers AS tueUsers GROUP BY tueUsers.nom complet, tueUsers . Date de naissance; ///////////////////////////////////////////// // /////////////////////////// SELECT wUsers.Nom complet, wUsers.Role FROM wUsers AS wUsers GROUP BY wUsers.Nom complet, wUsers Date. de naissance

tPackage = Request.ExecutePackage();

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

Comme nous pouvons le voir, la requête peut être exécutée par lots et le résultat peut être traité sous forme de tableau. Dans certains cas, c'est très pratique.

15. Conditions dans une demande groupée

Par exemple, nous avons une demande par lots, dans laquelle nous obtenons d'abord les champs : « Nom, Date de naissance, Code » du répertoire « Utilisateurs » et souhaitons obtenir des enregistrements avec des conditions pour ces champs du répertoire « Particuliers ».

SELECT Users.Individual.Name AS Nom, Users.Individual.Date of Birth AS Date de naissance, Users.Individual.Code AS Code PLACE vtUsers FROM Directory.Users AS Users ; ///////////////////////////////////////////// // ////////////////////////// SELECT Individus Lien COMME Individu À PARTIR du Répertoire Individus COMME Individus.

Vous pouvez imposer des conditions comme celles-ci :

OÙ Individus.Code IN (SELECT vtUsers.Code FROM vtUsers) ET Individuals.Name IN (SELECT vtUsers.Code FROM vtUsers) AND Individuals.BirthDate IN (SELECT vtUsers.DateBirth FROM tvUsers)

Et vous pouvez procéder comme ceci :

OÙ (Individus.Code, Individus.Nom, Individus.Date de naissance) DANS (SELECT tueUsers.Code, tueUsers.Name, tueUsers.Date of Birth FROM tueUsers)

De plus, il est nécessaire de maintenir l’ordre.

16. Appel du générateur de requêtes pour « condition » dans une requête par lots

Lorsqu'il faut imposer une condition, comme dans l'exemple ci-dessus, on peut oublier comment tel ou tel champ est appelé dans la table virtuelle.
Par exemple, vous devez imposer une condition sur le champ « Date de naissance », et dans la table virtuelle ce champ s'appelle « Date de naissance du débiteur », et si vous oubliez le nom, vous devrez quitter l'édition de la condition sans enregistrez et regardez le nom du champ. Afin d'éviter cela, vous pouvez utiliser la technique suivante.

Il faut mettre des parenthèses après la Construction « B » et laisser un espace vide (espace) entre les parenthèses, sélectionner cet espace et appeler le constructeur de requête. Le concepteur aura accès à toutes les tables de la requête batch. La technique fonctionne aussi bien sur les tables de registres virtuels que sur l'onglet « Conditions ». Dans ce dernier cas, il faut cocher la case "P (condition arbitraire)" et entrer dans le mode d'édition "F4".

Les requêtes étaient souvent formulées à la volée et ne servent qu'à illustrer les « techniques » que j'envisageais.

Je voulais examiner l'utilisation des index dans les requêtes, mais c'est un sujet très vaste. Je le mettrai dans un article séparé, ou je l'ajouterai ici plus tard.

mise à jour1. Points 11,12
mise à jour2. Points 13,14,15,16

Livres d'occasion :
Langage de requête "1C:Enterprise 8" - E.Yu. Khrustaleva
Développement professionnel dans le système 1C:Enterprise 8."

Attention! Il s'agit d'une version d'introduction de la leçon, dont le matériel peut être incomplet.

Connectez-vous au site en tant qu'étudiant

Connectez-vous en tant qu'étudiant pour accéder au matériel scolaire

Langage de requête 1C 8.3 pour les programmeurs débutants : syntaxe de base

À partir de cette leçon, nous commençons à apprendre la syntaxe du langage de requête.

Je vous conseille fortement de répondre à toutes les demandes sur votre ordinateur au fur et à mesure que vous lisez les leçons et d'être responsable dans la réalisation de vos devoirs, aussi simples qu'ils puissent paraître à première vue.

Bases de la syntaxe

En un mot, la syntaxe du langage de requête peut être décrite comme suit :

CHOISIR
NOUS ÉCRIVONS ICI CE QUE NOUS CHOISIRONS
DEPUIS
NOUS ÉCRIVONS ICI O NOUS CHOISIRONS

Ainsi, si nous voulons écrire une requête qui nous renverra les noms de tous les éléments du répertoire Nourriture, alors le raisonnement ressemblerait à ceci :

1. Au répertoire Nourriture il y a un accessoire avec un nom Nom.
2. Éléments du répertoire Nourriture stocké dans la base de données dans une table Annuaire.Alimentation.
3. La requête ressemblera donc à ceci :

   SELECT Nom FROM Répertoire. Nourriture

Essayez d'écrire cette requête dans la console de requêtes, comme nous l'avons fait dans la première leçon () :

Et puis exécutez-le (bouton Exécuter) :

Nous voyons que le résultat de la requête a renvoyé une table avec une seule colonne Nom, qui répertorie les noms de tous les éléments du répertoire Nourriture. Vous lisez une version d'essai de la leçon, des leçons complètes sont disponibles.

De la même manière, répétez tous les exemples que nous analyserons dans le futur.

Sélection de plusieurs propriétés

Si nous voulons demander plusieurs propriétés(Par exemple, Nom Et Couleur), ils doivent alors être répertoriés séparés par des virgules :

L'intégralité du tableau résultant qui nous a été renvoyé dans la demande ne correspondait pas à l'image - il y a en fait plus de colonnes - une pour chaque attribut d'objet (y compris les standards).

Récupération des N premières lignes

Résolvons maintenant le problème suivant : "Demander les noms des 3 premiers éléments du répertoire Nourriture". Vous lisez une version d'essai de la leçon, des leçons à part entière sont disponibles. Pour limiter le nombre de lignes que la demande nous renverra, nous utilisons le mot-clé PREMIER 3:

Explications supplémentaires

Voir explications (à partir du 30/07/2014)

A quoi ressemble un tableau de référence alimentaire ? Quelles colonnes contient-il ?

Tout d'abord, son nom complet Annuaire.Alimentation.

Deuxièmement, ses colonnes, telles qu'elles ressortent du configurateur, sont les suivantes :

• Teneur en calories

Plus standard pour tous les répertoires :

• Nom
• Et un certain nombre d'autres détails qui ne nous intéressent pas encore.

Ainsi, pour accéder à l'une de ces colonnes (propriétés, détails), on écrira directement comme ceci :

SELECT Nom, Saveur, Couleur DU Répertoire. Nourriture

Nous ne serons pas distraits longtemps.

A quoi ressemble le tableau de référence des couleurs ?

À en juger par le configurateur, il ne contient que des détails standards. Ainsi, son tableau ne comportera que les colonnes suivantes :

• Nom
• Et ainsi de suite.

Et maintenant ce moment.

A en juger par le configurateur, la colonne du tableau Annuaire.Alimentation Avec nom Couleur est un lien vers l'annuaire Couleurs(ou plutôt sur sa table). Comment peut-on, avec ce lien, accéder aux détails (colonnes, propriétés) de la couleur elle-même ?

Bien sûr, à travers le point :

Faites attention à la colonne Client. Ce n'est pas non plus simple et c'est un lien vers une autre table (du répertoire Clientèle). Ainsi, pour accéder aux propriétés du client via ce lien, nous utilisons également un point :

Mais ce ne sont pas toutes les données que contient le document. Comme il ressort du configurateur, il comporte une partie tableau portant le nom Des produits. C'est comme un autre tableau lié à ce document. Ce tableau possède ses propres colonnes (voir configurateur) :

• Quantité

Et pour y accéder à partir d'une requête, nous arrivons d'abord à la table elle-même - Document.CustomerOrder.Products, et indiquons ensuite seulement des détails spécifiques.

Demandes sont conçus pour extraire et traiter les informations de la base de données afin de les fournir à l'utilisateur sous la forme requise. Traiter ici signifie regrouper des champs, trier des lignes, calculer des totaux, etc. Vous ne pouvez pas modifier les données à l'aide de requêtes dans 1C !

La demande est exécutée selon les instructions données - demander un texte. Le texte de la demande est compilé conformément à la syntaxe et aux règles langage de requête. Le langage de requête 1C:Enterprise 8 est basé sur le standard SQL, mais présente quelques différences et extensions.

Schéma de travail avec une demande

Le schéma général de travail avec une requête se compose de plusieurs étapes successives :

1. Création d'un objet Request et définition du texte de la demande ;
2. Définition des paramètres de la demande ;
3. Exécuter une requête et obtenir le résultat ;
4. Contourner le résultat de la demande et traiter les données reçues.

1. Objet Demande a la propriété Texte, auquel vous devez attribuer le texte de la demande.

// Option 1
Demande = Nouvelle demande ;
Demande . Texte =
"CHOISIR
| Taux de change.Période,
| Taux de change. Devise,
| Taux de change.Taux
|DE

|OÙ
;

// Option 2
Demande = Nouvelle demande("CHOISIR
| Taux de change.Période,
| Taux de change. Devise,
| Taux de change.Taux
|DE
| Registre d'informations.Taux de change AS Taux de change
|OÙ
| Taux de change.Devise = &Devise");

2. Le réglage des valeurs des paramètres s'effectue à l'aide de la méthode DéfinirParamètre(< Имя>, < Значение>) . Les paramètres dans le texte de la demande sont indiqués par le symbole « & " et sont généralement utilisés dans les conditions de sélection (section WHERE) et dans les paramètres des tables virtuelles.

Demande);

3. Après avoir attribué le texte et défini les paramètres, la requête doit être exécutée et le résultat de l'exécution obtenu. L'exécution est réalisée par la méthode Execute(), qui renvoie un objet Résultat de la requête. À partir du résultat de la requête, vous pouvez :

• obtenir une sélection en utilisant la méthode Select (< ТипОбхода>, < Группировки>, < ГруппировкиДляЗначенийГруппировок>) ;
• télécharger des valeurs dans une table de valeurs ou un arbre de valeurs à l'aide de la méthode Upload (< ТипОбхода>) .

// Recevoir un échantillon

Échantillon = Résultat de la requête. Choisir();

// Récupère le tableau des valeurs
RequestResult = Demande. Courir();
Tableau = Résultat de la requête. Décharger();

4. Vous pouvez contourner la sélection des résultats de la requête à l'aide d'une boucle :

Au revoir Boucle Sample.Next()
Rapport (Sélection.Cours);
Fin du cycle ;

Un exemple complet de travail avec une requête pourrait ressembler à ceci :

// Étape 1. Création d'une requête et définition du texte de la requête
Demande = Nouvelle demande ;
Demande . Texte =
"CHOISIR
| Taux de change.Période,
| Taux de change. Devise,
| Taux de change.Taux
|DE
| Registre d'informations.Taux de change AS Taux de change
|OÙ
| Taux de change.Devise = &Devise";

// Étape 2. Définition des paramètres
Demande . SetParameter("Devise" , Devise Sélectionnée);

// Étape 3. Exécuter la requête et obtenir l'échantillon
RequestResult = Demande. Courir();
Échantillon = Résultat de la requête. Choisir();

// Parcours de la sélection
Au revoir Boucle Sample.Next()
Rapport (Sélection.Cours);
Fin du cycle ;

Composition du texte de la demande

Le texte de la demande se compose de plusieurs sections :

1. Description de la demande— liste des champs sélectionnables et des sources de données ;
2. Fusion de requêtes— les expressions « UNITE » et « UNITE ALL » ;
3. Organisation des résultats— l'expression « COMMANDER PAR… » ;
4. Commande automatique— expression « COMMANDE AUTOMATIQUE » ;
5. Description des résultats- l'expression « RÉSULTATS… PAR… ».

Seule la première section est obligatoire.

Tables temporaires et requêtes par lots

Le langage de requête 1C prend en charge l'utilisation tables temporaires— les tables obtenues à la suite de l'exécution d'une requête et stockées de manière temporaire.

Vous pouvez souvent rencontrer une situation dans laquelle vous devez utiliser non pas les tables de base de données comme source d'une requête, mais le résultat de l'exécution d'une autre requête. Ce problème peut être résolu à l'aide de requêtes imbriquées ou tables temporaires. L'utilisation de tables temporaires permet de simplifier le texte d'une requête complexe en le divisant en ses composants, et également, dans certains cas, d'accélérer l'exécution de la requête et de réduire le nombre de verrous. Pour travailler avec des tables temporaires, utilisez l'objet Gestionnaire d'horaires. Une table temporaire est créée à l'aide du mot-clé PLACE suivi du nom de la table temporaire.

ManagerVT = Nouveau TemporaryTablesManager ;
Demande = Nouvelle demande ;
Demande . TemporaryTablesManager = VTManager ;

Demande . Texte =
"CHOISIR
| Devises.Code,
| Devises.Nom
|Place en devise
|DE
| Annuaire.Devises AS Devises";

RequestResult = Demande. Exécuter();

Pour utiliser la table temporaire VTVcurrency dans d'autres requêtes, vous devez attribuer un gestionnaire de table temporaire commun à ces requêtes : VT Manager.

Demande par lots est une requête qui contient plusieurs requêtes séparées par le caractère « ; ». Lors de l'exécution d'une requête par lots, toutes les requêtes qui y sont incluses sont exécutées séquentiellement et les résultats de toutes les tables temporaires sont disponibles pour toutes les requêtes suivantes. Il n’est pas nécessaire d’attribuer explicitement un gestionnaire de tables temporaire aux requêtes par lots. Si aucun gestionnaire de tables temporaires n'est affecté, toutes les tables temporaires seront supprimées immédiatement après l'exécution de la requête.

Pour les requêtes par lots, la méthode ExecuteBatch() est disponible, qui exécute toutes les requêtes et renvoie un tableau de résultats. Les tables temporaires dans une requête batch seront représentées par une table avec une ligne et une colonne « Count », qui stocke le nombre d'enregistrements. Pour déboguer les requêtes batch, vous pouvez utiliser la méthode Exécuter un lot avec des données intermédiaires() : Il renvoie le contenu réel des tables temporaires, pas le nombre d'enregistrements.

// Exemple de travail avec une requête batch
Demande = Nouvelle demande ;
Demande . Texte =
"CHOISIR
| Devises.Nom
|DE
| Annuaire.Devises AS Devises
|;
|SÉLECTIONNER
| Nomenclature.Nom
|DE
| Annuaire Nomenclature AS Nomenclature";

BatchResult = Demande. ExécuterBatch();

TZDevises =PacketResult[ 0 ]. Décharger();
TZNomenclature = Résultat du package[ 1 ]. Décharger();

// Un exemple d'utilisation de tables temporaires dans une requête batch
Demande = Nouvelle demande ;
Demande . Texte =
"CHOISIR
| Produits. Lien COMMENT FAIRE Produit
|PLACE VTProduits
|DE
| Annuaire.Nomenclature COMMENT Produits
|OÙ
| Produits.Fabricant = &Fabricant
|;
|SÉLECTIONNER
| VTTProducts.Produit,
| École professionnelle. Quantité,
| Ecole professionnelle.Prix,
| Ecole professionnelle.Link AS DocumentReceipts
|DE
| Produits VT AS Produits VT
| Document de connexion à gauche. Réception des biens et services en tant que PTU.
| Logiciel VTVProducts.Product = PTU.Nomenclature";

Demande . DéfinirParamètre( "Fabricant", Fabricant);

RequestResult = Demande. Courir();
Échantillon = Résultat de la requête. Choisir();

Au revoir Boucle Sample.Next()

Fin du cycle ;

Tables virtuelles

Tables virtuelles- ce sont des tables qui ne sont pas stockées dans la base de données, mais sont générées par la plateforme. À la base, il s’agit de requêtes imbriquées sur une ou plusieurs tables physiques exécutées par la plateforme. Les tables virtuelles reçoivent des informations uniquement à partir de registres et sont principalement destinées à résoudre des problèmes hautement spécialisés.

Il existe les tables virtuelles suivantes (les paramètres possibles sont indiqués entre parenthèses) :

• Pour les registres d’information :
  • TranchePremier(<Период>, <Условие>) — les enregistrements les plus anciens pour la date spécifiée ;
  • TrancheDernier(<Период>, <Условие>) — les derniers enregistrements pour la date spécifiée ;
• Pour les registres d’accumulation :
  • Les restes(<Период>, <Условие>) — les soldes à la date spécifiée ;
  • Révolutions(<НачалоПериода>, <КонецПериода>, <Периодичность>, <Условие>) - Opérations de période ;
  • Restes et chiffre d'affaires (<НачалоПериода>, <КонецПериода>, <Периодичность>, <МетодДополненияПериодов>, <Условие>) — les soldes et le chiffre d'affaires de la période;
• Pour les registres comptables :
  • Les restes(<Период>, <УсловиеСчета>, <Субконто>, <Условие>) — soldes à la date spécifiée par compte, dimensions et sous-comptes ;
  • Révolutions(<НачалоПериода>, <КонецПериода>, <Периодичность>, <УсловиеСчета>, <Субконто>, <Условие>, <УсловиеКорСчета>, <КорСубконто>) — chiffre d'affaires de la période dans le cadre des comptes, mesures, corr. comptes, sous-conto, cor. sous-conto ;
  • Restes et chiffre d'affaires (<НачалоПериода>, <КонецПериода>, <Периодичность>, <МетодДополненияПериодов>, <УсловиеСчета>, <Субконто>, <Условие>) — les soldes et le chiffre d'affaires dans le cadre des comptes, mesures et sous-comptes ;
  • Chiffre d'affairesDtKt(<НачалоПериода>, <КонецПериода>, <Периодичность>, <УсловиеСчетаДт>, <СубконтоДт>, <УсловиеСчетаКт>, <СубконтоКт>, <Условие>) — chiffre d'affaires de la période par compte Dt, compte Kt, Sous-conto Dt, Sous-conto Kt;
  • MouvementsSubconto(<НачалоПериода>, <КонецПериода>, <Условие>, <Порядок>, <Первые>) — mouvements avec valeurs de sous-conto ;
• Pour les registres de calcul :
  • Base(<ИзмеренияОсновногоРегистра>, <ИзмеренияБазовогоРегистра>, <Разрезы>, <Условие>) — données de base du registre de calcul ;
  • DonnéesGraphiques(<Условие>)—données graphiques ;
  • ActualActionPeriod(<Условие>) est la durée de validité effective.

Lorsque vous travaillez avec des tables virtuelles, vous devez appliquer des sélections dans les paramètres des tables virtuelles, et non dans la condition WHERE. Le temps d'exécution de la requête en dépend grandement.

Constructeur de requête

Pour accélérer la saisie des textes de requêtes, la plateforme dispose d'outils particuliers : Constructeur de requête Et Constructeur de requête avec traitement des résultats. Pour appeler des constructeurs, vous devez cliquer avec le bouton droit et sélectionner l'élément requis :

Les constructeurs peuvent également être appelés depuis le menu principal Texte.

À l'aide du générateur de requêtes, le programmeur peut construire de manière interactive le texte de la requête. Pour cela, sélectionnez les tableaux et champs nécessaires avec la souris, établissez des relations, des regroupements, des totaux, etc. Cette approche permet de gagner du temps et d'éliminer les erreurs possibles. Grâce à son travail, le constructeur de requête génère le texte de la requête.

Le constructeur de requête avec traitement des résultats, en plus de générer le texte de la requête, crée un fragment de code prêt à l'emploi pour recevoir et traiter les données.

Objet RequestSchema

La plateforme vous permet de créer et de modifier par programme le texte de la demande à l'aide de l'objet Schéma de demande. Un objet a une seule propriété Lot de demandes, dans lequel l'objet stocke les propriétés de toutes les requêtes en cours d'édition. L'objet RequestSchema prend en charge les méthodes suivantes :

• DéfinirTexteRequête(< Текст>) — remplit la propriété Query Packet en fonction du texte de la demande soumise ;
• ObtenirTexteRequête() - renvoie le texte de la demande généré en fonction de la propriété Request Package ;

FindParameters() - renvoie les paramètres de la requête.

Regardons un exemple de travail avec l'objet RequestSchema. Pour générer par programme le texte de la demande

TRIER PAR
Devises.Code

Le code de langue intégré pourrait ressembler à ceci :

RequestScheme = Nouveau RequestScheme ;
Forfait 1 = Schéma de demande. RequêteBatch[ 0 ];
Opérateur1 = Paquet1. Opérateurs[ 0 ];
// ajout de la source
RegisterTable = Opérateur1. Sources. Ajouter( "Répertoire.Devises", "Devises" );
// ajout de champs
Lien sur le terrain = Opérateur1. Champs sélectionnables. Ajouter("Currencies.Link" , 0 );
Code de champ = Opérateur1. Champs sélectionnables. Add("Devises.Code", 1);
// spécification des alias de champ
Forfait 1 . Colonnes[ 0 ]. Alias ​​​​= "Devise" ;
Forfait 1 . Colonnes[ 1 ]. Alias ​​​​= "Code" ;
// ajout d'une condition
Opérateur1 . Sélection. Ajouter( "PAS de suppression de drapeau");
// ajoute une commande
Forfait 1 . Commande. Ajouter (Code de champ);
RequestText = RequestScheme. ObtenirTexteRequête();

Une requête est un outil puissant qui permet d'obtenir et de traiter rapidement (par rapport à toutes les autres méthodes) les données contenues dans divers objets de la base d'informations 1C.

Créer une demande

La demande est créée en tant qu'objet distinct doté d'un attribut obligatoire Texte, où la demande elle-même est réellement placée. De plus, divers paramètres nécessaires à son exécution peuvent être transmis à la requête. Une fois le texte et les paramètres de la requête renseignés, la requête doit être exécutée et le résultat de l'exécution placé dans une sélection ou un tableau de valeurs. Tout ressemble à ceci :

//Créer une requête
Demande = nouvelle demande ;

//Remplissez le texte de la demande
Demande. Texte= "Ici, nous écrivons le texte de la demande";

// Passer les paramètres à la requête
Demande. SetParameter("ParameterName" , ParameterValue) ;

//Exécuter la requête
Résultat = Requête. Courir() ;

// Téléchargez le résultat de la requête dans la sélection
Échantillon = Résultat. Choisir() ;

// Téléchargez le résultat de la requête dans la table de valeurs
Tableau = Résultat. Décharger() ;

//Les dernières actions peuvent être combinées
Récupérer = Requête. Courir() . Choisir() ;
//ou
Tableau = Requête. Courir() . Décharger() ;

Bases du langage de requête 1C

Les requêtes les plus simples et les plus fréquemment utilisées sont utilisées pour obtenir des données à partir d'une source donnée. La source peut être presque tous les objets contenant des données quelconques : répertoires, documents, registres, constantes, énumérations, plans de types de caractéristiques, etc.

A partir de ces objets, à l'aide d'une requête, vous pouvez obtenir les valeurs des détails, des parties de table, des détails des parties de table, des modifications, des ressources, etc.

Pour obtenir le texte de la demande, il est souvent pratique d'utiliser Constructeur de requête. Il est appelé lorsque vous cliquez avec le bouton droit n'importe où dans le module du programme.

Par exemple, si vous avez besoin d'obtenir les valeurs de tous les détails du répertoire Contreparties, alors la requête ressemblera à ceci :

Demande. Texte = "CHOISIR
| *
|DE
| Annuaire des contreparties".;

Si vous n'avez besoin d'obtenir que des détails individuels, procédez comme suit :

Demande. Texte = "CHOISIR
| Code,
| Nom,
| Parent
|DE
| Annuaire des contreparties".;

Pour recevoir une telle demande par SMS Constructeur de requête vous devez sélectionner les champs appropriés dans l'onglet Tableaux et champs.

Vous pouvez attribuer des alias aux éléments et sources sélectionnés dans la requête et les utiliser ultérieurement à la fois dans la requête elle-même et lorsque vous travaillez avec le résultat. De plus, la requête peut contenir des champs avec une valeur spécifique prédéfinie, ou avec une valeur calculée :

Demande. Texte = "CHOISIR
| Clients.Code AS Numéro,

| 1000 AS ChampAvecValeur
|DE
;

Récupérer = Requête. Courir() . Choisir() ;

Au revoir la sélection. Boucle Suivant()
ClientNumber = Échantillon. Nombre;
ClientName = Sélection. Nom;
Valeur = Échantillon. ChampAvecValeur ;
Fin du cycle ;

Pour définir des alias, utilisez l'onglet Syndicats/Alias V Générateur de requêtes.

Un champ à valeur fixe ou calculée est créé manuellement sur l'onglet Tables et champs, dans une colonne Des champs.

Tous les éléments sélectionnés peuvent être disposés dans l'ordre direct ou inverse. Vous pouvez sélectionner un ou plusieurs champs pour la commande. En plus de l'organisation, il peut parfois être utile de sélectionner un ou quelques-uns des premiers éléments.

//Classez les clients par nom de A à Z et sélectionnez les 10 premiers
Demande. Texte = "SÉLECTIONNEZ LES 10 PREMIERS
| Clients.Code AS Numéro,
| Clients.Nom AS Nom,
| 1000 AS ChampAvecValeur
|DE

|COMMANDER PAR
| Nom";

//Sélectionnez le client alphabétique le plus récent
Demande. Texte = "SÉLECTIONNER LE TOP 1
| Clients.Code AS Numéro,
| Clients.Nom AS Nom,
| 1000 AS ChampAvecValeur
|DE
| Annuaire des contreparties AS Clients.
|COMMANDER PAR
| Nom DÉCLIN »;

Vous pouvez limiter la sélection des éléments à ceux pour lesquels l'utilisateur dispose de droits d'accès. Ou supprimez les lignes en double du résultat de la requête.

//Données d'échantillonnage autorisées à l'utilisateur
Demande. Texte = "SÉLECTION AUTORISÉE
| Clients.Code AS Numéro,
| Clients.Nom AS Nom,
| 1000 AS ChampAvecValeur
|DE
| Annuaire des Contreparties AS Clients".;

//Sélection d'éléments non répétitifs
Demande. Texte = " SÉLECTIONNEZ DIVERS
| Clients.Code AS Numéro,
| Clients.Nom AS Nom,
| 1000 AS ChampAvecValeur
|DE
| Annuaire des Contreparties AS Clients".;

La commande est définie sur l'onglet Commande V Générateur de requêtes le nombre d'éléments sélectionnés, les paramètres de résolution et de répétabilité sont sur l'onglet En plus.

À suivre…