12,23 Yuan Chuanghui·Shanghai Station, sprechen wir über die LLM-Infrastruktur

PostgreSQL ist ein relationales Open-Source-Datenbankverwaltungssystem (DBMS) und eine der am weitesten verbreiteten Open-Source-Datenbanken. Es ermöglicht Benutzern die Erweiterung seiner Funktionalität durch das Hinzufügen benutzerdefinierter Funktionen, Datentypen und Indizes, unterstützt ACID-Transaktionen und nutzt Multi-Version-Parallelitätskontrolle (MVCC) zur Verwaltung des gleichzeitigen Zugriffs mit hervorragender Sicherheit und Skalierbarkeit. AufgrundParallelitätsproblemen und Erweiterungsproblemen usw. ist die Entwicklung von PostgreSQL jedoch immer noch mit vielen Engpässen konfrontiert.

DolphinDB ist eine effiziente, verteilte Datenverwaltungs- und Analyseplattform, die leistungsstarke Programmiersprachen wie SQL, Python, Java usw. integriert und eine hohe Kapazität und Geschwindigkeit bietet Streaming Das Datenanalysesystem bietet eine Komplettlösung für die schnelle Speicherung, den Abruf, die Analyse und die Berechnung großer Datenmengen (insbesondere Zeitreihendaten). Es ist einfach zu bedienen, hoch skalierbar, verfügt über eine gute Fehlertoleranz und hervorragende Möglichkeiten für den gleichzeitigen Zugriff mehrerer Benutzer und eignet sich für verschiedene große Datenverarbeitungsszenarien.

Dieser Artikel soll eine kurze Tutorial-Referenz für Benutzer bereitstellen, die von der PostgreSQL-Datenbank zu DolphinDB migrieren müssen. Dieses Tutorial ist auch auf andere Datenbanktypen anwendbar, die auf PostgreSQL basieren, wie z. B. Greenplum. Die spezifische Implementierung kann unterschiedlich sein, und die offiziellen Anweisungen der tatsächlichen Datenbank haben Vorrang.

Der Gesamtrahmen für die Migration von Daten von PostgreSQL nach DolphinDB ist wie folgt:

1. Implementierungsmethode

Es gibt zwei Methoden zum Migrieren von Daten von PostgreSQL nach DolphinDB:

1.1 ODBC-Plugin

Das ODBC-Plugin (Open Database Connectivity) ist ein von DolphinDB bereitgestelltes Open-Source-Produkt, das über die ODBC-Schnittstelle auf PostgreSQL zugreift. Durch die Verwendung des Plug-ins in Verbindung mit dem DolphinDB-Skript und die Ausführung im selben Prozessraum wie der Server kann das Schreiben von Oracle-Daten in DolphinDB effizient abgeschlossen werden.

ODBC bietet die folgenden Funktionen. Informationen zur spezifischen Verwendung der Funktionen finden Sie unterodbc/README_CN.md · Zhejiang Zhiyu Technology Co., Ltd./DolphinDBPlugin – Gitee

odbc::connect(connStr, [dataBaseType])
odbc::close(conn)
odbc::query(connHandle or connStr, querySql, [t], [batchSize], [tranform])
odbc::execute(connHandle or connStr, SQLstatements)
odbc::append(connHandle, tableData, tablename, [createTableIfNotExist], [insertIgnore])

1.2 DataX-Treiber

DataX ist ein erweiterbares Datensynchronisierungs-Framework, das die Synchronisierung verschiedener Datenquellen in ein Reader-Plug-In abstrahiert, das Daten aus der Quelldatenquelle liest, und ein Writer-Plug-In, das Daten in das Ziel schreibt. Theoretisch kann das DataX-Framework dies Unterstützt jeden Datenquellentyp. Die Datensynchronisierung funktioniert.

DolphinDB bietet Open-Source-Treiber basierend auf DataXReader und DataXWriter. Das DolphinDBWriter-Plugin implementiert das Schreiben von Daten in DolphinDB. Mithilfe des vorhandenen Reader-Plugins von DataX in Kombination mit dem DolphinDBWriter-Plugin können Sie Daten aus verschiedenen Datenquellen mit DolphinDB synchronisieren. Benutzer können das DataX-Treiberpaket in ein Java-Projekt einbinden, um Datenmigrationssoftware von Oracle-Datenquellen zu DolphinDB zu entwickeln.

2. Bewerbungsvoraussetzungen

Viele in PostgreSQL gespeicherte Daten können über die beiden oben genannten Methoden mit DolphinDB synchronisiert werden. Der Praxisfall in diesem Artikel basiert auf den Transaktionsdaten eines Tages am 04.01.2021 mit einem Datenvolumen von ca. 27,21 Millionen. Einige Beispiele seiner Daten sind wie folgt:

3. Migrationsfälle und Betriebsschritte

3.1 Umgebungskonfiguration

Dabei wurden folgende Datenbanken und Plug-Ins verwendet, die Versionen und Modelle lauten wie folgt:

Postgre Version:PostgreSQL 13.1 on x86_64-pc-linux-gnu, compiled by gcc (GCC) 4.8.5 20150623 (Red Hat 4.8.5-44), 64-bit
unixODBC Version:2.3.7
DolphinDB Server Funktionen2.00.10 2023.07.18
DolphinDB GUI Funktionen1.30.22.1

2.00.10 Die Serverversion wird mit dem ODBC-Plugin geliefert, das sich im Verzeichnis des Servers befindet und direkt geladen und verwendet werden kann. Wenn der ODBC-Ordner nicht im Verzeichnis vorhanden ist, laden Sie ihn über den folgenden Link herunter: <HomeDir>/plugins <HomeDir>/plugins

Zhejiang Zhiyu Technology Co., Ltd./DolphinDBPlugin [Branch: release200.10]

Bitte beachten Sie, dass die Versionsnummer des DolphinDB ODBC-Plugins mit der Versionsnummer des Servers übereinstimmen muss, da sonst Fehler auftreten können. Wenn die Versionsnummer von DolphinDB Server beispielsweise 2.00.10.X ist, müssen Sie das ODBC-Plug-in des Zweigs release200.10 verwenden.

Beachten:

Wenn Sie es selbst kompilieren möchten, lesen Sie bitte:odbc/README_CN.md · Zhejiang Zhiyu Technology Co., Ltd./DolphinDBPlugin - Gitee im Artikel Kapitel 2.

3.2 Datenbank und Tabelle erstellen

Die PostgreSQL-Anweisung zur Tabellenerstellung lautet wie folgt:

create table ticksh(
  SecurityID         varchar(20),
  TradeTime       	 TIMESTAMP,
  TradePrice         NUMERIC(38,4),
  TradeQty 	         NUMERIC(38),
  TradeAmount        NUMERIC(38,4),
  BuyNo              NUMERIC(38),
  SellNo             NUMERIC(38),
  TradeIndex         NUMERIC(38),
  ChannelNo          NUMERIC(38),
  TradeBSFlag        varchar(10),
  BizIndex           integer
);

Beim Entwerfen eines Datenbank- und Tabellenaufbauplans müssen Sie Faktoren wie die Felder, Typen und Datenmengen der tatsächlichen Daten sowie die Frage, ob eine Partitionierung in DolphinDB erforderlich ist, das Partitionierungsschema usw. umfassend berücksichtigen ob OLAP- oder TSDB-Engines verwendet werden sollen. Informationen zu einigen Entwurfspraktiken für Datenrepository-Tabellen finden Sie im Tutorial zur DolphinDB-Datenbankpartitionierung.

In diesem Beispiel lautet der Inhalt der DolphinDB-Datenbank- und Tabellenerstellungsdatei createTable.dos wie folgt:

def createTick(dbName, tbName){
	if(existsDatabase(dbName)){
		dropDatabase(dbName)
	}
	db1 = database(, VALUE, 2020.01.01..2021.01.01)
	db2 = database(, HASH, [SYMBOL, 10])
	db = database(dbName, COMPO, [db1, db2], , "TSDB")
	db = database(dbName)
	name = `SecurityID`TradeTime`TradePrice`TradeQty`TradeAmount`BuyNo`SellNo`ChannelNo`TradeIndex`TradeBSFlag`BizIndex
	type = `SYMBOL`TIMESTAMP`DOUBLE`INT`DOUBLE`INT`INT`INT`INT`SYMBOL`INT
	schemaTable = table(1:0, name, type)
	db.createPartitionedTable(table=schemaTable, tableName=tbName, partitionColumns=`TradeTime`SecurityID, compressMethods={TradeTime:"delta"}, sortColumns=`SecurityID`TradeTime, keepDuplicates=ALL)
}

dbName="dfs://TSDB_tick"
tbName="tick"
createTick(dbName, tbName)

Die Zuordnungsbeziehung der von PostgreSQL nach DolphinDB migrierten Datenfelder ist wie folgt:

Bedeutung des PostgreSQL-Feldes	PostgreSQL-Felder	PostgreSQL-Datentypen	Bedeutung des DolphinDB-Felds	DolphinDB-Felder	DolphinDB-Datentypen
Wertpapiercode	Sicherheits-ID	VARCHAR(20)	Wertpapiercode	Sicherheits-ID	SYMBOL
Transaktionsstunde	TradeTime	ZEITSTEMPEL	Transaktionsstunde	TradeTime	ZEITSTEMPEL
Handelspreis	Handelspreis	NUMERISCH(38,4)	Handelspreis	Handelspreis	DOPPELT
Anzahl der Transaktionen	Handelsmenge	NUMERISCH(38)	Anzahl der Transaktionen	Handelsmenge	INT
Betrag der Transaktion	Handelsbetrag	NUMERISCH(38,4)	Betrag der Transaktion	Handelsbetrag	DOPPELT
Bestellindex des Käufers	Kaufen Nr	NUMERISCH(38)	Bestellindex des Käufers	Kaufen Nr	INT
Bestellindex des Verkäufers	VerkaufNr	NUMERISCH(38)	Bestellindex des Verkäufers	VerkaufNr	INT
Transaktionsnummer	TradeIndex	NUMERISCH(38)	Transaktionsnummer	TradeIndex	INT
Kanalcode	KanalNr	NUMERISCH(38)	Kanalcode	KanalNr	INT
Transaktionsrichtung	TradeBSFlag	VARCHAR(10)	Transaktionsrichtung	TradeBSFlag	SYMBOL
Geschäftsseriennummer	BizIndex	GANZE ZAHL	Geschäftsseriennummer	BizIndex	INT

3.3 Migration über ODBC

3.3.1 ODBC-Treiber installieren

In diesem Beispiel ist das Serverbetriebssystem, auf dem DolphinDB bereitgestellt wird, Centos.

Schritt 1: Bevor Sie den PostgreSQL-ODBC-Treiber installieren, müssen Sie zunächst die unixODBC-Bibliothek installieren. Verwenden Sie den folgenden Befehl, um sie zu installieren.

Centos-System:

# 安装 unixODBC 库
yum install unixODBC unixODBC-devel

Schritt 3: Konfigurieren Sie die ODBC-Konfigurationsdatei

1)odbcinst.ini Die Datei wird verwendet, um den Dateipfad der ODBC-Treiberbibliothek festzulegen, die von einem bestimmten ODBC-Treiber verwendet werden soll . Konfiguration odbcinst.ini Inhalt der Datei (falls die Konfigurationsdatei nicht vorhanden ist, muss sie manuell erstellt werden):

[PostgreSQL]
Description     = ODBC for PostgreSQL
Driver          = /usr/lib/psqlodbcw.so
Setup           = /usr/lib/libodbcpsqlS.so
Driver64        = /usr/lib64/psqlodbcw.so
Setup64         = /usr/lib64/libodbcpsqlS.so
FileUsage       = 1

2)/etc/odbc.ini Die Datei wird verwendet, um den in ODBC verwendeten Treiber, die zu verwendende Datenbank usw. festzulegen . und mehr Weitere Informationen zu mehreren Konfigurationselementen finden Sie unter Konfiguration der ODBC-Verbindungszeichenfolge. Der Treiber ist der Inhalt in eckigen Klammern in der ersten Zeile, der in der Datei /etc/odbcinst.ini konfiguriert ist. Fügen Sie den folgenden Inhalt hinzu (wenn die Konfigurationsdatei nicht vorhanden ist, müssen Sie sie manuell erstellen):

[postgresql] 					//ODBC数据源名称
Description = PostgresSQLODBC	//ODBC的描述
Driver = PostgreSQL				//驱动名称
Database = postgres				//数据库名称
Servername = 127.0.0.1			//布置了Postgresql数据库的服务器IP地址
UserName = postgres				//数据库相关的用户名
Password = postgres				//数据库密码
Port = 5432					    //布置了Postgresql数据库的服务器的端口号
ReadOnly = 0					//关闭只读特性
ConnSettings = set client_encoding to UTF8	//客户端编码

Schritt 4: ODBC-Verbindung testen

Melden Sie sich mit ODBC bei der Postgresql-Datenbank an, testen Sie die Verbindung und die erwarteten Ergebnisse lauten wie folgt:

isql postgresql postgres postgres  //后两位分别是用户名和密码

/**********output********/
+---------------------------------------+
| Connected!                            |
|                                       |
| sql-statement                         |
| help [tablename]                      |
| quit                                  |
|                                       |
+---------------------------------------+

Die erfolgreiche Anmeldung ist wie unten dargestellt. Sie können SQL eingeben, um die Datenbank zu betreiben

SQL>

Beachten:

Wenn Sie weitere häufig gestellte Fragen haben, lesen Sie bitte Kapitel 5 Vorsichtsmaßnahmen und häufig gestellte Fragen im Artikel ODBC_plugin_user_guide.md · Zhejiang Zhiyu Technology Co., Ltd./Tutorials_CN – Gitee.

3.3.2 Daten synchronisieren

Schritt 1: Führen Sie den folgenden Befehl aus, um das ODBC-Plug-in zu laden ( ServerPath Bitte ändern Sie es selbst)

loadPlugin("ServerPath/plugins/odbc/PluginODBC.txt")

Schritt 2: Führen Sie den folgenden Befehl aus, um eine Verbindung mit Oracle herzustellen (der erste Parameter ist die ODBC-Verbindungszeichenfolge connStr).

connstr Sehen Sie sich die Referenz zur Verbindungszeichenfolge an, um sie selbst zu ändern.

conn = odbc::connect("Driver={PostgreSQL};Server=*;Port=5432;Database=postgres;Uid=postgres;Pwd=postgres;", `PostgreSQL)

Schritt 3: Führen Sie den folgenden Befehl aus, um mit der Synchronisierung der Daten zu beginnen

def transForm(mutable msg){
	msg.replaceColumn!(`TradeQty, int(msg[`TradeQty]))
	msg.replaceColumn!(`BuyNo, int(msg[`BuyNo]))
	msg.replaceColumn!(`SellNo, int(msg[`SellNo]))
	msg.replaceColumn!(`ChannelNo, int(msg[`ChannelNo]))
	msg.replaceColumn!(`TradeIndex, int(msg[`TradeIndex]))
	msg.replaceColumn!(`BizIndex, int(msg[`BizIndex]))
	return msg
}

def syncData(conn, dbName, tbName, dt){
	sql = "select SecurityID, TradeTime, TradePrice, TradeQty, TradeAmount, BuyNo, SellNo, ChannelNo, TradeIndex, TradeBSFlag, BizIndex from ticksh"
	if(!isNull(dt)) {
		sql = sql + " where to_date(TradeTime,'yyyy-MM-dd hh24:mi:ss') = dt"
	}
    odbc::query(conn,sql, loadTable(dbName,tbName), 100000, transForm)
}

dbName="dfs://TSDB_tick"
tbName="tick"
syncData(conn, dbName, tbName, NULL)

Insgesamt gibt es 27211975 Daten, und die Synchronisierung der Daten dauert etwa 597 Sekunden.

Schritt 4: Multitasking-Datensynchronisierung im Hintergrund

In diesem Tutorial wird die DolphinDB-Datenbank nach Tagen partitioniert. Wenn Sie Daten für mehrere Tage synchronisieren müssen, können Sie mehrere Aufgaben im Hintergrund ausführen:

for(dt in 2021.01.04..2021.01.05){
	submitJob(`syncPostgreTick, `syncPostgreTick, syncData, conn, dbName, tbName, dt)
}
// 查看后台任务
select * from getRecentJobs() where jobDesc = `syncPostgreTick

3.4 Migration über DataX

3.4.1 Bereitstellen von DataX

Laden Sie das komprimierte DataX-Paket von der DataX-Downloadadresse herunter und extrahieren Sie es in ein benutzerdefiniertes Verzeichnis. Führen Sie den datax Selbsttest wie folgt aus:

cd datax/bin
python datax.py /opt/datax/job/job.json

Es kann ein Fehler auftreten. Der Fehler lautet: [Die von Ihnen angegebene Konfigurationsdatei enthält Fehlerinformationen...plugin.json] existiert nicht:

Dieses Problem ist auf das Vorhandensein temporärer Dateien in den Lese- und Schreibverzeichnissen zurückzuführen, die den Betrieb von datax beeinträchtigen. Die Lösung lautet wie folgt:

# 这里的/datax/plugin/writer/要改为你自己的目录
find /datax/plugin/reader/ -type f -name "._*er" | xargs rm -rf
find /datax/plugin/writer/ -type f -name "._*er" | xargs rm -rf

Nachdem der Selbsttest erfolgreich war, kopieren Sie den gesamten Inhalt des Verzeichnisses ./dist/dolphindbwriter des Quellcodes in DataX-DolphinDBWriter in das Verzeichnis DataX/plugin/writer, und Sie können ihn verwenden.

3.4.2 Ausführen von DataX-Aufgaben

Schritt 1: JSON-Datei konfigurieren

Der spezifische Inhalt der Konfigurationsdatei pgddb.json lautet wie folgt. Die JSON-Datei wird in einem benutzerdefinierten Verzeichnis abgelegt. In diesem Tutorial wird sie im Verzeichnis datax/job abgelegt.

{
    "job": {
            "content": [{
                    "writer": {
                            "name": "dolphindbwriter",
                            "parameter": {
                                    "userId": "admin",
                                    "pwd": "123456",
                                    "host": "10.0.0.80",
                                    "port": 8848,
                                    "dbPath": "dfs://TSDB_tick",
                                    "tableName": "Tick",
                                    "table": [
                                        {
                                             "type": "DT_SYMBOL",
                                             "name": "SecurityID"
                                        },
                                        {
                                            "type": "DT_TIMESTAMP",
                                            "name": "TradeTime"
                                        },
                                        {
                                            "type": "DT_DOUBLE",
                                            "name": "TradePrice"
                                        },
                                        {
                                            "type": "DT_INT",
                                            "name": "TradeQty"
                                        },
                                        {
                                            "type": "DT_DOUBLE",
                                            "name": "TradeAmount"
                                        },
                                        {
                                            "type": "DT_INT",
                                            "name": "BuyNo"
                                        },
                                        {
                                            "type": "DT_INT",
                                            "name": "SellNo"
                                        },
                                        {
                                            "type": "DT_INT",
                                            "name": "TradeIndex"
                                        },
                                        {
                                            "type": "DT_INT",
                                            "name": "ChannelNo"
                                        },
                                        {
                                            "type": "DT_SYMBOL",
                                            "name": "TradeBSFlag"
                                        },
                                        {
                                            "type": "DT_INT",
                                            "name": "BizIndex"
                                        }
                                    ]                            
                            }
                    },
                    "reader": {
                            "name": "postgresqlreader",
                            "parameter": {
                                    "username": "postgres",
                                    "column": ["SecurityID", "TradeTime", "TradePrice", "TradeQty", "TradeAmount", "BuyNo", "SellNo", "ChannelNo", "TradeIndex", "TradeBSFlag", "BizIndex"],
                                    "connection": [{
                                            "table": ["ticksh"],
                                            "jdbcUrl": ["jdbc:postgresql:postgres"]
                                    }],
                                    "password": "postgres",
                                    "where": ""
                            }                            
                    }
            }],
            "setting": {
                    "speed": {
                            "channel": 1
                    }
            }
    }
}

Schritt 2: Führen Sie den folgenden Befehl im Linux-Terminal aus, um die DataX-Aufgabe auszuführen

cd ./datax
python bin/datax.py --jvm=-Xmx8g job/ddbtopg.json

Schritt 3: DataX-Synchronisierungsergebnisse anzeigen

任务启动时刻                    : 2023-08-29 14:19:53
任务结束时刻                    : 2023-08-29 14:26:33
任务总计耗时                    :                400s
任务平均流量                    :            4.08MB/s
记录写入速度                    :          68029rec/s
读出记录总数                    :            27211975
读写失败总数                    :                   0

4. Grundleistung

Für die Datenmigration wurden das ODBC-Plugin bzw. der DataX-Treiber verwendet. Die Datenmenge betrug 27,21 Millionen. Der Vergleich der Migrationszeit ist in der folgenden Tabelle dargestellt:

ODBC-Plugin	DataX
597,54 Sekunden	400er

Zusammenfassend lässt sich sagen, dass sowohl das ODBC-Plug-in als auch DataX Daten von PostgreSql nach DolphinDB migrieren können, aber jedes hat seine eigenen Vor- und Nachteile:

ODBC ist einfach zu verwenden und eignet sich zum Importieren benutzerdefinierter Daten, die Betriebs- und Wartungsverwaltung ist jedoch umständlich.
Das Importieren von Daten durch DataX erfordert das Schreiben komplexer Importkonfigurationen. Die Erweiterung ist jedoch flexibel, für den Stapelimport geeignet, praktisch für die Überwachung und bietet umfangreiche Community-Unterstützung.

Benutzer können die geeignete Importmethode basierend auf der Größe ihrer Daten und dem Komfort des Engineerings auswählen.

Tutorial zur Datenmigration | Von PostgreSQL/Greenplum zu DolphinDB