Read Anytime Anywhere Easy Ebook Downloads at ebookmeta.

com

Beginning jOOQ: Learn to Write Efficient and

Effective Java-Based SQL Database Operations 1st
Edition Tayo Koleoso

https://ebookmeta.com/product/beginning-jooq-learn-to-write-
efficient-and-effective-java-based-sql-database-
operations-1st-edition-tayo-koleoso/

OR CLICK HERE

DOWLOAD EBOOK

Visit and Get More Ebook Downloads Instantly at https://ebookmeta.com

 Recommended digital products (PDF, EPUB, MOBI) that
you can download immediately if you are interested.

Beginning jOOQ: Learn to Write Efficient and Effective

Java-Based SQL Database Operations 1st Edition Tayo
Koleoso
https://ebookmeta.com/product/beginning-jooq-learn-to-write-efficient-
and-effective-java-based-sql-database-operations-1st-edition-tayo-
koleoso-3/
ebookmeta.com

Beginning jOOQ: Learn to Write Efficient and Effective

Java-Based SQL Database Operations 1st Edition Tayo
Koleoso
https://ebookmeta.com/product/beginning-jooq-learn-to-write-efficient-
and-effective-java-based-sql-database-operations-1st-edition-tayo-
koleoso/
ebookmeta.com

Effective SQL 61 Specific Ways to Write Better SQL 1st

Edition John L. Viescas & Douglas J. Steele & Ben G.
Clothier
https://ebookmeta.com/product/effective-sql-61-specific-ways-to-write-
better-sql-1st-edition-john-l-viescas-douglas-j-steele-ben-g-clothier/

ebookmeta.com

Runequest Cults of Runequest The Prosopaedia 1st Edition

Greg Stafford

https://ebookmeta.com/product/runequest-cults-of-runequest-the-
prosopaedia-1st-edition-greg-stafford/

ebookmeta.com
The 2021 International Conference on Machine Learning and
Big Data Analytics for IoT Security and Privacy:
SPIoT-2021 Volume 2 (Lecture Notes on Data Engineering and
Communications Technologies, 98) John Macintyre (Editor)
https://ebookmeta.com/product/the-2021-international-conference-on-
machine-learning-and-big-data-analytics-for-iot-security-and-privacy-
spiot-2021-volume-2-lecture-notes-on-data-engineering-and-
communications-technologies-98-j/
ebookmeta.com

Flame on You 1st Edition Taiden Milly

https://ebookmeta.com/product/flame-on-you-1st-edition-taiden-milly/

ebookmeta.com

Pocket Guide to Quilting Tips Tricks 4th Edition Haren

Penny

https://ebookmeta.com/product/pocket-guide-to-quilting-tips-
tricks-4th-edition-haren-penny/

ebookmeta.com

AWS Certified Solutions Architect Associate All-in-One

Exam Guide, Second Edition (Exam SAA-C02), 2nd Edition
Joyjeet Banerjee
https://ebookmeta.com/product/aws-certified-solutions-architect-
associate-all-in-one-exam-guide-second-edition-exam-saa-c02-2nd-
edition-joyjeet-banerjee/
ebookmeta.com

Sinners Fairytales 06 0 Lust Alexandra K Martin

https://ebookmeta.com/product/sinners-fairytales-06-0-lust-alexandra-
k-martin/

ebookmeta.com
On the Wandering Paths 1st Edition Sylvain Tesson

https://ebookmeta.com/product/on-the-wandering-paths-1st-edition-
sylvain-tesson/

ebookmeta.com
Beginning
jOOQ
Learn to Write Efficient and Effective
Java-Based SQL Database Operations
—
Tayo Koleoso
 Beginning jOOQ
Learn to Write Efficient
and Effective Java-Based SQL
Database Operations

Tayo Koleoso
Beginning jOOQ: Learn to Write Efficient and Effective Java-Based SQL
Database Operations
Tayo Koleoso
Silver Spring, MD, USA

ISBN-13 (pbk): 978-1-4842-7430-9 ISBN-13 (electronic): 978-1-4842-7431-6

https://doi.org/10.1007/978-1-4842-7431-6

Copyright © 2022 by Tayo Koleoso

This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or
part of the material is concerned, specifically the rights of translation, reprinting, reuse of
illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way,
and transmission or information storage and retrieval, electronic adaptation, computer software,
or by similar or dissimilar methodology now known or hereafter developed.
Trademarked names, logos, and images may appear in this book. Rather than use a trademark
symbol with every occurrence of a trademarked name, logo, or image we use the names, logos,
and images only in an editorial fashion and to the benefit of the trademark owner, with no
intention of infringement of the trademark.
The use in this publication of trade names, trademarks, service marks, and similar terms, even if
they are not identified as such, is not to be taken as an expression of opinion as to whether or not
they are subject to proprietary rights.
While the advice and information in this book are believed to be true and accurate at the date of
publication, neither the authors nor the editors nor the publisher can accept any legal
responsibility for any errors or omissions that may be made. The publisher makes no warranty,
express or implied, with respect to the material contained herein.
Managing Director, Apress Media LLC: Welmoed Spahr
Acquisitions Editor: Steve Anglin
Development Editor: Matthew Moodie
Coordinating Editor: Mark Powers
Cover designed by eStudioCalamar
Cover image by Josh Rose on Unsplash (www.unsplash.com)
Distributed to the book trade worldwide by Apress Media, LLC, 1 New York Plaza, New York, NY
10004, U.S.A. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail [email protected],
or visit www.springeronline.com. Apress Media, LLC is a California LLC and the sole member
(owner) is Springer Science + Business Media Finance Inc (SSBM Finance Inc). SSBM Finance
Inc is a Delaware corporation.
For information on translations, please e-mail [email protected]; for
reprint, paperback, or audio rights, please e-mail [email protected].
Apress titles may be purchased in bulk for academic, corporate, or promotional use. eBook
versions and licenses are also available for most titles. For more information, reference our Print
and eBook Bulk Sales web page at http://www.apress.com/bulk-sales.
Any source code or other supplementary material referenced by the author in this book is
available to readers on GitHub via the book’s product page, located at www.apress.com/
9781484274309. For more detailed information, please visit http://www.apress.com/
source-­code.
Printed on acid-free paper
Table of Contents
About the Author��������������������������������������������������������������������������������vii
About the Technical Reviewer�������������������������������������������������������������ix

Chapter 1: Welcome to jOOQ�����������������������������������������������������������������1

Database Operations in Java: The Good Parts������������������������������������������������������2
Database Operations in Java: The…Not So Good Parts����������������������������������������4
You Have Got to Be jOOQing����������������������������������������������������������������������������9
jOOQ Feature Tour�����������������������������������������������������������������������������������������������10
Database Aware���������������������������������������������������������������������������������������������11
Code Generation��������������������������������������������������������������������������������������������11
Type Safety����������������������������������������������������������������������������������������������������12
Domain-Specific Language���������������������������������������������������������������������������12
Tooling Support���������������������������������������������������������������������������������������������13
JVM Languages���������������������������������������������������������������������������������������������14

Chapter 2: Getting Started with jOOQ�������������������������������������������������15

Eden Auto Mart���������������������������������������������������������������������������������������������������19
Setting Up jOOQ��������������������������������������������������������������������������������������������������20
Install Dependencies for Commercial-Licensed jOOQ�����������������������������������22
CRUD with jOOQ��������������������������������������������������������������������������������������������������24
Your SQL Dialect and You�������������������������������������������������������������������������������25
Tools of CRUD in jOOQ�����������������������������������������������������������������������������������28

iii
Table of Contents

Select Statements�����������������������������������������������������������������������������������������34
Insert Statements������������������������������������������������������������������������������������������63
Update Statements����������������������������������������������������������������������������������������66
Delete Statements�����������������������������������������������������������������������������������������67
Alternative Data Access Modes���������������������������������������������������������������������69
Transactions��������������������������������������������������������������������������������������������������������73
With Locking��������������������������������������������������������������������������������������������������76
Configuration������������������������������������������������������������������������������������������������������78
Connection Management�������������������������������������������������������������������������������79
Schema, Catalog, and Multi-tenant Deployment�������������������������������������������81
Query Management���������������������������������������������������������������������������������������84
Query Lifecycle Integration����������������������������������������������������������������������������86

Chapter 3: Working with jOOQ������������������������������������������������������������89

Generating Code�������������������������������������������������������������������������������������������������89
Tools of jOOQ Code Generation����������������������������������������������������������������������90
Working with Generated Code��������������������������������������������������������������������������109
CRUD with Generated Code�������������������������������������������������������������������������109
Advanced Database Operations������������������������������������������������������������������������117
Joins������������������������������������������������������������������������������������������������������������117
Batch Operations�����������������������������������������������������������������������������������������128
Advanced Query Syntax�������������������������������������������������������������������������������137

Chapter 4: Integrating with jOOQ������������������������������������������������������145

Java Persistence API with jOOQ������������������������������������������������������������������������146
Generate JPA Entities����������������������������������������������������������������������������������147
Generate from JPA Entities��������������������������������������������������������������������������151
Generate SQL Queries���������������������������������������������������������������������������������153

iv
 Table of Contents

Spring Boot and jOOQ���������������������������������������������������������������������������������������162

Configure jOOQ in Spring Boot���������������������������������������������������������������������163
Quarkus and jOOQ���������������������������������������������������������������������������������������������168

Chapter 5: Packaging and Testing jOOQ�������������������������������������������173

Package Code with jOOQ����������������������������������������������������������������������������������174
When You Don’t Need Code Generation�������������������������������������������������������175
When You Don’t Have an Active Database Connection��������������������������������177
When Your Schema Needs to Incrementally Evolve������������������������������������178
Testing with jOOQ����������������������������������������������������������������������������������������������185
Tools of the (SQL) Testing Trade�������������������������������������������������������������������187
Unit Testing with jOOQ���������������������������������������������������������������������������������191
Integration Testing with Docker and TestContainers�����������������������������������198

Index�������������������������������������������������������������������������������������������������211

v
About the Author
Tayo Koleoso is the Founder and CEO of
LettuceWork (www.lettucework.io), the
platform dedicated to engineering culture.
He created the Better Managed Development
method for building and sustaining an effective
product engineering culture. He's a lifelong
learner, engineer, and engineering leader
committed to building people and software in
a healthy, sustainable, and effective ecosystem.
Outside of tech, comedy is the only thing he
consumes in large quantity. King of the Hill,
Peep Show and 30 Rock are his comfort telly,
I tell you what.
He got his start in software engineering as a teenage database
programmer with Oracle 8i. The jOOQ platform is therefore a natural fit and
a return to his roots: his love affair with SQL.

vii
About the Technical Reviewer
Vishwesh Ravi Shrimali graduated in 2018
from BITS Pilani, where he studied mechanical
engineering. Currently, he is working at
Mercedes Benz Research and Development
India Pvt. Ltd. as an ADAS Engineer. He has
also co-authored Machine Learning for
OpenCV 4 (Second Edition), The Computer
Vision Workshop, and Data Science for
Marketing Analytics (Second Edition) by Packt.
When he is not writing blogs or working on
projects, he likes to go on long walks or play
his acoustic guitar.

ix
CHAPTER 1

Welcome to jOOQ
I got my start in software engineering (and really, serious computer business)
at 15 years old, with Oracle 8i SQL. Yes, I’ve been an old man from a young
age, technologically speaking. Playing with SQL* Plus, trying (and failing) my
first Oracle SQL certification exam, before I even started university, taught me
the value of getting SQL right. Don’t take it from me, take it from this chap:

I was a data access purist: I like my DAOs chilled, my

PreparedStatements prepared, and my SQL handwritten with
the care and tenderness of a lover... The world moved on to
Hibernate, Java Persistence API (JPA), and everything in
between... I still believe in raw SQL – a well-crafted SQL state-
ment will outperform Object-Relational Mapping (ORM).
—A tall, dark, dashing young and cool man, with flowing
locks of jet black hair and piercing brown eyes1

That tall drink of SQL? Probably me; I don’t know. The point is I deeply
appreciate Structured Query Language (SQL) and all it has to offer. The
industry’s been going gaga about NoSQL because it’s “easy to use” and it
“scales quickly,” but the fact of the matter is that SQL is still the undisputed
king of Online Analytical Processing (OLAP). When you want sanity
and integrity in your data, SQL is there. When you want (most of 2) the

1
Editor’s note: Oh brother. Here we go again.
2
 I say “most of” here because different Relational Database Management Systems
provide varying degrees of ACID strength.

© Tayo Koleoso 2022 1

T. Koleoso, Beginning jOOQ, https://doi.org/10.1007/978-1-4842-7431-6_1
Chapter 1 Welcome to jOOQ

guarantees of reliable transaction handling (à la ACID), you’re still going to

need solid SQL in your stack. Not for nothing, database stored procedures
will typically outperform application-layer (e.g., Java, .Net) processing in
many cases. In the words of the late, great Thanos: “SQL is inevitable. It’s in
the interests of your application’s scalability and correctness to get it right.”
Unfortunately, SQL gets very short shrift from devs nowadays. The
database is just another “black box” that we’re supposed to yell commands
at, so it yields some data and then we move on. It’s not until our queries
progressively degrade due to preventable problems; our schema is an
incoherent mess after two versions of our applications; SQL injection
attacks expose our weaknesses; the application chokes on queries
returning more than a few hundred rows. One of the dark sides of SQL is
that you’re not likely to realize that your SQL query is returning incorrect
or incomplete data at first glance. You ran a query, it returned some
queries, and that’s that, right? Yikes.
This book isn’t about the fundamentals of SQL. Or even the joys of
SQL per se (there are many). This book is about taking a different look at
handling SQL work in Java.

 atabase Operations in Java: The Good

D
Parts
Your options for handling SQL data in the Java world are fairly
straightforward:

1. JDBC (Java Database Connectivity): JDBC is the

most fundamental API supporting Relational
Database Management System (RDBMS) access. It
provides

• Connection management

• Direct SQL statement control

2
 Chapter 1 Welcome to jOOQ

• Stored procedure and function execution

• Mostly SQL injection safe componentry

• Transaction management

Save for one or two JakartaEE specifications, pretty

much everything else RDBMS related in the Java
ecosystem is based on JDBC. Because of JDBC, we
can then have…

2. Mapping Frameworks: Yes, I’m talking about

Object-Relational Mapping (ORM) frameworks
like Hibernate, MyBatis, and EclipseLink. These
are très convenient frameworks, based on the
premise that developers don’t want to spend any
time…developing SQL or other database-related
constructs. Neato. With these mapping frameworks,
you get to define some classes, slap some
annotations on them and the framework:

• Maps your java classes (the object model) to your

database tables (the domain model). This mapping
is used to convert query results into java objects,
known as entities. These entities are managed
objects – like a concierge service – changes to the
entities in memory are tracked and persisted by the
ORM runtime.

• Allows you to declaratively model the relationships

between your tables in your RDBMS, using java
object relationships (is-a, has-a type stuff ). An
absolute cornucopia of annotations supports this
feature of ORMs.

3
Chapter 1 Welcome to jOOQ

• Completely spares you of any details related to the

SQL involved in all this magic. It just works.

• Provides declarative transaction handling – with

more annotations.

• Provides an additional query language, Hibernate

Query Language (HQL), that introduces an object-­
oriented flavor to the mix. This way, you can
abandon SQL altogether (!) and just speak fluent
OOP all the time!

Most ORM providers offer some form of caching of the results of

database queries. The goal here is to save the travel time to the database
for subsequent trips to the database. So that when one user loads some
data once, if they request the same rows, it’s already in memory.
Then we have the Java Persistence API (JPA). This is a JakartaEE
specification that attempts to standardize the usage and behavior of ORMs
in the Java platform. The various providers (Hibernate, etc.) implement
this specification to varying degrees. They each also have implementation-­
specific syntactic sugar that isn’t supported by the API. The API still allows
you to write your raw SQL if you like, and the results can still be managed
objects. Pretty neat.
In addition to all this, a framework like Spring offers the JdbcTemplate
as a wrapper around JDBC proper. SQL in the Java system is just one raging
party of convenience. Nice!

 atabase Operations in Java: The…Not

D
So Good Parts
Ask yourself this: why aren’t JavaServer Pages (JSP) and JavaServer
Faces (JSF) as wildly popular as, say, React.js or Vue.js, when front-end
development is concerned? A lot of Java-based organizations are happy to

4
 Chapter 1 Welcome to jOOQ

have Java or Kotlin Spring Boot back ends, but fronted by not Java. Because
when you care about performance and resource efficiency in a domain like
the browser, nothing beats raw JavaScript.
And I say this as someone that’s spent a fair bit of time teaching about
JSF and answering questions on StackOverflow. Don’t get me wrong: JSF
is super convenient. Heck, that’s why I got into the business of JSF in the
first place: a cheap, convenient, and practical way to belch out markup and
scripting into a web page. But when no one’s watching, I know. I know that
raw JavaScript is still where it’s at. If you want to make your browser dance,
deal with the quirks and nuances of individual browsers, you turn to the
language invented for browsers. These hips stylesheets don’t lie.
Yet here we are, where many have decided that SQL should take a
backseat when interacting with databases. Park the language built for the
platform in the garage; Java, the language of kings, is preferable. In many
scenarios, it isn’t. Here are some reasons why:

1. JPA isn’t aware of what type of database you’re

using, which is a shame, when you consider that
there are specific quirks, features, and limitations of
individual databases, for example:

• MySQL doesn’t support the INTERSECT or EXCEPT

set operations; FULL JOIN is also off the menu. You
wouldn’t know until you tried to use it and your
operation chokes.

• JPA doesn’t know what to do with nulls in the ORDER

BY clause; there’s also no support for the ORDER BY
NULLS FIRST clause from standard SQL.3 You’re on
your own here.

3
 Coming soon with Hibernate 6: https://docs.jboss.org/hibernate/orm/6.0/
userguide/html_single/Hibernate_User_Guide.html#hql-order-by

5
Chapter 1 Welcome to jOOQ

• JPA doesn’t deal well with the IN clause in some

scenarios:

• When you want to take advantage of query plan

caching

• When there are nulls in the list of parameters

passed to the IN clause

• PostgreSQL supports a massive array of data types

that are hyper-specific and hyper-optimized to
some use cases. There’s a wide assortment of data
types you can leverage in this RDBMS that you will
have to do a bunch of extra work to support with
UserTypes in Hibernate.

• Many of the mainstream database providers

(Oracle, PostgreSQL, and MySQL at least) provide
document storage and SQL querying – that’s
right, you can save your JSON documents in
these databases, query, and navigate inside the
documents with SQL. Basically combine NoSQL
and SQL in the same box. Some benchmarks have
shown the performance to be comparable to the
likes of MongoDB up to certain scales. These aren’t
your grandmother’s RDBMSes.

“But I want to make my application portable.” Your

enterprise has spent borderline sinful sums of money
on an Oracle license, but you’re going to use like 5% of
its capabilities, like a really fancy Excel spreadsheet?

6
 Chapter 1 Welcome to jOOQ

2. Even with native query capabilities, neither JPA nor

Hibernate will save you from yourself. Your raw SQL
is still open to SQL injection if you make the right
mistakes. Your SQL could still be incorrect, and you
won’t find out until you try to execute the native
query. Java Persistence Query Language (JPQL)
and Hibernate Query Language (HQL) aren’t going
to save you either. You won’t find out your query
syntax is broken or incorrect until you try to run it.
And if you accidentally make changes to a managed
JPA entity, it’s going to be committed to the database
the first chance it gets.

3. Remember the caching that Hibernate and other

tools will do for you by default? Guess whose RAM
is slowly being devoured? Go on, guess. You might
be surprised to find out that every entity retrieved
and managed by a single hibernate session is
cached – for just that hibernate session – so that in
a large enterprise application with any number of
concurrent users, they’re all liable to hold copies
of exactly the same data in RAM of the application
server. Imagine how thirsty your application will get
at scale!

4. Can you confidently say you know what’s going

on inside of Hibernate or EclipseLink? Have
you tried to look at the actual queries being
generated by Hibernate? You might be in for a lot of
disappointment. There are many scenarios where
Hibernate is simply wasteful with database trips that
are hidden from view:

7
Chapter 1 Welcome to jOOQ

• Batch inserts and updates aren’t enabled by

default, and you’re going to do a bit of work to fully
support both.

• Even more specifically, using GenerationType.

IDENTITY with PostgreSQL and some others,
Hibernate will still ignore any batching directives.4
5. The challenges of an ORM really get in your face
when you need to scale. A couple rows, maybe a
couple hundred, and you could skate by. Larger
result sets, on the other hand, are sometimes not
practical (see the previous discussion: loading all
retrieved entities into memory). You could struggle
to handle an increase in query volume. JPA 2.2
introduced support for more efficient streaming
from the database; but again different kinds of
databases handle this feature differently. So that
despite your best efforts, MySQL and PostgreSQL
could still very well retrieve the entire ResultSet,5
ignoring your JPA 2.2 expectations of efficient results
streaming.

6. Fundamentally, ORM as a concept is at odds with

relational data representations. The technical name
for it is the Object-Relational Impedance Mismatch.
Don’t take it from me; ask the nerds at Hibernate
themselves6:

4
https://vladmihalcea.com/postgresql-serial-column-hibernate-identity/
5
https://vladmihalcea.com/whats-new-in-jpa-2-2-stream-the-result-of-
a-query-execution/
6
http://hibernate.org/orm/what-is-an-orm/

8
 Chapter 1 Welcome to jOOQ

The way you access data in Java is fundamentally different

than (sic) the way you do it in a relational database. In Java,
you navigate from one association to another walking the
object network. This is not an efficient way of retrieving data
from a relational database. You typically want to minimize
the number of SQL queries and thus load several entities via
JOINs and select the targeted entities before you start walking
the object network.
Point is that past a certain point, you’re either going to be dealing with
a mess of annotations and a hopelessly complex entity class graph, or
you’re going to need to roll up your sleeves and get SQL-y.
You can’t avoid writing SQL if you’re going to do data access correctly
in Java. This isn’t a dig at the gang over at Hibernate; that framework
is a dang miracle for many use cases. But we’re not here to talk about
Hibernate, are we?

You Have Got to Be jOOQing

Yes, I’m here to give you the good news of the jOOQ framework. First
things first: jOOQ is not a complete replacement for Hibernate, JPA, or
anything in that realm. JPA delivers on its goals of standardizing most
of RDBMS access for Java developers. Hibernate is hella powerful and
convenient; particularly for write operations, you can ORM to your heart’s
content and delight. I mean, what can beat the convenience of simply
updating a field of a java object and persist-ing or flush-ing?
For adult-tier, large-scale SQL data wrestling? Where there are a lot of
read operations? You’ll need the big guns. jOOQ is as big a gun as you’ll
get in this business of ours. Don’t take it from me, take it from an actual
ORM expert:

9
Chapter 1 Welcome to jOOQ

How about this chap:

…But while abstracting the SQL write statements is a doable

task, when it comes to reading data, nothing can beat native
SQL...native querying is unavoidable on almost any enterprise
system...While you can fire native queries from JPA, there’s no
support for dynamic native query building. jOOQ allows you to
build typesafe dynamic native queries, strengthening your
application against SQL injection attacks. jOOQ can be inte-
grated with JPA, as I already proven on my blog, and the JPA-
jOOQ combo can provide a solid data access stack.
—Vlad Mihalcea7

Vlad was a contributor to the Hibernate platform and continues to

support his own query performance optimizer, and he’s an authority on
the relationship between Java and relational databases. Cheers to that.
If you think of JPA and its implementations as being too Object-­
Oriented Programming (OOP) friendly, jOOQ seeks to bring a balance to
the force. Providing strong awareness of the nuances of safe, effective, and
efficient SQL handling, all the while maintaining a solid grip on the object-­
oriented side of things. So what’s in the jOOQ box?

jOOQ Feature Tour

Alright, gather round everyone8! Let me sing you the song of my people
jOOQ. Ohhh, this is a tale of…

7
 https://blog.jooq.org/2015/04/14/jooq-tuesdays-vlad-mihalcea-gives-
deep-insight-into-sql-and-hibernate/
8
 Editor’s note: How many people do you think are concurrently reading a single
copy of your book?

10
 Chapter 1 Welcome to jOOQ

D
 atabase Aware
jOOQ is unapologetically RDBMS vendor aware.9 Unlike those other guys,
jOOQ provides API kits built specifically for a wide range of major database
vendors. This way, when you’re using jOOQ tools and APIs, you can be
sure you’re idiomatically correct; the syntax and semantics of your code is
transparently optimized and tightly mated with your database of choice.
And the delightful part of this is that it doesn’t translate to a tight coupling
to your Java code. Because jOOQ skews closer to the database, your Java
code can still remain technically database agnostic; your jOOQ library
implementation will quietly handle the finer details and nuances of your
specific database of choice. You can then quite easily flip a configuration in
jOOQ to support another, should you choose to switch databases.

C
 ode Generation
jOOQ is all about convenience when it comes to the developer experience.
Observe.
Starting with any one of the following:

• Existing database schema

• Database table

• Stored procedure or function

• Sequence

• JPA entity

• XML file

9
www.jooq.org/download/support-matrix

11
Chapter 1 Welcome to jOOQ

• Plaintext file containing SQL

• Liquibase YAML, XML, or JSON file

• Custom data types

jOOQ will generate java classes, JPA-annotated entity classes,

interfaces, or even XML that correctly maps what is represented in the
source material. If you’re starting with stored procedures or functions,
jOOQ will generate “routines”: classes that represent that database code,
making it as convenient as physically possible to use what’s already
available.

Type Safety
All the entities, data, and fields you’ll be working with are typesafe –
guaranteed correct. The fields from your database tables, bind variables
from your stored procedures and functions, etc. are translated to the
closest match available in Java.

Domain-Specific Language
jOOQ provides a DSL that mirrors the specific SQL dialect that’s
implemented by your choice of database vendor. Even beyond that, the
library integrates the quirks and non-standard features of the supported
database vendors. You know the ones, the bad boy databases (looking at
you, Oracle). This compile-time checking of your SQL syntax means that
you’ll have to go out of your way to write broken or otherwise unsupported
SQL. No more waiting till runtime to find out your SQL doesn’t compile!

12
 Chapter 1 Welcome to jOOQ

Tooling Support
You also get a robust toolkit to support a lot of developer convenience and
safe usage of the library:

• Maven: jOOQ offers configurable Maven plugins and

tools to support a variety of tasks around the code
generation feature.

• Command Line: Also supports the powerful code

generation feature of jOOQ. Additionally, there’s a
Schema Diff feature that helps compare two schemata
and output the difference.

• Flyway and Liquibase: You can use the two most popular
DML and DDL version control libraries with jOOQ.

• Raw SQL Vendor Safety: Should you opt to not use

the SQL DSL, instead choosing raw SQL, you can use
jOOQ’s Parser anywhere in your code to ensure that
the SQL you’re writing is correct and valid for the
selected database.

• SQL Disabler: The PlainSQLChecker allows you to

disable support for raw SQL anywhere in your project.
Drop it in your Maven POM.xml and it’ll disallow
compilation of any raw SQL in your project. This way,
you can guarantee that anyone that’s working on your
project or codebase will have to use jOOQ-generated
code and jOOQ’s fluent API; eliminating the probability
of incorrect SQL creeping into the code.

13
Chapter 1 Welcome to jOOQ

JVM Languages
We get to take the jOOQ box on tour! You can use jOOQ with

• Kotlin

• Scala

• Groovy

This has been a 50,000 ft. flyover of jOOQ and what it brings to the
table. I want to stress here that jOOQ isn’t a replacement for ORM – the
right tool for the right job, etc. Where Hibernate, etc. don’t give you the
coverage you need, that’s where jOOQ swings into action.
So! Whaddya think so far? Pretty neat, huh? I’ll just catch my breath for
a moment here, and see you in the next chapter!

14
CHAPTER 2

Getting Started
with jOOQ
Let’s take this thing for spin! But first, you should get to know these classes
and interfaces; they’re at the heart of 75% of what you’ll be doing in jOOQ:

1. org.jooq.impl.DSL

This is the sturdy, wise grandparent of most of

jOOQ’s functionality. With this class, you can

• Manipulate parts of a strongly typed SQL query in a

typesafe manner.

• Access database functions (concat, coalesce, etc.)

as if they were java methods.

• Specify database dialects. This is for when you need to

perform operations that are unique to your datastore
(Oracle, Amazon Redshift, PostgreSQL, etc.).

• Carry out Database Definition Language (DDL)

operations like ALTER, CREATE, DROP, etc., all in a
typesafe manner.

• Perform more mundane tasks like

• Constructing plaintext SQL

• Configuring the database connections

© Tayo Koleoso 2022 15

T. Koleoso, Beginning jOOQ, https://doi.org/10.1007/978-1-4842-7431-6_2
Chapter 2 Getting Started with jOOQ

Almost all of its functionality are static methods in

the class, so you’ll typically just need to perform an
import static org.jooq.impl.DSL.* to use its
features.
2. org.jooq.DSLContext

Where DSL offers almost all its functionality in

static methods without state, DSLContext is more
object oriented. There’s some overlap between
this component and the DSL class, but there’s a
fundamental difference. It’s really in the name DSL:
Domain-Specific Language Context. Keeping state
in a context object provides runtime capabilities that
you’re not going to get from DSL – comes in handy
when your SQL operation is a multi-­step one or is
part of a longer process. Overall, DSLContext offers

• Fluent programming style

• Stateful components

• Better integration with dependency injection

frameworks like Spring (more on that later)
The fluent programming style of DSLContext is
remarkable. This isn’t your standard builder-­pattern
style chain of method calls. This is a true DSL
that will prevent you from accidentally (or even
purposefully) constructing incorrect SQL. Each
method call in the chain is possible only if the
previous method call will correctly support it. Truly,
you’ll need to work super hard to construct incorrect
SQL in jOOQ. Because the DSLContext usage is
mostly stateful, you’ll need to be more conscious of
thread safety when using this class.

16
 Chapter 2 Getting Started with jOOQ

3. org.jooq.conf.Settings

The Settings class will let you further customize

your jOOQ context with simple, straightforward
parameters that change the behavior of the API. An
instance of this class can help you control factors like

• The kind of JDBC Statement that’s jOOQ uses – a

regular Statement or a PreparedStatement.1
• Mapping different schemas in same jOOQ context.

• Controlling the logging of SQL statements being

executed by jOOQ.

• Disabling support for Java Persistence API (JPA)

annotations, for a slight performance improvement.

• Configuring the behavior of jOOQ’s internal SQL

parser – for example, to set it up for a specific SQL
dialect. This would apply if you’re using jOOQ to
process raw SQL strings instead of its typesafe options.

• Configuring JDBC-specific options like

queryTimeout and maxRows.
• Configuring batch size for batch operations.

4. org.jooq.Configuration

The Configuration class contains the core

configuration items that control how your jOOQ
runtime behaves. Configuration is responsible

1
Unlike with standard usage of PreparedStatement vs. Statement, you’re at no
greater risk of SQL injection by selecting one or the other in jOOQ. The difference
here is largely performance related, where PreparedStatement queries are
cacheable by the RDBMs.

17
Chapter 2 Getting Started with jOOQ

for managing your database connection, plugging

into the jOOQ engine to customize its behavior on
a broader scope than just individual SQL queries.
org.jooq.Configuration provides methods that
allow you to plug in custom code that can replace or
support standard jOOQ functionality altogether.

5. org.jooq.meta.jaxb.Configuration

You’ll be using this class to control the code

generation feature of jOOQ. It’s a direct analog of
a jOOQ configuration file named library.xml.
Generating java representations of your database
tables, rows, columns, stored procedures, etc. is a
major feature of the jOOQ platform, and I’m looking
forward to getting to that part of this book! Yes: org.
jooq.Configuration vs. org.jooq.meta.jaxb.
Configuration could lead to some awkwardness.

Which import statement is wearing it best? Trick question: it’s Becky.

18
 Chapter 2 Getting Started with jOOQ

Eden Auto Mart

I’m going to use a car dealership as the background for all the examples
that I’ll be showing throughout this book. Eden Auto is a car dealer that
sells new and used cars via a web portal so that customers can
• Search for cars by many different attributes of the
vehicle itself

• Search across brands of vehicle

• Search across a price range

On the back end, the staff of Eden Auto can

• Upload cars for sale

• Update existing prices and other attributes

• Remove cars from the inventory

• View existing inventory

• Search the inventory for cars by many attributes

We’re going to use a relatively simplified data model here just for the
purpose of demonstrating specific jOOQ features. Here’s what that looks like.

19
Chapter 2 Getting Started with jOOQ

To help run some of the examples in this book, you can bootstrap with
the database definition that comes with the code sample attached to this
book.

Setting Up jOOQ
To start, you’ll need to reckon with the particulars of the RDBMS you’re
going to be working with. A lot of the beauty of jOOQ is how it allows you
to use pretty much any database with tons of convenience. Features that
aren’t available in your chosen database can be emulated transparently by
the jOOQ API. For this book, I’ll be doing most of the demonstrations with
MySQL, with some detours into the some other popular databases every
now and then.

20
 Chapter 2 Getting Started with jOOQ

I’ll need MySQL’s Connector/J database driver as a dependency:

<dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql-driver-version}</version>
</dependency>

On to the actual setup of jOOQ, where things get a little…interesting.

See, jOOQ is offered as both free and commercial software – a dual
licensing model. The license model determines (among other things)
• The SQL dialects you can use in your application
• The way you set jOOQ up in your project
For the free version of jOOQ, it’s a straightforward maven entry,
because it’s publicly available in the global Maven repo:

<dependency>
    <groupId>org.jooq</groupId>
    <artifactId>jooq</artifactId>
    <version>3.15.1</version>
</dependency>
<dependency>
    <groupId>org.jooq</groupId>
    <artifactId>jooq-meta</artifactId>
    <version>3.15.1</version>
</dependency>
<dependency>
    <groupId>org.jooq</groupId>
    <artifactId>jooq-codegen</artifactId>
    <version>3.15.1</version>
</dependency>

21
Chapter 2 Getting Started with jOOQ

Simple enough, yes? Bueno. When you’ve paid for the commercial
version however, things get a bit more manual. Here’s how.

Install Dependencies for Commercial-Licensed

jOOQ
The dependencies for the commercial2 version of jOOQ aren’t available in
public repositories because, well, they’re not free and thus not available
for public download. To get the commercial version (or a trial), visit www.
jooq.org/download/versions to download the version that matches your
version of Java.

<screenshot of versions page>

Once you’ve plugged in your particulars, you’ll be prompted to

download a zip file containing

• Sources

• Compiled JARs

• Helper scripts

There are two helper scripts in the zip file:

• maven-deploy

• maven-install

Both helpers do the same thing with different targets: build and install
the jOOQ jars into repositories. maven-deploy will set up the jOOQ JARs
in a remote repository, so reach for that to set up the JAR in a central

2
Commercial = Express, Professional, and Enterprise licenses

22
 Chapter 2 Getting Started with jOOQ

Artifactory or similar dependency repository. For a local maven repository,

reach for the maven-install script and you’re sorted. After all this scriptin’
action, you can then add commercial jOOQ to your project like so:

<dependency>
   <groupId>org.jooq.pro</groupId>
   <artifactId>jooq</artifactId>
   <version>3.15.1</version>
</dependency>
<dependency>
   <groupId>org.jooq.pro</groupId>
   <artifactId>jooq-meta</artifactId>
   <version>3.15.1</version>
</dependency>
<dependency>
   <groupId>org.jooq.pro</groupId>
   <artifactId>jooq-codegen</artifactId>
   <version>3.15.1</version>
</dependency>

It’s the same artifactId as the free version, but with a different
groupId:org.jooq.pro. You can use a trial license for the commercial
version of jOOQ by using org.jooq.trial for the groupId. The open
source version is just as functional for many use cases, but with limited
database vendor support and fewer features.3 Also noteworthy that jOOQ’s
JDK support starts from JDK 6, all the way up to the latest (17, as at the
time of this writing). The older JDK versions are supported only with the
paid version.

3
www.jooq.org/download/#feature-comparison

23
Chapter 2 Getting Started with jOOQ

Tip The trial version of the commercial jOOQ distribution will print
a message indicating that yes, you are indeed on a trial version of
the commercial jOOQ distribution. But rejoice, oh ye trial version
users, for jOOQ is effective as it is generous: set the org.jooq.
no-logo=true JVM property to disable the trial license warning
message.

And that’s it! jOOQ is set up in your project. Now to do stuff with it…

CRUD with jOOQ

With your jOOQ JARs in place, database driver configured, we now should
start using this bad boy. We’re going to need to acquire connections, load
the driver, etc. If you haven’t done database work in Java before now, I’m
going to show you how the least cool way to do it in Java:

try(Connection connection = DriverManager.

getConnection("jdbc:mysql://localhost/test?user=testuser&
password=thisisaterriblepassword")){
      //more to come
}catch(SQLException sqlex){

The goal of the preceding snippet is to acquire a database connection;

jOOQ can take care of everything following that. jOOQ on its own isn’t
too particular about how you acquire the connection if you follow some
established commonsense principles. This isn’t a particularly great way
to do connection acquisition in a modern application. You should be
using the javax.sql.Datasource class and connection pools instead of
manually wrangling connection drivers. But more on that later. For now,
we have a database connection, and thus it’s time to start jOOQin’.

24
 Chapter 2 Getting Started with jOOQ

Remember DSL and DSLContext are the primary entry points into
the jOOQ ecosystem.

Fundamentally, most jOOQ operations will begin with some variation

of the following:

DSLContext context = DSL.using(connection,SQLDialect.MYSQL);

In the preceding sample

• I supply the JDBC connection object (how I obtained

the connection isn’t important for now).

• And I supply a dialect from the SQLDialect enum to

pass to the DSLContext.

According to the manufacturer, DSLContext isn’t always guaranteed to

be thread safe – it is a context object after all. However, if you personally
take sensible precautions, you could enjoy thread safety with this class.
Having provided DSLContext with a valid JDBC connection, you can now
get into the nitty-gritty of Create, Read, Update, and Delete (CRUD). But
first, a word from our sponsors…

Your SQL Dialect and You

While it’s not mandatory to set a SQL dialect on your DSLContext, it’s ideal
you do. See, RDBMSes have many different quirks as I’ve already covered.
Some of them are glaring and easily detectable. Other more trivial ones
can trip you up unexpectedly. Take my choice of MySQL database, for
example:

• Identifier Style: You might already be aware that

different databases use different quote styles for
identifiers. Because of this, standard SQL will have

25
Chapter 2 Getting Started with jOOQ

select "e"."first_name", "e"."last_name" from

"employees" "e"

but MySQL has4

select `e`.`first_name`, `e`.`last_name`  from

`employees` `e`

Backticks, instead of double quotes. This isn’t to say

that you’ll be denied a lot of functionality without
specifying a dialect. Au contraire, jOOQ will routinely
go out of its way to emulate features that are supported
natively by one or two databases but not by others, for
example:

• Returning Keys: A SQL INSERT... RETURNING in

PostgreSQL will return with the generated keys of the
rows that have been inserted, and it’s immediately
available because of the insert operation. This is
provided for by the SQL standard but isn’t uniformly
supported by databases. Among those that do, the
implementation details vary. jOOQ can emulate this
feature for you, regardless of the kind of database
you’re using. Fair warning here: depending on the kind
of support your database has for it, jOOQ may be forced
to silently initiate a second SELECT trip to the database
to retrieve the generated keys.

4
You can control this behavior by configuring the ANSI_QUOTES option
for MySQL (https://dev.mysql.com/doc/refman/8.0/en/sql-mode.
html#sqlmode_ansi_quotes).

26
 Chapter 2 Getting Started with jOOQ

• Dummy Tables: Different SQL databases allow you to

select from dummy tables in different ways. Oracle has
the famous DUAL table, for example. Sometimes, you
just want to run some functions, but then your RDBMS
requires you to specify a FROM clause – without offering
a dummy table. jOOQ supports select statements
without from clauses so you can do whatever sorcery
you like, with or without a dummy table.

If you don’t specify any dialect, you’ll get the default SQLDialect.
DEFAULT and then via con Dios!5

Caution For your own peace of mind, go ahead and configure the
org.jooq.conf.Settings.backslashEscaping property on
your Settings object. MySQL and some versions of PostgreSQL
support non-standard escape characters that can cause you a lot of
grief when you least expect it. This property lets jOOQ properly handle
this “feature” from MySQL.

5
Lukas: If you provide DSL.using(connection), then jOOQ will try to “guess”
the appropriate SQLDialect from the JDBC DatabaseMetaData – https://docs.
oracle.com/javase/7/docs/api/java/sql/DatabaseMetaData.html

27
Chapter 2 Getting Started with jOOQ

And that has been the word from our sponsors!

Thank you for reading!

Okay, let’s now get into…

Tools of CRUD in jOOQ

jOOQ offers a lot of fine-grained control of the entirety of a SQL
statement – really, an insane amount of control at your fingertips.
Starting from a pretty high level, I’m going to go over some of the key
components that you’re going to need to get familiar with if you’re going
to CRUD with jOOQ:

1. org.jooq.Query

This is the fundamental unit of a SQL query in

jOOQ-land. It extends org.jooq.Statement along
with the jOOQ representations of other executable

28
 Chapter 2 Getting Started with jOOQ

database units of work like stored procedures and

functions. You can use it to execute

• Plaintext SQL that you pass in as an argument

• Strongly typed SQL fragments constructed using

the jOOQ API

It can help you convert a manually derived plaintext

SQL to a jOOQ DSL-typed SQL object and vice versa.
It’s the quintessential representation of a SQL query;
use it to execute SQL statements when you don’t
need a return value from the operation (like Data
Manipulation Language operations).

2. org.jooq.ResultQuery

This class is basically org.jooq.Query, but you can

obtain return values from it, like query results. Some
notable qualities of this class:

• It’s efficient in that it doesn’t need an active

database connection to provide access to its
results – once the query has been successfully
executed, the connection can be discharged, and
you can interrogate your instance of this class for
all the query results.6 This is useful when you are
resource conscious and want to protect against
long-running transactions. Compare this feature to
detached hibernate entities.

6
Lukas: It’s time to deprecate that ancient feature of the mutable ResultQuery!
This won’t be available in the future anymore. In the future, only
ResultQuery::fetch and similar methods should be used.

29
Chapter 2 Getting Started with jOOQ

• It provides typed or untyped result fetching,

comparable to what you get with the Spring
JdbcTemplate.
• It maps to custom Plain Old Java Objects (POJOs).
• It supports lazy fetching of query results using an
underlying database cursor. If you go this route,
be mindful that it depends on maintaining the live
database connection.
• It supports reactive programming.
• It supports streams via the java.util.stream.
Stream interface.
All told, it provides a very flexible interface for
wrangling query results. It’s as powerful as anything
you’ll get with Hibernate or JPA, with much less
verbosity than what JDBC would put you through for
the same outcomes.
3. org.jooq.QueryPart
On its own, not too powerful. But it’s the parent type
of a large suite of classes that help you construct
complex queries dynamically. Compare this class to
the CriteriaBuilder in JPA or the Specification from
Spring Data JPA. To be clear, this API is exorbitantly
richer than either of what JPA or Spring Data provide.
Pretty much every fragment of the SQL standard
specification can be represented as variant of org.
jooq.QueryPart, for example:
• Field to represent a field that can be used
anywhere, in any kind of SQL statement
• Condition to represent predicates like WHERE, HAVING

30
 Chapter 2 Getting Started with jOOQ

• SQL to represent a whole SQL statement or fragment

• Table to represent a whole table, wherever a table is

needed in your query

• Row to represent tuples (or in layman’s terms,

something like a row of a table)

• Field to represent…yes, a column

• Constraint to represent a database constraint, as

part of a DDL operation

• Schema to represent the schema part of any SQL

query

This is a small sampling of the level of granularity

that QueryPart can get to. Heck, there are even more
specialized versions of each of these that offer specific
advantages. If you’ve ever dreamed of being able to
support a powerful dynamic filter as part of a search
function, but without concatenating strings of ugly
plaintext SQL all over the place, this is where you
want to be.
You get powerful and reusable components to
construct any kind of SQL use case you can dream of.
When you use jOOQ’s code generation feature, the
artifacts that are generated inherit from this family as
well. Incredibly powerful stuff.

4. org.jooq.Record

This is the parent class for representations of a row

of data from a table. This is in addition to jOOQ’s
capability to work with your custom POJOs and
Data Transfer Object (DTOs). You get the following
specializations of this class, among others:

31
Chapter 2 Getting Started with jOOQ

• org.jooq.UpdatableRecord

Compare this to a hibernate entity: it’s a live

object that remains bound to the underlying
database row for its lifetime. This way, you can
modify the refresh, modify, or delete an instance
of UpdatableRecord, and it can reflect the
change in the underlying table.

When you use jOOQ’s generated artifacts, you’ll

get classes that extend this one by default. This
applies only to tables with primary keys – without
primary keys, you’ll get a different generated
artifact. Additionally, you’ll be able to navigate to
related entities of an updatable record using its
foreign key references. Just like JPA! But better!
UpdatableRecords isn’t cached, so you can be
guaranteed you’re always working with up-to-
date, live data. It’s also easier on RAM.

• org.jooq.TableRecord

This is what you get instead of an

UpdatableRecord when the underlying table
doesn’t use a primary key. So, you won’t be able
to refresh or update parts of these records; you’ll
still be able to insert rows with this class, however.

• org.jooq.RecordMapper

Use this class for finer-grained control over the

translation of your query results. Compare this
to Spring’s RowMapper class.

32
Exploring the Variety of Random
Documents with Different Content
VII.

Pâvel Petrôwitsh sai kasvatuksensa ensin kotona, kuten nuorempikin

veli, sittemmin paashi-opistossa. Pienestä pitäin hän oli herättänyt
huomiota erinomaisella kauneudellaan. Sen ohella hän oli itseensä
luottava, hiukan ivallinen, jossain määrin hauskan ärtyisä: häneen
täytyi mieltyä. Upseeriksi päästyään hän alkoi käydä kaikkialla. Häntä
kannettiin käsillä, ja itsekin hän hemmotteli itseänsä, jopa kiekailikin,
virnaili; mutta sekin oli hänessä somaa. Naiset olivat hänestä ihan
pyörällä päin; miehet sanoivat häntä teeskentelijäksi ja kadehtivat
häntä.

Hän eli, kuten jo on mainittu, yhdessä veljensä kanssa ja rakasti

veljeänsä vilpittömästi, vaikk'ei ollut lainkaan hänen kaltaisensa.
Nikolai Petrôwitsh onnahteli hiukan, kasvonpiirteet olivat hänellä
heikot, miellyttävät, mutta hiukan surumieliset, silmät mustat,
pienet, tukka pehmeä, ohut. Mielellään hän laiskotteli, mutta
mielellään lukikin ja pelkäsi seuroja. Pâvel Petrôwitsh ei ollut yhtään
iltaa kotona, oli kuuluisa rohkeudestaan ja notkeudestaan (aikoi jo
panna alkuun voimisteluharjoituksiakin ylhäisen nuorison
keskuudessa) ja ennätti lukea kaikkiansa viisi kuusi franskalaista
kirjaa. Kahdeksannellakolmatta vuodellaan hän oli jo kapteeni;
loistava elämän-ura oli hänellä edessä. Mutta äkkiä muuttui kaikki.
 Siihen aikaan esiintyi Pietarin ylhäisissä piireissä silloin tällöin
muuan nainen, jota yhä vieläkin muistellaan, ruhtinatar P. Hänen
puolisonsa oli hienosti sivistynyt ja sievä, mutta typeränpuoleinen
mies. Lapsia heillä ei ollut. Ruhtinatar se välisti läksi aivan äkkiä
ulkomaille ja äkkiä taas palasi Venäjälle, viettäen yleensä varsin
kummallista elämää. Häntä pidettiin kevytmielisenä kokettina; hän
heittäysi kaikenlaisten huvituksien huimaan pyörteesen, tanssi
uupumukseen asti, naureskeli ja laski leikkiä nuorten miesten
kanssa, ottaen heitä vastaan puoli hämäräisessä vieraskamarissa,
mutta öisin hän itki ja rukoili, missään lepoa löytämättä. Hamaan
aamuun asti hän useinkin käveli rauhatonna huoneessaan,
tuskaisesti käsiänsä väännellen, tahi istui kalpeana ja kylmänä
psalttarin ääressä. Päivän valjettua hänestä jälleen kuontui ylhäisen
maailman nainen, ja silloin hän ajeli jälleen seurasta toiseen, nauroi
ja haastella jaaritteli, ikäänkuin pyrkien heittäymällä heittäymään
kaiken sen syliin, mikä hänelle suinkin saattoi hauskuutta tuoda.
Ihmeteltävä oli hänen olentonsa. Palmikko, kullan värinen ja
raskaskin kuin kulta, ulottui alapuolelle polven. Kauniiksi ei häntä
kumminkaan kukaan olisi sanonut: kasvoissa ei muuta kaunista
ollutkaan kuin silmät, eikä edes itse silmätkään — ne olivat
pienenpuoleiset ja harmaat — vaan niitten katse, nopea ja syvä,
huimuuteen saakka huoleton ja alakuloisuuteen asti miettiväinen, —
arvoituksen tapainen koko tuo katse. Siinä välkähteli jotain
tavattoman kirkasta silloinkin kuin kieli jokelsi aivan turhanpäiväisiä.
Puku oli hänellä aina hieno ja aistikas.

Pâvel Petrôwitsh kohtasi hänet baaleissa kerran, tanssi hänen

kanssaan masurkan, jonka aikana ruhtinatar ei virkkanut yhtään
kunnon sanaa, ja — Pâvel Petrôwitsh rakastui häneen intohimoisesti.
Tottunut hän oli voittoihin, ja pääsi tarkoituksensa perille pian
tässäkin, mutta voiton helppous ei laimentanut silti hänen intoansa.
Päinvastoin hän kiintyi entistä tuskaisemmin, entistä lujemmin
tuohon naiseen, jossa silloinkin, kun hän antautui kokonansa, oli
ikäänkuin yhä vieläkin jotain taikaperäistä, saavuttamatonta, mihin ei
kukaan päässyt tunkeutumaan. Mitä lie tuossa sielussa piillytkään, —
ties Herra, Näytti kuin hän olisi ollut jonkinlaisten salaperäisten,
hänelle itselleenkin tuntemattomain voimain vallassa. Ne leikittelivät
hänen kanssaan mielin määrin: hänen pikkuinen ymmärryksensä ei
osannut pitää puoliaan niitten oikkuja vastaan. Koko hänen
menettelynsä oli yhtämittaista epäsuhtaisuutta. Ainoat kirjeet, jotka
olisivat olleet omiansa herättämään hänen miehessään oikeutettuja
epäluuloja, hän kirjoitti sellaiselle henkilölle, jota hän tuskin
tunsikaan, mutta hänen rakkautensa oli surunsekaista: hän ei
naureskellut eikä lasketellut leikkiä sen miehen kanssa, jonka
kulloinkin oli suosikikseen valinnut, vaan kuunteli häntä,
neuvottomana tuijotellen häneen. Välisti, enimmäkseen äkkiä, tämä
neuvottomuus muuttui kylmäksi kauhuksi; hänen kasvojensa ilme oli
silloin kuollutta ja vierasta; hän sulkeutui niinä aikoina huoneesensa,
ja kamarineitsyt saattoi, pitäen korvaa avaimen reiän kohdalla, kuulla
hänen pidätettyjä nyyhkytyksiänsä.

Hellistä kohtauksista palatessaan Kirsânow tunsi sydämessään

monastikin tuota raastavaa, katkeraa harmia, joka seuraa lopullista
epäonnistumista.

— Mitäpäs minä vielä lisää tahtoisin? — kyseli hän itseltään, mutta

sydäntä vain ahdisti yhä edelleen.

Kerran hän lahjoitti ruhtinattarelle sormuksen, jonka nastakiveen

oli piirretty sfinksi.

— Mikäs tuo? — kysyi ruhtinatar. — Sfinksikö?

 — Niin on, — vastasi hän; — ja tämä sfinksi olette te.

— Minäkö? — kysäsi ruhtinatar, verkalleen kohottaen häneen tuon

selittämättömän katseensa. — Tuo on, tiedättekö, sangen
mairittelevaa, — lisäsi hän, hiukan ivallisesti myhähtäen, mutta yhä
tuijottaen häneen niin kummallisesti.

Raskaalta tuntui Pâvel Petrôwitshista silloinkin kuin ruhtinatar P.

häntä rakasti, mutta kun ruhtinattaren lempi laimeni, ja se tapahtui
jotenkin pian, silloin hän oli vähällä menettää järkensä. Hän kärsi
tuskia, oli mustasukkainen, ei antanut ruhtinattarelle rauhaa, kulki
hänen jäljissään kaikkialle. Ruhtinatar kyllästyi hänen
hellittämättömiin ahdistelemisiinsa ja matkusti ulkomaille. Pâvel
Petrôwitsh otti eron sotapalveluksesta, huolimatta toveriensa
pyynnöistä ja päällikkönsä varottelemisista, ja läksi hänen jälkeensä.

Neljän vuoden verran hän oleskeli vieraissa maissa, milloin

seuraten hänen jälkiään, milloin tahallansa kadottaen hänet
näkyvistään. Hän häpesi omaa itseänsä, moitti arkamaisuuttaan,
mutta ei apua mistään. Tuon naisen kuva, tuo käsittämätön, melkein
tympeä, mutta lumoava kuva oli liian syvälle imeytynyt hänen
sieluunsa. Badenissa hän jälleen sai uudistaneeksi entiset välit
ruhtinattaren kanssa; näytti kuin ei tämä vielä milloinkaan olisi
rakastanut häntä niin intohimoisesti … mutta kuukauden kuluttua oli
taas kaikki lopussa … tuli oli leimahtanut viimeistä kertaa ja sammui
ainaiseksi. Välttämätöntä eroa aavistellessaan, Pâvel Petrôvitsh olisi
tahtonut pysyä edes hänen ystävänänsä, ikäänkuin ystävyys
sellaisen kanssa olisi mahdollista… Ruhtinatar läksi salaa Badenista
ja kartteli häntä sen koommin lakkaamatta.

Kirsânow palasi Venäjälle, koetti ruveta elämään vanhaan

tapaansa, mutta ei voinut enää päästä entisille laduille. Huumauneen
lailla hän samoili paikasta toiseen. Seuroissa hän kävi yhä vieläkin,
entiset ylhäisen maailmanmiehen tavat hänellä oli yhä tallella,
saattoipa kerskaista parista, kolmesta uudesta voitostakin, mutta ei
hän mitään erinomaista odottanut itseltään eikä muiltakaan, eikä
ryhtynyt mihinkään toimiin. Hän vanheni, harmaantui. Hänelle kävi
nyt välttämättömäksi istua illoin klubissa, tuntea ärtymystä, olla
ikävissä, kylmäkiskoisesti kinastella naimattomien miesten seurassa,
— sangen paha merkki, niinkuin tietty on. Naimisiin menoa hän ei
tietysti ajatellutkaan.

Täten kului kymmenen vuotta, kului kukitta, hedelmittä ja

nopeaan, hirmuisen nopeaan. Ei riennä aika missään niin joutuisasti
kuin Venäjällä; vankilassa kuuluu kuluvan vieläkin nopeammin.

Klubin päivällispöydässä hän sitten kerran sai tiedon ruhtinatar P:n

kuolemasta. Hän oli kuollut Parisissa, ollen jo melkein hourupäiseksi
tulemaisillaan. Kirsânow nousi pöydästä ja käveli klubissa kauan
aikaa huoneesta huoneesen, pysähdellen kuin kivettynyt
korttipöytäin ääreen, mutta ei kumminkaan tullut kotia varhemmin
kuin ennenkään. Jonkun ajan perästä hän sai omalle nimellensä
osoitetun paketin; siinä oli sormus, jonka hän aikoinaan oli
lahjoittanut ruhtinattarelle. Vainaja oli piirtänyt sfinksin yli ristin ja
käskenyt sanoa Kirsânowille, että risti on arvoituksen selitys.

Tämä tapahtui 1848 vuoden alussa, samaan aikaan, jolloin Nikolai

Petrôwitsh, leskeksi jäätyään, käväisi Pietarissa. Pâvel Petrôwitsh ei
ollut nähnyt veljeänsä melkein siitä saakka kuin tämä oli asettunut
maalle. Nikolai Petrôwitshin häät oli vietetty juuri niinä päivinä,
jolloin Pâvel Petrôwitsh oli tutustunut ruhtinattaren kanssa.
Ulkomailta palattuaan hän läksi veljensä luokse maalle, aikoen viipyä
siellä pari kuukautta, nauttiakseen heidän onnestaan, mutta ei
kestänyt siellä kuin viikon päivät. Veljesten olot, itsekunkin, olivat
siksi kovin erilaiset. Vuonna 1848 tämä erotus ei ollut enää niin
räikeä: Nikolai Petrôwitsh oli kadottanut vaimonsa, Pâvel Petrôwitsh
oli kadottanut entiset muistonsa; ruhtinattaren kuoltua hän koetti
olla muistelematta häntä. Mutta Nikolai Petrôwitshissa oli tallella
tietoisuus säännöllisesti vietetystä elämästä, ja poikakin se kasvoi ja
varttui hänen silmissään. Pâvel sitä vastoin, yksinäinen, naimaton
mies, oli astumassa tuohon himmeään, usmaisaan aikaan, jolloin
ihmisessä elähtelee toiveitten kaltaisia surkutteluja ja surkuttelujen
kaltaisia toiveita, jolloin nuoruus on mennyt, mutta vanhuus vasta
tuloansa tekee.

Tämä aika oli Pâvel Petrôwitshille raskaampaa kuin kenellekään

muulle: kadotettuaan menneisyytensä, hän oli kadottanut kaikki.

— En minä nyt enää sinua kutsu Mârjinoon — virkkoi hänelle veli

kerran. (Hän oli näet kylänsä pannut vaimonsa nimikoksi.) — Maria
vainajankin aikana sinun tuli siellä ikävä olla, mutta nyt sinä kaiketi
siellä ihan menehtyisit ikävästä.

— Silloin minä vielä olin tyhmä ja hyörin ja pyörin sinne tänne, —

vastasi Pâvel Petrôwitsh. — Sen koommin olen talttunut, eilenhän
viisastunutkaan. Nyt minä päinvastoin olen valmis asettumaan sinun
luoksesi ainaiseksi, jos sallit.

Vastauksen asemesta Nikolai Petrôwitsh sulki hänet syliinsä, mutta

puolitoista vuotta kului vielä tästä keskustelusta, ennenkuin Pâvel
Petrôwitsh päätti panna aikeensa toimeen. Vaan sittenpä hän, kerran
maalle muutettuansa, ei sieltä enää lähtenytkään, ei edes niinäkään
talvikausina, jotka Nikolai Petrôwitsh vietti poikansa kanssa
Pietarissa. Hän rupesi lukemaan, enimmäkseen englanninkielistä
kirjallisuutta, ja asetti elämänsä muutenkin englantilaiseen malliin.
Harvoin hän seurusteli naapuriensa kanssa, ei käynyt kaupungissa
muulloin kuin aatelisvaaleissa. Sielläkin hän oli enimmäkseen ääneti,
silloin tällöin vain härnäten ja säikyttäen vanhan kuosin tilan-
omistajia vapaamielisyyden puuskauksilla ja pysyen loitolla
uudemman sukupolven edustajista.

Niin vanhan kuin nuorenkin kannan ihmiset pitivät häntä

korskeana miehenä, mutta niin toiset kuin toisetkin näkivät hänessä
paljon arvoa ansaitsevia puolia: hänellä oli niin miellyttävä,
aristokraatinen käytöstapa; hänellä oli ollut niin paljon voittoja
naismaailmassa; hän kävi varsin hienossa puvussa, asui parhaimman
hotellin parhaimmassa numerossa, yleensä söi pulskia päivällisiä,
olipa kerran ollut Wellingtonin kanssa päivällisillä Louis Filipin luona,
hänellä oli kaikkialla mukanaan täysihopeinen matka-nécessaire ja
matka-amme; hänestä tuoksusi aina tavattoman hyviltä, ihmeellisen
"jaloilta" hajuvesiltä; hän pelasi mainiosti whistiä ja joutui aina
tappiolle. Ja vihdoin pidettiin häntä arvossa hänen mallikelpoisen
rehellisyytensäkin tähden. Naisten silmissä hän oli viehättävä
melankooliko, mutta naisten tuttavuudesta hän ei välittänyt.

*****

— Katsopas nyt, Jevgêni, — virkkoi Arkâdi, päätettyään

kertomuksensa; — nyt huomaat, kuinka väärin sinä olet setää
tuominnut. En nyt puhukaan siitä, että hän on monta monituista
kertaa pelastanut isäni pulasta, antaen hänelle kaikki rahansa —
omaisuus, kuten tietänet, on heillä jakamatta, — mutta hän on
valmis auttamaan ketä hyvänsä ja muun muassa pitää aina
talonpoikain puolta, vaikka heidän kanssaan haastellessaan tosin
rypisteleekin kulmiansa ja haistelee eau-de-colognea…

— Tietty se: hermot näet… — keskeytti Bazârow.

 — Kenties, mutta hyvä on hänellä sydän. Älyä ei häneltä
myöskään puutu. Kuinka hyödyllisiä neuvoja olenkaan saanut
häneltä … vallankin … vallankin naisiin nähden.

— Ahaa! Omassa puurossa suunsa poltti ja vieraasen velliin

puhaltaa.
Kyllä minä tuon tiedän.

— Sanalla sanoen, — jatkoi Arkâdi: — hän on hyvin onneton, usko

minua; synti on halveksia häntä.

— Kukas se häntä sitten halveksii? — vastasi Bazârow. — Mutta

sen minä kumminkin sanon, että semmoinen mies, joka on pannut
koko elämänsä naisen rakkauden kortille ja sitten, nähtyään, että
toiset tuon kortin häneltä kattoivat, lyyhistyy ja raukenee siihen
määrin, ett'ei enää kykene mihinkään, — semmoinen ei ole mies,
vaan koiras. Hän on onneton muka; sen sinä mahdat parhaiten
tietää; mutta mieltä hän ei vaan ole päähänsä saanut. Minä olen
vakuutettu hänen pitävän itseänsä kunnon miehenä siitä syystä, että
lukee jotain Galjaanin pahaista ja kerran kuukaudessa pelastaa
pieksiäisistä talonpojan.

— Mutta otahan lukuun hänen kasvatuksensa ja se aika, jossa hän

on elänyt, — huomautti Arkâdi.

— Kasvatusko? — huudahti Bazârow. — Joka ihminen on

velvollinen kasvattamaan itse itseänsä, niinkuin, no vaikkapa niinkuin
esimerkiksi minä… Ja mitä taas aikaan tulee, niin miksikä minun
pitäisi olla ajasta riippuvainen? Riippukoon ennen aika minusta. Ei,
veikkonen! Kaikki tuo on semmoista löyhää, tyhjänpäiväistä! Ja mitä
ne sitten ovat nuo miehen ja naisen salaiset muka välit? Kyllä me
"fysiologit" tiedämme, mitä ne ovat. Otapas ja tutki silmän
anatomiaa: mistä ne, niinkuin sinä sanot, arvoituksen tapaiset
katseet siihen tulee? Kaikki se on romanttisuutta, hörön-töröä,
mätää, taidetta. Tule pois, mennään katsomaan koppakuoriaista.

Ja ystävykset menivät Bazârowin huoneesen. Sinne oli jo

ennättänyt asettua tuommoinen medisiini-kirurgillinen haju, johon oli
sekaantunut halvan tupakan löyhkää.
VIII.

Pâvel Petrôwitsh ei ollut kuin vähän aikaa läsnä veljen keskustellessa

voudin kanssa. Tämä vouti oli pitkä, laiha mies, ääni imelänkäheä
niinkuin keuhkotautisilla, silmissä veijarimaisuus. Kaikkiin Nikolai
Petrôwitshin huomautuksiin hän vastaili: "Ka herrainen aika, se on
vissi se", ja koetti saada talonpojat juomarin ja varkaan kirjoihin.
Äskettäin käytäntöön pantu uudenlainen maatalous se vonkui kuin
pyörä voiteen puutteessa, paukahteli kuin tuoreesta puusta kotona
tehty huonekalu. Nikolai Petrôwitsh ei tuosta mieleltään masentunut,
mutta huokaili sentään usein ja vaipui mietteisinsä: hän tunsi, että
asian onnistuminen kysyy rahoja, mutta rahat olivat häneltä melkein
lopussa.

Arkâdi oli ollut oikeassa: Pâvel Petrôwitsh oli monastikin auttanut

veljeänsä. Useinkin, nähdessään velimiehen puuhailevan ja
ponnistelevan, päätänsä särkien, mitenkä taaskin päästä pulasta,
usein Pâvel Petrôwitsh silloin astui akkunan luo ja kädet
housuntaskussa jupisi hampaittensa välitse: Mais je puis vous
donner de l'argent,[10] ja antoi hänelle rahoja. Mutta tänään ei
hänellä niitä ollut, ja senvuoksi hän katsoi parhaaksi vetäytyä pois.
Taloudelliset harmit olivat hänestä sangen ikäviä. Sitä paitsi tuntui
hänestä, että niin paljon kuin Nikolai Petrôwitsh puuhaileekaan ja
hommaa, ei hän sittenkään ota asiata siitä päästä kiinni kuin pitäisi,
vaikk'ei hän suinkaan olisi osannut nimenomaa sanoa, missä kohden
velimies milloinkin erehtyy.

"Veli ei ole tarpeeksi käytännöllinen", arveli hän itsekseen; "muut

puijaavat häntä."

Nikolai Petrôwitsh sitä vastoin piti veljeänsä erinomaisen

käytännöllisenä miehenä ja kysyi myötäänsä häneltä neuvoa.

— Minä olen tuommoinen heikko, hempeä mies, ikäni elänyt

erämaassa, — puheli hän; — mutta sinä sensijaan olet niin paljon
seurustellut ihmisten kanssa, sinä tunnet heidät; sinulla on kotkan
silmä.

Pâvel Petrôwitsh ei vastannut tuohon mitään, kääntyihän vaan

pois, koettamatta kumminkaan saada veljeänsä luopumaan moisista
luuloista.

Veljensä huoneesta tultuaan, hän läksi astumaan kartanon etu- ja

takaosan välistä käytävää myöten ja tultuaan erään matalan oven
eteen, pysähtyi miettiväisenä, kieritteli viiksiänsä ja kolkutti oveen.

— Kuka siellä? Käykää sisään! — kuului Fênitshkan ääni.

— Minä, — virkkoi Pâvel Petrôwitsh ja avasi oven.

Fênitshka kavahti pystyyn tuolilta, jossa hän oli istunut lapsi

sylissä. Annettuaan sen lapsentytölle, joka heti kohta vei sen pois,
hän pikimmältään korjasi huiviansa.

— Suokaa anteeksi, jos häiritsin, — sanoi Pâvel Petrôwitsh,

katsomatta häneen. — Minä olisin vaan pyytänyt … tänään on
luullakseni asiata kaupunkiin … pyytänyt, että käskisitte ostamaan
minulle viheriäistä teetä.

— Kyllä, — vastasi Fênitshka; — kuinka paljon suvaitsette?

— Puoli naulaa riittänee yllinkyllin… Teillähän näkyy täällä olevan

uutta — lisäsi hän, heittäen ympärilleen pikaisen silmäyksen, joka
kosketti Fênitshkankin kasvoja. — Uutimet ikkunoissa, tarkoitan, —
selitti hän, huomattuaan, ett'ei toinen häntä ymmärrä.

— Jaa, niin, uutimet kyllä. Nikolai Petrôwitsh hyvällä hyvyyttään

lahjoitti ne meille. Johan ne on olleet kauan aikaa akkunoissa.

— Kauanpa aikaa minäkin olen ollut käymättä teillä. Täällä näyttää

olevan sangen mukavaa.

— Nikolai Petrôwitshin suosiosta, — kuiskasi Fênitshka.

— Onko teidän parempi olla täällä kuin entisessä vanhassa

kylkirakennuksessa? — kysäisi Pâvel Petrôwitsh kohteliaasti, mutta
vähääkään myhähtämättä.

— Parempi on, tiettävästi.

— Kukas sinne pantiin teidän sijaanne?

— Siell'on pesijät nyt.

— Vai niin!

Pâvel Petrôwitsh vaikeni.

"Nyt se kai lähtee", arveli Fênitshka itsekseen, mutta eipä hän

lähtenytkään. Fênitshka seisoi hänen edessään kuin suolapatsas,
hiljalleen nyppien sormiaan.

— Miksikäs te käskitte viedä poikanne pois? — virkkoi Pâvel

Petrôwitsh vihdoin. — Minä olen hyvin lapsirakas; näyttäkääs se
minulle.

Fênitshka punastui; hän kävi hämille ja ihastui yhtaikaa. Hän

pelkäili Pâvel Petrôwitshia, joka tuskin koskaan oli puhellut hänen
kanssaan.

— Dunjâsha! — huusi hän, — Tuokaa Mitja tänne (Fênitshka

teititteli talossa kaikkia). — Tai malttakaa, pannaan hänelle koltti
päälle.

Fênitshka kääntyi ovea kohti.

— Samahan se on, — huomautti Pâvel Petrôwitsh.

— Minä tulen heti, — vastasi Fênitshka, lähtien kiireesti toiseen

huoneesen.

Pâvel Petrôwitsh, jäätyään yksikseen, loi erittäin tarkkaavaisen

katseen ympärilleen. Tämä pienenläntä, matala huone oli sangen
siisti ja kodikas. Siinä tuntui vereksen lattiamaalin, juhannuskukan ja
mesiruohon haju. Seinuksilla seisoi tuoleja lyyramaisine
selkämyksineen. Ne oli jo kenraali vainaja aikoinaan ostanut
Puolasta, ollessaan sotaretkellä siellä. Yhdessä nurkassa oli
musliniuutimien verhoama pieni sänky ja sen vieressä kupukantinen,
rautavanteinen arkku. Nurkassa vastapäätä sitä paloi pikkuinen
lamppu suuren pyhimyskuvan edessä, joka esitti Nikolaita
Ihmeittentekijää; sädekehästä riippui punaisessa nauhassa
pikkuruinen poslinimuna pyhimyksen rinnalla. Ikkunalaudoilla oli
viimevuotisilla marjasylteillä täytettyjä lasipurkkeja, joitten läpi
päivänvalo viheriänä kuulsi. Niitten suulle oli huolellisesti sidottu
paperipäällykset, joihin Fênitshka itse oli suurilla kirjaimilla
merkinnyt: "karviaismarja". Se oli Nikolai Petrôwitshin lempisylttiä.
Katosta riippui pitkässä nuorassa häkki, jossa lyhythäntäinen
keltasirkku myötäänsä hypiskeli tirskutellen ja pannen häkin
yhtämittaa heilumaan ja vavahtelemaan, jolloin hampun siemeniä
aina pudota pirahteli maahan. Väliseinällä, pienen piirongin
yläpuolella riippui jotenkin huonoja, kiertävän taiteilijan ottamia
valokuvia Nikolai Petrôwitshista jos millaisissakin asennoissa. Siinä
riippui Fênitshkankin kuva, kerrassaan onnistumaton: tummissa
puitteissa oli jotain kasvojen tapaista, silmiä vailla, suupielissä
ponnistettu hymy; muuta ei siinä erottanut. Fênitshkan yläpuolella
taas itse kenraali Jermôlow, huopaviitta yllään, ankaran tuimana
tuijotteli kohti Kaukaasian kaukaisia kukkuloita pienen,
kengänmuotoisen silkkisen neulatyynyn alta, joka oli painunut ihan
kenraalin otsalle asti.

Kului viiden minutin verran. Viereisestä huoneesta kuului kahinaa

ja supatusta. Pâvel Petrôwitsh otti piirongilta tahratun, hajallisen
nidoksen Masáljskin Stréltseja ja selaili sitä hiukan… Ovi aukeni, ja
sisään astui Fênitshka Mitja sylissä. Hän oli pukenut pojan päälle
punaisen paidan, jonka kauluksessa oli kiiltonauhainen reunus,
kammannut pojan pään ja pessyt silmät. Poika hengitti lujasti,
kurotteli ruumistaan ja nytkäytteli käsiään, niinkuin terveitten lasten
on tapa, mutta uhkea paita se nähtävästikin teki tehtävänsä:
tyytyväisyyden ilme heijasti koko hänen pulleasta olennostaan.
Fênitshka oli laittanut omankin tukkansa järjestykseen ja sitaissut
päähänsä paremman huivin, mutta hän olisi huoleti saattanut jäädä
entiseen asuunsa. Ja todellakin, oliko maailmassa mitään sen
viehättävämpää kuin nuori äiti, terve lapsi sylissään?
 — Kas tuota pallukkaa, — virkkoi Pâvel Petrôwitsh, kutkuttaen
Mitjaa kaksoisleuasta etusormensa pitkän kynnen päällä. Poikanen
kiinnitti katseensa keltasirkkuun ja rupesi nauramaan.

— Setä se on, — virkkoi Fênitshka, painaen kasvojansa lasta

vasten ja hiljalleen puistellen häntä, Dunjâshan asetellessa ikkunalle
savupyperöä vaskirahan päälle.

— Kuinkas vanha hän onkaan? — kysäsi Pâvel Petrôwitsh.

— Kuusi kuukautta, pian kääntyy seitsemännelle, yhdentenätoista

päivänä ensi kuuta.

— Eiköhän kahdeksannelle jo, Feodôsia Nikolâjewna? — virkkoi

Dunjâsha hiukan arkaillen.

— Eihän toki! Seitsemännelle. Mitäs sinä nyt! — Lapsi rupesi taas

nauramaan, käänsi sitten huomionsa arkkuun ja tarttui äkkiä koko
kourallaan äitiään nenään ja huuliin. — Vallaton veitikka! — puheli
Fênitshka, vetämättä kasvojaan pois pojan kourasta.

— Hän on veljeni näköinen, — huomautti Pâvel Petrôwitsh.

"Kenenkäpäs se olisikaan näköinen?", ajatteli Fênitshka.

— Niin, niin, — puheli Pâvel Petrôwitsh ikäänkuin itsekseen; —

ihan velimiehen näköinen.

Hän loi Fênitshkaan tarkan, melkein murheellisen katseen.

— Setä se on, — virkkoi Fênitshka, nyt jo kuiskaamalla.

— Kas, Pâvel! Täälläkös sinä oletkin? — kuului äkkiä Nikolai

Petrôwitshin ääni.
 Pâvel Petrôwitsh kääntyi kiireesti ympärinsä, kulmiaan rypistäen,
mutta veli katsahti häneen niin iloisasti, niin kiitollisena, että toisen
täytyi väkisinkin myhähtää hänelle.

— Sinullahan on koko pulska poika, — sanoi hän, kelloonsa

katsahtaen. — Minä poikkesin tänne puhumaan teestä…

Ja sen sanottuaan Pâvel Petrôwitsh läksi pois, varsin levollinen

ilme kasvoissa.

— Itsestäänkö hän tuli? — kysäisi Nikolai Petrôwitsh Fênitshkalta.

— Itsestään tulivat; oveen kopauttivat ja tulivat sisään.

— Entäs Arkâsha? Eikö hän ole enää käynyt sinun luonasi?

— Eivät ole. Enköhän minä muuta tuonne kylkirakennukseen,

Nikolai
Petrôwitsh?

— Miksi niin?

— Eiköhän se olisi parasta ensi aluksi?

— Nnno … eipä sentään, — äännähti Nikolai Petrôwitsh, änkytellen

ja otsaansa hieraisten. — Kun olisi ennen… No terve, sinä mötys, —
virkkoi hän sitten, äkkiä vilkastuen, lähestyi lasta ja suuteli häntä
poskeen. Senjälkeen hän, kumartui hiukan ja kosketti huulillaan
Fênitshkan kättä, joka kuulsi valkoisena kuin maito Mitjan punaisen
paidan päällä.

— Nikolai Petrôwitsh! Mitäs te nyt? — sopotti Fênitshka, laskien

silmänsä maahan, mutta kohottaen ne jälleen ylös… Soma oli hänen
silmäinsä välke, hänen katsellessaan kulmainsa alta ja naurahdellen
lempeästi ja hiukan typerästi.

*****

Nikolai Petrôwitsh oli tutustunut Fênitshkaan seuraavalla tavalla.

Kerran, noin kolme vuotta sitten, hän oli matkoillaan yöpynyt

majataloon eräässä kaukaisessa maaseutukaupungissa.
Odottamattoman mielihyvän teki hänelle erinomainen järjestys siinä
huoneessa, minkä oli saanut, ja sänkyvaatteiden puhtaus.
"Saksalainenkohan täällä lieneekin emäntä?" iski hänen mieleensä.
Mutta emäntänä olikin venakko, noin viidenkymmenen vanha vaimo,
siistissä puvussa, kasvot somat ja puhe arvokasta. Nikolai Petrôwitsh
puuttui pakinoille hänen kanssaan, teetä juodessaan, ja varsin hyvän
vaikutuksen häneen emäntä tekikin.

Nikolai Petrôwitsh oli siihen aikaan vast'ikään muuttanut uuteen

maakartanoonsa, jossa ei tahtonut pitää äärellään maaorjia, vaan
haeskeli palkkaväkeä. Emäntä puolestaan valitteli matkustajain
vähyyttä ja kallista aikaa. Nikolai Petrôwitsh tarjosi hänelle silloin
emännöitsijän paikan hovissaan, ja toinen suostuikin. Hänen
miehensä oli kuollut jo kauan sitten, jätettyään äidin huostaan
ainoan tyttären, Fênitshkan.

Parin viikon kuluttua Arina Sâvishna (se oli uuden emännöitsijän

nimi) muuttikin tyttärineen Mârjinoon ja asettui asumaan
kylkirakennukseen. Nikolai Petrôwitsh näytti osanneen oikeaan. Arina
pani talon hyvään järjestykseen. Fênitshkasta, joka silloin jo oli
täyttänyt seitsemäntoista vuotta, ei puhunut talossa kukaan, eikä
häntä kukaan nähnytkään, hän kun eleli hiljalleen ja yksikseen.
Sunnuntaisin vain Nikolai Petrôwitsh huomasi pitäjän kirkossa,
jossain syrjäisessä paikassa, hänen vaikeitten kasvojensa profilin.

Näin kului toista vuotta.

Aamulla kerran Arina tuli isäntänsä huoneesen ja, tehtyään

tavanmukaisen syvän kumarruksen, kysyi, eikö hän voisi auttaa
hänen tytärtään, jolle kipinä uunista oli lentänyt silmään. Nikolai
Petrôwitsh, niinkuin muutkin kotona-kykkijät, harjoitti tautien
parantelemista; olipa hankkinut taloonsa homeopaatillisen
apteekinkin. Hän käski Arinan tuoda sairaan heti sisään. Fênitshka,
kuultuaan herran kutsuvan häntä luokseen, säikähti
pahanpäiväiseksi, mutta seurasi sentään äitiänsä. Vietyään hänet
akkunan eteen, Nikolai Petrôwitsh otti häntä molemmin käsin päästä,
tutki tarkoin tuon punaisen, tulehtuneen silmän ja valmisti hänelle
samassa omin käsin haudevettä, repäsi sitten nenäliinansa ja neuvoi,
mitenkä hautoa. Fênitshka kuunteli häntä loppuun asti ja aikoi lähteä
tiehensä.

— Suutele toki herran kättä, tyttö riepu! — sanoi Alina hänelle.

Mutta Nikolai Petrôwitsh ei sallinut hänen suudella kättä, vaan

joutui hämille itsekin ja suuteli tyttöä kumartuneesen päähän
jakauksen kohdalle.

Fênitshkan silmä parani pian, mutta se vaikutus, minkä hän oli

isäntäänsä tehnyt, ei hälvennyt niinkään pian. Yhä vain Nikolai
Petrôwitshin silmissä kuvastuivat nuo puhtaat, hennot, arasti
kohotetut kasvot; hän tunsi kämmeniensä koskettelevan tuota
pehmeätä tukkaa, näki nuo viattomat, puoleksi avonaiset huulet,
joitten välitse helmimäiset hampaat kosteina väikähtelivät
päivänvalossa. Hän rupesi entistä tarkkaavammin katselemaan häntä
kirkossa ja koetti päästä puheisin hänen kanssaan.

Fênitshka vierasti häntä ensi alussa. Niinpä kerrankin, kun Nikolai

Petrôwitsh kohtasi hänet kapealla, tuuhean ruispellon kautta
kulkevalla polulla, hän puikahti piiloon korkeakortiseen, sankkaan
peltoon, jossa rukiinen juurella kasvoi tiheässä ruiskukkia ja
koiruohoa. Nikolai Petrôwitsh huomasi hänen päänsä kortten
kultaisen verkon lävitse, josta hän katsella kurkisteli kuin pikku eläin.

— Hyvää iltaa, Fênitshka! — huusi hän tytölle lempeällä äänellä. —

En minä pure.

— Jumal' antakoon! — kuiskasi toinen, tyyssijaansa jättämättä.

Vähitellen hän alkoi tottua Nikolai Petrôwitshiin, vaikka yhä

vieläkin pelkäili hänen läsnäollessaan, kunnes Arina, hänen äitinsä,
äkkiä kuoli koleraan. Minnekä oli tyttö nyt joutuva? Hän oli perinyt
äidiltään rakkauden järjestykseen, järkevyyteen ja arvokkaisuuteen,
mutta olihan hän vielä niin nuori, niin yksinäinen. Nikolai Petrôwitsh
itse oli niin hyväntahtoinen, siivo…

Tarpeetonta on kertomusta enää jatkaa…

— Vai tuli se veli noin vaan? — tiedusteli Nikolai Petrôwitsh. —

Oveen kolkutti ja astui sisään?

— Niin.

— No se on hyvä se. Annas kun hypittelen Mitjaa. Ja Nikolai

Petrôwitsh rupesi hypittelemään poikaa melkein lakeen saakka. Kovin
oli pienonen itse siitä hyvillään, mutta levoton oli äiti. Joka kerta kuin
poikanen lennähti ylös, joka kerta hän ojensi kätensä lapsen
paljastuneita jalkoja kohti.

Mutta Pâvel Petrôwitsh palasi uhkeaan kabinettiinsa. Seinillä oli

sirot, omituisen väriset tapetit, kirjavalla persialaisella matolla riippui
ampuma-aseita; huonekalut olivat pähkinäpuusta, tummanvehreällä
shaggilla päällystetyt; kirjakaappi oli vanhaa tammea, renaissance-
stiiliä, komealla kirjoituspöydällä seisoi pieniä pronssisia statuetteja;
nurkassa kamini-uuni. Hän heittäysi seljälleen sohvalle, pani kätensä
niskan taa ja katseli liikahtamatta, melkein epätoivoisena kattoon.
Lieneekö hän sitten tahtonut itse seiniltäkin kätkeä, mitä hänen
kasvoillansa ilmenee, vai mikä lienee ollut syynä, mutta hän nousi,
veti raskaat uutimet akkunain eteen ja heittäytyi sohvalle jälleen.
IX.

Samana päivänä Bazârowkin tutustui Fênitshkaan. Bazârow oli

Arkâdin kanssa kävelyllä puutarhassa, selitellen ystävälleen, miksikä
eivät kaikki puut ole ottaneet juurtuakseen, varsinkaan pienet
tammet.

— Tänne pitäisi istuttaa enemmän hopeapoppeleita ja kuusia,

vaikkapa lehmuksiakin, ja panna ruokamultaa lisää. Tuo lehtimaja,
katsos, se on menestynyt hyvin — lisäsi hän — sillä akaasia ja syreni
ne ovat kelpo poikia ne, eivät kysy hoitoa. Mutta … siellähän on
joku! Lehtimajassa istui Fênitshka Dunjâshan ja Mitjan kanssa.
Bazârow pysähtyi, mutta Arkâdi nyökäytti Fênitshkalle päätä,
niinkuin vanha tuttava ainakin.

— Kuka se on? — kysyi Bazârow, heti kuin oli kuljettu lehtimajan

ohi. — Soma naikkonen!

— Kumpaisestako sinä puhut?

— Tietty se, kestä; yksihän siellä oli soma.

Aina väliin hämilleen joutuen Arkâdi kertoi hänelle lyhyesti, ken

Fênitshka on.
 — Ahaa — virkkoi Bazârow. — Näkyypä sinun isäsi tietävän, mikä
on vettä mikä mettä. Hän on reipas poika kerrassaan, tuo sinun
isäsi; hän miellyttää minua, miellyttää totta maar niinkin. Mutta
pitäähän sitä tutustua, — lisäsi hän, kääntyen lehtimajalle päin.

— Jevgêni! — huudahti säikähtäneenä Arkâdi hänen jälkeensä. —

Ole,
Herran tähden varovainen!

— Ole huoleti, — vastasi Bazârow, — me ollaan monessa liemessä

keitettyä väkeä; ei sitä niinkään pelkkiä maamoukkia olla.

Fênitshkaa lähestyessään hän otti lakin päästään.

— Sallikaa minun esitellä itseni, — alkoi hän, kumartaen

kohteliaasti. — Arkâdi Nikolâitshin ystävä ja vallan sävyisä mies.

Fênitshka nousi seisomaan ja katseli häntä arasti.

— Tuopas on kerrassaan sievä lapsi, — jatkoi Bazârow. — Olkaa

huoleti, ei mull' ole silmät noidan silmät. Miksikäs sillä posket noin
hehkuu? Hampaitako saa?

— Niin, — vastasi Fênitshka, — neljä on jo puhjennut, ja nyt on

ikenet taas pöhössä.

— Näyttäkääs … älkää peljätkö; minä olen tohtori. Bazârow otti

lapsen syliinsä, ja kovin kummastelivat niin Fênitshka kuin
Dunjâshakin, ett'ei poika pyristellyt vastaan eikä ensinkään
vierastanut.

— Jaha, jaha… Kaikki on niinkuin olla pitää: poika saa uhkeat

hampaat. Jos mitä joskus sattuu, pankaa sana minulle. Oletteko te
itse terve?

— Terve olen, Jumalan kiitos.

— Jumalan kiitos; sehän onkin paras kaikista. Entäs te? — lisäsi

Bazârow, kääntyen Dunjâshaan.

Dunjâsha, tyttönen tuikea tuvassa ja rasavilli tanhualla, tirskautti

vaan, eikä vastannut mitään.

— No niin. Tuoss'on pulska prinssinne. Fênitshka otti pojan

syliinsä.

— Että hän viihtyi teillä niin hyvin! — virkkoi hän puoliääneen.

— Minulla viihtyy lapset aina, — vastasi Bazârow; mull' on

tiedossani taika semmoinen.

— Lapset tuntee kyllä, kuka heitä rakastaa, — huomautti

Dunjâsha.

— Se on vissi se, — vahvisti Fênitshka. — Niinkuin Mitjakin: välisti

ei menisi vieraan syliin, ei vaikka.

— Entäs minun? — kysäsi Arkâdi, joka oli seisonut kotvan aikaa

taampana ja nyt läheni lehtimajaa.

Hän kurotti kätensä Mitjaa kohti, mutta poikanen kääntyi pois ja

rupesi uikuttamaan. Fênitshka joutui hämille.

— Kylläpähän tulee vielä, jahka tottuu, — virkkoi Arkâdi suopeasti.

Ystävykset läksivät lehtimajasta.

 — Mikä hänen nimensä olikaan? — kysyi Bazârow.

— Fênitshka … Feodôsia.

— Entäs isännimeltä? Pitäähän se tietää sekin.

— Nikolâjewna.

— Bene. Minua miellyttää hänessä se, ett'ei hän kainostele liiaksi.

Toinen kukaties juuri moittisi häntä siitä. Joutavia! Mitäs siinä olisi
kainostelemista? Hän on äiti, ja niinmuodoin hän on oikeassa.

— Hän on kyllä oikeassa, — virkkoi Arkâdi, — mutta isä…

— Isä on oikeassa kanssa, — keskeytti Bazârow.

— Ei minun mielestäni.

— Niin, niin: yksi perillinen lisää, se nähkääs harmittaa meitä

hiukan.

— Ettes häpeä, luullessasi minun ajattelevan tuollaista! —

huudahti Arkâdi kiivaasti. — En minä siltä kannalta katso isän olevan
väärässä; isän pitäisi minun mielestäni naida hänet.

— Vai niin, vai niin! — virkkoi Bazârow tyynesti. — Kas kuinka me

ollaankaan jalomielisiä! Sinun mielestäsi siis avioliitolla on vielä jotain
merkitystä. Sitä en olisi sinulta odottanut.

Ystävykset astuivat muutamia askeleita ääneti.

— Minä olen nähnyt kaikki sinun isäsi laitokset, — puheli taas

Bazârov. — Karja on kehnoa ja hevoset työllä tapetuita. Rakennukset
ne hiukan rasahtelevat nekin, työväki on laiskaa ja vetelää, mutta
vouti se on joko tomppeli tai veijari, en ole vielä päässyt perille,
kumpaako.

— Kovinhan sinä olet ankara tänään, Jevgêni Vasíljitsh.

— Ja kunnonkin talonpojat ne vielä saavat isäsi puijatuksi, usko

pois. Ilmankos sananlasku sanoo: "Venäläinen musikka pistää
Jumalankin poskeensa."

— Minä alan olla yhtä mieltä sedän kanssa, — virkkoi Arkâdi: —

sinulla on kerrassaan huono ajatus venäläisistä.

— Jopa sitten jotain! Ei venäläisessä muuta hyvää olekaan kuin se,

että hänellä on peräti huono ajatus itsestään. Kaks kertaa kaks on
neljä — se se jotain on; muu kaikki on hölynpölyä.

— Luontokin? — virkkoi Arkâdi, miettiväisenä katsellen tuonne

kauas yli moniväristen peltojen, joihin mailleen jo kallistuva aurinko
loi kaunista, lempeätä valoa.

— Ja hölynpölyä se on luontokin, siinä merkityksessä, jossa sinä

sitä käsität. Ei luonto ole mikään temppeli; paja se on ja ihminen
seppänä siinä.

Samassa kuului kartanosta viivähteleviä violoncellon säveleitä.

Joku siellä soitti tunteellisesti, vaikka epävarmalla kädellä, Schubertin
Träumereitä, ja hunajana hajaantui ilmassa suloinen melodia.

— Mitäs tuo on? — kysyi Bazârow kummastellen.

— Isä soittaa.

— Soittaako sinun isäsi celloa?

 — Kyllä.

— Mutta kuinka vanha hän on?

— Neljäkymmentä neljä. Bazârow räjähti nauramaan.

— Mitäs sinä naurat?

— No mutta, hyvä ystävä! Mies viidennellä viidettä, pater familias,

asuu täällä maan sydänmaassa ja — soittaa celloa!

Bazârow nauraa hohotti edelleen, mutta Arkâdi, niin syvästi kuin

kunnioittakaan mestariansa, ei tällä kertaa edes myhähtänytkään.
X.

Kului pari viikkoa. Elämä Mârjinossa kulki kulkuansa: Arkâdi vietti

makean leivän päiviä, Bazârow teki työtä. Talossa olivat jo kaikki
ennättäneet tottua häneen, hänen leväperäiseen menettelytapaansa,
hänen jyrkkäpuheisuuteensa. Fênitshka varsinkin oli jo niin
tutustunut häneen, että yöllä kerran käski herättää hänet: Mitja oli
saanut suonenvetoja. Ja Bazârow tuli, tapansa mukaan, puoleksi
leikkiä laskien, puoleksi haukotellen, istui hänen luonaan parisen
tuntia ja sai lapsen entiselleen.

Pâvel Petrôwitsh sitä vastoin oli ruvennut vihaamaan häntä koko

sydämensä pohjasta, pitäen häntä röyhkeänä, öykkärinä, kyynillisenä
miehenä, plebeijinä. Hän aavisteli, ett'ei Bazârow pidä häntä
arvossa, melkeinpä halveksii häntä, — häntä, Pâvel Kirsânowia!

Nikolai Petrôwitsh pelkäili hiukan tätä nuorta "nihilistiä", epäillen,

tokko hänen vaikutuksensa Arkâdiin lienee hyvinkään edullista,
mutta mielellään hän kuunteli Bazârowia, mielellään oli läsnä hänen
fyysillis-kemiallisissa kokeissaan. Bazârow oli tuonut mikroskopin
mukanaan ja hääräili tuntimäärin sen ääressä.
 Palvelijat olivat hekin kiintyneet häneen, vaikka hän usein teki
heistä pilkkaakin. He tunsivat, että siinä se on sentään meikäläinen
mies eikä herra. Dunjâsha se mielellään nauraa hihitteli hänen
kanssaan, ja heitti häneen vihjaavia silmäyksiä, juosta
puikahdellessaan hänen ohitsensa. Pjotr, mies peräti itserakas ja
typerä, otsa alati rypyssä, mies, jonka ainoa ansio oli siinä, että osasi
katsoa ihmisiä kohteliaasti silmiin ja sai tavaamalla kirjasta selvän ja
usein harjaili tukkaansa, — hänkin rupesi myhähtelemään ja
kirkastui kasvoiltaan, milloin vain Bazârow kiinnitti häneen huomiota.
Palvelusväen pojat ne juoksentelivat "tohtorismiehen" perässä kuin
pienet koirat. Ukko Prokôfjitsh se vain ei sietänyt häntä. Tuiman
näköisenä hän pöydässä passaili tuota "sammakonnylkijää" ja
"lipilaaria", ja vakuutti, että tuo partaniekka roikale on — sika
kaalismaassa. Prokôfjitsh oli tavallaan yhtä hyvä aristokraati kuin
Pâvel Petrôwitshkin.

Tuli vuoden herttaisin aika, kesäkuun ensimmäiset päivät. Säät

olivat ihanat. Kansaa uhkasi kyllä jälleen kolera, mutta X:n läänin
asukkaat olivat jo tottuneet näkemään sitä vieraanansa. Bazârowin
oli tapana nousta aamulla hyvin aikaisin ja lähteä astumaan parin
kolmen virstan päähän, ei kävelemään — kävely ilman mitään
tarkoitusta oli hänestä peräti vastenmielistä, — vaan keräämään
kasveja ja hyönteisiä. Väliin hän otti mukaansa Arkâdinkin.
Paluumatkalla he tavallisesti joutuivat väittelyyn, jossa Arkâdi
useimmiten jäi alle kynsin, vaikka pitikin enemmän ääntä kuin
toinen.

Kerran he olivat viipyneet tavallista kauemmin. Nikolai Petrôwitsh

läksi heitä vastaan puutarhaan. Tultuansa lehtimajan kohdalle hän
kuuli äkkiä nopeita askelia, ja odottelemiensa nuorten miesten
puhetta. He kulkivat lehtimajan toiselta puolen eivätkä voineet nähdä
häntä.

— Sin'et tunne isää tarpeeksi, — kuului Arkâdi sanovan.

Nikolai Petrôwitsh painautui piiloon.

— Sinun isäsi on kelpo poika, — virkkoi Bazârow; — mutta hän on

jo virkaheitto; hänen laulunsa on laulettu loppuun.

"Virkaheitto" seisoi paikallaan minutin, vieläpä toisenkin, ja läksi

sitten verkalleen astua laahustamaan kotia.

— Toissapäivänä, — jatkoi Bazârow, — toissapäivänä minä tapasin

hänet lukemasta Púshkinia. Selitä toki hänelle, ett'eihän
semmoisesta ole mihinkään. Eihän hän enää mikään poika ole;
heittäis jo mokomankin höröntörön. Olla romantikona nykyaikoina …
että hän viitsii! Anna hänelle jotain kunnollisempaa luettavaksi.

— Mitähän hänelle antaisi? — kysyi Arkâdi.

— Vaikkapa ensi hätään Büchnerin "Stoff und Kraft". — Niinpä

niinkin, — vastasi Arkâdi hyväksyvästi. — "Stoff und Kraft" on
kirjoitettu kansantajuisesti…

*****

— Ja niinpä, näetkös meistä, sinusta ja minusta, — puheli samana

päivänä iltapuoleen Nikolai Petrôwitsh veljelleen, istuen hänen
kabinetissansa, — meistä tuli kuin tulikin virkaheitot, ja laulettu se
on loppuun meidän laulummekin: No niin. Oikeassa kenties Bazârow
onkin. Mutta yksi asia minusta sentään tuntuu katkeralta: minä
toivoin näet, että nythän minä pääsen oikein sydämellisen
ystävyyden kannalle Arkâdin kanssa, mutta näyttääkin siltä, että
minä olen jäänyt jälkeen ja hän mennyt eteenpäin; emme me enää
voi ymmärtää toisiamme.

— Milläs tavoin hän sitten on mennyt eteenpäin? Ja missäs hän on

niin paljoa etevämpi meitä? — huudahti Pâvel Petrôwitsh
maltittomasti. — Sen kaiken on hänelle ajanut päähän tuo signor,
tuo nihilisti. Min'en voi sietää tuota puoskaria; hän on minun
mielestäni ilmeinen charlataani; minä olen varma siitä, ett'ei hän
kaikkine sammakoineenkaan ole kovin pitkällä luonnontieteissä.

— Älä, veikkonen, sano niin; Bazârow on älykäs mies, ja tietoja on

hänellä paljon.

— Ja niin inhottavan itserakas, — keskeytti jälleen Pâvel

Petrôwitsh.

— Totta kyllä, — virkkoi Nikolai Petrôwitsh, — itserakas hän on,

mutta eipä sitä vailla näy saattavan olla. Yksi asia kumminkin on,
jota en saa päähäni. Minähän luullakseni teen kaikki, jott'en jäisi
ajastani jälkeen: olen järjestänyt alustalaisteni olot, olen pannut
kuntoon farmin, niin että minua jo yli koko läänin sanotaan
punaiseksi; minä luen, hankin tietoja, koetan ylipäänsä päästä
tasakannalle nykyaikaisten vaatimusten kanssa, — mutta nyt minulle
sanotaan, että minun lauluni on laulettu loppuun. Alanpa, veli hyvä,
itsekin jo olla sitä mieltä, että eiköhän jo lienekin tuo laulu loppuun
laulettu.

— Kuinka niin?

— Niinpä niin. Tänään esimerkiksi olin lukemassa Púshkinia.

"Mustalaiset" muistaakseni sattui siinä eteeni… Äkkiä astuu Arkâdi