Da der Löwenanteil der Geschäftsinformationen in Datenbanken gespeichert ist. In welcher Programmiersprache Sie auch schreiben, Sie müssen verschiedene Aktionen mit ihnen ausführen.

In diesem Artikel werde ich über zwei Schnittstellen für die Arbeit mit Datenbanken in R sprechen. Die meisten Beispiele zeigen die Arbeit mit Microsoft SQL Server. Alle Codebeispiele funktionieren jedoch mit anderen Datenbanken, z. B. MySQL, PostgreSQL, SQLite, ClickHouse , Google BigQuery usw.

Bild

Inhalt

Software erforderlich

Um alle im Artikel beschriebenen Beispiele für die Arbeit mit dem DBMS zu wiederholen, benötigen Sie die folgende kostenlose Software:

Sprache R ;
RStudio- Entwicklungsumgebung;
Datenbankverwaltungssystem zur Auswahl:
3.1. Microsoft SQL Server
3.2. MySQL
3.3. PostgreSQL

DBI-Paket

Das DBI Paket ist die beliebteste und bequemste Möglichkeit, mit Datenbanken in R zu interagieren.

DBI bietet Ihnen eine Reihe von Funktionen, mit denen Sie Datenbanken verwalten können. Um jedoch eine Verbindung zu Datenbanken herzustellen, müssen Sie zusätzliche Pakete installieren, die Treiber für verschiedene Datenbankverwaltungssysteme (DBMS) sind.

Liste der grundlegenden DBI-Funktionen

dbConnect - Verbindung zur Datenbank;
dbWriteTable - schreibt eine Tabelle in die Datenbank;
dbReadTable - Laden einer Tabelle aus einer Datenbank;
dbGetQuery - Laden des Ergebnisses der Abfrageausführung;
dbSendQuery - Senden einer Abfrage an die Datenbank;
dbFetch - Elemente aus einer Ergebnismenge extrahieren;
dbExecute - Ausführung von Anforderungen zum Aktualisieren / Löschen / Einfügen von Daten in Tabellen;
dbGetInfo - Anforderungsinformationen zum Ergebnis der Anforderung oder Verbindung;
dbListFields - Anforderung einer Liste von Tabellenfeldern;
dbListTables - eine Liste von Datenbanktabellen abfragen;
dbExistsTable - Überprüfen dbExistsTable ob eine Tabelle in der Datenbank vorhanden ist.
dbRemoveTable - Löscht eine Tabelle aus der Datenbank.
dbDisconnect - Verbindung zur Datenbank trennen.

Datenbankkonnektivität

Um mit Datenbanken zu interagieren, müssen Sie zuerst eine Verbindung zu ihnen herstellen. Abhängig von dem DBMS, mit dem Sie arbeiten möchten, benötigen Sie ein zusätzliches Paket. Nachfolgend finden Sie eine Liste der am häufigsten verwendeten.

odbc - Treiber für die Verbindung über die ODBC-Schnittstelle;
RSQLite - Treiber für SQLite;
RMySQL / RMariaDB - Treiber für MySQL und MariaDB;
RPostgreSQL - Treiber für PosrtgreSQL;
bigrquery - Treiber für Google BigQuery;
RClickhouse / clickhouse - Treiber für ClickHouse;
RMSSQL - Treiber für Microsoft SQL Server (MS SQL) ist zum Zeitpunkt des Schreibens nur auf GitHub vorhanden .

Das DBI Paket wird mit dem Basis-R-Paket geliefert, aber Pakete, die Datenbanktreiber sind, müssen mit dem Befehl install.packages(" ") Treibername install.packages(" ") installiert werden.

Um Pakete von GitHub zu installieren, benötigen Sie außerdem ein zusätzliches Paket - devtools . Beispielsweise wird das RMSSQL Paket derzeit nicht im Haupt-R-Paket-Repository veröffentlicht. Verwenden Sie den folgenden Code, um es zu installieren:

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

Ein Beispiel für die Verbindung mit Microsoft SQL Server mithilfe des odbc-Pakets

Bevor ein Paket in einer R-Sitzung verwendet werden kann, muss es zunächst über die library(" ") .

Nicht ohne Grund habe ich Microsoft SQL Server als Haupt-DBMS ausgewählt, das die meisten Beispiele in diesem Artikel enthält. Tatsache ist, dass dies eine ziemlich beliebte Datenbank ist, aber gleichzeitig noch keinen Treiber für die Verbindung von R auf CRAN veröffentlicht hat.

Glücklicherweise verfügt SQL Server wie fast jede andere Datenbank über eine ODBC- Schnittstelle (English Open Database Connectivity) für die Verbindung. Es gibt eine Reihe von Paketen für die Verbindung zum DBMS über die ODBC-Schnittstelle in R. Zuerst werden wir uns die Verbindung über das odbc Paket odbc .

Einfache Datenbankverbindung über die ODBC-Schnittstelle

 #   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)

In der Funktion dbConnect() müssen Sie die Funktion, die der Treiber für die Verbindung zum DBMS ( odbc() ) ist, als erstes Argument an drv übergeben . Solche Funktionen werden normalerweise als DBMS bezeichnet und werden mit Paketen geliefert, die Treiber für DBI .

Als nächstes müssen Sie die Verbindungsparameter auflisten. Um über ODBC eine Verbindung zu MS SQL herzustellen, müssen Sie die folgenden Parameter angeben:

Treiber - Name des ODBC-Treibers;
Server - IP-Adresse des SQL Servers;
Datenbank - Der Name der Datenbank, zu der eine Verbindung hergestellt werden soll.
UID - Datenbankbenutzername;
PWD - Passwort;
Port - Der Port, zu dem mit SQL Server eine Verbindung hergestellt werden soll. Der Standardport ist 1433.

Ein ODBC-Treiber für die Verbindung mit Microsoft SQL Server ist in Windows enthalten, kann jedoch einen anderen Namen haben. Sie können die Liste der installierten Treiber im ODBC-Datenquellenadministrator anzeigen. Sie können den Datenquellenadministrator in Windows 10 folgendermaßen starten:

32-Bit-Version: %systemdrive%\Windows\SysWoW64\Odbcad32.exe
64-Bit-Version: %systemdrive%\Windows\System32\Odbcad32.exe

Mit der Funktion odbcListDrivers() können Sie auch eine Liste aller auf Ihrem PC installierten Treiber 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

Sie können ODBC-Treiber für andere DBMS unter den folgenden Links herunterladen:

Bei verschiedenen DBMS kann der Name der Verbindungsparameter unterschiedlich sein, z. B.:

PostgreSQL / MySQL / MariaDB - Benutzer, Passwort, Host, Port, Datenbankname;
GoogleBigQuery - Projekt, Datensatz;
ClickHouse - Benutzer, Passwort, Datenbank, Port, Host;

Mit dem ODBC-Datenquellenadministrator können Sie den Assistenten ausführen, um eine ODBC-Datenquelle zu erstellen. Öffnen Sie dazu einfach den Administrator, wechseln Sie zur Registerkarte "Benutzerdefinierter DSN" und klicken Sie auf die Schaltfläche "Hinzufügen ...".

Wenn Sie eine Datenquelle mit einem Administrator erstellen, geben Sie ihr den Namen DSN (Data Source Name).

Im obigen Beispiel haben wir eine Datenquelle mit dem DSN "my_test_source" erstellt. Jetzt können wir diese Quelle verwenden, um eine Verbindung zu Microsoft SQL Server herzustellen, und keine anderen Verbindungsparameter im Code angeben.

Verbindung zur Datenbank über die ODBC-Schnittstelle über DSN

 #   DSN con <- dbConnect(odbc(), DSN = "my_test_source", UID = "my_username", PWD = "my_password")

Mit der Funktion odbcListDataSources() können Sie die Namen aller auf Ihrem PC erstellten ODBC-Datenquellen 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

Ein Beispiel für die Verbindung mit Microsoft SQL Server mithilfe des RMSSQL-Pakets

RMSSQL nicht auf CRAN veröffentlicht, daher können Sie es mit dem devtools Paket von GitHub installieren.

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

Verbindungsbeispiel mit DBI RMSSQL-Treiber

 #    library(RJDBC) library(RMSSQL) library(DBI) #  RMSSQL con <- dbConnect(MSSQLServer(), host = 'localhost', user = 'my_username', password = 'my_password', dbname = "mybase")

In den meisten Fällen stellen Sie auf diese Weise eine Verbindung her, wenn Sie das DBI Paket für die Arbeit mit Datenbanken verwenden. Das heißt, Installieren Sie eines der erforderlichen Treiberpakete, und übergeben Sie die Funktion dbConnect als Wert des Argumentes drv , der Treiberfunktion für die Verbindung mit dem von Ihnen benötigten DBMS.

Ein Beispiel für die Verbindung zu MySQL, PostgreSQL, SQLite und 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")

So verbergen Sie Datenbankkennwörter in R-Skripten

Oben habe ich einige Beispiele angegeben, mit denen eine Verbindung zu einer beliebigen Datenbank hergestellt werden kann, die jedoch ein Minus enthält. In dieser Form werden alle Datenbankzugriffe, einschließlich Kennwörter, als Text in den Skripten selbst gespeichert.

Wenn alle Ihre Skripte ausschließlich lokal auf Ihrem PC bereitgestellt und ausgeführt werden und gleichzeitig durch ein Kennwort geschützt sind, liegt höchstwahrscheinlich kein Problem vor. Wenn Sie jedoch mit jemandem auf demselben Server arbeiten, ist das Speichern von Kennwörtern aus den Datenbanken im Text Ihrer Skripte nicht die beste Lösung.

Jedes Betriebssystem verfügt über ein Dienstprogramm zum Verwalten von Anmeldeinformationen. Unter Windows ist dies beispielsweise der Anmeldeinformations-Manager. Sie können das Kennwort, mit dem Sie über das keyring eine Verbindung zur Datenbank herstellen, zu diesem Repository hinzufügen. Das Paket ist plattformübergreifend und das obige Beispiel funktioniert unter jedem Betriebssystem, zumindest unter Windows, MacOS und 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")

Das heißt, Mit der Funktion key_set_with_value() fügen Sie dem Speicher für Anmeldeinformationen ein Kennwort hinzu, und mit key_get() es an. Nur der Benutzer, der es dem Geschäft hinzugefügt hat, kann ein Kennwort anfordern. Mit dem keyring Sie Kennwörter nicht nur aus Datenbanken, sondern auch aus beliebigen Diensten sowie Autorisierungstoken speichern, wenn Sie mit der API arbeiten.

Tabellen erstellen und in die Datenbank schreiben

Das Schreiben in die Datenbank wird von der Funktion dbWriteTable() .

Argumente für die Funktion dbWriteTable() :

Erforderliche Argumente sind fett gedruckt, Kursivschrift ist optional

conn - DBMS-Verbindungsobjekt, das mit der Funktion dbConnect ;
name - der Name der Tabelle im DBMS, in die die Daten geschrieben werden;
value - eine Tabelle (ein Objekt der Klasse data.frame / data.table / tibble_frame) in R, deren Daten in das DBMS geschrieben werden;
row.names - Fügt der Tabelle eine row_names-Spalte mit Zeilennummern hinzu, standardmäßig FALSE .
überschreiben - Überschreibt die Tabelle, wenn die Tabelle mit dem im Argument name angegebenen Namen bereits im DBMS vorhanden ist. Der Standardwert ist FALSE .
append - Hängt Daten an, wenn eine Tabelle mit dem im Argument name angegebenen Namen bereits im DBMS vorhanden ist. Der Standardwert ist FALSE .
field.types - Akzeptiert einen benannten Vektor und legt den Datentyp in jedem Feld beim Schreiben in das DBMS fest. Der Standardwert ist NULL .
temporär - Ermöglicht das Erstellen temporärer Tabellen im DBMS, die verfügbar sind, bis die Verbindung zur Datenbank getrennt wird. Der Standardwert ist FALSE .

Ein Beispiel für das Schreiben von Daten in ein DBMS über 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)

Verwenden Sie zum dbListTables() Tabellen in der Datenbank die Funktion dbListTables() , um Tabellen zu löschen. dbRemoveTable()

Beispiel für das Abfragen einer Tabellenliste und das Löschen einer Tabelle aus einem DBMS

 #   library(odbc) #    con <- dbConnect(odbc(), DSN = "my_test_source", UID = "my_username", PWD = "my_password") #    dbListTables(con) #   iris dbRemoveTable(con, "iris") #     dbDisconnect(con)

Daten aus einem DBMS lesen

Mit DBI Sie entweder ganze Tabellen oder das Ergebnis der Ausführung Ihrer SQL-Abfrage abfragen. Die Funktionen dbReadTable() und dbGetQuery() werden verwendet, um diese Operationen auszuführen.

Beispiel für die Abfrage einer Iris-Tabelle aus einem DBMS

 #   library(odbc) #    con <- dbConnect(odbc(), DSN = "my_test_source", UID = "my_username", PWD = "my_password") #   iris   iris dbiris <- dbReadTable(con, "iris") #     dbDisconnect(con)

Ein Beispiel für das Laden des SQL-Ausführungsergebnisses aus einem DBMS

 #   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)

Datenmanipulation in DBMS (DML)

Die dbGetQuery() Funktion dbGetQuery() wird ausschließlich zum Abfragen von Datenproben (SELECT) verwendet.

Für Datenmanipulationsvorgänge wie UPDATE, INSERT, DELETE ist die Funktion dbExecute() in DBI .

Beispielcode zum Bearbeiten von Daten in einem DBMS

 #   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)

Transaktionen im DBMS

Eine Transaktion ist eine sequentielle Lese- und Schreiboperation. Das Ende einer Transaktion kann entweder das Speichern von Änderungen (Festschreiben, Festschreiben) oder das Abbrechen von Änderungen (Rollback, Rollback) sein. In Bezug auf die Datenbank besteht eine Transaktion aus einer Reihe von Abfragen, die als einzelne Abfrage behandelt werden.

Zitat aus dem Artikel "Transaktionen und die Mechanismen ihrer Kontrolle"

Eine Transaktion kapselt mehrere SQL-Anweisungen in einer Elementareinheit. In DBI Start einer Transaktion mit dbBegin() initiiert und dann entweder mit dbCommit() bestätigt oder mit dbCommit() abgebrochen. In jedem Fall garantiert das DBMS Folgendes: Entweder alle oder keine der Anweisungen werden auf die Daten angewendet.

Fügen Sie während der Transaktion beispielsweise 51 Zeilen zur Iris-Tabelle hinzu, ändern Sie dann den Wert für Sepal.Width in 5 Zeilen und löschen Sie 43 Zeilen aus der Tabelle.

Beispiel für einen Transaktionscode

 #   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

Beispiel für einen Transaktionsstornierungscode

 #   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

RODBC-Paket

Das RODBC Paket bietet eine eigenständige Schnittstelle zum Verbinden und Arbeiten mit einem DBMS über eine ODBC-Schnittstelle.

RODBC nicht DBI kompatibel, d.h. Sie können das mit RODBC erstellte RODBC in den vom DBI Paket bereitgestellten Funktionen verwenden.

Hauptmerkmale des RODBC-Pakets

odbcConnect - Verbindung zum DBMS über DSN;
odbcDriverConnect - Verbindung zur Datenbank über die Verbindungszeichenfolge;
sqlQuery - Senden einer Abfrage an das DBMS und sqlQuery des Ergebnisses der Ausführung. Unterstützt Abfragen aller Art: SELECT, UPDATE, INSERT, DELETE.
sqlFetch - sqlFetch die gesamte Tabelle aus dem DBMS ab.
sqlTables - sqlTables eine Liste der Tabellen in der Datenbank ab.
sqlSave - Erstellen Sie eine neue Tabelle in der Datenbank oder fügen Sie einer vorhandenen Tabelle neue Daten hinzu.
sqlUpdate - Aktualisieren von Daten in einer Tabelle, die bereits im DBMS vorhanden ist;
sqlDrop - Löscht eine Tabelle in einem DBMS.
odbcClose - odbcClose eine Verbindung zu einem DBMS.

Ein Beispiel für die Arbeit mit RODBC

Aus meiner Sicht ist RODBC weniger funktional als DBI , verfügt jedoch über alle erforderlichen Funktionen für die Arbeit mit einem DBMS.

Ein Beispiel für die Interaktion mit einem DBMS über 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()

Transaktion

Standardmäßig ist die Transaktionsfähigkeit in RODBC . Das Transaktionsmanagement wird von zwei Funktionen ausgeführt.

odbcSetAutoCommit - odbcSetAutoCommit zwischen dem normalen und dem transaktionalen DBMS-Betriebsmodus.
odbcEndTran - Bestätigen oder stornieren Sie eine Transaktion.

Das Ein- und Ausschalten des Transaktionsmodus erfolgt durch die Funktion odbcSetAutoCommit mit dem Argument autoCommit .

Beispiel für die Arbeit im Transaktionsmodus in 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)

Fazit

Die beiden im Artikel beschriebenen Methoden zum Arbeiten mit Datenbanken in den Sprachen R, DBI und RODBC sind recht universell und funktionieren mit fast jedem DBMS.

Der einzige Unterschied im Betrieb zwischen verschiedenen DBMS ist der Verbindungsprozess. Für die meisten gängigen DBMS gibt es separate Pakete, die Treiber sind. Für den Rest des DBMS muss die Verbindung über die ODBC-Schnittstelle mithilfe von odbc oder RODBC . Alle anderen Manipulationen, unabhängig von dem von Ihnen gewählten DBMS, bleiben unverändert. Eine Ausnahme ist das Senden von SQL-Abfragen, abhängig vom SQL-Dialekt, der von dem DBMS unterstützt wird, mit dem Sie arbeiten.

Interaktion von R mit Datenbanken am Beispiel von Microsoft SQL Server und anderen DBMS