Examples with OutputTable org.talend.designer.dbmap.model.emf.dbmap.OutputTable used on opensource projects

Example 1 with OutputTable

use of org.talend.designer.dbmap.model.emf.dbmap.OutputTable in project tdi-studio-se by Talend.

the class DbMapComponent method buildExternalData.

@Override
public void buildExternalData(AbstractExternalData abstractData) {
    externalData = new ExternalDbMapData();
    if (abstractData instanceof DBMapData) {
        DBMapData mapperData = (DBMapData) abstractData;
        List<ExternalDbMapTable> externalTables = new ArrayList<ExternalDbMapTable>();
        // input
        for (InputTable pTable : mapperData.getInputTables()) {
            ExternalDbMapTable externalTable = new ExternalDbMapTable();
            externalTable.setName(pTable.getName());
            externalTable.setMinimized(pTable.isMinimized());
            externalTable.setAlias(pTable.getAlias());
            externalTable.setJoinType(pTable.getJoinType());
            externalTable.setTableName(pTable.getTableName());
            List<ExternalDbMapEntry> entities = new ArrayList<ExternalDbMapEntry>();
            for (DBMapperTableEntry pEntity : pTable.getDBMapperTableEntries()) {
                ExternalDbMapEntry entity = new ExternalDbMapEntry();
                entity.setExpression(pEntity.getExpression());
                entity.setJoin(pEntity.isJoin());
                entity.setName(pEntity.getName());
                entity.setOperator(pEntity.getOperator());
                entities.add(entity);
            }
            externalTable.setMetadataTableEntries(entities);
            externalTables.add(externalTable);
        }
        externalData.setInputTables(externalTables);
        // output
        externalTables = new ArrayList<ExternalDbMapTable>();
        for (OutputTable pTable : mapperData.getOutputTables()) {
            ExternalDbMapTable externalTable = new ExternalDbMapTable();
            externalTable.setName(pTable.getName());
            externalTable.setMinimized(pTable.isMinimized());
            externalTable.setTableName(pTable.getTableName());
            List<ExternalDbMapEntry> entities = new ArrayList<ExternalDbMapEntry>();
            for (DBMapperTableEntry pEntity : pTable.getDBMapperTableEntries()) {
                ExternalDbMapEntry entity = new ExternalDbMapEntry();
                entity.setExpression(pEntity.getExpression());
                entity.setName(pEntity.getName());
                entities.add(entity);
            }
            externalTable.setMetadataTableEntries(entities);
            // filters
            entities = new ArrayList<ExternalDbMapEntry>();
            List<ExternalDbMapEntry> otherFilterEntities = new ArrayList<ExternalDbMapEntry>();
            for (FilterEntry pFilter : pTable.getFilterEntries()) {
                ExternalDbMapEntry entity = new ExternalDbMapEntry();
                entity.setExpression(pFilter.getExpression());
                entity.setName(pFilter.getName());
                if (FilterTableEntry.OTHER_FILTER.equals(pFilter.getFilterKind())) {
                    otherFilterEntities.add(entity);
                } else {
                    entities.add(entity);
                }
            }
            externalTable.setCustomWhereConditionsEntries(entities);
            externalTable.setCustomOtherConditionsEntries(otherFilterEntities);
            externalTables.add(externalTable);
        }
        externalData.setOutputTables(externalTables);
    }
    this.setExternalData(externalData);
}

Example 2 with OutputTable

use of org.talend.designer.dbmap.model.emf.dbmap.OutputTable in project tdi-studio-se by Talend.

the class DBMapDataImpl method equals.

/**
     * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
     * @generated not
     */
@Override
public boolean equals(Object obj) {
    if (this == obj) {
        return true;
    }
    if (obj == null) {
        return false;
    }
    if (getClass() != obj.getClass()) {
        return false;
    }
    DBMapDataImpl dbObj = (DBMapDataImpl) obj;
    EList<InputTable> inputs = dbObj.getInputTables();
    EList<OutputTable> outputs = dbObj.getOutputTables();
    EList<VarTable> vars = dbObj.getVarTables();
    if (inputs.size() != getInputTables().size()) {
        return false;
    }
    if (outputs.size() != getOutputTables().size()) {
        return false;
    }
    if (vars.size() != getVarTables().size()) {
        return false;
    }
    for (InputTable inputTable : inputTables) {
        boolean found = false;
        for (InputTable input : inputs) {
            if (inputTable.getName().equals(input.getName())) {
                found = true;
                if (!inputTable.equals(input)) {
                    return false;
                }
                break;
            }
        }
        if (found == false) {
            return false;
        }
    }
    for (OutputTable outputTable : outputTables) {
        boolean found = false;
        for (OutputTable output : outputs) {
            if (outputTable.getName().equals(output.getName())) {
                found = true;
                if (!outputTable.equals(output)) {
                    return false;
                }
                break;
            }
        }
        if (found == false) {
            return false;
        }
    }
    for (VarTable varTable : varTables) {
        boolean found = false;
        for (VarTable var : vars) {
            if (varTable.getName().equals(var.getName())) {
                found = true;
                if (!varTable.equals(var)) {
                    return false;
                }
                break;
            }
        }
        if (found == false) {
            return false;
        }
    }
    return true;
}

Example 3 with OutputTable

use of org.talend.designer.dbmap.model.emf.dbmap.OutputTable in project tdi-studio-se by Talend.

the class DBMapSplitTableConstraintFiltersMigrationTask method execute.

/*
     * (non-Javadoc)
     * 
     * @see org.talend.core.model.migration.AbstractItemMigrationTask#execute(org.talend.core.model.properties.Item)
     */
@Override
public ExecutionResult execute(Item item) {
    IProxyRepositoryFactory factory = CorePlugin.getDefault().getRepositoryService().getProxyRepositoryFactory();
    ProcessType processType = getProcessType(item);
    boolean modified = false;
    if (processType != null) {
        for (Object obj : processType.getNode()) {
            NodeType nodeType = (NodeType) obj;
            AbstractExternalData externalData = nodeType.getNodeData();
            if (externalData instanceof DBMapData) {
                DBMapData mapperData = (DBMapData) externalData;
                for (OutputTable pTable : mapperData.getOutputTables()) {
                    int i = 0;
                    List<FilterEntry> needSplitFilters = new ArrayList<FilterEntry>();
                    List<FilterEntry> newFilters = new ArrayList<FilterEntry>();
                    for (FilterEntry pFilter : pTable.getFilterEntries()) {
                        String expression = pFilter.getExpression();
                        if (expression != null && !expression.trim().isEmpty()) {
                            if (!DbGenerationManager.containWith(expression, DbMapSqlConstants.GROUP_BY_PATTERN, false) && !DbGenerationManager.containWith(expression, DbMapSqlConstants.ORDER_BY_PATTERN, false)) {
                                continue;
                            } else {
                                // can not split the clause directly here, because clause like this(a = b GROUP BY
                                // c) will be put at
                                // the end of where clause
                                needSplitFilters.add(pFilter);
                            }
                        }
                    }
                    if (!needSplitFilters.isEmpty()) {
                        EList<FilterEntry> entryList = pTable.getFilterEntries();
                        for (FilterEntry pFilter : needSplitFilters) {
                            String expression = pFilter.getExpression().trim();
                            int splitIndex = firstIndexInString(expression, DbMapSqlConstants.GROUP_BY_PATTERN);
                            int orderIndex = firstIndexInString(expression, DbMapSqlConstants.ORDER_BY_PATTERN);
                            if (splitIndex < 0 || (0 <= orderIndex && orderIndex < splitIndex)) {
                                splitIndex = orderIndex;
                            }
                            if (splitIndex == 0) {
                                // keep the order of "GROUP BY" and "ORDER BY"
                                pFilter.setFilterKind(FilterTableEntry.OTHER_FILTER);
                                entryList.remove(pFilter);
                                newFilters.add(pFilter);
                            } else {
                                String whereClause = expression.substring(0, splitIndex);
                                if (//$NON-NLS-1$
                                !DbGenerationManager.containWith(expression, DbMapSqlConstants.OR + "\\b", true) && !DbGenerationManager.containWith(expression, DbMapSqlConstants.AND + "\\b", true)) {
                                    //$NON-NLS-1$ 
                                    //$NON-NLS-1$
                                    whereClause = DbMapSqlConstants.AND + " " + whereClause;
                                }
                                pFilter.setExpression(whereClause);
                                FilterEntry tFilter = DbmapFactory.eINSTANCE.createFilterEntry();
                                //$NON-NLS-1$
                                tFilter.setName("newFilterSplited" + ++i);
                                tFilter.setExpression(expression.substring(splitIndex).trim());
                                tFilter.setFilterKind(FilterTableEntry.OTHER_FILTER);
                                entryList.remove(pFilter);
                                entryList.add(pFilter);
                                newFilters.add(tFilter);
                            }
                            modified = true;
                        }
                        if (!newFilters.isEmpty()) {
                            pTable.getFilterEntries().addAll(newFilters);
                            modified = true;
                        }
                    }
                }
            }
        }
    }
    try {
        if (modified) {
            factory.save(item, true);
            return ExecutionResult.SUCCESS_WITH_ALERT;
        } else {
            return ExecutionResult.SUCCESS_NO_ALERT;
        }
    } catch (Exception e) {
        ExceptionHandler.process(e);
        return ExecutionResult.FAILURE;
    }
}

Example 4 with OutputTable

use of org.talend.designer.dbmap.model.emf.dbmap.OutputTable in project tdi-studio-se by Talend.

the class DBMapHelper method saveDataToEmf.

public static void saveDataToEmf(DBMapData emfMapperData, ExternalDbMapData externalData) {
    // input
    if (externalData.getInputTables() != null && !externalData.getInputTables().isEmpty()) {
        for (ExternalDbMapTable table : externalData.getInputTables()) {
            final InputTable persistentTable = DbmapFactory.eINSTANCE.createInputTable();
            persistentTable.setMinimized(table.isMinimized());
            persistentTable.setName(table.getName());
            persistentTable.setAlias(table.getAlias());
            persistentTable.setJoinType(table.getJoinType());
            persistentTable.setTableName(table.getTableName());
            if (table.getMetadataTableEntries() != null && !table.getMetadataTableEntries().isEmpty()) {
                List<DBMapperTableEntry> persistentEntities = new ArrayList<DBMapperTableEntry>();
                for (ExternalDbMapEntry entity : table.getMetadataTableEntries()) {
                    final DBMapperTableEntry emfMapperTableEntry = DbmapFactory.eINSTANCE.createDBMapperTableEntry();
                    emfMapperTableEntry.setExpression(entity.getExpression());
                    emfMapperTableEntry.setName(entity.getName());
                    emfMapperTableEntry.setJoin(entity.isJoin());
                    emfMapperTableEntry.setOperator(entity.getOperator());
                    persistentEntities.add(emfMapperTableEntry);
                }
                persistentTable.getDBMapperTableEntries().addAll(persistentEntities);
            }
            emfMapperData.getInputTables().add(persistentTable);
        }
    }
    // output
    if (externalData.getOutputTables() != null && !externalData.getOutputTables().isEmpty()) {
        for (ExternalDbMapTable table : externalData.getOutputTables()) {
            final OutputTable persistentTable = DbmapFactory.eINSTANCE.createOutputTable();
            persistentTable.setMinimized(table.isMinimized());
            persistentTable.setName(table.getName());
            persistentTable.setTableName(table.getTableName());
            if (table.getMetadataTableEntries() != null && !table.getMetadataTableEntries().isEmpty()) {
                for (ExternalDbMapEntry entity : table.getMetadataTableEntries()) {
                    final DBMapperTableEntry emfMapperTableEntry = DbmapFactory.eINSTANCE.createDBMapperTableEntry();
                    emfMapperTableEntry.setExpression(entity.getExpression());
                    emfMapperTableEntry.setName(entity.getName());
                    persistentTable.getDBMapperTableEntries().add(emfMapperTableEntry);
                }
                // filters
                if (table.getCustomWhereConditionsEntries() != null && !table.getCustomWhereConditionsEntries().isEmpty()) {
                    for (ExternalDbMapEntry entity : table.getCustomWhereConditionsEntries()) {
                        final FilterEntry persistentEntry = DbmapFactory.eINSTANCE.createFilterEntry();
                        persistentEntry.setName(entity.getName());
                        persistentEntry.setExpression(entity.getExpression());
                        persistentEntry.setFilterKind(FilterTableEntry.WHERE_FILTER);
                        persistentTable.getFilterEntries().add(persistentEntry);
                    }
                }
                if (table.getCustomOtherConditionsEntries() != null && !table.getCustomOtherConditionsEntries().isEmpty()) {
                    for (ExternalDbMapEntry entity : table.getCustomOtherConditionsEntries()) {
                        final FilterEntry persistentEntry = DbmapFactory.eINSTANCE.createFilterEntry();
                        persistentEntry.setName(entity.getName());
                        persistentEntry.setExpression(entity.getExpression());
                        persistentEntry.setFilterKind(FilterTableEntry.OTHER_FILTER);
                        persistentTable.getFilterEntries().add(persistentEntry);
                    }
                }
            }
            emfMapperData.getOutputTables().add(persistentTable);
        }
    }
}

Example 5 with OutputTable

use of org.talend.designer.dbmap.model.emf.dbmap.OutputTable in project tdi-studio-se by Talend.

the class DBMapDataImplTest method test4.

private void test4() {
    DBMapDataImpl mapData1 = new DBMapDataImpl();
    DBMapDataImpl mapData2 = new DBMapDataImpl();
    assertTrue(mapData1.equals(mapData2));
    final OutputTable persistentTable = DbmapFactory.eINSTANCE.createOutputTable();
    persistentTable.setMinimized(true);
    persistentTable.setName("table1");
    persistentTable.setTableName("tableName");
    final DBMapperTableEntry emfMapperTableEntry = DbmapFactory.eINSTANCE.createDBMapperTableEntry();
    emfMapperTableEntry.setExpression("expression1");
    emfMapperTableEntry.setName("entityName1");
    emfMapperTableEntry.setJoin(true);
    emfMapperTableEntry.setOperator("operator1");
    persistentTable.getDBMapperTableEntries().add(emfMapperTableEntry);
    mapData1.getOutputTables().add(persistentTable);
    final InputTable persistentTable2 = DbmapFactory.eINSTANCE.createInputTable();
    persistentTable2.setMinimized(true);
    persistentTable2.setName("table1");
    persistentTable2.setTableName("tableName");
    final DBMapperTableEntry emfMapperTableEntry2 = DbmapFactory.eINSTANCE.createDBMapperTableEntry();
    emfMapperTableEntry2.setExpression("expression1");
    emfMapperTableEntry2.setName("entityName");
    emfMapperTableEntry2.setJoin(true);
    emfMapperTableEntry2.setOperator("operator1");
    persistentTable2.getDBMapperTableEntries().add(emfMapperTableEntry2);
    mapData2.getOutputTables().add(persistentTable);
    assertFalse(mapData1.equals(mapData2));
}