Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/juliomarcopineda/jdbc-stream
Light-weight library to wrap JDBC ResultSet to Java Stream API
https://github.com/juliomarcopineda/jdbc-stream
java java-stream-api java-streams java8 java8-stream jdbc lambda sql
Last synced: about 1 month ago
JSON representation
Light-weight library to wrap JDBC ResultSet to Java Stream API
- Host: GitHub
- URL: https://github.com/juliomarcopineda/jdbc-stream
- Owner: juliomarcopineda
- License: mit
- Created: 2019-04-24T16:18:06.000Z (over 5 years ago)
- Default Branch: master
- Last Pushed: 2019-05-06T18:43:00.000Z (over 5 years ago)
- Last Synced: 2024-09-28T23:20:54.992Z (about 2 months ago)
- Topics: java, java-stream-api, java-streams, java8, java8-stream, jdbc, lambda, sql
- Language: Java
- Homepage:
- Size: 123 KB
- Stars: 9
- Watchers: 1
- Forks: 2
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# jdbc-stream
[](https://travis-ci.org/juliomarcopineda/jdbc-stream)
[](https://maven-badges.herokuapp.com/maven-central/com.github.juliomarcopineda/jdbc-stream)
[](https://opensource.org/licenses/MIT)
Light-weight library to wrap JDBC ResultSet to Java Stream API
# Overview
jdbc-stream is a light-weight convenience library that wraps any JDBC ResultSet into a Java 8 Stream to take advantage of the Stream API and functional programming in Java.
## Add jdbc-stream to your build
jdbc-stream can be found at MavenCentral with group ID `com.github.juliomarcopineda` and artifact ID `jdbc-stream`.
#### Maven
```xml
com.github.juliomarcopineda
jdbc-stream
0.1.1
```
#### Gradle (Groovy DSL)
```groovy
implementation 'com.github.juliomarcopineda:jdbc-stream:0.1.1'
```
#### Gradle (Kotlin DSL)
```kotlin
compile("com.github.juliomarcopineda:jdbc-stream:0.1.1")
```
## Example Usage
For this example, we will assume that we have a SQLite instance with the [Iris Data Set](https://archive.ics.uci.edu/ml/datasets/iris) in the table `iris` with the following schema:
```sql
CREATE TABLE iris (SepalLength real,
SepalWidth real,
PetalLength real,
PetalWidth real,
IrisClass varchar(255))
```
#### 1) Create a connection to our SQL database.
For this example we will use an in-memory SQLite server and the `java.sql` library
```java
Connection conn = DriverManager.getConnection("jdbc:sqlite::memory")
```
#### 2) Execute SQL query to get ResultSet
```java
String sql = "SELECT * FROM iris"
PreparedStatement ps = conn.prepareStatement(sql)
ResultSet resultSet = ps.executeQuery()
```
#### 3) Use jdbc-stream library to utilize Java 8 Stream API
The following are limited examples of what you can do with jdbc-stream and Java 8 Stream API
##### a) Get number of records from SQL query
```java
long count = JdbcStream.stream(resultSet).count()
```
##### b) Get average Sepal Length of all Iris records
```java
double averageSepalLength = JdbcStream.stream(resultSet)
.mapToDouble(rs -> {
double sepalLength = 0;
try {
sepalLength = rs.getDouble("SepalLength");
}
catch (SQLException e) {
// Handle exception
}
return sepalLength;
})
.average()
.getAsDouble();
```
##### c) Get Iris species with the widest Petal Width
- Get `Map>` where each `key` is the Iris species and each `value` is the `List` of all their possible petal widths
```java
Map> petalWidths = JdbcStream.stream(resultSet)
.map(rs -> {
String irisClass = "";
double petalWidth = 0;
try {
irisClass = rs.getString("IrisClass");
petalWidth = rs.getDouble("PetalWidth");
}
catch (SQLException e) {
// Handle exception
}
return new AbstractMap.SimpleEntry<>(irisClass, petalWidth);
})
.collect(Collectors.toMap(Map.Entry::getKey,
e -> {
List list = new ArrayList<>();
list.add(e.getValue());
return list;
},
(l1, l2) -> Stream.of(l1, l2)
.flatMap(Collection::stream)
.collect(Collectors.toList())))
```
- Iterate over entries of the Map to get the Iris species with the widest petal
```java
String irisWidestPetal = petalWidths.entrySet()
.stream()
.max((e1, e2) -> Collections.max(e1.getValue()) > Collections.max(e2.getValue()) ? 1 : -1)
.get()
.getKey()
```
##### d) Use a custom Mapper from ResultSet to client-defined Java class
jdbc-stream can handle the mapping between ResultSet rows to a Java class as long as the client provides a Mapper. This Mapper must extend the Mapper interface that is included in the library.
Example usage of this Mapper as follows:
- First let us define a Sepal class.
```java
public class Sepal {
private int width;
private int length;
public double getArea() {
return this.width * this.length;
}
// getters and setters
}
```
- Then, let's define a Mapper from ResultSet row to a Sepal.
```java
public class SepalMapper implements Mapper {
@Override
public Sepal map(ResultSet resultSet) {
Sepal sepal = new Sepal();
try {
sepal.setWidth(resultSet.get(SepalWidth));
sepal.setLength(resultSet.get(SepalLength));
}
catch (SQLException e) {
// Handle exception
}
return sepal;
}
}
```
- Now, we can use both the ResultSet and the custom Mapper to take advantage of Java Stream API. Suppose we want to get the average sepal area:
```java
SepalMapper mapper = new SepalMapper();
double averageSepalArea = JdbcStream(resultSet, mapper)
.map(Sepal::getArea)
.mapToDouble(i -> i)
.average()
.getAsDouble();
```
- Note: we could have used an anonymous class to define the custom mapper as follows:
```java
Mapper mapper = new Mapper() {
@Override
public Sepal map(ResultSet resultSet) {
Sepal sepal = new Sepal();
try {
sepal.setWidth(resultSet.get(SepalWidth));
sepal.setLength(resultSet.get(SepalLength));
}
catch (SQLException e) {
// Handle exception
}
return sepal;
}
}
```