Productos secos 丨 Tutorial de carga de datos de Orca

Este artículo describe cómo cargar datos en Orca.

1 Establezca una conexión a la base de datos

connectConéctese al servidor DolphinDB a través de la función en Orca :

>>> importar dolphindb.orca como orca 
>>> orca.connect (MY_HOST, MY_PORT, MY_USERNAME, MY_PASSWORD)

2 Importar datos

El siguiente tutorial usa un archivo de datos: quotes.csv .

2.1 función read_csv

Orca proporciona read_csvfunciones para importar conjuntos de datos. Cabe señalar que read_csvel valor del parámetro del motor de la función Orca puede ser {'c', 'python', 'dolphindb'}, y el valor predeterminado de este parámetro es 'dolphindb'. Cuando el valor es 'dolphindb', la read_csvfunción buscará el archivo de datos que se va a importar en el directorio del servidor DolphinDB. Cuando el valor es 'python' o 'c', la read_csvfunción buscará el archivo de datos que se va a importar en el directorio del cliente de Python.

Tenga en cuenta que, cuando el parámetro del motor se establece en 'python' o 'c', Orca la read_csv llamada a la read_csv función corresponde a la función pandas introducida. Esta sección se basa en la premisa El valor del parámetro del motor Orca es 'dolphindb', la read_csv explicación de la función.

Cuando el parámetro del motor se establece en 'dolphindb', read_csvlos parámetros actualmente admitidos por la función de Orca son los siguientes:

ruta: ruta del archivo
sep: separador
delimitador: delimitador
nombres: especifique los nombres de las columnas
index_col: especifique la columna como índice
motor: el motor a importar
usecols: especifique las columnas que se importarán
squeeze: cuando el archivo de datos tiene solo una fila o una columna, si comprimir el DataFrame en Series
prefijo: la cadena de prefijo agregada a cada columna
dtype: especifica el tipo de datos a importar
particionado: si permitir que los datos se importen de manera particionada
db_handle: la ruta de la base de datos que se va a importar
table_name: el nombre de la tabla que se va a importar
Partition_columns: nombres de columna para particionar

La siguiente es una introducción detallada a varios parámetros que difieren entre Orca y pandas.

parámetro dtype

Orca reconoce automáticamente el tipo de datos del archivo que se va a importar al importar csv y admite varios formatos de hora comunes. El usuario también puede forzar el tipo de datos especificado a través del parámetro dtype.

Cabe señalar que las read_csvfunciones de Orca no solo admiten la especificación de varios tipos de datos numéricos (np.bool, np.int8, np.float32, etc.), sino que también admiten la especificación de todos los tipos de datos proporcionados por DolphinDB en forma de cadenas , incluidos todos tipos de tiempo y tipos de cadenas.

P.ej:

dfcsv = orca.read_csv ("DATA_DIR / quotes.csv", dtype = {"TIME": "NANOTIMESTAMP", "Exchange": "SYMBOL", "SYMBOL": "SYMBOL", "Bid_Price": np.float64, " Bid_Size ": np.int32 ，" Offer_Price ": np.float64," Offer_Size ": np.int32})

parámetro particionado

El tipo bool, el valor predeterminado es True. Cuando este parámetro es Verdadero, cuando el tamaño de los datos alcanza un cierto nivel, los datos se importarán como una tabla de memoria particionada. Si se establece en Falso, csv se importará directamente como una tabla de memoria ordinaria DolphinDB no particionada.

Nota: Comparada con la tabla de memoria de Orca, la tabla de particiones de Orca tiene muchas diferencias en el funcionamiento. Para más detalles, vea las diferencias especiales de la tabla de particiones de Orca . Si su volumen de datos no es muy grande y la consistencia entre Orca y pandas es mayor cuando usa Orca, intente no importar los datos de una manera particionada. Si tiene una gran cantidad de datos y tiene requisitos de rendimiento extremadamente altos, se recomienda que importe los datos mediante particiones.

Parámetros db_handle, table_name y partition_columns

Orca read_csvtambién admite los tres parámetros db_handle, table_name y partition_columns.Estos parámetros se utilizan para importar datos a la tabla de particiones de DolphinDB especificando la base de datos y la tabla de DolphinDB y otra información relacionada al importar datos.

DolphinDB admite la importación de datos a la base de datos de DolphinDB de varias formas . Orca read_csvespecifica los parámetros db_handle, table_name y partition_columns cuando llama a la función. En esencia, llama a la función loadTextEx de DolphinDB . De esta manera, podemos importar directamente los datos directamente al Tabla de particiones DolphinDB.

2.1.1 Importar a la tabla de memoria

Importar como una tabla de particiones de memoria

Llame a la read_csvfunción directamente y los datos se importarán en paralelo. Debido a la importación paralela, la velocidad de importación es rápida, pero el uso de memoria es el doble que el de una tabla normal. En el siguiente ejemplo, 'DATA_DIR' es la ruta donde se almacena el archivo de datos.

>>> DATA_DIR = "dolphindb/database" # e.g. data_dir
>>> df = orca.read_csv(DATA_DIR + "/quotes.csv")
>>> df.head()
# output

                        time Exchange Symbol  Bid_Price  Bid_Size  \
0 2017-01-01 04:40:11.686699        T   AAPL       0.00         0   
1 2017-01-01 06:42:50.247631        P   AAPL      26.70        10   
2 2017-01-01 07:00:12.194786        P   AAPL      26.75         5   
3 2017-01-01 07:15:03.578071        P   AAPL      26.70        10   
4 2017-01-01 07:59:39.606882        K   AAPL      26.90         1   
   Offer_Price  Offer_Size  
0        27.42           1  
1        27.47           1  
2        27.47           1  
3        27.47           1  
4         0.00           0

导入为普通内存表

partitioned参数取值为False，导入为普通内存表。导入对内存要求低，但是计算速度略低于上面的导入方式：

df = orca.read_csv(DATA_DIR + "/quotes.csv"， partitioned=False)

2.1.2 导入到磁盘表

DolphinDB的分区表可以保存在本地磁盘，也可以保存在dfs上，磁盘分区表与分布式表的区别就在于分布式表的数据库路径以"dfs://"开头，而磁盘分区表的数据库路径是本地路径。

示例

我们在DolphinDB服务端创建一个磁盘分区表，下面的脚本中，'YOUR_DIR'为保存磁盘数据库的路径：

dbPath=YOUR_DIR + "/demoOnDiskPartitionedDB"
login('admin', '123456')
if(existsDatabase(dbPath))
   dropDatabase(dbPath)
db=database(dbPath, RANGE, datehour(2017.01.01 00:00:00+(0..24)*3600))

请注意：以上两段脚本需要在DolphinDB服务端执行，在Python客户端中则可以通过DolphinDB Python API执行脚本。

在Python客户端中调用Orca的read_csv函数，指定数据库db_handle为磁盘分区数据库YOUR_DIR + "/demoOnDiskPartitionedDB"，指定表名table_name为"quotes"和进行分区的列partition_columns为"time"，将数据导入到DolphinDB的磁盘分区表，并返回一个表示DolphinDB数据表的对象给df，用于后续计算。

>>> df = orca.read_csv(path=DATA_DIR+"/quotes.csv", dtype={"Exchange": "SYMBOL", "SYMBOL": "SYMBOL"}, db_handle=YOUR_DIR + "/demoOnDiskPartitionedDB", table_name="quotes", partition_columns="time")
>>> df
# output
<'dolphindb.orca.core.frame.DataFrame' object representing a column in a DolphinDB segmented table>
>>> df.head()
# output
                        time Exchange Symbol  Bid_Price  Bid_Size  \
0 2017-01-01 04:40:11.686699        T   AAPL       0.00         0   
1 2017-01-01 06:42:50.247631        P   AAPL      26.70        10   
2 2017-01-01 07:00:12.194786        P   AAPL      26.75         5   
3 2017-01-01 07:15:03.578071        P   AAPL      26.70        10   
4 2017-01-01 07:59:39.606882        K   AAPL      26.90         1   
   Offer_Price  Offer_Size  
0        27.42           1  
1        27.47           1  
2        27.47           1  
3        27.47           1  
4         0.00           0

将上述过程整合成的Python中可执行的脚本如下：

>>> s = orca.default_session()
>>> DATA_DIR = "/dolphindb/database" # e.g. data_dir
>>> YOUR_DIR = "/dolphindb/database" # e.g. database_dir
>>> create_onDiskPartitioned_database = """
dbPath="{YOUR_DIR}" + "/demoOnDiskPartitionedDB"
login('admin', '123456')
if(existsDatabase(dbPath))
   dropDatabase(dbPath)
db=database(dbPath, RANGE, datehour(2017.01.01 00:00:00+(0..24)*3600))
""".format(YOUR_DIR=YOUR_DIR)
>>> s.run(create_onDiskPartitioned_database)
>>> df = orca.read_csv(path=DATA_DIR+"/quotes.csv", dtype={"Exchange": "SYMBOL", "SYMBOL": "SYMBOL"}, db_handle=YOUR_DIR + "/demoOnDiskPartitionedDB", table_name="quotes", partition_columns="time")

上述脚本中，我们使用的defalut_session实际上就是通过orca.connect函数创建的会话，在Python端，我们可以通过这个会话与DolphinDB服务端进行交互。关于更多功能，请参见DolphinDB Python API。

请注意：在通过 read_csv函数指定数据库导入数据之前，需要确保在DolphinDB服务器上已经创建了对应的数据库。 read_csv函数根据指定的数据库，表名和分区字段导入数据到DolphinDB数据库中，若表存在则追加数据，若表不存在则创建表并且导入数据。

2.1.3 导入到分布式表

read_csv函数若指定db_handle参数为dfs数据库路径，则数据将直接导入到DolphinDB的dfs数据库中。

示例

请注意只有启用enableDFS=1的集群环境或者DolphinDB单例模式才能使用分布式表。

与磁盘分区表类似，首先需要在DolphinDB服务器上创建分布式表，只需要将数据库路径改为"dfs://"开头的字符串即可。

dbPath="dfs://demoDB"
login('admin', '123456')
if(existsDatabase(dbPath))
   dropDatabase(dbPath)
db=database(dbPath, RANGE, datehour(2017.01.01 00:00:00+(0..24)*3600))

在Python客户端中调用Orca的read_csv函数，指定数据库db_handle为分布式数据库"dfs://demoDB"，指定表名table_name为"quotes"和进行分区的列partition_columns为"time"，将数据导入到DolphinDB的分布式表。

>>> df = orca.read_csv(path=DATA_DIR+"/quotes.csv", dtype={"Exchange": "SYMBOL", "SYMBOL": "SYMBOL"}, db_handle="dfs://demoDB", table_name="quotes", partition_columns="time")
>>> df
# output
<'dolphindb.orca.core.frame.DataFrame' object representing a column in a DolphinDB segmented table>
>>> df.head()
# output
                        time Exchange Symbol  Bid_Price  Bid_Size  \
0 2017-01-01 04:40:11.686699        T   AAPL       0.00         0   
1 2017-01-01 06:42:50.247631        P   AAPL      26.70        10   
2 2017-01-01 07:00:12.194786        P   AAPL      26.75         5   
3 2017-01-01 07:15:03.578071        P   AAPL      26.70        10   
4 2017-01-01 07:59:39.606882        K   AAPL      26.90         1   
   Offer_Price  Offer_Size  
0        27.42           1  
1        27.47           1  
2        27.47           1  
3        27.47           1  
4         0.00           0

将上述过程整合成的Python中可执行的脚本如下：

>>> s = orca.default_session()
>>> DATA_DIR = "/dolphindb/database" # e.g. data_dir
>>> create_dfs_database = """
dbPath="dfs://demoDB"
login('admin', '123456')
if(existsDatabase(dbPath))
   dropDatabase(dbPath)
db=database(dbPath, RANGE, datehour(2017.01.01 00:00:00+(0..24)*3600))
"""
>>> s.run(create_dfs_database)
>>> df = orca.read_csv(path=DATA_DIR+"/quotes.csv", dtype={"Exchange": "SYMBOL", "SYMBOL": "SYMBOL"}, db_handle="dfs://demoDB", table_name="quotes", partition_columns="time")

2.2 read_table函数

Orca提供read_table函数，通过该函数指定DolphinDB数据库和表名来加载DolphinDB数据表的数据，可以用于加载DolphinDB的磁盘表、磁盘分区表和分布式表。若您已在DolphinDB中创建了数据库和表，则可以直接在Orca中调用该函数加载存放在DolphinDB服务端中的数据，read_table函数支持的参数如下:

database：数据库名称
table：表名
partition：需要导入的分区,可选参数

加载DolphinDB的磁盘表

read_table函数可以用于加载DolphinDB的磁盘表，首先在DolphinDB服务端创建一个本地磁盘表：

>>> s = orca.default_session()
>>> YOUR_DIR = "/dolphindb/database" # e.g. database_dir
>>> create_onDisk_database="""
saveTable("{YOUR_DIR}"+"/demoOnDiskDB", table(2017.01.01..2017.01.10 as date, rand(10.0,10) as prices), "quotes")
""".format(YOUR_DIR=YOUR_DIR)
>>> s.run(create_onDisk_database)

通过read_table函数加载磁盘表：

>>> df = orca.read_table(YOUR_DIR + "/demoOnDiskDB", "quotes")
>>> df.head()
# output
      date    prices
0 2017-01-01  8.065677
1 2017-01-02  2.969041
2 2017-01-03  3.688191
3 2017-01-04  4.773723
4 2017-01-05  5.567130

请注意: read_table函数要求所要导入的数据库和表在DolphinDB服务器上已经存在，若只存在数据库和没有创建表，则不能将数据成功导入到Python中。

加载DolphinDB的磁盘分区表

对于已经在DolphinDB上创建的数据表，可以通过read_table函数直接加载。例如，加载2.1.2小节中创建的磁盘分区表：

>>> df = orca.read_table(YOUR_DIR + "/demoOnDiskPartitionedDB", "quotes")

加载DolphinDB的分布式表

分布式表同样可以通过read_table函数加载。例如，加载2.1.3小节中创建的分布式表：

>>> df = orca.read_table("dfs://demoDB", "quotes")

2.3 from_pandas函数

Orca提供from_pandas函数，该函数接受一个pandas的DataFrame作为参数，返回一个Orca的DataFrame，通过这个方式，Orca可以直接加载原先存放在pandas的DataFrame中的数据。

>>> import pandas as pd
>>> import numpy as np

>>> pdf = pd.DataFrame(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),  columns=['a', 'b', 'c'])
>>> odf = orca.from_pandas(pdf)

3 对其它格式文件的支持

对于其它数据格式的导入，Orca也提供了与pandas类似的接口。这些方法包括：read_pickle, read_fwf, read_msgpack, read_clipboard, read_excel, read_json, json_normalize,build_table_schema, read_html, read_hdf, read_feather, read_parquet, read_sas, read_sql_table, read_sql_query, read_sql, read_gbq, read_stata。

Productos secos 丨 Tutorial de carga de datos de Orca

Supongo que te gusta