Informe Tcnico

Trabajar con Datos de Forex

con SQLite y R
Versin 1.1

(c) 2012 Entropy Computational Services SLU

www.entropycs.com
Tabla de Contenidos
1 Introduccin.......................................................................................................................................2
2 Preparacin de los Datos...................................................................................................................3
2.1 Creacin de la Tabla de Datos...................................................................................................3
2.2 Importar los Datos......................................................................................................................4
2.2.1 Datos de Forex Tester........................................................................................................4
2.2.2 Datos de MetaTrader 4.......................................................................................................5
2.2.3 Importar los Datos..............................................................................................................5
3 Trabajar con los Datos.......................................................................................................................6
3.1 Introduccin a SQL....................................................................................................................6
3.2 Consultas Bsicas......................................................................................................................7
3.3 Consultas Avanzadas.................................................................................................................8
4 Optimizacin de las Consultas........................................................................................................10
4.1 Optimizacin con el Tiempo Unix...........................................................................................10
4.2 Otras Optimizaciones...............................................................................................................11
5 Bsqueda de Huecos........................................................................................................................12
6 Integracin de SQLite y R...............................................................................................................14
7 Utilidad de Acceso...........................................................................................................................15

Datos de Forex con SQLite y R

Introduccin

1 Introduccin
El entorno R es extremadamente rpido analizando datos siempre y cuando estos quepan en la
memoria de nuestro ordenador, pero si esto no es as, el rendimiento de R se puede degradar
hasta niveles inaceptables. Existen mltiples soluciones a este problema, como los paquetes
bigMemory1 o ff2, que nos permiten trabajar con grandes volmenes de datos. Sin embargo, para
el caso de anlisis de datos de Forex, se nos da la situacin de que aunque hay que analizar un
gran volumen de datos, es rara la situacin en la que necesitemos tener cargados en memoria la
totalidad de los datos. Es decir, que podemos ir cargando y descargando los datos segn los
vayamos necesitando.
Para este tipo de casos una solucin ms conveniente podra ser utilizar una base de datos
externa, en la que almacenamos la totalidad de los datos, y a continuacin, desde R, los vamos
consultando segn los vayamos necesitando para nuestro anlisis.
En este Informe Tcnico vamos a aprender cmo se pueden analizar grandes volmenes de datos
desde R con la ayuda de SQLite3. Esto nos ser de gran ayuda a la hora de analizar y optimizar
estrategias de trading.
SQLite es un sistema gestor de bases de datos relacionales muy popular y ampliamente utilizado
(de hecho, Bloomberg es uno de sus patrocinadores). SQLite es una librera que se distribuye de
manera gratuita, y cuyo cdigo fuente est disponible para su integracin en otros programas.
SQLite no necesita de ningn tipo de configuracin o de mantenimiento, y actualmente est
siendo utilizada para gestionar bases de datos de varios gigabytes (suficiente para trabajar con
barras de 1 minuto, aunque quizs se quede algo corta para trabajar con datos tick a tick).

1 http://www.bigmemory.org
2 http://ff.r-forge.r-project.org
3 Http://www.sqlite.og

2 Datos de Forex con SQLite y R

 Preparacin de los Datos

2 Preparacin de los Datos

En esta primera parte del documento vamos a preparar el entorno SQLite que nos permitir
trabajar con los datos Forex, y vamos a ver cmo podemos importar los datos histricos en la
base de datos.

2.1 Creacin de la Tabla de Datos

Lo primero que vamos a hacer es crear una tabla que permita almacenar los datos histricos,
en barras de un minuto, para, por ejemplo, el cambio de divisas EUR/USD. Esta tabla
almacena la fecha y hora de cada barra en formato texto (campo date), y los valores que se han
dado en esa barra (apertura, mximo, mnimo y cierre) como nmeros con decimales.
Tambin contiene el capo unix, que es la misma fecha que contiene el campo date, pero en
formato tiempo de unix (que cuenta el nmero de segundos que han transcurrido desde el 1 de
Enero de 1970). El campo unix, desde un punto de vista formal, es redundante y debera ser
eliminado. Sin embargo, y como veremos ms adelante, nos va a venir muy bien para mejorar
el rendimiento de nuestras consultas.
Utilizando el editor de comandos de sqlite creamos un fichero de datos para el smbolo
EURUSD:

sqlite3 eurusd.db

y a continuacin creamos la tabla con:

CREATE TABLE eurusd (

date TEXT NOT NULL PRIMARY KEY,
unix INTEGER NOT NULL,
open REAL NOT NULL,
high REAL NOT NULL,
low REAL NOT NULL,
close REAL NOT NULL
);

Nuevamente, desde un punto de vista formal hubiera sido ms correcto crear una nica tabla
para almacenar los datos de todos los smbolos, pero por cuestiones de rendimiento, tenemos
que optar por crear un nico fichero que contiene una nica tabla para cada uno de los
smbolos con los que queramos trabajar.

Datos de Forex con SQLite y R

Preparacin de los Datos

2.2 Importar los Datos

En esta seccin vamos a ver cmo se pueden importar los datos histricos en la base de datos
SQLite. La importacin de los datos requiere un pre-procesamiento previo de los mismos, que
puede variar de una plataforma a otra. En este caso vamos a ver dos ejemplos concretos de
formato, y cmo se pueden transformar en un formato que pueda ser entendido por SQLite.

2.2.1 Datos de Forex Tester

Para el primer ejemplo vamos a utilizar los datos histricos proporcionados
gratuitamente por Forex Tester1. Estos datos tienen una calidad ms que suficiente para
nuestros anlisis. De hecho, tienen una calidad mucho mayor que los datos
proporcionados por la mayora de los brokers.
Si abrimos el fichero (una vez descomprimido) vemos que el formato en el que vienen
los datos de las barras es el siguiente:

<TICKER>,<DTYYYYMMDD>,<TIME>,<OPEN>,<HIGH>,<LOW>,<CLOSE>,<VOL>
EURUSD,20010102,230100,0.9507,0.9507,0.9507,0.9507,4
EURUSD,20010102,230200,0.9506,0.9506,0.9505,0.9505,4
EURUSD,20010102,230300,0.9505,0.9507,0.9505,0.9506,4
...

Este formato no es el que SQLite espera, por lo que hay que hacer un pre-procesamiento
del mismo. Aqu nos encontramos con el problema de que necesitamos un editor de
textos que sea lo suficientemente potente como para poder cargar este fichero de datos
en memoria, y que sea lo suficientemente verstil para permitir hacer cambios
complejos en el mismo. En el mundo Linux tenemos el editor vi que cumple ambas
funciones (existe una versin para Windows de este editor de textos llamada Vim).
Alternativamente, aquellos que tengan conocimientos de programacin pueden escribir
un pequeo script en Perl, Python, TCL o similar, que haga la tarea.
As que editamos el fichero con vi, borramos la primera lnea y escribimos la siguiente
orden:

:1,$s/\w\{6},\(\d\{4}\)\(\d\{2}\)\(\d\{2}\),\(\d\{2}\)\(\d\{2}\)\(\d\
{2}\),\(.*\),\d$/\1-\2-\3 \4:\5,0,\7/

Grabamos el resultado como EURUSD.cvs, y comprobamos que el fichero tiene ahora

el formato deseado (el indicado por la tabla que hemos creado):

2001-01-02 23:01,0,0.9507,0.9507,0.9507,0.9507

1 http://www.forextester.com/data/datasources.html

4 Datos de Forex con SQLite y R

 Preparacin de los Datos

2.2.2 Datos de MetaTrader 4

En el caso de trabajar con la plataforma MetaTrader, el procedimiento de importacin
de datos es similar. Lo que tendramos que hacer es irnos al "centro de historiales" y
exportamos los datos con granularidad de 1 minuto del smbolo que queramos y en
formato CSV (valores separados por comas). El fichero exportado tendr el siguiente
formato:

1971.01.27,00:00,0.5386,0.5386,0.5386,0.5386,1

y para convertirlo con el editor vi escribimos:

:1,$s/\(\d\{4}\)\.\(\d\{2}\)\.\(\d\{2}\),\(\d\{2}:\d\{2}\),\(.*\),\d\
{1,5}$/\1-\2-\3 \4,0,\5/

Grabamos el resultado y ya tendramos el fichero en el formato adecuado.

2.2.3 Importar los Datos

Una vez que tenemos el fichero de datos en el formato adecuado, el siguiente paso es
abrir SQLite y escribir:

.mode csv
.import EURUSD.csv eurusd

Esto nos importa la totalidad de los datos de las barras en nuestra tabla. Tan slo nos
quedara corregir el campo de tiempo en formato unix, y para ello escribimos:

UPDATE eurusd SET unix = CAST(STRFTIME('%s', date) AS INTEGER);

Y con esto ya tendramos completamente cargados los datos en la base de datos.

Datos de Forex con SQLite y R

Trabajar con los Datos

3 Trabajar con los Datos

En el apartado anterio vimos como crear una tabla para almacenar los datos histricos del cambio
euro / dlar. En este apartado vamos a empezar a trabajar con estos datos.

3.1 Introduccin a SQL

En primera seccin vamos a ver una muy breve introduccin al lenguaje de consulta de bases
de datos SQL, que es el lenguaje que, como era de esperar, utiliza la base de datos SQLite.
Lo primero que vamos a hacer es darle algo de formato a la salida que nos proporciona el
intrprete de SQLite para que sea algo ms legible, para ello escribimos:

.echo on
.mode column
.headers on
.nullvalue NULL

Bsicamente, lo que le hemos dicho a SQLite es que queremos ver los datos formateados por
columnas, y con una cabecera de tabla.
Para mostrar todos los elementos contenidos en la base de datos (que recomiendo no hacer
porque llevara un rato largo visualizarlos, ya que son muchos) se hara:

SELECT * FROM eurusd;

Para contar el nmero de barras almacenadas en la base de datos escribimos:

SELECT count(*) FROM eurusd;

que por cierto, debe coincidir con el nmero de lneas del fichero CSV desde el que hemos
importado los datos, y que se pueden contar con la orden Unix:

wc -l EURUSD.csv

Para insertar una nueva barra se hara con:

INSERT INTO eurusd (date, unix, open, high, low, close) VALUES (
'2011-11-01 00:01:00', 0, '1.1212', '1.2323', '1.3434', '1.4545');

6 Datos de Forex con SQLite y R

 Trabajar con los Datos

Que a su vez se puede borrar con:

DELETE FROM eurusd WHERE date = '2011-11-01 00:01:00';

Finalmente, podemos consultar los datos de cualquier barra con una orden como:

SELECT * FROM eurusd WHERE date = "2001-01-05 02:26";

3.2 Consultas Bsicas

En esta seccin vamos a empezar a ver la potencia de almacenar los datos Forex en una base
de datos relacional. Por ejemplo, si queremos ver el mximo y el mnimo alcanzado en cada
mes escribimos:

SELECT MAX(high) AS High, MIN(low) as Low,

STRFTIME("%Y-%m", date) as Month
FROM eurusd
WHERE date > '2010-01-01' AND date < '2011-01-01'
GROUP BY STRFTIME("%Y-%m", date);

Si queremos ver el mximo y mnimo alcanzado cada da:

SELECT MAX(high) AS High, MIN(low) as Low,

STRFTIME("%Y-%m-%d", date) as Date
FROM eurusd
WHERE date > '2010-01-01' AND date < '2011-01-01'
GROUP BY STRFTIME("%Y-%m-%d", date);

Si queremos ver el mximo y mnimo alcanzado durante un periodo cualquiera de tiempo, por
ejemplo 40 minutos, hacemos:

SELECT high, low FROM eurusd WHERE date >= "2001-01-05 02:00" AND date <=
"2001-01-05 02:40";

Y finalmente, si queremos ver el precio de apertura en barras diarias, haramos:

SELECT open, date FROM eurusd WHERE date IN

Datos de Forex con SQLite y R

Trabajar con los Datos

(SELECT MIN(date)
FROM eurusd
WHERE date > '2010-01-01' AND date < '2011-01-01'
GROUP BY STRFTIME("%Y-%m-%d", date));

3.3 Consultas Avanzadas

En esta seccin vamos a ver es cmo hacer otras consultas SQL ms avanzadas, y ms tiles
para nuestros propsitos.
Si por ejemplo queremos ver el mximo y el mnimo de barras de 8 minutos (s, s, de 8
minutos), podemos hacer:

SELECT MAX(high) AS High, MIN(low) as Low, date as Date

FROM eurusd
WHERE date > '2010-01-01' AND date < '2011-01-01'
GROUP BY round(STRFTIME('%s', date) / (8 * 60));

Es decir, podemos agrupar los datos en barras de cualquier longitud, y no slo las longitudes
estndar de 5 minutos, 15 minutos, 1 hora, etc. que ofrecen la mayora de las plataformas de
trading.
Uniendo el ejemplo anterior con las consultas de apertura, mximo, mnimo y cierre de la
seccin anterior, lo que podemos conseguir es agrupar nuestros datos sobre barras de
cualquier longitud. Esto nos permite hacer trading en barras de longitudes no convencionales,
lo que nos puede suponer una importante ventaja sobre otros traders. Adems, tambin
podemos identificar mejor el tamao de barra ptimo para nuestras estrategias de trading,
optimizndolas para cada una las longitudes de barra, desde 1 minuto, hasta valores como
1440 minutos (1 da).
Por ejemplo, para ver los datos agrupados en barras de 13 minutos utilizamos:

SELECT STRFTIME('%Y-%m-%d %H %M', MIN(date)) as Date,

MAX(CASE WHEN STRFTIME('%s', date) % (13 * 60) = 0 THEN open ELSE 0
END) AS Open,
MAX(high) as High,
MIN(low) as Low,
MAX(CASE WHEN STRFTIME('%s', date) % (13 * 60) = 4 * 60 THEN close ELSE
0 END) AS Close
FROM eurusd
WHERE date > '2010-01-01' AND date < '2011-01-01'
GROUP BY STRFTIME('%s', date) / (13 * 60);

8 Datos de Forex con SQLite y R

 Trabajar con los Datos

Desgraciadamente esta consulta slo funciona si nuestros datos no tienen huecos, lo cual no
siempre se cumple. Para conseguir el mismo resultado pero con datos que potencialmente
pueden tener huecos, tendramos que utilizar otra consulta algo ms compleja:

SELECT STRFTIME('%Y-%m-%d %H %M', MIN(date)) AS Date,

(SELECT open from eurusd e2
where CAST(STRFTIME('%s', e2.date) AS INTEGER) >=
CAST(STRFTIME('%s', e1.date) AS INTEGER) / (13 * 60) * 13 * 60
order by e2.date asc limit 1) AS Open,
MAX(high) as High,
MIN(low) as Low,
(SELECT close from eurusd e3
where CAST(STRFTIME('%s', e3.date) AS INTEGER) <
(CAST(STRFTIME('%s', e1.date) AS INTEGER) / (13 * 60) + 1) * 13 *
60
order by e3.date desc limit 1) AS Close
FROM eurusd e1
WHERE date > '2010-01-01' AND date < '2011-01-01'
GROUP BY CAST(STRFTIME('%s', e1.date) / (13 * 60) AS INTEGER);

Sin embargo, el lector habr notado que el tiempo de respuesta de esta ltima consulta es
demasiado elevado. Esto puede crear ciertos problemas en operativa real para estrategias que
trabajen en barras muy cortas (de por ejemplo un minuto), y sobre todo, cuando queramos
realizar anlisis de tipo walk forward, que requieren de mltiples consultas.
Pero aqu es donde entra en juego las optimizaciones que permite SQLite, y sobre todo, ese
misterioso atributo unix de nuestra tabla, y que veremos en la siguiente seccin.

Datos de Forex con SQLite y R

Optimizacin de las Consultas

4 Optimizacin de las Consultas

En este apartado vamos a estudiar cmo podemos mejorar el rendimiento de las consultas SQL
vistas hasta ahora para poder aplicarlas en entornos de produccin.

4.1 Optimizacin con el Tiempo Unix

Para poder mejorar el rendimiento utilizando el atributo unix, lo primero que tenemos que
hacer es crear un ndice sobre esta columna:

CREATE INDEX unix_index ON eurusd (unix);

Y a continuacin veamos cmo podemos consultar el mximo y el mnimo en barras de 8

minutos utilizando este nuevo campo:

SELECT MAX(high) AS High, MIN(low) as Low, date as Date

FROM eurusd
WHERE date > '2010-01-01' AND date < '2011-01-01'
GROUP BY round(unix / (8 * 60));

Y de igual manera se podran consultar los precios de apertura y de cierre.

En este momento ya tenemos todo lo que necesitamos para crear barras de cualquier longitud,
para cualquier periodo de tiempo, y de una manera eficiente. La consulta final para barras de 8
minutos (8*60=480) sera:

SELECT STRFTIME('%Y-%m-%d %H %M', MIN(date)) AS Date,

(SELECT open FROM eurusd e2
WHERE e2.unix >= e1.unix / 480 * 480
ORDER BY e2.unix ASC LIMIT 1) AS Open,
MAX(high) as High,
MIN(low) as Low,
(SELECT close FROM eurusd e3
WHERE e3.unix < (e1.unix / 480 + 1) * 480
ORDER BY e3.unix DESC LIMIT 1) AS Close
FROM eurusd e1
WHERE date > '2010-01-01' AND date < '2011-01-01'
GROUP BY e1.unix / 480;

10 Datos de Forex con SQLite y R

 Optimizacin de las Consultas

4.2 Otras Optimizaciones

Estas consultas se pueden optimizar aun ms, pero para ello habra que entrar a programar
directamente en el API C de SQLite, un API que nos permite extender la funcionalidad del
lenguaje SQL. SQLite dispone de las funciones agregadas MAX y MIN que nos permiten
calcular el mximo y el mnimo alcanzado en una barra, pero no dispone de nada equivalente
para calcular los precios de apertura y cierre de dicha barra. Es por ello que tenemos que
realizar complejas sub-queries que nos retrasan mucho todo el proceso. Este problema se
podra solucionar creando nuestras propias funciones agregadas OPEN y CLOSE utilizando el
mencionado API de SQLite.

Datos de Forex con SQLite y R

Bsqueda de Huecos

5 Bsqueda de Huecos
Como hemos mencionado anteriormente, cargar los datos histricos de forex en una base de
datos relacional tiene ciertas ventajas a la hora de proceder a su anlisis. En esta seccin vamos a
estudiar una de esas ventajas, en concreto, cmo la base de datos nos puede ayudar a la hora de
buscar huecos en los datos histricos.
Todos los ficheros de datos histricos tienen huecos. A veces, incluso, nos podemos encontrar
con saltos que comprenden varios das, y que pueden llegar a resultar muy peligrosos, porque
pueden distorsionar de forma importante nuestro anlisis. Por tanto, es importante conocer la
calidad de los datos que estamos utilizando en nuestros back-tests.
Si queremos conocer el nmero de huecos de una determinada longitud que existen en el
histrico de datos, escribiremos:

SELECT count(*), ((SELECT MIN(e2.unix) FROM eurusd e2 WHERE e2.unix > e1.unix) -
e1.unix - 60) / 60 as minutes
FROM eurusd e1 WHERE minutes = 1

donde 'minutes' es la longitud en minutos del hueco que estamos analizando. Tambin podramos
ver concretamente en qu fecha y hora se producen dichos huecos, para ello escribiramos:

SELECT DATETIME(e1.date, '+1 minutes') AS start_date,

DATETIME((SELECT MIN(e2.date) FROM eurusd e2 WHERE e2.date > e1.date), '-
1 minutes') AS end_date,
((SELECT MIN(e2.unix) FROM eurusd e2 WHERE e2.unix > e1.unix) - e1.unix -
60) / 60 as minutes
FROM eurusd e1 WHERE minutes = 1

o si lo que queremos es sacar una tabla que nos indique para cada longitud de hueco el nmero
de ellos que hay, escribiramos:

SELECT count(*), ((SELECT MIN(e2.unix) FROM eurusd e2 WHERE e2.unix >

e1.unix) - e1.unix - 60) / 60 as minutes
FROM eurusd e1 GROUP BY minutes

Finalmente, a modo de ejemplo voy a mostrar los resultados de un anlisis comparativo realizado
sobre dos histricos de datos, uno de ellos descargado desde la pgina web de Forex Tester, y el
segundo utilizando el Centro de Historiales de la herramienta MetaTrader y a travs del broker
XTB.

12 Datos de Forex con SQLite y R

 Bsqueda de Huecos

El siguiente grfico muestra para cada longitud de hueco desde 1 a 30 minutos el nmero de
huecos encontrados:

Como se puede observar, el nmero de huecos de longitudes 1, 2, 3 y 4 es tremendamente

grande, del orden de 3 huecos al da para XTB, y de 4 para Forex Tester. Este hecho debera ser
tenido en cuenta por todos aquellos que utilizan sistemas automticos que trabajan sobre barras
de un minuto, sobre todo si se basan en optimizaciones y back-tests de los mismos.

Datos de Forex con SQLite y R

Integracin de SQLite y R

6 Integracin de SQLite y R
En este apartado vamos a ver cmo podemos acceder a los datos almacenados en nuestras bases
de datos SQLite desde R. Para ello vamos a utilizar el paquete DBI de R. DBI es un paquete que
permite acceder de manera unificada a diferentes bases de datos, entre ellas Oracle, MySQL, y
SQLite. Cada base de datos cuenta con su propia librera que debe ser previamente cargada en R:

library(DBI)
library(RSQLite)

A continuacin abrimos una conexin con la base de datos. Para ello primero tenemos que crear
un driver que nos gestione la conexin, y despus abrir la conexin propiamente dicha con el
fichero donde se encuentre la base de datos:

drv <- dbDriver(SQLite)

db <- dbConnect(drv, eurusd.db)

En este momento podemos enviar nuestras consultas SQL a la base de datos, como por ejemplo:

rs <- dbSendQuery(db, SELECT MAX(high) AS High, MIN(low) as Low, date as

Date FROM eurusd WHERE date > '2010-01-01' AND date < '2011-01-01' GROUP BY
round(unix / (8 * 60)))

Para recuperar los datos tenemos que utilizar la funcin fetch(), a la que le debemos indicar
cuantas barras queremos recuperar, o -1 para recuperar la totalidad:

EURUSD <- fetch(rs, n=25)

En este momento la variable EURUSD contiene los datos listos para ser analizados.
Cuando no necesitemos recuperar ms datos de la consulta, debemos liberar esta con:

dbClearResult(rs)

Y finalmente, para cerrar la conexin con la base de datos hacemos:

dbDisconnect(db)

14 Datos de Forex con SQLite y R

 Utilidad de Acceso

7 Utilidad de Acceso
En este ltimo apartado vamos a agrupar todo lo visto hasta ahora en una nica funcin R, que
nos podr de ser de gran ayuda en nuestros propios anlisis de datos de Forex.
La funcin, llamada symbolQuery, abre la base de datos que contiene los datos Forex, consulta el
rango de datos que le hayamos proporcionado, y nos retorna un objeto tipo xts con los resultados.
La funcin recibe los siguientes parmetros:
symbol: el smbolo que queremos consultar, que debe coincidir con el nombre del
fichero que contiene la base de datos (sin la extensin .db), y adems, debe coincidir con
el nombre de la tabla dentro de dicha base de datos.
from: da y hora desde la que queremos recuperar datos, en el formato YYYY-MM-DD
HH:MM
to: da y hora hasta la que queremos recuperar datos, igualmente en el formato YYYY-
MM-DD HH:MM
minutes: el tamao de la barra deseado, en minutos.
Por ejemplo, para recuperar un ao de datos del cambio EUR/USD en barras de 48 minutos
escribiramos:

datos <- symbolQuery(eurusd, 2010-01-01, 2011-01-01, 48)

El cdigo de la funcin es el siguiente:

symbolQuery <- function(symbol, from, to, minutes) {

library("xts")
library("DBI")
library("RSQLite")

# Abre una conexion con SQLite

drv <- dbDriver("SQLite")
db <- dbConnect(drv, paste(symbol, ".db", sep=""))

# Construimos la consulta
sec <- minutes * 60
sql <- paste("SELECT STRFTIME('%Y-%m-%d %H %M', MIN(date)) AS Date, ",
"(SELECT open FROM ", symbol, " e2 ",
"WHERE e2.unix >= e1.unix / ", sec, " * ", sec, " ",
"ORDER BY e2.unix ASC LIMIT 1) AS Open, ",

Datos de Forex con SQLite y R

Utilidad de Acceso

"MAX(high) as High, ",

"MIN(low) as Low, ",
"(SELECT close FROM ", symbol, " e3 ",
"WHERE e3.unix < (e1.unix / ", sec, " + 1) * ", sec, " ",
"ORDER BY e3.unix DESC LIMIT 1) AS Close ",
"FROM ", symbol, " e1 ",
"WHERE date > '", from, "' AND date < '", to, "' ",
"GROUP BY e1.unix / ", sec, sep = "")

# Enviamos la consulta y recuperamos el resultado

rs <- dbSendQuery(db, sql)
ret <- fetch(rs, n = -1)

# Cerramos la conexion con la base de datos

dbClearResult(rs)
dbDisconnect(db)

# Convertimos el resultado a formato XTS

xret <- xts(ret[,-1], order.by=as.Date(ret[,1], "%Y-%m-%d %H %M"))

return(xret)
}

16 Datos de Forex con SQLite y R