Examples with TypedReturnCode org.talend.utils.sugars.TypedReturnCode used on opensource projects

Example 26 with TypedReturnCode

use of org.talend.utils.sugars.TypedReturnCode in project tdq-studio-se by Talend.

the class DependenciesHandler method removeConnDependencyAndSave.

/**
 * delete the dependency between analysis and connection,then save the connection and analysis.
 *
 * @param analysis
 * @return whether it has been deleted
 */
public boolean removeConnDependencyAndSave(TDQAnalysisItem analysisItem) {
    Analysis analysis = analysisItem.getAnalysis();
    Connection oldDataProvider = (Connection) analysis.getContext().getConnection();
    ReturnCode rect = new TypedReturnCode<Object>(Boolean.TRUE);
    // Remove old dependencies.
    if (oldDataProvider != null) {
        List<ModelElement> tempList = new ArrayList<ModelElement>();
        tempList.add(oldDataProvider);
        DependenciesHandler.getInstance().removeDependenciesBetweenModels(analysis, tempList);
        Property property = PropertyHelper.getProperty(oldDataProvider);
        if (property != null) {
            rect = ElementWriterFactory.getInstance().createDataProviderWriter().save(property.getItem(), false);
        } else {
            rect.setOk(Boolean.FALSE);
        }
        if (!rect.isOk()) {
            // $NON-NLS-1$
            rect.setMessage(Messages.getString("DependenciesHandler.removeDependFailed"));
            log.error(rect.getMessage());
        } else {
            analysis.getContext().setConnection(null);
            analysis.getClientDependency().clear();
            rect = ElementWriterFactory.getInstance().createAnalysisWrite().save(analysisItem, false);
        }
    } else {
        // $NON-NLS-1$ //$NON-NLS-2$
        log.warn(Messages.getString("DependenciesHandler.removeDependFailByNull", "oldDataProvider"));
    }
    return rect.isOk();
}

Example 27 with TypedReturnCode

use of org.talend.utils.sugars.TypedReturnCode in project tdq-studio-se by Talend.

the class ConnectionService method createConnection.

public static TypedReturnCode<Connection> createConnection(DBConnectionParameter parameter) {
    TypedReturnCode<Connection> tReturnCode = new TypedReturnCode<Connection>(false);
    MetadataFillFactory instance = null;
    instance = MetadataFillFactory.getDBInstance();
    IMetadataConnection metaConnection = instance.fillUIParams(ParameterUtil.toMap(parameter));
    ReturnCode rc = instance.createConnection(metaConnection);
    if (rc.isOk()) {
        Connection dbConn = instance.fillUIConnParams(metaConnection, null);
        DatabaseMetaData dbMetadata = null;
        List<String> packageFilter = ConnectionUtils.getPackageFilter(parameter);
        java.sql.Connection sqlConn = null;
        try {
            if (rc instanceof TypedReturnCode) {
                @SuppressWarnings("rawtypes") Object sqlConnObject = ((TypedReturnCode) rc).getObject();
                if (sqlConnObject instanceof java.sql.Connection) {
                    sqlConn = (java.sql.Connection) sqlConnObject;
                    dbMetadata = org.talend.utils.sql.ConnectionUtils.getConnectionMetadata(sqlConn);
                }
            }
            instance.fillCatalogs(dbConn, dbMetadata, packageFilter);
            instance.fillSchemas(dbConn, dbMetadata, packageFilter);
            tReturnCode.setObject(dbConn);
        } catch (SQLException e) {
            log.error(e, e);
        // Need to add a dialog for report the reson of error
        } finally {
            if (sqlConn != null) {
                ConnectionUtils.closeConnection(sqlConn);
            }
        }
    } else {
        tReturnCode.setMessage(rc.getMessage());
        tReturnCode.setOk(false);
    }
    return tReturnCode;
}

Example 28 with TypedReturnCode

use of org.talend.utils.sugars.TypedReturnCode in project tdq-studio-se by Talend.

the class FunctionalDependencyExecutor method runAnalysis.

@Override
protected boolean runAnalysis(Analysis analysis, String sqlStatement) {
    Boolean runStatus = Boolean.TRUE;
    TypedReturnCode<java.sql.Connection> trc = this.getConnectionBeforeRun(analysis);
    if (!trc.isOk()) {
        log.error(trc.getMessage());
        setError(trc.getMessage());
        traceError(Messages.getString("FunctionalDependencyExecutor.CANNOTEXECUTEANALYSIS", analysis.getName(), // $NON-NLS-1$
        trc.getMessage()));
        return Boolean.FALSE;
    }
    Connection connection = trc.getObject();
    try {
        // execute the sql statement for each indicator
        EList<Indicator> indicators = analysis.getResults().getIndicators();
        EList<Indicator> deactivatedIndicators = analysis.getParameters().getDeactivatedIndicators();
        for (Indicator indicator : indicators) {
            if (deactivatedIndicators.contains(indicator)) {
                // do not evaluate this indicator
                continue;
            }
            Expression query = dbms().getInstantiatedExpression(indicator);
            if (query == null) {
                // TODO internationalize the string.
                traceError(// $NON-NLS-1$//$NON-NLS-2$
                "Query not executed for indicator: \"" + AnalysisExecutorHelper.getIndicatorName(indicator) + "\" " + // $NON-NLS-1$
                "query is null");
                runStatus = Boolean.FALSE;
                continue;
            }
            try {
                boolean exeStatus = executeQuery(indicator, connection, query);
                if (!exeStatus) {
                    // TODO internationalize the string.
                    traceError(// $NON-NLS-1$//$NON-NLS-2$
                    "Query not executed for indicator: \"" + AnalysisExecutorHelper.getIndicatorName(indicator) + "\" " + "SQL query: " + // $NON-NLS-1$
                    query.getBody());
                    runStatus = Boolean.FALSE;
                    continue;
                }
            } catch (AnalysisExecutionException e) {
                traceError(e.getMessage());
                runStatus = Boolean.FALSE;
                continue;
            }
            indicator.setComputed(true);
        }
    } finally {
        ReturnCode rc = closeConnection(analysis, connection);
        if (!rc.isOk()) {
            runStatus = Boolean.FALSE;
        }
    }
    return runStatus;
}

Example 29 with TypedReturnCode

use of org.talend.utils.sugars.TypedReturnCode in project tdq-studio-se by Talend.

the class AnalysisExecutor method runAnalysis.

/**
 * Method "runAnalysis". Mod 20130314 TDQ-5973 refactor to extract same part here
 *
 * @param analysis the analysis to be run
 * @param sqlStatement the sql statement to execute on Database
 * @return true if ok
 */
protected boolean runAnalysis(Analysis analysis, String sqlStatement) {
    // Open connection
    TypedReturnCode<java.sql.Connection> connection = this.getConnectionBeforeRun(analysis);
    if (!connection.isOk()) {
        traceError(connection.getMessage());
        return Boolean.FALSE;
    }
    // abstract method
    ReturnCode rc = evaluate(analysis, connection.getObject(), sqlStatement);
    // close connection
    ReturnCode rcon = closeConnection(analysis, connection.getObject());
    if (!rc.isOk()) {
        traceError(rc.getMessage());
    }
    return rc.isOk() && rcon.isOk();
}

Example 30 with TypedReturnCode

use of org.talend.utils.sugars.TypedReturnCode in project tdq-studio-se by Talend.

the class CreateDuplicatesAnalysisAction method run.

@Override
public void run() {
    ReturnCode success = new ReturnCode(true);
    if (this.getColumnsMap() == null || this.getColumnsMap().isEmpty() || this.getConnection() == null) {
        return;
    }
    try {
        Set<ColumnSet> keySet = this.getColumnsMap().keySet();
        for (ColumnSet cs : keySet) {
            List<TdColumn> columns = this.getColumnsMap().get(cs);
            // create the analysis
            Analysis analysis = null;
            AnalysisBuilder analysisBuilder = new AnalysisBuilder();
            boolean analysisInitialized = analysisBuilder.initializeAnalysis(getAnalysisName(cs), AnalysisType.MULTIPLE_COLUMN);
            if (analysisInitialized) {
                analysis = analysisBuilder.getAnalysis();
            }
            fillMetadataToAnalysis(analysis, createDefaultAnalysisParameter(cs));
            // add Connection into the Analysis Context
            analysis.getContext().setConnection(this.getConnection());
            for (TdColumn theColumn : columns) {
                // add TdColumn into the Analysis Context
                analysis.getContext().getAnalysedElements().add(theColumn);
                // create Row Count Indicator
                RowCountIndicator rcIndicator = IndicatorsFactory.eINSTANCE.createRowCountIndicator();
                rcIndicator.setAnalyzedElement(theColumn);
                DefinitionHandler.getInstance().setDefaultIndicatorDefinition(rcIndicator);
                analysis.getResults().getIndicators().add(rcIndicator);
                // create Duplicate Count Indicator
                DuplicateCountIndicator dcIndicator = IndicatorsFactory.eINSTANCE.createDuplicateCountIndicator();
                dcIndicator.setAnalyzedElement(theColumn);
                DefinitionHandler.getInstance().setDefaultIndicatorDefinition(dcIndicator);
                analysis.getResults().getIndicators().add(dcIndicator);
            }
            // create dependencies
            DependenciesHandler.getInstance().setDependencyOn(analysis, this.getConnection());
            // set the domain
            for (Domain domain : analysis.getParameters().getDataFilter()) {
                domain.setName(analysis.getName());
            }
            // set execution language
            analysis.getParameters().setExecutionLanguage(ExecutionLanguage.SQL);
            // save the analysis
            RepositoryNode analysisRepNode = (RepositoryNode) RepositoryNodeHelper.getDataProfilingFolderNode(EResourceConstant.ANALYSIS);
            IFolder folder = WorkbenchUtils.getFolder(analysisRepNode);
            AnalysisWriter analysisWriter = ElementWriterFactory.getInstance().createAnalysisWrite();
            TypedReturnCode<Object> create = analysisWriter.create(analysis, folder);
            if (create.isOk()) {
                // refresh the RepositoryView
                CorePlugin.getDefault().refreshDQView(analysisRepNode);
                // open the editor
                AnalysisRepNode anaRepNode = RepositoryNodeHelper.recursiveFindAnalysis(analysis);
                AnalysisItemEditorInput analysisEditorInput = new AnalysisItemEditorInput(anaRepNode);
                IRepositoryNode connectionRepNode = RepositoryNodeHelper.recursiveFind(this.getConnection());
                analysisEditorInput.setConnectionNode(connectionRepNode);
                CorePlugin.getDefault().openEditor(analysisEditorInput, AnalysisEditor.class.getName());
            } else {
                success.setOk(false);
                success.setMessage(create.getMessage());
            }
        }
    // for
    } catch (Exception e) {
        success.setOk(false);
        success.setMessage(e.getMessage());
    }
    if (!success.isOk()) {
        MessageUI.openError(success.getMessage());
    }
}