SQL y MQL5: Trabajando con la base de datos SQLite
2 936
0
Small. Fast. Reliable.
Choose any of three.
Introducción
Muchos desarrolladores han pensado sobre la necesidad de usar en sus proyectos bases de datos para el almacenamiento de información, pero cada vez que han querido ponerse a ello, la idea del gasto de tiempo que significa la instalación de un servidor SQL les ha echado para atrás. Si para un programador no es complicado realizar esto (o ya tiene instalado un SGBD (SQL por sus siglas en inglés) con otros fines), para un usuario común esta operación conlleva muchas dudas y cuestiones, o incluso le quita las ganas de instalar un software.
En tal caso, el programador puede, sencillamente, dejar a un lado el SGBD, ya que entiende que, salvo él, son muy pocos los que usan esta opción. Al final se lleva a cabo el trabajo con archivos (con frecuencia más de uno, si los datos son dispares): se usa CSV, con menos frecuencia XML o JSON, o bien se graban datos binarios con un tamaño de estructura muy grande, etc.
¡Pero resulta que existe una alternativa magnífica a los servidores SQL! Además, no es necesario instalar software adicional, todo el trabajo tiene lugar a nivel local en su proyecto, e incluso así, usted estará utilizando toda la potencia del lenguaje SQL. El nombre de esta alternativa es: SQLite.
El objetivo de este artículo es hacer posible que el usuario comience a usar SQLite rápidamente. Por eso, no voy a profundizar en los detalles y conjuntos de parámetros posibles o las banderas de funciones, sino que voy a crear un conector que ejecuta comandos SQL, y mostraré su utilización con ejemplos.
Los requisitos imprescindibles para trabajar con el artículo son:
- Buen humor ;)
- Extraiga el archivo de la aplicación que viene con el artículo a una carpeta del terminal de trabajo MetaTrader 5
- Instale cualquier utility para el visionado de las bases SQLite (por ejemplo, SQLiteStudio)
- Añada al registro la documentación oficial sobre SQLite http://www.sqlite.org
Contenido
1. Principios de SQLite
2. Trabajar con SQLite API
2.1. Apertura y cierre de las bases de datos
2.2. Ejecución de requerimientos SQL
2.3. Obtención de datos de los recuadros
2.4. Grabación de los datos paramétricos con unión
2.5. Transacciones / Multirow insert (ejemplo de creación de un recuadro de operaciones de la cuenta comercial)
3. Montaje de la DLL de 64 bit versión SQLite3
1. Principios de funcionamiento de SQLite
SQLite es un SGBD (Sistema de Gestión de Bases de Datos) cuya principal peculiaridad es la ausencia de un sevidor SQL "oyente". El servidor mismo será su aplicación. Trabajar con las bases de datos en SQLite es, en la práctica, un trabajo con archivos (en un disco o en la memoria). Puede archivar todos los datos o trasladarlos a otro ordenador sin ninguna exigencia en particular en lo que respecta a su instalación.
El uso de SQLite proporciona tanto al desarrollador como al usuario varias ventajas indiscutibles:
- no hay que instalar software adicional;
- los datos se almacenan en un archivo local, lo que posibilita la transparencia en su control y gestión, es decir, los datos se pueden ver y redactar independientemente de su aplicación;
- posibilidad de importar o exportar recuadros a otros SGBD;
- en el código se usan los requerimientos SQL habituales, lo que permite, en cualquier momento, poner a trabajar la aplicación con otros SGBD.
Se puede trabajar con SQLite de tres maneras:
- usando archivos DLL con el conjunto completo de funciones API;
- usar los comandos shell de un archivo EXE;
- compilar el proyecto, incluyendo en él los códigos fuente SQLite API.
En este artículo trataré el uso de la primera posibilidad, ya que es la más frecuente en MQL5.
2. Trabajar con SQLite3 API
En el trabajo con el conector se usarán las siguientes funciones SQLite:
//--- funciones generales sqlite3_open sqlite3_prepare sqlite3_step sqlite3_finalize sqlite3_close sqlite3_exec //--- funciones para obtener la descripción de un error sqlite3_errcode sqlite3_extended_errcode sqlite3_errmsg //--- funciones para almacenar datos sqlite3_bind_null sqlite3_bind_int sqlite3_bind_int64 sqlite3_bind_double sqlite3_bind_text sqlite3_bind_blob //--- funciones para obtener datos sqlite3_column_count sqlite3_column_name sqlite3_column_type sqlite3_column_bytes sqlite3_column_int sqlite3_column_int64 sqlite3_column_double sqlite3_column_text sqlite3_column_blob
Asímismo, necesitaremos las funciones de bajo nivel msvcrt.dll para trabajar con los índices:
strlen strcpy memcpy
Dado que estoy creando un conector que funciona con terminales de 32 y 64 bits, entonces es necesario ocuparse del tamaño del índice enviado en la función API. Dividimos sus nombres:
// para el terminal de 32 bits #define PTR32 int #define sqlite3_stmt_p32 PTR32 #define sqlite3_p32 PTR32 #define PTRPTR32 PTR32 // para el terminal de 64 bits #define PTR64 long #define sqlite3_stmt_p64 PTR64 #define sqlite3_p64 PTR64 #define PTRPTR64 PTR64
Todas las funciones API se recargan para los índices de 32 y 64 bits, en caso necesario. Quiero llamar la atención sobre el hecho de todos los índices en el conector tendrán un tamaño de 64 bits. Su paso a un tamaño de 32 bits tendrá lugar directamente en las funciones API recargadas. El código fuente de la importación de las funciones API se encuentra en el archivo SQLite3Import.mqh
Tipos de datos SQLite
En la tercera versión de SQLite se contemplan cinco tipos de datos
| Tipo |
Descripción |
|---|---|
| NULL | Ausencia de datos. |
| INTEGER | Entero de un tamaño de 1, 2, 3, 4, 6 u 8 bytes, dependiendo de la amplitud del valor almacenado. |
| REAL | Con coma flotante, tamaño 8 bytes. |
| TEXT | Línea con el símbolo final \0 en codificación UTF-8 o UTF-16. |
| BLOB | Datos binarios arbitrarios |
Para indicar los tipos de campo al crear los recuadros en un requerimiento SQL, se pueden usar igualmente otros nombres de tipos, por ejemplo, BIGINT o INT, que están aceptados en los SGBD. En este caso, SQLite los pasará a algunos de sus tipos internos, en este caso a INTEGER. Podrá leer con más detalle sobre los tipos de datos y sus relaciones en la documentación http://www.sqlite.org/datatype3.html
2.1. Apertura y cierre de las bases de datos
Como ya sabe usted, la base de datos en SQLite3 es un archivo normal. La apertura de una base de datos es, en la práctica, la apertura de de un archivo y la obtención de su handle.
La apertura se lleva a cabo con la ayuda de la función sqlite3_open:
int sqlite3_open(const uchar &filename[], sqlite3_p64 &ppDb); filename [in] - ruta al archivo, o bien al nombre del archivo, si el archivo se abre en su ubicación actual. ppDb [out] - es la variable donde grabará la dirección del handle del archivo de la base. Retorna SQLITE_OK en caso de éxito o de código de error.
El archivo de la base se cierra con la función sqlite3_close:
int sqlite3_close(sqlite3_p64 ppDb); ppDb [in] - handle del archivo Retorna SQLITE_OK en caso de éxito o de código de error.
Creamos en el conector las funciones de apertura y cierre de la BD.
//+------------------------------------------------------------------+ //| CSQLite3Base class | //+------------------------------------------------------------------+ class CSQLite3Base { sqlite3_p64 m_db; // pointer to database file bool m_bopened; // flag "Is m_db handle valid" string m_dbfile; // path to database file public: CSQLite3Base(); // constructor virtual ~CSQLite3Base(); // destructor public: //--- connection to database bool IsConnected(); int Connect(string dbfile); void Disconnect(); int Reconnect(); }; //+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CSQLite3Base::CSQLite3Base() { m_db=NULL; m_bopened=false; } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CSQLite3Base::~CSQLite3Base() { Disconnect(); } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ bool CSQLite3Base::IsConnected() { return(m_bopened && m_db); } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ int CSQLite3Base::Connect(string dbfile) { if(IsConnected()) return(SQLITE_OK); m_dbfile=dbfile; return(Reconnect()); } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void CSQLite3Base::Disconnect() { if(IsConnected()) ::sqlite3_close(m_db); m_db=NULL; m_bopened=false; } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ int CSQLite3Base::Reconnect() { Disconnect(); uchar file[]; StringToCharArray(m_dbfile,file); int res=::sqlite3_open(file,m_db); m_bopened=(res==SQLITE_OK && m_db); return(res); }
El conector ya no sabe abrir ni cerrar la base de datos. Vamos a comprobar el funcionamiento con un script muy sencillo:
#include <MQH\Lib\SQLite3\SQLite3Base.mqh> CSQLite3Base sql3; // database connector //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void OnStart() { //--- open database connection if(sql3.Connect("SQLite3Test.db3")!=SQLITE_OK) return; //--- close connection sql3.Disconnect(); }
Inicie el script en el modo depuración, haga una profunda inspiración y compruebe el funcionamiento de cada línea. Como resultado del trabajo, aparecerá una base de datos en la carpeta de instalación del terminal MetaTrader 5. Ya puede alegrarse de que todo haya salido bien. Pasemos al apartado siguiente.
2.2. Ejecución de requerimientos SQL
Cualquier requerimiento SQL en SQLite3 supera un mínimo de tres etapas:
- sqlite3_prepare - es la verificación y obtención de la lista de instrucciones (statement);
- sqlite3_step - es la ejecución de dichas instrucciones;
- sqlite3_finalize - es la finalización y la limpieza de la memoria.
Este esquema, básicamente, viene bien para crear o eliminar recuadros, o bien para grabar datos no binarios, es decir, para los casos en los que el requerimiento SQL no presupone el retorno de algunos datos, además del informe de su correcta ejecución.
Si el requerimiento presupone que se vayan a recibir datos o grabar datos binarios, entonces, en la segunda etapa tendremos que utilizar las funciones sqlite3_column_хх o sqlite3_bind_хх, respectivamente. En el siguiente apartado veremos detalladamente estas funciones.
Escribimos el método CSQLite3Base::Query para la ejecución de un requerimiento SQL sencillo:
//+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ int CSQLite3Base::Query(string query) { //--- check connection if(!IsConnected()) if(!Reconnect()) return(SQLITE_ERROR); //--- check query string if(StringLen(query)<=0) return(SQLITE_DONE); sqlite3_stmt_p64 stmt=0; // variable for pointer //--- get pointer PTR64 pstmt=::memcpy(stmt,stmt,0); uchar str[]; StringToCharArray(query,str); //--- prepare statement and check result int res=::sqlite3_prepare(m_db,str,-1,pstmt,NULL); if(res!=SQLITE_OK) return(res); //--- execute res=::sqlite3_step(pstmt); //--- clean ::sqlite3_finalize(pstmt); //--- return result return(res); }
Como puede ver, las funciones sqlite3_prepare, sqlite3_step y sqlite3_finalize van una detrás de otra.
Veamos la aplicación de CSQLite3Base::Query en el trabajo con recuadros en SQLite:
// Crear un recuadro (CREATE TABLE) sql3.Query("CREATE TABLE IF NOT EXISTS `TestQuery` (`ticket` INTEGER, `open_price` DOUBLE, `comment` TEXT)");
Tras ejecutar este comando, en la base de datos aparecerá un recuadro:
// Renombrar columna (ALTER TABLE RENAME) sql3.Query("ALTER TABLE `TestQuery` RENAME TO `Trades`"); // Añadir columna (ALTER TABLE ADD COLUMN) sql3.Query("ALTER TABLE `Trades` ADD COLUMN `profit`");
Tras ejecutar estos comandos, tendremos un recuadro con un nombre nuevo y un campo añadido:
// Añadir fila (INSERT INTO) sql3.Query("INSERT INTO `Trades` VALUES(3, 1.212, 'info', 1)"); // Actualizar fila (UPDATE) sql3.Query("UPDATE `Trades` SET `open_price`=5.555, `comment`='New price' WHERE(`ticket`=3)")
Como resultado, tras añadir un fila y realizar cambios, en el recuadro aparecerá la siguiente anotación:
Y, al fin, los comandos siguientes, ejecutados consecutivamente, limpiarán la base de datos.
// Borrar todas las filas del recuadro (DELETE FROM) sql3.Query("DELETE FROM `Trades`") // Eliminar recuadro (DROP TABLE) sql3.Query("DROP TABLE IF EXISTS `Trades`"); // Compresión de la base de datos (VACUUM) sql3.Query("VACUUM");
Antes de ver el próximo apartado, necesitaremos un método para obtener la descripción de errores. La experiencia me dice que el código de error dice mucho, pero la descripción del error nos mostrará el lugar del texto del requerimiento SQL donde está el error, y esto acelerará su búsqueda y corrección significativamente.
const PTR64 sqlite3_errmsg(sqlite3_p64 db); db [in] - handle obtenido con la función sqlite3_open Retorna el índice de la línea con la descripción del error.
En el conector añadimos el método para obtener esta línea desde índice con la ayuda de strcpy y strlen.
//+------------------------------------------------------------------+ //| Error message | //+------------------------------------------------------------------+ string CSQLite3Base::ErrorMsg() { PTR64 pstr=::sqlite3_errmsg(m_db); // get message string int len=::strlen(pstr); // length of string uchar str[]; ArrayResize(str,len+1); // prepare buffer ::strcpy(str,pstr); // read string to buffer return(CharArrayToString(str)); // return string }
2.3. Obtener datos del recuadro
Como ya recordé al comienzo del apartado 2.2, la lectura de datos se realiza con la ayuda de la función sqlite3_column_хх. De una manera esquemática, se puede representar de la manera siguiente:
- sqlite3_prepare
- sqlite3_column_count - averiguamos la cantidad de columnas del recuadro obtenido
- Por ahora, el resultado del paso es sqlite3_step == SQLITE_ROW
- sqlite3_column_хх - leemos la celda de esta línea
- sqlite3_finalize
Ya que nos aproximamos al apartado común de lectura y grabación de datos, ha llegado un momento muy adecuado para describir las tres clases de contenedores con cuya ayuda tendrá lugar el cambio. El modelo necesario de datos nos vendrá dictado por el modo de almacenamiento de información en la BD:
Base de datos
|
El recuadro es una matriz de filas.
|
La fila es una matriz de celdas.
|
La celda es un búfer de bytes de longitud al azar.
//+------------------------------------------------------------------+ //| CSQLite3Table class | //+------------------------------------------------------------------+ class CSQLite3Table { public: string m_colname[]; // column name CSQLite3Row m_data[]; // database rows //... };
//+------------------------------------------------------------------+ //| CSQLite3Row class | //+------------------------------------------------------------------+ class CSQLite3Row { public: CSQLite3Cell m_data[]; //... };
//+------------------------------------------------------------------+ //| CSQLite3Cell class | //+------------------------------------------------------------------+ class CSQLite3Cell { public: enCellType type; CByteImg buf; //... };
Como puede ver, las conexiones CSQLite3Row y CSQLite3Table son primitivas , se trata de matrices corrientes de datos. La clase de celda CSQLite3Cell también tiene la matriz de datos uchar + el campo Tipo de datos. Como matriz de bytes ejerce la clase CByteImage (por analogía con CFastFile, que usted ya conoce).
Para que sea más cómodo trabajar con el conector y el control de tipo de datos de la celda, he creado la enumeración:
enum enCellType
{
CT_UNDEF,
CT_NULL,
CT_INT,
CT_INT64,
CT_DBL,
CT_TEXT,
CT_BLOB,
CT_LAST
};
Preste atención al hecho de que añadimos a los cinco tipos principales de SQLite3 el tipo CT_UNDEF para identificar el estado inicial de la celda. El tipo entero INTEGER se divide en dos CT_INT y CT_INT64, de acuerdo con la funciones divididas de manera análoga sqlite3_bind_intXX, sqlite3_column_intXX.
Obtención de datos
Para obtener datos de la celda, crearemos un método que generaliza las funciones del tipo sqlite3_column_хх, y que comprobará el tipo de datos, su tamaño y los grabará en CSQLite3Cell.
//+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ bool CSQLite3Base::ReadStatement(sqlite3_stmt_p64 stmt,int column,CSQLite3Cell &cell) { cell.Clear(); if(!stmt || column<0) return(false); int bytes=::sqlite3_column_bytes(stmt,column); int type=::sqlite3_column_type(stmt,column); //--- if(type==SQLITE_NULL) cell.type=CT_NULL; else if(type==SQLITE_INTEGER) { if(bytes<5) cell.Set(::sqlite3_column_int(stmt,column)); else cell.Set(::sqlite3_column_int64(stmt,column)); } else if(type==SQLITE_FLOAT) cell.Set(::sqlite3_column_double(stmt,column)); else if(type==SQLITE_TEXT || type==SQLITE_BLOB) { uchar dst[]; ArrayResize(dst,bytes); PTR64 ptr=0; if(type==SQLITE_TEXT) ptr=::sqlite3_column_text(stmt,column); else ptr=::sqlite3_column_blob(stmt,column); ::memcpy(dst,ptr,bytes); if(type==SQLITE_TEXT) cell.Set(CharArrayToString(dst)); else cell.Set(dst); } return(true); }
La función nos ha salido bastante voluminosa, pero, en esencia, lo único que hace es leer los datos de la instrucción actual, almacenándolos en una celda.
Asímismo, recargamos la función CSQLite3Base::Query, añadiéndole como primer parámetro el recuadro contenedor CSQLite3Table para los datos que se reciban.
//+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ int CSQLite3Base::Query(CSQLite3Table &tbl,string query) { tbl.Clear(); //--- check connection if(!IsConnected()) if(!Reconnect()) return(SQLITE_ERROR); //--- check query string if(StringLen(query)<=0) return(SQLITE_DONE); //--- sqlite3_stmt_p64 stmt=NULL; PTR64 pstmt=::memcpy(stmt,stmt,0); uchar str[]; StringToCharArray(query,str); int res=::sqlite3_prepare(m_db, str, -1, pstmt, NULL); if(res!=SQLITE_OK) return(res); int cols=::sqlite3_column_count(pstmt); // get column count bool b=true; while(::sqlite3_step(pstmt)==SQLITE_ROW) // in loop get row data { CSQLite3Row row; // row for table for(int i=0; i<cols; i++) // add cells to row { CSQLite3Cell cell; if(ReadStatement(pstmt,i,cell)) row.Add(cell); else { b=false; break; } } tbl.Add(row); // add row to table if(!b) break; // if error enabled } // get column name for(int i=0; i<cols; i++) { PTR64 pstr=::sqlite3_column_name(pstmt,i); if(!pstr) { tbl.ColumnName(i,""); continue; } int len=::strlen(pstr); ArrayResize(str,len+1); ::strcpy(str,pstr); tbl.ColumnName(i,CharArrayToString(str)); } ::sqlite3_finalize(stmt); // clean return(b?SQLITE_DONE:res); // return result code }
Ya tenemos todas las funciones para la obtención de datos. Pasemos a ver sus ejemplos:
// Lectura de datos (SELECT) CSQLite3Table tbl; sql3.Query(tbl, "SELECT * FROM `Trades`")
Imprimimos el resultado de este requerimiento en el terminal con el comando Print(TablePrint(tbl)). En el registro veremos lo siguiente (en orden ascendente):
// Ejemplo de cálculo de la información estadística del recuadro (COUNT, MAX, AVG ...) sql3.Query(tbl, "SELECT COUNT(*) FROM `Trades` WHERE(`profit`>0)") sql3.Query(tbl, "SELECT MAX(`ticket`) FROM `Trades`") sql3.Query(tbl, "SELECT SUM(`profit`) AS `sumprof`, AVG(`profit`) AS `avgprof` FROM `Trades`")
// Obtener los nombres de todos los recuadros en la base sql3.Query(tbl, "SELECT `name` FROM `sqlite_master` WHERE `type`='table' ORDER BY `name`;");
Imprimimos el resultado a dicho requerimiento de manera análoga con el comando Print(TablePrint(tbl)). Veremos el siguiente recuadro:
Como podemos ver por los parámetros, los resultados de la ejecución de requerimientos se ubican en la variable tbl, desde la cual se pueden obtener y gestionar dichos resultados de modo sencillo.
2.4. Grabación de los datos paramétricos con unión
Otro tema que debe ver sin falta cualquier principiante es la grabación de información en una base de datos que tenga un formato "incómodo". Por supuesto, estamos hablando sobre datos binarios, que no se pueden transmitir directamente con las instrucciones de texto normales INSERT o UPDATE, ya que con el primer cero la línea se considerará finalizada. O, por ejemplo, hay casos cuando en la propia línea tenemos símbolos con una comilla sola'.
En algunas situaciones la unión tardía es cómoda, cuando tenemos un recuadro muy ancho y grabar todos los campos en una sola línea es complicado y poco fiable, ya que hay muchas posibilidades de que se nos pase o perdamos algo importante. Para esta operación de unión, es necesaria una función de la familia sqlite3_bind_хх.
Para aplicar la unión, es necesario poner una plantilla en lugar de los datos transmitidos. Yo mostraré una de las variantes, que es el signo "?". Es decir, el requerimiento UPDATE tendrá el aspecto siguiente:
Después, hay que ejecutar dos funciones seguidas: sqlite3_bind_double y sqlite3_bind_text, para que quepan los datos en open_price y comment. En general, el esquema de trabajo con las funciones bind-se podría mostrar bajo el aspecto siguiente:
- sqlite3_prepare
- Llamamos por orden sqlite3_bind_хх y grabamos los datos necesarios en la instrucción
- sqlite3_step
- sqlite3_finalize
Según la cantidad de los tipos, sqlite3_bind_xx repiten completamente las funciones de lectura ya vistas, por eso es fácil unirlas en el conector en CSQLite3Base::BindStatement:
//+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ bool CSQLite3Base::BindStatement(sqlite3_stmt_p64 stmt,int column,CSQLite3Cell &cell) { if(!stmt || column<0) return(false); int bytes=cell.buf.Len(); enCellType type=cell.type; //--- if(type==CT_INT) return(::sqlite3_bind_int(stmt, column+1, cell.buf.ViewInt())==SQLITE_OK); else if(type==CT_INT64) return(::sqlite3_bind_int64(stmt, column+1, cell.buf.ViewInt64())==SQLITE_OK); else if(type==CT_DBL) return(::sqlite3_bind_double(stmt, column+1, cell.buf.ViewDouble())==SQLITE_OK); else if(type==CT_TEXT) return(::sqlite3_bind_text(stmt, column+1, cell.buf.m_data, cell.buf.Len(), SQLITE_STATIC)==SQLITE_OK); else if(type==CT_BLOB) return(::sqlite3_bind_blob(stmt, column+1, cell.buf.m_data, cell.buf.Len(), SQLITE_STATIC)==SQLITE_OK); else if(type==CT_NULL) return(::sqlite3_bind_null(stmt, column+1)==SQLITE_OK); else return(::sqlite3_bind_null(stmt, column+1)==SQLITE_OK); }
La única tarea de este método es grabar en la instrucción el búfer de la celda transmitida.
De manera análoga añadimos el método CQLite3Table::QueryBind, cuyo primer argumento es la línea de los datos a grabar:
//+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ int CSQLite3Base::QueryBind(CSQLite3Row &row,string query) // UPDATE <table> SET <row>=?, <row2>=? WHERE (cond) { if(!IsConnected()) if(!Reconnect()) return(SQLITE_ERROR); //--- if(StringLen(query)<=0 || ArraySize(row.m_data)<=0) return(SQLITE_DONE); //--- sqlite3_stmt_p64 stmt=NULL; PTR64 pstmt=::memcpy(stmt,stmt,0); uchar str[]; StringToCharArray(query,str); int res=::sqlite3_prepare(m_db, str, -1, pstmt, NULL); if(res!=SQLITE_OK) return(res); //--- bool b=true; for(int i=0; i<ArraySize(row.m_data); i++) { if(!BindStatement(pstmt,i,row.m_data[i])) { b=false; break; } } if(b) res=::sqlite3_step(pstmt); // executed ::sqlite3_finalize(pstmt); // clean return(b?res:SQLITE_ERROR); // result }
Su misión es grabar la línea en los parámetros correspondientes.
2.5. Transacciones / Multirow inserts
Antes de pasar a ver este tema, usted deberá tener conocimientos de otra función SQLite API más. En el apartado anterior traté el tema del procesado en tres etapas de los requerimientos prepare+step+finalize. Una solución alternativa, en algunos casos sencilla, en otros incluso imprescindible, sería la función sqlite3_exec:
int sqlite3_exec(sqlite3_p64 ppDb, const char &sql[], PTR64 callback, PTR64 pvoid, PTRPTR64 errmsg); ppDb [in] - handle de la base de datos sql [in] - requerimiento SQL Por el momento, no estudiaremos la aplicación a MQL5 de los tres parámetros restantes. Retorna SQLITE_OK al realizarse correctamente o al obtener un error de archivo.
Su esencia es realizar el requerimiento en una sola llamada, sin crear un construcción en tres etapas.
Añadimos su llamada al conector:
//+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ int CSQLite3Base::Exec(string query) { if(!IsConnected()) if(!Reconnect()) return(SQLITE_ERROR); if(StringLen(query)<=0) return(SQLITE_DONE); uchar str[]; StringToCharArray(query,str); int res=::sqlite3_exec(m_db,str,NULL,NULL,NULL); return(res); }
Usar el método obtenido es muy sencillo. Por ejemplo, los comandos de eliminación del recuadro (DROP TABLE) o de compresión de la base (VACUUM) se pueden ejecutar así:
sql3.Exec("DROP TABLE `Trades`"); sql3.Exec("VACUUM");
Transacciones
Ahora presentamos la situación en la que es necesario añadir varios miles de líneas a un recuadro. Si lo introducimos todo en este ciclo:
for (int i=0; i<N; i++) sql3.Query("INSERT INTO `Table` VALUES(1, 2, 'text')");
entonces tendremos una ejecución mmmmmmuuuuuuyyyyyyyyyy lenta. Para pegar mil líneas se invertirán más de 10(!) segundos, así que no recomendamos hacer esto en SQLite. La salida a esta situación es el uso de transacciones: todas las instrucciones SQL se introducen en una lista común y después se llevan a cabo en un solo requerimiento.
Para grabar el principio y el final de la transacción se usan operadores SQL:
BEGIN ... COMMIT
Todo lo que hay en el interior se ejecuta de manera atómica en el último operador COMMIT. Para las situaciones en que haya que interrumpir el ciclo, o que por algún motivo no haya que ejecutar instrucciones ya añadidas, tenemos el operador ROLLBACK.
Como ejemplo añadiremos todas las operaciones de la cuenta en un recuadro.
#include <MQH\Lib\SQLite3\SQLite3Base.mqh> //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void OnStart() { CSQLite3Base sql3; //--- open database connection if(sql3.Connect("Deals.db3")!=SQLITE_OK) return; //--- if(sql3.Query("CREATE TABLE IF NOT EXISTS `Deals` (`ticket` INTEGER PRIMARY KEY, `open_price` DOUBLE, `profit` DOUBLE, `comment` TEXT)")!=SQLITE_DONE) { Print(sql3.ErrorMsg()); return; } //--- create transaction if(sql3.Exec("BEGIN")!=SQLITE_OK) { Print(sql3.ErrorMsg()); return; } HistorySelect(0,TimeCurrent()); //--- dump all deals from terminal to table for(int i=0; i<HistoryDealsTotal(); i++) { CSQLite3Row row; long ticket=(long)HistoryDealGetTicket(i); row.Add(ticket); row.Add(HistoryDealGetDouble(ticket, DEAL_PRICE)); row.Add(HistoryDealGetDouble(ticket, DEAL_PROFIT)); row.Add(HistoryDealGetString(ticket, DEAL_COMMENT)); if(sql3.QueryBind(row,"REPLACE INTO `Deals` VALUES("+row.BindStr()+")")!=SQLITE_DONE) { sql3.Exec("ROLLBACK"); Print(sql3.ErrorMsg()); return; } } //--- end transaction if(sql3.Exec("COMMIT")!=SQLITE_OK) return; //--- get statistical information from table CSQLite3Table tbl; CSQLite3Cell cell; if(sql3.Query(tbl,"SELECT COUNT(*) FROM `Deals` WHERE(`profit`>0)")!=SQLITE_DONE) { Print(sql3.ErrorMsg()); return; } tbl.Cell(0,0,cell); Print("Count(*)=",cell.GetInt64()); //--- if(sql3.Query(tbl,"SELECT SUM(`profit`) AS `sumprof`, AVG(`profit`) AS `avgprof` FROM `Deals`")!=SQLITE_DONE) { Print(sql3.ErrorMsg()); return; } tbl.Cell(0,0,cell); Print("SUM(`profit`)=",cell.GetDouble()); tbl.Cell(0,1,cell); Print("AVG(`profit`)=",cell.GetDouble()); }
Tras ejecutar este script en su cuenta, grabará al instante las operaciones de su cuenta en un recuadro.
Se ha mostrado información estadística en el registro del terminal
Experimente con este script: comente las líneas con BEGIN, ROLLBACK y COMMIT, y si tiene más de cien operaciones en su cuenta, entonces apreciará claramente la diferencia. A propósito, según ciertas pruebas, las transacciones SQLite funcionan más rápido que en MySQL o PostgreSQL.
3. Montaje de la versión de 64 bits sqlite3_64.dll
- Descargamos el código fuente de SQLite (amalgamation) y extraemos de él el archivo sqlite3.c.
- Descargamos DLL sqlite-dll-win32 y le extraemos el archivo sqlite3.dll.
- En la carpeta donde ha sido extraido el archivo dll, ejecutamos en la consola el comando LIB.EXE /DEF:sqlite3.def. Asegúrese de que las rutas hasta el archivo lib.exe están escritas con la variable sistémica PATH, o bien encuéntrela en Visual Studio.
- Creamos un proyecto DLL, elegiendo la configuración Release para plataformas de 64 bits.
- Añadimos al proyecto el archivo descargado sqlite3.c y el archivo obtenido sqlite3.def. Si en alguna función del archivo def el compilador se "enfada", en este caso, coméntelo, simplemente.
- En los ajustes del proyecto, establecemos los siguientes parámetros:
C/C++ --> General --> Debug Information Format = Program Database (/Zi)
C/C++ --> Precompiled Headers --> Create/Use Precompiled Header = Not Using Precompiled Headers (/Yu) - Compilamos y obtenemos una dll de 64 bit.
Conclusión
Espero que este artículo se convierta en sus instrucciones de cabecera para la asimilación de SQLite. Es muy posible que lo utilice en sus futuros proyectos. Esta breve panorámica le dará una idea general de la funcionalidad de SQLite, como una solución ideal y fiable para las aplicaciones.
En el artículo hemos echado un vistazo a todos los ejemplos con los que puede usted encontrarse al procesar los datos informáticos. Como deberes para hacer en casa, le propongo crear un recopilador sencillo de ticks, que sea capaz de grabar los ticks en un recuadro para cada símbolo. El código fuente de la biblioteca de clases y los scripts de texto podrá encontrarlos en el anexo al artículo.
¡Le deseo que tenga suerte y beneficios!
Traducción del ruso hecha por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/ru/articles/862
Fundamentos de programación en MQL5 - Cadenas de caracteres
Creación de filtros digitales sin retardo temporal
Recetas MQL5 - Desarrollo de un indicador multidivisa para el análisis de la divergencia de precios
Pegado de contrato de futuros en MetaTrader 5
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Usted acepta la política del sitio web y las condiciones de uso