Discussion :

[SergeF]

Bonjour,

quelle est la solution la + simple et la + cohérente pour copier une table d'une base de donnée vers une autre ?

PS :

cas 1 : il y a + de colonnes dans la table cible
cas 2 : les tables origine et cible sont identiques

Merci pour toute suggestion

[bifidus]

Salut,
Si c'est entre des Formats différents:
Un DataReader Pour récupèrer les données.
Puis on boucle avec une Commande qui fait des INSERT dans la table Cible a chaque lecture.
Si c'est sur les bases sont au meme format SQL Server ou Oracle il faut écrire toute la procédure en SQL.
Il suffit alors d'appeler la procedure stockée, ce sera beaucoup plus rapide.

[Maniak]

cas 2 : les tables origine et cible sont identiques

2 chaînes de connexions, 1 DataSet. Tu remplis le DataSet à partir de la première connexion, tu mets à jour dans la deuxième.

cas 1 : il y a + de colonnes dans la table cible

Si les colonnes existantes sont identiques, c'est pareil. Sinon, si tu peux rendre la structre identique en jouant sur la requête de récupération des données, le reste est pareil aussi. Et sinon, faut une moulinette :)

[bifidus]

Le Dataset c'est bien si les tables sont pas trop importantes...
Pour une utilisation générale la moulinette sur le DataReader me semble plus sure....

[Maniak]

Le Dataset c'est bien si les tables sont pas trop importantes...
Pour une utilisation générale la moulinette sur le DataReader me semble plus sure....

On a déjà couvert le sujet, mais à partir du moment où l'ensemble des données sont parcourues, il n'y a pas d'avantage du DataReader en termes de vitesse. Reste l'utilisation de la mémoire. S'il y a 2Go de données dans la table, c'est clair qu'il vaut mieux éviter, ou faire par petits bouts :)

Bon après, selon le type de bases, il y a peut-être déjà des instructions toutes faites pour ce genre d'opérations (genre BULK INSERT dans SQL Server). Si c'est applicable, y aura ni plus simple, ni plus rapide :)

Autre option, toujours pour SQL Server en source & destination : passer par un SELECT INTO (en faisant un serveur lié si la base de destination est sur une autre machine).

[SergeF]

Merci pour toutes les solutions.

Et s'il s'agit d'une duplication de BDD complete, y a t il une solution particulière ?

Faut il passer par un backup / restore ?

[bifidus]

Pour la Duplication d'une db complète, c'est pas vraiment un problème de .NET a moins de vouloir réinventer la poudre!
Il ne suffit pas de copier les tables: il y a les utilisateurs, les autorisations, les triggers etc...
De toute facon ca va dépendre du format de la base de donnée...
Pour SQL Server il y a la solution du Backup/Restore ou l'assistant de Transformation de données de Enterprise Manager qui permet d'importer tous les objets de la base et qui est trés souple.
Pour MySQL ou Oracle je connais pas.

[Maniak]

Faut il passer par un backup / restore ?

C'est encore le plus simple (si on excepte les embrouilles de droits avec des logins qui n'existent pas encore sur la base de destination). Sinon, toujours pour SQLServer, tu peux faire un package DTS pour ça, il y a une opération déjà toute faite pour les copies de BDDs. D'autres systèmes ont peut-être des équivalents.

Dans tous les cas, je rejoins bifidus, c'est pas du ressort de .NET. À moins de vouloir développer un remplacement d'Enterprise Manager en .NET :)

[SergeF]

Oui, effectivement, je n'avais pas pensé a DTS ... :-(

Pour ceux que ca interesse, une solution en VB.NET qui copie le contenu de toutes tables de la BDD d'origine vers le BDD destination. Les structures de tables sont considérées comme identiques (mais ca marche aussi si les tables destinations ont + de colones).

Si il y a des commentaires sur le codage ou l'utilisation plus ou moins appropriée des objets .net, je suis preneur.

Salut a tous.

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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
    Public Function CopyTableDataV1p1(ByVal sFromConnection As String, ByVal sToConnection As String) As Boolean
 
        Dim sctSchemaTableTABLES As DataTable
        Dim ocmMyFromOleDBCommand As New OleDb.OleDbCommand
        Dim drMyFromOleDataReader As OleDb.OleDbDataReader
        Dim iTables As Integer
        Dim sFromCommand As String
        Dim arColumns As New ArrayList
        Dim arColumnTypes As New ArrayList
        Dim sctSchemaTableCOLUMNS As DataTable
        Dim myRow As DataRow
        Dim myCol As DataColumn
        Dim ocmMyToOleDBCommand As New OleDb.OleDbCommand
        Dim drMyToOleDataReader As OleDb.OleDbDataReader
        Dim sToCommand As String
        Dim sToCommandFinal As String
        Dim iColumns As Integer
 
        'ouverture base de donnée source
        Try
            myFromOleBDConnexion.ConnectionString = sFromConnection
            myFromOleBDConnexion.Open()
        Catch ex As OleDb.OleDbException
            MessageBox.Show("Erreur d'ouverture Base de Donnée source. Erreur : <" & ex.Message & ">" & vbCrLf & sFromConnection.ToString, "CopyTableDataV1p1", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning)
            CopyTableDataV1p1 = False
            GoTo ExitFunction
        End Try
 
        'ouverture base de donnée cible
        Try
            myToOleBDConnexion.ConnectionString = sToConnection
            myToOleBDConnexion.Open()
        Catch ex As OleDb.OleDbException
            MessageBox.Show("Erreur d'ouverture Base de Donnée cible. Erreur : <" & ex.Message & ">" & vbCrLf & sToConnection.ToString, "CopyTableDataV1p1", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning)
            CopyTableDataV1p1 = False
            GoTo ExitFunction
        End Try
 
        'récupération du schéma BDD (liste des tables)
        sctSchemaTableTABLES = myFromOleBDConnexion.GetOleDbSchemaTable(OleDb.OleDbSchemaGuid.Tables, New Object() {Nothing, Nothing, Nothing, "TABLE"})
 
        'pour chaque table
        Try
            For iTables = 0 To sctSchemaTableTABLES.Rows.Count - 1
                With sctSchemaTableTABLES.Rows(iTables)
                    'ouverture de la table et du datareader
                    sFromCommand = "SELECT * FROM " & .Item(2)
                    With ocmMyFromOleDBCommand
                        .Connection = myFromOleBDConnexion
                        .CommandType = CommandType.Text
                        .CommandText = sFromCommand
                        drMyFromOleDataReader = .ExecuteReader()
                    End With
 
                    'récupération du schéma de la table
                    sctSchemaTableCOLUMNS = drMyFromOleDataReader.GetSchemaTable()
                    arColumns.Clear()
                    arColumnTypes.Clear()
                    For Each myRow In sctSchemaTableCOLUMNS.Rows
                        arColumns.Add(myRow(0).ToString)
                        arColumnTypes.Add(myRow(5).ToString.ToLower)
                    Next
 
                    'construire le SQL INSERT
                    sToCommand = "INSERT INTO " & .Item(2) & " ("
 
                    'pour chaque colonne les noms de colonnes
                    For iColumns = 0 To arColumns.Count - 1
                        sToCommand &= arColumns(iColumns).ToString & ", "
                    Next iColumns
                    sToCommand = sToCommand.Substring(0, sToCommand.Length - 2) & ") VALUES ("
 
                    'copie des données
                    Do While drMyFromOleDataReader.Read
                        sToCommandFinal = sToCommand
 
                        'pour chaque colonne les data
                        For iColumns = 0 To arColumns.Count - 1
                            Select Case arColumnTypes(iColumns).ToString
                                Case "system.int32"
                                    sToCommandFinal &= IIf(IsDBNull(drMyFromOleDataReader.Item(iColumns)), "NULL", drMyFromOleDataReader.Item(iColumns).ToString) & ", "
                                Case "system.string"
                                    sToCommandFinal &= IIf(IsDBNull(drMyFromOleDataReader.Item(iColumns)), "NULL", "'" & drMyFromOleDataReader.Item(iColumns).ToString) & "', "
                                Case "system.datetime"
                                    sToCommandFinal &= IIf(IsDBNull(drMyFromOleDataReader.Item(iColumns)), "NULL", "'" & Format(CDate(drMyFromOleDataReader.Item(iColumns).ToString), "MM/dd/yyyy hh:mm:ss")) & "', "
                                Case "system.double"
                                    sToCommandFinal &= IIf(IsDBNull(drMyFromOleDataReader.Item(iColumns)), "NULL", drMyFromOleDataReader.Item(iColumns).ToString.Replace(",", ".")) & ", "
                                Case Else 'pour d'autres types
                            End Select
                        Next iColumns
                        sToCommandFinal = sToCommandFinal.Substring(0, sToCommandFinal.Length - 2) & ")"
 
                        'utiliser le SQL INSERT
                        With ocmMyToOleDBCommand
                            .Connection = myToOleBDConnexion
                            .CommandType = CommandType.Text
                            .CommandText = sToCommandFinal
                            drMyFromOleDataReader = .ExecuteReader()
                        End With
                        drMyToOleDataReader.Close()
                    Loop
 
                    'fin de lecture de la table
                    drMyFromOleDataReader.Close()
                End With
            Next
        Catch ex As OleDb.OleDbException
            MessageBox.Show("Erreur pendant opération de copie. Erreur : <" & ex.Message & ">" & vbCrLf & sToConnection.ToString, "CopyTableDataV1p1", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning)
            CopyTableDataV1p1 = False
            GoTo ExitFunction
        End Try
 
        CopyTableDataV1p1 = True
 
ExitFunction:
 
        'fermeture base de donnée source
        If Not myFromOleBDConnexion Is Nothing Then
            Try
                myFromOleBDConnexion.Close()
            Catch ex As Exception
                MessageBox.Show("Erreur de fermeture Base de Donnée source. Erreur : <" & ex.Message & ">", "CopyTableDataV1p1", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning)
                CopyTableDataV1p1 = False
            End Try
        End If
 
        'fermeture base de donnée cible
        If Not myToOleBDConnexion Is Nothing Then
            Try
                myToOleBDConnexion.Close()
            Catch ex As Exception
                MessageBox.Show("Erreur de fermeture Base de Donnée cible. Erreur : <" & ex.Message & ">", "CopyTableDataV1p1", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning)
                CopyTableDataV1p1 = False
            End Try
        End If
 
    End Function

[bifidus]

Ou la la, c'est pas trés Objet ton code !
ca fait un peu VB6...
Si tu as besoin de copier une seule Table vers une autre tu va être obligé de faire de l'héritage par Copier Coller...
VB6 = Function CopyTables(ConDep, ConDest)
VB.NET= (je donne juste un exemple de structure)

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
Class dbClass 'ta classe de base de donnée qui encapsule des Objets OleDb qui ne sont pas héritables
 
Dim Con as OleDbConnection
Dim Tb() as TbClass
 
Sub New(con as OledbConnection)
 me.Con = con
End Sub
 
Public Sub CopyTo(db as dbClass)
  Dim Tble as New TbClass
  For each Tble in me.Tb
    Dim TbDest as new TbClass
    db.Tb.add(TbDest)    
    Tble.CopyTo(TbDest)
  Next
End sub
End Class
 
Public Class TbClass 'Ta classe de Table
 
  Dim Tb as DataTable
 
  Public Sub CopyTo(Tb as TbClass)
  End sub
 
End Class

Aprés on peut gérer les erreurs, rajouter une détection des formats de Base pour faire du SQL spécifique et avoir un vrai composant de gestion de Bases réutilisable !