IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Voir le flux RSS

SQLpro

[Actualité] La haute disponibilité des données, un comparatif SGBD PostGreSQL versus Microsoft SQL Server

Note : 4 votes pour une moyenne de 4,25.
par , 12/07/2024 à 13h21 (3676 Affichages)
Introduction

La haute disponibilité des données est un facteur fondamental dans l’élaboration d’une architecture de bases de données, notamment pour des données sensibles dont la disponibilité doit être continue. C’est le cas pour les applications du monde de l’hôpital, les services de secours ou encore la régulation des transports.

Cet article à pour but de comparer les solutions de deux systèmes de base de données relationnelles PostGreSQL et Microsoft SQL Server.

Nom : BANDEAU-pont-768x171.jpg
Affichages : 3665
Taille : 31,2 Ko

1 – Qu’est-ce que la haute disponibilité ?

La haute disponibilité en anglais high availability (HA) consiste à mettre en œuvre une architecture physique et logique pour redonder les données des bases de données (aspect physique) et faire en sorte que le système bascule d’une unité à l’autre (aspect logique) de la manière la plus rapide et la plus transparente au regard des besoins d’accès aux données.

2 – Qu’est-ce que le taux de disponibilité ?

C’est une mesure communément admise, calculée en pourcentage du temps où le système est indisponible par rapport au temps passé. Par exemple un système qui serait en moyenne indisponible quelques jours par an, se verrait alors attribuer un taux de disponibilité compris entre 95 % (18 jours / an) et 99 % (3 jours / an).

Aujourd’hui il est courant de viser un taux de disponibilité de l’ordre de 99,99 à 99,999 % du temps, soit une limite d’indisponibilité de 9,75 heures à 5 minutes et 30 secondes…

3 – Différence entre haute disponibilité, PRA et PCA

Un Plan de Reprise d’Activité, PRA, vise à rétablir le système d’information de l’entreprise au plus vite en cas de sinistre majeur (incendie, inondation, …).

Un Plan de Continuité des Activités PCA vise la poursuite des activités de l’entreprise face à un incident dont la gravité est circonscrite (panne machine, erreur logique, …).

Les mécanismes spécifiques introduits dans les bases de données permettent aussi bien d’assurer le PCA ou le PRA pour l’unique périmètre des bases de données, ce qui constitue, il ne faut pas l’oublier, le principal capital économique de l’entreprise.

En règle générale, les mécanismes intégrés de haute disponibilité permettent d’atteindre un PCA sans perte de données, grâce à un mode synchrone pour lequel la distance entre les données répliquées doit être relativement faible (LAN) ou bien à longue distance (WAN) via des réseaux à très haut débit extrêmement résilients.

Dans le cas du PRA une réplication asynchrone est préférable, car les machines se trouvent généralement à grande distance afin de ne pas être affecté par un sinistre de grande étendue (inondation, tremblement de terre, panne du réseau public de distribution d’électricité…), le mode asynchrone étant plus performant du point de vue du service des données, mais induisant une perte potentielle des données…

4 – Architecture technique

4.1 – Le principe

Une première instance du serveur de bases de données concentre les bases actives dites « primaires » et un mécanisme, généralement basé sur les transactions, propage aux nœuds passifs (généralement appelés esclaves), c’est-à-dire aux autres instances de serveurs de bases de données, les informations nécessaires à reconstruire les données qui ont été modifiées dans les différentes bases.

Une fonctionnalité complémentaire surveille la disponibilité des machines et en cas de problème alerte le DBA sur la défaillance ou bascule directement sur l’un des nœuds de secours.

4.2 – L’implémentation

Nous n’allons pas recopier bêtement les aides en lignes officielles et les exemples documentés sur Internet, mais en voici les liens :



5 – Différences entre les deux approches

Parlons maintenant de ce qui différencie PostGreSQL de SQL Server en matière de haute disponibilité…

5.1 – Quelles bases sont concernées ?

Dans PostGreSQL du fait qu’il n’existe qu’un seul journal de transactions, toutes les bases, sans exception, doivent être répliquées de manière physique d’un nœud à l’autre…

Au contraire dans SQL Server, chaque base de données dispose de son propre journal de transactions. On peut alors répliquer certaines bases d’un nœud A vers un nœud B et d’autres du nœud A vers un nœud C et enfin d’autres peuvent ne pas être répliquée du tout. Pour simplifier la chose, SQL Server propose de regrouper les bases de données dans des groupes de disponibilité afin que les opérations mutuelles soient conjointes aux bases d’un même groupe…

5.2 – Toutes les opérations sont-elles répliquées ?

Dans PostGreSQL la réplication est arrêtée dès qu’une commande propage l’exécution d’instruction au niveau externe (par exemple la création d’un « storage » CREATE TABLESPACE… qui induit la création d’un répertoire). Il faut donc effectuer une reprise en reconstruisant l’ensemble de la réplication, car malheureusement et toujours à cause de l’unique journal de transactions, cette reconstruction doit concerner toutes les bases, même si une seule est en cause.

Ceci ne pose aucun problème à SQL Server, à condition que le chemin dans lequel sera créé le nouvel espace de stockage existe dans les différents nœuds et le nouveau répertoire sera créé par SQL Server.

5.3 – Synchrone ?

Par défaut asynchrone dans PostGreSQL, le mécanisme permet un mode « synchrone » qui peut s’avérer désastreux en production, car il tire les performances vers le bas : le nœud actif n’envoie la transaction qu’après quelle ait été finalisée sur le « master » et le système attend la confirmation de l'unique nœud passif pour continuer, ce qui peut prendre de nombreuses minutes pour des transactions longues.

Au contraire, SQL Server agit en amont au démarrage de la transaction : les différentes transactions sont propagées en parallèle, immédiatement sur tous les nœuds, y compris le primaire. Il en résulte que, si les machines sont équilibrées, le délai n’est que celui du transit réseau dont le seuil d’alerte est de l’ordre de 15 ms, au-delà duquel SQL Server passe transitoirement en mode asynchrone pour éviter les blocages (phase de rattrapage).

5.4 – Combien de nœuds ?

Le mode synchrone de PostGreSQL est toujours limité à deux nœuds, les autres étant asynchrones, car le mécanisme de réplication est en cascade dans PostGreSQL. Par exemple à 3 nœuds (A, B, C), les deux premiers (A et B, le premier A étant actif et le second B passif) pourront être synchrones, mais pas le 3e, car la réplication se fait d’abord du nœud A vers le B puis, lorsque le nœud B a finalisé ses transactions, le nœud C les reçoit de B…

Dans SQL Server, tous les nœuds reçoivent les transactions à répliquer en parallèle, qu’ils soient en mode synchrone (dans la limite de 5 nœuds synchrone) ou asynchrone (dans la limite de 8 nœuds)…

5.5 – Quid du quorum ?

Le quorum est un algorithme dans lequel un élément interne ou externe agit en tant que témoin pour assurer une majorité de votes afin de déclencher le basculement. Par exemple avec une solution de réplication à deux nœuds, il faut un mécanise tiers pour décider quel nœud défaillant isoler et faire en sorte que le nœud résistant prenne le rôle de master si ce n’est pas le cas. L’imparité des votes devant être la règle pour décider de comment traiter le problème.

PostGreSQL ne disposant pas d’un mécanisme de quorum indépendant et au niveau système, il faut impérativement au moins 3 nœuds, c’est-à-dire trois instances de PostGreSQL pour pouvoir prétendre à un basculement automatique en mode synchrone.

En comparaison SQL Server utilise le cluster Windows et un quorum (disque ou partage de fichier) pour assurer le vote majoritaire qui décide du basculement.

5.6 – En combien de temps le système bascule ?

Bien que PostgreSQL propose un basculement automatique, celui-ci met beaucoup de temps en mode synchrone (30 secondes environ).

SQL Server en comparaison ne met que quelques millisecondes…

5.7 – Les applications se reconnectent-elles sans problème ?

PostGreSQL ne dispose pas de manière interne de la notion de « listener » qui permet à toute application de ne jamais être coupé de la base opérationnelle, quel que soit le nœud actif (le listener étant constitué dans SQL Server d’une adresse IP de redirection vers le nœud actif). Compte tenu de ceci, il faudra donc modifier les chaines de connexion des applicatifs pour que le service des données fonctionne de nouveau.
On comprend donc que, si le rétablissement de la disponibilité des bases peut être très rapide en cas de sinistre dans PostGreSQL, il n’en est pas de même pour les applicatifs, car il faudra agir manuellement… !

Dans SQL Server, chaque groupe de disponibilité rassemblant différentes base, est généralement doté d’un listener qui redirige le flux des requêtes applicatives sur le serveur actif de manière totalement transparente du point de vue des applications. Il n’y a donc aucune action à entreprendre au niveau des applications pour que celles-ci continuent d’accéder aux données de la base active en cas de basculement automatique.

5.8 – Quel volume transite sur le réseau ?

PostGreSQL ne disposant que d’un seul journal de transactions commun à toutes les bases de données, si la réplication n’a d'intérêt que pour certaines bases, le volume des communications entre nœuds est pollué par des informations inutiles qui obèrent les ressources.

En comparaison, dans SQL Server chaque base de données possède son propre journal de transactions ce qui minimise le volume du transit. De plus SQL Server pratique la compression des données des tables et index ce qui permet de diminuer encore plus le volume du transit. La compression des données étant une fonctionnalité inconnue de PostGreSQL [1].

De surcroit, les informations transmises sont elles aussi compressées avant d'être envoyées sur le réseau, en particulier si elles ne le sont déjà pas au niveau des tables et des index...

5.9 – la réplication peut-elle assurer la répartition de charge ?

Là encore une fois, le mauvais choix d’une architecture avec un seul journal de transactions pour toutes les bases de données de PostGreSQL empêche de panacher les différents nœuds en ayant une partie des bases actives sur le nœud A et l’autre sur le nœud B…
Avec PostGreSQL vous aurez donc toujours un nœud dont toutes les bases sont actives et sur l’autre toutes passives avec l’étrange impression que le serveur accueillant toutes les bases passives dispose de ressources presque toutes totalement inexploitées.

Ceci n’est pas le cas dans SQL Server, car grâce au concept de Groupe de Disponibilité, vous pouvez par exemple, enrôler 50 % de vos bases dans un groupe et le reste dans l’autre, le groupe 1 étant actif sur le nœud A et le groupe 2 actif sur le nœud B. Ceci améliore grandement les performances globales du service des données, ou encore, permet de choisir des serveurs moins « costaud » au niveau des ressources afin d’économiser sur le matériel et les licences…

5.10 – Quel est le coût des licences ?

Nous savons tous que PostGreSQL est un outil gratuit… Mais dans une certaine mesure ! En effet plusieurs entreprises proposent des versions payantes de PostGreSQL (Enterprise DB, Fujitsu, Citus…) dont le coût est loin d’être négligeable et qui deviennent vite indispensable dès que la volumétrie augmente ou que l’on a besoin de telle ou telle fonctionnalité manquante dans la version « libre » de PostGreSQL… N’oublions pas que les développeurs de PostGreSQL ont eux aussi besoin de manger et que bon nombre d’entre eux sont salariés de la société Enterprise DB qui bride sciemment les fonctionnalités de PostGreSQL pour permettre de vendre leurs produits…

Cette avancée masquée n’est pas le mode de fonctionnement de Microsoft dont les coûts sont les plus bas des SGBDR d’entreprise. L’édition Standard limitée à 24 cœurs physiques (soit 48 logiques) et 192 Go de cache (RAM : 128 table et index relationnels + 32 tables in memory + 32 index columnstore… deux fonctionnalités qui n’existent pas dans PostGreSQL) coute un peu moins de 2000 € par cœur physique auquel il faut ajouter la Software Insurance (nécessaire pour la haute disponibilité AlwaysOn, 700 € par cœurs physiques et par an) ce qui donne droit à la version future gratuitement.
Autre gratuité, celle des instances passives… Microsoft ne fait jamais payer les licences SQL Server des machines passives. Vous n’aurez donc rien à payer en licence pour le second nœud par exemple.

Ainsi, pour une machine à 16 cœurs logiques, avec un amortissement sur 5 ans, pour lequel vous serez passé par deux à trois versions de SQL Server (2017, 2019, 2022… par exemple), le budget mensuel sera donc de moins de 1000 €, soit un peu moins que le TJM de 2 journées d’un développeur…
J’oubliais le prix des licences Windows… environ 1000 € pour 16 cœurs physiques. En amortissement sur 5 ans, cela représente donc 5 € par mois…
Cher non ?

5.11 – Quels sont les outils pour faciliter la mise en œuvre et l’exploitation ?

PostGreSQL ne dispose d’aucun assistant pour la mise en place de cette réplication (il faut tout scripter) et encore moins de tableaux de bord permettant la surveillance de l’état du système, ni, bien entendu d’alertes intégrées pour être informé des dysfonctionnements… Ceci oblige à rajouter, à un outil de monitoring externe, de nombreuses requêtes tant au niveau de PostGreSQL que de l’OS afin de capturer les informations essentielles de la surveillance…
Bref un travail complexe, couteux et casse-gueule, que seules quelques entreprises comme Dalibo, Enterprise DB, … maitrisent…

En comparaisons, SQL Server dispose d’un assistant de mise en œuvre et de nombreux tableaux de bord pour la surveillance…

Nom : Haute-dispo-assistant.jpg
Affichages : 1879
Taille : 73,9 Ko
L’assistant de mise en œuvre de la haute disponibilité dans Microsoft SQL Server

Nom : Haute-dispo-tableau-de-bord.jpg
Affichages : 1855
Taille : 69,3 Ko
Un des tableaux de bord de la haute disponibilité SQL Server AlwaysOn

6 – En guide de conclusion

Certains des problèmes évoqués ci-avant au sujet de PostGreSQL peuvent être contournés en ajoutant des outils complémentaires comme Barman, repmgr, Slony I, Pgpool II, Patroni, Pacemaker…
Mais cela complexifie encore plus l’architecture et nécessite une administration complémentaire lourde, complexe et chère en exploitation et pour ce dernier point parce qu’il n’existe quasiment pas d’assistance de niveau professionnelle à contacter en cas de problème…

Bref, la soi-disant économie réalisée du fait de la gratuité des licences PostGreSQL en comparaison de l’explosion du coût d’exploitation et du hardware complémentaire montre vite que SQL Server est plus que compétitif, et il restera toujours de nombreuses lacunes à PostGreSQL par rapport aux fonctionnalités incluses dans Microsoft SQL Server en matière de haute disponibilité…

Pour information, les pompiers de Paris (BSPP) utilisent SQL Server pour la base de données des secours depuis 2005 d’abord avec le mirroring puis depuis la version 2012 avec AlwaysOn…

Pour information, le site web leboncoin avait mis en place une réplication pour ses 70 instances de PostGreSQL et avait perdu le mécanisme de haute disponibilité le 1er mars 2013 nécessitant 5 jours d’efforts pour le remettre en fonctionnement… Et Jean-Louis Bergamo (@JLB666 ça ne s’invente pas…) était fier de présenter ce désastre comme une réussite aux PGDays 2014
Il est a noter que leboncoin utilise une seule instance MS SQL Server pour leur base analytique… !



[1] la compression des données dans SQL Server concerne les données des tables et des index et s’opère a différents niveaux plus qui permettent d’économiser plus ou moins d’octets, mais n’affecte pas les lectures dont les performances sont améliorées grâce au gain de place en cache liée à cette compression. Les techniques de compression étant spécifiques aux SGBDR. Dans SQL Server ces algorithmes consistent en deux familles : l’élimination des données non significatives d’une part (compression « ROW ») et la réalisation de dictionnaires de racines d’autre part (compression de type « PAGE ») dont on trouvera, pour cette dernière, quelques les détails techniques ici : Implémentation de la compression de page.

Nom : Capture d’écran 2024-07-11 175940.png
Affichages : 1850
Taille : 37,0 Ko
Ce contenu a été publié avec comme mot(s)-clé(s) AlwaysOn, base de données, continuité, haute disponibilité, hot standby, PCA, PostGreSQL, PostGreSQL vs SQL Server, PRA, Replication, sql server.

Envoyer le billet « La haute disponibilité des données, un comparatif SGBD PostGreSQL versus Microsoft SQL Server » dans le blog Viadeo Envoyer le billet « La haute disponibilité des données, un comparatif SGBD PostGreSQL versus Microsoft SQL Server » dans le blog Twitter Envoyer le billet « La haute disponibilité des données, un comparatif SGBD PostGreSQL versus Microsoft SQL Server » dans le blog Google Envoyer le billet « La haute disponibilité des données, un comparatif SGBD PostGreSQL versus Microsoft SQL Server » dans le blog Facebook Envoyer le billet « La haute disponibilité des données, un comparatif SGBD PostGreSQL versus Microsoft SQL Server » dans le blog Digg Envoyer le billet « La haute disponibilité des données, un comparatif SGBD PostGreSQL versus Microsoft SQL Server » dans le blog Delicious Envoyer le billet « La haute disponibilité des données, un comparatif SGBD PostGreSQL versus Microsoft SQL Server » dans le blog MySpace Envoyer le billet « La haute disponibilité des données, un comparatif SGBD PostGreSQL versus Microsoft SQL Server » dans le blog Yahoo

Mis à jour 12/07/2024 à 23h19 par Malick

Catégories
Sans catégorie

Commentaires

  1. Avatar de Pierre Louis Chevalier
    • |
    • permalink
    Sujet intéressant. Dans les SGBD commerciaux en sus de SQL Server, il y a aussi une solution connue coté Oracle, mais c'est couteux.
    Du coté des solutions pour les radins c'est possible aussi de trouver des solutions MySQL en cluster, et il y a aussi des sociétés qui proposent des solutions en sus pour se faire, et MariaDB a aussi son offre la dessus.

    Sinon il y a des offres de SGBD en cloud avec ce genre d'options, mais le cout peut être parfois prohibitif, et il y a toujours la peur de se faire hacker, fautes de compétences utiles c'est parfois très mal sécurisé, voir pas du tout et la c'est le drame, exemple : Un million d'enregistrements de clients exposés via une instance Elasticsearch, y compris les détails des utilisateurs.
  2. Avatar de sphynxounet
    • |
    • permalink
    Bonjour,

    sujet intéressant en effet mais je pense que le titre n'est pas très approprié. Une fois qu'on a lu ce billet on se serait plus attendu à un titre du genre "Pourquoi Microsoft SQL Server est meilleur que PostGreSQL ?"

    Et promis je ne remets absolument pas en doute l'objectivité de l'auteur.
  3. Avatar de MagnusMoi
    • |
    • permalink
    La comparaison est bien ... mais sur quel OS ?
    Parce que les 2 sont disponibles sur Linux et Windows, et ce n'est pas le même cirque ...
    Et surtout pourquoi toutes les références à PG parlent de 2013 ou 2014, ce qui fait une décennie tout de même, quand SQL Server a le droit a des mentions des dernières versions ?

    Je pose candidement la question, parce l'entreprise dans laquelle je travaille propose un produit leader dans le segment des grand clients (plus de 2 000 employés, on a un client à plus de 40 000), possède une base de donnée de plus de 200 tables avant module complémentaires, a certaines table qui ont jusqu'à 20 enregistrements par jour par employé, nous maintenons pour pas mal de client un historique de 2 ans en base.
    Et les benchmark de 2024 que l'on fait entre SQL Server sur Windows (son supposé OS de prédilection) et PostGre SQL sur Linux montrent qu'il n'y a pas photo.
    On vend le produit à des groupe du Cac40, ils prennent le PostGre gratuit sans support extérieur et s'en tire très bien ...
    Et pour des raisons de coût et de problème récurrent sur d'autre logiciel des client, on aide à migrer sur PostGre ...

    J'ai personnellement utilisé SQL Server de 2012 à 2016 en parallèle de PG, MariaDB, SQL Lite et SQL Server CE, que ce soit pour une association d’utilité publique, ou personnellement.
    Mais aujourd'hui, pour des raisons de ratio Productivité/Coût, à moins d'être dans le cloud Azure, pourquoi j'irai utiliser SQL Server ?

    C'est toujours un article intéressant qui a le mérite de mettre en lumière un débat sur la manière de stocker ses données et y accéder.
    Mais même les articles de comparaison de langages ont des benchmark clair et tangible, qui permettent d'y voir plus clair ...

    Merci tout de même pour billet et passez une excellente journée !
    Mis à jour 18/07/2024 à 10h25 par MagnusMoi (Orthographe Grand mère)
  4. Avatar de SQLpro
    • |
    • permalink
    Citation Envoyé par MagnusMoi
    La comparaison est bien ... mais sur quel OS ?
    Effectivement cela n'est pas dit d'emblée, mais c'est bien sur Windows...

    Citation Envoyé par MagnusMoi
    ... certaines table qui ont jusqu'à 20 enregistrements par jour par employé, nous maintenons pour pas mal de client un historique de 2 ans en base.
    Donc au pire 584 millions de lignes dans la table de votre client avec ses 40 000 employés... C'est pas mal, mais c'est peanuts avec SQL Server et un index columnstore dont l'unité minimale de stockage est de 1 million de lignes...
    Bref pour lire la table séquentiellement il faut à SQL Server 584 lecture là ou PostGreSQL va faire 18 millions de lectures (=>136 Go si les lignes font en moyenne 250 octets... et PostGreSQL ne pratique pas la compression...)...
    Je doute plus que fortement que le temps de réponse soit équivalent... je miserait sur 100 fois plus lent au minimum, d'autant que PostGreSQL ne sait toujours pas paralléliser toutes les opérations d'un plan de requête...

    A +
  5. Avatar de SQLpro
    • |
    • permalink
    Citation Envoyé par MagnusMoi
    ...
    Et les benchmark de 2024 que l'on fait entre SQL Server sur Windows (son supposé OS de prédilection) et PostGre SQL sur Linux montrent qu'il n'y a pas photo.
    ...
    Pourrais tu me donner les informations sur le benchmarks de performance effectués entre SQL Server et PostGreSQL ? Parce que c'est facile d'affirmer, mais difficile de vérifier...
    Pour ma part tous les benchmarks que j'ai effectué entre les deux montrent que SQL Server bat à plate couture PostGreSQL.
    Quelques exemples de benchmarks reproductible :

    PostGreSQL vs Microsoft SQL Server (comparaison) – Partie 1 : performances des commandes pour le DBA
    Montre que les performances des commandes de :
    • chargement de fichier sont 5 fois plus lentes avec PostGreSQL qu'avec SQL Server
    • création d'index sont 14 fois plus lente avec PostGreSQL qu'avec SQL Server
    • maintenance d'index sont 32 fois plus lents avec PostGreSQL qu'avec SQL Server
    • maintenance des statistiques sont 10 fois plus lentes avec PostGreSQL qu'avec SQL Server



    PostGreSQL vs Microsoft SQL Server (comparaison) – Partie 2 : performances des requêtes avec COUNT
    Montre que les performances des requêtes d'agrégation sont :
    • pour le COUNT DISTINCT : SQL Server est entre 61 et 561 fois plus rapide que PostGreSQL dans toutes les situations, et avec l’indexation verticale (columnstore index) SQL Server est 1 533 fois plus rapide que PostGreSQL
    • pour le simple COUNT PostGreSQL se révèle entre 4 et 429 fois plus lent que SQL Server

    Globalement PostGreSQL est 114 fois plus lent que SQL Server sur le COUNT...

    À titre d'exemple complémentaire, voici les performances entre PostGreSQL et SQL Server pour l'INSERT de 4 000 000 (4 millions de lignes) dans une table :

    Script pour MS SQL Server :
    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
    CREATE DATABASE DB_TEST;
    GO
    
    USE DB_TEST;
    GO
    
    CREATE TABLE T (K INT IDENTITY PRIMARY KEY,
    	           DATA   VARCHAR(32));
    
    INSERT INTO T (DATA) VALUES 
    ('Tribui autem sed ego memineram m'),
    ('hi in mihi credo si pueris pueri'),
    ('et nec sed tantum videris credo '),
    ('aulum nec quod ut in ut Quo aut '),
    ('ec de nemo amice fuit autem trib'),
    ('i autem Catone pueris aut nec mo'),
    ('tem omittam videris modo fuit se'),
    (',t pueris tribui recte non quide'),
    ('Quo Cato si recte mihi Paulum hi'),
    ('non iudicas pueris mortem Fanni '),
    ('lle et quantum facis quantum Fan'),
    ('i spectato ut credo recte recte '),
    ('lle filii recte mihi nec omittam'),
    ('Cato modo Catone tulit sed fuit '),
    ('uod quidem quod ille sed in aut '),
    ('ostulo nec credo mihi perfecto u');
    
    SET STATISTICS TIME ON;
    
    INSERT INTO T (DATA)
    SELECT SUBSTRING(CONCAT(SUBSTRING(T1.DATA, 1, (ABS(CHECKSUM(NEWID()) % 32))), 
    	                    REVERSE(SUBSTRING(REVERSE(T2.DATA), 1, (ABS(CHECKSUM(NEWID()) % 32))))), 1, 32)  
    FROM   T AS T1
           CROSS JOIN T AS T2
    ORDER BY CHECKSUM(NEWID()) OFFSET 0 ROW FETCH NEXT 4000000 ROWS ONLY;
    --> Temps UC = 0*ms, temps écoulé = 2*ms.
    
    INSERT INTO T (DATA)
    SELECT SUBSTRING(CONCAT(SUBSTRING(T1.DATA, 1, (ABS(CHECKSUM(NEWID()) % 32))), 
    	                    REVERSE(SUBSTRING(REVERSE(T2.DATA), 1, (ABS(CHECKSUM(NEWID()) % 32))))), 1, 32)  
    FROM   T AS T1
           CROSS JOIN T AS T2
    ORDER BY CHECKSUM(NEWID()) OFFSET 0 ROW FETCH NEXT 4000000 ROWS ONLY;
    --> Temps UC = 265*ms, temps écoulé = 289*ms
    Test d'insertion de 4 millions de lignes :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    INSERT INTO T (DATA)
    SELECT SUBSTRING(CONCAT(SUBSTRING(T1.DATA, 1, (ABS(CHECKSUM(NEWID()) % 32))), 
    	                    REVERSE(SUBSTRING(REVERSE(T2.DATA), 1, (ABS(CHECKSUM(NEWID()) % 32))))), 1, 32)  
    FROM   T AS T1
           CROSS JOIN T AS T2
    ORDER BY CHECKSUM(NEWID()) OFFSET 0 ROW FETCH NEXT 4000000 ROWS ONLY;
    Le temps de cette commande a été de :
    Au niveau UC = 694 5947
    Au niveau chrono = 484 355*ms.
    NOTA : SQL Server a utilisé 16 cœurs pour paralléliser cette requête (sur une machine comptant 72 coeurs et pour une installation "out of the box")

    Script équivalent pour PostGreSQL :

    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
    ALTER SYSTEM SET
     shared_buffers = '128GB';
    ALTER SYSTEM SET
     effective_cache_size = '384GB';
    ALTER SYSTEM SET
     maintenance_work_mem = '2047MB';
    ALTER SYSTEM SET
     checkpoint_completion_target = '0.9';
    ALTER SYSTEM SET
     wal_buffers = '16MB';
    ALTER SYSTEM SET
     default_statistics_target = '100';
    ALTER SYSTEM SET
     random_page_cost = '1.1';
    ALTER SYSTEM SET
     work_mem = '338933kB';
    ALTER SYSTEM SET
     huge_pages = 'try';
    ALTER SYSTEM SET
     min_wal_size = '2GB';
    ALTER SYSTEM SET
     max_wal_size = '8GB';
    ALTER SYSTEM SET
     max_worker_processes = '72';
    ALTER SYSTEM SET
     max_parallel_workers_per_gather = '4';
    ALTER SYSTEM SET
     max_parallel_workers = '72';
    ALTER SYSTEM SET
     max_parallel_maintenance_workers = '4';
    SELECT pg_reload_conf();
    
    CREATE TABLE T (K INT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
    	           DATA   VARCHAR(32))
    
    INSERT INTO T (DATA) VALUES 
    ('Tribui autem sed ego memineram m'),
    ('hi in mihi credo si pueris pueri'),
    ('et nec sed tantum videris credo '),
    ('aulum nec quod ut in ut Quo aut '),
    ('ec de nemo amice fuit autem trib'),
    ('i autem Catone pueris aut nec mo'),
    ('tem omittam videris modo fuit se'),
    (',t pueris tribui recte non quide'),
    ('Quo Cato si recte mihi Paulum hi'),
    ('non iudicas pueris mortem Fanni '),
    ('lle et quantum facis quantum Fan'),
    ('i spectato ut credo recte recte '),
    ('lle filii recte mihi nec omittam'),
    ('Cato modo Catone tulit sed fuit '),
    ('uod quidem quod ille sed in aut '),
    ('ostulo nec credo mihi perfecto u');
    
    INSERT INTO T (DATA)
    SELECT SUBSTRING(CONCAT(SUBSTRING(T1.DATA, 1, CAST((RANDOM() * 32) AS INT)), 
    	                    REVERSE(SUBSTRING(REVERSE(T2.DATA), 1, CAST((RANDOM() * 32) AS INT)))), 1, 32)  
    FROM   T AS T1
           CROSS JOIN T AS T2
    ORDER BY RANDOM() OFFSET 0 ROW FETCH NEXT 4000000 ROWS ONLY;
    --> Query returned successfully in 87 msec
    
    INSERT INTO T (DATA)
    SELECT SUBSTRING(CONCAT(SUBSTRING(T1.DATA, 1, CAST((RANDOM() * 32) AS INT)), 
    	                    REVERSE(SUBSTRING(REVERSE(T2.DATA), 1, CAST((RANDOM() * 32) AS INT)))), 1, 32)  
    FROM   T AS T1
           CROSS JOIN T AS T2
    ORDER BY RANDOM() OFFSET 0 ROW FETCH NEXT 4000000 ROWS ONLY;
    --> Query returned successfully in 412 msec.
    Pour PostGreSQL nous avons fait confiance à PGTune pour paramétrer l'instance (appelé curieusement "cluster" dans le vocabulaire PostGreSQL...)

    Test d'insertion de 4 millions de lignes :
    Notez qu'il y a moins de fonctions dans le code de la requête PostGreSQL générant les 4 millions de lignes que dans celle de SQL Server...

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    INSERT INTO T (DATA)
    SELECT SUBSTRING(CONCAT(SUBSTRING(T1.DATA, 1, CAST((RANDOM() * 32) AS INT)), 
    	                    REVERSE(SUBSTRING(REVERSE(T2.DATA), 1, CAST((RANDOM() * 32) AS INT)))), 1, 32)  
    FROM   T AS T1
           CROSS JOIN T AS T2
    ORDER BY RANDOM() OFFSET 0 ROW FETCH NEXT 4000000 ROWS ONLY;
    Le temps de traitement a été de 3 h 7 m ! Soit 11*220*000 ms

    Autrement dit dans ce cas de figure PostGreSQL a mis 23 fois plus de temps que SQL Server...

    Bref, le jour ou on me présentera des benchmarks reproductibles montrant que PostGreSQL est au moins équivalent de SQL Server j'en ferais la promotion...

    Pour information il existe un organisme recensant les bencmarks officiels (TPC.org)dans lequel on n'a jamais vu figurer PostGreSQL tellement les performance comme le TCO de PostGreSQL est lamentable...

    Bref si l'on est un tantinet rationnel et surtout écologique on devrait éliminer PostGreSQL pour diminuer à la fois les coûts globaux licence comprise, mais aussi pour consommer moins d'énergie pour faire la même chose !
    A +
    Mis à jour 19/07/2024 à 09h13 par SQLpro