Simulação de mercado: Iniciando o SQL no MQL5 (I)

Introdução

Olá pessoal, e sejam bem-vindos a mais um artigo da série sobre como construir um sistema de replay/simulação.

No artigo anterior Simulação de mercado (Parte 24): Iniciando o SQL (VII), fechamos o que considero ser a base da base, necessária para que você, caro leitor, mesmo sem nenhuma experiência em SQL. Possa, ou no mínimo, consiga acompanhar o que iremos fazer de agora em diante. Isto por que, estaremos entrando em uma nova fase do desenvolvimento do sistema de replay/simulação. Onde saber SQL, será primordial para que você consiga acompanhar este e os próximos artigos.

Não se preocupe se você ainda está iniciando no SQL. E tem como base, apenas o que foi explicado nos artigos anteriores. Aquele material, ser for bem empregado, e compreendido, já nos será o suficiente, para permitir fazer muito do que realmente precisamos e iremos fazer. Visto, que neste primeiro momento, a minha real intenção é nos manter dentro do SQLite. Já que ele vem embutido no MetaTrader 5. Facilitando muito o uso sem que precisemos fazer uso de uma DLL ou mesmo soquetes.

Muito bem, se você já faz uso do SQLite em seus programas, usando o MQL5. Este artigo não irá de maneira alguma acrescentar em nada no que você já sabe fazer. Porém, se você ainda está começando neste mundo, onde fazer uso de banco de dados é algo a ser firmemente pensado. E não sabe como fazer isto, usando o MQL5. Penso que se acomode na poltrona, e acompanhe este artigo. Pois aqui iremos ver como fazer para iniciar o uso de um banco de dados SQL usando o MQL5 para isto. Só que não faremos uso de qualquer banco de dados. Faremos uso do SQLite. E como você viu nos artigos anteriores, podemos fazer bastante coisa dentro do sistema. Isto com um mínimo de esforço sendo feito aqui no MQL5.

Criando o banco de dados SQL via MQL5

Muito bem. A primeira coisa a ser feita, será criar um banco de dados. Como você viu nos artigos anteriores, fazer isto é algo bastante simples e sem nenhuma dificuldade. Podemos fazer isto diretamente via MetaEditor ou via prompt ou programa próprio para editar scripts em SQL. Mas quero que você, caro leitor, aprenda e entenda que não precisamos fazer assim. Podemos fazer as coisas diretamente via programação mesmo. Usando uma ou outra linguagem para isto.

Se você procurar, irá encontrar muita gente explicando diversas maneiras de se fazer a mesma coisa. Usando para isto linguagens diferentes. Porém, se você prestar a devida atenção. Notará que lá no fundo e no coração do que está sendo feito. Que tudo estará sendo desenvolvido para ser feito usando o SQL. E é neste ponto que as coisas passam a se tornar interessantes. Isto por que, se você entender estes princípios. Poderá traduzir algo feito em JAVA por exemplo, para ser feito aqui no MQL5. O motivo é que no final quem de fato irá tratar as informações e atuará nos registros, será o código em SQL. O JAVA, apenas irá servir para fornecer uma interface mais amigável para um dado tipo de usuário.

Você encontrará o mesmo tipo de coisa sendo feita em VBA, onde usamos o Excel para apresentar as informações que serão obtidas diretamente via SQL. Por isto é que é tão importante compreender como o código em SQL de fato funciona. Pois no final, você de fato estará usando o SQL. A linguagem que estará dando apoio ao SQL, servirá apenas como forma de apresentar os dados que o SQL estará nos fornecendo.

Ter esta visão sobre como as coisas, de fato funcionam irá lhe ajudar bastante, de agora em diante. Então vamos começar, pelo princípio mais básico de todos. Criando um arquivo de banco de dados em SQLite, usando para isto o MQL5. Já que o intuito daqui será ser o mais didático quanto for possível. Iremos usar algo que será o mais simples possível. Ou seja, iremos usar um script em MQL5. Isto por conta que um script, pode ser mais claramente entendido e é mais facilmente testado. O primeiro código que usaremos pode ser visto logo abaixo:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. #property description "Basic script for SQL database written in MQL5"
04. #property version   "1.00"
05. #property script_show_inputs
06. //+------------------------------------------------------------------+
07. input string user01 = "DataBase01";        //FileName
08. //+------------------------------------------------------------------+
09. void OnStart()
10. {
11.     string szFileName = user01 + ".sqlite";
12.     int handleDB;
13.     
14.     if ((handleDB = DatabaseOpen(szFileName, DATABASE_OPEN_CREATE | DATABASE_OPEN_READWRITE)) == INVALID_HANDLE)
15.     {
16.         Print("Unable to create or open the file ", szFileName);
17.         return;
18.     }
19.     DatabaseClose(handleDB);
20.     Print("Database file saved successfully..");
21. }
22. //+------------------------------------------------------------------+

Código em MQL5

Este é o código mais simples possível, para podemos abrir ou mesmo criar um arquivo de banco de dados. Isto usando o MQL5 junto com o SQLite. Repare que é algo muito fácil de entender. Você na linha sete, permite ao usuário do script, informar qual o nome do banco de dados a ser criado ou aberto. Note que não estamos indicando a extensão do arquivo a ser usado. Isto por que, indicaremos depois qual será a extensão a ser utilizada. A extensão a ser utilizada é indicada na linha 11. Note que ali usamos o nome que o usuário do script nos informará, e unimos com uma outra string. Esta que no caso será a extensão do nome do arquivo.

É importante notar que podemos usar qualquer extensão. Mas sugiro que você faça uso de uma que indique o tipo de arquivo que estaremos usando. Para banco de dados em SQL, o mais comum é usar .DB, ou no caso do SQLite, usarmos .sqlite como extensão. Visto que poderemos estar usando coisas que são próprias do SQLite. Isto foi explicado nos artigos anteriores. Qualquer dúvida, veja os mesmos, assim como as referências que estão neles. Isto para melhor entender o assunto.

Ok, já que iremos estar tratando de arquivos, precisamos de um manipulador. Este é declarado na linha 12. Já na linha 14, usamos a função DatabaseOpen que é parte integrante do MQL5, para abrir ou mesmo criar o arquivo de banco de dados. Neste ponto, temos um detalhe importante, a ser observado. Você poderá criar um arquivo de banco de dados em três localizações diferentes. Isto usando esta mesma função DatabaseOpen. Os locais são: Primeiro em memória, ou seja, uma vez que o banco de dados seja finalizado, ele deixará de existir. Isto é muito útil para determinadas situações. Mas para nós aqui, isto não será utilizado. Pelo menos por hora.

O segundo, assim como o terceiro local, irá depender dos argumentos passados para a função DatabaseOpen. Observe que no código mostrado, estamos usando os argumentos, DATABASE_OPEN_CREATE e DATABASE_OPEN_READWRITE. Isto fará com que o arquivo de banco de dados, seja criado em algum ponto da pasta MQL5\Files. Digo algum ponto, pois no nome que o usuário informar, ele poderá estar passando um nome de diretório válido. E se isto ocorrer, você deverá ir para o diretório apontado pelo usuário. De qualquer maneira tal diretório, se encontrará na pasta MQL5\Files, justamente por conta dos argumentos informados.

No entanto, este local pode ser diferente, caso junto dos argumentos visto no código, você adicione também o argumento DATABASE_OPEN_COMMON. Isto fará com que a patas deixe de ser a MQL5\Files e passe a ser a COMMON\Files. Mas espere, eu não sei onde fica esta pasta COMMON, como posso ter acesso a ela? Este tipo de dúvida é bastante comum. Então meu caro leitor, caso você não saiba onde fica esta pasta. Bastará ir no seguinte caminho dentro do seu disco local:

C:\Users\<UserName>\AppData\Roaming\MetaQuotes\Terminal

Neste local você encontrará a tal pasta COMMON e dentro dela a pasta Files. Lembre-se de modificar o valor <UserName> pelo nome do usuário logado no Windows.

Se a criação ou acesso ao arquivo especificado não for permitido. Teremos no terminal do MetaTrader 5, a mensagem vista na linha 16 sendo impressa. Logo depois na linha 17 o script será encerrado. Mas se tudo funcionou perfeitamente bem. Na linha 19 fecharemos o arquivo de banco de dados e na linha 20 imprimiremos uma mensagem no terminal do MetaTrader 5, dizendo que tudo foi devidamente concluído com êxito. Como resultado, no MetaEditor, você poderá abrir e verá algo parecido com a imagem abaixo sendo mostrada.

Neste ponto, já podemos fazer uso do SQL, via MetaEditor. Porém, vamos fazer uso via MQL5. Mas você pode usar o MetaEditor ou mesmo os programas mostrados durante a explicação do SQL, visto nos artigos anteriores, para poder acompanhar o que estará sendo feito via MQL5. É importante que nestes primeiros passos, onde você estará aprendendo a fazer uso do SQLite no MQL5. Que tenha alguma maneira de acompanhar o que estará sendo feito. Para isto, saber o básico de SQL será de grande valia. Então use o material de apoio, presente nos artigos anteriores para acelerar ainda mais o seu aprendizado. Pois a coisa aqui será bastante interessante de ser feita.

Muito bem, agora que já sabemos como criar, ou abrir um arquivo de banco de dados SQL. Podemos partir para a próxima etapa. Mas antes, deixe-me esclarecer uma coisa. Que talvez você possa ficar na dúvida. Quando for dito, que estaremos abrindo um arquivo, acessando dados e adicionando ou ajustando registros no SQL. Quero que você, tenha em mente que estaremos usando o SQLite. Isto por que para fazer as mesmas coisas que serão feitas aqui, mas usando uma outra implementação do SQL, seja por exemplo o MySQL ou SQL Server. A forma de fazer as coisas é ligeiramente diferente. Não confunda as coisas.

SQL só existe um, que é a linguagem usada. Tipos de implementação, existem diversos, e cada um nos permite fazer mais ou menos coisas. Aqui iremos lidar exclusivamente com o SQLite. Pelo menos neste começo de implementação. No futuro, pode ser que eu venha a mudar de ideia. Mas se isto ocorrer, irei explicar como você faz para migra do SQLite para uma outra implementação do SQL. Mas não precisa ficar com receio ou medo de aprender SQL. Pois a linguagem SQL será sempre a mesma, independente da aplicação ou implementação que a estará usando.

Criando as primeiras tabelas

Assim como foi feito, para explicar sobre os comandos SQL. Iremos fazer algo muito parecido aqui. Isto para que a transição entre a programação em SQL puro, seja suave para um SQL implantado em um outro código. No caso o código a receber tais comandos é o MQL5. Bem, felizmente, os desenvolvedores do MQL5, fizeram um excelente trabalho, deixando a coisa de uma forma bastante simples de ser compreendida e utilizada. Assim você precisará realmente aprender como usar seis funções de todas a presentes no MQL5, a fim de trabalhar com banco de dados. Mas então as outras funções são desnecessárias? Não, eu não disse isto. Eu disse que você precisa aprender a usar seis funções. E sabendo trabalhar com estas seis e conhecendo um pouco sobre SQL, conseguirá lidar perfeitamente com qualquer situação envolvendo banco de dados. Isto no que rege trabalhar com o SQLite que está incluso no MQL5.

Se você for usar o SQLite via DLL, a forma de fazer as coisas será um pouco diferente. Isto por que neste caso, você fará as chamadas diretamente pelo SQLite presente da DLL. Então se este for o seu caso específico e particular. Sugiro que estude a documentação de como usar o SQLite via DLL, pois as coisas diferem um pouco do que será visto aqui.

Muito bem, então vamos ver quais as funções das quais precisaremos aprender a usar. Duas delas já foram mostradas que são: DatabaseOpen e DatabaseClose. Mas também precisaremos da DatabaseExecute, DatabasePrepare, DataBaseReadBind e DatabaseFinalize. É claro que saber usar as demais funções lhe ajudará bastante em diversos momentos. Mas com estas seis, já poderemos construir quase qualquer coisa muito facilmente. Desde é claro você já tenha uma boa base formada em programar SQL.

Mas com as coisas que mostrei nos artigos anteriores você já conseguirá pelo menos, fazer algumas coisas bastante interessantes. Além é claro, conseguirá fazer algumas coisas que muitos não saberiam como você estará conseguindo fazer. Mas como prometi, irei fazer as coisas aos poucos, para que todos consigam acompanhar e entender o que estará se passando.

Legal. Como você deve ter visto nos artigos anteriores. Qualquer coisa que vamos fazer, estará de alguma forma ligadas a tabelas. Então vamos começar com o mais básico sobre este assunto. Assim, o nosso novo script pode ser visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. #property description "Basic script for SQL database written in MQL5"
04. #property version   "1.00"
05. #property script_show_inputs
06. //+------------------------------------------------------------------+
07. input string user01 = "DataBase01";        //FileName
08. //+------------------------------------------------------------------+
09. void OnStart()
10. {
11.     string szFileName = user01 + ".sqlite",
12.              szRequestSQL;
13.     int handleDB;
14.     
15.     if ((handleDB = DatabaseOpen(szFileName, DATABASE_OPEN_CREATE | DATABASE_OPEN_READWRITE)) == INVALID_HANDLE)
16.     {
17.         Print("Unable to create or open the file ", szFileName);
18.         return;
19.     }
20.     szRequestSQL = "CREATE TABLE IF NOT EXISTS tb_Symbol(id PRIMARY KEY, symbol NOT NULL UNIQUE);";
21.     if (!DatabaseExecute(handleDB, szRequestSQL))
22.     {
23.         Print("Request execution failed.");
24.         DatabaseClose(handleDB);
25.         return;
26.     }
27.     DatabaseClose(handleDB);
28.     Print("Database file saved successfully.");
29. }
30. //+------------------------------------------------------------------+

Código em MQL5

Quando este script for executado no MetaTrader 5, você terá o resultado mostrado abaixo:

Nossa que legal. Mas como isto foi feito? Simples. Tudo que fizemos foi usar algo que vimos nos artigos anteriores, onde expliquei sobre SQL. Mas aqui fizemos a coisa toda via MQL5. Como? Pegando como base o script visto no tópico anterior, apenas adicionamos umas poucas linhas a mais no código. Com um detalhe, este código ainda não está sendo corretamente estruturado. Aqui a minha intenção é lhe mostrar como podemos fazer as mesmas coisas vista anteriormente. Então adicionamos a linha 12, que é uma string que receberá o comando SQL que desejamos executar. Na linha 20 dizemos qual é este comando. No caso estaremos pedindo para o SQL criar uma tabela chamada tb_Symbol, caso ela não exista no banco de dados.

Logo depois usando a função DatabaseExecute, dizemos ao SQLite para executar o comando em SQL. Se este procedimento falhar, teremos na linha 23, uma mensagem sendo impressa no terminal do MetaTrader 5. Já que o banco se encontra aberto, precisamos fechá-lo. Isto é feito na linha 24. Já na linha 25 encerramos a execução do script no MetaTrader 5.

Agora preste atenção a uma coisa. Todo o comando que desejamos enviar para o SQLite executar. Isto quando estamos usando o SQLite presente no MetaTrader 5, faremos via DatabaseExecute. Porém, isto somente é adequado quando queremos dar ordens ao SQL. Quando desejamos fazer consultas precisamos fazer uso das demais funções também. Note como as coisas vão se encaixando a fim de que possamos desenvolver o que necessitamos desenvolver.

Então antes de partimos para ver como trabalhar com consultas. Vamos tornar este script em MQL5, um pouco mais versátil e por consequência melhor para podermos usar o banco de dados que estamos fazendo. Já que as coisas podem ser estruturadas de uma outra maneira. Podemos, tornar este mesmo script em uma classe. Mesmo que ela neste momento pareça simples. Isto já irá ajudar bastante, já que podemos tornar as coisas mais reutilizáveis e por consequência, mais seguras e estáveis. Então o mesmo código visto acima, passa a ser o que é visto abaixo. Só que agora usando classes para isto.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. #property description "Basic script for SQL database written in MQL5"
04. #property version   "1.00"
05. #property script_show_inputs
06. //+------------------------------------------------------------------+
07. input string user01 = "DataBase01";         //FileName
08. //+------------------------------------------------------------------+
09. class C_DB_SQLite
10. {
11.     private :
12.             int     m_handleDB;
13.     public  :
14. //+------------------------------------------------------------------+
15.             C_DB_SQLite(const string szFileName)
16.                     :m_handleDB(INVALID_HANDLE)
17.                     {
18.                             if ((m_handleDB = DatabaseOpen(szFileName, DATABASE_OPEN_CREATE | DATABASE_OPEN_READWRITE)) == INVALID_HANDLE)
19.                             {
20.                                     Print("Unable to create or open the file ", szFileName);
21.                                     return;
22.                             }
23.                     }
24. //+------------------------------------------------------------------+
25.             ~C_DB_SQLite()
26.                     {
27.                             DatabaseClose(m_handleDB);
28.                             Print("Closing Database...");
29.                     }
30. //+------------------------------------------------------------------+
31.             bool Command(const string szRequestSQL)
32.                     {
33.                             bool ret = DatabaseExecute(m_handleDB, szRequestSQL);                           
34.                             Print("Request execution: ", (ret ? "Success" : "Failed"), "...");
35.                             return ret;
36.                     }
37. //+------------------------------------------------------------------+
38. };
39. //+------------------------------------------------------------------+
40. void OnStart()
41. {
42.     C_DB_SQLite *DB;
43.     
44.     DB = new C_DB_SQLite(user01 + ".sqlite");
45.     
46.     (*DB).Command("CREATE TABLE IF NOT EXISTS tb_Symbol(id PRIMARY KEY, symbol NOT NULL UNIQUE);");
47.     
48.     delete DB;      
49. }
50. //+------------------------------------------------------------------+

Código em MQL5

Note que agora, temos uma estruturação muito mais elaborada a fim de trabalhar com o banco de dados. Isto por que não importa o que faremos. Sempre que estivermos enviando comandos para dentro do banco de dados, estaremos sempre enviando para o banco correto. Não importando se estamos com um ou dezenas de bancos abertos. O comando sempre será enviado para o banco correto. Isto por que estamos agora com as funções sendo usadas dentro da classe que foi criada entre as linhas 9 e 38. E olha que estamos apenas começando. E mesmo assim já temos toda a segurança que uma classe nos promove fazer uso.

Por exemplo, você não conseguirá usar um manipulador de arquivos, sem que ele tenha sido inicializado. E como a inicialização se dá via constructor da classe. Temos a garantia de que sempre estaremos usando um manipulador adequado. Isto pode ser visto, na linha 33, onde usamos o manipulador para enviar o comando ao SQL.

Agora quero que você preste atenção a uma coisa. Muitos podem achar desnecessário fazer uso, ou mesmo criar uma classe a fim de comportar o sistema de comunicação com o SQLite. Mas vamos pensar um pouco, e talvez isto lhe faça mudar de ideia. Você pode pensar o seguinte: Por que eu deveria criar uma classe, apenas para usar o SQLite presente no MetaTrader 5? É bem mais fácil usar diretamente as funções do MQL5, para promover isto. Ainda mais por que não farei uso massivo do SQL em meus programas. Bem, olhando por esta objetiva, devo concordar com você, meu caro leitor. Mas vamos ver as coisas de uma forma um pouco mais ampla. O MQL5, nos permite ter acesso fácil e simples ao SQLite presente no MetaTrader 5. Ok. Mas não devemos nos limitar a isto.

Se você desenvolver toda uma gama de aplicações, ou mesmo desenvolver um sistema que utiliza o SQLite presente no MetaTrader 5, fazendo uso apenas das funções presentes no MQL5. Ficará em algum momento limitado a ter que usar apenas e somente o SQLite do MetaTrader 5. Você não poderá usar uma compilação pessoal do SQLite em DLL, feita exclusivamente para você. E pior, se você em um dado momento, decidir usar uma outra implementação do SQL, seja o MySQL, seja o SQL Server, ou outro qualquer. Isto lhe dará muito trabalho, ter que repaginar todo o seu código a fim de conseguir cobrir as dependências necessárias. Isto por que o MySQL e o SQL Server que acabei de citar, não faz uso de um sistema de arquivos que você poderá acessar usando o MQL5. Você até poderá usar o MQL5, mas terá que fazer uso de uma outra ferramenta que já mostrei nesta sequência como usar. A tal ferramenta seria os soquetes.

Ou seja, para acessar bancos de dados que fazem uso de uma arquitetura cliente servidor, você terá que usar soquetes para isto. Se a sua implementação, foi pensada desde o princípio para usar um sistema de classes, a fim de ocultar como as coisas estão sendo implementadas. Tudo que você precisará fazer, será modificar a classe, adicionando ou a modificando de maneira que ela consiga dar o suporte necessários para que a comunicação via soquetes aconteça. Isto simplifica enormemente todo o trabalho de desenvolvimento. Pois, se você precisar mudar a implementação do SQL, do SQLite usado no MetaTrader 5, para um SQLite particular compilado em DLL. Será simples fazer tal tarefa.

A mesma coisa se aplica, se você precisar, mudar a implementação. Saindo do SQLite, que é baseada em arquivo, para um SQL, baseado em cliente servidor. Não terá grandes problemas. Bastará mudar a forma como a classe funciona e a restante do código irá se beneficiar com as mudanças. Simples assim. Então não despreze o poder que existe, quando se desenvolve uma aplicação pensando em futuramente mudar a forma como as coisas acontecem. Lembre-se: A tecnologia muda com o tempo. Fazer as coisas ficarem travadas ou ligadas de forma intrínseca a algo. Não é uma boa escolha.

Entendendo algumas coisas

Antes de continuarmos, quero mostrar a você, caro leitor, uma coisa. Pois é muito importante que você entenda algo. Vamos fazer o seguinte. Nos artigos anteriores, criamos um relacionamento entre tabelas de forma a termos um banco de dados relacional. Expliquei como você poderia fazer isto. As vantagens e desvantagens de tal forma de esquematizar o banco de dados de forma relacional. Mas quando vamos trabalhar com muitos comandos em SQL. Isto via SQLite, presente no MetaTrader 5, precisaremos tomar alguns cuidados. Ou melhor, precisamos bolar uma forma de fazer as coisas com mais segurança.

O que mostrarei, irá nos forçar a tomar algumas decisões no próximo artigo. Então observe com calma o seguinte código em MQL5, visto abaixo:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. #property description "Basic script for SQL database written in MQL5"
04. #property version   "1.00"
05. #property script_show_inputs
06. //+------------------------------------------------------------------+
07. input string user01 = "DataBase01";        //FileName
08. //+------------------------------------------------------------------+
09. class C_DB_SQLite
10. {
11.     private    :
12.         int    m_handleDB;
13.     public    :
14. //+------------------------------------------------------------------+
15.         C_DB_SQLite(const string szFileName)
16.             :m_handleDB(INVALID_HANDLE)
17.             {
18.                 if ((m_handleDB = DatabaseOpen(szFileName, DATABASE_OPEN_CREATE | DATABASE_OPEN_READWRITE)) == INVALID_HANDLE)
19.                 {
20.                     Print("Unable to create or open the file ", szFileName);
21.                     return;
22.                 }
23.             }
24. //+------------------------------------------------------------------+
25.         ~C_DB_SQLite()
26.             {
27.                 DatabaseClose(m_handleDB);
28.                 Print("Closing Database...");
29.             }
30. //+------------------------------------------------------------------+
31.         bool Command(const string szRequestSQL)
32.             {
33.                 bool ret = DatabaseExecute(m_handleDB, szRequestSQL);                
34.                 Print("Request execution: ", (ret ? "Success" : "Failed"), "...");
35.                 return ret;
36.             }
37. //+------------------------------------------------------------------+
38. };
39. //+------------------------------------------------------------------+
40. void OnStart()
41. {
42.     C_DB_SQLite *DB;
43.     
44.     DB = new C_DB_SQLite(user01 + ".sqlite");
45.     
46.     (*DB).Command("PRAGMA FOREIGN_KEYS = ON;");    
47.     (*DB).Command("CREATE TABLE IF NOT EXISTS tb_Symbols"
48.                   "("
49.                     "id PRIMARY KEY,"
50.                     "symbol NOT NULL UNIQUE"
51.                   ");");
52.     (*DB).Command("CREATE TABLE IF NOT EXISTS tb_Quotes"
53.                   "("
54.                     "of_day NOT NULL,"
55.                     "price NOT NULL,"
56.                     "fk_id NOT NULL,"
57.                     "FOREIGN KEY (fk_id) REFERENCES tb_Symbols(id)"
58.                   ");");    
59.     delete DB;
60. }
61. //+------------------------------------------------------------------+

Código em MQL5

Observe como os comandos estão sendo colocados dentro do código MQL5. Isto para que possamos executar comandos em SQL. Não é raro, durante a digitação de tantas coisas, acabarmos por fazer alguma besteira. Agora observe o script logo abaixo:

01. PRAGMA FOREIGN_KEYS = ON;
02. 
03. CREATE TABLE IF NOT EXISTS tb_Symbols
04. (
05.     id PRIMARY KEY,
06.     symbol NOT NULL UNIQUE
07. );
08. 
09. CREATE TABLE IF NOT EXISTS tb_Quotes
10. (
11.     of_day NOT NULL,
12.     price NOT NULL,
13.     fk_id NOT NULL,
14.     FOREIGN KEY (fk_id) REFERENCES tb_Symbols(id)
15. );

Código em SQLite

Compare este script visto com o anterior. Note que apesar deste último está usando o SQL puro, podendo ter a sua sintaxe analisada durante a digitação. Não temos a mesma facilidade quando estamos inserindo strings diretamente no código MQL5. Isto para que o MQL5, possa fazer com que o SQLite presente no MetaTrader 5, cumpra adequadamente a suas tarefas. Ou seja, se durante a digitação do código SQL. Isto dentro de uma string no código MQL5, cometermos um erro de digitação. O SQL não irá executar adequadamente o nosso código. E você poderá acabar pondo toda a culpa no MQL5 ou mesmo no MetaTrader 5. O que é um grande equívoco. Porém, observe que estamos criando em ambos códigos um banco com tabelas relacionadas. E se você por um acaso, em algum ponto, digitar o nome da tabela tb_Symbols como tb_Symbol, o resultado será completamente diferente do mostrado na figura abaixo.

Note que se você tentar olhar esta mesma estrutura vista na figura acima, no MetaEditor não conseguirá. Já falei sobre isto em um outro artigo. Se você não entende o que está se passando aqui. Aconselho a você olhar os artigos onde estive explicando sobre o SQL e como obter os programas necessários para fazer um melhor uso do sistema SQL.

Mas a questão que quero ressaltar aqui é justamente esta. Olhando o código SQL, isto dentro de uma string, o mesmo pode conter erros, que você não irá perceber facilmente. Porém se você usar um editor, capaz se analisar o código SQL, será bem mais simples perceber tais falhas. Como você pode ver logo abaixo.

Note que é muito mais fácil perceber onde está alguma falha no código do script em SQL. Como eu disse há pouco, não é raro, você como programador cometer erros durante a digitação. Então fazer uso das ferramentas corretas pode lhe poupar muito tempo, tentando entender por que um código está ou não funcionando. Pois na maior parte das vezes, o erro está justamente na questão da digitação de algum comando.

Considerações finais

Neste artigo, começamos a explorar o uso do SQL dentro de um código MQL5. Vimos como podemos cria um banco de dados. Ou melhor dizendo, como podemos criar um arquivo de banco de dados em SQLite, usando para isto dispositivos ou procedimentos contidos dentro da linguagem MQL5. Vimos também, como criar uma tabela e depois como criar uma relação entre tabelas via chave primária e chave estrangeira. Isto tudo, usando novamente o MQL5. Vimos como é simples tornar um código que poderá no futuro ser portado para outras implementações do SQL, usando uma classe para nos ajudar a ocultar a implementação que está sendo criada.

E o mais importante de tudo. Vimos que em diversos momentos, podemos correr o risco de fazer algo não dar certo ao usarmos SQL. Isto devido ao fato de que dentro do código MQL5, um código SQL irá ser colocado como sendo uma STRING. E o fato de isto acontecer, torna bastante provável que algo possa dar errado. Tornando a execução do código SQL dentro do MQL5, algo problemático, devido a uma falha de digitação. Porém, podemos e iremos criar um mecanismo que nos permitirá, além de um melhor grau de liberdade, evitar tais problemas. Visto que existem editores cujo propósito é nos permitir ler com mais facilidade o código de um script em SQL.

Então no próximo artigo, iremos criar um mecanismo para facilitar tal portabilidade. Muitos com alguma experiência, já devem estar logo imaginando do que se trata. Mas se este não é o seu caso, não se preocupe. No próximo artigo veremos como isto será feito. E vamos continuar no nosso campo de trabalho em SQL, só que agora usando o MQL5 como base de execução. Isto para que o MetaTrader 5, possa fazer com que o nosso sistema de replay / simulador, comece a fazer uso de banco de dados em suas atividades. Então bons estudos, e nos vemos no próximo artigo, onde a coisa ficará ainda mais interessante de ser feita.

Arquivo	Descrição
Experts\Expert Advisor.mq5	Demonstra a interação entre o Chart Trade e o Expert Advisor (É necessário o Mouse Study para interação)
Indicators\Chart Trade.mq5	Cria a janela para configuração da ordem a ser enviada (É necessário o Mouse Study para interação)
Indicators\Market Replay.mq5	Cria os controles para interação com o serviço de replay/simulador (É necessário o Mouse Study para interação)
Indicators\Mouse Study.mq5	Permite interação entre os controles gráficos e o usuário (Necessário tanto para operar o replay simulador, quanto no mercado real)
Services\Market Replay.mq5	Cria e mantém o serviço de replay e simulação de mercado (Arquivo principal de todo o sistema)
Code VS C++\Servidor.cpp	Cria e mantém um soquete servidor criado em C++ (Versão Mini Chat)
Code in Python\Server.py	Cria e mantém um soquete em python para comunicação entre o MetaTrader 5 e o Excel
Indicators\Mini Chat.mq5	Permite implementar um mini chat via indicador (Necessário uso de um servidor para funcionar)
Experts\Mini Chat.mq5	Permite implementar um mini chat via Expert Advisor (Necessário uso de um servidor para funcionar)
Scripts\SQLite.mq5	Demonstra uso de script SQL por meio do MQL5
Files\Script 01.sql	Demonstra a criação de uma tabela simples, com chave estrangeira
Files\Script 02.sql	Demonstra a adição de valores em uma tabela