1s 8.3 syntaxe pour écrire des requêtes. Créer et travailler avec des requêtes (pour les débutants). Travailler avec des requêtes par lots

Cet article est destiné aux lecteurs familiarisés avec le langage SQL.

Le langage de requête 1C, utilisé depuis la version 8, est devenu aujourd'hui un outil utile pour travailler avec des bases de données, qui permet d'y lire, mais pas d'écrire. Syntaxiquement, le langage de requête est très similaire au langage SQL, mais en russe.

Ci-dessous un tableau de correspondance entre le langage de requête principal et les opérateurs SQL :

Opérateurs de langage de requête 1C	Instruction SQL


DIVERS



COMPOSÉ
PAR GROUPE
COMBINER
TRIER PAR

Et ce n'est pas une liste complète. Des informations de référence plus complètes sur les opérateurs de langage de requête disponibles peuvent être obtenues dans le concepteur de requêtes, qui sera abordé ci-dessous.

L'exécution d'une requête 1C à partir du code du programme s'effectue à l'aide de l'objet langage intégré « Requête ». Un exemple d'écriture d'une requête de base de données à l'aide du langage de programmation intégré :

Demande = Nouvelle demande ; Query.Text = "SELECT | Synonyme.Link AS Link |FROM | Directory.Directory1 AS Synonyme"; Sélectionner = Query.Run().Select(); While Selection.Next() Loop // Insérer le traitement de sélection SelectionDetailedRecords EndCycle;

La méthode « Run » exécute la requête, la méthode « Select » renvoie une valeur de type « SelectFromQueryResult ». Vous pouvez également utiliser la méthode Unload, qui renvoie une table de valeurs.

Les paramètres de la requête sont stockés dans la propriété « Paramètres » (dans ce cas, il s'agit d'une structure, donc toutes les méthodes de structure sont applicables ici - insertion, suppression, etc.).

Un exemple de définition du paramètre « Query.Parameters.Insert » (« Directory », DirectoryLink). Dans la requête, vous pouvez accéder aux paramètres à l'aide de l'esperluette « &Répertoire ». Ci-dessous un exemple de requête utilisant des paramètres :

Demande = Nouvelle demande ; Query.Text = "SELECT | Users.Link AS Link, | Users.Parent AS Parent, | Users.Name AS Name |FROM | Directory.Users AS Users |WHERE | Users.Link = &Directory"; Query.Parameters.Insert("Répertoire", DirectoryLink); Sélectionner = Query.Run().Select(); While Selection.Next() Loop // Insérer le traitement de sélection SelectionDetailedRecords EndCycle;

Rappelons que le langage de requête est destiné uniquement à lire les données de la base de données, il n'a donc pas d'analogues à des instructions SQL telles que INS ERT et UPDATE. Les données ne peuvent être modifiées que via le modèle objet du langage de programmation 1C intégré. Également dans le langage de requête 1C, il existe des opérateurs qui n'ont pas d'analogues en SQL, par exemple :

DANS LA HIÉRARCHIE
LIEU
INDEX PAR

DANS LA HIÉRARCHIE– permet de sélectionner tous les éléments du répertoire hiérarchique qui sont inclus dans la hiérarchie du lien transféré. Exemple de requête utilisant DANS LA HIÉRARCHIE:

SELECT Produits.Lien, Produits.Article FROM Répertoire.Produits AS Produits OÙ Produits.Lien DANS LA HIÉRARCHIE (&Citrus)"

Dans ce cas, le résultat renverra tous les éléments subordonnés du répertoire de nomenclature Citrus, quel que soit le nombre de niveaux hiérarchiques de ce répertoire.

Par exemple, la tâche consiste également à trouver un produit portant le nom « Pen ». Le produit doit être inclus dans la hiérarchie « Papeterie ». Marchandises », c’est-à-dire que nous n’avons pas besoin de chercher la poignée de porte. La structure de la nomenclature dans ce cas est la suivante :

Bureau

Accessoires

|_ Poignées de porte |_ Poignée de porte simple |_ Poignée de porte de luxe

Nous rédigeons la demande suivante :

SELECT Products.Link, Products.Article FROM Directory.Products AS Products WHERE Products.Name Like "Pen%" AND Products.Link IN HIERARCHY(&Papeterie)"

Lors de l'utilisation du design DANS LA HIÉRARCHIE il faut tenir compte du fait que si vous passez un lien vide au paramètre « Office », l'exécution de la requête ralentira, puisque la plateforme vérifiera chaque élément pour voir s'il appartient à la racine.

LIEU– Cette instruction place le résultat dans une table temporaire. Exemple de demande :

SELECT Users.Link AS Link, Users.Parent AS Parent, Users.Name AS Name PLACE SelectedUsers FROM Directory.Users AS Users WHERE Users.Link = &Directory; SELECT SelectedUsers.Link AS Link, SelectedUsers.Parent AS Parent, SelectedUsers.Name AS Nom FROM SelectedUsers AS SelectedUsers

Cette requête SQL sera exécutée par plusieurs requêtes :

Création d'une table temporaire (la plateforme peut « réutiliser » des tables temporaires précédemment créées, donc la création n'a pas toujours lieu) ;
Placer les données dans une table temporaire ;
Exécuter la requête principale, à savoir SEL ECT à partir de cette table temporaire ;
Détruire/nettoyer une table temporaire.

Une table temporaire peut être détruite explicitement, via la construction DÉTRUIRE, ou implicitement - lors de la fermeture du gestionnaire de tables temporaire.

L'objet « Requête » du langage de programmation intégré possède une propriété « Temporary Table Manager », destinée à travailler avec des tables temporaires. Exemple de code :

MVT = Nouveau TemporaryTableManager(); Demande = Nouvelle demande ; Query.TemporaryTableManager = MVT ;

Après avoir exécuté une requête, la variable MVT peut être utilisée une seconde fois dans une autre requête, ce qui est sans doute un autre avantage de l'utilisation de tables temporaires. Dans ce cas, la table temporaire de la base de données sera supprimée lors de l'appel de la méthode « Close »...

MVT.Close();

...ou lors de l'effacement d'une variable de la mémoire, c'est-à-dire lors de l'exécution de la méthode dans laquelle la variable a été déclarée. Les tables temporaires augmentent la charge sur le sous-système de disque, vous ne devez donc pas créer trop de sous-systèmes temporaires (en boucle, par exemple) ou de sous-systèmes de gros volume.

INDEX PAR– cet opérateur est utilisé conjointement avec l'opérateur LIEU. Lors de la création d'une table temporaire, cet opérateur peut indexer la table en cours de création, ce qui accélère considérablement son utilisation (mais uniquement si l'index correspond à votre requête).

Consultation gratuite d'experts

Merci pour votre requête!

Un spécialiste 1C vous contactera dans les 15 minutes.

Caractéristiques de certains opérateurs de langage de requête

POUR CHANGER– cet opérateur est destiné à verrouiller une table de requête spécifique (ou toutes les tables qui participent à la requête). Le verrouillage est réalisé en appliquant un verrou en U à la table. En SQL, cela est implémenté via l'indice UPDLOCK. Cette conception est nécessaire pour éviter les blocages. Exemple de demande avec une construction POUR CHANGER:

SELECT Users.Link AS Link, Users.Parent AS Parent, Users.Name AS Name FROM Directory.Users AS Users LEFT JOIN Directory.RFK AS RFK BY Users.RFK = RFK.Link POUR CHANGER Directory.Users

Dans cet exemple, le verrou U sera placé sur la table Utilisateurs. Si vous ne spécifiez pas de table pour un verrou, celui-ci sera imposé à toutes les tables participant à la requête. Il est important de noter que cette conception ne fonctionne que dans les configurations dans lesquelles le mode de gestion automatique des verrouillages est activé.

COMPOSÉ– la requête prend en charge les connexions GAUCHE/DROITE, COMPLET, INTÉRIEUR, qui correspond aux jointures en SQL – LEFT/RIGHT JOIN, OUTER JOIN, INNER JOIN.

Cependant, lorsque vous utilisez le générateur de requêtes, vous ne pourrez pas faire REJOIGNEZ À DROITE. Le constructeur échangera simplement les tables, mais l'opérateur sera toujours gaucher. Pour cette raison, vous ne verrez jamais l'utilisation d'une jointure à droite dans 1C.

Syntaxiquement, la connexion ressemble à ceci :

SELECT Table1.Link AS Link FROM Directory.Directory1 AS Table1 LEFT JOIN Directory.Directory2 AS Table2 BY Table1.Attributes = Table2.Attributes

Le langage de requête 1C ne dispose pas d'opérateur pour rejoindre un produit cartésien (CROSS JOIN). Cependant, l’absence d’opérateur ne signifie pas que le langage de requête ne prend pas en charge une telle connexion. Si nécessaire, vous pouvez joindre des tables comme ceci :

SELECT Table1.Link AS Link FROM Directory.Directory1 AS Table1 LEFT JOIN Directory.Directory2 AS Table2 BY TRUE

Comme le montre l'exemple, la clé de connexion est définie PAR VRAI, c'est-à-dire que chaque ligne d'une table correspond à une ligne d'une autre. Le type de jointure (LEFT, RIGHT, FULL, INNER) n'est pas important si vous avez des lignes dans les deux tables, mais s'il n'y a pas de lignes dans l'une des tables (disons la table) - le résultat sera différent. Par exemple, lors de l'utilisation INTERNE le résultat de la connexion sera vide. En utilisant GAUCHE DROITE le résultat de la jointure sera ou non des données selon la table que nous rejoignons - avec des données ou non. En utilisant COMPLET Les données seront toujours connectées (naturellement, uniquement à partir d'une table, puisque l'autre est vide) ; le choix du type de connexion dépend de la tâche spécifique de l'application.

Un petit indice visuel sur le fonctionnement des différents types de connexion :

COMME. Contrairement à l'opérateur SQL similaire - LIKE, le modèle pour COMME peut être spécifié en utilisant uniquement certains caractères spéciaux :

% (pourcentage) : une séquence contenant un nombre quelconque de caractères arbitraires ;
_ (trait de soulignement) : un caractère arbitraire ;
/ - le caractère suivant doit être interprété comme un caractère normal.

RÉSULTATS DU LOGICIEL L'analogue de SQL est l'opérateur ROLLUP. Exemple d'utilisation de l'opérateur RÉSULTATS:

SELECT Produits.Prix AS Prix, Produits.Produit AS Produit FROM Répertoire.Nomenclature AS Produits RÉSULTATS MOYENNE (Prix) PAR Produit

Le résultat sera comme ceci :


Lit	9833,333



Fer





Stylo

C'est-à-dire qu'une ligne supplémentaire est ajoutée au résultat contenant la valeur du champ par lequel le regroupement est effectué et la valeur de la fonction d'agrégation.

Travailler avec des requêtes par lots

1C vous permet de travailler avec des lots de demandes. Dans une requête batch, les textes de requête sont séparés par des points-virgules (;). La demande batch 1C est exécutée séquentiellement. Exemple de texte de demande par lots :

SELECT Users.Link AS Link, Users.Parent AS Parent, Users.Name AS Name FROM Directory.Users AS Users ;
SELECT Work Schedule.User AS User, Work Schedule.Date AS Date, Work Schedule.Working Hours AS Working Hours FROM Register Information.Work Schedule AS Work Schedule

Pour obtenir le résultat de toutes les requêtes incluses dans un package, vous devez utiliser la méthode « ExecutePackage » de l'objet requête, au lieu de « Run ». Cette méthode exécute toutes les requêtes de manière séquentielle. Le résultat de la requête est un tableau de résultats pour chaque requête du package, et la séquence de placement dans le tableau est la même que la séquence de requêtes dans le texte du package.

Lorsque l'on considère un langage de requête, il convient de mentionner une fonctionnalité telle que les tables virtuelles. Les tables virtuelles ne sont pas présentes dans la base de données ; elles constituent une sorte de wrapper qui est exécuté côté SGBD sous forme de requête utilisant des sous-requêtes. Exemple de requête 1C utilisant des tables virtuelles :

SELECT RegisterLiabilitiesTurnovers.Liability AS Liability FROM RegisterAccumulations.RegisterLiabilities.Turnovers() AS RegisterLiabilitiesTurnovers

Une telle requête au SGBD ressemblerait à ceci :

SEL ECT T1.Fld25931RRef FROM (SELECT T2._Fld25931RRef AS Fld25931RRef, CAST(SUM(T2._Fld25936) AS NUMERIC(38, 8)) AS Fld25936Turnover_, CAST(SUM(T2._Fld25937) AS NUMERIC(38, 8) ) AS Fld25937Turnover_ FR OM dbo._AccumRgTn25938 T2 WH ERE ((T2._Fld949 = @P1)) ET ((T2._Fld25936 @P2 OU T2._Fld25937 @P3)) GROUPE PAR T2._Fld25931RRef AVANT (CAST(SUM(T2._Fld2 ) 5936 ) AS NUMERIC(38, 8))) 0.0 OU (CAST(SUM(T2._Fld25937) AS NUMERIC(38, 8))) 0.0) T1>>>>

On voit que cela ne ressemble pas à SQL, puisqu'il existe une sous-requête, un regroupement. Les tables virtuelles, dans l'ensemble, sont du « sucre syntaxique », c'est-à-dire qu'elles sont créées, en général, pour faciliter le développement de requêtes, afin que les requêtes soient plus compactes et plus lisibles.

Seuls les registres ont des tables virtuelles, mais les tables virtuelles disponibles dans un registre peuvent être vues dans le concepteur de requêtes.

Lorsque vous utilisez des tables virtuelles, vous devez toujours fournir une condition de sélection. Sinon, des problèmes de performances pourraient survenir.

Dans le corps de la requête, cela ressemble à ceci :

Registre d'accumulation Registre de passif Chiffre d'affaires (, Opération = &Opération) Chiffre d'affaires du Registre de passif.

Pour faciliter l'écriture de requêtes, c'est-à-dire la création de textes de requête, dans 1C, il existe un constructeur qui peut être appelé via le menu contextuel (bouton droit de la souris) :

Dans le concepteur de requêtes, vous pouvez voir une liste complète des fonctions et opérateurs du langage de requête pris en charge.

Le Query Builder est un outil visuel très flexible pour créer des requêtes de toute complexité. Il est uniquement disponible en mode configurateur. En mode Entreprise, il existe ce qu'on appelle une « Console de requêtes » : il s'agit d'un traitement externe fourni sur le disque ITS. Pour une application gérée, la console de requêtes peut être téléchargée depuis its.1c.ru.

Une description du travail dans le concepteur de requêtes dépasse le cadre de cet article, elle ne sera donc pas abordée en détail.

Raisons des performances de requête sous-optimales

Vous trouverez ci-dessous une liste des principales raisons (mais pas toutes) qui entraînent une exécution lente des requêtes.

Utiliser des jointures avec des sous-requêtes

Il n'est pas recommandé d'effectuer une jointure avec des sous-requêtes ; les sous-requêtes doivent être remplacées par des tables temporaires. La concaténation de sous-requêtes peut entraîner des pertes de performances importantes, et la vitesse d'exécution des requêtes sur différents SGBD peut varier considérablement. La vitesse d'exécution de ces requêtes est également sensible aux statistiques du SGBD. La raison de ce comportement est que l'optimiseur de SGBD ne peut pas toujours déterminer correctement le plan d'exécution optimal de la requête, car l'optimiseur ne sait rien du nombre de lignes que la sous-requête renverra après son exécution.

Utilisation de tables virtuelles dans les jointures de requêtes

Les tables virtuelles au niveau du SGBD sont exécutées sous forme de sous-requêtes, les raisons sont donc les mêmes que dans le premier paragraphe.

Utiliser des conditions dans une requête qui ne correspondent pas aux index existants

Si dans les conditions de la demande (dans l'opérateur OÙ ou conditions de table virtuelle) utilise des champs qui ne sont pas tous inclus dans l'index, cette requête sera exécutée à l'aide du scan de table de construction SQL ou du scan d'index (en tout ou en partie). Cela affectera non seulement le temps d'exécution de la requête, mais également un verrou S excessif sera placé sur des lignes supplémentaires, ce qui à son tour peut conduire à une escalade de verrouillage, c'est-à-dire que la table entière sera verrouillée.

Utilisation de OR dans les conditions de requête

Utiliser l'opérateur logique OU en conception OÙ peut également entraîner une analyse de la table. Cela se produit car le SGBD ne peut pas utiliser correctement l'index. Au lieu de OU vous pouvez utiliser le design COMBINEZ TOUT.

Réception de données via un point pour les champs de type composite

Il n'est pas recommandé d'obtenir des valeurs via un point (dans la construction CHOISISSEZ OÙ), car si l'attribut objet s'avère être un type complexe, la jointure se produira avec chaque table incluse dans ce type complexe. En conséquence, la requête du SGBD sera nettement plus compliquée, ce qui peut empêcher l'optimiseur de choisir le bon plan d'exécution de requê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 :

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.

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.

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…

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 ».

Afin d'obtenir des données de la base de données, il n'est pas du tout nécessaire d'utiliser la construction « DE ».
Exemple : nous devons sélectionner toutes les informations sur les banques dans le répertoire 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 la même manière, 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(Fourniture 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.

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

11. Construction "AVANT".

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 construction « 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 EN 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 tueUsers.Code FROM tueUsers) ET Individuals.Name IN (SELECT tueUsers.Code FROM tueUsers) AND Individuals.BirthDate IN (SELECT tueUsers.DateBirth FROM tueUsers)

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 servent simplement à 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."

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 leçons. 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

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
É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 : rechercher 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
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
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
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
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. Le problème de l'obtention des 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
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 de données externes (bases de données externes)			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.
La version « 1C : Enterprise 8.2 » suffit pour apprendre la programmation.

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 :

Au répertoire Nourriture il y a un accessoire avec un nom Nom.
Éléments du répertoire Nourriture stocké dans la base de données dans une table Annuaire.Alimentation.
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 cadrait pas avec 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 comporte-t-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 standard. 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 contenues dans 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.