Examples with RowMeta org.pentaho.di.core.row.RowMeta used on opensource projects

Example 76 with RowMeta

use of org.pentaho.di.core.row.RowMeta in project pentaho-kettle by pentaho.

the class InsertUpdate method setLookup.

public void setLookup(RowMetaInterface rowMeta) throws KettleDatabaseException {
    data.lookupParameterRowMeta = new RowMeta();
    data.lookupReturnRowMeta = new RowMeta();
    DatabaseMeta databaseMeta = meta.getDatabaseMeta();
    String sql = "SELECT ";
    for (int i = 0; i < meta.getUpdateLookup().length; i++) {
        if (i != 0) {
            sql += ", ";
        }
        sql += databaseMeta.quoteField(meta.getUpdateLookup()[i]);
        data.lookupReturnRowMeta.addValueMeta(rowMeta.searchValueMeta(meta.getUpdateStream()[i]).clone());
    }
    sql += " FROM " + data.schemaTable + " WHERE ";
    for (int i = 0; i < meta.getKeyLookup().length; i++) {
        if (i != 0) {
            sql += " AND ";
        }
        sql += " ( ( ";
        sql += databaseMeta.quoteField(meta.getKeyLookup()[i]);
        if ("BETWEEN".equalsIgnoreCase(meta.getKeyCondition()[i])) {
            sql += " BETWEEN ? AND ? ";
            data.lookupParameterRowMeta.addValueMeta(rowMeta.searchValueMeta(meta.getKeyStream()[i]));
            data.lookupParameterRowMeta.addValueMeta(rowMeta.searchValueMeta(meta.getKeyStream2()[i]));
        } else {
            if ("IS NULL".equalsIgnoreCase(meta.getKeyCondition()[i]) || "IS NOT NULL".equalsIgnoreCase(meta.getKeyCondition()[i])) {
                sql += " " + meta.getKeyCondition()[i] + " ";
            } else if ("= ~NULL".equalsIgnoreCase(meta.getKeyCondition()[i])) {
                sql += " IS NULL AND ";
                if (databaseMeta.requiresCastToVariousForIsNull()) {
                    sql += " CAST(? AS VARCHAR(256)) IS NULL ";
                } else {
                    sql += " ? IS NULL ";
                }
                // null check
                data.lookupParameterRowMeta.addValueMeta(rowMeta.searchValueMeta(meta.getKeyStream()[i]));
                sql += " ) OR ( " + databaseMeta.quoteField(meta.getKeyLookup()[i]) + " = ? ";
                // equality check, cloning so auto-rename because of adding same fieldname does not cause problems
                data.lookupParameterRowMeta.addValueMeta(rowMeta.searchValueMeta(meta.getKeyStream()[i]).clone());
            } else {
                sql += " " + meta.getKeyCondition()[i] + " ? ";
                data.lookupParameterRowMeta.addValueMeta(rowMeta.searchValueMeta(meta.getKeyStream()[i]));
            }
        }
        sql += " ) ) ";
    }
    try {
        if (log.isDetailed()) {
            logDetailed("Setting preparedStatement to [" + sql + "]");
        }
        data.prepStatementLookup = data.db.getConnection().prepareStatement(databaseMeta.stripCR(sql));
    } catch (SQLException ex) {
        throw new KettleDatabaseException("Unable to prepare statement for SQL statement [" + sql + "]", ex);
    }
}

Example 77 with RowMeta

use of org.pentaho.di.core.row.RowMeta in project pentaho-kettle by pentaho.

the class InsertUpdate method prepareUpdate.

// Lookup certain fields in a table
public void prepareUpdate(RowMetaInterface rowMeta) throws KettleDatabaseException {
    DatabaseMeta databaseMeta = meta.getDatabaseMeta();
    data.updateParameterRowMeta = new RowMeta();
    String sql = "UPDATE " + data.schemaTable + Const.CR;
    sql += "SET ";
    boolean comma = false;
    for (int i = 0; i < meta.getUpdateLookup().length; i++) {
        if (meta.getUpdate()[i].booleanValue()) {
            if (comma) {
                sql += ",   ";
            } else {
                comma = true;
            }
            sql += databaseMeta.quoteField(meta.getUpdateLookup()[i]);
            sql += " = ?" + Const.CR;
            data.updateParameterRowMeta.addValueMeta(rowMeta.searchValueMeta(meta.getUpdateStream()[i]).clone());
        }
    }
    sql += "WHERE ";
    for (int i = 0; i < meta.getKeyLookup().length; i++) {
        if (i != 0) {
            sql += "AND   ";
        }
        sql += " ( ( ";
        sql += databaseMeta.quoteField(meta.getKeyLookup()[i]);
        if ("BETWEEN".equalsIgnoreCase(meta.getKeyCondition()[i])) {
            sql += " BETWEEN ? AND ? ";
            data.updateParameterRowMeta.addValueMeta(rowMeta.searchValueMeta(meta.getKeyStream()[i]));
            data.updateParameterRowMeta.addValueMeta(rowMeta.searchValueMeta(meta.getKeyStream2()[i]));
        } else if ("IS NULL".equalsIgnoreCase(meta.getKeyCondition()[i]) || "IS NOT NULL".equalsIgnoreCase(meta.getKeyCondition()[i])) {
            sql += " " + meta.getKeyCondition()[i] + " ";
        } else if ("= ~NULL".equalsIgnoreCase(meta.getKeyCondition()[i])) {
            sql += " IS NULL AND ";
            if (databaseMeta.requiresCastToVariousForIsNull()) {
                sql += "CAST(? AS VARCHAR(256)) IS NULL";
            } else {
                sql += "? IS NULL";
            }
            // null check
            data.updateParameterRowMeta.addValueMeta(rowMeta.searchValueMeta(meta.getKeyStream()[i]));
            sql += " ) OR ( " + databaseMeta.quoteField(meta.getKeyLookup()[i]) + " = ?";
            // equality check, cloning so auto-rename because of adding same fieldname does not cause problems
            data.updateParameterRowMeta.addValueMeta(rowMeta.searchValueMeta(meta.getKeyStream()[i]).clone());
        } else {
            sql += " " + meta.getKeyCondition()[i] + " ? ";
            data.updateParameterRowMeta.addValueMeta(rowMeta.searchValueMeta(meta.getKeyStream()[i]).clone());
        }
        sql += " ) ) ";
    }
    try {
        if (log.isDetailed()) {
            logDetailed("Setting update preparedStatement to [" + sql + "]");
        }
        data.prepStatementUpdate = data.db.getConnection().prepareStatement(databaseMeta.stripCR(sql));
    } catch (SQLException ex) {
        throw new KettleDatabaseException("Unable to prepare statement for SQL statement [" + sql + "]", ex);
    }
}

Example 78 with RowMeta

use of org.pentaho.di.core.row.RowMeta in project pentaho-kettle by pentaho.

the class MappingInputMeta method getFields.

public void getFields(RowMetaInterface row, String origin, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space, Repository repository, IMetaStore metaStore) throws KettleStepException {
    // 
    if (inputRowMeta != null && !inputRowMeta.isEmpty()) {
        // First rename any fields...
        if (valueRenames != null) {
            for (MappingValueRename valueRename : valueRenames) {
                ValueMetaInterface valueMeta = inputRowMeta.searchValueMeta(valueRename.getSourceValueName());
                if (valueMeta == null) {
                    // ok, let's search once again, now using target name
                    valueMeta = inputRowMeta.searchValueMeta(valueRename.getTargetValueName());
                    if (valueMeta == null) {
                        throw new KettleStepException(BaseMessages.getString(PKG, "MappingInput.Exception.UnableToFindMappedValue", valueRename.getSourceValueName()));
                    }
                } else {
                    valueMeta.setName(valueRename.getTargetValueName());
                }
            }
        }
        if (selectingAndSortingUnspecifiedFields) {
            // Select the specified fields from the input, re-order everything and put the other fields at the back,
            // sorted...
            // 
            RowMetaInterface newRow = new RowMeta();
            for (int i = 0; i < fieldName.length; i++) {
                int index = inputRowMeta.indexOfValue(fieldName[i]);
                if (index < 0) {
                    throw new KettleStepException(BaseMessages.getString(PKG, "MappingInputMeta.Exception.UnknownField", fieldName[i]));
                }
                newRow.addValueMeta(inputRowMeta.getValueMeta(index));
            }
            // Now get the unspecified fields.
            // Sort the fields
            // Add them after the specified fields...
            // 
            List<String> extra = new ArrayList<String>();
            for (int i = 0; i < inputRowMeta.size(); i++) {
                String fieldName = inputRowMeta.getValueMeta(i).getName();
                if (newRow.indexOfValue(fieldName) < 0) {
                    extra.add(fieldName);
                }
            }
            Collections.sort(extra);
            for (String fieldName : extra) {
                ValueMetaInterface extraValue = inputRowMeta.searchValueMeta(fieldName);
                newRow.addValueMeta(extraValue);
            }
            // now merge the new row...
            // This is basically the input row meta data with the fields re-ordered.
            // 
            row.mergeRowMeta(newRow);
        } else {
            row.mergeRowMeta(inputRowMeta);
            // 
            if (!row.isEmpty()) {
                for (int i = 0; i < fieldName.length; i++) {
                    if (row.indexOfValue(fieldName[i]) < 0) {
                        throw new KettleStepException(BaseMessages.getString(PKG, "MappingInputMeta.Exception.UnknownField", fieldName[i]));
                    }
                }
            }
        }
    } else {
        if (row.isEmpty()) {
            // We'll have to work with the statically provided information
            for (int i = 0; i < fieldName.length; i++) {
                if (!Utils.isEmpty(fieldName[i])) {
                    int valueType = fieldType[i];
                    if (valueType == ValueMetaInterface.TYPE_NONE) {
                        valueType = ValueMetaInterface.TYPE_STRING;
                    }
                    ValueMetaInterface v;
                    try {
                        v = ValueMetaFactory.createValueMeta(fieldName[i], valueType);
                        v.setLength(fieldLength[i]);
                        v.setPrecision(fieldPrecision[i]);
                        v.setOrigin(origin);
                        row.addValueMeta(v);
                    } catch (KettlePluginException e) {
                        throw new KettleStepException(e);
                    }
                }
            }
        }
    // else: row is OK, keep it as it is.
    }
}

Example 79 with RowMeta

use of org.pentaho.di.core.row.RowMeta in project pentaho-kettle by pentaho.

the class MemoryGroupBy method initGroupMeta.

private void initGroupMeta(RowMetaInterface previousRowMeta) throws KettleValueException {
    data.groupMeta = new RowMeta();
    data.entryMeta = new RowMeta();
    for (int i = 0; i < data.groupnrs.length; i++) {
        ValueMetaInterface valueMeta = previousRowMeta.getValueMeta(data.groupnrs[i]);
        data.groupMeta.addValueMeta(valueMeta);
        ValueMetaInterface normalMeta = valueMeta.clone();
        normalMeta.setStorageType(ValueMetaInterface.STORAGE_TYPE_NORMAL);
    }
    return;
}

Example 80 with RowMeta

use of org.pentaho.di.core.row.RowMeta in project pentaho-kettle by pentaho.

the class MemoryGroupByMeta method getFields.

@Override
public void getFields(RowMetaInterface r, String origin, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space, Repository repository, IMetaStore metaStore) {
    // Check compatibility mode
    boolean compatibilityMode = ValueMetaBase.convertStringToBoolean(space.getVariable(Const.KETTLE_COMPATIBILITY_MEMORY_GROUP_BY_SUM_AVERAGE_RETURN_NUMBER_TYPE, "N"));
    // re-assemble a new row of metadata
    // 
    RowMetaInterface fields = new RowMeta();
    // 
    for (int i = 0; i < groupField.length; i++) {
        ValueMetaInterface valueMeta = r.searchValueMeta(groupField[i]);
        if (valueMeta != null) {
            valueMeta.setStorageType(ValueMetaInterface.STORAGE_TYPE_NORMAL);
            fields.addValueMeta(valueMeta);
        }
    }
    // 
    for (int i = 0; i < subjectField.length; i++) {
        ValueMetaInterface subj = r.searchValueMeta(subjectField[i]);
        if (subj != null || aggregateType[i] == TYPE_GROUP_COUNT_ANY) {
            String value_name = aggregateField[i];
            int value_type = ValueMetaInterface.TYPE_NONE;
            int length = -1;
            int precision = -1;
            switch(aggregateType[i]) {
                case TYPE_GROUP_FIRST:
                case TYPE_GROUP_LAST:
                case TYPE_GROUP_FIRST_INCL_NULL:
                case TYPE_GROUP_LAST_INCL_NULL:
                case TYPE_GROUP_MIN:
                case TYPE_GROUP_MAX:
                    value_type = subj.getType();
                    break;
                case TYPE_GROUP_COUNT_DISTINCT:
                case TYPE_GROUP_COUNT_ALL:
                case TYPE_GROUP_COUNT_ANY:
                    value_type = ValueMetaInterface.TYPE_INTEGER;
                    break;
                case TYPE_GROUP_CONCAT_COMMA:
                    value_type = ValueMetaInterface.TYPE_STRING;
                    break;
                case TYPE_GROUP_SUM:
                case TYPE_GROUP_AVERAGE:
                    if (!compatibilityMode && subj.isNumeric()) {
                        value_type = subj.getType();
                    } else {
                        value_type = ValueMetaInterface.TYPE_NUMBER;
                    }
                    break;
                case TYPE_GROUP_MEDIAN:
                case TYPE_GROUP_PERCENTILE:
                case TYPE_GROUP_STANDARD_DEVIATION:
                    value_type = ValueMetaInterface.TYPE_NUMBER;
                    break;
                case TYPE_GROUP_CONCAT_STRING:
                    value_type = ValueMetaInterface.TYPE_STRING;
                    break;
                default:
                    break;
            }
            if (aggregateType[i] == TYPE_GROUP_COUNT_ALL || aggregateType[i] == TYPE_GROUP_COUNT_DISTINCT || aggregateType[i] == TYPE_GROUP_COUNT_ANY) {
                length = ValueMetaInterface.DEFAULT_INTEGER_LENGTH;
                precision = 0;
            } else if (aggregateType[i] == TYPE_GROUP_SUM && value_type != ValueMetaInterface.TYPE_INTEGER && value_type != ValueMetaInterface.TYPE_NUMBER && value_type != ValueMetaInterface.TYPE_BIGNUMBER) {
                // If it ain't numeric, we change it to Number
                // 
                value_type = ValueMetaInterface.TYPE_NUMBER;
                precision = -1;
                length = -1;
            }
            if (value_type != ValueMetaInterface.TYPE_NONE) {
                ValueMetaInterface v;
                try {
                    v = ValueMetaFactory.createValueMeta(value_name, value_type);
                } catch (KettlePluginException e) {
                    log.logError(BaseMessages.getString(PKG, "MemoryGroupByMeta.Exception.UnknownValueMetaType"), value_type, e);
                    v = new ValueMetaNone(value_name);
                }
                v.setOrigin(origin);
                v.setLength(length, precision);
                if (subj != null) {
                    v.setConversionMask(subj.getConversionMask());
                }
                fields.addValueMeta(v);
            }
        }
    }
    // Now that we have all the fields we want, we should clear the original row and replace the values...
    // 
    r.clear();
    r.addRowMeta(fields);
}