Mule - JDBC

Kalaimathi

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

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">

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.

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.

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">

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>

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"/>

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.

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.

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.

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>

MEL - JDBCArrays 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]

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.

Thank you