Salvar os resultados do banco de dados no DB

Este exemplo trata de salvar o conteúdo do banco de dados em um banco de dados, implementado como snippet CustomAnalysis.

Nota! Havia um pequeno bug na extensão original - ele usou um pacote que ainda não estava disponível na versão lançada do SQ X. Por favor, recarregue o snippet.

Ele usa SQLite DB para simplificar, mas não há problema em usar MySql ou MariaDB ou qualquer outro banco de dados, porque ele usa a conexão de banco de dados JDBC que é um padrão Java ao se conectar e se comunicar com bancos de dados.
Ao utilizar outro banco de dados, você precisará fazê-lo:

• mudar a corda de conexão JDBC em createDBConnection() método
• talvez seja necessário adicionar a biblioteca JDBC para seu banco de dados alvo - SQLite já está incluída no SQX, mas bancos de dados como MySql ou MariaDB não estão - então você precisará encontrar sua biblioteca JDBC (algo como https://dev.mysql.com/downloads/connector/j/ e adicionar seu(s) arquivo(s) JAR à pasta {StrategyQuant installation}/user/libs.

bastante complexo, porque guarda a visão exata do banco de dados que você vê na IU - se você não quiser usar a visão você pode simplesmente obter valores como lucro líquido, número de negócios, etc. do ResultsGroup e salvá-los por conta própria.

A lógica principal é, na verdade, muito simples:

@Override
public ArrayList processDatabank(String project, String task, String databankName, ArrayList databankRG) lança Exceção {
    Banco de dados = ProjectEngine.get(projeto).getDatabanks().get(banco de dadosNome);
    if(databank == nulo){
        lançar nova Exceção ("Databank " + projeto + "/" + banco de dadosNome + " não existe");
    }

    DatabankTableView view = banco de dados.getView();

    String tableName = getTableName(projeto, tarefa, banco de dadosNome);

    try (Conexão dbConnection = createDBConnection(tableName, view)) {
        dbConnection.setAutoCommit(false);

        try (Declaração stmt = dbConnection.createStatement()) {
            para (int a = 0; a < banco de dadosRG.size(); a++) {
                ResultadosGrupo rg = banco de dadosRG.get(a);
                writeData(rg, view, tableName, stmt);
            }
        }

        dbConnection.commit();
    }

    banco de dados de retornoRG;
}

O código criará a conexão DB, criará Statement, depois passará por ResultGroups armazenados em banco de dados e salvará cada um deles no DB usando o comando SQL padrão.

Código completo do snippet (também pode ser baixado no anexo a este post):

pacote SQ.CustomAnalysis;

import com.strategyquant.lib.SQTime;
importar com.strategyquant.lib.SQUtils;
import com.strategyquant.tradinglib.*;
import com.strategyquant.tradinglib.databank.DatabankTableColumnEntry;
importar com.strategyquant.tradinglib.databank.DatabankTableView;
import com.strategyquant.tradinglib.project.projectEngine;
importação org.joda.time.format.DateTimeFormat;
importação org.joda.time.format.DateTimeFormat;
importação org.slf4j.logger;
importação org.slf4j.LoggerFactory;

conexão java.sql.import;
importação java.sql.DriverManager;
importação de java.sql.SQLException;
importação de java.sql.Statement;
importação java.util.ArrayList;
importação de java.util.HashMap;

classe pública SaveDatabankToDB estende o Método Análises Personalizadas {

    logger final estático público = LoggerFactory.getLogger("SaveDatabankToDB");

    privado estático final TABELA_NAME_SEPARADOR = "__";
    private static final DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern("yyyyy-MM-dd-HHmm");

    public static final String TABLE_NAME = "databankData";

    privado estático final String STRATEGY_COLUMN_NAME = "strategyName" (nome da estratégia);

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    //------------------------------------------------------------------------

    /**
     * Instanta um novo método de análise personalizado.
     */
    público SaveDatabankToDB() {
        super("SaveDatabankToDB", TYPE_PROCESS_DATABANK);
    }


    //------------------------------------------------------------------------

    @Override
    filtro booleano públicoEstratégia(projeto String, tarefa String, banco de dados StringName, ResultsGroup rg) lança Exceção {
        retornar verdadeiro;
    }

    //------------------------------------------------------------------------

    @Override
    public ArrayList processDatabank(String project, String task, String databankName, ArrayList databankRG) lança Exceção {
        Banco de dados = ProjectEngine.get(projeto).getDatabanks().get(banco de dadosNome);
        if(databank == nulo){
            lançar nova Exceção ("Databank " + projeto + "/" + banco de dadosNome + " não existe");
        }

        DatabankTableView view = banco de dados.getView();

        String tableName = getTableName(projeto, tarefa, banco de dadosNome);

        try (Conexão dbConnection = createDBConnection(tableName, view)) {
            dbConnection.setAutoCommit(false);

            try (Declaração stmt = dbConnection.createStatement()) {
                para (int a = 0; a < banco de dadosRG.size(); a++) {
                    ResultadosGrupo rg = banco de dadosRG.get(a);
                    writeData(rg, view, tableName, stmt);
                }
            }

            dbConnection.commit();
        }

        banco de dados de retornoRG;
    }

    //------------------------------------------------------------------------

    public static String getOutputFolder(){
        retornar "C:/SQDatabankExports";
    }

    //------------------------------------------------------------------------

    Conexão Privada CriarDBConexão(String tableName, DatabankTableView view) lança Exceção {
        Conexão c = nula;

        tente {
            Class.forName("org.sqlite.JDBC");
            String folderPath = getOutputFolder();

            SQUtils.ensureDirExists(pastaPath);

            String dbPath = String.format("%s/%s.db", folderPath, tableName);
            String connectionString = String.format("jdbc:sqlite:%s", dbPath);

            c = DriverManager.getConnection(connectionString);

            tryCreateTable(c, tableName, view);
        }
        captura (Exceção e ) {
            Log.error("Criando conexão de banco de dados falhou", e);
            lançar e;
        }

        retornar c;
    }

    //------------------------------------------------------------------------

    public static String getTableName(String projectName, String taskName, String databankName){
        String dateTime = dateTimeFormatter.print(System.currentTimeMillis());
        data de retornoTimeTime + TABLE_NAME_SEPARATOR + projectName + TABLE_NAME_SEPARATOR + taskName + TABLE_NAME_SEPARATOR + databankName;
    }

    //------------------------------------------------------------------------

    vazio privado tryCreateTable(Conexão de conexão, String tableName, DatabankTableView view) lança Exceção {
        if(view === nulo){
            lançar nova Exceção ("Databank view is null");
        }

        Declaração stmt = nula;
        tentar {
            StringBuilder sb = novo StringBuilder(STRATEGY_COLUMN_NAME).append(" TEXT PRIMARY KEY");

            ColunaNomesColunaResolver ColunaNomesResolver = nova ColunaNomesResolver();

            for(int a=0; a<view.columns.size(); a++){
                Banco de dadosTableColumnEntry column = view.columns.get(a);
                String columnName = columnNamesResolver.getColumnName(column);

                sb.append(",");
                sb.append(columnName);
                sb.append("," TEXTO");
            }

            String sql = String.format("CREATE TABLE IF NOT EXISTS %s (%s);", TABLE_NAME, sb);

            stmt = connection.createStatement();
            stmt.executeUpdate(sql);
        }
        finalmente {
            if(stmt != null) {
                stmt.close();
            }
        }
    }

    //------------------------------------------------------------------------

    dados privados nulos de escrita (ResultsGroup rg, DatabankTableView view, String tableName, Statement stmt) lança SQLException {
        StringBuilder columnNames = novo StringBuilder();
        valores StringBuilder = novo StringBuilder();

        ColunaNomesColunaResolver ColunaNomesResolver = nova ColunaNomesResolver();

        columnNames.append(STRATEGY_COLUMN_NAME);
        values.append("'").append(rg.getName()).append("'");

        para (int a = 0; a < view.columns.size(); a++) {
            Banco de dadosTableColumnEntry column = view.columns.get(a);
            String columnName = columnNamesResolver.getColumnName(column);
            Valor da corda = "N/A";

            tente {
                valor = coluna.tabelaColuna.exportValor(rg, nulo, Directions.Both, PlTypes.Money, SampleTypes.FullSample);
            } catch (Exceção e) {
                Log.error("Error getting value for strategy + " + rg.getName() + " e coluna " + columnName, e);
            }

            columnNames.append(",").append(columnName);
            values.append(",").append("'").append(value).append("'");
        }

        String sql = String.format("INSERT INTO %s (%s) VALORES (%s)", TABLE_NAME, colunaNomes, valores);
        stmt.executeUpdate(sql);
    }

    //------------------------------------------------------------------------

    classe privada ColumnNamesResolver {

        Private HashMap columnNameCounts = novo HashMap();

        public String getColumnName(DatabankTableColumnEntry columnEntry){
            String columnName = columnEntry.tableColumn.getClass().getSimpleName();
            String finalColumnName = null;

            //código de acompanhamento cuida de várias colunas com o mesmo nome dentro da visualização do banco de dados
            Integer columnCount = columnNameCounts.get(columnName);
            if(columnCount != nulo){
                colunaContar += 1;
                finalColunaNome = colunaNome + colunaContar;
            }
            senão {
                columnCount = 1;
                finalColunaNome = ColunaNome;
            }

            columnNameCounts.put(columnName, columnCount);

            devolver finalColumnName;
        }

    }
}