private String quoteLiteral(String value, DataType type) { if (type == DataType.TEXT) { return stringLiteral(value); } else if (type == DataType.DATE) { return "DATE " + stringLiteral(value); } else if (type == DataType.TIME) { return "TIME " + stringLiteral(value); } else if (type == DataType.DATETIME) { return "TIMESTAMP " + stringLiteral(value); } return value; } }
private String quoted(String value, DataType type) { if (type == null || type == TEXT) { return stringLiteral(value); } else if (type == DATE) { if (value == null) { return "CAST (null as DATE)"; } return "DATE " + stringLiteral(value); } else if (type == TIME) { if (value == null) { return "CAST (null as TIME)"; } return "TIME " + stringLiteral(value); } else if (type == DATETIME) { if (value == null) { return "CAST (null as TIMESTAMP)"; } return "TIMESTAMP " + stringLiteral(value); } else { return value; } }
private String prepareValue(final String value, DataType type) throws Exception { if (value == null) { return "NULL"; } switch (type) { case BOOLEAN: case DECIMAL: case FLOAT: case INTEGER: return value; case DATE: case DATETIME: case TEXT: case TIME: return stringLiteral(value); default: throw new UnsupportedOperationException("prepareValue can not be aplied to " + type.name()); } }
@Override public String getFunctionExpr(String expr, Object... args) { checkArgument(args.length == 2 && args[0] != null && args[1] != null, "Expected the split position type and index as arguments"); SplitPositionType splitPositionType = (SplitPositionType) args[0]; Integer index = (Integer) args[1]; return String.format("%s(%s, %s, %s, %d)", SplitPattern.REGEXP_SPLIT, expr, getDelimiterRegexLiteral(false), stringLiteral(splitPositionType.toString()), index ); }
@Override public String visit(FieldConvertDateToText dateToText) throws Exception { return format( "TO_CHAR(%s, %s)", eval(fieldTransformation.getOperand()), stringLiteral(dateToText.getFormat())); }
@Override public String visit(FieldConvertListToText listToText) throws Exception { return format( "%s(%s, %s)", FormatList.NAME, eval(fieldTransformation.getOperand()), stringLiteral(listToText.getDelimiter())); }
private String getMatchFunction(String expr) { // Generate the match function if (rule.getSelectionType() == IS_NULL) { return String.format("%s IS NULL", expr); } else if (rule.getSelectionType() == EXACT) { if (rule.getIgnoreCase() != null && rule.getIgnoreCase()) { return String.format("lower(%s) = lower(%s)", expr, stringLiteral(rule.getSelectionPattern())); } else { return String.format("%s = %s", expr, stringLiteral(rule.getSelectionPattern())); } } else { String patternLiteral = getRegexPatternLiteral(true); return String.format("regexp_like(%s, %s)", expr, patternLiteral); } }
private String getFunction(String functionName, String inputExpr) { ExtractRulePattern patternRule = rule.getPattern(); String pattern = patternRule.getPattern(); if (patternRule.getIgnoreCase() != null && patternRule.getIgnoreCase()) { pattern = "(?i)(?u)" + pattern; } return String.format("%s(%s, %s, %d, %s)", functionName, inputExpr, stringLiteral(pattern), patternRule.getIndex(), stringLiteral(patternRule.getIndexType().name()) ); }
final TextFileConfig textFileConfig = (TextFileConfig)this; stringBuilder.append("type => 'text', "); stringBuilder.append(format("fieldDelimiter => %s, ", SqlUtils.stringLiteral(textFileConfig.getFieldDelimiter()))); stringBuilder.append(format("comment => %s, ", SqlUtils.stringLiteral(singleChar(textFileConfig.getComment())))); stringBuilder.append(format("%1$sescape%1$s => %2$s, ", SqlUtils.QUOTE, SqlUtils.stringLiteral(singleChar(textFileConfig.getEscape())))); stringBuilder.append(format("quote => %s, ", SqlUtils.stringLiteral(singleChar(textFileConfig.getQuote())))); stringBuilder.append(format("lineDelimiter => %s, ", SqlUtils.stringLiteral(textFileConfig.getLineDelimiter()))); stringBuilder.append(format("extractHeader => %s, ", textFileConfig.getExtractHeader().toString())); stringBuilder.append(format("skipFirstLine => %s, ", textFileConfig.getSkipFirstLine().toString())); stringBuilder.append("type => 'excel', "); if (excelFileConfig.getSheetName() != null) { stringBuilder.append(format("sheet => %s, ", SqlUtils.stringLiteral(excelFileConfig.getSheetName()))); stringBuilder.append("type => 'excel', "); if (xlsFileConfig.getSheetName() != null) { stringBuilder.append(format("sheet => %s, ", SqlUtils.stringLiteral(xlsFileConfig.getSheetName())));
@Override public String visit(FieldConvertTextToDate textToDate) throws Exception { String op = eval(fieldTransformation.getOperand()); String dateFormat = stringLiteral(textToDate.getFormat()); DataType desiredType = textToDate.getDesiredType(); switch (desiredType) { case DATE: case DATETIME: case TIME: return format("TO_%s(%s, %s)", DataTypeUtil.getStringValueForDateType(desiredType), op, dateFormat); default: throw new IllegalArgumentException("only DATE, TIME and DATETIME ar valid. Got " + desiredType); } }
@Override public String getExampleFunctionExpr(String input) { final boolean ignoreCase = rule.getIgnoreCase() == null ? false : rule.getIgnoreCase(); final String quotedPattern = stringLiteral(rule.getSelectionPattern()); return String.format("%s(%s, '%s', %s, %s)", MatchPattern.GEN_EXAMPLE, input, rule.getSelectionType().toString(), quotedPattern, ignoreCase); }
if (replaceType != ReplaceType.NULL) { checkArgument(args.length == 2 && args[1] != null, "Expected the replacement value as second argument"); replacementValue = stringLiteral((String)args[1]);
private String getRegexPatternLiteral(boolean forMatch) { final String patternLiteral = rule.getSelectionPattern(); String regexp; switch (rule.getSelectionType()) { case CONTAINS: regexp = regexp(forMatch) + quote(patternLiteral) + regexp(forMatch); break; case STARTS_WITH: regexp = "^" + quote(patternLiteral) + regexp(forMatch); break; case ENDS_WITH: regexp = regexp(forMatch) + quote(patternLiteral) + "$"; break; case MATCHES: regexp = regexp(forMatch) + patternLiteral + regexp(forMatch); break; default: throw UserException.unsupportedError() .message("regexp not available for selection type: " + rule.getSelectionType().toString()) .build(logger); } if (rule.getIgnoreCase() != null && rule.getIgnoreCase()) { // make the pattern case insensitive and unicode case aware regexp = "(?i)(?u)" + regexp; } return stringLiteral(regexp); }
private String getDelimiterRegexLiteral(boolean forMatching) { String regexp; switch (rule.getMatchType()) { case exact: regexp = quote(rule.getPattern()); break; case regex: regexp = rule.getPattern(); break; default: throw UserException.unsupportedError() .message("unsupported selection type: " + rule.getMatchType().toString()) .build(logger); } if (forMatching) { regexp = ".*" + regexp + ".*"; } if (rule.getIgnoreCase() != null && rule.getIgnoreCase()) { // make the pattern case insensitive and unicode case aware regexp = "(?i)(?u)" + regexp; } return stringLiteral(regexp); } }