DolphinDB proporciona un potente motor de cálculo en memoria, función de serie de tiempo incorporada, cálculo distribuido y motor de procesamiento de datos de transmisión, que puede calcular de manera eficiente K-line en muchos escenarios. Este tutorial presentará cómo DolphinDB calcula las velas mediante el procesamiento por lotes y la transmisión.
- Cálculo de lotes de datos históricos K-line
Se puede especificar la hora de inicio de la ventana de velas; puede haber varios períodos de negociación en un día, incluidos períodos nocturnos; las ventanas de velas pueden superponerse; el volumen de transacciones se utiliza como la dimensión para dividir la ventana de velas. Cuando la cantidad de datos que deben leerse es particularmente grande y los resultados deben escribirse en la base de datos, puede utilizar la función Map-Reduce incorporada de DolphinDB para el cálculo paralelo.
- Cálculo de caudal K-line
Utilice la API para recibir datos del mercado en tiempo real y utilice el motor de cálculo de tiempo de transmisión de datos integrado de DolphinDB (TimeSeriesAggregator) para el cálculo en tiempo real para obtener datos de K-line.
1. Cálculo de la línea K de datos históricos
Para el cálculo de la línea K a partir de datos históricos, se puede utilizar de DolphinDB función integrada de la barra , dailyAlignedBar o WJ .
1.1 No especifique la hora de inicio de la ventana de la línea K y genere automáticamente los resultados de la línea K de acuerdo con los datos
bar (X, Y) devuelve el resto de X menos X dividido por Y, generalmente utilizado para agrupar datos.
date = 09:32m 09:33m 09:45m 09:49m 09:56m 09:56m;
bar(date, 5);Se devuelven los siguientes resultados:
[09:30m,09:30m,09:45m,09:45m,09:55m,09:55m]Ejemplo 1: utilice los siguientes datos para simular el mercado de valores de EE. UU.:
n = 1000000
date = take(2019.11.07 2019.11.08, n)
time = (09:30:00.000 + rand(int(6.5*60*60*1000), n)).sort!()
timestamp = concatDateTime(date, time)
price = 100+cumsum(rand(0.02, n)-0.01)
volume = rand(1000, n)
symbol = rand(`AAPL`FB`AMZN`MSFT, n)
trade = table(symbol, date, time, timestamp, price, volume).sortBy!(`symbol`timestamp)
undef(`date`time`timestamp`price`volume`symbol)Calcule la línea K de 5 minutos:
barMinutes = 5
OHLC = select first(price) as open, max(price) as high, min(price) as low, last(price) as close, sum(volume) as volume from trade group by symbol, date, bar(time, barMinutes*60*1000) as barStartTenga en cuenta que en los datos anteriores, la precisión de la columna de tiempo es milisegundos. Si la precisión de la columna de tiempo no es milisegundos, el número en barMinutes * 60 * 1000 debe ajustarse en consecuencia.
1.2 Necesidad de especificar la hora de inicio de la ventana de velas
Necesita especificar la hora de inicio de la ventana de velas, puede usar la dailyAlignedBarfunción. Esta función puede manejar múltiples horas de negociación por día y también puede manejar periodos nocturnos.
Tenga en cuenta que al utilizar la dailyAlignedBarfunción, la columna de hora debe contener información de fecha, incluidos tres tipos de datos: DATETIME, TIMESTAMP o NANOTIMESTAMP. El parámetro timeOffset que especifica la hora de inicio de cada ventana de la sesión de negociación debe utilizar los datos SECOND, TIME o NANOTIME correspondientes después de eliminar la información de la fecha.
Ejemplo 2 (Una sesión de negociación por día): Calcule la línea K de 7 minutos del mercado de valores de EE. UU. Los datos siguen la tabla de operaciones del Ejemplo 1.
barMinutes = 7
OHLC = select first(price) as open, max(price) as high, min(price) as low, last(price) as close, sum(volume) as volume from trade group by symbol, dailyAlignedBar(timestamp, 09:30:00.000, barMinutes*60*1000) as barStartEjemplo 3 (Dos horas de negociación por día): El mercado de valores chino tiene dos horas de negociación por día, de 9:30 a 11:30 de la mañana y de 13:00 a 15:00 de la tarde.
Utilice los siguientes datos para simular:
n = 1000000
date = take(2019.11.07 2019.11.08, n)
time = (09:30:00.000 + rand(2*60*60*1000, n/2)).sort!() join (13:00:00.000 + rand(2*60*60*1000, n/2)).sort!()
timestamp = concatDateTime(date, time)
price = 100+cumsum(rand(0.02, n)-0.01)
volume = rand(1000, n)
symbol = rand(`600519`000001`600000`601766, n)
trade = table(symbol, timestamp, price, volume).sortBy!(`symbol`timestamp)
undef(`date`time`timestamp`price`volume`symbol)Calcule la línea K de 7 minutos:
barMinutes = 7
sessionsStart=09:30:00.000 13:00:00.000
OHLC = select first(price) as open, max(price) as high, min(price) as low, last(price) as close, sum(volume) as volume from trade group by symbol, dailyAlignedBar(timestamp, sessionsStart, barMinutes*60*1000) as barStartEjemplo 4 (dos horas de negociación por día, incluidas las horas nocturnas): algunos futuros tienen varias horas de negociación cada día, incluidas las horas nocturnas. En este ejemplo, el primer período de negociación es de 8:45 a 13:45 de la tarde, y el otro período es un período nocturno, desde las 15:00 de la tarde hasta las 05:00 del día siguiente.
Utilice los siguientes datos para simular:
daySession = 08:45:00.000 : 13:45:00.000
nightSession = 15:00:00.000 : 05:00:00.000
n = 1000000
timestamp = rand(concatDateTime(2019.11.06, daySession[0]) .. concatDateTime(2019.11.08, nightSession[1]), n).sort!()
price = 100+cumsum(rand(0.02, n)-0.01)
volume = rand(1000, n)
symbol = rand(`A120001`A120002`A120003`A120004, n)
trade = select * from table(symbol, timestamp, price, volume) where timestamp.time() between daySession or timestamp.time()>=nightSession[0] or timestamp.time()<nightSession[1] order by symbol, timestamp
undef(`timestamp`price`volume`symbol)Calcule la línea K de 7 minutos:
barMinutes = 7
sessionsStart = [daySession[0], nightSession[0]]
OHLC = select first(price) as open, max(price) as high, min(price) as low, last(price) as close, sum(volume) as volume from trade group by symbol, dailyAlignedBar(timestamp, sessionsStart, barMinutes*60*1000) as barStart1.3 Superposición de ventanas de velas: uso de wjfunciones
En el ejemplo anterior, las ventanas de velas no se superponen. Para calcular la ventana de velas superpuestas, puede utilizar una wjfunción. Con wjfunciones, puede especificar un rango de tiempo relativo para la columna de tiempo en la tabla de la izquierda y realizar cálculos en la tabla de la derecha.
Ejemplo 5 (dos horas de negociación por día, ventanas de línea K superpuestas): Simule los datos del mercado de valores chino y calcule la línea K de 30 minutos cada 5 minutos.
n = 1000000
sampleDate = 2019.11.07
symbols = `600519`000001`600000`601766
trade = table(take(sampleDate, n) as date,
(09:30:00.000 + rand(7200000, n/2)).sort!() join (13:00:00.000 + rand(7200000, n/2)).sort!() as time,
rand(symbols, n) as symbol,
100+cumsum(rand(0.02, n)-0.01) as price,
rand(1000, n) as volume)Primero, genere ventanas basadas en el tiempo y use la combinación cruzada para generar una combinación de acciones y ventanas de negociación.
barWindows = table(symbols as symbol).cj(table((09:30:00.000 + 0..23 * 300000).join(13:00:00.000 + 0..23 * 300000) as time))Luego use la wjfunción para calcular los datos de la línea K de la ventana superpuesta:
OHLC = wj(barWindows, trade, 0:(30*60*1000),
<[first(price) as open, max(price) as high, min(price) as low, last(price) as close, sum(volume) as volume]>, `symbol`time)1.4 Utilice el volumen de operaciones para dividir la ventana de velas
En los ejemplos anteriores, todos usamos el tiempo como dimensión para dividir la ventana de velas. En la práctica, también se pueden utilizar otras dimensiones como base para dividir la ventana de la vela. Por ejemplo, use el volumen de transacciones acumulado para calcular la línea K.
Ejemplo 6 (Dos horas de negociación por día, utilizando el volumen de negociación acumulado para calcular la línea K): Simule los datos del mercado de valores de China y calcule la línea K por cada 10.000 aumentos en el volumen de negociación.
n = 1000000
sampleDate = 2019.11.07
symbols = `600519`000001`600000`601766
trade = table(take(sampleDate, n) as date,
(09:30:00.000 + rand(7200000, n/2)).sort!() join (13:00:00.000 + rand(7200000, n/2)).sort!() as time,
rand(symbols, n) as symbol,
100+cumsum(rand(0.02, n)-0.01) as price,
rand(1000, n) as volume)
volThreshold = 10000
select first(time) as barStart, first(price) as open, max(price) as high, min(price) as low, last(price) as close
from (select symbol, price, cumsum(volume) as cumvol from trade context by symbol)
group by symbol, bar(cumvol, volThreshold) as volBarEl código usa un método de consulta anidado. La subconsulta genera el volumen acumulado de operaciones acumuladas para cada acción y luego utiliza la barfunción para generar una ventana basada en el volumen de operaciones acumulado en la consulta principal .
1.5 Utilice la función MapReduce para acelerar
Si necesita extraer una cantidad relativamente grande de datos históricos de la base de datos, calcular la línea K y luego almacenarla en la base de datos, puede utilizar la función integrada Map-Reduce mr de DolphinDB para leer y calcular los datos. en paralelo. Este método puede aumentar significativamente la velocidad.
Este ejemplo utiliza datos de transacciones con precisión de nanosegundos en el mercado de valores de EE. UU. Los datos originales se almacenan en la tabla "trades" de la base de datos "dfs: // TAQ". La base de datos "dfs: // TAQ" utiliza particiones compuestas: la partición de valor basada en la fecha de la transacción Fecha y la partición de rango basada en el símbolo del código de stock.
(1) Cargue los metadatos de la tabla de datos original almacenada en el disco en la memoria:
login(`admin, `123456)
db = database("dfs://TAQ")
trades = db.loadTable("trades")(2) Cree una tabla de datos vacía en el disco para almacenar los resultados del cálculo. El siguiente código crea una tabla de plantilla (modelo) y crea una tabla OHLC vacía en la base de datos "dfs: // TAQ" de acuerdo con el esquema de esta tabla de plantilla para almacenar los resultados del cálculo de la línea K:
model=select top 1 Symbol, Date, Time.second() as bar, PRICE as open, PRICE as high, PRICE as low, PRICE as close, SIZE as volume from trades where Date=2007.08.01, Symbol=`EBAY
if(existsTable("dfs://TAQ", "OHLC"))
db.dropTable("OHLC")
db.createPartitionedTable(model, `OHLC, `Date`Symbol)(3) Utilice la mrfunción para calcular los datos de la línea K y escriba el resultado en la tabla OHLC:
def calcOHLC(inputTable){
tmp=select first(PRICE) as open, max(PRICE) as high, min(PRICE) as low, last(PRICE) as close, sum(SIZE) as volume from inputTable where Time.second() between 09:30:00 : 15:59:59 group by Symbol, Date, 09:30:00+bar(Time.second()-09:30:00, 5*60) as bar
loadTable("dfs://TAQ", `OHLC).append!(tmp)
return tmp.size()
}
ds = sqlDS(<select Symbol, Date, Time, PRICE, SIZE from trades where Date between 2007.08.01 : 2019.08.01>)
mr(ds, calcOHLC, +)En el código anterior, ds es sqlDSuna serie de fuentes de datos generadas por la función , cada fuente de datos representa los datos extraídos de una partición de datos; la función personalizada calcOHLCes la función de mapa en el algoritmo Map-Reduce, y se calcula la línea K para cada fuente de datos Data, y escribe el resultado en la base de datos, devuelve el número de filas de datos de línea K escritos en la base de datos; "+" es la función de reducción en el algoritmo Map-Reduce, y los resultados de todas las funciones de mapa , es decir, los datos de la línea K escritos en la base de datos. Agregue el número de filas para devolver el número total de datos de la línea K escritos en la base de datos.
2. Cálculo de la línea K en tiempo real
El proceso de cálculo de la línea K en tiempo real en la base de datos DolphinDB se muestra en la siguiente figura:
Diagrama de flujo para calcular la línea K en tiempo real en DolphinDB
Los proveedores de datos en tiempo real generalmente brindan servicios de suscripción de datos basados en API en Python, Java u otros lenguajes comunes. En este ejemplo, Python se usa para simular la recepción de datos del mercado y se escribe en la tabla de datos de transmisión a través de la API de Python de DolphinDB. El motor de agregación de tiempo de transmisión de datos de DolphinDB (TimeSeriesAggregator) puede calcular K-lines para datos en tiempo real a una frecuencia y ventana móvil específicas.
La fuente de datos en tiempo real simulada que se utiliza en este ejemplo es el archivo de texto trades.csv . El archivo contiene las siguientes 4 columnas (se proporciona una fila de datos de muestra juntos):
Las siguientes tres subsecciones presentan los tres pasos del cálculo de velas en tiempo real:
2.1 Use Python para recibir datos en tiempo real y escribirlos en la tabla de datos de flujo de DolphinDB
- Cree una tabla de datos de flujo en DolphinDB
share streamTable(100:0, `Symbol`Datetime`Price`Volume,[SYMBOL,DATETIME,DOUBLE,INT]) as Trade- El programa Python lee datos del archivo trades.csv de la fuente de datos y los escribe en DolphinDB.
La precisión de los datos de Datetime en datos en tiempo real es de segundos. Dado que solo DateTime [64], es decir, el tipo nanatimestamp, se puede usar en pandas DataFrame, el siguiente código tiene un proceso de conversión de tipo de datos antes de escribir. Este proceso también es aplicable a escenarios donde la mayoría de los datos deben limpiarse y convertirse.
import dolphindb as ddb
import pandas as pd
import numpy as np
csv_file = "trades.csv"
csv_data = pd.read_csv(csv_file, dtype={'Symbol':str} )
csv_df = pd.DataFrame(csv_data)
s = ddb.session();
s.connect("127.0.0.1",8848,"admin","123456")
#上传DataFrame到DolphinDB，并对Datetime字段做类型转换
s.upload({"tmpData":csv_df})
s.run("data = select Symbol, datetime(Datetime) as Datetime, Price, Volume from tmpData")
s.run("tableInsert(Trade,data)")2.2 Cálculo en tiempo real de la línea K
En este ejemplo, la createTimeSeriesAggregatorfunción del motor de agregación de series de tiempo se usa para calcular los datos de la línea K en tiempo real, y el resultado del cálculo se envía a la tabla de datos de flujo OHLC.
El cálculo en tiempo real de los datos de la línea K se puede dividir en las dos situaciones siguientes de acuerdo con diferentes escenarios de aplicación:
- Solo desencadenar cálculos al final de cada ventana de tiempo
- Las ventanas de tiempo no se superponen en absoluto, por ejemplo, calcule los datos de la línea K de los últimos 5 minutos cada 5 minutos
- Las ventanas de tiempo se superponen parcialmente, por ejemplo, los datos de la línea K de los últimos 5 minutos se calculan cada 1 minuto
- El cálculo se activa al final de cada ventana de tiempo, y los datos de cada ventana de tiempo se actualizarán
con una frecuencia determinada. Por ejemplo, los datos de la línea K del último minuto se calculan cada minuto, pero la K- La línea del último minuto no quiere esperar hasta el final de la ventana Calcular más tarde. Espero actualizar cada 1 segundo
A continuación se describe cómo utilizar createTimeSeriesAggregatorfunciones para calcular los datos de la línea K en tiempo real para las situaciones mencionadas anteriormente . Seleccione el escenario correspondiente para crear un motor de agregación de series de tiempo de acuerdo con las necesidades reales.
2.2.1 Solo desencadenar cálculos al final de cada ventana de tiempo
Solo cuando el cálculo se activa al final de cada ventana de tiempo, se puede dividir en dos escenarios: la ventana de tiempo no se superpone completamente y la ventana de tiempo se superpone parcialmente. Estas dos situaciones se pueden lograr configurando createTimeSeriesAggregatorlos parámetros windowSize y step de la función. La siguiente es una descripción específica.
Primero defina la tabla de salida:
share streamTable(100:0, `datetime`symbol`open`high`low`close`volume,[DATETIME, SYMBOL, DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG]) as OHLCLuego, de acuerdo con los diferentes escenarios de uso, elija cualquiera de los siguientes escenarios para crear un motor de agregación de series de tiempo.
Escenario 1: Calcule los datos de la línea K de los últimos 5 minutos cada 5 minutos, use el siguiente script para definir el motor de agregación de tiempos, donde el valor del parámetro windowSize es igual al valor del parámetro step
tsAggrKline = createTimeSeriesAggregator(name="aggr_kline", windowSize=300, step=300, metrics=<[first(Price),max(Price),min(Price),last(Price),sum(volume)]>, dummyTable=Trade, outputTable=OHLC, timeColumn=`Datetime, keyColumn=`Symbol)Escenario 2: Calcule los datos de la línea K de los últimos 5 minutos cada 1 minuto. Puede usar el siguiente script para definir el motor de agregación de tiempos. Entre ellos, el valor del parámetro windowSize es un múltiplo del valor del parámetro step
tsAggrKline = createTimeSeriesAggregator(name="aggr_kline", windowSize=300, step=60, metrics=<[first(Price),max(Price),min(Price),last(Price),sum(volume)]>, dummyTable=Trade, outputTable=OHLC, timeColumn=`Datetime, keyColumn=`Symbol)Finalmente, defina la suscripción de transmisión de datos. Si se han escrito datos en tiempo real en la tabla de datos de transmisión Trade en este momento, los datos en tiempo real se suscribirán inmediatamente y se inyectarán en el motor de agregación:
subscribeTable(tableName="Trade", actionName="act_tsaggr", offset=0, handler=append!{tsAggrKline}, msgAsTable=true)Las primeras 5 filas de datos en la tabla de salida del escenario 1:
2.2.2 El cálculo se activa al final de cada ventana de tiempo y los resultados del cálculo se actualizan con una cierta frecuencia.
Tome el cálculo del precio de vwap con un tiempo de ventana de 1 minuto como ejemplo. Después de que el resultado de la agregación se actualice a las 10:00, la próxima actualización debe ser al menos a las 10:01. De acuerdo con las reglas de cálculo, incluso si hay muchas transacciones en este minuto, no se activará ningún cálculo. Esto es inaceptable en muchos escenarios de transacciones financieras, y se espera actualizar la información con mayor frecuencia, por lo que se introduce el parámetro updateTime del motor de agregación de tiempos .
El parámetro updateTime indica el intervalo de tiempo para el cálculo. Si no se especifica updateTime, el motor de agregación de series de tiempo activará un cálculo solo al final de cada ventana de tiempo. Pero si se especifica updateTime, el cálculo se activará en los siguientes tres casos:
- Al final de cada ventana de tiempo, el motor de agregación de series de tiempo activará un cálculo
- Cada vez que updateTime unidades de tiempo, el motor de agregación de series de tiempo activará un cálculo
- Si los datos ingresan más de 2 * updateTime unidades de tiempo (si 2 * updateTime es menos de 2 segundos, establecido en 2 segundos), todavía hay datos sin calcular en la ventana actual y el motor de agregación de series de tiempo activará un cálculo
De esta manera, se puede garantizar que el motor de agregación de tiempos pueda finalizar el cálculo de activación en cada ventana de tiempo y, al mismo tiempo, el cálculo se activará a una cierta frecuencia dentro de cada ventana de tiempo.
Cabe señalar que el motor de agregación de tiempos requiere que cuando se usa el parámetro updateTime, se debe usar keyedTable como tabla de salida. Las razones específicas son las siguientes:
- Si la tabla ordinaria o streamTable se utiliza como tabla de salida, la
tabla y streamTable no restringirán la escritura de datos repetidos. Por lo tanto, cuando los datos cumplen la condición de activación de updateTime pero aún no cumplen la condición de paso de activación, la agregación de tiempo El motor continuará generando la tabla. Agregando el resultado del cálculo del mismo tiempo, la tabla de salida final tendrá una gran cantidad de registros con el mismo tiempo, este resultado no tiene sentido. - Si keyedStreamTable se usa como tabla de salida,
keyedStreamTable no puede actualizar los registros del historial ni agregar registros con el mismo valor de clave a la tabla. Al agregar un nuevo registro a la tabla, el sistema verificará automáticamente el valor de la clave principal del nuevo registro. Si el valor de la clave principal del nuevo registro es el mismo que el valor de la clave principal del registro existente, el nuevo registro no ser escrito. El resultado del rendimiento en este escenario es que cuando los datos aún no han cumplido las condiciones para activar el paso, pero cuando se cumplen las condiciones para activar updateTime, el motor de agregación de tiempos escribe los resultados del cálculo de la ventana más reciente en la tabla de salida, pero se prohíbe escribir porque la hora es la misma Enter, el parámetro updateTIme también pierde su significado. - Use keyedTable como la tabla de salida
keyedTable permite la actualización. Al agregar un nuevo registro a la tabla, el sistema verificará automáticamente el valor de la clave principal del nuevo registro. Si el valor de la clave principal del nuevo registro es el mismo que el valor de la clave principal del registro existente, se actualizará la tabla El registro correspondiente. El resultado del rendimiento en este escenario es que el resultado del cálculo puede actualizarse al mismo tiempo. Cuando los datos aún no han cumplido la condición del paso de activación, pero se cumple la condición de activación de updateTime, el resultado del cálculo se modificará al resultado del cálculo basado en los datos de la ventana más reciente en lugar de agregar un nuevo registro a la tabla de salida. Hasta que los datos cumplan las condiciones que desencadenan el paso, se agregará un nuevo registro a la tabla de salida. Y este resultado es lo que esperamos lograr, por lo que el motor de agregación de tiempo requiere que cuando se usa el parámetro updateTime, debe usar keyedTable como tabla de salida.
Por ejemplo, desea calcular la línea K con una ventana de 1 minuto, pero no desea esperar hasta que termine la ventana para calcular la línea K con el último minuto. Espero actualizar los datos de la línea K durante casi 1 minuto cada 1 segundo. Podemos implementar este escenario a través de los siguientes pasos.
Primero, necesitamos crear una keyedTable como la tabla de salida, y usar la columna de tiempo y la columna de código de inventario como clave principal. Cuando se inyectan nuevos datos en la tabla de salida, si la hora del nuevo registro ya existe en la tabla, se actualizará el registro de la hora correspondiente en la tabla. Esto asegurará que los datos en cada momento de cada consulta sean los más recientes.
share keyedTable(`datetime`Symbol, 100:0, `datetime`Symbol`open`high`low`close`volume,[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG]) as OHLCNota: cuando se usa el motor de agregación de series temporales, keyedTable se usa como la tabla de salida. Si el motor de agregación de series temporales especifica el parámetro keyColumn, kyedTable debe usar la columna relacionada con el tiempo y la columna keyColumn como clave principal en el Mismo tiempo.
Calcule los datos de la línea K durante el último minuto cada 1 minuto y actualice los datos de la línea K durante casi 1 minuto cada segundo. Puede utilizar el siguiente script para definir el motor de agregación de tiempos. Entre ellos, el valor del parámetro windowSize es igual al valor del parámetro step, y el parámetro updateTime se especifica en 1 segundo, es decir, el último minuto de datos se actualiza cada 1 segundo. El parámetro useWindowStartTime en el siguiente ejemplo se usa para especificar la hora en la tabla de salida como la hora de inicio de la ventana de datos.
tsAggrKline = createTimeSeriesAggregator(name="aggr_kline", windowSize=60, step=60, metrics=<[first(Price),max(Price),min(Price),last(Price),sum(volume)]>, dummyTable=Trade, outputTable=OHLC, timeColumn=`Datetime, keyColumn=`Symbol,updateTime=1, useWindowStartTime=true)Tenga en cuenta que cuando se utiliza el motor de agregación de series de tiempo, windowSize debe ser un múltiplo entero de step y step debe ser un múltiplo entero de updateTime.
Finalmente, defina la suscripción de transmisión de datos. Si se han escrito datos en tiempo real en la tabla de datos de transmisión Trade en este momento, los datos en tiempo real se suscribirán inmediatamente y se inyectarán en el motor de agregación:
subscribeTable(tableName="Trade", actionName="act_tsaggr", offset=0, handler=append!{tsAggrKline}, msgAsTable=true)Las primeras 5 filas de datos en la tabla de salida:
2.3 Mostrar datos de K-line en Python
En este ejemplo, la tabla de salida del motor de agregación también se define como una tabla de datos de flujo. El cliente puede suscribirse a la tabla de salida a través de la API de Python y mostrar el resultado del cálculo en la terminal de Python.
El siguiente código usa la API de Python para suscribirse a la tabla de resultados de salida de cálculo de agregación en tiempo real OHLC e printimprimir el resultado a través de la función.
import dolphindb as ddb
import pandas as pd
import numpy as np
#设定本地端口20001用于订阅流数据
s.enableStreaming(20001)
def handler(lst):
print(lst)
# 订阅DolphinDB(本机8848端口)上的OHLC流数据表
s.subscribe("127.0.0.1", 8848, handler, "OHLC")Además, el sistema de visualización de base de datos DolphinDB conectado a Grafana y similares, la tabla de salida y los resultados de la consulta en un gráfico para mostrar.