FAQ DelphiConsultez toutes les FAQ

Nombre d'auteurs : 124, nombre de questions : 934, dernière mise à jour : 23 octobre 2024 Ajouter une question

Cette FAQ a été réalisée à partir des questions fréquemment posées sur les forums Delphi et Delphi et bases de données de www.developpez.com et de l'expérience personnelle des auteurs.

Nous tenons à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose soient correctes. Les auteurs font le maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous souhaitez y apporter des corrections ou la compléter, contactez un responsable (lien au bas de cette page).

Nous espérons que cette FAQ saura répondre à vos attentes. Nous vous en souhaitons une bonne lecture.

L'équipe Delphi de Developpez.com.

Commentez

Sommaire →Système →WMI →Interrogation avec WQL (5)

Qu'est-ce que WQL ?
Comment modifier les propriétés des fichiers de l'EventLog ?
Comment retrouver un type d'événement particulier de l'EventLog ?
Comment utiliser l'instruction ASSOCIATORS OF ?
Comment utiliser l'instruction REFERENCE OF ?

Qu'est-ce que WQL ?

Le langage d'interrogation de WMI (WQL) est un sous-ensemble du langage d'interrogation structuré SQL ANSI comportant quelques changements sémantiques mineurs. A la différence de SQL, WQL interroge des classes et non des tables, et retourne des classes et/ou des instances au lieu de lignes. Attention WQL n'est pas du SQL mais y ressemble.

WQL est un langage d'interrogation en lecture seule uniquement , on ne peut pas modifier le référentiel CIM par les instructions Insert, Update et Delete, elles ne sont donc pas permises.

WQL fournit des moyens de choisir quelles propriétés sont intéressantes et peut être utilisé pour réduire le nombre de propriétés retournées.

Il existe trois types d'interrogations :

Data queries : retrouve des instances de classes et des informations concernant les associations d'instances.
Schema queries : retrouve des définitions de classes et des informations concernant les associations de schéma.
Event queries : utilisé par des clients d'évènements (temporaires ou permanents). Permet de filtrer les événements.

Certains

opérateurs WQL ne peuvent être utilisés qu'avec certains types d'interrogation, par exemple l'opérateur LIKE ne peut être utilisé qu'avec des interrogations de type Data queries.

La requête suivante interroge le fichier "Application" de l'event log de Windows NT à partir de toutes les instances de Win32_NTLogEvent.

Code delphi :

Sélectionner tout

1
2
Query:='SELECT * FROM Win32_NTLogEvent WHERE Logfile = 'Application''; 
wmiObjectSet := wmiServices.ExecQuery(Query,'WQL',wbemFlagReturnImmediately, nil);

Note : L'installation du produit

SMS de Microsoft ajoute des opérateurs au langage WQL.

WQL permet donc de manipuler des données du système sans connaître ni utiliser d'API Win32. WMI prend ici tout son sens !

Mis à jour le 15 janvier 2014 Laurent Dardenne Pedro

Comment modifier les propriétés des fichiers de l'EventLog ?

On utilise la méthode ExecQuery de l'objet SWbemServices qui renvoie une collection d'objet SWbemObject.
On passe en paramètre une chaine de caractéres ou variable de type string contenant la requête :

Code sql :

Sélectionner tout

'Select * from Win32_NTEventLogFile'

La classe Win32_NTEventLogFile contient des informations sur les fichiers du gestionnaire d'évenements de Windows NT. Elle propose de nombreuses méthodes pour manipuler ces fichiers.
Cette exemple permet de modifier la taille de ces fichiers et le nombre de jours avant la réécriture des événements les plus anciens.
On utilise la méthode Put_ pour modifier l'instance concernée.

Code delphi :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
procedure TForm1.BTConfigureEventLogClick(Sender: TObject); 
var 
  WMILocator:          TSWbemLocator; 
  WmiService:          SWbemServices; 
  
  WmiObject:           SWbemObject; 
  WmiObjectSet:        SWbemObjectSet; 
  
  PropertyMaxFileSize, 
  PropertyOverwriteOutdated: SWbemProperty; 
  
  ObjectEnumerator:    IEnumVariant; 
  
  ArrayVariant, 
  MaxFileSize, 
  OverwriteOutdated :  OleVariant; 
  
  NumberItem:          LongWord; 
  
begin 
  WMILocator:= TSWbemLocator.Create(self); 
  
 try 
   WmiService:= WMILocator.ConnectServer('.', 'ROOT\CIMV2', '', '', '', 
                                         '', wbemConnectFlagUseMaxWait, nil); 
  
     // Retrouve, via une requête WQL et dans l'espace de nom courant, 
     // une collection d'instance de la classe Win32_NTEventLogFile 
     // 3 fichiers EventLog 
   WmiObjectSet := wmiService.ExecQuery('Select * from Win32_NTEventLogFile', 
                                        'WQL', 
                                        wbemFlagReturnImmediately, nil); 
  
   ObjectEnumerator:= (WmiObjectSet._NewEnum) as IEnumVariant; 
   while (ObjectEnumerator.Next(1, ArrayVariant, NumberItem) = S_OK) do 
    begin 
     WmiObject := IUnknown(ArrayVariant) as SWBemObject; 
  
        // Retrouve les propriétés à modifier 
     PropertyMaxFileSize:= WmiObject.Properties_.Item('MaxFileSize',0); 
     PropertyOverwriteOutdated:= WmiObject.Properties_.Item('OverwriteOutdated',0); 
  
        // Nouvelle valeur des propriétés 
     MaxFileSize:= 512000; // 512 Ko (unité byte) 
     OverwriteOutdated:=14; // Ecraser les lignes datant de plus de 14 jours 
  
       //Renseigne les valeurs des propriétés 
     PropertyMaxFileSize.Set_Value(MaxFileSize); 
     PropertyOverwriteOutdated.Set_Value(OverwriteOutdated); 
  
       // Mise à jour de l'instance courante de type Win32_NTEventLogFile 
     WmiObject.Put_(wbemFlagReturnWhenComplete,Nil) ; 
   end; 
 Finally 
  WMILocator.Free; 
 end; 
end;

Pour sauvegarder les fichiers de l'EventLog, vous pouvez utiliser la méthode BackupEventLog.

Mis à jour le 15 janvier 2014 Laurent Dardenne Pedro

Comment retrouver un type d'événement particulier de l'EventLog ?

On utilise ici la classe Win32_NTLogEvent en précisant que l'on recherche les erreurs applicatives :

Code delphi :

Sélectionner tout

SELECT * FROM Win32_NTLogEvent WHERE Logfile = "Application" and EventType=1'

Consultez MSDN pour connaître la signification des types d'événement (EventType).
On affichera les informations au format MOF :

Code delphi :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
procedure TForm1.BTLitEventLogClick(Sender: TObject); 
var 
  WMILocator:          TSWbemLocator; 
  WmiService:          SWbemServices; 
  
  WmiObject:           SWbemObject; 
  wmiObjectSet:        SWbemObjectSet; 
  
  ObjectEnumerator:    IEnumVariant; 
  ArrayVariant:        OleVariant;  // Tableau de variant 
  NumberItem:          LongWord; 
  
begin 
  WMILocator:= TSWbemLocator.Create(self); 
 try 
   WmiService:= WMILocator.ConnectServer('.', 'ROOT\CIMV2', '', '', '', 
                                         '', wbemConnectFlagUseMaxWait, nil); 
  
     // Retrouve, via une requête WQL et dans l'espace de nom courant, 
     // une collection d'instance de la classe Win32_NTLogEvent 
     // Seul les événements 'Application' de type erreur sont concernés. 
     // LogFile= Application, System ou Security 
   WmiObjectSet := wmiService.ExecQuery('SELECT * FROM Win32_NTLogEvent '+ 
                                          'WHERE Logfile = "Application" and EventType=1', 
                                         'WQL', 
                                          wbemFlagReturnImmediately, nil); 
  
  ObjectEnumerator:= (WmiObjectSet._NewEnum) as IEnumVariant; 
  
  while (ObjectEnumerator.Next(1, ArrayVariant, NumberItem) = S_OK) do 
  begin 
   WmiObject := IUnknown(ArrayVariant) as SWBemObject; 
   Memo1.Lines.Add(AdjustLineBreaks(WmiObject.GetObjectText_(0))); 
 end; 
  
 Finally 
  WMILocator.Free; 
 end; 
end;

Mis à jour le 15 janvier 2014 Laurent Dardenne Pedro

Comment utiliser l'instruction ASSOCIATORS OF ?

L'instruction ASSOCIATORS OF retrouve toutes les instances qui sont associées à un objet donné.

Les instances qui sont retrouvées sont désignées sous le nom de points finaux/terminaison (endpoints).
Chaque point final retourné l'est autant de fois qu'il y a d'associations entre lui et l'objet source.

Par exemple, supposez les instances A, B, X, et Y. Deux instances d'association existent, une qui lie A et X et une autre qui lie B et Y. La requête suivante renvoie un point final sur X :

Code delphi :

Sélectionner tout

ASSOCIATORS OF {A}

Cependant, s'il y a une autre association liant A et X, la requête ci-dessus renverra deux points
finaux sur X.

L'exemple suivant affiche les objets liés au répertoire C:\WINDOWS\system32\wbem\Repository qui est le répertoire du référentiel WMI. Il contient, au minimum, le sous-répertoire FS et le fichier $WinMgmt.CFG.

Chacun de ces éléments est une association ainsi que le répertoire parent et une instance de la classe Win32_LogicalFileSecuritySetting qui permet de retrouver les informations de sécurité du répertoire interrogé.

Code delphi :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
var 
  WMILocator:          TSWbemLocator; 
  WmiService:          SWbemServices; 
  
  WmiObject:           SWbemObject; 
  wmiObjectSet:        SWbemObjectSet; 
  
  ObjectEnumerator:    IEnumVariant; 
  ArrayVariant:        OleVariant;  // Tableau de variant 
  NumberItem:          LongWord; 
  FullPath:            String; 
  KeyQualificateur:    String; 
  
begin 
  WMILocator:= TSWbemLocator.Create(self); 
  try 
    // Initialisation du répertoire interrogé 
    FullPath:='"C:\WINDOWS\system32\wbem\Repository"'; 
  
    // Duplique le backslash 
    //"C:\\WINDOWS\\system32\\wbem\\Repository" 
    FullPath:=StringReplace(FullPath,'\','\\',[rfReplaceAll,rfIgnoreCase]); 
  
    WmiService:= WMILocator.ConnectServer('.', 'ROOT\CIMV2', '', '', '', 
                                          '', wbemConnectFlagUseMaxWait, nil); 
    // Retrouve les instances d'association du répertorie courant 
    WmiObjectSet := wmiService.ExecQuery('Associators Of {Win32_Directory.Name='+FullPath+'}', 
                                        'WQL',wbemFlagReturnImmediately, nil); 
  
    ObjectEnumerator:= (WmiObjectSet._NewEnum) as IEnumVariant; 
    Memo1.Lines.Add('Associations de l''instance :'); 
    Memo1.Lines.Add(StringOfChar('*',80)); 
    WMIEnumereObjetRelPath(WmiObjectSet, Memo1.Lines); 
  
    Memo1.Lines.Add(#13#10'Reconstruction des informations contenu dans le path relatif :'); 
    while (ObjectEnumerator.Next(1, ArrayVariant, NumberItem) = S_OK) do 
    begin 
      WmiObject := IUnknown(ArrayVariant) as SWBemObject; 
      // Teste si la propriété est une propriété clé d'unicité 
      KeyQualificateur:=WMIGet_KeyQualifierOfPropertySet(WmiService,WmiObject.Properties_); 
      Memo1.Lines.add('Type de classe : '+WmiObject.path_.Class_+ 
                      '.  Propriété Clé ['+KeyQualificateur+'] = '+ 
                      WmiObject.Properties_.Item(KeyQualificateur,0).Get_Value); 
    end; 
    Memo1.Lines.add(' '); 
  Finally 
    WMILocator.Free; 
  end; 
end;

L'appel du code précédent affichera :

Code other :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
Associations de l'instance : 
******************************************************************************** 
Win32_Directory.Name="c:\\windows\\system32\\wbem\\repository\\fs" 
Win32_Directory.Name="c:\\windows\\system32\\wbem" 
CIM_DataFile.Name="c:\\windows\\system32\\wbem\\repository\\$winmgmt.cfg" 
Win32_LogicalFileSecuritySetting.Path="c:\\windows\\system32\\wbem\\repository" 
  
Reconstruction des informations contenu dans le path relatif: 
Type de classe : CIM_DataFile. Propriété Clé [Name] = c:\windows\system32\wbem\repository\$winmgmt.cfg 
Type de classe : Win32_Directory. Propriété Clé [Name] = c:\windows\system32\wbem\repository\fs 
Type de classe : Win32_Directory. Propriété Clé [Name] = c:\windows\system32\wbem 
Type de classe : Win32_LogicalFileSecuritySetting. Propriété Clé [Path] = c:\windows\system32\wbem\repository

La méthode Associators_ de l'objet SWbemObject retourne une collection d'objets associés.
Cette méthode renvoie le même résultat que l'instruction WQL ASSOCIATORS OF.

Vous pouvez visualiser un schéma d'association avec

un des outils additionnels : "..\WMI Tools\studio.htm".

Note :
La fonction WMIGet_KeyQualifierOfProperty recherche pour une propriété le qualificateur KEY. Cette clé détermine par
exemple l'unicité dans une classe d'association. Ce qualificateur peut ne pas exister, ce qui est souvent le cas.
L'exception wbemErrNotFound (0x80041002) ou « Objet non-trouvé » est donc très souvent déclenchée dans l'EDI sans que cela soit à proprement parler une erreur.

Mis à jour le 15 janvier 2014 Laurent Dardenne Pedro

Lien MSDN :

ASSOCIATORS OF Statement

Comment utiliser l'instruction REFERENCE OF ?

L'instruction REFERENCES OF retrouve toutes les instances d'association qui se rapportent à une instance source particulière. La syntaxe de l'instruction REFERENCES OF est semblable à celle de l'instruction ASSOCIATORS OF. Cependant, plutôt que de retrouver les points finaux, elle recherche les instances d'associations intermédiaires.

Voici les codes MOF des classes que l'on retrouve dans l'exemple plus avant :

Code other :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class CIM_DirectoryContainsFile 
{ 
CIM_Directory ref GroupComponent;  
CIM_DataFile ref PartComponent; 
}; 
  
class Win32_SubDirectory : CIM_Component 
{ 
Win32_Directory ref GroupComponent; 
Win32_Directory ref PartComponent; 
}; 
  
class Win32_SecuritySettingOfLogicalFile : Win32_SecuritySettingOfObject 
{ 
CIM_LogicalFile ref Element; 
Win32_LogicalFileSecuritySetting ref Setting; 
};

La classe CIM_DirectoryContainsFile définit une relation entre la classe CIM_Directory et la classe CIM_DataFile.
Les propriétés GroupComponent et PartComponent contiennent des chemins d'objet vers les instances de classe associées.

Le nom à droite de ref référence une instance de la classe indiquée à gauche de ref.

Ce code d'exemple est la continuation du code proposé dans la rubrique WMI Comment utiliser l'instruction ASSOCIATORS OF ?

Code delphi :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
var 
  WMILocator:          TSWbemLocator; 
  WmiService:          SWbemServices; 
  
  WmiObject:           SWbemObject; 
  wmiObjectSet:        SWbemObjectSet; 
  
  ObjectEnumerator:    IEnumVariant; 
  ArrayVariant:        OleVariant;  // Tableau de variant 
  NumberItem:          LongWord; 
  FullPath:            String; 
  KeyQualificateur:    String; 
  
begin 
  WMILocator:= TSWbemLocator.Create(self); 
  try 
    // Initialisation du répertoire interrogé 
    FullPath:='"C:\WINDOWS\system32\wbem\Repository"'; 
  
    // Duplique le backslash 
    //"C:\\WINDOWS\\system32\\wbem\\Repository" 
    FullPath:=StringReplace(FullPath,'\','\\',[rfReplaceAll,rfIgnoreCase]); 
  
    WmiService:= WMILocator.ConnectServer('.', 'ROOT\CIMV2', '', '', '', 
                                          '', wbemConnectFlagUseMaxWait, nil); 
    // Retrouve les instances des références du directory courant 
  
    WmiObjectSet := wmiService.ExecQuery('References Of {Win32_Directory.Name='+FullPath+'}', 
                                        'WQL',wbemFlagReturnImmediately, nil); 
  
    ObjectEnumerator:= (WmiObjectSet._NewEnum) as IEnumVariant; 
    Memo1.Lines.Add(#13#10+'Références de l''instance :'); 
    Memo1.Lines.Add(StringOfChar('*',80)); 
    WMIEnumereObjetRelPath(WmiObjectSet, Memo1.Lines); 
    while (ObjectEnumerator.Next(1, ArrayVariant, NumberItem) = S_OK) do 
    begin 
      WmiObject := IUnknown(ArrayVariant) as SWBemObject; 
      Memo1.Lines.Add(#13#10+StringOfChar('*',132)); 
      Memo1.Lines.Add('Détail de la référence '+WmiObject.Path_.RelPath); 
      Memo1.Lines.Add(StringOfChar('*',132)); 
  
      Memo1.Lines.Add('Qualificateurs de l''instance de la classe ['+WmiObject.path_.Class_+'] :' ); 
      WMIEnumereQualificateur( WmiObject.Qualifiers_,Memo1.Lines); 
  
      Memo1.Lines.Add(#13#10+'Définition MOF de la classe référencée de type ['+WmiObject.path_.Class_+'] :'+ 
                      AdjustLineBreaks(WmiObject.GetObjectText_(0))); 
  
      Memo1.Lines.Add(#13#10+'Propriétées (références d''instance de classe) de l''instance de la classe ['+WmiObject.path_.Class_+']'); 
  
      WMIEnumereProperty( WmiService,WmiObject.Properties_,Memo1.Lines); 
    end; 
  finally 
    WMILocator.Free; 
  end; 
end;

Mis à jour le 15 janvier 2014 Laurent Dardenne Pedro

Comment utiliser l'instruction ASSOCIATORS OF ?

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça

Titre de la question

Réponse à la question

Liens sous la question

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2024 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.