Mule JDBC Component

1. Mule - JDBC
Kalaimathi

2. Chapters
Schedule
Filter Types
JDBC - Introduction
JDBC Endpoint: Inbound vs Outbound
JDBC Connector Attributes
Data sources Shortcuts
Results Data Structure
JDBC - CE vs EE
JDBC Transactions
MEL - JDBC

3. JDBC - Introduction
 The Java Database Connectivity (JDBC) transport connects to any relational database
that supports JDBC.
 A JDBC inbound endpoint maps to an SQL SELECT statement while a JDBC outbound
endpoint maps to an SQL SELECT, UPDATE, INSERT or DELETE statement.
 Similar to the File transport, consumption of records needs to be simulated.
 Schema definition
CE Version:
<xmlns:jdbc="http://www.mulesoft.org/schema/mule/jdbc"
xsi:schemaLocation="http://www.mulesoft.org/schema/mule/jdbc
http://www.mulesoft.org/schema/mule/jdbc/current/mule-jdbc.xsd">
EE Version:
<xmlns:jdbc="http://www.mulesoft.org/schema/mule/jdbc"
xsi:schemaLocation="http://www.mulesoft.org/schema/mule/jdbc
http://www.mulesoft.org/schema/mule/jdbc/current/mule-jdbc.xsd">

4. JDBC Endpoint: Inbound vs Outbound
 A SELECT on a JDBC inbound endpoint is polling. This means that Mule will
attempt to read records every so often from a given database table. In
addition, Mule will only retrieve un-read records. In other words, a JDBC
inbound endpoint will consume records.
 Inbound Endpoints can only be configured for SELECT queries
 A SELECT on a JDBC outbound endpoint is triggered by a Mule event. For
example, this Mule event could have been created as a result of an HTTP
request.
 A JDBC outbound endpoint does not care if a record has been read or not. It
will retrieve all records matching the SELECT’s WHERE clause.
 Outbound Endpoints can be configured for any allowed (as set by database)
query.

5. JDBC Connector Attributes
 JDBC transport requires configuration of the JDBC connector. In the connector,
we must point the dataSource-ref attribute to a Spring bean and the Spring
bean would configure a class which implements the javax.sql.DataSource
interface. Configuring a DataSource usually involves setting the URL, JDBC
driver, username and password bean properties.
 JDBC connector we can also add the queries that are to be executed by the
JDBC inbound and outbound endpoints.
 Each query is represented as a child element in the JDBC connector element.
Moreover, each query needs a key (which is a descriptive name for the query)
as well as the actual SQL query itself.
 There are three types of queries available:
 Read queries are SELECT SQL statements bound to an inbound or an
outbound endpoint.
 Write queries are INSERT or UPDATE SQL statements bound to an outbound
endpoint.

6. JDBC Connector Attributes (Contd)
 Acknowledgement queries are executed immediately after a read query. This
type of query is identified with the same name as the read query together
with an '.ack' suffix. An acknowledgement query is normally used to mark
the previously selected rows as having been processed or consumed. This
type of query is usually an UPDATE statement.
 Other properties that are set on the connector but are optional are:
 pollingFrequency: The frequency to poll the database for new records, in
milliseconds.
 queryRunner-ref: The name of the class to execute queries. The default class
is org.apache.commons.dbutils.QueryRunner.
 resultSetHandler-ref: The name of the class used to pass query results back.
The default class is org.apache.commons.dbutils.handlers.MapListHandler
converts the result set to an object.
Eg:
<jdbc:connector dataSource-ref="ordersDB" name="salesDB“ pollingFrequency="1000">

7. JDBC Connector Attributes (Contd)
<jdbc:query key="getTest“ value="SELECT ID, TYPE, DATA, ACK, RESULT FROM TEST WHERE
TYPE =#[map-payload:type] AND ACK IS NULL"/>
<jdbc:query key="getTest.ack“ value="UPDATE TEST SET ACK = #[map-payload:NOW] WHERE
ID = #[map-payload:id] AND TYPE =#[map-payload:type] AND DATA = #[map-payload:data]"/>
<jdbc:query key="writeTest“ value="INSERT INTO TEST (ID, TYPE, DATA, ACK, RESULT) VALUES
(NULL, #[map-payload:type], #[map-payload:payload], NULL, NULL)"/>
</jdbc:connector>
<flow name="...">
<jdbc:inbound-endpoint queryKey="getTest"/>
...
<jdbc:outbound-endpoint queryKey="writeTest"/>
</flow>
<spring:bean class="org.springframework.jdbc.datasource. DriverManagerDataSource" id="ordersDB">
<spring:property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<spring:property name="url" value="jdbc:mysql://localhost:3306/orderdb"/>
<spring:property name="username" value="myName"/>
<spring:property name="password" value="myPwd"/>
</spring:bean>

8. Datasources Shortcuts
 Mule 3.2 and later versions provide shortcuts for configuring a number of data
sources including Derby, MySQL, Oracle and PostgreSQL:
Eg:
MySql:
<jdbc:mysql-data-source database="mule" name="dataSource" password="secret" user="mysql"/>
Derby:
<jdbc:derby-data-source create="true" database="mule" name="dataSource"/>
Oracle:
<jdbc:oracle-data-source instance="mule" name="dataSource" password="secret" user="oracle"/>

9. Results Data Structure
 Query(SELECT statement) result, is an array of Maps
 Each Map represents a record in the database and each entry in the Map
represents a column in the record.
 Using a Groovy expression is one way of retrieving the required data from the
result set.

10. JDBC - CE vs EE
 The EE version of the JDBC transport offers a number of extra features over and above
the features provided by the CE version. List of JDBC features offered by both versions:
 Select queries with acknowledgement
 Basic Insert/Update/Delete: Single row Insert/Update/Delete
 Basic Stored Procedure Support: Supports only in parameters
 Unnamed Queries: Queries can be invoked programmatically
 Flexible Data Source Config: Can configure data sources through JNDI, XAPool or
Spring.
 Transactions
 Outbound Select Query: Retrieve records using the select statement configured on
outbound endpoints.
 The EE JDBC transport also offers:
 Large Dataset Retrieval: Allows the consumption of records in smaller batches thus
allows the retrieval of large datasets.

11. JDBC - CE vs EE (Contd)
 Batch Insert/Update/Delete: Batch inserts/update/delete improve the
performance of the JDBC transport considerably when large datasets need
to be inserted/updated.
 Advanced Transformers: These transformers include XML and CSV
transformers.
 Advanced Stored Procedures: Allows both in and out parameters.

12. JDBC Transactions
 Similar to JMS, the JDBC transport has support for single resource JDBC transactions. This is configured using the jdbc:transaction element as seen in the
following example.
Eg:
<jdbc:connector dataSource-ref="jdbcDataSource" name="jdbcConnector">
<jdbc:query key="JobSearch“ value="SELECT Id,Task FROM Jobs WHERE Started IS NULL"/>
<jdbc:query key="JobSearch.ack“ value="UPDATE Jobs SET Started=#[function:now] WHERE Id = #[map-
payload:Id]"/>
<jdbc:query key="InsertNewTask“ value="INSERT INTO Tasks (JobId,Task) VALUES (#[map-payload:Id],#[map-
payload:Task])"/>
</jdbc:connector>
<flow name="JdbcSimpleTransaction">
<jdbc:inbound-endpoint queryKey="JobSearch">
<jdbc:transaction action="ALWAYS_BEGIN"/>
</jdbc:inbound-endpoint>
<component class="com.mulesoft.MyCustomComponent"/>
<jdbc:outbound-endpoint queryKey="InsertNewTask">
<jdbc:transaction action="ALWAYS_JOIN"/>
</jdbc:outbound-endpoint>
</flow>

13. MEL - JDBC
Arrays and Lists
 Literal forms for Lists ({item1, item2, . . }) and Arrays ([item1, item2, . . ]). Using the literal
form the payload can be set by:
Eg: Message.payload = ({‘foo’, ‘bar’, ‘dog’})
This will set the payload to a list of 3 elements. In the MEL, as in many other
languages, indexes start at 0. Eg: Message.payload[2] results in ‘dog’
 Arrays and Lists in Java must specify the type of their contents, but in MEL they are untyped.
 The MEL supplies the correct type when we use them – either by determining it at compile
time or coercing the array to the correct type at run time.
Eg: Valid MEL: Message.payload = ({‘foo’, 1234, 1234.56})
Mule Maps
 The MEL has built-in support for maps.
 Maps are used to store "associative arrays" or "dictionaries".
Eg: Message.payload = [ "Brett":100,"Pete":"Did not finish", "Andrew":86.879]

14. MEL – JDBC (Contd)
 MEL provides a very clean way to access the values in a map.
 Use square brackets to address the key:
 Eg: Message.payload ["Pete"] => Output: 'Did not finish'
 The MEL supplies the correct type when we use them – either by determining it at
compile time or coercing the array to the correct type at run time. If there is no value,
the operation returns a Null.
Arrays of Maps
 The very common Mule Payload is an array of maps
Eg: {['destination':'SFO', 'price':500]}. Price of SFO can be found by
Message.payload[0]['price']
 The following example shows how to check the size of an array in a WHEN statement,
evaluates to true if the array is not empty:
Eg: <when expression="message.payload.size() > 0"> This can be used to avoid
NullPayloads when potentially asking for something that the database didn't return any
values for.

15. Thank you