@Override public String getFieldDefinition( ValueMetaInterface v, String tk, String pk, boolean use_autoinc, boolean add_fieldname, boolean add_cr) { String retval = ""; String fieldname = v.getName(); int length = v.getLength(); int precision = v.getPrecision(); if (add_fieldname) retval += fieldname + " "; int type = v.getType(); switch (type) { case ValueMetaInterface.TYPE_DATE: retval += "DATETIME"; break; case ValueMetaInterface.TYPE_BOOLEAN: retval += "CHAR(1)"; break; case ValueMetaInterface.TYPE_NUMBER: case ValueMetaInterface.TYPE_INTEGER: case ValueMetaInterface.TYPE_BIGNUMBER: retval += "DECIMAL"; if (length > 0) { retval += "(" + length; if (precision > 0) { retval += ", " + precision; } retval += ")"; } break; case ValueMetaInterface.TYPE_STRING: if (length >= DatabaseMeta.CLOB_LENGTH) { retval += "CLOB"; } else { retval += "VARCHAR"; if (length > 0) { retval += "(" + length; } else { retval += "("; // Maybe use some default DB String length? } retval += ")"; } break; default: retval += " UNKNOWN"; break; } if (add_cr) retval += Const.CR; return retval; }
protected JsonInput createBasicTestJsonInput( String jsonPath, ValueMetaInterface outputMeta, final String inCol, Object[]... inputRows) { JsonInputField jpath = new JsonInputField(outputMeta.getName()); jpath.setPath(jsonPath); jpath.setType(outputMeta.getType()); JsonInputMeta meta = createSimpleMeta(inCol, jpath); return createJsonInput(inCol, meta, inputRows); }
private Date getIncrementalFieldValue() throws KettleException { Date result = null; boolean firstRow = true; Object[] row; RowMetaInterface inputRowMeta; while ((row = getRow()) != null) { if (firstRow) { firstRow = false; inputRowMeta = getInputRowMeta(); if (inputRowMeta == null || inputRowMeta.size() <= 0) { if (log.isBasic()) { logBasic(BaseMessages.getString(PKG, "ZendeskInput.Error.NoIncomingRows")); } return null; } String filenameField = environmentSubstitute(meta.getTimestampFieldName()); int fieldIndex = inputRowMeta.indexOfValue(filenameField); if (fieldIndex < 0) { throw new KettleStepException( BaseMessages.getString( PKG, "ZendeskInputIncremental.Exception.StartDateFieldNotFound", filenameField)); } ValueMetaInterface fieldValueMeta = inputRowMeta.getValueMeta(fieldIndex); if (!(fieldValueMeta instanceof ValueMetaDate)) { throw new KettleStepException( BaseMessages.getString( PKG, "ZendeskInput.Error.WrongFieldType", ValueMetaFactory.getValueMetaName(fieldValueMeta.getType()))); } else { result = fieldValueMeta.getDate(row[fieldIndex]); } } else { if (log.isDetailed()) { logDetailed( BaseMessages.getString(PKG, "ZendeskInput.Warning.IgnoringAdditionalInputRows")); } } } if (firstRow) { if (log.isBasic()) { logBasic(BaseMessages.getString(PKG, "ZendeskInput.Error.NoIncomingRows")); } } return result; }
public static Object[] createObjectsForRow(RowMetaInterface rowMeta, Object[] rowData) throws KettleValueException { Object[] values = new Object[rowMeta.size()]; for (int i = 0; i < rowMeta.size(); i++) { ValueMetaInterface valueMeta = rowMeta.getValueMeta(i); Object valueData = rowData[i]; // Prevent a NullPointerException below if (valueData == null || valueMeta == null) { values[i] = null; continue; } int length = valueMeta.getLength(); switch (valueMeta.getType()) { case ValueMetaInterface.TYPE_INTEGER: if (length < 3) { values[i] = new Byte(valueMeta.getInteger(valueData).byteValue()); } else { if (length < 5) { values[i] = new Short(valueMeta.getInteger(valueData).shortValue()); } else { values[i] = valueMeta.getInteger(valueData); } } break; case ValueMetaInterface.TYPE_NUMBER: values[i] = valueMeta.getNumber(valueData); break; case ValueMetaInterface.TYPE_DATE: values[i] = valueMeta.getDate(valueData); break; case ValueMetaInterface.TYPE_STRING: values[i] = valueMeta.getString(valueData); break; case ValueMetaInterface.TYPE_BINARY: values[i] = valueMeta.getBinary(valueData); break; case ValueMetaInterface.TYPE_BOOLEAN: values[i] = valueMeta.getBoolean(valueData); break; case ValueMetaInterface.TYPE_BIGNUMBER: values[i] = valueMeta.getNumber(valueData); break; default: break; } } return values; }
public static ValueMetaInterface cloneValueMeta(ValueMetaInterface source, int targetType) throws KettlePluginException { ValueMetaInterface target = null; // If we're Cloneable and not changing types, call clone() if (source instanceof Cloneable && source.getType() == targetType) { target = source.clone(); } else { target = createValueMeta(source.getName(), targetType, source.getLength(), source.getPrecision()); } target.setConversionMask(source.getConversionMask()); target.setDecimalSymbol(source.getDecimalSymbol()); target.setGroupingSymbol(source.getGroupingSymbol()); target.setStorageType(source.getStorageType()); if (source.getStorageMetadata() != null) { target.setStorageMetadata( cloneValueMeta(source.getStorageMetadata(), source.getStorageMetadata().getType())); } target.setStringEncoding(source.getStringEncoding()); target.setTrimType(source.getTrimType()); target.setDateFormatLenient(source.isDateFormatLenient()); target.setDateFormatLocale(source.getDateFormatLocale()); target.setDateFormatTimeZone(source.getDateFormatTimeZone()); target.setLenientStringToNumber(source.isLenientStringToNumber()); target.setLargeTextField(source.isLargeTextField()); target.setComments(source.getComments()); target.setCaseInsensitive(source.isCaseInsensitive()); target.setIndex(source.getIndex()); target.setOrigin(source.getOrigin()); target.setOriginalAutoIncrement(source.isOriginalAutoIncrement()); target.setOriginalColumnType(source.getOriginalColumnType()); target.setOriginalColumnTypeName(source.getOriginalColumnTypeName()); target.setOriginalNullable(source.isOriginalNullable()); target.setOriginalPrecision(source.getOriginalPrecision()); target.setOriginalScale(source.getOriginalScale()); target.setOriginalSigned(source.isOriginalSigned()); return target; }
public static ValueMetaInterface cloneValueMeta(ValueMetaInterface source) throws KettlePluginException { return cloneValueMeta(source, source.getType()); }
@Override public String getFieldDefinition( ValueMetaInterface v, String tk, String pk, boolean use_autoinc, boolean add_fieldname, boolean add_cr) { String retval = ""; String fieldname = v.getName(); int length = v.getLength(); int precision = v.getPrecision(); if (add_fieldname) { retval += fieldname + " "; } int type = v.getType(); switch (type) { case ValueMetaInterface.TYPE_DATE: retval += "TIMESTAMP"; break; case ValueMetaInterface.TYPE_BOOLEAN: retval += "CHAR(1)"; break; case ValueMetaInterface.TYPE_NUMBER: case ValueMetaInterface.TYPE_INTEGER: case ValueMetaInterface.TYPE_BIGNUMBER: if (fieldname.equalsIgnoreCase(tk) || // Technical key fieldname.equalsIgnoreCase(pk) // Primary key ) { if (use_autoinc) { retval += "BIGINT NOT NULL GENERATED ALWAYS AS IDENTITY (START WITH 0, INCREMENT BY 1)"; } else { retval += "BIGINT NOT NULL PRIMARY KEY"; } } else { // Integer values... if (precision == 0) { if (length > 9) { retval += "BIGINT"; } else { if (length > 4) { retval += "INTEGER"; } else { retval += "SMALLINT"; } } } else { // Floating point values... if (length > 18) { retval += "DECIMAL(" + length; if (precision > 0) { retval += ", " + precision; } retval += ")"; } else { retval += "FLOAT"; } } } break; case ValueMetaInterface.TYPE_STRING: if (length >= DatabaseMeta.CLOB_LENGTH || length > 32700) { retval += "CLOB"; } else { retval += "VARCHAR"; if (length > 0) { retval += "(" + length; } else { retval += "("; // Maybe use some default DB String length? } retval += ")"; } break; case ValueMetaInterface.TYPE_BINARY: retval += "BLOB"; break; default: retval += "UNKNOWN"; break; } if (add_cr) { retval += Const.CR; } return retval; }
public void writeLine(RowMetaInterface mi, Object[] row) throws KettleException { if (first) { first = false; enclosure = meta.getEnclosure(); // Setup up the fields we need to take for each of the rows // as this speeds up processing. fieldNumbers = new int[meta.getFieldStream().length]; for (int i = 0; i < fieldNumbers.length; i++) { fieldNumbers[i] = mi.indexOfValue(meta.getFieldStream()[i]); if (fieldNumbers[i] < 0) { throw new KettleException( "Could not find field " + meta.getFieldStream()[i] + " in stream"); } } sdfDate = new SimpleDateFormat("yyyy-MM-dd"); sdfDateTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS"); outbuf = new StringBuilder(); } outbuf.setLength(0); // Write the data to the output ValueMetaInterface v = null; int number = 0; for (int i = 0; i < fieldNumbers.length; i++) { if (i != 0) { outbuf.append(","); } v = mi.getValueMeta(i); number = fieldNumbers[i]; if (row[number] == null) { // TODO (SB): special check for null in case of Strings. outbuf.append(enclosure); outbuf.append(enclosure); } else { switch (v.getType()) { case ValueMetaInterface.TYPE_STRING: String s = mi.getString(row, number); if (s.indexOf(enclosure) >= 0) { s = createEscapedString(s, enclosure); } outbuf.append(enclosure); outbuf.append(s); outbuf.append(enclosure); break; case ValueMetaInterface.TYPE_INTEGER: Long l = mi.getInteger(row, number); outbuf.append(enclosure); outbuf.append(l); outbuf.append(enclosure); break; case ValueMetaInterface.TYPE_NUMBER: Double d = mi.getNumber(row, number); outbuf.append(enclosure); outbuf.append(d); outbuf.append(enclosure); break; case ValueMetaInterface.TYPE_BIGNUMBER: BigDecimal bd = mi.getBigNumber(row, number); outbuf.append(enclosure); outbuf.append(bd); outbuf.append(enclosure); break; case ValueMetaInterface.TYPE_DATE: Date dt = mi.getDate(row, number); outbuf.append(enclosure); String mask = meta.getDateMask()[i]; if (OraBulkLoaderMeta.DATE_MASK_DATETIME.equals(mask)) { outbuf.append(sdfDateTime.format(dt)); } else { // Default is date format outbuf.append(sdfDate.format(dt)); } outbuf.append(enclosure); break; case ValueMetaInterface.TYPE_BOOLEAN: Boolean b = mi.getBoolean(row, number); outbuf.append(enclosure); if (b.booleanValue()) { outbuf.append("Y"); } else { outbuf.append("N"); } outbuf.append(enclosure); break; case ValueMetaInterface.TYPE_BINARY: byte[] byt = mi.getBinary(row, number); outbuf.append("<startlob>"); outbuf.append(byt); outbuf.append("<endlob>"); break; default: throw new KettleException("Unsupported type"); } } } outbuf.append(recTerm); try { output.append(outbuf); } catch (IOException e) { throw new KettleException("IO exception occured: " + e.getMessage(), e); } }
/** * Performs the lookup based on the meta-data and the input row. * * @param row The row to use as lookup data and the row to add the returned lookup fields to * @return the resulting row after the lookup values where added * @throws KettleException In case something goes wrong. */ private synchronized Object[] lookupValues(RowMetaInterface inputRowMeta, Object[] row) throws KettleException { Object[] outputRow = RowDataUtil.resizeArray(row, data.outputRowMeta.size()); Object[] lookupRow = new Object[data.lookupMeta.size()]; int lookupIndex = 0; for (int i = 0; i < meta.getStreamKeyField1().length; i++) { if (data.keynrs[i] >= 0) { ValueMetaInterface input = inputRowMeta.getValueMeta(data.keynrs[i]); ValueMetaInterface value = data.lookupMeta.getValueMeta(lookupIndex); lookupRow[lookupIndex] = row[data.keynrs[i]]; // Try to convert type if needed if (input.getType() != value.getType()) { lookupRow[lookupIndex] = value.convertData(input, lookupRow[lookupIndex]); } lookupIndex++; } if (data.keynrs2[i] >= 0) { ValueMetaInterface input = inputRowMeta.getValueMeta(data.keynrs2[i]); ValueMetaInterface value = data.lookupMeta.getValueMeta(lookupIndex); lookupRow[lookupIndex] = row[data.keynrs2[i]]; // Try to convert type if needed if (input.getType() != value.getType()) { lookupRow[lookupIndex] = value.convertData(input, lookupRow[lookupIndex]); } lookupIndex++; } } Object[] add = null; boolean cache_now = false; boolean cacheHit = false; // First, check if we looked up before if (meta.isCached()) { add = getRowFromCache(data.lookupMeta, lookupRow); if (add != null) { cacheHit = true; } } else { add = null; } if (add == null) { if (!(meta.isCached() && meta.isLoadingAllDataInCache()) || data.hasDBCondition) { // do not go to the // database when all rows // are in (exception LIKE // operator) if (log.isRowLevel()) { logRowlevel( BaseMessages.getString(PKG, "DatabaseLookup.Log.AddedValuesToLookupRow1") + meta.getStreamKeyField1().length + BaseMessages.getString(PKG, "DatabaseLookup.Log.AddedValuesToLookupRow2") + data.lookupMeta.getString(lookupRow)); } data.db.setValuesLookup(data.lookupMeta, lookupRow); add = data.db.getLookup(meta.isFailingOnMultipleResults()); cache_now = true; } } if (add == null) { // nothing was found, unknown code: add default values if (meta.isEatingRowOnLookupFailure()) { return null; } if (getStepMeta().isDoingErrorHandling()) { putError(getInputRowMeta(), row, 1L, "No lookup found", null, "DBL001"); // return false else we would still be processed. return null; } if (log.isRowLevel()) { logRowlevel(BaseMessages.getString(PKG, "DatabaseLookup.Log.NoResultsFoundAfterLookup")); } add = new Object[data.returnMeta.size()]; for (int i = 0; i < meta.getReturnValueField().length; i++) { if (data.nullif[i] != null) { add[i] = data.nullif[i]; } else { add[i] = null; } } } else { if (log.isRowLevel()) { logRowlevel( BaseMessages.getString(PKG, "DatabaseLookup.Log.FoundResultsAfterLookup") + add); } // Only verify the data types if the data comes from the DB, NOT when we have a cache hit // In that case, we already know the data type is OK. if (!cacheHit) { incrementLinesInput(); int[] types = meta.getReturnValueDefaultType(); // The assumption here is that the types are in the same order // as the returned lookup row, but since we make the lookup row // that should not be a problem. // for (int i = 0; i < types.length; i++) { ValueMetaInterface returned = data.db.getReturnRowMeta().getValueMeta(i); ValueMetaInterface expected = data.returnMeta.getValueMeta(i); if (returned != null && types[i] > 0 && types[i] != returned.getType()) { // Set the type to the default return type add[i] = expected.convertData(returned, add[i]); } } } } // Store in cache if we need to! // If we already loaded all data into the cache, storing more makes no sense. // if (meta.isCached() && cache_now && !meta.isLoadingAllDataInCache() && data.allEquals) { storeRowInCache(data.lookupMeta, lookupRow, add); } for (int i = 0; i < data.returnMeta.size(); i++) { outputRow[inputRowMeta.size() + i] = add[i]; } return outputRow; }
public static final List<Column> getColumns(RowMetaInterface row) { List<Column> list = new ArrayList<Column>(); for (int i = 0; i < row.size(); i++) { ValueMetaInterface value = row.getValueMeta(i); Column column = new Column(); column.setName(value.getName()); int length = value.getLength(); switch (value.getType()) { case ValueMetaInterface.TYPE_INTEGER: if (length < 3) { column.setType(DataType.BYTE); length = DataType.BYTE.getFixedSize(); } else { if (length < 5) { column.setType(DataType.INT); length = DataType.INT.getFixedSize(); } else { column.setType(DataType.LONG); length = DataType.LONG.getFixedSize(); } } break; case ValueMetaInterface.TYPE_NUMBER: column.setType(DataType.DOUBLE); length = DataType.DOUBLE.getFixedSize(); break; case ValueMetaInterface.TYPE_DATE: column.setType(DataType.SHORT_DATE_TIME); length = DataType.SHORT_DATE_TIME.getFixedSize(); break; case ValueMetaInterface.TYPE_STRING: if (length < 255) { column.setType(DataType.TEXT); length *= DataType.TEXT.getUnitSize(); } else { column.setType(DataType.MEMO); length *= DataType.MEMO.getUnitSize(); } break; case ValueMetaInterface.TYPE_BINARY: column.setType(DataType.BINARY); break; case ValueMetaInterface.TYPE_BOOLEAN: column.setType(DataType.BOOLEAN); length = DataType.BOOLEAN.getFixedSize(); break; case ValueMetaInterface.TYPE_BIGNUMBER: column.setType(DataType.NUMERIC); length = DataType.NUMERIC.getFixedSize(); break; default: break; } if (length >= 0) { column.setLength((short) length); } if (value.getPrecision() >= 1 && value.getPrecision() <= 28) { column.setPrecision((byte) value.getPrecision()); } list.add(column); } return list; }
private void populateTableWithIncomingFields() { if (m_incomingFieldsProducer != null) { RowMetaInterface incomingRowMeta = m_incomingFieldsProducer.getIncomingFields(); Table table = m_fieldsView.table; if (incomingRowMeta != null) { Set<String> existingRowAliases = new HashSet<String>(); for (int i = 0; i < table.getItemCount(); i++) { TableItem tableItem = table.getItem(i); String alias = tableItem.getText(1); if (!Const.isEmpty(alias)) { existingRowAliases.add(alias); } } int choice = 0; if (existingRowAliases.size() > 0) { // Ask what we should do with existing mapping data MessageDialog md = new MessageDialog( m_shell, Messages.getString("MappingDialog.GetFieldsChoice.Title"), null, Messages.getString( "MappingDialog.GetFieldsChoice.Message", "" + existingRowAliases.size(), "" + incomingRowMeta.size()), MessageDialog.WARNING, new String[] { Messages.getString("MappingDialog.AddNew"), Messages.getString("MappingOutputDialog.Add"), Messages.getString("MappingOutputDialog.ClearAndAdd"), Messages.getString("MappingOutputDialog.Cancel"), }, 0); MessageDialog.setDefaultImage(GUIResource.getInstance().getImageSpoon()); int idx = md.open(); choice = idx & 0xFF; } if (choice == 3 || choice == 255 /* 255 = escape pressed */) { return; // Cancel } if (choice == 2) { m_fieldsView.clearAll(); } for (int i = 0; i < incomingRowMeta.size(); i++) { ValueMetaInterface vm = incomingRowMeta.getValueMeta(i); boolean addIt = true; if (choice == 0) { // only add if its not already in the table if (existingRowAliases.contains(vm.getName())) { addIt = false; } } if (addIt) { TableItem item = new TableItem(m_fieldsView.table, SWT.NONE); item.setText(1, vm.getName()); item.setText(2, "N"); if (m_familyCI.getComboValues()[0].length() > 0) { // use existing first column family name as the default item.setText(3, m_familyCI.getComboValues()[0]); } else { // default item.setText(3, DEFAULT_FAMILY); } item.setText(4, vm.getName()); item.setText(5, vm.getTypeDesc()); if (vm.getType() == ValueMetaInterface.TYPE_INTEGER) { item.setText(5, "Long"); } if (vm.getType() == ValueMetaInterface.TYPE_NUMBER) { item.setText(5, "Double"); } if (vm.getStorageType() == ValueMetaInterface.STORAGE_TYPE_INDEXED) { Object[] indexValus = vm.getIndex(); String indexValsS = HBaseValueMeta.objectIndexValuesToString(indexValus); item.setText(6, indexValsS); } } } m_fieldsView.removeEmptyRows(); m_fieldsView.setRowNums(); m_fieldsView.optWidth(true); } } }
public void check( List<CheckResultInterface> remarks, TransMeta transMeta, StepMeta stepinfo, RowMetaInterface prev, String input[], String output[], RowMetaInterface info) { CheckResult cr; String error_message = ""; // $NON-NLS-1$ boolean first = true; boolean error_found = false; if (prev == null) { error_message += BaseMessages.getString(PKG, "StringCutMeta.CheckResult.NoInputReceived") + Const.CR; // $NON-NLS-1$ cr = new CheckResult(CheckResult.TYPE_RESULT_ERROR, error_message, stepinfo); remarks.add(cr); } else { for (int i = 0; i < fieldInStream.length; i++) { String field = fieldInStream[i]; ValueMetaInterface v = prev.searchValueMeta(field); if (v == null) { if (first) { first = false; error_message += BaseMessages.getString(PKG, "StringCutMeta.CheckResult.MissingInStreamFields") + Const.CR; // $NON-NLS-1$ } error_found = true; error_message += "\t\t" + field + Const.CR; // $NON-NLS-1$ } } if (error_found) { cr = new CheckResult(CheckResult.TYPE_RESULT_ERROR, error_message, stepinfo); } else { cr = new CheckResult( CheckResult.TYPE_RESULT_OK, BaseMessages.getString(PKG, "StringCutMeta.CheckResult.FoundInStreamFields"), stepinfo); //$NON-NLS-1$ } remarks.add(cr); // Check whether all are strings first = true; error_found = false; for (int i = 0; i < fieldInStream.length; i++) { String field = fieldInStream[i]; ValueMetaInterface v = prev.searchValueMeta(field); if (v != null) { if (v.getType() != ValueMeta.TYPE_STRING) { if (first) { first = false; error_message += BaseMessages.getString( PKG, "StringCutMeta.CheckResult.OperationOnNonStringFields") + Const.CR; // $NON-NLS-1$ } error_found = true; error_message += "\t\t" + field + Const.CR; // $NON-NLS-1$ } } } if (error_found) { cr = new CheckResult(CheckResult.TYPE_RESULT_ERROR, error_message, stepinfo); } else { cr = new CheckResult( CheckResult.TYPE_RESULT_OK, BaseMessages.getString( PKG, "StringCutMeta.CheckResult.AllOperationsOnStringFields"), stepinfo); //$NON-NLS-1$ } remarks.add(cr); if (fieldInStream.length > 0) { for (int idx = 0; idx < fieldInStream.length; idx++) { if (Const.isEmpty(fieldInStream[idx])) { cr = new CheckResult( CheckResult.TYPE_RESULT_ERROR, BaseMessages.getString( PKG, "StringCutMeta.CheckResult.InStreamFieldMissing", new Integer(idx + 1).toString()), stepinfo); //$NON-NLS-1$ remarks.add(cr); } } } } }
private Object[] lookupValues(RowMetaInterface rowMeta, Object[] row) throws KettleException { // See if we need to stop. if (isStopped()) return null; if (data.lookupColumnIndex == null) { String names[] = data.lookupMeta.getFieldNames(); data.lookupColumnIndex = new int[names.length]; for (int i = 0; i < names.length; i++) { data.lookupColumnIndex[i] = rowMeta.indexOfValue(names[i]); if (data.lookupColumnIndex[i] < 0) { // we should not get here throw new KettleStepException("The lookup column '" + names[i] + "' could not be found"); } } } // Copy value references to lookup table. // Object[] lu = new Object[data.keynrs.length]; for (int i = 0; i < data.keynrs.length; i++) { // If the input is binary storage data, we convert it to normal storage. // if (data.convertKeysToNative[i]) { lu[i] = data.lookupMeta .getValueMeta(i) .convertBinaryStringToNativeType((byte[]) row[data.keynrs[i]]); } else { lu[i] = row[data.keynrs[i]]; } } // Handle conflicting types (Number-Integer-String conversion to lookup type in hashtable) if (data.keyTypes != null) { for (int i = 0; i < data.lookupMeta.size(); i++) { ValueMetaInterface inputValue = data.lookupMeta.getValueMeta(i); ValueMetaInterface lookupValue = data.keyTypes.getValueMeta(i); if (inputValue.getType() != lookupValue.getType()) { try { // Change the input value to match the lookup value // lu[i] = lookupValue.convertDataCompatible(inputValue, lu[i]); } catch (KettleValueException e) { throw new KettleStepException("Error converting data while looking up value", e); } } } } Object[] add = null; if (data.hasLookupRows) { try { if (meta.getKeystream().length > 0) { add = getFromCache(data.keyTypes, lu); } else { // Just take the first element in the hashtable... throw new KettleStepException( BaseMessages.getString(PKG, "StreamLookup.Log.GotRowWithoutKeys")); // $NON-NLS-1$ } } catch (Exception e) { throw new KettleStepException(e); } } if (add == null) // nothing was found, unknown code: add the specified default value... { add = data.nullIf; } return RowDataUtil.addRowData(row, rowMeta.size(), add); }
/** * Get the contents of the control file as specified in the meta object * * @param meta the meta object to model the control file after * @return a string containing the control file contents */ public String getControlFileContents(OraBulkLoaderMeta meta, RowMetaInterface rm, Object[] r) throws KettleException { DatabaseMeta dm = meta.getDatabaseMeta(); String inputName = "'" + environmentSubstitute(meta.getDataFile()) + "'"; String loadAction = meta.getLoadAction(); StringBuilder contents = new StringBuilder(500); contents.append("OPTIONS(").append(Const.CR); contents.append(" ERRORS=\'").append(meta.getMaxErrors()).append("\'").append(Const.CR); if (meta.getCommitSizeAsInt(this) != 0 && !(meta.isDirectPath() && getStepMeta().getCopies() > 1)) { // For the second part of the above expressions: ROWS is not supported // in parallel mode (by sqlldr). contents.append(" , ROWS=\'").append(meta.getCommitSize()).append("\'").append(Const.CR); } if (meta.getBindSizeAsInt(this) != 0) { contents.append(" , BINDSIZE=\'").append(meta.getBindSize()).append("\'").append(Const.CR); } if (meta.getReadSizeAsInt(this) != 0) { contents.append(" , READSIZE=\'").append(meta.getReadSize()).append("\'").append(Const.CR); } contents.append(")").append(Const.CR); contents.append("LOAD DATA").append(Const.CR); if (!Utils.isEmpty(meta.getCharacterSetName())) { contents.append("CHARACTERSET ").append(meta.getCharacterSetName()).append(Const.CR); } if (!OraBulkLoaderMeta.METHOD_AUTO_CONCURRENT.equals(meta.getLoadMethod()) || !Utils.isEmpty(meta.getAltRecordTerm())) { String infile = inputName; if (OraBulkLoaderMeta.METHOD_AUTO_CONCURRENT.equals(meta.getLoadMethod())) { infile = "''"; } // For concurrent input, data command line argument must be specified contents.append("INFILE ").append(infile); if (!Utils.isEmpty(meta.getAltRecordTerm())) { contents .append(" \"STR x'") .append(encodeRecordTerminator(meta.getAltRecordTerm(), meta.getEncoding())) .append("'\""); } contents.append(Const.CR); } contents .append("INTO TABLE ") .append( dm.getQuotedSchemaTableCombination( environmentSubstitute(meta.getSchemaName()), environmentSubstitute(meta.getTableName()))) .append(Const.CR) .append(loadAction) .append(Const.CR) .append("FIELDS TERMINATED BY ',' ENCLOSED BY '\"'") .append(Const.CR) .append("("); String[] streamFields = meta.getFieldStream(); String[] tableFields = meta.getFieldTable(); String[] dateMask = meta.getDateMask(); if (streamFields == null || streamFields.length == 0) { throw new KettleException("No fields defined to load to database"); } for (int i = 0; i < streamFields.length; i++) { if (i != 0) { contents.append(", ").append(Const.CR); } contents.append(dm.quoteField(tableFields[i])); int pos = rm.indexOfValue(streamFields[i]); if (pos < 0) { throw new KettleException("Could not find field " + streamFields[i] + " in stream"); } ValueMetaInterface v = rm.getValueMeta(pos); switch (v.getType()) { case ValueMetaInterface.TYPE_STRING: if (v.getLength() > 255) { contents.append(" CHAR(").append(v.getLength()).append(")"); } else { contents.append(" CHAR"); } break; case ValueMetaInterface.TYPE_INTEGER: case ValueMetaInterface.TYPE_NUMBER: case ValueMetaInterface.TYPE_BIGNUMBER: break; case ValueMetaInterface.TYPE_DATE: if (OraBulkLoaderMeta.DATE_MASK_DATE.equals(dateMask[i])) { contents.append(" DATE 'yyyy-mm-dd'"); } else if (OraBulkLoaderMeta.DATE_MASK_DATETIME.equals(dateMask[i])) { contents.append(" TIMESTAMP 'yyyy-mm-dd hh24:mi:ss.ff'"); } else { // If not specified the default is date. contents.append(" DATE 'yyyy-mm-dd'"); } break; case ValueMetaInterface.TYPE_BINARY: contents.append(" ENCLOSED BY '<startlob>' AND '<endlob>'"); break; case ValueMetaInterface.TYPE_TIMESTAMP: contents.append(" TIMESTAMP 'yyyy-mm-dd hh24:mi:ss.ff'"); break; default: break; } } contents.append(")"); return contents.toString(); }
@Override public void getFields( RowMetaInterface rowMeta, String origin, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space, Repository repository, IMetaStore metaStore) { // re-assemble a new row of metadata // RowMetaInterface fields = new RowMeta(); if (!passAllRows) { // Add the grouping fields in the correct order... // for (int i = 0; i < groupField.length; i++) { ValueMetaInterface valueMeta = rowMeta.searchValueMeta(groupField[i]); if (valueMeta != null) { fields.addValueMeta(valueMeta); } } } else { // Add all the original fields from the incoming row meta // fields.addRowMeta(rowMeta); } // Re-add aggregates // for (int i = 0; i < subjectField.length; i++) { ValueMetaInterface subj = rowMeta.searchValueMeta(subjectField[i]); if (subj != null || aggregateType[i] == TYPE_GROUP_COUNT_ANY) { String valueName = aggregateField[i]; int valueType = ValueMetaInterface.TYPE_NONE; int length = -1; int precision = -1; switch (aggregateType[i]) { case TYPE_GROUP_SUM: case TYPE_GROUP_AVERAGE: case TYPE_GROUP_CUMULATIVE_SUM: case TYPE_GROUP_CUMULATIVE_AVERAGE: 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: valueType = subj.getType(); break; case TYPE_GROUP_COUNT_DISTINCT: case TYPE_GROUP_COUNT_ANY: case TYPE_GROUP_COUNT_ALL: valueType = ValueMetaInterface.TYPE_INTEGER; break; case TYPE_GROUP_CONCAT_COMMA: valueType = ValueMetaInterface.TYPE_STRING; break; case TYPE_GROUP_STANDARD_DEVIATION: case TYPE_GROUP_MEDIAN: case TYPE_GROUP_PERCENTILE: valueType = ValueMetaInterface.TYPE_NUMBER; break; case TYPE_GROUP_CONCAT_STRING: valueType = ValueMetaInterface.TYPE_STRING; break; default: break; } // Change type from integer to number in case off averages for cumulative average // if (aggregateType[i] == TYPE_GROUP_CUMULATIVE_AVERAGE && valueType == ValueMetaInterface.TYPE_INTEGER) { valueType = ValueMetaInterface.TYPE_NUMBER; precision = -1; length = -1; } else 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 && valueType != ValueMetaInterface.TYPE_INTEGER && valueType != ValueMetaInterface.TYPE_NUMBER && valueType != ValueMetaInterface.TYPE_BIGNUMBER) { // If it ain't numeric, we change it to Number // valueType = ValueMetaInterface.TYPE_NUMBER; precision = -1; length = -1; } if (valueType != ValueMetaInterface.TYPE_NONE) { ValueMetaInterface v = new ValueMeta(valueName, valueType); v.setOrigin(origin); v.setLength(length, precision); fields.addValueMeta(v); } } } if (passAllRows) { // If we pass all rows, we can add a line nr in the group... if (addingLineNrInGroup && !Utils.isEmpty(lineNrInGroupField)) { ValueMetaInterface lineNr = new ValueMetaInteger(lineNrInGroupField); lineNr.setLength(ValueMetaInterface.DEFAULT_INTEGER_LENGTH, 0); lineNr.setOrigin(origin); fields.addValueMeta(lineNr); } } // Now that we have all the fields we want, we should clear the original row and replace the // values... // rowMeta.clear(); rowMeta.addRowMeta(fields); }
@Override public String getFieldDefinition( ValueMetaInterface v, String tk, String pk, boolean use_autoinc, boolean add_fieldname, boolean add_cr) { String retval = ""; String fieldname = v.getName(); int length = v.getLength(); int precision = v.getPrecision(); if (add_fieldname) { retval += fieldname + " "; } int type = v.getType(); switch (type) { case ValueMetaInterface.TYPE_DATE: retval += "DATETIME"; break; case ValueMetaInterface.TYPE_BOOLEAN: if (supportsBooleanDataType()) { retval += "BIT"; } else { retval += "CHAR(1)"; } break; case ValueMetaInterface.TYPE_NUMBER: case ValueMetaInterface.TYPE_INTEGER: case ValueMetaInterface.TYPE_BIGNUMBER: if (fieldname.equalsIgnoreCase(tk) || // Technical key fieldname.equalsIgnoreCase(pk) // Primary key ) { if (use_autoinc) { retval += "BIGINT PRIMARY KEY IDENTITY(0,1)"; } else { retval += "BIGINT PRIMARY KEY"; } } else { if (precision == 0) { if (length > 18) { retval += "DECIMAL(" + length + ",0)"; } else { if (length > 9) { retval += "BIGINT"; } else { retval += "INT"; } } } else { if (precision > 0) { if (length > 0) { retval += "DECIMAL(" + length + "," + precision + ")"; } } else { retval += "FLOAT(53)"; } } } break; case ValueMetaInterface.TYPE_STRING: if (length < getMaxVARCHARLength()) { // Maybe use some default DB String length in case length<=0 if (length > 0) { retval += "VARCHAR(" + length + ")"; } else { retval += "VARCHAR(100)"; } } else { retval += "TEXT"; // Up to 2bilion characters. } break; default: retval += " UNKNOWN"; break; } if (add_cr) { retval += Const.CR; } return retval; }
public boolean processRow(StepMetaInterface smi, StepDataInterface sdi) throws KettleException { meta = (DatabaseLookupMeta) smi; data = (DatabaseLookupData) sdi; boolean sendToErrorRow = false; String errorMessage = null; Object[] r = getRow(); // Get row from input rowset & set row busy! if (r == null) { // no more input to be expected... setOutputDone(); return false; } if (first) { first = false; // create the output metadata data.outputRowMeta = getInputRowMeta().clone(); meta.getFields(data.outputRowMeta, getStepname(), null, null, this, repository, metaStore); if (meta.isCached()) { if (meta.getCacheSize() > 0) { data.look = new Hashtable<RowMetaAndData, TimedRow>((int) (meta.getCacheSize() * 1.5)); } else { data.look = new Hashtable<RowMetaAndData, TimedRow>(); } } data.db.setLookup( environmentSubstitute(meta.getSchemaName()), environmentSubstitute(meta.getTablename()), meta.getTableKeyField(), meta.getKeyCondition(), meta.getReturnValueField(), meta.getReturnValueNewName(), meta.getOrderByClause(), meta.isFailingOnMultipleResults()); // lookup the values! if (log.isDetailed()) { logDetailed( BaseMessages.getString(PKG, "DatabaseLookup.Log.CheckingRow") + getInputRowMeta().getString(r)); } data.keynrs = new int[meta.getStreamKeyField1().length]; data.keynrs2 = new int[meta.getStreamKeyField1().length]; for (int i = 0; i < meta.getStreamKeyField1().length; i++) { data.keynrs[i] = getInputRowMeta().indexOfValue(meta.getStreamKeyField1()[i]); if (data.keynrs[i] < 0 && // couldn't find field! !"IS NULL".equalsIgnoreCase(meta.getKeyCondition()[i]) && // No field needed! !"IS NOT NULL".equalsIgnoreCase(meta.getKeyCondition()[i]) // No field needed! ) { throw new KettleStepException( BaseMessages.getString(PKG, "DatabaseLookup.ERROR0001.FieldRequired1.Exception") + meta.getStreamKeyField1()[i] + BaseMessages.getString( PKG, "DatabaseLookup.ERROR0001.FieldRequired2.Exception")); } data.keynrs2[i] = getInputRowMeta().indexOfValue(meta.getStreamKeyField2()[i]); if (data.keynrs2[i] < 0 && // couldn't find field! "BETWEEN".equalsIgnoreCase(meta.getKeyCondition()[i]) // 2 fields needed! ) { throw new KettleStepException( BaseMessages.getString(PKG, "DatabaseLookup.ERROR0001.FieldRequired3.Exception") + meta.getStreamKeyField2()[i] + BaseMessages.getString( PKG, "DatabaseLookup.ERROR0001.FieldRequired4.Exception")); } if (log.isDebug()) { logDebug( BaseMessages.getString(PKG, "DatabaseLookup.Log.FieldHasIndex1") + meta.getStreamKeyField1()[i] + BaseMessages.getString(PKG, "DatabaseLookup.Log.FieldHasIndex2") + data.keynrs[i]); } } data.nullif = new Object[meta.getReturnValueField().length]; for (int i = 0; i < meta.getReturnValueField().length; i++) { ValueMetaInterface stringMeta = new ValueMeta("string", ValueMetaInterface.TYPE_STRING); ValueMetaInterface returnMeta = data.outputRowMeta.getValueMeta(i + getInputRowMeta().size()); if (!Const.isEmpty(meta.getReturnValueDefault()[i])) { data.nullif[i] = returnMeta.convertData(stringMeta, meta.getReturnValueDefault()[i]); } else { data.nullif[i] = null; } } // Determine the types... data.keytypes = new int[meta.getTableKeyField().length]; String schemaTable = meta.getDatabaseMeta() .getQuotedSchemaTableCombination( environmentSubstitute(meta.getSchemaName()), environmentSubstitute(meta.getTablename())); RowMetaInterface fields = data.db.getTableFields(schemaTable); if (fields != null) { // Fill in the types... for (int i = 0; i < meta.getTableKeyField().length; i++) { ValueMetaInterface key = fields.searchValueMeta(meta.getTableKeyField()[i]); if (key != null) { data.keytypes[i] = key.getType(); } else { throw new KettleStepException( BaseMessages.getString(PKG, "DatabaseLookup.ERROR0001.FieldRequired5.Exception") + meta.getTableKeyField()[i] + BaseMessages.getString( PKG, "DatabaseLookup.ERROR0001.FieldRequired6.Exception")); } } } else { throw new KettleStepException( BaseMessages.getString(PKG, "DatabaseLookup.ERROR0002.UnableToDetermineFieldsOfTable") + schemaTable + "]"); } // Count the number of values in the lookup as well as the metadata to send along with it. // data.lookupMeta = new RowMeta(); for (int i = 0; i < meta.getStreamKeyField1().length; i++) { if (data.keynrs[i] >= 0) { ValueMetaInterface inputValueMeta = getInputRowMeta().getValueMeta(data.keynrs[i]); // Try to convert type if needed in a clone, we don't want to // change the type in the original row // ValueMetaInterface value = ValueMetaFactory.cloneValueMeta(inputValueMeta, data.keytypes[i]); data.lookupMeta.addValueMeta(value); } if (data.keynrs2[i] >= 0) { ValueMetaInterface inputValueMeta = getInputRowMeta().getValueMeta(data.keynrs2[i]); // Try to convert type if needed in a clone, we don't want to // change the type in the original row // ValueMetaInterface value = ValueMetaFactory.cloneValueMeta(inputValueMeta, data.keytypes[i]); data.lookupMeta.addValueMeta(value); } } // We also want to know the metadata of the return values beforehand (null handling) data.returnMeta = new RowMeta(); for (int i = 0; i < meta.getReturnValueField().length; i++) { ValueMetaInterface v = data.outputRowMeta.getValueMeta(getInputRowMeta().size() + i).clone(); data.returnMeta.addValueMeta(v); } // If the user selected to load all data into the cache at startup, that's what we do now... // if (meta.isCached() && meta.isLoadingAllDataInCache()) { loadAllTableDataIntoTheCache(); } } if (log.isRowLevel()) { logRowlevel( BaseMessages.getString(PKG, "DatabaseLookup.Log.GotRowFromPreviousStep") + getInputRowMeta().getString(r)); } try { // add new lookup values to the row Object[] outputRow = lookupValues(getInputRowMeta(), r); if (outputRow != null) { // copy row to output rowset(s); putRow(data.outputRowMeta, outputRow); if (log.isRowLevel()) { logRowlevel( BaseMessages.getString(PKG, "DatabaseLookup.Log.WroteRowToNextStep") + getInputRowMeta().getString(r)); } if (checkFeedback(getLinesRead())) { logBasic("linenr " + getLinesRead()); } } } catch (KettleException e) { if (getStepMeta().isDoingErrorHandling()) { sendToErrorRow = true; errorMessage = e.toString(); } else { logError( BaseMessages.getString(PKG, "DatabaseLookup.ERROR003.UnexpectedErrorDuringProcessing") + e.getMessage()); setErrors(1); stopAll(); setOutputDone(); // signal end to receiver(s) return false; } if (sendToErrorRow) { // Simply add this row to the error row putError(getInputRowMeta(), r, 1, errorMessage, null, "DBLOOKUPD001"); } } return true; }
public void getFields( RowMetaInterface row, String origin, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space) throws KettleStepException { // Row should normally be empty when we get here. // That is because there is no previous step to this mapping input step from the viewpoint of // this single sub-transformation. // From the viewpoint of the transformation that executes the mapping, it's important to know // what comes out at the exit points. // For that reason we need to re-order etc, based on the input specification... // if (inputRowMeta != null && !inputRowMeta.isEmpty()) { // this gets set only in the parent transformation... // It includes all the renames that needed to be done // if (selectingAndSortingUnspecifiedFields) { // First rename any fields... if (valueRenames != null) { for (MappingValueRename valueRename : valueRenames) { ValueMetaInterface valueMeta = inputRowMeta.searchValueMeta(valueRename.getSourceValueName()); if (valueMeta == null) { throw new KettleStepException( BaseMessages.getString( PKG, "MappingInput.Exception.UnableToFindMappedValue", valueRename.getSourceValueName())); } valueMeta.setName(valueRename.getTargetValueName()); } } // 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); // Validate the existence of all the specified fields... // 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 { // We'll have to work with the statically provided information for (int i = 0; i < fieldName.length; i++) { if (!Const.isEmpty(fieldName[i])) { ValueMetaInterface v = new ValueMeta(fieldName[i], fieldType[i]); if (v.getType() == ValueMetaInterface.TYPE_NONE) v.setType(ValueMetaInterface.TYPE_STRING); v.setLength(fieldLength[i]); v.setPrecision(fieldPrecision[i]); v.setOrigin(origin); row.addValueMeta(v); } } } }
public static final RowMetaAndData buildRow( RowGeneratorMeta meta, List<CheckResultInterface> remarks, String origin) { RowMetaInterface rowMeta = new RowMeta(); Object[] rowData = RowDataUtil.allocateRowData(meta.getFieldName().length); for (int i = 0; i < meta.getFieldName().length; i++) { int valtype = ValueMeta.getType(meta.getFieldType()[i]); if (meta.getFieldName()[i] != null) { ValueMetaInterface valueMeta = new ValueMeta(meta.getFieldName()[i], valtype); // build a value! valueMeta.setLength(meta.getFieldLength()[i]); valueMeta.setPrecision(meta.getFieldPrecision()[i]); valueMeta.setConversionMask(meta.getFieldFormat()[i]); valueMeta.setGroupingSymbol(meta.getGroup()[i]); valueMeta.setDecimalSymbol(meta.getDecimal()[i]); valueMeta.setOrigin(origin); ValueMetaInterface stringMeta = valueMeta.clone(); stringMeta.setType(ValueMetaInterface.TYPE_STRING); String stringValue = meta.getValue()[i]; // If the value is empty: consider it to be NULL. if (Const.isEmpty(stringValue)) { rowData[i] = null; if (valueMeta.getType() == ValueMetaInterface.TYPE_NONE) { String message = BaseMessages.getString( PKG, "RowGenerator.CheckResult.SpecifyTypeError", valueMeta.getName(), stringValue); remarks.add(new CheckResult(CheckResultInterface.TYPE_RESULT_ERROR, message, null)); } } else { // Convert the data from String to the specified type ... // try { rowData[i] = valueMeta.convertData(stringMeta, stringValue); } catch (KettleValueException e) { switch (valueMeta.getType()) { case ValueMetaInterface.TYPE_NUMBER: { String message = BaseMessages.getString( PKG, "RowGenerator.BuildRow.Error.Parsing.Number", valueMeta.getName(), stringValue, e.toString()); remarks.add( new CheckResult(CheckResultInterface.TYPE_RESULT_ERROR, message, null)); } break; case ValueMetaInterface.TYPE_DATE: { String message = BaseMessages.getString( PKG, "RowGenerator.BuildRow.Error.Parsing.Date", valueMeta.getName(), stringValue, e.toString()); remarks.add( new CheckResult(CheckResultInterface.TYPE_RESULT_ERROR, message, null)); } break; case ValueMetaInterface.TYPE_INTEGER: { String message = BaseMessages.getString( PKG, "RowGenerator.BuildRow.Error.Parsing.Integer", valueMeta.getName(), stringValue, e.toString()); remarks.add( new CheckResult(CheckResultInterface.TYPE_RESULT_ERROR, message, null)); } break; case ValueMetaInterface.TYPE_BIGNUMBER: { String message = BaseMessages.getString( PKG, "RowGenerator.BuildRow.Error.Parsing.BigNumber", valueMeta.getName(), stringValue, e.toString()); remarks.add( new CheckResult(CheckResultInterface.TYPE_RESULT_ERROR, message, null)); } break; default: // Boolean and binary don't throw errors normally, so it's probably an unspecified // error problem... { String message = BaseMessages.getString( PKG, "RowGenerator.CheckResult.SpecifyTypeError", valueMeta.getName(), stringValue); remarks.add( new CheckResult(CheckResultInterface.TYPE_RESULT_ERROR, message, null)); } break; } } } // Now add value to the row! // This is in fact a copy from the fields row, but now with data. rowMeta.addValueMeta(valueMeta); } } return new RowMetaAndData(rowMeta, rowData); }
public String getFieldDefinition( ValueMetaInterface v, String tk, String pk, boolean use_autoinc, boolean add_fieldname, boolean add_cr) { StringBuffer retval = new StringBuffer(128); String fieldname = v.getName(); int length = v.getLength(); int precision = v.getPrecision(); if (add_fieldname) retval.append(fieldname).append(' '); int type = v.getType(); switch (type) { case ValueMetaInterface.TYPE_DATE: retval.append("TIMESTAMP"); break; case ValueMetaInterface.TYPE_BOOLEAN: if (supportsBooleanDataType()) { retval.append("BOOLEAN"); } else { retval.append("CHAR(1)"); } break; case ValueMetaInterface.TYPE_NUMBER: case ValueMetaInterface.TYPE_INTEGER: case ValueMetaInterface.TYPE_BIGNUMBER: if (fieldname.equalsIgnoreCase(tk) || // Technical key fieldname.equalsIgnoreCase(pk) // Primary key ) { retval.append( "BIGINT GENERATED BY DEFAULT AS IDENTITY(START WITH 0, INCREMENT BY 1) PRIMARY KEY"); } else { if (length > 0) { if (precision > 0 || length > 18) { retval.append("NUMERIC(").append(length).append(", ").append(precision).append(')'); } else { if (length > 9) { retval.append("BIGINT"); } else { if (length < 5) { retval.append("SMALLINT"); } else { retval.append("INTEGER"); } } } } else { retval.append("DOUBLE PRECISION"); } } break; case ValueMetaInterface.TYPE_STRING: if (length >= DatabaseMeta.CLOB_LENGTH) { retval.append("TEXT"); } else { retval.append("VARCHAR"); if (length > 0) { retval.append('(').append(length); } else { retval.append('('); // Maybe use some default DB String length? } retval.append(')'); } break; default: retval.append(" UNKNOWN"); break; } if (add_cr) retval.append(Const.CR); return retval.toString(); }