anchor.diff:  
   Actual call will be done using org.springframework.jdbc.core.SqlParameter.
   
  -#### OUT Parameters
  +==== OUT Parameters
   
   OUT parameters work similarly IN parameters and contain three parts: SQL type(with scale), type name and output parameter name.
   
  
positive.code: 
  SQL type is required and can be an integer (positive or negative) or reference to integer field in some class.
  If SQL type contains a dot then component tries resolve that class and read the given field. For example
  SQL type com.Foo.INTEGER is read from the field INTEGER of class com.Foo. If the type doesn't
  contain comma then class to resolve the integer value will be java.sql.Types.
  Type can be postfixed by scale for example DECIMAL(10) would mean java.sql.Types.DECIMAL with scale 10.
  
  Type name is optional and must be given between quotes(').
  
  Value source is required. Value source populates the parameter value from the Exchange.
  It can be either a Simple expression or header location i.e. :#<header name>. For example
  Simple expression ${header.val} would mean that parameter value will be read from the header "val".
  Header location expression :#val would have identical effect.
  
  [source,java]
  ----------------------------------------------------------------------------------------------------------
  <to uri="sql-stored:MYFUNC('param1' org.example.Types.INTEGER(10) ${header.srcValue})"/>
  ----------------------------------------------------------------------------------------------------------
  URI means that the stored procedure will be called with parameter name "param1",
  it's SQL type is read from field INTEGER of class org.example.Types and scale will be set to 10.
  Input value for the parameter is passed from the header "srcValue".
  
  [source,java]
  
negative.code: 
  Output parameter name is used for the OUT parameter name, as well as the header name where the result will be stored.
  
  [source,xml]
  ----
  <to uri="sql-stored:MYFUNC(OUT org.example.Types.DECIMAL(10) outheader1)"/>
  ----
  
  URI means that OUT parameter's name is "outheader1" and result will be but into header "outheader1".
  
  [source,xml]
  ----
  <to uri="sql-stored:MYFUNC(OUT org.example.Types.NUMERIC(10) 'mytype' outheader1)"/>
  ----
  
  This is identical to previous one but type name will be "mytype".
  
  Actual call will be done using `org.springframework.jdbc.core.SqlOutParameter`.
  
  ==== INOUT Parameters
  
  INOUT parameters are a combination of all of the above.  They receive a value from the exchange, as well as store a
  result as a message header.  The only caveat is that the IN parameter's "name" is skipped.  Instead, the OUT
  parameter's "name" defines both the SQL parameter name, as well as the result header name.
  
  [source,xml]
  ----
  <to uri="sql-stored:MYFUNC(INOUT DECIMAL(10) ${headers.inheader} outheader)"/>
  ----
  
  Actual call will be done using org.springframework.jdbc.core.SqlInOutParameter.
  
  === Camel SQL Starter
  
  A starter module is available to spring-boot users. When using the starter,
  the `DataSource` can be directly configured using spring-boot properties.
  
  [source,text]
  ----
  # Example for a mysql datasource
  spring.datasource.url=jdbc:mysql://localhost/test
  spring.datasource.username=dbuser
  spring.datasource.password=dbpass
  spring.datasource.driver-class-name=com.mysql.jdbc.Driver
  ----
  
  To use this feature, add the following dependencies to your spring boot pom.xml file:
  
  [source,xml]
  ----
  <dependency>
      <groupId>org.apache.camel</groupId>
      <artifactId>camel-sql-starter</artifactId>
  