Geekly articles weekly

Interaction de R avec des bases de données sur l'exemple de Microsoft SQL Server et d'autres SGBD

Depuis la part du lion des informations commerciales sont stockées dans des bases de données. Quel que soit le langage de programmation que vous écrivez, vous devez effectuer diverses actions avec eux.


Dans cet article, je parlerai de deux interfaces pour travailler avec des bases de données dans R. La plupart des exemples montrent qu'ils fonctionnent avec Microsoft SQL Server, cependant, tous les exemples de code fonctionneront avec d'autres bases de données, telles que: MySQL, PostgreSQL, SQLite, ClickHouse , Google BigQuery, etc.


image


Table des matières



Logiciel requis


Afin de répéter tous les exemples d'utilisation du SGBD décrits dans l'article, vous aurez besoin des logiciels gratuits suivants répertoriés ci-dessous:


  1. Langue R ;
  2. Environnement de développement RStudio ;
  3. Système de gestion de base de données, au choix:
    3.1. Microsoft SQL Server
    3.2. MySQL
    3.3. PostgreSQL

Package DBI


Le package DBI est le moyen le plus populaire et le plus pratique pour interagir avec les bases de données dans R.


DBI vous fournit un ensemble de fonctions avec lesquelles vous pouvez gérer des bases de données. Mais pour vous connecter aux bases de données, vous devez installer des packages supplémentaires qui sont des pilotes pour divers systèmes de gestion de base de données (SGBD).


Liste des fonctions DBI de base


  • dbConnect - connexion à la base de données;
  • dbWriteTable - écrit une table dans la base de données;
  • dbReadTable - chargement d'une table à partir d'une base de données;
  • dbGetQuery - chargement du résultat de l'exécution de la requête;
  • dbSendQuery - envoi d'une requête à la base de données;
  • dbFetch - extrait des éléments d'un jeu de résultats;
  • dbExecute - exécution de demandes de mise à jour / suppression / insertion de données dans des tables;
  • dbGetInfo - demande des informations sur le résultat de la demande ou de la connexion;
  • dbListFields - demande d'une liste de champs de table;
  • dbListTables - interroge une liste de tables de base de données;
  • dbExistsTable - vérifie la présence d'une table dans la base de données;
  • dbRemoveTable - supprime une table de la base de données;
  • dbDisconnect - se déconnecte de la base de données.

Connectivité à la base de données


Pour interagir avec des bases de données, vous devez d'abord vous y connecter. Selon le SGBD avec lequel vous prévoyez de travailler, vous aurez besoin d'un package supplémentaire, voici une liste des plus fréquemment utilisés.


  • odbc - Pilote pour la connexion via l'interface ODBC;
  • RSQLite - Pilote pour SQLite;
  • RMySQL / RMariaDB - Pilote pour MySQL et MariaDB;
  • RPostgreSQL - Pilote pour PosrtgreSQL;
  • bigrquery - Pilote pour Google BigQuery;
  • RClickhouse / clickhouse - Pilote pour ClickHouse;
  • RMSSQL - Le pilote pour Microsoft SQL Server (MS SQL), au moment de la rédaction, n'est présent que sur GitHub .

Le package DBI est fourni avec le package R de base, mais les packages qui sont des pilotes de base de données doivent être installés à l'aide de la commande install.packages(" ") .


Pour installer des packages à partir de GitHub, vous aurez également besoin d'un package supplémentaire - devtools . Par exemple, le package RMSSQL n'est pas actuellement publié dans le référentiel de packages R principal, utilisez le code suivant pour l'installer:


 install.packages("devtools") devtools::install_github("bescoto/RMSSQL")

Un exemple de connexion à Microsoft SQL Server à l'aide du package odbc


Avant d'utiliser un package dans une session R, il doit d'abord être connecté à l'aide de la fonction de library(" ") .


Ce n'est pas sans raison que j'ai choisi Microsoft SQL Server comme SGBD principal, qui fournira la plupart des exemples de cet article. Le fait est qu'il s'agit d'une base de données assez populaire, mais en même temps, elle n'a toujours pas de pilote de connexion depuis R publié sur CRAN.


Mais heureusement, SQL Server, comme presque toutes les autres bases de données, dispose d'une interface ODBC (English Open Database Connectivity) pour la connexion. Il existe un certain nombre de packages pour la connexion au SGBD via l'interface ODBC dans R. Tout d'abord, nous examinerons la connexion via le package odbc .


Connexion facile à la base de données via l'interface ODBC
 #   odbc install.packages("odbc") #   library(odbc) #   MS SQL con <- dbConnect(drv = odbc(), Driver = "SQL Server", Server = "localhost", Database = "mybase", UID = "my_username", PWD = "my_password", Port = 1433)

Dans la fonction dbConnect() , vous devez passer la fonction, qui est le pilote de connexion au SGBD ( odbc() ), comme premier argument de drv . Ces fonctions sont généralement appelées les mêmes que le SGBD et sont fournies avec des packages qui sont des pilotes pour DBI .


Ensuite, vous devez répertorier les paramètres de connexion. Pour vous connecter à MS SQL via ODBC, vous devez spécifier les paramètres suivants:


  • Driver - Nom du pilote ODBC;
  • Serveur - adresse IP du serveur SQL;
  • Base de données - Le nom de la base de données à laquelle se connecter;
  • UID - Nom d'utilisateur de la base de données;
  • PWD - Mot de passe;
  • Port - Le port auquel se connecter, avec SQL Server, le port par défaut est 1433.

Un pilote ODBC pour la connexion à Microsoft SQL Server est inclus avec Windows, mais il peut avoir un nom différent. Vous pouvez afficher la liste des pilotes installés dans l'administrateur de source de données ODBC. Vous pouvez démarrer l'administrateur de source de données dans Windows 10 de la manière suivante:


  • Version 32 bits: %systemdrive%\Windows\SysWoW64\Odbcad32.exe
  • Version 64 bits: %systemdrive%\Windows\System32\Odbcad32.exe


Vous pouvez également obtenir une liste de tous les pilotes installés sur votre PC en utilisant la fonction odbcListDrivers() .


  name attribute value <chr> <chr> <chr> 1 SQL Server APILevel 2 2 SQL Server ConnectFunctions YYY 3 SQL Server CPTimeout 60 4 SQL Server DriverODBCVer 03.50 5 SQL Server FileUsage 0 6 SQL Server SQLLevel 1 7 SQL Server UsageCount 1 8 MySQL ODBC 5.3 ANSI Driver UsageCount 1 9 MySQL ODBC 5.3 Unicode Driver UsageCount 1 10 Simba ODBC Driver for Google BigQuery Description Simba ODBC Driver for Google BigQuery2.0 # ... with 50 more rows

Vous pouvez télécharger des pilotes ODBC pour d'autres SGBD aux liens suivants:



Pour différents SGBD, le nom des paramètres de connexion peut être différent, par exemple:


  • PostgreSQL / MySQL / MariaDB - utilisateur, mot de passe, hôte, port, dbname;
  • GoogleBigQuery - projet, jeu de données;
  • ClickHouse - utilisateur, mot de passe, db, port, hôte;

À l'aide de l'administrateur de source de données ODBC, vous pouvez exécuter l'Assistant pour créer une source de données ODBC. Pour ce faire, ouvrez simplement l'administrateur, allez dans l'onglet "DSN personnalisé" et cliquez sur le bouton "Ajouter ...".



Lorsque vous créez une source de données à l'aide d'un administrateur, vous lui donnez un nom, DSN (Data Source Name).



Dans l'exemple ci-dessus, nous avons créé une source de données avec le DSN "my_test_source". Nous pouvons maintenant utiliser cette source pour se connecter à Microsoft SQL Server et ne pas spécifier d'autres paramètres de connexion dans le code.


Connexion à la base de données via l'interface ODBC à l'aide de DSN
 #   DSN con <- dbConnect(odbc(), DSN = "my_test_source", UID = "my_username", PWD = "my_password")

Vous pouvez voir les noms de toutes les sources de données ODBC créées sur votre PC à l'aide de la fonction odbcListDataSources() .


  name description <chr> <chr> 1 BQ Simba ODBC Driver for Google BigQuery 2 BQ_main Simba ODBC Driver for Google BigQuery 3 BQ ODBC Simba ODBC Driver for Google BigQuery 4 OLX Simba ODBC Driver for Google BigQuery 5 Multicharts Simba ODBC Driver for Google BigQuery 6 PostgreSQL35W PostgreSQL Unicode(x64) 7 hillel_bq Simba ODBC Driver for Google BigQuery 8 blog_bq Simba ODBC Driver for Google BigQuery 9 MyClientMSSQL SQL Server 10 local_mssql SQL Server 11 MSSQL_localhost SQL Server 12 my_test_source SQL Server 13 Google BigQuery Simba ODBC Driver for Google BigQuery

Un exemple de connexion à Microsoft SQL Server à l'aide du package RMSSQL


RMSSQL pas publié sur CRAN, vous pouvez donc l'installer à partir de GitHub à l'aide du package devtools .


 install.packages("devtools") devtools::install_github("bescoto/RMSSQL")

Exemple de connexion à l'aide du pilote DBI RMSSQL
 #    library(RJDBC) library(RMSSQL) library(DBI) #  RMSSQL con <- dbConnect(MSSQLServer(), host = 'localhost', user = 'my_username', password = 'my_password', dbname = "mybase")

Dans la plupart des cas, en utilisant le package DBI pour travailler avec des bases de données, vous vous connecterez de cette manière. C'est-à-dire installez l'un des packages de pilotes requis, en passant la fonction dbConnect comme valeur de l'argument drv , la fonction de pilote pour vous connecter au SGBD dont vous avez besoin.


Un exemple de connexion à MySQL, PostgreSQL, SQLite et BigQuery
 #   MySQL library(RMySQL) con <- dbConnect(MySQL(), host = 'localhost', user = 'my_username', password = 'my_password', dbname = "mybase", host = "localhost") #   PostrgeSQL library(RPostgreSQL) con <- dbConnect(PostgreSQL(), host = 'localhost', user = 'my_username', password = 'my_password', dbname = "mybase", host = "localhost") #   PostrgeSQL library(RPostgreSQL) con <- dbConnect(PostgreSQL(), host = 'localhost', user = 'my_username', password = 'my_password', dbname = "mybase", host = "localhost") #   SQLite library(RSQLite) # connection or create base con <- dbConnect(drv = SQLite(), "localhost.db") #   Google BigQuery library(bigrquery) con <- dbConnect(drv = bigquery(), project = "my_proj_id", dataset = "dataset_name")

Comment masquer les mots de passe de base de données dans les scripts R


Ci-dessus, j'ai donné quelques exemples qui peuvent être utilisés pour se connecter à n'importe quelle base de données, mais il y a un inconvénient, sous cette forme, tous les accès à la base de données, y compris les mots de passe, sont stockés sous forme de texte dans les scripts eux-mêmes.


Si tous vos scripts sont déployés et exécutés exclusivement localement sur votre PC et qu'ils sont protégés par mot de passe en même temps, il n'y aura probablement aucun problème. Mais si vous travaillez avec quelqu'un sur le même serveur, le stockage des mots de passe des bases de données dans le texte de vos scripts n'est pas la meilleure solution.


Chaque système d'exploitation dispose d'un utilitaire de gestion des informations d'identification. Par exemple, sous Windows, il s'agit du gestionnaire d'informations d'identification. Vous pouvez ajouter le mot de passe que vous utilisez pour vous connecter à la base de données via le package de keyring - keyring dans ce référentiel. Le package est multiplateforme et l'exemple ci-dessus fonctionnera dans n'importe quel système d'exploitation, au moins sous Windows, MacOS et Linux.


 # install.packages("keyring") #   library(keyring) library(RMSSQL) #   key_set_with_value(service = "mssql", username = "my_username", password = "my_password") #   RMSSQL con <- dbConnect(MSSQLServer(), host = 'localhost', user = 'my_username', password = key_get("mssql", "my_username"), dbname = "mybase")

C'est-à-dire en utilisant la fonction key_set_with_value() , vous ajoutez un mot de passe au stockage des informations d'identification et en utilisant key_get() demandez, et seul l'utilisateur qui l'a ajouté au magasin peut demander un mot de passe. À l'aide de keyring vous pouvez stocker des mots de passe non seulement à partir de bases de données, mais également à partir de n'importe quel service, ainsi que des jetons d'autorisation lorsque vous travaillez avec l'API.


Création de tables et écriture dans la base de données


L'écriture dans la base de données est effectuée par la fonction dbWriteTable() .


Arguments de la fonction dbWriteTable() :


Les arguments requis sont en gras, l'italique est facultatif


  • conn - Objet de connexion au SGBD créé à l'aide de la fonction dbConnect ;
  • nom - le nom de la table du SGBD dans laquelle les données seront écrites;
  • valeur - une table (un objet de la classe data.frame / data.table / tibble_frame) dans R, dont les données seront écrites dans le SGBD;
  • row.names - Ajoute une colonne row_names avec des numéros de ligne à la table, par défaut FALSE .
  • écraser - Écraser la table si la table portant le nom spécifié dans l'argument nom est déjà présente dans le SGBD; la valeur par défaut est FAUX ;
  • append - Ajoute des données si une table avec le nom spécifié dans l'argument name est déjà présente dans le SGBD; la valeur par défaut est FALSE ;
  • field.types - Accepte un vecteur nommé et définit le type de données dans chaque champ lors de l'écriture dans le SGBD, par défaut NULL ;
  • temporaire - Vous permet de créer des tables temporaires dans le SGBD, qui seront disponibles jusqu'à ce que la connexion avec la base de données soit déconnectée; la valeur par défaut est FALSE .

Un exemple d'écriture de données dans un SGBD via DBI
 #   library(odbc) #     DSN con <- dbConnect(odbc(), DSN = "my_test_source", UID = "my_username", PWD = "my_password") #     iris,         R  iris dbWriteTable(conn = con, name = "iris", value = iris) #     dbDisconnect(con)

Pour afficher les tables dans la base de données, utilisez la fonction dbListTables() , pour supprimer les tables dbRemoveTable()


Un exemple d'interrogation d'une liste de tables et de suppression d'une table d'un SGBD
 #   library(odbc) #    con <- dbConnect(odbc(), DSN = "my_test_source", UID = "my_username", PWD = "my_password") #    dbListTables(con) #   iris dbRemoveTable(con, "iris") #     dbDisconnect(con)

Lecture des données d'un SGBD


À l'aide de DBI vous pouvez interroger des tables entières ou le résultat de l'exécution de votre requête SQL. Les fonctions dbReadTable() et dbGetQuery() sont utilisées pour effectuer ces opérations.


Un exemple d'interrogation d'une table d'iris à partir d'un SGBD
 #   library(odbc) #    con <- dbConnect(odbc(), DSN = "my_test_source", UID = "my_username", PWD = "my_password") #   iris   iris dbiris <- dbReadTable(con, "iris") #     dbDisconnect(con)

Un exemple de chargement du résultat de l'exécution de SQL à partir d'un SGBD
 #   library(odbc) #    con <- dbConnect(odbc(), DSN = "my_test_source", UID = "my_username", PWD = "my_password") #     setosa <- dbGetQuery(con, "SELECT * FROM iris WHERE Species = 'setosa'") #     dbDisconnect(con)

Manipulation de données dans un SGBD (DML)


La fonction dbGetQuery() ci dbGetQuery() dessus est utilisée exclusivement pour interroger des échantillons de données (SELECT).


Pour les opérations de manipulation de données, telles que UPDATE, INSERT, DELETE, la fonction dbExecute() existe dans DBI .


Exemple de code pour manipuler des données dans un SGBD
 #   library(odbc) #    con <- dbConnect(odbc(), DSN = "my_test_source", UID = "my_username", PWD = "my_password") #   (INSERT) dbExecute(con, "INSERT INTO iris (row_names, [Sepal.Length], [Sepal.Width], [Petal.Length], [Petal.Width], [Species]) VALUES (51, 5.0, 3.3, 1.7, 0.3, 'new_values')") #   (UPDATE) dbExecute(con, "UPDATE iris SET [Species] = 'old_value' WHERE row_names = 51") #     (DELETE) dbExecute(con, "DELETE FROM iris WHERE row_names = 51") #     dbDisconnect(con)

Transactions dans le SGBD


Une transaction est une opération séquentielle de lecture et d'écriture. La fin d'une transaction peut être soit l'enregistrement des modifications (validation, validation) ou l'annulation des modifications (restauration, restauration). En ce qui concerne la base de données, une transaction est une série de requêtes, qui sont traitées comme une requête unique.

Citation de l'article "Les transactions et les mécanismes de leur contrôle"


Une transaction encapsule plusieurs instructions SQL dans une unité élémentaire. Dans DBI début d'une transaction est initié avec dbBegin() puis confirmé avec dbCommit() ou annulé avec dbRollback() . Dans tous les cas, le SGBD garantit que: tout ou partie des déclarations seront appliquées aux données.


Par exemple, pendant la transaction, ajoutons 51 lignes à la table iris, puis changez la valeur Sepal.Width en 5 lignes et supprimons 43 lignes de la table.


Exemple de code de transaction
 #   library(odbc) #    con <- dbConnect(odbc(), DSN = "my_test_source", UID = "my_username", PWD = "my_password") #      dbGetQuery(con, "SELECT * FROM iris WHERE row_names IN (5, 43, 51)") # row_names Sepal.Length Sepal.Width Petal.Length Petal.Width Species # 1 5 5.0 3.6 1.4 0.2 setosa # 2 43 4.4 3.2 1.3 0.2 setosa # 3 51 7.0 3.2 4.7 1.4 versicolor #    dbBegin(con) #   dbExecute(con, "INSERT INTO iris (row_names, [Sepal.Length], [Sepal.Width], [Petal.Length], [Petal.Width], [Species]) VALUES (51, 5.0, 3.3, 1.7, 0.3, 'new_values')") #   dbExecute(con, "UPDATE iris SET [Sepal.Width] = 8 WHERE row_names = 5") #   43 dbExecute(con, "DELETE FROM iris WHERE row_names = 43") #   dbCommit(con) #      dbGetQuery(con, "SELECT * FROM iris WHERE row_names IN (5, 43, 51)") # row_names Sepal.Length Sepal.Width Petal.Length Petal.Width Species # 1 5 5 8.0 1.4 0.2 setosa # 2 51 7 3.2 4.7 1.4 versicolor # 3 51 5 3.3 1.7 0.3 new_values

Exemple de code d'annulation de transaction
 #   library(odbc) #    con <- dbConnect(odbc(), DSN = "my_test_source", UID = "my_username", PWD = "my_password") #      dbGetQuery(con, "SELECT * FROM iris WHERE row_names IN (5, 43, 51)") # row_names Sepal.Length Sepal.Width Petal.Length Petal.Width Species # 1 5 5.0 3.6 1.4 0.2 setosa # 2 43 4.4 3.2 1.3 0.2 setosa # 3 51 7.0 3.2 4.7 1.4 versicolor #    dbBegin(con) #   dbExecute(con, "INSERT INTO iris (row_names, [Sepal.Length], [Sepal.Width], [Petal.Length], [Petal.Width], [Species]) VALUES (51, 5.0, 3.3, 1.7, 0.3, 'new_values')") #   dbExecute(con, "UPDATE iris SET [Sepal.Width] = 8 WHERE row_names = 5") #   43 dbExecute(con, "DELETE FROM iris WHERE row_names = 43") #   dbRollback(con) #      dbGetQuery(con, "SELECT * FROM iris WHERE row_names IN (5, 43, 51)") # row_names Sepal.Length Sepal.Width Petal.Length Petal.Width Species # 1 5 5.0 3.6 1.4 0.2 setosa # 2 43 4.4 3.2 1.3 0.2 setosa # 3 51 7.0 3.2 4.7 1.4 versicolor

Forfait RODBC


Le package RODBC fournit une interface autonome pour la connexion et l'utilisation d'un SGBD via une interface ODBC.


RODBC pas compatible DBI , c'est-à-dire vous ne pouvez pas utiliser l'objet de connexion créé à l'aide de RODBC dans les fonctions fournies par le package DBI .


Fonctionnalités clés du package RODBC


  • odbcConnect - Connexion au SGBD via DSN;
  • odbcDriverConnect - Connexion à la base de données via la chaîne de connexion;
  • sqlQuery - Envoi d'une requête au SGBD et obtention du résultat de son exécution. Prend en charge les requêtes de tout type: SELECT, UPDATE, INSERT, DELETE.
  • sqlFetch - Récupère la table entière du SGBD;
  • sqlTables - Récupère une liste des tables dans la base de données.
  • sqlSave - Créez une nouvelle table dans la base de données ou ajoutez de nouvelles données à une table existante;
  • sqlUpdate - Mise à jour des données dans une table qui existe déjà dans le SGBD;
  • sqlDrop - Supprimer une table dans un SGBD;
  • odbcClose - odbcClose fin à une connexion à un SGBD.

Un exemple de collaboration avec RODBC


De mon point de vue, RODBC moins fonctionnel que DBI , mais il a toutes les fonctions nécessaires pour travailler avec un SGBD.


Un exemple d'interaction avec un SGBD via RODBC
 #   library(RODBC) #   con_string <- odbcDriverConnect(connection = "Driver=SQL Server;Server=localhost;Database=mybase;UID=my_username;PWD=my_password;Port=1433") #   DSN con_dsn <- odbcConnect(dsn = "my_test_source", uid = "my_username", pwd = "my_password") #     sqlSave(con_dsn, dat = iris, tablename = "iris") #     iris sqlSave(con_dsn, dat = iris, tablename = "iris", append = TRUE) #   4  sqlFetch(con_dsn, "iris", rownames = FALSE, max = 4) #      R iris[1, 5] <- "virginica" #     sqlUpdate(con_dsn, dat = iris, tablename = "iris") #   4     sqlFetch(con_dsn, "iris", rownames = FALSE, max = 4) #   sqlDrop(con_dsn, sqtable = "iris") #     odbcCloseAll()

Transactionnel


Par défaut, la transactionnalité dans RODBC désactivée. La gestion des transactions est assurée par deux fonctions.


  • odbcSetAutoCommit - Bascule entre les modes de fonctionnement SGBD normal et transactionnel;
  • odbcEndTran - Confirmer ou annuler une transaction.

L'activation et la désactivation du mode de transaction est effectuée par la fonction odbcSetAutoCommit à l'aide de l'argument autoCommit .


Exemple de travail en mode transactionnel dans RODBC
 #   library(RODBC) #   DSN con_dsn <- odbcConnect(dsn = "my_test_source", uid = "my_username", pwd = "my_password") #     sqlSave(con_dsn, dat = iris, tablename = "iris") #    odbcSetAutoCommit(con_dsn, autoCommit = FALSE) #   4  sqlFetch(con_dsn, "iris", rownames = FALSE, max = 4) # rownames SepalLength SepalWidth PetalLength PetalWidth Species # 1 1 5.1 3.5 1.4 0.2 setosa # 2 2 4.9 3.0 1.4 0.2 setosa # 3 3 4.7 3.2 1.3 0.2 setosa # 4 4 4.6 3.1 1.5 0.2 setosa #      R iris[1, 5] <- "virginica" #     sqlUpdate(con_dsn, dat = iris, tablename = "iris") #   4  sqlFetch(con_dsn, "iris", rownames = FALSE, max = 4) # rownames SepalLength SepalWidth PetalLength PetalWidth Species # 1 1 5.1 3.5 1.4 0.2 virginica # 2 2 4.9 3.0 1.4 0.2 setosa # 3 3 4.7 3.2 1.3 0.2 setosa # 4 4 4.6 3.1 1.5 0.2 setosa #   odbcEndTran(con_dsn, commit = FALSE) #   4  sqlFetch(con_dsn, "iris", rownames = FALSE, max = 4) # rownames SepalLength SepalWidth PetalLength PetalWidth Species # 1 1 5.1 3.5 1.4 0.2 setosa # 2 2 4.9 3.0 1.4 0.2 setosa # 3 3 4.7 3.2 1.3 0.2 setosa # 4 4 4.6 3.1 1.5 0.2 setosa #     sqlUpdate(con_dsn, dat = iris, tablename = "iris") #   odbcEndTran(con_dsn, commit = TRUE) #   4     sqlFetch(con_dsn, "iris", rownames = FALSE, max = 4) # rownames SepalLength SepalWidth PetalLength PetalWidth Species # 1 1 5.1 3.5 1.4 0.2 virginica # 2 2 4.9 3.0 1.4 0.2 setosa # 3 3 4.7 3.2 1.3 0.2 setosa # 4 4 4.6 3.1 1.5 0.2 setosa #     odbcClose(con_dsn)

Conclusion


Les deux méthodes de travail avec des bases de données dans les langages R, DBI et RODBC décrites dans l'article sont assez universelles et fonctionneront avec presque tous les SGBD.


La seule différence de fonctionnement entre différents SGBD est le processus de connexion. Pour les SGBD les plus courants, il existe des packages distincts qui sont des pilotes. Pour le reste du SGBD, il est nécessaire de configurer la connexion via l'interface ODBC à odbc RODBC odbc ou RODBC . Toutes les autres manipulations, quel que soit le SGBD que vous avez choisi, seront inchangées. Une exception est l'envoi de requêtes SQL, selon le dialecte SQL pris en charge par le SGBD avec lequel vous travaillez.

Source: https://habr.com/ru/post/fr461063/

More articles:


All Articles