Discussion :

[lacava]

Bonjour à vous le forum,

Aussi nouveau que je sois ici, je le suis autant sur PS.
C'est pourquoi je sollicite votre aide sur ma situation.

J'ai un fichier texte assez conséquent (environ 400 blocs) qui se trouve sous la forme suivante, je me suis limité à 2 exemples :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
[10]
nom=mon_nom
prenom=mon_prenom
code=1111
adresse=mon_adresse
postal=12345
sexe=m
tel=1234567890

[12]
nom=mon_nom1
prenom=mon_prenom1
code=2222
adresse=mon_adresse1
postal=12345
sexe=f
tel=1234567891

Ce que je souhaite faire, c'est de pouvoir récupérer juste les valeurs de la façon suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
10
mon_nom
mon_prenom
1111
mon_adresse
12345
m
1234567890

12
mon_nom1
mon_prenom2
2222
mon_adresse2
12345
f
1234567891

Pour ensuite les mettre dans une requête SQL qui va insérer les données dans une base.

Dans un premier temps, ma question est de savoir comment récupérer juste ces valeurs et les insérer chacune dans une variable.
En espérant que ma demande soit assez précise.

Merci de votre aide.

[Laurent Dardenne]

Salut,

Bonjour à vous le forum,
J'ai un fichier texte assez conséquent (environ 400 blocs) qui se trouve sous la forme suivante, je me suis limité à 2 exemples :

Pour analyser ce type de fichier structuré il faut en connaitre toutes les règles. Nb de lignes par bloc, structure de chaque ligne
Ensuite la création d'objet ou d'une ligne de requête sera plus aisé.

[lacava]

Bonjour Laurent,

Merci bien de votre retour.

Pour analyser ce type de fichier structuré il faut en connaitre toutes les règles. Nb de lignes par bloc, structure de chaque ligne
Ensuite la création d'objet ou d'une ligne de requête sera plus aisé.

Pour ce qui est des règles, pour les 2 exemples que j'ai illustré, tous les autres sont fait de la même façon donc cette structure reste la même qui soit pour le [21], le [112], le [203] et ainsi de suite.
Par contre, je n'ai pas mentionné que dans certains paramètres, se trouve un caractère spécial, exemple du [20] :

[20]
...
etage=1/2
dpt=bloc <30>
...

Et pour certains paramètres, le nombre de caractères sur la ligne peut changer (ex : etage=1/21).
Donc concrètement, si l'on compte ce paramètre entre [] avec les autres valeurs qui lui sont attribuées, cela fait 20 lignes exactement par bloc.
Par inattention, j'ai mis 10 et 20 comme valeur entre crochet mais en fait j'ai 4 chiffres et ça pour tout le monde. Je le précise au cas où cela aurait son importance.
J'espère répondre à toutes vos questions.

Merci.

[Laurent Dardenne]

Comme c'est le type de traitement qu'on peut réutiliser, voici une ébauche :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
$file ='c:\temp\datas.txt'
@'
[10]
nom=mon_nom
prenom=mon_prenom
code=1111
adresse=mon_adresse
postal=12345
sexe=m
tel=1234567890
etage=1/2
dpt=bloc <30>

[12]
nom=mon_nom1
prenom=mon_prenom1
code=2222
adresse=mon_adresse1
postal=12345
sexe=f
tel=1234567891
etage=1/2
dpt=bloc <30>

[12]
nom=mon_nom1
prenom=mon_prenom1
code=2222
adresse=mon_adresse1
postal=12345
sexe=f
tel=1234567891
'@ > $File

Function Split-Bloc {
  $NombreDeLigneParBloc=11
  $NombreDePropriétés=10

  $Elements=Get-Content $File -ReadCount $NombreDeLigneParBloc
  
   #tableau de tableau
  Foreach( $Lignes in $Elements)
  {
       #Transforme un bloc en un objet Powershell 
      $CurrentObject= New-Object PSObject         
      
       #Ligne d'un bloc
       Foreach( $Ligne in $Lignes)
       {
        #Write-debug "Traite la ligne : $Ligne"
         switch -regex ($Ligne) 
         {
             #séparateur + valeur sur quatre chiffres + séparateur
            '^\[(?<Number>\d{1,4})\]$'     { 
                                              Write-debug ("`tAjoute la propriété {0}"-F $Matches.0)
                                              $CurrentObject.psObject.Properties.Add( 
                                                (New-Object Management.Automation.PSNoteProperty('Number',$Matches.Number)))
                                              Continue 
                                           }
                
             #Nom + séparateur + valeur
            '^(?<Name>.*?)=(?<Value>.*)$' { 
                                            Write-debug ("`tAjoute la propriété {0}"-F $Matches.0)
                                            $CurrentObject.psObject.Properties.Add(
                                              (New-Object Management.Automation.PSNoteProperty($Matches.Name, $Matches.Value)))
                                            Continue 
                                          }
  
            ''                            { Write-Debug "`tLigne vide";Continue }
            default {Write-Error 'Cas inconnu : $Element' }
         }
       } #lignes
       
       #Todo liste des noms de propriété, car ETS peut ajouter des membres 
      $nbProperties=0;$CurrentObject.psobject.Properties.GetEnumerator()|% {$nbProperties++}
      Write-Debug "nbProperties=$nbProperties" 
      if ($nbProperties -ne $NombreDePropriétés) 
      { Write-Error "Object incomplet :  $CurrentObject" }
      #Controles d'autres régles, possible...
        
      Write-Output $CurrentObject 
  }#Elements
} #Split-Bloc

$Objets=Split-Bloc

$Objets.Count

Et pour certains paramètres, le nombre de caractères sur la ligne peut changer (ex : etage=1/21).

L'autre étape serait d'insérer des règles de validation sur les données de l'objet, à moins qu'une procédure stockée s'en charge...

Je le précise au cas où cela aurait son importance.

C'est toi seul qui juge si cela l'est ou pas ! je ne connais pas le fonctionnel.
J'ai préféré construire des objets ainsi tu peux filtrer la collection, ou regrouper des objets pour une insertion par lots, via BCP.exe par exemple.

[lacava]

J'ai dû modifier un peu votre code pour que cela fonctionne de mon côté. $Matches.0 devient $Matches
De ce que je comprends, il arrive bien à lire les valeurs après le '=' de chaque ligne ainsi que le nombre entre [].
Et ce qu'il fait, au final, il compte le nombre de blocs.

Pour voir ce que la variable $Objets retourne, j'ai rajouté : Write-Output $Objets au code et j'enregistre dans un fichier
$Objets=Split-Bloc > $files2.

Il me retourne le résultat suivant :

Number : 10
nom : mon_nom
prenom : mon_prenom
code : 1111
adresse : mon_adresse
postal : 12345
sexe : m
tel : 1234567890
etage : 1/2
dpt : bloc <30>

Number : 12
nom : mon_nom1
prenom : mon_prenom1
code : 2222
adresse : mon_adresse1
postal : 12345
sexe : f
tel : 1234567891
etage : 1/2
dpt : bloc <30>


Donc il arrive à bien séparer les blocs et à retourner les valeurs de chaque ligne sous une forme un peu plus normalisée.

Avant d'utiliser BCP, j'ai essayé de retourner en résultat seulement le nombre et les valeurs après le ':' avec les variables $Matches.Number et $Matches.Value, qui je pense sont les variables où se stockent les fameuses valeurs, mais je n'y suis pas arrivé.

Finalement la longueur peut varier, le script arrivera quand même à l'interpréter sans créer de règles ou autres.

Du coup pour ce qui est de BCP, est-ce possible de le faire directement à partir du code, ou l'on doit partir d'un fichier non xml généré par le code ?

[Laurent Dardenne]

Pour voir ce que la variable $Objets retourne, j'ai rajouté : Write-Output $Objets au code et j'enregistre dans un fichier

Comme la fonction renvoie des objets tu peux ne pas utiliser de variable intermédiaire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Split-Bloc > $files2

Avant d'utiliser BCP, j'ai essayé de retourner en résultat seulement le nombre et les valeurs après le ':' avec les variables $Matches.Number et $Matches.Value, qui je pense sont les variables où se stockent les fameuses valeurs, mais je n'y suis pas arrivé.

C'est à dire construire une ligne d'insert SQL ?

Du coup pour ce qui est de BCP, est-ce possible de le faire directement à partir du code, ou l'on doit partir d'un fichier non xml généré par le code ?

Je crois que BCP.exe nécessite un fichier intermédiaire, voici un exemple via un csv :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
$csv="C:\Script\DATA\Tables\tablename.csv"
bcp Base.dbo.TableName in $csv -q -c -t ';' -S My_MSSQLSERVER -U MyAccountName -P MyPassWord

La contrainte est que la première ligne du fichier .csv ne doit pas contenir les noms des champs et les guillemets doivent être supprimé.
Un exemple rapido :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
function Skip-Count() {
#jaredpar's WebLog
# Skip the specified number of items
#Example:
#
#1..10 | skip-count 5 #renvoi 6..10
#Ignore un nombre spécifié d'éléments dans une séquence puis retourne les éléments restants. 

    param ( $count = $(throw "Need a count") )
    begin { 
        $i = 0
    }
    process {
        if ( $i -ge $count ) { 
            $_
        }
        $i += 1
    }
    end {}
}

Function ConvertTo-CsvNoQuote([string]$PathCsv)
{
    #remplace les guillemets
  $T=Get-content $PathCsv|% { $_ -replace '"',""}
    #retire la première ligne contenant les noms des champs
  $T|Skip-Count 1|Set-content $PathCsv
}
$csvFileName="C:\Script\DATA\Tables\tablename.csv"
Split-Bloc|Export-csv $csvFileName -notype -Delimiter ';'
ConvertTo-CsvNoQuote  "$csvFileName.New" # a revoir

bcp Base.dbo.TableName in $"$csvFileName.New" -q -c -t ';' -S My_MSSQLSERVER -U MyAccountName -P MyPassWord

Je ne me souviens plus comment bcp traite les lignes en erreur et peut être que cet BCP.exe sait manipuler des blocs, à vérifier dans la doc.
Il y a également SMO (BulkLoad), mais il faut 'recoder' une partie de BCP.
Cette approche date de 4-5 ans, il existe peut être mieux depuis.

[lacava]

C'est à dire construire une ligne d'insert SQL ?

C'est la finalité que je recherche. Déjà, je fais la connexion à ma base de données et ma requête doit être de la forme :

INSERT into 'identity (
id,
nom,
prenom,
code,
adresse,
postal,
sexe,
tel,
etage,
dpt
)
VALUES
(
$Number,
$nom,
$prenom,
$code,
$adresse,
$postal,
$sexe,
$tel,
$etage,
$dpt
)

où les variables contiennent les valeurs de chacune des lignes d'un bloc.

Je crois que BCP.exe nécessite un fichier intermédiaire, voici un exemple via un csv :

Le format du csv doit se faire sous forme de champs si je comprends. Donc il faudrait plutôt que de générer un fichier .txt, on génère un fichier .csv avec les noms des lignes comme champs :

id,nom,prenom,code,adresse,postal,sexe,tel,etage,dpt
10,mon_nom,mon_prenom,1111,mon_adresse,12345,m,1234567890,1/2,bloc <30>
20,mon_nom2,mon_prenom,...

et ainsi de suite.

Le problème est que les champs de ma base ne sont pas dans l'ordre donnée par le bloc, il y a des champs inutilisés, c'est pourquoi la présence des champs dans la requête est important. Donc si on supprime la première ligne où se trouve le nom des champs dans le .csv, cela ne fonctionnera pas.

[Laurent Dardenne]

C'est la finalité que je recherche.

Une possibilité via la substitution :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
Foreach ($Objet in $Objets)
{
@"
INSERT into 'identity' (
id,
nom,
prenom,
code,
adresse,
postal,
sexe,
tel,
etage,
dpt
)
VALUES
(
$($Objet.Number),
$($Objet.nom),
$($Objet.prenom),
$($Objet.code),
$($Objet.adresse),
$($Objet.postal),
$($Objet.sexe),
$($Objet.tel),
$($Objet.etage),
$($Objet.dpt)
)
"@
}

[lacava]

Je suis parti de la requête que tu m'as donné. Voilà comment cela se présente dans mon code à la suite du traitement des blocs pour l'exécution de la requête, sachant que c'est une base mysql que j'ai (j'ai omis la connexion à la base) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
   
    $connection = New-Object MySql.Data.MySqlClient.MySqlConnection

    $connection.ConnectionString = “server=$srv;port=$port;uid=$user;pwd=$mdp;database=$bdd;Pooling=False”

    $connection.Open()

Foreach ($Objet in $Objets)
{

     $Requete = "INSERT into 'identity' (

id,
nom,
prenom,
code,
adresse,
postal,
sexe,
tel,
etage,
dpt
)
VALUES
(
'$($Objet.Number)',
'$($Objet.nom)',
'$($Objet.prenom)',
'$($Objet.code)',
'$($Objet.adresse)',
'$($Objet.postal)',
'$($Objet.sexe)',
'$($Objet.tel)',
'$($Objet.etage)',
'$($Objet.dpt)'
)"

    $command = New-Object MySql.Data.MySqlClient.MySqlCommand($Requete, $connection)

    $dataAdapter = New-Object MySql.Data.MySqlClient.MySqlDataAdapter($command)

    $DataSet = new-object System.Data.DataSet

    $DataAdapter.Fill($DataSet)

    $tableauSQL = $DataSet.Tables[0].Rows

}

La requête s'exécute. Le souci c'est que dans ma table cela affiche 1 ligne dans ma table avec des valeurs vides. Donc non seulement, la boucle n'est pas prise en charge et en plus les variables ne sont pas lues. J'espère avoir fait les choses correctement. Je souhaiterai savoir comment régler ce souci.

Merci de votre aide.

[Laurent Dardenne]

Je souhaiterai savoir comment régler ce souci.

Peut être en exécutant la requête sur la base...

[lacava]

A partir du lien que tu m'as donné, et en rajoutant ceci au code :

$command.ExecuteNonQuery();

J'obtiens bien le même résultat : Une ligne rajoutée dans la table avec des champs vides. Semblerait il les variables passées en arguments à la requete ne contiennent pas de valeurs.

[Laurent Dardenne]

Semblerait il les variables passées en arguments à la requete ne contiennent pas de valeurs.

Pour s'en assurer ajoute,après sa construction, le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Write-debug $requete

Tu peux également vérifier avec requeteur MySQL si sa syntaxe est correcte.