Repository: camel Updated Branches: refs/heads/master dbb552c9e -> e9f3f60d2
CAMEL-4725 camel-sql - Add support for Callable statements Project: http://git-wip-us.apache.org/repos/asf/camel/repo Commit: http://git-wip-us.apache.org/repos/asf/camel/commit/6dac645b Tree: http://git-wip-us.apache.org/repos/asf/camel/tree/6dac645b Diff: http://git-wip-us.apache.org/repos/asf/camel/diff/6dac645b Branch: refs/heads/master Commit: 6dac645b89ac4c3e115137b08a079c822c935d1f Parents: dbb552c Author: Sami Nurminen <snurm...@gmail.com> Authored: Sun Dec 20 23:34:33 2015 +0200 Committer: Claus Ibsen <davscl...@apache.org> Committed: Sat Jan 9 10:59:45 2016 +0100 ---------------------------------------------------------------------- .../apache/camel/component/sql/SqlEndpoint.java | 5 +- .../apache/camel/component/sql/SqlProducer.java | 17 +- .../component/sql/sspt/ProducerSSPTHelper.java | 36 ++ .../sql/sspt/SimpleStoredProcedure.java | 56 +++ .../sql/sspt/SimpleStoredProcedureFactory.java | 33 ++ .../component/sql/sspt/ast/InputParameter.java | 47 ++ .../component/sql/sspt/ast/OutParameter.java | 33 ++ .../component/sql/sspt/ast/ParseException.java | 189 ++++++++ .../component/sql/sspt/ast/ParseHelper.java | 58 +++ .../camel/component/sql/sspt/ast/Template.java | 43 ++ .../component/sql/sspt/parser/SSPTParser.java | 282 +++++++++++ .../sql/sspt/parser/SSPTParserConstants.java | 39 ++ .../sql/sspt/parser/SSPTParserTokenManager.java | 366 ++++++++++++++ .../sql/sspt/parser/SimpleCharStream.java | 471 +++++++++++++++++++ .../camel/component/sql/sspt/parser/Token.java | 131 ++++++ .../sql/sspt/parser/TokenMgrError.java | 147 ++++++ .../sql/sspt/parser/generate_sptp_classes.sh | 4 + .../camel/component/sql/sspt/parser/sspt.jj | 136 ++++++ .../camel/component/sql/sspt/ParserTest.java | 81 ++++ .../camel/component/sql/sspt/ProducerTest.java | 72 +++ .../sql/sspt/SimpleStoredProcedureTest.java | 57 +++ .../sql/sspt/SimpleStoredProcedureUdf.java | 15 + .../test/resources/sql/storedProcedureTest.sql | 22 + 23 files changed, 2338 insertions(+), 2 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/main/java/org/apache/camel/component/sql/SqlEndpoint.java ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/main/java/org/apache/camel/component/sql/SqlEndpoint.java b/components/camel-sql/src/main/java/org/apache/camel/component/sql/SqlEndpoint.java index b16147d..247952d 100644 --- a/components/camel-sql/src/main/java/org/apache/camel/component/sql/SqlEndpoint.java +++ b/components/camel-sql/src/main/java/org/apache/camel/component/sql/SqlEndpoint.java @@ -20,6 +20,7 @@ import org.apache.camel.Component; import org.apache.camel.Consumer; import org.apache.camel.Processor; import org.apache.camel.Producer; +import org.apache.camel.component.sql.sspt.ProducerSSPTHelper; import org.apache.camel.spi.Metadata; import org.apache.camel.spi.UriEndpoint; import org.apache.camel.spi.UriPath; @@ -61,7 +62,9 @@ public class SqlEndpoint extends DefaultSqlEndpoint { public Producer createProducer() throws Exception { SqlPrepareStatementStrategy prepareStrategy = getPrepareStatementStrategy() != null ? getPrepareStatementStrategy() : new DefaultSqlPrepareStatementStrategy(getSeparator()); - SqlProducer result = new SqlProducer(this, query, getJdbcTemplate(), prepareStrategy, isBatch(), isAlwaysPopulateStatement(), isUseMessageBodyForSql()); + ProducerSSPTHelper producerSSPTHelper = new ProducerSSPTHelper(getJdbcTemplate().getDataSource()); + SqlProducer result = new SqlProducer(this, query, getJdbcTemplate(), prepareStrategy, isBatch(), + isAlwaysPopulateStatement(), isUseMessageBodyForSql(),producerSSPTHelper); result.setParametersCount(getParametersCount()); return result; } http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/main/java/org/apache/camel/component/sql/SqlProducer.java ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/main/java/org/apache/camel/component/sql/SqlProducer.java b/components/camel-sql/src/main/java/org/apache/camel/component/sql/SqlProducer.java index 483bd72..a8a85ac 100644 --- a/components/camel-sql/src/main/java/org/apache/camel/component/sql/SqlProducer.java +++ b/components/camel-sql/src/main/java/org/apache/camel/component/sql/SqlProducer.java @@ -27,6 +27,8 @@ import java.util.List; import java.util.Map; import org.apache.camel.Exchange; + +import org.apache.camel.component.sql.sspt.ProducerSSPTHelper; import org.apache.camel.impl.DefaultProducer; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.jdbc.core.PreparedStatementCallback; @@ -42,9 +44,11 @@ public class SqlProducer extends DefaultProducer { private final SqlPrepareStatementStrategy sqlPrepareStatementStrategy; private final boolean useMessageBodyForSql; private int parametersCount; + private final ProducerSSPTHelper producerSSPTHelper; public SqlProducer(SqlEndpoint endpoint, String query, JdbcTemplate jdbcTemplate, SqlPrepareStatementStrategy sqlPrepareStatementStrategy, - boolean batch, boolean alwaysPopulateStatement, boolean useMessageBodyForSql) { + boolean batch, boolean alwaysPopulateStatement, boolean useMessageBodyForSql, + ProducerSSPTHelper producerSSPTHelper) { super(endpoint); this.jdbcTemplate = jdbcTemplate; this.sqlPrepareStatementStrategy = sqlPrepareStatementStrategy; @@ -52,6 +56,7 @@ public class SqlProducer extends DefaultProducer { this.batch = batch; this.alwaysPopulateStatement = alwaysPopulateStatement; this.useMessageBodyForSql = useMessageBodyForSql; + this.producerSSPTHelper = producerSSPTHelper; } @Override @@ -61,12 +66,20 @@ public class SqlProducer extends DefaultProducer { public void process(final Exchange exchange) throws Exception { final String sql; + if (useMessageBodyForSql) { sql = exchange.getIn().getBody(String.class); } else { String queryHeader = exchange.getIn().getHeader(SqlConstants.SQL_QUERY, String.class); sql = queryHeader != null ? queryHeader : query; } + + if(producerSSPTHelper.isSSPTQuery(sql)) { + producerSSPTHelper.handleSstpQuery(sql,exchange); + return; + } + + final String preparedQuery = sqlPrepareStatementStrategy.prepareQuery(sql, getEndpoint().isAllowNamedParameters()); // CAMEL-7313 - check whether to return generated keys @@ -208,6 +221,8 @@ public class SqlProducer extends DefaultProducer { }); } + + public void setParametersCount(int parametersCount) { this.parametersCount = parametersCount; } http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ProducerSSPTHelper.java ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ProducerSSPTHelper.java b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ProducerSSPTHelper.java new file mode 100644 index 0000000..75e7a71 --- /dev/null +++ b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ProducerSSPTHelper.java @@ -0,0 +1,36 @@ +package org.apache.camel.component.sql.sspt; + +import org.apache.camel.Exchange; +import org.apache.camel.RuntimeCamelException; +import org.apache.camel.component.sql.sspt.ast.ParseException; + +import javax.sql.DataSource; + +/** + * Created by snurmine on 1/1/16. + */ +public class ProducerSSPTHelper { + + public static final String SSPT_QUERY_PREFIX = "sspt:"; + final DataSource dataSource; + SimpleStoredProcedureFactory simpleStoredProcedureFactory = new SimpleStoredProcedureFactory(); + + public ProducerSSPTHelper(DataSource dataSource) { + this.dataSource = dataSource; + } + + public void handleSstpQuery(String sql, Exchange exchange) { + try { + String sstp = sql.substring(SSPT_QUERY_PREFIX.length()); + //TODO: cache parsed SimpleStoredProcedure to LRU-cache. + SimpleStoredProcedure storedProcedure = simpleStoredProcedureFactory.createFromString(sstp, dataSource); + storedProcedure.execute(exchange); + } catch (ParseException parseException) { + throw new RuntimeCamelException(parseException); + } + } + + public boolean isSSPTQuery(String sql) { + return sql.startsWith(SSPT_QUERY_PREFIX); + } +} http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/SimpleStoredProcedure.java ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/SimpleStoredProcedure.java b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/SimpleStoredProcedure.java new file mode 100644 index 0000000..55da509 --- /dev/null +++ b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/SimpleStoredProcedure.java @@ -0,0 +1,56 @@ +package org.apache.camel.component.sql.sspt; + +import org.apache.camel.Exchange; +import org.apache.camel.component.sql.sspt.ast.InputParameter; +import org.apache.camel.component.sql.sspt.ast.OutParameter; +import org.apache.camel.component.sql.sspt.ast.Template; +import org.springframework.jdbc.core.SqlOutParameter; +import org.springframework.jdbc.core.SqlParameter; +import org.springframework.jdbc.object.StoredProcedure; + +import javax.sql.DataSource; +import java.util.HashMap; +import java.util.Map; + + +public class SimpleStoredProcedure extends StoredProcedure { + + Template template; + + public SimpleStoredProcedure(DataSource dataSource, Template template) { + this.template = template; + setDataSource(dataSource); + + setSql(template.getProcedureName()); + + for (InputParameter inputParameter : template.getInputParameterList()) { + declareParameter(new SqlParameter(inputParameter.getName(), inputParameter.getSqlType())); + } + + for (OutParameter outParameter : template.getOutParameterList()) { + declareParameter(new SqlOutParameter(outParameter.getName(), outParameter.getSqlType())); + setFunction(false); + } + + compile(); + } + + + public void execute(Exchange exchange) { + + Map<String, Object> params = new HashMap<>(); + + for (InputParameter inputParameter : template.getInputParameterList()) { + params.put(inputParameter.getName(), inputParameter.getValueExpression().evaluate(exchange, inputParameter.getJavaType())); + } + + Map<String, Object> ret = super.execute(params); + + for (OutParameter out : template.getOutParameterList()) { + exchange.getOut().setHeader(out.getOutHeader(), ret.get(out.getName())); + } + + } + + +} http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/SimpleStoredProcedureFactory.java ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/SimpleStoredProcedureFactory.java b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/SimpleStoredProcedureFactory.java new file mode 100644 index 0000000..43765b2 --- /dev/null +++ b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/SimpleStoredProcedureFactory.java @@ -0,0 +1,33 @@ +package org.apache.camel.component.sql.sspt; + +import org.apache.camel.component.sql.sspt.ast.ParseException; +import org.apache.camel.component.sql.sspt.ast.Template; +import org.apache.camel.component.sql.sspt.parser.SSPTParser; + +import javax.sql.DataSource; +import java.io.StringReader; + +public class SimpleStoredProcedureFactory { + + + public SimpleStoredProcedure createFromString(String string, DataSource dataSource) throws ParseException { + Template sptpRootNode = parseTemplate(string); + return new SimpleStoredProcedure(dataSource, sptpRootNode); + + } + + public Template parseTemplate(String template) throws ParseException { + SSPTParser parser = new SSPTParser(new StringReader(template)); + + return validate(parser.parse()); + } + + private Template validate(Template input) throws ParseException { + if (input.getOutParameterList().isEmpty()) { + throw new ParseException("At least one OUT parameter must be given."); + } + return input; + } + + +} http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ast/InputParameter.java ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ast/InputParameter.java b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ast/InputParameter.java new file mode 100644 index 0000000..2dfd62b --- /dev/null +++ b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ast/InputParameter.java @@ -0,0 +1,47 @@ +package org.apache.camel.component.sql.sspt.ast; + +import org.apache.camel.Expression; +import org.apache.camel.builder.ExpressionBuilder; + + +public class InputParameter { + + String name; + + int sqlType; + + Expression valueExpression; + + Class javaType; + + + public InputParameter(String name, int sqlType, String valueSrcAsStr, Class javaType) { + this.name = name; + this.sqlType = sqlType; + this.javaType = javaType; + this.valueExpression = parseValueExpression(valueSrcAsStr); + } + + + private Expression parseValueExpression(String str) { + return ExpressionBuilder.simpleExpression(str); + } + + public String getName() { + return name; + } + + public int getSqlType() { + return sqlType; + } + + public Expression getValueExpression() { + return valueExpression; + } + + public Class getJavaType() { + return javaType; + } + + +} http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ast/OutParameter.java ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ast/OutParameter.java b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ast/OutParameter.java new file mode 100644 index 0000000..b7914e4 --- /dev/null +++ b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ast/OutParameter.java @@ -0,0 +1,33 @@ +package org.apache.camel.component.sql.sspt.ast; + +/** + * Created by snurmine on 12/20/15. + */ +public class OutParameter { + + + String name; + + int sqlType; + + String outHeader; + + + public OutParameter(String name, int sqlType, String outHeader) { + this.name = name; + this.sqlType = sqlType; + this.outHeader = outHeader; + } + + public String getName() { + return name; + } + + public int getSqlType() { + return sqlType; + } + + public String getOutHeader() { + return outHeader; + } +} http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ast/ParseException.java ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ast/ParseException.java b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ast/ParseException.java new file mode 100644 index 0000000..f6b5878 --- /dev/null +++ b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ast/ParseException.java @@ -0,0 +1,189 @@ +/* Generated By:JavaCC: Do not edit this line. ParseException.java Version 5.0 */ +/* JavaCCOptions:KEEP_LINE_COL=null */ +package org.apache.camel.component.sql.sspt.ast; + +import org.apache.camel.component.sql.sspt.parser.Token; + +/** + * This exception is thrown when parse errors are encountered. + * You can explicitly create objects of this exception type by + * calling the method generateParseException in the generated + * parser. + * <p> + * You can modify this class to customize your error reporting + * mechanisms so long as you retain the public fields. + */ +public class ParseException extends RuntimeException { + + /** + * The version identifier for this Serializable class. + * Increment only if the <i>serialized</i> form of the + * class changes. + */ + private static final long serialVersionUID = 1L; + /** + * This is the last token that has been consumed successfully. If + * this object has been created due to a parse error, the token + * followng this token will (therefore) be the first error token. + */ + public Token currentToken; + /** + * Each entry in this array is an array of integers. Each array + * of integers represents a sequence of tokens (by their ordinal + * values) that is expected at this point of the parse. + */ + public int[][] expectedTokenSequences; + /** + * This is a reference to the "tokenImage" array of the generated + * parser within which the parse error occurred. This array is + * defined in the generated ...Constants interface. + */ + public String[] tokenImage; + /** + * The end of line string for this machine. + */ + protected String eol = System.getProperty("line.separator", "\n"); + + + /** + * This constructor is used by the method "generateParseException" + * in the generated parser. Calling this constructor generates + * a new object of this type with the fields "currentToken", + * "expectedTokenSequences", and "tokenImage" set. + */ + public ParseException(Token currentTokenVal, + int[][] expectedTokenSequencesVal, + String[] tokenImageVal + ) { + super(initialise(currentTokenVal, expectedTokenSequencesVal, tokenImageVal)); + currentToken = currentTokenVal; + expectedTokenSequences = expectedTokenSequencesVal; + tokenImage = tokenImageVal; + } + + /** + * The following constructors are for use by you for whatever + * purpose you can think of. Constructing the exception in this + * manner makes the exception behave in the normal way - i.e., as + * documented in the class "Throwable". The fields "errorToken", + * "expectedTokenSequences", and "tokenImage" do not contain + * relevant information. The JavaCC generated code does not use + * these constructors. + */ + + public ParseException() { + super(); + } + + /** + * Constructor with message. + */ + public ParseException(String message) { + super(message); + } + + public ParseException(Exception cause) { + super(cause); + } + + /** + * It uses "currentToken" and "expectedTokenSequences" to generate a parse + * error message and returns it. If this object has been created + * due to a parse error, and you do not catch it (it gets thrown + * from the parser) the correct error message + * gets displayed. + */ + private static String initialise(Token currentToken, + int[][] expectedTokenSequences, + String[] tokenImage) { + String eol = System.getProperty("line.separator", "\n"); + StringBuffer expected = new StringBuffer(); + int maxSize = 0; + for (int i = 0; i < expectedTokenSequences.length; i++) { + if (maxSize < expectedTokenSequences[i].length) { + maxSize = expectedTokenSequences[i].length; + } + for (int j = 0; j < expectedTokenSequences[i].length; j++) { + expected.append(tokenImage[expectedTokenSequences[i][j]]).append(' '); + } + if (expectedTokenSequences[i][expectedTokenSequences[i].length - 1] != 0) { + expected.append("..."); + } + expected.append(eol).append(" "); + } + String retval = "Encountered \""; + Token tok = currentToken.next; + for (int i = 0; i < maxSize; i++) { + if (i != 0) retval += " "; + if (tok.kind == 0) { + retval += tokenImage[0]; + break; + } + retval += " " + tokenImage[tok.kind]; + retval += " \""; + retval += add_escapes(tok.image); + retval += " \""; + tok = tok.next; + } + retval += "\" at line " + currentToken.next.beginLine + ", column " + currentToken.next.beginColumn; + retval += "." + eol; + if (expectedTokenSequences.length == 1) { + retval += "Was expecting:" + eol + " "; + } else { + retval += "Was expecting one of:" + eol + " "; + } + retval += expected.toString(); + return retval; + } + + /** + * Used to convert raw characters to their escaped version + * when these raw version cannot be used as part of an ASCII + * string literal. + */ + static String add_escapes(String str) { + StringBuffer retval = new StringBuffer(); + char ch; + for (int i = 0; i < str.length(); i++) { + switch (str.charAt(i)) { + case 0: + continue; + case '\b': + retval.append("\\b"); + continue; + case '\t': + retval.append("\\t"); + continue; + case '\n': + retval.append("\\n"); + continue; + case '\f': + retval.append("\\f"); + continue; + case '\r': + retval.append("\\r"); + continue; + case '\"': + retval.append("\\\""); + continue; + case '\'': + retval.append("\\\'"); + continue; + case '\\': + retval.append("\\\\"); + continue; + default: + if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) { + String s = "0000" + Integer.toString(ch, 16); + retval.append("\\u" + s.substring(s.length() - 4, s.length())); + } else { + retval.append(ch); + } + continue; + } + } + return retval.toString(); + } + +} +/* JavaCC - OriginalChecksum=9df9fe5c4e531f41d82ff5964724c931 (do not edit this line) */ http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ast/ParseHelper.java ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ast/ParseHelper.java b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ast/ParseHelper.java new file mode 100644 index 0000000..1b372db --- /dev/null +++ b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ast/ParseHelper.java @@ -0,0 +1,58 @@ +package org.apache.camel.component.sql.sspt.ast; + +import org.springframework.util.ReflectionUtils; + +import java.lang.reflect.Field; +import java.math.BigInteger; +import java.sql.Date; +import java.sql.Types; + + +public class ParseHelper { + + public static int parseSqlType(String sqlType) { + Field field = ReflectionUtils.findField(Types.class, sqlType); + if (field == null) { + throw new ParseException("Field " + sqlType + " not found from java.procedureName.Types"); + } + try { + return field.getInt(Types.class); + } catch (IllegalAccessException e) { + throw new ParseException(e); + } + } + + public static Class sqlTypeToJavaType(int sqlType, String sqlTypeStr) { + //TODO: as rest of types. + //TODO: add test for each type. + Class ret = null; + switch (sqlType) { + case Types.INTEGER: + ret = Integer.class; + break; + case Types.VARCHAR: + ret = String.class; + break; + case Types.BIGINT: + ret = BigInteger.class; + break; + case Types.CHAR: + ret = String.class; + break; + case Types.BOOLEAN: + ret = Boolean.class; + break; + case Types.DATE: + ret = Date.class; + break; + case Types.TIMESTAMP: + ret = Date.class; + break; + } + if (ret == null) { + throw new ParseException("Unable to map SQL type " + sqlTypeStr + " to Java type"); + + } + return ret; + } +} http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ast/Template.java ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ast/Template.java b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ast/Template.java new file mode 100644 index 0000000..adcb740 --- /dev/null +++ b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/ast/Template.java @@ -0,0 +1,43 @@ +package org.apache.camel.component.sql.sspt.ast; + +import java.util.ArrayList; +import java.util.List; + +/** + * Root element of Simple Stored Procedure Template AST. + */ +public class Template { + + String procedureName; + + List<InputParameter> inputParameterList = new ArrayList<>(); + + List<OutParameter> outParameterList = new ArrayList<>(); + + public void addParameter(Object parameter) { + + if (parameter instanceof OutParameter) { + outParameterList.add((OutParameter) parameter); + } else { + inputParameterList.add((InputParameter) parameter); + + } + } + + public String getProcedureName() { + return procedureName; + } + + public void setProcedureName(String procedureName) { + this.procedureName = procedureName; + } + + public List<InputParameter> getInputParameterList() { + return inputParameterList; + } + + public List<OutParameter> getOutParameterList() { + return outParameterList; + } +} + http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/SSPTParser.java ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/SSPTParser.java b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/SSPTParser.java new file mode 100644 index 0000000..66b0843 --- /dev/null +++ b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/SSPTParser.java @@ -0,0 +1,282 @@ +/* Generated By: http&JavaCC: Do not edit this line. SSPTParser.java */ +package org.apache.camel.component.sql.sspt.parser; + +import org.apache.camel.component.sql.sspt.ast.*; + +public class SSPTParser implements SSPTParserConstants { + int paramaterNameCounter = 0; + + String createNextParameterName() { + return "_"+(paramaterNameCounter++); + } + + final public Template parse() throws ParseException { + Token procudureName; + Template template = new Template(); + Object parameter = null; + procudureName = jj_consume_token(IDENTIFIER); + jj_consume_token(1); + parameter = Parameter(); + template.addParameter(parameter); + label_1: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 2: + ; + break; + default: + jj_la1[0] = jj_gen; + break label_1; + } + jj_consume_token(2); + parameter = Parameter(); + template.addParameter(parameter); + } + jj_consume_token(3); + jj_consume_token(0); + template.setProcedureName(procudureName.toString()); + {if (true) return template;} + throw new Error("Missing return statement in function"); + } + + final public Object Parameter() throws ParseException { + Object param; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case IDENTIFIER: + param = InputParameter(); + {if (true) return param;} + break; + case 5: + param = OutParameter(); + {if (true) return param;} + break; + default: + jj_la1[1] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public InputParameter InputParameter() throws ParseException { + String sqlTypeAsStr; + String name; + String valueSrcAsStr; + sqlTypeAsStr = ParameterSqlType(); + jj_consume_token(4); + valueSrcAsStr = InputParameterSrc(); + int sqlType = ParseHelper.parseSqlType(sqlTypeAsStr); + {if (true) return new InputParameter(createNextParameterName(),sqlType,valueSrcAsStr,ParseHelper.sqlTypeToJavaType(sqlType,sqlTypeAsStr));} + throw new Error("Missing return statement in function"); + } + + final public OutParameter OutParameter() throws ParseException { + String sqlType; + String name; + String outHeader; + jj_consume_token(5); + jj_consume_token(4); + sqlType = ParameterSqlType(); + jj_consume_token(4); + outHeader = OutHeader(); + {if (true) return new OutParameter(createNextParameterName(),ParseHelper.parseSqlType(sqlType),outHeader);} + throw new Error("Missing return statement in function"); + } + + final public String ParameterSqlType() throws ParseException { + Token t; + t = jj_consume_token(IDENTIFIER); + {if (true) return t.toString();} + throw new Error("Missing return statement in function"); + } + + final public String OutHeader() throws ParseException { + Token token; + token = jj_consume_token(IDENTIFIER); + {if (true) return token.toString();} + throw new Error("Missing return statement in function"); + } + + final public String InputParameterSrc() throws ParseException { + String ret; + ret = SimpleExpression(); + {if (true) return ret;} + throw new Error("Missing return statement in function"); + } + + final public String SimpleExpression() throws ParseException { + Token t = null; + t = jj_consume_token(SIMPLE_EXP_TOKEN); + {if (true) return t.toString();} + throw new Error("Missing return statement in function"); + } + + /** Generated Token Manager. */ + public SSPTParserTokenManager token_source; + SimpleCharStream jj_input_stream; + /** Current token. */ + public Token token; + /** Next token. */ + public Token jj_nt; + private int jj_ntk; + private int jj_gen; + final private int[] jj_la1 = new int[2]; + static private int[] jj_la1_0; + static { + jj_la1_init_0(); + } + private static void jj_la1_init_0() { + jj_la1_0 = new int[] {0x4,0x220,}; + } + + /** Constructor with InputStream. */ + public SSPTParser(java.io.InputStream stream) { + this(stream, null); + } + /** Constructor with InputStream and supplied encoding */ + public SSPTParser(java.io.InputStream stream, String encoding) { + try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); } + token_source = new SSPTParserTokenManager(jj_input_stream); + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 2; i++) jj_la1[i] = -1; + } + + /** Reinitialise. */ + public void ReInit(java.io.InputStream stream) { + ReInit(stream, null); + } + /** Reinitialise. */ + public void ReInit(java.io.InputStream stream, String encoding) { + try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); } + token_source.ReInit(jj_input_stream); + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 2; i++) jj_la1[i] = -1; + } + + /** Constructor. */ + public SSPTParser(java.io.Reader stream) { + jj_input_stream = new SimpleCharStream(stream, 1, 1); + token_source = new SSPTParserTokenManager(jj_input_stream); + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 2; i++) jj_la1[i] = -1; + } + + /** Reinitialise. */ + public void ReInit(java.io.Reader stream) { + jj_input_stream.ReInit(stream, 1, 1); + token_source.ReInit(jj_input_stream); + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 2; i++) jj_la1[i] = -1; + } + + /** Constructor with generated Token Manager. */ + public SSPTParser(SSPTParserTokenManager tm) { + token_source = tm; + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 2; i++) jj_la1[i] = -1; + } + + /** Reinitialise. */ + public void ReInit(SSPTParserTokenManager tm) { + token_source = tm; + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 2; i++) jj_la1[i] = -1; + } + + private Token jj_consume_token(int kind) throws ParseException { + Token oldToken; + if ((oldToken = token).next != null) token = token.next; + else token = token.next = token_source.getNextToken(); + jj_ntk = -1; + if (token.kind == kind) { + jj_gen++; + return token; + } + token = oldToken; + jj_kind = kind; + throw generateParseException(); + } + + +/** Get the next Token. */ + final public Token getNextToken() { + if (token.next != null) token = token.next; + else token = token.next = token_source.getNextToken(); + jj_ntk = -1; + jj_gen++; + return token; + } + +/** Get the specific Token. */ + final public Token getToken(int index) { + Token t = token; + for (int i = 0; i < index; i++) { + if (t.next != null) t = t.next; + else t = t.next = token_source.getNextToken(); + } + return t; + } + + private int jj_ntk() { + if ((jj_nt=token.next) == null) + return (jj_ntk = (token.next=token_source.getNextToken()).kind); + else + return (jj_ntk = jj_nt.kind); + } + + private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>(); + private int[] jj_expentry; + private int jj_kind = -1; + + /** Generate ParseException. */ + public ParseException generateParseException() { + jj_expentries.clear(); + boolean[] la1tokens = new boolean[10]; + if (jj_kind >= 0) { + la1tokens[jj_kind] = true; + jj_kind = -1; + } + for (int i = 0; i < 2; i++) { + if (jj_la1[i] == jj_gen) { + for (int j = 0; j < 32; j++) { + if ((jj_la1_0[i] & (1<<j)) != 0) { + la1tokens[j] = true; + } + } + } + } + for (int i = 0; i < 10; i++) { + if (la1tokens[i]) { + jj_expentry = new int[1]; + jj_expentry[0] = i; + jj_expentries.add(jj_expentry); + } + } + int[][] exptokseq = new int[jj_expentries.size()][]; + for (int i = 0; i < jj_expentries.size(); i++) { + exptokseq[i] = jj_expentries.get(i); + } + return new ParseException(token, exptokseq, tokenImage); + } + + /** Enable tracing. */ + final public void enable_tracing() { + } + + /** Disable tracing. */ + final public void disable_tracing() { + } + +} http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/SSPTParserConstants.java ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/SSPTParserConstants.java b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/SSPTParserConstants.java new file mode 100644 index 0000000..54e57d3 --- /dev/null +++ b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/SSPTParserConstants.java @@ -0,0 +1,39 @@ +/* Generated By: http&JavaCC: Do not edit this line. SSPTParserConstants.java */ +package org.apache.camel.component.sql.sspt.parser; + + +/** + * Token literal values and constants. + * Generated by org.javacc.parser.OtherFilesGen#start() + */ +public interface SSPTParserConstants { + + /** End of File. */ + int EOF = 0; + /** RegularExpression Id. */ + int DIGIT = 6; + /** RegularExpression Id. */ + int LETTER = 7; + /** RegularExpression Id. */ + int SIMPLE_EXP_TOKEN = 8; + /** RegularExpression Id. */ + int IDENTIFIER = 9; + + /** Lexical state. */ + int DEFAULT = 0; + + /** Literal token values. */ + String[] tokenImage = { + "<EOF>", + "\"(\"", + "\",\"", + "\")\"", + "\" \"", + "\"OUT\"", + "<DIGIT>", + "<LETTER>", + "<SIMPLE_EXP_TOKEN>", + "<IDENTIFIER>", + }; + +} http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/SSPTParserTokenManager.java ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/SSPTParserTokenManager.java b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/SSPTParserTokenManager.java new file mode 100644 index 0000000..4daa202 --- /dev/null +++ b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/SSPTParserTokenManager.java @@ -0,0 +1,366 @@ +/* Generated By: http&JavaCC: Do not edit this line. SSPTParserTokenManager.java */ +package org.apache.camel.component.sql.sspt.parser; +import org.apache.camel.component.sql.sspt.ast.*; + +/** Token Manager. */ +public class SSPTParserTokenManager implements SSPTParserConstants +{ + + /** Debug output. */ + public java.io.PrintStream debugStream = System.out; + /** Set debug output. */ + public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; } +private final int jjStopStringLiteralDfa_0(int pos, long active0) +{ + switch (pos) + { + case 0: + if ((active0 & 0x20L) != 0L) + { + jjmatchedKind = 9; + return 5; + } + return -1; + case 1: + if ((active0 & 0x20L) != 0L) + { + jjmatchedKind = 9; + jjmatchedPos = 1; + return 5; + } + return -1; + default : + return -1; + } +} +private final int jjStartNfa_0(int pos, long active0) +{ + return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1); +} +private int jjStopAtPos(int pos, int kind) +{ + jjmatchedKind = kind; + jjmatchedPos = pos; + return pos + 1; +} +private int jjMoveStringLiteralDfa0_0() +{ + switch(curChar) + { + case 32: + return jjStopAtPos(0, 4); + case 40: + return jjStopAtPos(0, 1); + case 41: + return jjStopAtPos(0, 3); + case 44: + return jjStopAtPos(0, 2); + case 79: + return jjMoveStringLiteralDfa1_0(0x20L); + default : + return jjMoveNfa_0(3, 0); + } +} +private int jjMoveStringLiteralDfa1_0(long active0) +{ + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(0, active0); + return 1; + } + switch(curChar) + { + case 85: + return jjMoveStringLiteralDfa2_0(active0, 0x20L); + default : + break; + } + return jjStartNfa_0(0, active0); +} +private int jjMoveStringLiteralDfa2_0(long old0, long active0) +{ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(0, old0); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(1, active0); + return 2; + } + switch(curChar) + { + case 84: + if ((active0 & 0x20L) != 0L) + return jjStartNfaWithStates_0(2, 5, 5); + break; + default : + break; + } + return jjStartNfa_0(1, active0); +} +private int jjStartNfaWithStates_0(int pos, int kind, int state) +{ + jjmatchedKind = kind; + jjmatchedPos = pos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return pos + 1; } + return jjMoveNfa_0(state, pos + 1); +} +private int jjMoveNfa_0(int startState, int curPos) +{ + int startsAt = 0; + jjnewStateCnt = 6; + int i = 1; + jjstateSet[0] = startState; + int kind = 0x7fffffff; + for (;;) + { + if (++jjround == 0x7fffffff) + ReInitRounds(); + if (curChar < 64) + { + long l = 1L << curChar; + do + { + switch(jjstateSet[--i]) + { + case 3: + if (curChar == 36) + jjstateSet[jjnewStateCnt++] = 0; + break; + case 1: + if ((0x3ff408100000000L & l) != 0L) + jjAddStates(0, 1); + break; + case 5: + if ((0x3ff400000000000L & l) == 0L) + break; + if (kind > 9) + kind = 9; + jjstateSet[jjnewStateCnt++] = 5; + break; + default : break; + } + } while(i != startsAt); + } + else if (curChar < 128) + { + long l = 1L << (curChar & 077); + do + { + switch(jjstateSet[--i]) + { + case 3: + case 5: + if ((0x7fffffe07fffffeL & l) == 0L) + break; + if (kind > 9) + kind = 9; + jjCheckNAdd(5); + break; + case 0: + if (curChar == 123) + jjCheckNAddTwoStates(1, 2); + break; + case 1: + if ((0x7fffffe07fffffeL & l) != 0L) + jjCheckNAddTwoStates(1, 2); + break; + case 2: + if (curChar == 125) + kind = 8; + break; + default : break; + } + } while(i != startsAt); + } + else + { + int i2 = (curChar & 0xff) >> 6; + long l2 = 1L << (curChar & 077); + do + { + switch(jjstateSet[--i]) + { + default : break; + } + } while(i != startsAt); + } + if (kind != 0x7fffffff) + { + jjmatchedKind = kind; + jjmatchedPos = curPos; + kind = 0x7fffffff; + } + ++curPos; + if ((i = jjnewStateCnt) == (startsAt = 6 - (jjnewStateCnt = startsAt))) + return curPos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return curPos; } + } +} +static final int[] jjnextStates = { + 1, 2, +}; + +/** Token literal values. */ +public static final String[] jjstrLiteralImages = { +"", "\50", "\54", "\51", "\40", "\117\125\124", null, null, null, null, }; + +/** Lexer state names. */ +public static final String[] lexStateNames = { + "DEFAULT", +}; +protected SimpleCharStream input_stream; +private final int[] jjrounds = new int[6]; +private final int[] jjstateSet = new int[12]; +protected char curChar; +/** Constructor. */ +public SSPTParserTokenManager(SimpleCharStream stream){ + if (SimpleCharStream.staticFlag) + throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); + input_stream = stream; +} + +/** Constructor. */ +public SSPTParserTokenManager(SimpleCharStream stream, int lexState){ + this(stream); + SwitchTo(lexState); +} + +/** Reinitialise parser. */ +public void ReInit(SimpleCharStream stream) +{ + jjmatchedPos = jjnewStateCnt = 0; + curLexState = defaultLexState; + input_stream = stream; + ReInitRounds(); +} +private void ReInitRounds() +{ + int i; + jjround = 0x80000001; + for (i = 6; i-- > 0;) + jjrounds[i] = 0x80000000; +} + +/** Reinitialise parser. */ +public void ReInit(SimpleCharStream stream, int lexState) +{ + ReInit(stream); + SwitchTo(lexState); +} + +/** Switch to specified lex state. */ +public void SwitchTo(int lexState) +{ + if (lexState >= 1 || lexState < 0) + throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); + else + curLexState = lexState; +} + +protected Token jjFillToken() +{ + final Token t; + final String curTokenImage; + final int beginLine; + final int endLine; + final int beginColumn; + final int endColumn; + String im = jjstrLiteralImages[jjmatchedKind]; + curTokenImage = (im == null) ? input_stream.GetImage() : im; + beginLine = input_stream.getBeginLine(); + beginColumn = input_stream.getBeginColumn(); + endLine = input_stream.getEndLine(); + endColumn = input_stream.getEndColumn(); + t = Token.newToken(jjmatchedKind, curTokenImage); + + t.beginLine = beginLine; + t.endLine = endLine; + t.beginColumn = beginColumn; + t.endColumn = endColumn; + + return t; +} + +int curLexState = 0; +int defaultLexState = 0; +int jjnewStateCnt; +int jjround; +int jjmatchedPos; +int jjmatchedKind; + +/** Get the next Token. */ +public Token getNextToken() +{ + Token matchedToken; + int curPos = 0; + + EOFLoop : + for (;;) + { + try + { + curChar = input_stream.BeginToken(); + } + catch(java.io.IOException e) + { + jjmatchedKind = 0; + matchedToken = jjFillToken(); + return matchedToken; + } + + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_0(); + if (jjmatchedKind != 0x7fffffff) + { + if (jjmatchedPos + 1 < curPos) + input_stream.backup(curPos - jjmatchedPos - 1); + matchedToken = jjFillToken(); + return matchedToken; + } + int error_line = input_stream.getEndLine(); + int error_column = input_stream.getEndColumn(); + String error_after = null; + boolean EOFSeen = false; + try { input_stream.readChar(); input_stream.backup(1); } + catch (java.io.IOException e1) { + EOFSeen = true; + error_after = curPos <= 1 ? "" : input_stream.GetImage(); + if (curChar == '\n' || curChar == '\r') { + error_line++; + error_column = 0; + } + else + error_column++; + } + if (!EOFSeen) { + input_stream.backup(1); + error_after = curPos <= 1 ? "" : input_stream.GetImage(); + } + throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR); + } +} + +private void jjCheckNAdd(int state) +{ + if (jjrounds[state] != jjround) + { + jjstateSet[jjnewStateCnt++] = state; + jjrounds[state] = jjround; + } +} +private void jjAddStates(int start, int end) +{ + do { + jjstateSet[jjnewStateCnt++] = jjnextStates[start]; + } while (start++ != end); +} +private void jjCheckNAddTwoStates(int state1, int state2) +{ + jjCheckNAdd(state1); + jjCheckNAdd(state2); +} + +} http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/SimpleCharStream.java ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/SimpleCharStream.java b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/SimpleCharStream.java new file mode 100644 index 0000000..58a03ae --- /dev/null +++ b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/SimpleCharStream.java @@ -0,0 +1,471 @@ +/* Generated By:JavaCC: Do not edit this line. SimpleCharStream.java Version 5.0 */ +/* JavaCCOptions:STATIC=false,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */ +package org.apache.camel.component.sql.sspt.parser; + +/** + * An implementation of interface CharStream, where the stream is assumed to + * contain only ASCII characters (without unicode processing). + */ + +public class SimpleCharStream +{ +/** Whether parser is static. */ + public static final boolean staticFlag = false; + int bufsize; + int available; + int tokenBegin; +/** Position in buffer. */ + public int bufpos = -1; + protected int bufline[]; + protected int bufcolumn[]; + + protected int column = 0; + protected int line = 1; + + protected boolean prevCharIsCR = false; + protected boolean prevCharIsLF = false; + + protected java.io.Reader inputStream; + + protected char[] buffer; + protected int maxNextCharInd = 0; + protected int inBuf = 0; + protected int tabSize = 8; + + protected void setTabSize(int i) { tabSize = i; } + protected int getTabSize(int i) { return tabSize; } + + + protected void ExpandBuff(boolean wrapAround) + { + char[] newbuffer = new char[bufsize + 2048]; + int newbufline[] = new int[bufsize + 2048]; + int newbufcolumn[] = new int[bufsize + 2048]; + + try + { + if (wrapAround) + { + System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin); + System.arraycopy(buffer, 0, newbuffer, bufsize - tokenBegin, bufpos); + buffer = newbuffer; + + System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin); + System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos); + bufline = newbufline; + + System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin); + System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos); + bufcolumn = newbufcolumn; + + maxNextCharInd = (bufpos += (bufsize - tokenBegin)); + } + else + { + System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin); + buffer = newbuffer; + + System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin); + bufline = newbufline; + + System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin); + bufcolumn = newbufcolumn; + + maxNextCharInd = (bufpos -= tokenBegin); + } + } + catch (Throwable t) + { + throw new Error(t.getMessage()); + } + + + bufsize += 2048; + available = bufsize; + tokenBegin = 0; + } + + protected void FillBuff() throws java.io.IOException + { + if (maxNextCharInd == available) + { + if (available == bufsize) + { + if (tokenBegin > 2048) + { + bufpos = maxNextCharInd = 0; + available = tokenBegin; + } + else if (tokenBegin < 0) + bufpos = maxNextCharInd = 0; + else + ExpandBuff(false); + } + else if (available > tokenBegin) + available = bufsize; + else if ((tokenBegin - available) < 2048) + ExpandBuff(true); + else + available = tokenBegin; + } + + int i; + try { + if ((i = inputStream.read(buffer, maxNextCharInd, available - maxNextCharInd)) == -1) + { + inputStream.close(); + throw new java.io.IOException(); + } + else + maxNextCharInd += i; + return; + } + catch(java.io.IOException e) { + --bufpos; + backup(0); + if (tokenBegin == -1) + tokenBegin = bufpos; + throw e; + } + } + +/** Start. */ + public char BeginToken() throws java.io.IOException + { + tokenBegin = -1; + char c = readChar(); + tokenBegin = bufpos; + + return c; + } + + protected void UpdateLineColumn(char c) + { + column++; + + if (prevCharIsLF) + { + prevCharIsLF = false; + line += (column = 1); + } + else if (prevCharIsCR) + { + prevCharIsCR = false; + if (c == '\n') + { + prevCharIsLF = true; + } + else + line += (column = 1); + } + + switch (c) + { + case '\r' : + prevCharIsCR = true; + break; + case '\n' : + prevCharIsLF = true; + break; + case '\t' : + column--; + column += (tabSize - (column % tabSize)); + break; + default : + break; + } + + bufline[bufpos] = line; + bufcolumn[bufpos] = column; + } + +/** Read a character. */ + public char readChar() throws java.io.IOException + { + if (inBuf > 0) + { + --inBuf; + + if (++bufpos == bufsize) + bufpos = 0; + + return buffer[bufpos]; + } + + if (++bufpos >= maxNextCharInd) + FillBuff(); + + char c = buffer[bufpos]; + + UpdateLineColumn(c); + return c; + } + + @Deprecated + /** + * @deprecated + * @see #getEndColumn + */ + + public int getColumn() { + return bufcolumn[bufpos]; + } + + @Deprecated + /** + * @deprecated + * @see #getEndLine + */ + + public int getLine() { + return bufline[bufpos]; + } + + /** Get token end column number. */ + public int getEndColumn() { + return bufcolumn[bufpos]; + } + + /** Get token end line number. */ + public int getEndLine() { + return bufline[bufpos]; + } + + /** Get token beginning column number. */ + public int getBeginColumn() { + return bufcolumn[tokenBegin]; + } + + /** Get token beginning line number. */ + public int getBeginLine() { + return bufline[tokenBegin]; + } + +/** Backup a number of characters. */ + public void backup(int amount) { + + inBuf += amount; + if ((bufpos -= amount) < 0) + bufpos += bufsize; + } + + /** Constructor. */ + public SimpleCharStream(java.io.Reader dstream, int startline, + int startcolumn, int buffersize) + { + inputStream = dstream; + line = startline; + column = startcolumn - 1; + + available = bufsize = buffersize; + buffer = new char[buffersize]; + bufline = new int[buffersize]; + bufcolumn = new int[buffersize]; + } + + /** Constructor. */ + public SimpleCharStream(java.io.Reader dstream, int startline, + int startcolumn) + { + this(dstream, startline, startcolumn, 4096); + } + + /** Constructor. */ + public SimpleCharStream(java.io.Reader dstream) + { + this(dstream, 1, 1, 4096); + } + + /** Reinitialise. */ + public void ReInit(java.io.Reader dstream, int startline, + int startcolumn, int buffersize) + { + inputStream = dstream; + line = startline; + column = startcolumn - 1; + + if (buffer == null || buffersize != buffer.length) + { + available = bufsize = buffersize; + buffer = new char[buffersize]; + bufline = new int[buffersize]; + bufcolumn = new int[buffersize]; + } + prevCharIsLF = prevCharIsCR = false; + tokenBegin = inBuf = maxNextCharInd = 0; + bufpos = -1; + } + + /** Reinitialise. */ + public void ReInit(java.io.Reader dstream, int startline, + int startcolumn) + { + ReInit(dstream, startline, startcolumn, 4096); + } + + /** Reinitialise. */ + public void ReInit(java.io.Reader dstream) + { + ReInit(dstream, 1, 1, 4096); + } + /** Constructor. */ + public SimpleCharStream(java.io.InputStream dstream, String encoding, int startline, + int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException + { + this(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize); + } + + /** Constructor. */ + public SimpleCharStream(java.io.InputStream dstream, int startline, + int startcolumn, int buffersize) + { + this(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize); + } + + /** Constructor. */ + public SimpleCharStream(java.io.InputStream dstream, String encoding, int startline, + int startcolumn) throws java.io.UnsupportedEncodingException + { + this(dstream, encoding, startline, startcolumn, 4096); + } + + /** Constructor. */ + public SimpleCharStream(java.io.InputStream dstream, int startline, + int startcolumn) + { + this(dstream, startline, startcolumn, 4096); + } + + /** Constructor. */ + public SimpleCharStream(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException + { + this(dstream, encoding, 1, 1, 4096); + } + + /** Constructor. */ + public SimpleCharStream(java.io.InputStream dstream) + { + this(dstream, 1, 1, 4096); + } + + /** Reinitialise. */ + public void ReInit(java.io.InputStream dstream, String encoding, int startline, + int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException + { + ReInit(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize); + } + + /** Reinitialise. */ + public void ReInit(java.io.InputStream dstream, int startline, + int startcolumn, int buffersize) + { + ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize); + } + + /** Reinitialise. */ + public void ReInit(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException + { + ReInit(dstream, encoding, 1, 1, 4096); + } + + /** Reinitialise. */ + public void ReInit(java.io.InputStream dstream) + { + ReInit(dstream, 1, 1, 4096); + } + /** Reinitialise. */ + public void ReInit(java.io.InputStream dstream, String encoding, int startline, + int startcolumn) throws java.io.UnsupportedEncodingException + { + ReInit(dstream, encoding, startline, startcolumn, 4096); + } + /** Reinitialise. */ + public void ReInit(java.io.InputStream dstream, int startline, + int startcolumn) + { + ReInit(dstream, startline, startcolumn, 4096); + } + /** Get token literal value. */ + public String GetImage() + { + if (bufpos >= tokenBegin) + return new String(buffer, tokenBegin, bufpos - tokenBegin + 1); + else + return new String(buffer, tokenBegin, bufsize - tokenBegin) + + new String(buffer, 0, bufpos + 1); + } + + /** Get the suffix. */ + public char[] GetSuffix(int len) + { + char[] ret = new char[len]; + + if ((bufpos + 1) >= len) + System.arraycopy(buffer, bufpos - len + 1, ret, 0, len); + else + { + System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0, + len - bufpos - 1); + System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1); + } + + return ret; + } + + /** Reset buffer when finished. */ + public void Done() + { + buffer = null; + bufline = null; + bufcolumn = null; + } + + /** + * Method to adjust line and column numbers for the start of a token. + */ + public void adjustBeginLineColumn(int newLine, int newCol) + { + int start = tokenBegin; + int len; + + if (bufpos >= tokenBegin) + { + len = bufpos - tokenBegin + inBuf + 1; + } + else + { + len = bufsize - tokenBegin + bufpos + 1 + inBuf; + } + + int i = 0, j = 0, k = 0; + int nextColDiff = 0, columnDiff = 0; + + while (i < len && bufline[j = start % bufsize] == bufline[k = ++start % bufsize]) + { + bufline[j] = newLine; + nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j]; + bufcolumn[j] = newCol + columnDiff; + columnDiff = nextColDiff; + i++; + } + + if (i < len) + { + bufline[j] = newLine++; + bufcolumn[j] = newCol + columnDiff; + + while (i++ < len) + { + if (bufline[j = start % bufsize] != bufline[++start % bufsize]) + bufline[j] = newLine++; + else + bufline[j] = newLine; + } + } + + line = bufline[j]; + column = bufcolumn[j]; + } + +} +/* JavaCC - OriginalChecksum=740c413ce2f513b4d926ea988f37e3da (do not edit this line) */ http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/Token.java ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/Token.java b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/Token.java new file mode 100644 index 0000000..a7ed978 --- /dev/null +++ b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/Token.java @@ -0,0 +1,131 @@ +/* Generated By:JavaCC: Do not edit this line. Token.java Version 5.0 */ +/* JavaCCOptions:TOKEN_EXTENDS=,KEEP_LINE_COL=null,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */ +package org.apache.camel.component.sql.sspt.parser; + +/** + * Describes the input token stream. + */ + +public class Token implements java.io.Serializable { + + /** + * The version identifier for this Serializable class. + * Increment only if the <i>serialized</i> form of the + * class changes. + */ + private static final long serialVersionUID = 1L; + + /** + * An integer that describes the kind of this token. This numbering + * system is determined by JavaCCParser, and a table of these numbers is + * stored in the file ...Constants.java. + */ + public int kind; + + /** The line number of the first character of this Token. */ + public int beginLine; + /** The column number of the first character of this Token. */ + public int beginColumn; + /** The line number of the last character of this Token. */ + public int endLine; + /** The column number of the last character of this Token. */ + public int endColumn; + + /** + * The string image of the token. + */ + public String image; + + /** + * A reference to the next regular (non-special) token from the input + * stream. If this is the last token from the input stream, or if the + * token manager has not read tokens beyond this one, this field is + * set to null. This is true only if this token is also a regular + * token. Otherwise, see below for a description of the contents of + * this field. + */ + public Token next; + + /** + * This field is used to access special tokens that occur prior to this + * token, but after the immediately preceding regular (non-special) token. + * If there are no such special tokens, this field is set to null. + * When there are more than one such special token, this field refers + * to the last of these special tokens, which in turn refers to the next + * previous special token through its specialToken field, and so on + * until the first special token (whose specialToken field is null). + * The next fields of special tokens refer to other special tokens that + * immediately follow it (without an intervening regular token). If there + * is no such token, this field is null. + */ + public Token specialToken; + + /** + * An optional attribute value of the Token. + * Tokens which are not used as syntactic sugar will often contain + * meaningful values that will be used later on by the compiler or + * interpreter. This attribute value is often different from the image. + * Any subclass of Token that actually wants to return a non-null value can + * override this method as appropriate. + */ + public Object getValue() { + return null; + } + + /** + * No-argument constructor + */ + public Token() {} + + /** + * Constructs a new token for the specified Image. + */ + public Token(int kind) + { + this(kind, null); + } + + /** + * Constructs a new token for the specified Image and Kind. + */ + public Token(int kind, String image) + { + this.kind = kind; + this.image = image; + } + + /** + * Returns the image. + */ + public String toString() + { + return image; + } + + /** + * Returns a new Token object, by default. However, if you want, you + * can create and return subclass objects based on the value of ofKind. + * Simply add the cases to the switch for all those special cases. + * For example, if you have a subclass of Token called IDToken that + * you want to create if ofKind is ID, simply add something like : + * + * case MyParserConstants.ID : return new IDToken(ofKind, image); + * + * to the following switch statement. Then you can cast matchedToken + * variable to the appropriate type and use sit in your lexical actions. + */ + public static Token newToken(int ofKind, String image) + { + switch(ofKind) + { + default : return new Token(ofKind, image); + } + } + + public static Token newToken(int ofKind) + { + return newToken(ofKind, null); + } + +} +/* JavaCC - OriginalChecksum=49813021262cb0b6d876cbaf57667539 (do not edit this line) */ http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/TokenMgrError.java ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/TokenMgrError.java b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/TokenMgrError.java new file mode 100644 index 0000000..b58d63b --- /dev/null +++ b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/TokenMgrError.java @@ -0,0 +1,147 @@ +/* Generated By:JavaCC: Do not edit this line. TokenMgrError.java Version 5.0 */ +/* JavaCCOptions: */ +package org.apache.camel.component.sql.sspt.parser; + +/** Token Manager Error. */ +public class TokenMgrError extends Error +{ + + /** + * The version identifier for this Serializable class. + * Increment only if the <i>serialized</i> form of the + * class changes. + */ + private static final long serialVersionUID = 1L; + + /* + * Ordinals for various reasons why an Error of this type can be thrown. + */ + + /** + * Lexical error occurred. + */ + static final int LEXICAL_ERROR = 0; + + /** + * An attempt was made to create a second instance of a static token manager. + */ + static final int STATIC_LEXER_ERROR = 1; + + /** + * Tried to change to an invalid lexical state. + */ + static final int INVALID_LEXICAL_STATE = 2; + + /** + * Detected (and bailed out of) an infinite loop in the token manager. + */ + static final int LOOP_DETECTED = 3; + + /** + * Indicates the reason why the exception is thrown. It will have + * one of the above 4 values. + */ + int errorCode; + + /** + * Replaces unprintable characters by their escaped (or unicode escaped) + * equivalents in the given string + */ + protected static final String addEscapes(String str) { + StringBuffer retval = new StringBuffer(); + char ch; + for (int i = 0; i < str.length(); i++) { + switch (str.charAt(i)) + { + case 0 : + continue; + case '\b': + retval.append("\\b"); + continue; + case '\t': + retval.append("\\t"); + continue; + case '\n': + retval.append("\\n"); + continue; + case '\f': + retval.append("\\f"); + continue; + case '\r': + retval.append("\\r"); + continue; + case '\"': + retval.append("\\\""); + continue; + case '\'': + retval.append("\\\'"); + continue; + case '\\': + retval.append("\\\\"); + continue; + default: + if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) { + String s = "0000" + Integer.toString(ch, 16); + retval.append("\\u" + s.substring(s.length() - 4, s.length())); + } else { + retval.append(ch); + } + continue; + } + } + return retval.toString(); + } + + /** + * Returns a detailed message for the Error when it is thrown by the + * token manager to indicate a lexical error. + * Parameters : + * EOFSeen : indicates if EOF caused the lexical error + * curLexState : lexical state in which this error occurred + * errorLine : line number when the error occurred + * errorColumn : column number when the error occurred + * errorAfter : prefix that was seen before this error occurred + * curchar : the offending character + * Note: You can customize the lexical error message by modifying this method. + */ + protected static String LexicalError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar) { + return("Lexical error at line " + + errorLine + ", column " + + errorColumn + ". Encountered: " + + (EOFSeen ? "<EOF> " : ("\"" + addEscapes(String.valueOf(curChar)) + "\"") + " (" + (int)curChar + "), ") + + "after : \"" + addEscapes(errorAfter) + "\""); + } + + /** + * You can also modify the body of this method to customize your error messages. + * For example, cases like LOOP_DETECTED and INVALID_LEXICAL_STATE are not + * of end-users concern, so you can return something like : + * + * "Internal Error : Please file a bug report .... " + * + * from this method for such cases in the release version of your parser. + */ + public String getMessage() { + return super.getMessage(); + } + + /* + * Constructors of various flavors follow. + */ + + /** No arg constructor. */ + public TokenMgrError() { + } + + /** Constructor with message and reason. */ + public TokenMgrError(String message, int reason) { + super(message); + errorCode = reason; + } + + /** Full Constructor. */ + public TokenMgrError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar, int reason) { + this(LexicalError(EOFSeen, lexState, errorLine, errorColumn, errorAfter, curChar), reason); + } +} +/* JavaCC - OriginalChecksum=40bf525b6801e308b2ddf5874ae68024 (do not edit this line) */ http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/generate_sptp_classes.sh ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/generate_sptp_classes.sh b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/generate_sptp_classes.sh new file mode 100755 index 0000000..e80e9a5 --- /dev/null +++ b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/generate_sptp_classes.sh @@ -0,0 +1,4 @@ +#!/usr/bin/env bash +rm -f *.java +javacc sspt.jj +rm -f ParseException.java http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/sspt.jj ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/sspt.jj b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/sspt.jj new file mode 100644 index 0000000..db2f33c --- /dev/null +++ b/components/camel-sql/src/main/java/org/apache/camel/component/sql/sspt/parser/sspt.jj @@ -0,0 +1,136 @@ +//Using some token definions from: http://kiwwito.com/build-a-lexical-analyzer-with-javacc/ + +options { + STATIC = false; +} + + +PARSER_BEGIN(SSPTParser) + +package org.apache.camel.component.sql.sspt.parser; + +import org.apache.camel.component.sql.sspt.ast.*; + +public class SSPTParser { + int paramaterNameCounter = 0; + + String createNextParameterName() { + return "_"+(paramaterNameCounter++); + } +} + +PARSER_END(SSPTParser) + +public Template parse() : +{ Token procudureName; + Template template = new Template(); + Object parameter = null; +} +{ + (procudureName = <IDENTIFIER> "(" (parameter = Parameter() { template.addParameter(parameter);}) ("," + parameter + = Parameter(){template.addParameter(parameter);})* ")" <EOF>) + { + template.setProcedureName(procudureName.toString()); + return template; + } +} + +Object Parameter() : +{ + Object param; +} +{ + (param = InputParameter() {return param;}) | (param = OutParameter(){return param;}) +} + +InputParameter InputParameter() : +{ + String sqlTypeAsStr; + String name; + String valueSrcAsStr; +} +{ + (sqlTypeAsStr = ParameterSqlType() " " valueSrcAsStr = + InputParameterSrc()) + { + int sqlType = ParseHelper.parseSqlType(sqlTypeAsStr); + return new InputParameter(createNextParameterName(),sqlType,valueSrcAsStr,ParseHelper.sqlTypeToJavaType(sqlType,sqlTypeAsStr)); + } +} + +OutParameter OutParameter() : +{ + String sqlType; + String name; + String outHeader; +} +{ + ("OUT" " " sqlType = ParameterSqlType() " " outHeader = + OutHeader()) + { + return new OutParameter(createNextParameterName(),ParseHelper.parseSqlType(sqlType),outHeader); + } +} + +String ParameterSqlType(): +{ + Token t; +} +{ + (t = <IDENTIFIER>) + { + return t.toString(); + } +} + +String OutHeader(): +{ + Token token; +} +{ + (token = <IDENTIFIER>) + { + return token.toString(); + } +} + +String InputParameterSrc(): +{ + String ret; +} +{ + (ret = SimpleExpression()) + { + return ret; + } +} + +String SimpleExpression() : +{ + Token t = null; +} +{ + (t = <SIMPLE_EXP_TOKEN>) + { + return t.toString(); + } +} + +TOKEN: { + <#DIGIT: (["0"-"9"])> +} + +TOKEN: { + <#LETTER: (["a"-"z","A"-"Z"])> +} + +TOKEN : { + <SIMPLE_EXP_TOKEN: "${"(<LETTER>|<DIGIT> | " " | "'" | "." )* "}"> +} + + +TOKEN : { + <IDENTIFIER: <LETTER>( <LETTER> | <DIGIT> | ".") *> +} + http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/test/java/org/apache/camel/component/sql/sspt/ParserTest.java ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/test/java/org/apache/camel/component/sql/sspt/ParserTest.java b/components/camel-sql/src/test/java/org/apache/camel/component/sql/sspt/ParserTest.java new file mode 100644 index 0000000..ba36baf --- /dev/null +++ b/components/camel-sql/src/test/java/org/apache/camel/component/sql/sspt/ParserTest.java @@ -0,0 +1,81 @@ +package org.apache.camel.component.sql.sspt; + + +import org.apache.camel.Exchange; +import org.apache.camel.component.sql.sspt.ast.InputParameter; +import org.apache.camel.component.sql.sspt.ast.OutParameter; +import org.apache.camel.component.sql.sspt.ast.ParseException; +import org.apache.camel.component.sql.sspt.ast.Template; +import org.apache.camel.test.junit4.CamelTestSupport; +import org.junit.Assert; +import org.junit.Test; + +import java.math.BigInteger; +import java.sql.Types; + +public class ParserTest extends CamelTestSupport { + + SimpleStoredProcedureFactory parser = new SimpleStoredProcedureFactory(); + + + @Test + public void shouldParseOk() { + + + Template template = parser.parseTemplate("addnumbers(INTEGER ${header.header1}," + + "VARCHAR ${property.property1},BIGINT ${header.header2},OUT INTEGER header1)"); + + Assert.assertEquals("addnumbers", template.getProcedureName()); + Assert.assertEquals(3, template.getInputParameterList().size()); + + Exchange exchange = createExchangeWithBody(null); + exchange.getIn().setHeader("header1", 1); + exchange.setProperty("property1", "constant string"); + exchange.getIn().setHeader("header2", BigInteger.valueOf(2)); + + InputParameter param1 = template.getInputParameterList().get(0); + Assert.assertEquals("_0", param1.getName()); + Assert.assertEquals(Types.INTEGER, param1.getSqlType()); + Assert.assertEquals(Integer.valueOf(1), param1.getValueExpression().evaluate(exchange, Integer.class)); + + InputParameter param2 = template.getInputParameterList().get(1); + Assert.assertEquals("_1", param2.getName()); + Assert.assertEquals(Types.VARCHAR, param2.getSqlType()); + Assert.assertEquals("constant string", param2.getValueExpression().evaluate(exchange, String.class)); + + InputParameter param3 = template.getInputParameterList().get(2); + Assert.assertEquals("_2", param3.getName()); + Assert.assertEquals(Types.BIGINT, param3.getSqlType()); + Assert.assertEquals(BigInteger.valueOf(2), param3.getValueExpression().evaluate(exchange, BigInteger.class)); + + OutParameter sptpOutputNode = template.getOutParameterList().get(0); + Assert.assertEquals("_3", sptpOutputNode.getName()); + Assert.assertEquals(Types.INTEGER, sptpOutputNode.getSqlType()); + Assert.assertEquals("header1", sptpOutputNode.getOutHeader()); + + } + + + @Test(expected = ParseException.class) + public void noOutputParameterShouldFail() { + parser.parseTemplate("ADDNUMBERS2" + + "(INTEGER VALUE1 ${header.v1},INTEGER VALUE2 ${header.v2})"); + + } + + @Test(expected = ParseException.class) + public void unexistingTypeShouldFail() { + parser.parseTemplate("ADDNUMBERS2" + + "(XML VALUE1 ${header.v1},OUT INTEGER VALUE2 ${header.v2})"); + + } + + + @Test(expected = ParseException.class) + public void unmappedTypeShouldFaild() { + parser.parseTemplate("ADDNUMBERS2" + + "(OTHER VALUE1 ${header.v1},INTEGER VALUE2 ${header.v2})"); + + } + +} http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/test/java/org/apache/camel/component/sql/sspt/ProducerTest.java ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/test/java/org/apache/camel/component/sql/sspt/ProducerTest.java b/components/camel-sql/src/test/java/org/apache/camel/component/sql/sspt/ProducerTest.java new file mode 100644 index 0000000..d00108c --- /dev/null +++ b/components/camel-sql/src/test/java/org/apache/camel/component/sql/sspt/ProducerTest.java @@ -0,0 +1,72 @@ +package org.apache.camel.component.sql.sspt; + +import org.apache.camel.Exchange; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.component.mock.MockEndpoint; +import org.apache.camel.component.sql.SqlComponent; +import org.apache.camel.test.junit4.CamelTestSupport; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.springframework.jdbc.datasource.embedded.EmbeddedDatabase; +import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder; +import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType; + +import java.util.HashMap; +import java.util.Map; + +/** + * Created by snurmine on 12/30/15. + */ +public class ProducerTest extends CamelTestSupport { + + + private EmbeddedDatabase db; + + @Before + public void setUp() throws Exception { + db = new EmbeddedDatabaseBuilder() + .setType(EmbeddedDatabaseType.DERBY).addScript("sql/storedProcedureTest.sql").build(); + + super.setUp(); + } + + @After + public void tearDown() throws Exception { + super.tearDown(); + + db.shutdown(); + } + + @Test + public void shouldExecuteStoredProcedure() throws InterruptedException { + MockEndpoint mock = getMockEndpoint("mock:query"); + mock.expectedMessageCount(1); + + + Map<String, Object> headers = new HashMap<>(); + headers.put("num1", 1); + headers.put("num2", 2); + template.requestBodyAndHeaders("direct:query", null, headers); + + assertMockEndpointsSatisfied(); + + Exchange exchange = mock.getExchanges().get(0); + + assertEquals(Integer.valueOf(3), exchange.getIn().getHeader("resultofsum")); + } + + @Override + protected RouteBuilder createRouteBuilder() throws Exception { + return new RouteBuilder() { + @Override + public void configure() throws Exception { + // required for the sql component + getContext().getComponent("sql", SqlComponent.class).setDataSource(db); + + from("direct:query").to("sql:sspt:ADDNUMBERS(INTEGER ${headers.num1},INTEGER ${headers" + + ".num2},OUT INTEGER resultofsum)").to("mock:query"); + } + }; + } +} http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/test/java/org/apache/camel/component/sql/sspt/SimpleStoredProcedureTest.java ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/test/java/org/apache/camel/component/sql/sspt/SimpleStoredProcedureTest.java b/components/camel-sql/src/test/java/org/apache/camel/component/sql/sspt/SimpleStoredProcedureTest.java new file mode 100644 index 0000000..5fc4fef --- /dev/null +++ b/components/camel-sql/src/test/java/org/apache/camel/component/sql/sspt/SimpleStoredProcedureTest.java @@ -0,0 +1,57 @@ +package org.apache.camel.component.sql.sspt; + + +import org.apache.camel.Exchange; +import org.apache.camel.component.sql.sspt.ast.ParseException; +import org.apache.camel.test.junit4.CamelTestSupport; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.jdbc.datasource.embedded.EmbeddedDatabase; +import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder; +import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType; + +public class SimpleStoredProcedureTest extends CamelTestSupport { + + SimpleStoredProcedureFactory parser = new SimpleStoredProcedureFactory(); + + private EmbeddedDatabase db; + private JdbcTemplate jdbcTemplate; + + @Before + public void setUp() throws Exception { + db = new EmbeddedDatabaseBuilder() + .setType(EmbeddedDatabaseType.DERBY).addScript("sql/storedProcedureTest.sql").build(); + + jdbcTemplate = new JdbcTemplate(db); + + super.setUp(); + } + + + @Test + public void shouldExecuteStoredProcedure() throws ParseException { + SimpleStoredProcedure sp = new SimpleStoredProcedure(db, parser.parseTemplate("ADDNUMBERS" + + "(INTEGER ${header.v1},INTEGER ${header.v2},OUT INTEGER resultofsum)")); + + Exchange exchange = createExchangeWithBody(null); + exchange.getIn().setHeader("v1", 1); + exchange.getIn().setHeader("v2", 2); + + + sp.execute(exchange); + + Assert.assertEquals(Integer.valueOf(3), exchange.getOut().getHeader("resultofsum")); + + + } + + @After + public void tearDown() throws Exception { + super.tearDown(); + + db.shutdown(); + } +} http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/test/java/org/apache/camel/component/sql/sspt/SimpleStoredProcedureUdf.java ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/test/java/org/apache/camel/component/sql/sspt/SimpleStoredProcedureUdf.java b/components/camel-sql/src/test/java/org/apache/camel/component/sql/sspt/SimpleStoredProcedureUdf.java new file mode 100644 index 0000000..f88ebd4 --- /dev/null +++ b/components/camel-sql/src/test/java/org/apache/camel/component/sql/sspt/SimpleStoredProcedureUdf.java @@ -0,0 +1,15 @@ +package org.apache.camel.component.sql.sspt; + +/** + * Created by snurmine on 12/20/15. + */ +public class SimpleStoredProcedureUdf { + + public static void addnumbers(int VALUE1, int VALUE2, int[] RESULT) { + System.out.println("calling addnumbers:" + VALUE1 + "," + VALUE2); + + RESULT[0] = VALUE1 + VALUE2; + + + } +} http://git-wip-us.apache.org/repos/asf/camel/blob/6dac645b/components/camel-sql/src/test/resources/sql/storedProcedureTest.sql ---------------------------------------------------------------------- diff --git a/components/camel-sql/src/test/resources/sql/storedProcedureTest.sql b/components/camel-sql/src/test/resources/sql/storedProcedureTest.sql new file mode 100644 index 0000000..edee883 --- /dev/null +++ b/components/camel-sql/src/test/resources/sql/storedProcedureTest.sql @@ -0,0 +1,22 @@ +-- ------------------------------------------------------------------------ +-- Licensed to the Apache Software Foundation (ASF) under one or more +-- contributor license agreements. See the NOTICE file distributed with +-- this work for additional information regarding copyright ownership. +-- The ASF licenses this file to You under the Apache License, Version 2.0 +-- (the "License"); you may not use this file except in compliance with +-- the License. You may obtain a copy of the License at +-- +-- http://www.apache.org/licenses/LICENSE-2.0 +-- +-- Unless required by applicable law or agreed to in writing, software +-- distributed under the License is distributed on an "AS IS" BASIS, +-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +-- See the License for the specific language governing permissions and +-- limitations under the License. +-- ------------------------------------------------------------------------ + +CREATE PROCEDURE ADDNUMBERS(VALUE1 INTEGER, VALUE2 INTEGER,OUT RESULT INTEGER) + PARAMETER STYLE JAVA + LANGUAGE JAVA + EXTERNAL NAME +'org.apache.camel.component.sql.sspt.SimpleStoredProcedureUdf.addnumbers'; \ No newline at end of file
