J'ai écrit un petit programme en VB dans le but de comparer les
rapidités d'Access et SQL Server en insertion.
J'insère donc 10 000 enregistrements dans une table de chacun des deux
systèmes. Je pensais que SQL Server serait au moins équivalent, si ce
n'est plus rapide qu'Access...
Voici mes résultats :
en local :
Access : 0 secondes !!!!!
SQL Server : entre 63 et 68 secondes !
en réseau, avec 4 PC faisant tourner le même programme en même temps
(ils sont synchronisés : le test ne démarre qu'en présence d'un
fichier bien précis sur le réseau et cette présence est testée toutes
les 5 millisecondes avant que le test ne démarre) :
Access : planté sur 2 PC sur les 4 avec une erreur renvoyant un
verrouillage, 6 secondes sur les 2 autres PC,
SQL Server : planté sur 1 PC avec une erreur incompréhensible (une
méthode ~ incorrecte sur un objet ~ !!?), sur les trois autres des
temps qui tournent autour de 125 !!!!
Ces chiffres sont pour moi complètement irréels, surtout le 0 secondes
pour 10 000 boucles d'insertions sur Access. A l'inverse, 125 secondes
sur un réseau certes chargé et sur une table utilisée par trois
programmes, ça me paraît énorme.
Quelqu'un a-t-il un début d'explication à ces résultats délirants ?
Merci d'avance,
Via :)
PS :
Voici le code du programme (du moins de la partie qui nous intéresse)
:
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Vuillermet Jacques
1- Pour insérer 10 000 enregistrements, je ne passerai pas forcément par une boucle.
2 - Pour SQL Server, essaie avec : RsADO.CursorLocation = adUseServer Je pense que cela devrait faire moins d'aller-retour C/S.
Jacques.
"Via" a écrit dans le message de news:
Bonjour à tous !
J'ai écrit un petit programme en VB dans le but de comparer les rapidités d'Access et SQL Server en insertion. J'insère donc 10 000 enregistrements dans une table de chacun des deux systèmes. Je pensais que SQL Server serait au moins équivalent, si ce n'est plus rapide qu'Access... Voici mes résultats :
en local : Access : 0 secondes !!!!! SQL Server : entre 63 et 68 secondes !
en réseau, avec 4 PC faisant tourner le même programme en même temps (ils sont synchronisés : le test ne démarre qu'en présence d'un fichier bien précis sur le réseau et cette présence est testée toutes les 5 millisecondes avant que le test ne démarre) : Access : planté sur 2 PC sur les 4 avec une erreur renvoyant un verrouillage, 6 secondes sur les 2 autres PC, SQL Server : planté sur 1 PC avec une erreur incompréhensible (une méthode ~ incorrecte sur un objet ~ !!?), sur les trois autres des temps qui tournent autour de 125 !!!!
Ces chiffres sont pour moi complètement irréels, surtout le 0 secondes pour 10 000 boucles d'insertions sur Access. A l'inverse, 125 secondes sur un réseau certes chargé et sur une table utilisée par trois programmes, ça me paraît énorme.
Quelqu'un a-t-il un début d'explication à ces résultats délirants ? Merci d'avance,
Via :)
PS : Voici le code du programme (du moins de la partie qui nous intéresse) :
Select Case Test Case FIN Unload Me Exit Sub
Case ACCESS, ACCESS + SQLSERVER
Me.Caption = "Test Access en cours..."
DBEngine.SystemDB = "ServeurCOPTISTestSYS.COR"
Set wEspacedeTravail = DBEngine.CreateWorkspace("Test", "xxxx", "xxxx") DBEngine.Workspaces.Append wEspacedeTravail Set dBaseDeDonnées > DBEngine.Workspaces("Test").OpenDatabase("ServeurCOPTISTestTest.mdb", False, False)
'Test en ajout SQL = "SELECT Test FROM Test;"
TDepart = Time
Set RsDAO = dBaseDeDonnées.OpenRecordset(SQL, dbOpenDynaset, dbConsistent)
For Index = 1 To NbOccurences
RsDAO.AddNew RsDAO!Test = Index RsDAO.Update
Next Index
Text1.Text = DateDiff("s", TDepart, Time)
If Test = ACCESS + SQLSERVER Then Test = SQLSERVER GoTo Test End If
Case SQLSERVER
Me.Caption = "Test SQL Server en cours..."
Set ConnexionSQLServer = CreateObject("ADODB.Connection") ConnexionSQLServer.Open "Provider=SQLOLEDB;Data Source=Coptis;Initial Catalog=Test;User ID=xxxx;Password=xxxx"
SQL = "SELECT Test FROM Test;"
TDepart = Time
Set RsADO = New ADODB.Recordset RsADO.CursorLocation = adUseClient RsADO.Open SQL, ConnexionSQLServer, adOpenDynamic, adLockOptimistic
For Index = 1 To NbOccurences
RsADO.AddNew RsADO!Test = Index RsADO.Update
Next Index
Text2.Text = DateDiff("s", TDepart, Time)
End Select
1- Pour insérer 10 000 enregistrements, je ne passerai pas forcément par une
boucle.
2 - Pour SQL Server, essaie avec :
RsADO.CursorLocation = adUseServer
Je pense que cela devrait faire moins d'aller-retour C/S.
Jacques.
"Via" <chew.baka@caramail.com> a écrit dans le message de news:
eb39e50b.0408250248.15deedc0@posting.google.com...
Bonjour à tous !
J'ai écrit un petit programme en VB dans le but de comparer les
rapidités d'Access et SQL Server en insertion.
J'insère donc 10 000 enregistrements dans une table de chacun des deux
systèmes. Je pensais que SQL Server serait au moins équivalent, si ce
n'est plus rapide qu'Access...
Voici mes résultats :
en local :
Access : 0 secondes !!!!!
SQL Server : entre 63 et 68 secondes !
en réseau, avec 4 PC faisant tourner le même programme en même temps
(ils sont synchronisés : le test ne démarre qu'en présence d'un
fichier bien précis sur le réseau et cette présence est testée toutes
les 5 millisecondes avant que le test ne démarre) :
Access : planté sur 2 PC sur les 4 avec une erreur renvoyant un
verrouillage, 6 secondes sur les 2 autres PC,
SQL Server : planté sur 1 PC avec une erreur incompréhensible (une
méthode ~ incorrecte sur un objet ~ !!?), sur les trois autres des
temps qui tournent autour de 125 !!!!
Ces chiffres sont pour moi complètement irréels, surtout le 0 secondes
pour 10 000 boucles d'insertions sur Access. A l'inverse, 125 secondes
sur un réseau certes chargé et sur une table utilisée par trois
programmes, ça me paraît énorme.
Quelqu'un a-t-il un début d'explication à ces résultats délirants ?
Merci d'avance,
Via :)
PS :
Voici le code du programme (du moins de la partie qui nous intéresse)
:
Select Case Test
Case FIN
Unload Me
Exit Sub
Case ACCESS, ACCESS + SQLSERVER
Me.Caption = "Test Access en cours..."
DBEngine.SystemDB = "\ServeurCOPTISTestSYS.COR"
Set wEspacedeTravail = DBEngine.CreateWorkspace("Test",
"xxxx", "xxxx")
DBEngine.Workspaces.Append wEspacedeTravail
Set dBaseDeDonnées > DBEngine.Workspaces("Test").OpenDatabase("\ServeurCOPTISTestTest.mdb",
False, False)
'Test en ajout
SQL = "SELECT Test FROM Test;"
TDepart = Time
Set RsDAO = dBaseDeDonnées.OpenRecordset(SQL, dbOpenDynaset,
dbConsistent)
For Index = 1 To NbOccurences
RsDAO.AddNew
RsDAO!Test = Index
RsDAO.Update
Next Index
Text1.Text = DateDiff("s", TDepart, Time)
If Test = ACCESS + SQLSERVER Then
Test = SQLSERVER
GoTo Test
End If
Case SQLSERVER
Me.Caption = "Test SQL Server en cours..."
Set ConnexionSQLServer = CreateObject("ADODB.Connection")
ConnexionSQLServer.Open "Provider=SQLOLEDB;Data
Source=Coptis;Initial Catalog=Test;User ID=xxxx;Password=xxxx"
SQL = "SELECT Test FROM Test;"
TDepart = Time
Set RsADO = New ADODB.Recordset
RsADO.CursorLocation = adUseClient
RsADO.Open SQL, ConnexionSQLServer, adOpenDynamic,
adLockOptimistic
1- Pour insérer 10 000 enregistrements, je ne passerai pas forcément par une boucle.
2 - Pour SQL Server, essaie avec : RsADO.CursorLocation = adUseServer Je pense que cela devrait faire moins d'aller-retour C/S.
Jacques.
"Via" a écrit dans le message de news:
Bonjour à tous !
J'ai écrit un petit programme en VB dans le but de comparer les rapidités d'Access et SQL Server en insertion. J'insère donc 10 000 enregistrements dans une table de chacun des deux systèmes. Je pensais que SQL Server serait au moins équivalent, si ce n'est plus rapide qu'Access... Voici mes résultats :
en local : Access : 0 secondes !!!!! SQL Server : entre 63 et 68 secondes !
en réseau, avec 4 PC faisant tourner le même programme en même temps (ils sont synchronisés : le test ne démarre qu'en présence d'un fichier bien précis sur le réseau et cette présence est testée toutes les 5 millisecondes avant que le test ne démarre) : Access : planté sur 2 PC sur les 4 avec une erreur renvoyant un verrouillage, 6 secondes sur les 2 autres PC, SQL Server : planté sur 1 PC avec une erreur incompréhensible (une méthode ~ incorrecte sur un objet ~ !!?), sur les trois autres des temps qui tournent autour de 125 !!!!
Ces chiffres sont pour moi complètement irréels, surtout le 0 secondes pour 10 000 boucles d'insertions sur Access. A l'inverse, 125 secondes sur un réseau certes chargé et sur une table utilisée par trois programmes, ça me paraît énorme.
Quelqu'un a-t-il un début d'explication à ces résultats délirants ? Merci d'avance,
Via :)
PS : Voici le code du programme (du moins de la partie qui nous intéresse) :
Select Case Test Case FIN Unload Me Exit Sub
Case ACCESS, ACCESS + SQLSERVER
Me.Caption = "Test Access en cours..."
DBEngine.SystemDB = "ServeurCOPTISTestSYS.COR"
Set wEspacedeTravail = DBEngine.CreateWorkspace("Test", "xxxx", "xxxx") DBEngine.Workspaces.Append wEspacedeTravail Set dBaseDeDonnées > DBEngine.Workspaces("Test").OpenDatabase("ServeurCOPTISTestTest.mdb", False, False)
'Test en ajout SQL = "SELECT Test FROM Test;"
TDepart = Time
Set RsDAO = dBaseDeDonnées.OpenRecordset(SQL, dbOpenDynaset, dbConsistent)
For Index = 1 To NbOccurences
RsDAO.AddNew RsDAO!Test = Index RsDAO.Update
Next Index
Text1.Text = DateDiff("s", TDepart, Time)
If Test = ACCESS + SQLSERVER Then Test = SQLSERVER GoTo Test End If
Case SQLSERVER
Me.Caption = "Test SQL Server en cours..."
Set ConnexionSQLServer = CreateObject("ADODB.Connection") ConnexionSQLServer.Open "Provider=SQLOLEDB;Data Source=Coptis;Initial Catalog=Test;User ID=xxxx;Password=xxxx"
SQL = "SELECT Test FROM Test;"
TDepart = Time
Set RsADO = New ADODB.Recordset RsADO.CursorLocation = adUseClient RsADO.Open SQL, ConnexionSQLServer, adOpenDynamic, adLockOptimistic
For Index = 1 To NbOccurences
RsADO.AddNew RsADO!Test = Index RsADO.Update
Next Index
Text2.Text = DateDiff("s", TDepart, Time)
End Select
Patrice
Il est toujours difficile de comparer directement deux choses différentes (malgré les apparences) : - DAO écrit directement dans le fichier local - ADO envoie des instructions SQL au serveur (même local) et peut par exemple dans le cas d'une mise à jour gérer également le verrouillage optimiste (ce qui peut poser problème dans certains cas).
Pour cette raison, il existe sans doute des méthodes plus efficaces pour charger des données en masse dans le cas de SQL Server.
Tu peux aussi voir ce que donne un objet "Command" pour exécuter une chaîne SQL préparée plutôt que d"utiliser un recordset. Cela devrait déjà fournir un premier gain en efficacité avec peu de changement...
Patrice
--
"Via" a écrit dans le message de news:
Bonjour à tous !
J'ai écrit un petit programme en VB dans le but de comparer les rapidités d'Access et SQL Server en insertion. J'insère donc 10 000 enregistrements dans une table de chacun des deux systèmes. Je pensais que SQL Server serait au moins équivalent, si ce n'est plus rapide qu'Access... Voici mes résultats :
en local : Access : 0 secondes !!!!! SQL Server : entre 63 et 68 secondes !
en réseau, avec 4 PC faisant tourner le même programme en même temps (ils sont synchronisés : le test ne démarre qu'en présence d'un fichier bien précis sur le réseau et cette présence est testée toutes les 5 millisecondes avant que le test ne démarre) : Access : planté sur 2 PC sur les 4 avec une erreur renvoyant un verrouillage, 6 secondes sur les 2 autres PC, SQL Server : planté sur 1 PC avec une erreur incompréhensible (une méthode ~ incorrecte sur un objet ~ !!?), sur les trois autres des temps qui tournent autour de 125 !!!!
Ces chiffres sont pour moi complètement irréels, surtout le 0 secondes pour 10 000 boucles d'insertions sur Access. A l'inverse, 125 secondes sur un réseau certes chargé et sur une table utilisée par trois programmes, ça me paraît énorme.
Quelqu'un a-t-il un début d'explication à ces résultats délirants ? Merci d'avance,
Via :)
PS : Voici le code du programme (du moins de la partie qui nous intéresse) :
Select Case Test Case FIN Unload Me Exit Sub
Case ACCESS, ACCESS + SQLSERVER
Me.Caption = "Test Access en cours..."
DBEngine.SystemDB = "ServeurCOPTISTestSYS.COR"
Set wEspacedeTravail = DBEngine.CreateWorkspace("Test", "xxxx", "xxxx") DBEngine.Workspaces.Append wEspacedeTravail Set dBaseDeDonnées > DBEngine.Workspaces("Test").OpenDatabase("ServeurCOPTISTestTest.mdb", False, False)
'Test en ajout SQL = "SELECT Test FROM Test;"
TDepart = Time
Set RsDAO = dBaseDeDonnées.OpenRecordset(SQL, dbOpenDynaset, dbConsistent)
For Index = 1 To NbOccurences
RsDAO.AddNew RsDAO!Test = Index RsDAO.Update
Next Index
Text1.Text = DateDiff("s", TDepart, Time)
If Test = ACCESS + SQLSERVER Then Test = SQLSERVER GoTo Test End If
Case SQLSERVER
Me.Caption = "Test SQL Server en cours..."
Set ConnexionSQLServer = CreateObject("ADODB.Connection") ConnexionSQLServer.Open "Provider=SQLOLEDB;Data Source=Coptis;Initial Catalog=Test;User ID=xxxx;Password=xxxx"
SQL = "SELECT Test FROM Test;"
TDepart = Time
Set RsADO = New ADODB.Recordset RsADO.CursorLocation = adUseClient RsADO.Open SQL, ConnexionSQLServer, adOpenDynamic, adLockOptimistic
For Index = 1 To NbOccurences
RsADO.AddNew RsADO!Test = Index RsADO.Update
Next Index
Text2.Text = DateDiff("s", TDepart, Time)
End Select
Il est toujours difficile de comparer directement deux choses différentes
(malgré les apparences) :
- DAO écrit directement dans le fichier local
- ADO envoie des instructions SQL au serveur (même local) et peut par
exemple dans le cas d'une mise à jour gérer également le verrouillage
optimiste (ce qui peut poser problème dans certains cas).
Pour cette raison, il existe sans doute des méthodes plus efficaces pour
charger des données en masse dans le cas de SQL Server.
Tu peux aussi voir ce que donne un objet "Command" pour exécuter une chaîne
SQL préparée plutôt que d"utiliser un recordset. Cela devrait déjà fournir
un premier gain en efficacité avec peu de changement...
Patrice
--
"Via" <chew.baka@caramail.com> a écrit dans le message de
news:eb39e50b.0408250248.15deedc0@posting.google.com...
Bonjour à tous !
J'ai écrit un petit programme en VB dans le but de comparer les
rapidités d'Access et SQL Server en insertion.
J'insère donc 10 000 enregistrements dans une table de chacun des deux
systèmes. Je pensais que SQL Server serait au moins équivalent, si ce
n'est plus rapide qu'Access...
Voici mes résultats :
en local :
Access : 0 secondes !!!!!
SQL Server : entre 63 et 68 secondes !
en réseau, avec 4 PC faisant tourner le même programme en même temps
(ils sont synchronisés : le test ne démarre qu'en présence d'un
fichier bien précis sur le réseau et cette présence est testée toutes
les 5 millisecondes avant que le test ne démarre) :
Access : planté sur 2 PC sur les 4 avec une erreur renvoyant un
verrouillage, 6 secondes sur les 2 autres PC,
SQL Server : planté sur 1 PC avec une erreur incompréhensible (une
méthode ~ incorrecte sur un objet ~ !!?), sur les trois autres des
temps qui tournent autour de 125 !!!!
Ces chiffres sont pour moi complètement irréels, surtout le 0 secondes
pour 10 000 boucles d'insertions sur Access. A l'inverse, 125 secondes
sur un réseau certes chargé et sur une table utilisée par trois
programmes, ça me paraît énorme.
Quelqu'un a-t-il un début d'explication à ces résultats délirants ?
Merci d'avance,
Via :)
PS :
Voici le code du programme (du moins de la partie qui nous intéresse)
:
Select Case Test
Case FIN
Unload Me
Exit Sub
Case ACCESS, ACCESS + SQLSERVER
Me.Caption = "Test Access en cours..."
DBEngine.SystemDB = "\ServeurCOPTISTestSYS.COR"
Set wEspacedeTravail = DBEngine.CreateWorkspace("Test",
"xxxx", "xxxx")
DBEngine.Workspaces.Append wEspacedeTravail
Set dBaseDeDonnées > DBEngine.Workspaces("Test").OpenDatabase("\ServeurCOPTISTestTest.mdb",
False, False)
'Test en ajout
SQL = "SELECT Test FROM Test;"
TDepart = Time
Set RsDAO = dBaseDeDonnées.OpenRecordset(SQL, dbOpenDynaset,
dbConsistent)
For Index = 1 To NbOccurences
RsDAO.AddNew
RsDAO!Test = Index
RsDAO.Update
Next Index
Text1.Text = DateDiff("s", TDepart, Time)
If Test = ACCESS + SQLSERVER Then
Test = SQLSERVER
GoTo Test
End If
Case SQLSERVER
Me.Caption = "Test SQL Server en cours..."
Set ConnexionSQLServer = CreateObject("ADODB.Connection")
ConnexionSQLServer.Open "Provider=SQLOLEDB;Data
Source=Coptis;Initial Catalog=Test;User ID=xxxx;Password=xxxx"
SQL = "SELECT Test FROM Test;"
TDepart = Time
Set RsADO = New ADODB.Recordset
RsADO.CursorLocation = adUseClient
RsADO.Open SQL, ConnexionSQLServer, adOpenDynamic,
adLockOptimistic
Il est toujours difficile de comparer directement deux choses différentes (malgré les apparences) : - DAO écrit directement dans le fichier local - ADO envoie des instructions SQL au serveur (même local) et peut par exemple dans le cas d'une mise à jour gérer également le verrouillage optimiste (ce qui peut poser problème dans certains cas).
Pour cette raison, il existe sans doute des méthodes plus efficaces pour charger des données en masse dans le cas de SQL Server.
Tu peux aussi voir ce que donne un objet "Command" pour exécuter une chaîne SQL préparée plutôt que d"utiliser un recordset. Cela devrait déjà fournir un premier gain en efficacité avec peu de changement...
Patrice
--
"Via" a écrit dans le message de news:
Bonjour à tous !
J'ai écrit un petit programme en VB dans le but de comparer les rapidités d'Access et SQL Server en insertion. J'insère donc 10 000 enregistrements dans une table de chacun des deux systèmes. Je pensais que SQL Server serait au moins équivalent, si ce n'est plus rapide qu'Access... Voici mes résultats :
en local : Access : 0 secondes !!!!! SQL Server : entre 63 et 68 secondes !
en réseau, avec 4 PC faisant tourner le même programme en même temps (ils sont synchronisés : le test ne démarre qu'en présence d'un fichier bien précis sur le réseau et cette présence est testée toutes les 5 millisecondes avant que le test ne démarre) : Access : planté sur 2 PC sur les 4 avec une erreur renvoyant un verrouillage, 6 secondes sur les 2 autres PC, SQL Server : planté sur 1 PC avec une erreur incompréhensible (une méthode ~ incorrecte sur un objet ~ !!?), sur les trois autres des temps qui tournent autour de 125 !!!!
Ces chiffres sont pour moi complètement irréels, surtout le 0 secondes pour 10 000 boucles d'insertions sur Access. A l'inverse, 125 secondes sur un réseau certes chargé et sur une table utilisée par trois programmes, ça me paraît énorme.
Quelqu'un a-t-il un début d'explication à ces résultats délirants ? Merci d'avance,
Via :)
PS : Voici le code du programme (du moins de la partie qui nous intéresse) :
Select Case Test Case FIN Unload Me Exit Sub
Case ACCESS, ACCESS + SQLSERVER
Me.Caption = "Test Access en cours..."
DBEngine.SystemDB = "ServeurCOPTISTestSYS.COR"
Set wEspacedeTravail = DBEngine.CreateWorkspace("Test", "xxxx", "xxxx") DBEngine.Workspaces.Append wEspacedeTravail Set dBaseDeDonnées > DBEngine.Workspaces("Test").OpenDatabase("ServeurCOPTISTestTest.mdb", False, False)
'Test en ajout SQL = "SELECT Test FROM Test;"
TDepart = Time
Set RsDAO = dBaseDeDonnées.OpenRecordset(SQL, dbOpenDynaset, dbConsistent)
For Index = 1 To NbOccurences
RsDAO.AddNew RsDAO!Test = Index RsDAO.Update
Next Index
Text1.Text = DateDiff("s", TDepart, Time)
If Test = ACCESS + SQLSERVER Then Test = SQLSERVER GoTo Test End If
Case SQLSERVER
Me.Caption = "Test SQL Server en cours..."
Set ConnexionSQLServer = CreateObject("ADODB.Connection") ConnexionSQLServer.Open "Provider=SQLOLEDB;Data Source=Coptis;Initial Catalog=Test;User ID=xxxx;Password=xxxx"
SQL = "SELECT Test FROM Test;"
TDepart = Time
Set RsADO = New ADODB.Recordset RsADO.CursorLocation = adUseClient RsADO.Open SQL, ConnexionSQLServer, adOpenDynamic, adLockOptimistic
For Index = 1 To NbOccurences
RsADO.AddNew RsADO!Test = Index RsADO.Update
Next Index
Text2.Text = DateDiff("s", TDepart, Time)
End Select
Fred BROUARD
on ne peut tester ce genre de chose qu'à code strictement équivalant :
1) le script est-il en "PUR" SQL ou fait-il appel à un bout de programme "client" genre VB ?
2) quel est le niveau d'isolation transactionnel ?
3) y a t-il gestion de transaction ?
4) les données sont elles bien physiquement écrites (persistence) ? Par exemple, si je coupe brutalement le courant après les 0 secondes d'accès, que vais-je retrouver au démarrage ?
Un SGBDR bien conçu doit répondre aux règles ACID... Si je me souvient bien d'accès, il ne répond à presque rien de l'acidité requise !
Moralité comparons les choses comparables !
A +
-- Frédéric BROUARD, MVP SQL Server. Expert SQL / spécialiste Delphi, web Livre SQL - col. Référence : http://sqlpro.developpez.com/bookSQL.html Le site du SQL, pour débutants et pros : http://sqlpro.developpez.com ************************ www.datasapiens.com *************************
Via a écrit:
Bonjour à tous !
J'ai écrit un petit programme en VB dans le but de comparer les rapidités d'Access et SQL Server en insertion. J'insère donc 10 000 enregistrements dans une table de chacun des deux systèmes. Je pensais que SQL Server serait au moins équivalent, si ce n'est plus rapide qu'Access... Voici mes résultats :
en local : Access : 0 secondes !!!!! SQL Server : entre 63 et 68 secondes !
en réseau, avec 4 PC faisant tourner le même programme en même temps (ils sont synchronisés : le test ne démarre qu'en présence d'un fichier bien précis sur le réseau et cette présence est testée toutes les 5 millisecondes avant que le test ne démarre) : Access : planté sur 2 PC sur les 4 avec une erreur renvoyant un verrouillage, 6 secondes sur les 2 autres PC, SQL Server : planté sur 1 PC avec une erreur incompréhensible (une méthode ~ incorrecte sur un objet ~ !!?), sur les trois autres des temps qui tournent autour de 125 !!!!
Ces chiffres sont pour moi complètement irréels, surtout le 0 secondes pour 10 000 boucles d'insertions sur Access. A l'inverse, 125 secondes sur un réseau certes chargé et sur une table utilisée par trois programmes, ça me paraît énorme.
Quelqu'un a-t-il un début d'explication à ces résultats délirants ? Merci d'avance,
Via :)
PS : Voici le code du programme (du moins de la partie qui nous intéresse) :
Select Case Test Case FIN Unload Me Exit Sub
Case ACCESS, ACCESS + SQLSERVER
Me.Caption = "Test Access en cours..."
DBEngine.SystemDB = "ServeurCOPTISTestSYS.COR"
Set wEspacedeTravail = DBEngine.CreateWorkspace("Test", "xxxx", "xxxx") DBEngine.Workspaces.Append wEspacedeTravail Set dBaseDeDonnées > DBEngine.Workspaces("Test").OpenDatabase("ServeurCOPTISTestTest.mdb", False, False)
'Test en ajout SQL = "SELECT Test FROM Test;"
TDepart = Time
Set RsDAO = dBaseDeDonnées.OpenRecordset(SQL, dbOpenDynaset, dbConsistent)
For Index = 1 To NbOccurences
RsDAO.AddNew RsDAO!Test = Index RsDAO.Update
Next Index
Text1.Text = DateDiff("s", TDepart, Time)
If Test = ACCESS + SQLSERVER Then Test = SQLSERVER GoTo Test End If
Case SQLSERVER
Me.Caption = "Test SQL Server en cours..."
Set ConnexionSQLServer = CreateObject("ADODB.Connection") ConnexionSQLServer.Open "Provider=SQLOLEDB;Data Source=Coptis;Initial Catalog=Test;User ID=xxxx;Password=xxxx"
SQL = "SELECT Test FROM Test;"
TDepart = Time
Set RsADO = New ADODB.Recordset RsADO.CursorLocation = adUseClient RsADO.Open SQL, ConnexionSQLServer, adOpenDynamic, adLockOptimistic
For Index = 1 To NbOccurences
RsADO.AddNew RsADO!Test = Index RsADO.Update
Next Index
Text2.Text = DateDiff("s", TDepart, Time)
End Select
on ne peut tester ce genre de chose qu'à code strictement équivalant :
1) le script est-il en "PUR" SQL ou fait-il appel à un bout de programme
"client" genre VB ?
2) quel est le niveau d'isolation transactionnel ?
3) y a t-il gestion de transaction ?
4) les données sont elles bien physiquement écrites (persistence) ? Par exemple,
si je coupe brutalement le courant après les 0 secondes d'accès, que vais-je
retrouver au démarrage ?
Un SGBDR bien conçu doit répondre aux règles ACID... Si je me souvient bien
d'accès, il ne répond à presque rien de l'acidité requise !
Moralité comparons les choses comparables !
A +
--
Frédéric BROUARD, MVP SQL Server. Expert SQL / spécialiste Delphi, web
Livre SQL - col. Référence : http://sqlpro.developpez.com/bookSQL.html
Le site du SQL, pour débutants et pros : http://sqlpro.developpez.com
************************ www.datasapiens.com *************************
Via a écrit:
Bonjour à tous !
J'ai écrit un petit programme en VB dans le but de comparer les
rapidités d'Access et SQL Server en insertion.
J'insère donc 10 000 enregistrements dans une table de chacun des deux
systèmes. Je pensais que SQL Server serait au moins équivalent, si ce
n'est plus rapide qu'Access...
Voici mes résultats :
en local :
Access : 0 secondes !!!!!
SQL Server : entre 63 et 68 secondes !
en réseau, avec 4 PC faisant tourner le même programme en même temps
(ils sont synchronisés : le test ne démarre qu'en présence d'un
fichier bien précis sur le réseau et cette présence est testée toutes
les 5 millisecondes avant que le test ne démarre) :
Access : planté sur 2 PC sur les 4 avec une erreur renvoyant un
verrouillage, 6 secondes sur les 2 autres PC,
SQL Server : planté sur 1 PC avec une erreur incompréhensible (une
méthode ~ incorrecte sur un objet ~ !!?), sur les trois autres des
temps qui tournent autour de 125 !!!!
Ces chiffres sont pour moi complètement irréels, surtout le 0 secondes
pour 10 000 boucles d'insertions sur Access. A l'inverse, 125 secondes
sur un réseau certes chargé et sur une table utilisée par trois
programmes, ça me paraît énorme.
Quelqu'un a-t-il un début d'explication à ces résultats délirants ?
Merci d'avance,
Via :)
PS :
Voici le code du programme (du moins de la partie qui nous intéresse)
:
Select Case Test
Case FIN
Unload Me
Exit Sub
Case ACCESS, ACCESS + SQLSERVER
Me.Caption = "Test Access en cours..."
DBEngine.SystemDB = "\ServeurCOPTISTestSYS.COR"
Set wEspacedeTravail = DBEngine.CreateWorkspace("Test",
"xxxx", "xxxx")
DBEngine.Workspaces.Append wEspacedeTravail
Set dBaseDeDonnées > DBEngine.Workspaces("Test").OpenDatabase("\ServeurCOPTISTestTest.mdb",
False, False)
'Test en ajout
SQL = "SELECT Test FROM Test;"
TDepart = Time
Set RsDAO = dBaseDeDonnées.OpenRecordset(SQL, dbOpenDynaset,
dbConsistent)
For Index = 1 To NbOccurences
RsDAO.AddNew
RsDAO!Test = Index
RsDAO.Update
Next Index
Text1.Text = DateDiff("s", TDepart, Time)
If Test = ACCESS + SQLSERVER Then
Test = SQLSERVER
GoTo Test
End If
Case SQLSERVER
Me.Caption = "Test SQL Server en cours..."
Set ConnexionSQLServer = CreateObject("ADODB.Connection")
ConnexionSQLServer.Open "Provider=SQLOLEDB;Data
Source=Coptis;Initial Catalog=Test;User ID=xxxx;Password=xxxx"
SQL = "SELECT Test FROM Test;"
TDepart = Time
Set RsADO = New ADODB.Recordset
RsADO.CursorLocation = adUseClient
RsADO.Open SQL, ConnexionSQLServer, adOpenDynamic,
adLockOptimistic
on ne peut tester ce genre de chose qu'à code strictement équivalant :
1) le script est-il en "PUR" SQL ou fait-il appel à un bout de programme "client" genre VB ?
2) quel est le niveau d'isolation transactionnel ?
3) y a t-il gestion de transaction ?
4) les données sont elles bien physiquement écrites (persistence) ? Par exemple, si je coupe brutalement le courant après les 0 secondes d'accès, que vais-je retrouver au démarrage ?
Un SGBDR bien conçu doit répondre aux règles ACID... Si je me souvient bien d'accès, il ne répond à presque rien de l'acidité requise !
Moralité comparons les choses comparables !
A +
-- Frédéric BROUARD, MVP SQL Server. Expert SQL / spécialiste Delphi, web Livre SQL - col. Référence : http://sqlpro.developpez.com/bookSQL.html Le site du SQL, pour débutants et pros : http://sqlpro.developpez.com ************************ www.datasapiens.com *************************
Via a écrit:
Bonjour à tous !
J'ai écrit un petit programme en VB dans le but de comparer les rapidités d'Access et SQL Server en insertion. J'insère donc 10 000 enregistrements dans une table de chacun des deux systèmes. Je pensais que SQL Server serait au moins équivalent, si ce n'est plus rapide qu'Access... Voici mes résultats :
en local : Access : 0 secondes !!!!! SQL Server : entre 63 et 68 secondes !
en réseau, avec 4 PC faisant tourner le même programme en même temps (ils sont synchronisés : le test ne démarre qu'en présence d'un fichier bien précis sur le réseau et cette présence est testée toutes les 5 millisecondes avant que le test ne démarre) : Access : planté sur 2 PC sur les 4 avec une erreur renvoyant un verrouillage, 6 secondes sur les 2 autres PC, SQL Server : planté sur 1 PC avec une erreur incompréhensible (une méthode ~ incorrecte sur un objet ~ !!?), sur les trois autres des temps qui tournent autour de 125 !!!!
Ces chiffres sont pour moi complètement irréels, surtout le 0 secondes pour 10 000 boucles d'insertions sur Access. A l'inverse, 125 secondes sur un réseau certes chargé et sur une table utilisée par trois programmes, ça me paraît énorme.
Quelqu'un a-t-il un début d'explication à ces résultats délirants ? Merci d'avance,
Via :)
PS : Voici le code du programme (du moins de la partie qui nous intéresse) :
Select Case Test Case FIN Unload Me Exit Sub
Case ACCESS, ACCESS + SQLSERVER
Me.Caption = "Test Access en cours..."
DBEngine.SystemDB = "ServeurCOPTISTestSYS.COR"
Set wEspacedeTravail = DBEngine.CreateWorkspace("Test", "xxxx", "xxxx") DBEngine.Workspaces.Append wEspacedeTravail Set dBaseDeDonnées > DBEngine.Workspaces("Test").OpenDatabase("ServeurCOPTISTestTest.mdb", False, False)
'Test en ajout SQL = "SELECT Test FROM Test;"
TDepart = Time
Set RsDAO = dBaseDeDonnées.OpenRecordset(SQL, dbOpenDynaset, dbConsistent)
For Index = 1 To NbOccurences
RsDAO.AddNew RsDAO!Test = Index RsDAO.Update
Next Index
Text1.Text = DateDiff("s", TDepart, Time)
If Test = ACCESS + SQLSERVER Then Test = SQLSERVER GoTo Test End If
Case SQLSERVER
Me.Caption = "Test SQL Server en cours..."
Set ConnexionSQLServer = CreateObject("ADODB.Connection") ConnexionSQLServer.Open "Provider=SQLOLEDB;Data Source=Coptis;Initial Catalog=Test;User ID=xxxx;Password=xxxx"
SQL = "SELECT Test FROM Test;"
TDepart = Time
Set RsADO = New ADODB.Recordset RsADO.CursorLocation = adUseClient RsADO.Open SQL, ConnexionSQLServer, adOpenDynamic, adLockOptimistic
