JPAStreamer

https://github.com/speedment/jpa-streamer
Admin
JPAStreamer is a lightweight Java library for expressing JPA queries as Java Streams, enabling...
Tokens:42,444
Snippets:627
Trust Score:8
License:LGPL-2.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### Cheerio Installation

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/cheerio/Readme.md

Install Cheerio using npm.

```bash
npm install cheerio
```

--------------------------------

### Instantiate JPAStreamer and Query Data

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/fetching-data/pages/fetching-data.adoc

Example demonstrating the instantiation of JPAStreamer using a builder pattern and performing a query to count films starting with 'A'.

```java
public static void main(String[] args) {

    JPAStreamer jpaStreamer = JPAStreamer.createJPAStreamerBuilder("sakila") 
        .build();

    long count = jpaStreamer.stream(Film.class)
        .filter(Film$.title.startsWith("A"))
        .count();

    System.out.format("There are %d films with a title that starts with A", count);
}
```

--------------------------------

### Install entities Package

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/entities/readme.md

Install the 'entities' package using npm.

```bash
npm install entities
```

--------------------------------

### Example Persistence Unit Configuration

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/fetching-data/pages/fetching-data.adoc

An example XML configuration for a persistence unit named 'sakila'. This file is typically found in your project and describes database connection details.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.2"
             xmlns="http://xmlns.jcp.org/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
     http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">

    <persistence-unit name="sakila" transaction-type="RESOURCE_LOCAL"> 
        <description>MySQL Sakila Example Database</description>
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <properties>
            <!-- Configuring The Database Connection Details -->
            <property name="javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver" />
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/sakila" />

            <!-- ... -->

        </properties>
    </persistence-unit>
</persistence>
```

--------------------------------

### Install html-entities via npm

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/html-entities/README.md

Install the html-entities library using npm. This is the first step to using the library in your Node.js project.

```bash
$ npm install html-entities
```

--------------------------------

### Install antora-lunr Module

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/antora-lunr/README.md

Install the antora-lunr npm package locally or globally.

```bash
npm i antora-lunr
npm i -g antora-lunr
```

--------------------------------

### forEach() Example

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/stream-fundamentals/pages/terminal_operations.adoc

Performs an action for each element in the stream. The order of execution is not guaranteed.

```java
Stream.of("B", "A", "C" , "B")
    .forEach(System.out::print);
```

--------------------------------

### count() Example

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/stream-fundamentals/pages/terminal_operations.adoc

Counts the number of elements in a stream.

```java
Stream.of("B", "A", "C" , "B")
    .count();
```

```java
Stream.empty()
    .count();
```

--------------------------------

### asLongStream() Example for IntStream

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/stream-fundamentals/pages/intermediate_operations.adoc

Converts an IntStream to a LongStream.

```java
IntStream.of(1, 2, 3, 4)
    .asLongStream()
```

--------------------------------

### mapMulti Example

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/stream-fundamentals/pages/intermediate_operations.adoc

Demonstrates how mapMulti can duplicate elements based on a condition. Requires Java 16 or later.

```java
Stream.of(1.0, 2.0, 3.0, 4.0, 5.0)
    .mapMulti((i, mapper) -> {
        if (i % 2 == 0) {
            mapper.accept(i); 
            mapper.accept(i); 
        }
    });
```

--------------------------------

### Install Default Antora Site Generator

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/antora-lunr/README.md

Check if the default Antora site generator is installed locally or globally.

```bash
npm list --depth 0
npm list -g --depth 0
```

--------------------------------

### Filter Strings Starting with 'A' using Java Predicate

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/predicates/pages/predicates.adoc

Demonstrates filtering a stream of strings using a standard Java Predicate to select elements that begin with the letter 'A'. This example shows basic Predicate usage.

```java
Predicate<String> startsWithA = (String s) -> s.startsWith("A");

Stream.of("Snail", "Ape", "Bird", "Ant", "Alligator")
    .filter(startsWithA)
    .forEachOrdered(System.out::println);
```

--------------------------------

### Start Lunr.js Test Server

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/lunr/CONTRIBUTING.md

Launch a local development server to run tests in a web browser. The server will be accessible on port 3000, with tests available at the /test path.

```bash
make server
```

--------------------------------

### collect() to List Example

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/stream-fundamentals/pages/terminal_operations.adoc

Collects stream elements into a List.

```java
Stream.of("B", "A", "C" , "B")
    .collect(Collectors.toList());
```

--------------------------------

### Using Metamodel Fields for Filtering

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/how-it-works/pages/how-it-works.adoc

Demonstrates how to use generated metamodel fields like 'Film$.title' to create predicates for filtering streams. This example counts films starting with 'A'.

```java
long nrOfFilmsStartingWithA = jpaStreamer.stream(Film.class)
    .filter(Film$.title.startsWith("A")) // As title is of type StringField we get access to operators such as startsWith that returns a Predicate<T> that evaluates to true or false.
    .count();
```

--------------------------------

### asDoubleStream() Example for IntStream

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/stream-fundamentals/pages/intermediate_operations.adoc

Converts an IntStream to a DoubleStream.

```java
IntStream.of(1, 2, 3, 4)
    .asDoubleStream()
```

--------------------------------

### boxed() Example for IntStream

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/stream-fundamentals/pages/intermediate_operations.adoc

Converts an IntStream to a Stream of Integer objects.

```java
IntStream.of(1, 2, 3, 4)
    .boxed()
```

--------------------------------

### Define StreamConfiguration with Query Hints

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/fetching-data/pages/fetching-data.adoc

Create a StreamConfiguration to pass query hints to the underlying JPA provider. This example sets a read-only hint and a query timeout.

```java
StreamConfiguration sc = StreamConfiguration.of(Film.class)
    .withHint("javax.persistence.query.timeout", 50)
    .withHint("org.hibernate.readOnly", true);
List<Film> films = jpaStreamer.stream(sc)
    .filter(Film$.title.startsWith("A"))
    .sorted(Film$.length)
    .limit(10)
    .collect(Collectors::toList);
```

--------------------------------

### Example Film Entity

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/predicates/pages/reference-predicates.adoc

An example JPA entity 'Film' with a 'rating' field, used for demonstrating reference predicates.

```java
@Entity
@Table(name = "film", schema = "sakila")
public class Film  {

    // ...

    @Column(name = "rating", nullable = true, columnDefinition = "enum('G','PG','PG-13','R','NC-17')")
    private String rating;

    // ...
}

```

--------------------------------

### collect() to Set Example

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/stream-fundamentals/pages/terminal_operations.adoc

Collects stream elements into a Set, removing duplicates.

```java
Stream.of("B", "A", "C" , "B")
    .collect(Collectors.toSet());
```

--------------------------------

### collect() to Map Example

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/stream-fundamentals/pages/terminal_operations.adoc

Collects stream elements into a Map, using a key and value extractor.

```java
Stream.of("I", "am", "a", "stream")
    .collect(
        Collectors.toMap(
            s -> s.toLowerCase(), // Key extractor
            s -> s.length())      // Value extractor
    )
```

--------------------------------

### Example of Optimized Query Generation

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/how-it-works/pages/how-it-works.adoc

This example demonstrates how JPA Streamer translates Stream API operations like filtering and sorting into an optimized SQL query. It highlights the use of generated fields for efficient database interaction.

```sql
select
    film0_.film_id as film_id1_0_,
    film0_.title as title2_0_,
    film0_.length as length3_0_
from
    film film0_
where
    film0_.length > 100
order by
    film0_.length desc,
    film0_.title asc limit ?, ?
```

--------------------------------

### mapMultiToLong Example

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/stream-fundamentals/pages/intermediate_operations.adoc

Demonstrates mapMultiToLong for creating a LongStream by duplicating elements. Requires Java 16 or later.

```java
Stream.of(1.0, 2.0, 3.0, 4.0, 5.0)
    .mapMulti((i, mapper) -> {
        if (i % 2 == 0) {
            mapper.accept(i.longValue()); 
            mapper.accept(i.longValue()); 
        }
    });
```

--------------------------------

### JPA Entity Bean Example

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/how-it-works/pages/how-it-works.adoc

An example of a JPA entity bean class named 'Film'. This class defines the structure and columns of a database table.

```java
import javax.persistence.Entity;
import javax.persistence.Table;
import javax.persistence.Id;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Column;

@Entity
@Table(name = "film", schema = "sakila")
public class Film {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "film_id", nullable = false, updatable = false, columnDefinition = "smallint(5)")
    private Integer filmId;

    @Column(name = "title", nullable = false, columnDefinition = "varchar(255)")
    private String title;

    // ...

}
```

--------------------------------

### Empty attributes with emptyAttrs: true

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/dom-serializer/README.md

Example showing how an empty attribute is rendered when the `emptyAttrs` option is set to true.

```html
<input checked="">
```

--------------------------------

### DOM Structure Output

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/domhandler/readme.md

Example output of the DOM structure generated by DomHandler after parsing HTML.

```javascript
[
    {
        data: "Xyz ",
        type: "text",
    },
    {
        type: "script",
        name: "script",
        attribs: {
            language: "javascript",
        },
        children: [
            {
                data: "var foo = '<bar>';<",
                type: "text",
            },
        ],
    },
    {
        data: "<!-- Waah! -- ",
        type: "comment",
    },
];
```

--------------------------------

### forEachOrdered() Example

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/stream-fundamentals/pages/terminal_operations.adoc

Performs an action for each element in the stream, preserving the encounter order.

```java
Stream.of("B", "A", "C" , "B")
    .forEachOrdered(System.out::print);
```

--------------------------------

### Self-closing tags with selfClosingTags: true

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/dom-serializer/README.md

Example showing how a tag without content is rendered when the `selfClosingTags` option is true.

```html
<foo />
```

--------------------------------

### min() Example

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/stream-fundamentals/pages/terminal_operations.adoc

Finds the minimum element in a stream based on a Comparator. Returns an Optional.

```java
Stream.of("B", "A", "C" , "B")
    .min(String::compareTo);
```

```java
Stream.<String>empty()
    .min(String::compareTo);
```

--------------------------------

### Empty attributes with emptyAttrs: false

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/dom-serializer/README.md

Example showing how an empty attribute is rendered when the `emptyAttrs` option is set to false.

```html
<input checked>
```

--------------------------------

### Example of negating a predicate twice

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/predicates/pages/negating-predicates.adoc

Negating a predicate an even number of times returns the original predicate. For example, negating equal(1) twice is equivalent to equal(1).

```java
Film$.film_id.equal(1).negate().negate()
```

--------------------------------

### Mocha Test Setup

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/lunr/test/index.html

Initializes the Mocha testing framework in 'tdd' mode and sets up Chai assertions. It also defines a global `withFixture` function for loading test data.

```javascript
mocha.setup('tdd')
window.assert = chai.assert
window.withFixture = function (name, fn) {
  var fixturePath = '/test/fixtures/' + name,
      xhr = new XMLHttpRequest()

  xhr.addEventListener('load', function () {
    if (this.status != 200) {
      fn('non 200 response')
    } else {
      fn(null, this.responseText)
    }
  })

  xhr.open('GET', fixturePath)
  xhr.send()
}

mocha.checkLeaks();
mocha.globals(['lunr']);
mocha.run();
```

--------------------------------

### Create, Filter, Sort, and Collect a Stream of Strings

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/stream-fundamentals/pages/stream_basics.adoc

This snippet demonstrates the basic pipeline of a Java 8 Stream, starting with a source, applying intermediate operations like filter and sort, and concluding with a terminal operation to collect the results.

```java
Stream.of(
        "Zlatan",
        "Tim",
        "Bo",
        "George",
        "Adam",
        "Oscar"
        )
        .filter(n -> n.length() > 2)
        .sorted()
        .collect(Collectors.toList());
```

--------------------------------

### anyMatch() Example

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/stream-fundamentals/pages/terminal_operations.adoc

Checks if any element in the stream matches the given predicate. Returns a boolean.

```java
Stream.of("B", "A", "C", "B")
    .anyMatch("A"::equals);
```

```java
Stream.of("B", "A", "C", "B")
    .anyMatch("Z"::equals);
```

--------------------------------

### Self-closing tags with selfClosingTags: false

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/dom-serializer/README.md

Example showing how a tag without content is rendered when the `selfClosingTags` option is false.

```html
<foo></foo>
```

--------------------------------

### Stream Query Example

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/introduction/pages/introduction.adoc

Demonstrates filtering, sorting, skipping, and limiting results from the Film entity. It filters by rating, sorts by length and title, skips the first 10, and limits to 5 results.

```java
jpaStreamer.stream(Film.class)
    .filter(Film$.rating.equal("G"))
    .sorted(Film$.length.reversed().thenComparing(Film$.title.comparator())) // Sort by reversed length, then by title
    .skip(10)
    .limit(5)
    .forEach(System.out::println);
```

--------------------------------

### Loading HTML with htmlparser2

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/cheerio/Readme.md

Load HTML using the htmlparser2 library. This is useful for handling invalid markup or for performance-critical situations. Ensure htmlparser2 is installed.

```javascript
const htmlparser2 = require('htmlparser2');
const dom = htmlparser2.parseDocument(document, options);

const $ = cheerio.load(dom);
```

--------------------------------

### takeWhile() Example

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/stream-fundamentals/pages/intermediate_operations.adoc

Uses `takeWhile` to include elements as long as the condition is true. Elements are dropped once the condition becomes false.

```java
Stream.of("A", "B", "C", "B")
    .takeWhile(s -> "B".compareTo(s) >= 0)
```

--------------------------------

### mapMultiToInt Example

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/stream-fundamentals/pages/intermediate_operations.adoc

Illustrates mapMultiToInt for generating an IntStream by duplicating elements. Requires Java 16 or later.

```java
Stream.of(1, 2, 3, 4, 5)
    .mapMulti((i, mapper) -> {
        if (i % 2 == 0) {
            mapper.accept(i); 
            mapper.accept(i); 
        }
    });
```

--------------------------------

### Fetch Second Page of Films

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/fetching-data/pages/stream-examples.adoc

Example of how to use the filmPage method to retrieve the second page of films, sorted by title in descending order.

```java
filmPage(1, Film$.title.reversed());
```

--------------------------------

### max() Example

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/stream-fundamentals/pages/terminal_operations.adoc

Finds the maximum element in a stream based on a Comparator. Returns an Optional.

```java
Stream.of("B", "A", "C" , "B")
    .max(String::compareTo);
```

```java
Stream.<String>empty()
    .max(String::compareTo);
```

--------------------------------

### Filter Films by Title Starting With

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/predicates/pages/string-predicates.adoc

Use `startsWith` to filter entities where a string property begins with a specified prefix. This is case-sensitive.

```java
jpaStreamer.stream(Film.class)
    .filter(Film$.title.startsWith("ALABAMA"))
    .forEachOrdered(System.out::println);
```

--------------------------------

### Configure Maven Compiler Plugin for JPAStreamer

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/quick-start/pages/quick-start.adoc

Configure the Maven Compiler Plugin to set the package name, prefix, and suffix for generated entities. This example sets the package to 'com.speedment.jpastreamer.test', prefix to 'A', and suffix to 'B'.

```xml
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.10.1</version>
    <configuration>
        <compilerArgs>
            <arg>-AjpaStreamerPackage=com.speedment.jpastreamer.test</arg> <1>
            <arg>-AjpaStreamerPrefix=A</arg> <2>
            <arg>-AjpaStreamerSuffix=B</arg> <3>
        </compilerArgs>
    </configuration>
</plugin>
```

--------------------------------

### Pull Sakila Docker Image

Source: https://github.com/speedment/jpa-streamer/blob/master/integration-tests/README.adoc

Pulls the Sakila database Docker image from Docker Hub. Ensure Docker is installed and running.

```shell
docker pull restsql/mysql-sakila
```

--------------------------------

### Filter Films by Title Not Starting With

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/predicates/pages/string-predicates.adoc

Use `notStartsWith` to filter entities where a string property does not begin with a specified prefix. This is case-sensitive.

```java
jpaStreamer.stream(Film.class)
    .filter(Film$.title.notStartsWith("ALABAMA"))
    .forEachOrdered(System.out::println);
```

--------------------------------

### Initialize a Lunr Index

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/lunr/index.html

Set up a new Lunr index with specified fields and a reference field. This is the initial step before adding documents.

```javascript
var index = lunr(function () {
    this.field('title', {boost: 10})
    this.field('body')
    this.ref('id')
  })
```

--------------------------------

### Create a Simple Search Index

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/lunr/README.md

Demonstrates how to create a basic Lunr.js search index with fields and add a document.

```javascript
var idx = lunr(function () {
  this.field('title')
  this.field('body')

  this.add({
    "title": "Twelfth-Night",
    "body": "If music be the food of love, play on: Give me excess of it…",
    "author": "William Shakespeare",
    "id": "1"
  })
})
```

--------------------------------

### Limit Records with LIMIT

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/fetching-data/pages/sql-equivalents.adoc

Limits the number of records returned by the stream. This example fetches and prints the first 3 films sorted by title.

```java
jpaStreamer.stream(Film.class)
    .sorted(Film$.title)
    .limit(3)
    .forEachOrdered(System.out::println);
```

--------------------------------

### JPA Persistence Unit Configuration

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/quick-start/pages/quick-start.adoc

Example of a JPA persistence unit configuration in XML. This defines the entity manager name, provider, and database connection properties.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.2"
             xmlns="http://xmlns.jcp.org/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
     http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">

    <persistence-unit name="sakila" transaction-type="RESOURCE_LOCAL">
        <description>MySQL Sakila Example Database</description>
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <properties>
            <!-- Configuring The Database Connection Details -->
            <property name="javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver" />
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/sakila" />

            <!-- ... -->

        </properties>
    </persistence-unit>
</persistence>
```

--------------------------------

### Basic Cheerio Usage

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/cheerio/Readme.md

Demonstrates loading HTML, selecting elements, modifying text and classes, and rendering the HTML.

```javascript
const cheerio = require('cheerio');
const $ = cheerio.load('<h2 class="title">Hello world</h2>');

$('h2.title').text('Hello there!');
$('h2').addClass('welcome');

$.html();
//=> <html><head></head><body><h2 class="title welcome">Hello there!</h2></body></html>
```

--------------------------------

### Add Documents to Lunr Index

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/lunr/index.html

Add individual documents to the Lunr index. Each document requires a unique reference and fields defined during index setup.

```javascript
index.add({
    id: 1,
    title: 'Foo',
    body: 'Foo foo foo!'
  })
```

```javascript
index.add({
    id: 2,
    title: 'Bar',
    body: 'Bar bar bar!'
  })
```

--------------------------------

### Instantiate DomHandler

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/domhandler/readme.md

Shows how to instantiate the DomHandler with an optional callback and options.

```javascript
const handler = new DomHandler([ <func> callback(err, dom), ] [ <obj> options ]);
// const parser = new Parser(handler[, options]);
```

--------------------------------

### Filter Films by Title Starting With (Ignore Case)

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/predicates/pages/string-predicates.adoc

Use `startsWithIgnoreCase` to filter entities where a string property begins with a specified prefix, ignoring case differences. This is useful for flexible searching.

```java
jpaStreamer.stream(Film.class)
    .filter(Film$.title.startsWithIgnoreCase("ala"))
    .forEachOrdered(System.out::println);
```

--------------------------------

### Filter Films by Title Starting with 'A' using Standard Lambda (Not Recommended)

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/predicates/pages/predicates.adoc

Illustrates filtering films using a standard Java lambda expression. This approach is not optimized by JPAstreamer and forces the entire table to be loaded into the JVM.

```java
films.stream()
    .filter(f -> f.getTitle().startsWith("A"))
    .forEachOrdered(System.out::println);
```

--------------------------------

### Filter Films by Title Not Starting With (Ignore Case)

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/predicates/pages/string-predicates.adoc

Use `notStartsWithIgnoreCase` to filter entities where a string property does not begin with a specified prefix, ignoring case. This provides case-insensitive exclusion.

```java
jpaStreamer.stream(Film.class)
    .filter(Film$.title.notStartsWithIgnoreCase("ala"))
    .forEachOrdered(System.out::println);
```

--------------------------------

### JPAstreamer Metamodel Generation

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/how-it-works/pages/how-it-works.adoc

An example of a generated metamodel class 'Film$' corresponding to the 'Film' entity. It represents entity columns as 'Field' objects for predicate composition.

```java
public class Film$ {

    public static final ComparableField<Film, Integer> filmId = ComparableField.create(
        Film.class, // Declares which table the Field belongs to
        "filmId", // The name of the field
        Film::getFilmId, // A reference to the associated getter
        false // A boolean that describes if the Field is nullable
    );

    public static final StringField<Film> title = StringField.create(
        Film.class,
        "title",
        Film::getTitle,
        false
    );

    // ...

}
```

--------------------------------

### Importing Available Entity Classes

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/html-entities/README.md

Demonstrates how to import the different entity classes provided by the library, including XmlEntities, Html4Entities, Html5Entities, and AllHtmlEntities.

```javascript
const XmlEntities = require('html-entities').XmlEntities,
      Html4Entities = require('html-entities').Html4Entities,
      Html5Entities = require('html-entities').Html5Entities,
      AllHtmlEntities = require('html-entities').AllHtmlEntities;
```

--------------------------------

### Generated SQL Query

Source: https://github.com/speedment/jpa-streamer/blob/master/README.adoc

Example of the SQL query generated by JPAstreamer for the preceding Stream operations. This shows how Stream API calls are translated into efficient SQL.

```roomsql
select
    film0_.film_id as film_id1_1_,
    film0_.description as descript2_1_,
    film0_.language_id as languag11_1_,
    film0_.last_update as last_upd3_1_,
    film0_.length as length4_1_,
    film0_.rating as rating5_1_,
    film0_.rental_duration as rental_d6_1_,
    film0_.rental_rate as rental_r7_1_,
    film0_.replacement_cost as replacem8_1_,
    film0_.special_features as special_9_1_,
    film0_.title as title10_1_
from
    film film0_
where
    film0_.rating=?
order by
    film0_.length desc,
    film0_.title asc
limit ?, ?
```

--------------------------------

### Filter Films by Length Between 60 and 120 (Start Inclusive, End Inclusive)

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/predicates/pages/comparable-predicates.adoc

Prints all films with a length between 60 and 120, where both the start and end values are included in the range. This uses a specific Inclusion enum constant.

```java
jpaStreamer.stream(Film.class)
    .filter(Film$.length.between(60, 120, Inclusion.START_INCLUSIVE_END_INCLUSIVE))
```

--------------------------------

### Rendering with options

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/dom-serializer/README.md

Demonstrates how to pass an options object to the render function to customize serialization behavior.

```javascript
render(node, {
  xmlMode: true,
  emptyAttrs: true,
  selfClosingTags: true
});
```

--------------------------------

### Configure Antora UI for Supplemental Files

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/antora-lunr/README.md

Configure Antora to use supplemental UI files, including the Lunr search index.

```yaml
ui:
  bundle:
    url: https://gitlab.com/antora/antora-ui-default/-/jobs/artifacts/master/raw/build/ui-bundle.zip?job=bundle-stable
    snapshot: true
  supplemental_files: ./supplemental_ui
```

--------------------------------

### Run Sakila Docker Instance

Source: https://github.com/speedment/jpa-streamer/blob/master/integration-tests/README.adoc

Runs the Sakila database as a Docker container, exposing port 3306. Use the --platform flag for ARM64 architecture if needed.

```shell
docker run -d --publish 3306:3306 --name mysqld restsql/mysql-sakila
```

--------------------------------

### Cheerio Load Options for XML

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/cheerio/Readme.md

Configure parsing options for XML input by passing an options object to the .load() method.

```javascript
const $ = cheerio.load('<ul id="fruits">...</ul>', {
  xml: {
    normalizeWhitespace: true,
  },
});
```

--------------------------------

### Importing dom-serializer

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/dom-serializer/README.md

Demonstrates how to import the dom-serializer library using both ES Module and CommonJS syntax.

```javascript
import render from "dom-serializer";
```

```javascript
const render = require("dom-serializer").default;
```

--------------------------------

### Equivalent AND using stacked filters

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/predicates/pages/combining-predicates.adoc

Demonstrates an alternative way to achieve the same result as `and()` by stacking two separate `filter` operations. This can be less efficient as it may result in two separate queries.

```java
jpaStreamer.stream(Film.class)
    .filter(Film$.length.greaterThan(120))
    .filter(Film$.rating.equal("PG-13"))
    .forEachOrdered(System.out::println);
```

--------------------------------

### Generate Antora Site with Lunr Search Enabled

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/antora-lunr/README.md

Generate the Antora documentation site with search enabled, specifying Lunr as the engine.

```bash
DOCSEARCH_ENABLED=true DOCSEARCH_ENGINE=lunr antora site.yml
```

--------------------------------

### Basic HTML Parsing with Callbacks

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/htmlparser2/README.md

Demonstrates how to use the htmlparser2 Parser with event callbacks for handling tags, text, and closing tags. Useful for processing HTML incrementally.

```javascript
const htmlparser2 = require("htmlparser2");
const parser = new htmlparser2.Parser({
    onopentag(name, attributes) {
        /*
         * This fires when a new tag is opened.
         *
         * If you don't need an aggregated `attributes` object,
         * have a look at the `onopentagname` and `onattribute` events.
         */
        if (name === "script" && attributes.type === "text/javascript") {
            console.log("JS! Hooray!");
        }
    },
    ontext(text) {
        /*
         * Fires whenever a section of text was processed.
         *
         * Note that this can fire at any point within text and you might
         * have to stich together multiple pieces.
         */
        console.log("-->", text);
    },
    onclosetag(tagname) {
        /*
         * Fires when a tag is closed.
         *
         * You can rely on this event only firing when you have received an
         * equivalent opening tag before. Closing tags without corresponding
         * opening tags will be ignored.
         */
        if (tagname === "script") {
            console.log("That's it?!");
        }
    },
});
parser.write(
    "Xyz <script type='text/javascript'>const foo = '<<bar>>';</ script>"
);
parser.end();
```

--------------------------------

### Configure Lunr Indexing for Latest Version Only

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/antora-lunr/README.md

Set an environment variable to index only the latest released version of the documentation.

```bash
DOCSEARCH_ENABLED=true DOCSEARCH_ENGINE=lunr DOCSEARCH_INDEX_VERSION=latest antora site.yml
```

--------------------------------

### Announcer Interface

Source: https://github.com/speedment/jpa-streamer/blob/master/jpastreamer.announcer/README.adoc

Defines the greeting method for feature libraries to announce themselves at system start-up. Returning an empty string will prevent any output.

```java
public interface Announcer {

    /**
     * Returns a greeting that is to be output upon
     * system start-up.
     * <p>
     * Returning an empty String prevents output.
     *
     * @return a greeting that is to be output upon
     *         system start-up
     */
    String greeting();

}
```

--------------------------------

### Define Film Entity

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/fetching-data/pages/sql-equivalents.adoc

Example of a JPA entity class representing a 'film' table in the database.

```java
@Entity
public class Film {

    @Id
    @Column(name = "film_id", columnDefinition = "smallint(5)")
    private Integer filmId;

    @Column(name = "title", columnDefinition = "varchar(255)")
    private String title;

    ...
}
```

--------------------------------

### Loading HTML with Context

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/cheerio/Readme.md

Load HTML into Cheerio by providing the HTML string as the context argument.

```javascript
$('ul', '<ul id="fruits">...</ul>');
```

--------------------------------

### Loading HTML with Root Element

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/cheerio/Readme.md

Load HTML into Cheerio by providing the HTML string as the root element argument.

```javascript
$('li', 'ul', '<ul id="fruits">...</ul>');
```

--------------------------------

### Loading HTML with Cheerio (ES6/TypeScript)

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/cheerio/Readme.md

Load HTML into Cheerio using ES6 or TypeScript import syntax.

```javascript
import * as cheerio from 'cheerio';

const $ = cheerio.load('<ul id="fruits">...</ul>');
```

--------------------------------

### Initialize JPAStreamer from Supplier<EntityManager>

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/fetching-data/pages/fetching-data.adoc

Initialize JPAStreamer by providing a Supplier of Entity Managers. JPAStreamer will not manage the lifecycle of supplied Entity Managers.

```java
EntityManagerFactory emf = Persistence.createEntityManagerFactory("sakila"); 
JPAStreamer jpaStreamer = JPAStreamer.of(emf::createEntityManager);
```

--------------------------------

### Options

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/dom-serializer/README.md

Configuration options for the `render` function to control how DOM nodes are serialized into strings.

```APIDOC
## Options

### `encodeEntities`
- **Type**: `boolean | "utf8"`
- **Optional**
- **Description**: Controls whether characters reserved in HTML or XML are encoded. If `xmlMode` is true or the value is not 'utf8', characters outside the utf8 range will also be encoded.
- **Default**: `decodeEntities` value.

### `decodeEntities`
- **Type**: `boolean`
- **Optional**
- **Description**: Inherited from parsing; used as the default for `encodeEntities`.
- **Default**: `true`

### `emptyAttrs`
- **Type**: `boolean`
- **Optional**
- **Description**: Determines whether an empty attribute should have its value printed. Defaults to the `xmlMode` setting.
- **Example**: With `emptyAttrs: false`: `<input checked>`, With `emptyAttrs: true`: `<input checked="">

### `selfClosingTags`
- **Type**: `boolean`
- **Optional**
- **Description**: Determines whether self-closing tags should be used for tags that do not contain content. Defaults to the `xmlMode` setting.
- **Example**: With `selfClosingTags: false`: `<foo></foo>`, With `selfClosingTags: true`: `<foo />`

### `xmlMode`
- **Type**: `boolean | "foreign"`
- **Optional**
- **Description**: If true, treats the input as an XML document, enabling `emptyAttrs` and `selfClosingTags`. If set to 'foreign', it attempts to correct mixed-case attribute names.
- **Default**: `false`
```

--------------------------------

### Film Entity Definition

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/transactions/pages/transactions.adoc

Defines the Film entity with relevant fields for rating and rental rate, used in transaction examples.

```java
@Entity
@Table(name = "film", schema = "sakila")
public class Film {

    //...

    @Column(name = "rating", columnDefinition = "enum('G','PG','PG-13','R','NC-17')")
    private String rating;

    @Column(name = "rental_rate", columnDefinition = "decimal(4,2)")
    private Float rentalRate;

    //...

}
```

--------------------------------

### Loading HTML with Cheerio (CommonJS)

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/cheerio/Readme.md

Load HTML into Cheerio using CommonJS require syntax.

```javascript
const cheerio = require('cheerio');

const $ = cheerio.load('<ul id="fruits">...</ul>');
```

--------------------------------

### Parse HTML with DomHandler

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/domhandler/readme.md

Demonstrates parsing raw HTML using htmlparser2 and DomHandler, and logging the resulting DOM structure.

```javascript
const { Parser } = require("htmlparser2");
const { DomHandler } = require("domhandler");
const rawHtml =
    "Xyz <script language= javascript>var foo = '<<bar>>';</script><!--<!-- Waah! -- -->";
const handler = new DomHandler((error, dom) => {
    if (error) {
        // Handle error
    } else {
        // Parsing completed, do something
        console.log(dom);
    }
});
const parser = new Parser(handler);
parser.write(rawHtml);
parser.end();
```

--------------------------------

### dropWhile() Example

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/stream-fundamentals/pages/intermediate_operations.adoc

Uses `dropWhile` to skip elements as long as the condition is true. Once the condition becomes false, all subsequent elements are included.

```java
Stream.of("B", "A", "C", "B")
    .dropWhile(s -> "B".compareTo(s) >= 0)
```

--------------------------------

### Count Records with COUNT

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/fetching-data/pages/sql-equivalents.adoc

Counts the number of records that satisfy a given filter. This example counts films longer than 120 minutes.

```java
long noLongFilms = jpaStreamer.stream(Film.class)
    .filter(Film$.length.greaterThan(120))
    .count();
```

--------------------------------

### Rendering the Root HTML

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/cheerio/Readme.md

Render the entire document's HTML by calling the `html` method on the root selection. This provides the complete HTML structure.

```javascript
const $ = cheerio.load('<html>
  <head></head>
  <body>
    <ul id="fruits">
      <li class="apple">Apple</li>
      <li class="orange">Orange</li>
      <li class="pear">Pear</li>
    </ul>
  </body>
</html>');

$.root().html();
//=>  <html>
//      <head></head>
//      <body>
//        <ul id="fruits">
//          <li class="apple">Apple</li>
//          <li class="orange">Orange</li>
//          <li class="pear">Pear</li>
//        </ul>
//      </body>
//    </html>
```

--------------------------------

### Get distinct elements from a Java Stream

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/stream-fundamentals/pages/intermediate_operations.adoc

Removes duplicate elements from a stream based on their equals() method. Use to ensure uniqueness of elements.

```java
Stream.of("B", "A", "C" , "B")
    .distinct()
```

--------------------------------

### toList()

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/stream-fundamentals/pages/terminal_operations.adoc

Collects the stream elements into a `List`. Requires Java 16 or later.

```java
Stream.of("B", "A", "C", "B")
    .toList();
```

--------------------------------

### Search the Index

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/lunr/README.md

Shows how to perform a search query against a Lunr.js index.

```javascript
idx.search("love")
```

--------------------------------

### Run Module Tests

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/antora-lunr/README.md

Execute the test suite for the antora-lunr module.

```bash
npm t
```

--------------------------------

### Skip Records with OFFSET

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/fetching-data/pages/sql-equivalents.adoc

Skips a specified number of records before processing. This example skips the first 100 films and prints the rest in title order.

```java
films.stream()
    .sorted(Film$.title)
    .skip(100)
    .forEachOrdered(System.out::println);
```

--------------------------------

### Generated JPA Query Example

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/how-it-works/pages/how-it-works.adoc

The SQL query generated by JPAstreamer from the preceding Java stream pipeline. It shows how stream operations are translated into SQL WHERE and other clauses.

```text
select
            film0_.film_id as film_id1_0_,
            film0_.description as descript2_0_,
            film0_.last_update as last_upd3_0_,
            film0_.length as length4_0_,
            film0_.rating as rating5_0_,
            film0_.rental_duration as rental_d6_0_,
            film0_.rental_rate as rental_r7_0_,
            film0_.replacement_cost as replacem8_0_,
            film0_.special_features as special_9_0_,
            film0_.title as title10_0_ 
        from 
            film film0_ 
        where 
            film0_.rating=?
```

--------------------------------

### Create Stream from Entity Class

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/fetching-data/pages/fetching-data.adoc

The simplest way to create a Stream is by providing the entity class. This is equivalent to using StreamConfiguration.of(YourEntity.class).

```java
Stream<Film> stream = jpaStreamer.stream(Film.class);
```

--------------------------------

### Processing HTML with WritableStream

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/htmlparser2/README.md

Shows how to use the WritableStream interface for processing HTML from a Node.js readable stream. Ideal for large HTML files.

```javascript
const { WritableStream } = require("htmlparser2/lib/WritableStream");
const parserStream = new WritableStream({
    ontext(text) {
        console.log("Streaming:", text);
    },
});

const htmlStream = fs.createReadStream("./my-file.html");
htmlStream.pipe(parserStream).on("finish", () => console.log("done"));
```

--------------------------------

### Import nth-check utilities

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/nth-check/README.md

Import the main nthCheck function along with parse and compile utilities from the 'nth-check' package.

```javascript
import nthCheck, { parse, compile } from "nth-check";
```

--------------------------------

### Filter Films by Length Not Between Range

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/predicates/pages/comparable-predicates.adoc

Filters films where the length is outside a specified inclusive range. Ensure the start and end parameters are in the correct order to avoid always evaluating to true.

```java
jpaStreamer.stream(Film.class)
    .filter(Film$.length.notBetween(60, 120, Inclusion.START_INCLUSIVE_END_INCLUSIVE))
    .forEachOrdered(System.out::println);
```

--------------------------------

### Filter Films by Title Starting with 'A' using JPAstreamer Field

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/predicates/pages/predicates.adoc

Shows how to filter a stream of Film objects by their title using a JPAstreamer StringField. This method allows JPAstreamer to optimize the query.

```java
jpaStreamer.stream(Film.class)
    .filter(Film$.title.startsWith("A"))
    .forEachOrdered(System.out::println);
```

--------------------------------

### Maven Build Helper Plugin Configuration

Source: https://github.com/speedment/jpa-streamer/blob/master/README.adoc

Configures the build-helper-maven-plugin to add generated sources directory. This is needed by some IDEs to recognize compile-time generated code.

```xml
<plugins>
    <!-- Needed by some IDEs -->
    <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>build-helper-maven-plugin</artifactId>
        <version>3.2.0</version>
        <executions>
            <execution>
                <phase>generate-sources</phase>
                <goals>
                    <goal>add-source</goal>
                </goals>
                <configuration>
                    <sources>
                        <source>${project.build.directory}/generated-sources/annotations</source>
                    </sources>
                </configuration>
            </execution>
        </executions>
    </plugin>
</plugins>
```

--------------------------------

### Using Cheerio Slim Export

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/cheerio/Readme.md

Use the slim export of Cheerio to reduce bundle size. This version always uses htmlparser2.

```javascript
const cheerio = require('cheerio/lib/slim');
```

--------------------------------

### Configure Maven Build Helper Plugin

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/quick-start/pages/quick-start.adoc

Configure the build-helper-maven-plugin to add the generated metamodel sources to your project. This ensures the compiler can find the generated classes.

```xml
<plugins>
    <plugin> 
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>build-helper-maven-plugin</artifactId>
        <version>3.2.0</version>
        <executions>
            <execution>
                <phase>generate-sources</phase>
                <goals>
                    <goal>add-source</goal>
                </goals>
                <configuration>
                    <sources>
                        <source>${project.build.directory}/generated-sources/annotations</source>
                    </sources>
                </configuration>
            </execution>
        </executions>
    </plugin>
</plugins>
```

--------------------------------

### Check index against nth-check formula

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/nth-check/README.md

Use the nthCheck function to create a checker for a given CSS nth-formula. Note that the CSS rule starts counting at 1, but the returned function checks from index 0.

```javascript
const check = nthCheck("2n+3");

check(0); // `false`
check(1); // `false`
check(2); // `true`
check(3); // `false`
check(4); // `true`
check(5); // `false`
check(6); // `true`
```

--------------------------------

### Import css-select

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/css-select/README.md

Import the css-select module for use in your project. This is the primary way to access its functionality.

```javascript
const CSSselect = require("css-select");
```

--------------------------------

### Get Summary Statistics of Stream Elements

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/stream-fundamentals/pages/terminal_operations.adoc

Use `summaryStatistics()` to obtain a comprehensive set of statistics for an IntStream, including count, sum, min, average, and max. Handles empty streams by returning default statistical values.

```java
IntStream.of(1, 2, 3, 4)
    .summaryStatistics();
```

--------------------------------

### Equivalent OR using stream concatenation

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/predicates/pages/combining-predicates.adoc

Illustrates an alternative to `or()` by concatenating two streams and then applying `distinct()`. This approach requires JVM-level handling for distinctness and is generally less performant than using `Predicate::or`.

```java
StreamComposition.concatAndAutoClose(
    jpaStreamer.stream(Film.class).filter(Film$.length.greaterThan(120)),
    jpaStreamer.stream(Film.class).filter(Film$.rating.equal("PG-13"))
    )
    .distinct()
    .forEachOrdered(System.out::println);
```

--------------------------------

### Configure Eager Joins with StreamConfiguration

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/fetching-data/pages/sql-equivalents.adoc

Use StreamConfiguration to eagerly join related fields like 'actors' and 'language' to avoid N+1 SELECT issues.

```java
StreamConfiguration<Film> configuration = StreamConfiguration.of(Film.class)
        .joining(Film$.actors)
        .joining(Film$.language);
```

--------------------------------

### Create Stream with Filter and Collect

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/fetching-data/pages/fetching-data.adoc

Demonstrates creating a stream from the Film table, filtering by name, and collecting the results. The terminal operation closes the stream and its EntityManager.

```java
final JPAStreamer jpaStreamer = JPAStreamer.of("sakila"); 

final List<Film> films = jpaStreamer.stream(Film.class) 
    .filter(Film$.name.equal("Casablanca"))
    .collect(toList());
```

--------------------------------

### CSSselect.selectAll(query, elems, options)

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/css-select/README.md

Selects all elements from a list that match the given CSS selector query. Returns an array of matching elements.

```APIDOC
## CSSselect.selectAll(query, elems, options)

### Description
Selects all elements from a list that match the given CSS selector query.

### Parameters
#### Path Parameters
- **query** (string | function) - Required - The CSS selector string or a compiled function to match against.
- **elems** (array) - Required - The list of elements to search within.
- **options** (object) - Optional - Configuration options for the selection process.

### Returns
- array - An array of elements that match the query.
```

--------------------------------

### Negating startsWith Predicate

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/predicates/pages/negating-predicates.adoc

Negating startsWith(p) results in the notStartsWith(p) predicate.

```java
notStartsWith(p)
```

--------------------------------

### Combine OFFSET and LIMIT

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/fetching-data/pages/sql-equivalents.adoc

Combines skip and limit operations to fetch a specific range of records. Note that the order of `.skip()` and `.limit()` is crucial and differs from SQL.

```java
films.stream()
    .sorted(Film.TITLE)
    .skip(100)
    .limit(50)
    .forEachOrdered(System.out::println);
```

--------------------------------

### CSSselect.selectOne(query, elems, options)

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/css-select/README.md

Selects the first element from a list that matches the given CSS selector query. Returns the matching element or null if no match is found.

```APIDOC
## CSSselect.selectOne(query, elems, options)

### Description
Selects the first element from a list that matches the given CSS selector query.

### Parameters
#### Path Parameters
- **query** (string | function) - Required - The CSS selector string or a compiled function to match against.
- **elems** (array) - Required - The list of elements to search within.
- **options** (object) - Optional - Configuration options for the selection process.

### Returns
- object | null - The first element that matches the query, or `null` if no match is found.
```

--------------------------------

### Map Actors to Films

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/fetching-data/pages/stream-examples.adoc

Collects actors and their associated films into a Map. Use this to create a filmography where each actor is a key and their list of films is the value.

```java
Map<Actor, List<Film>> filmography = jpaStreamer.stream(of(Actor.class).joining(Actor$.films)) \
    .collect(
            Collectors.toMap(Function.identity(), \
                Actor::getFilms 
            )
    );
```

--------------------------------

### Stream Pipeline Rendering to JPA Query

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/how-it-works/pages/how-it-works.adoc

Illustrates a complex stream pipeline with multiple operators (filter, sorted, skip, limit) and its translation into an optimized JPA query.

```java
jpaStreamer.stream(Film.class)
    .filter(Film$.rating.equal("G").and(Film$.length.greaterThan(100)))
    .sorted(Film$.length.reversed().thenComparing(Film$.title.comparator()))
    .skip(10)
    .limit(5)
    .forEach(System.out::println);
```

--------------------------------

### Configure Spring Boot Application to Scan JPAStreamer

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/get-jpa-streamer/pages/spring_integration.adoc

Set the `scanBasePackages` parameter on the `SpringBootApplication` annotation to include 'com.speedment.jpastreamer' for component scanning.

```java
@SpringBootApplication(scanBasePackages={"com.speedment.jpastreamer"})
```

--------------------------------

### Extending Cheerio with Custom Plugins

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/cheerio/Readme.md

Extend Cheerio's prototype or `fn` property with custom plugin methods. This allows for reusable custom functionality.

```javascript
const $ = cheerio.load('<html><body>Hello, <b>world</b>!</body></html>');
$.prototype.logHtml = function () {
  console.log(this.html());
};

$('body').logHtml(); // logs "Hello, <b>world</b>!" to the console
```

--------------------------------

### Run Lunr.js Tests with PhantomJS

Source: https://github.com/speedment/jpa-streamer/blob/master/node_modules/lunr/CONTRIBUTING.md

Execute the project's test suite using PhantomJS. This is a common way to ensure code changes do not introduce regressions.

```bash
make test
```

--------------------------------

### Negating notStartsWith Predicate

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/predicates/pages/negating-predicates.adoc

Negating notStartsWith(p) results in the startsWith(p) predicate.

```java
startsWith(p)
```

--------------------------------

### SQL Query Parameters

Source: https://github.com/speedment/jpa-streamer/blob/master/README.adoc

The parameters corresponding to the generated SQL query. This array shows the values that will be bound to the placeholders in the SQL statement.

```text
["G", 10, 5]
```

--------------------------------

### Close a Stream

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/stream-fundamentals/pages/other_operations.adoc

Shows how to manually close a stream after its use to release resources. It also demonstrates the recommended try-with-resources pattern for automatic stream closure.

```java
Stream<String> stream = Stream.of("B", "A", "C", "B");
stream.forEachOrdered(System.out::println);
stream.close()
```

```java
try (Stream<String> s = Stream.of("B", "A", "C", "B")) {
    s.forEachOrdered(System.out::println);
}
```

--------------------------------

### Direct AND composition

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/predicates/pages/combining-predicates.adoc

Shows the direct composition of predicates within a single `filter` call using the `and()` method. This is the preferred and more optimized approach for combining conditions.

```java
jpaStreamer.stream(Film.class)
    .filter(Film$.length.greaterThan(120).and(Film$.rating.equal("PG-13"))
    .forEachOrdered(System.out::println);
```

--------------------------------

### Negating notStartsWithIgnoreCase Predicate

Source: https://github.com/speedment/jpa-streamer/blob/master/docs/modules/predicates/pages/negating-predicates.adoc

Negating notStartsWithIgnoreCase(p) results in the startsWithIgnoreCase(p) predicate.

```java
startsWithIgnoreCase(p)
```
Tokens:
Raw